text: # coding=utf-8
  # *** WARNING: this file was generated by the Pulumi SDK Generator. ***
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
  
  import warnings
  import pulumi
  import pulumi.runtime
  from typing import Any, Mapping, Optional, Sequence, Union
  from ... import _utilities, _tables
  from ._enums import *
  
  __all__ = [
      'AddressSpaceArgs',
      'ApplicationGatewayAuthenticationCertificateArgs',
      'ApplicationGatewayAutoscaleConfigurationArgs',
      'ApplicationGatewayBackendAddressArgs',
      'ApplicationGatewayBackendAddressPoolArgs',
      'ApplicationGatewayBackendHttpSettingsArgs',
      'ApplicationGatewayConnectionDrainingArgs',
      'ApplicationGatewayCustomErrorArgs',
      'ApplicationGatewayFirewallDisabledRuleGroupArgs',
      'ApplicationGatewayFirewallExclusionArgs',
      'ApplicationGatewayFrontendIPConfigurationArgs',
      'ApplicationGatewayFrontendPortArgs',
      'ApplicationGatewayHeaderConfigurationArgs',
      'ApplicationGatewayHttpListenerArgs',
      'ApplicationGatewayIPConfigurationArgs',
      'ApplicationGatewayPathRuleArgs',
      'ApplicationGatewayProbeArgs',
      'ApplicationGatewayProbeHealthResponseMatchArgs',
      'ApplicationGatewayRedirectConfigurationArgs',
      'ApplicationGatewayRequestRoutingRuleArgs',
      'ApplicationGatewayRewriteRuleArgs',
      'ApplicationGatewayRewriteRuleActionSetArgs',
      'ApplicationGatewayRewriteRuleSetArgs',
      'ApplicationGatewaySkuArgs',
      'ApplicationGatewaySslCertificateArgs',
      'ApplicationGatewaySslPolicyArgs',
      'ApplicationGatewayTrustedRootCertificateArgs',
      'ApplicationGatewayUrlPathMapArgs',
      'ApplicationGatewayWebApplicationFirewallConfigurationArgs',
      'ApplicationSecurityGroupArgs',
      'AzureFirewallApplicationRuleArgs',
      'AzureFirewallApplicationRuleCollectionArgs',
      'AzureFirewallApplicationRuleProtocolArgs',
      'AzureFirewallIPConfigurationArgs',
      'AzureFirewallNatRCActionArgs',
      'AzureFirewallNatRuleArgs',
      'AzureFirewallNatRuleCollectionArgs',
      'AzureFirewallNetworkRuleArgs',
      'AzureFirewallNetworkRuleCollectionArgs',
      'AzureFirewallRCActionArgs',
      'BackendAddressPoolArgs',
      'BgpSettingsArgs',
      'ConnectionMonitorDestinationArgs',
      'ConnectionMonitorSourceArgs',
      'ContainerArgs',
      'ContainerNetworkInterfaceArgs',
      'ContainerNetworkInterfaceConfigurationArgs',
      'ContainerNetworkInterfaceIpConfigurationArgs',
      'DdosSettingsArgs',
      'DelegationArgs',
      'DevicePropertiesArgs',
      'DhcpOptionsArgs',
      'EndpointServiceArgs',
      'ExpressRouteCircuitAuthorizationArgs',
      'ExpressRouteCircuitConnectionArgs',
      'ExpressRouteCircuitPeeringArgs',
      'ExpressRouteCircuitPeeringConfigArgs',
      'ExpressRouteCircuitPeeringIdArgs',
      'ExpressRouteCircuitServiceProviderPropertiesArgs',
      'ExpressRouteCircuitSkuArgs',
      'ExpressRouteCircuitStatsArgs',
      'ExpressRouteGatewayPropertiesAutoScaleConfigurationArgs',
      'ExpressRouteGatewayPropertiesBoundsArgs',
      'ExpressRouteLinkArgs',
      'FrontendIPConfigurationArgs',
      'HubVirtualNetworkConnectionArgs',
      'IPConfigurationProfileArgs',
      'InboundNatPoolArgs',
      'InboundNatRuleArgs',
      'IpTagArgs',
      'IpsecPolicyArgs',
      'Ipv6ExpressRouteCircuitPeeringConfigArgs',
      'LoadBalancerSkuArgs',
      'LoadBalancingRuleArgs',
      'LocalNetworkGatewayArgs',
      'ManagedServiceIdentityArgs',
      'NetworkInterfaceDnsSettingsArgs',
      'NetworkInterfaceIPConfigurationArgs',
      'NetworkInterfaceTapConfigurationArgs',
      'NetworkSecurityGroupArgs',
      'OutboundRuleArgs',
      'P2SVpnServerConfigRadiusClientRootCertificateArgs',
      'P2SVpnServerConfigRadiusServerRootCertificateArgs',
      'P2SVpnServerConfigVpnClientRevokedCertificateArgs',
      'P2SVpnServerConfigVpnClientRootCertificateArgs',
      'P2SVpnServerConfigurationArgs',
      'PacketCaptureFilterArgs',
      'PacketCaptureStorageLocationArgs',
      'ProbeArgs',
      'ProtocolCustomSettingsFormatArgs',
      'PublicIPAddressArgs',
      'PublicIPAddressDnsSettingsArgs',
      'PublicIPAddressSkuArgs',
      'PublicIPPrefixSkuArgs',
      'ReferencedPublicIpAddressArgs',
      'ResourceNavigationLinkArgs',
      'RouteArgs',
      'RouteFilterArgs',
      'RouteFilterRuleArgs',
      'RouteTableArgs',
      'SecurityRuleArgs',
      'ServiceAssociationLinkArgs',
      'ServiceEndpointPolicyArgs',
      'ServiceEndpointPolicyDefinitionArgs',
      'ServiceEndpointPropertiesFormatArgs',
      'SubResourceArgs',
      'SubnetArgs',
      'VirtualHubIdArgs',
      'VirtualHubRouteArgs',
      'VirtualHubRouteTableArgs',
      'VirtualNetworkGatewayArgs',
      'VirtualNetworkGatewayIPConfigurationArgs',
      'VirtualNetworkGatewaySkuArgs',
      'VirtualNetworkPeeringArgs',
      'VirtualNetworkTapArgs',
      'VpnClientConfigurationArgs',
      'VpnClientRevokedCertificateArgs',
      'VpnClientRootCertificateArgs',
      'VpnConnectionArgs',
  ]
  
  @pulumi.input_type
  class AddressSpaceArgs:
      def __init__(__self__, *,
                   address_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          AddressSpace contains an array of IP address ranges that can be used by subnets of the virtual network.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] address_prefixes: A list of address blocks reserved for this virtual network in CIDR notation.
          """
          if address_prefixes is not None:
              pulumi.set(__self__, "address_prefixes", address_prefixes)
  
      @property
      @pulumi.getter(name="addressPrefixes")
      def address_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          A list of address blocks reserved for this virtual network in CIDR notation.
          """
          return pulumi.get(self, "address_prefixes")
  
      @address_prefixes.setter
      def address_prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "address_prefixes", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayAuthenticationCertificateArgs:
      def __init__(__self__, *,
                   data: Optional[pulumi.Input[str]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          Authentication certificates of an application gateway.
          :param pulumi.Input[str] data: Certificate public data.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Name of the authentication certificate that is unique within an Application Gateway.
          :param pulumi.Input[str] provisioning_state: Provisioning state of the authentication certificate resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input[str] type: Type of the resource.
          """
          if data is not None:
              pulumi.set(__self__, "data", data)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def data(self) -> Optional[pulumi.Input[str]]:
          """
          Certificate public data.
          """
          return pulumi.get(self, "data")
  
      @data.setter
      def data(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "data", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the authentication certificate that is unique within an Application Gateway.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Provisioning state of the authentication certificate resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the resource.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayAutoscaleConfigurationArgs:
      def __init__(__self__, *,
                   min_capacity: pulumi.Input[int],
                   max_capacity: Optional[pulumi.Input[int]] = None):
          """
          Application Gateway autoscale configuration.
          :param pulumi.Input[int] min_capacity: Lower bound on number of Application Gateway capacity
          :param pulumi.Input[int] max_capacity: Upper bound on number of Application Gateway capacity
          """
          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) -> pulumi.Input[int]:
          """
          Lower bound on number of Application Gateway capacity
          """
          return pulumi.get(self, "min_capacity")
  
      @min_capacity.setter
      def min_capacity(self, value: pulumi.Input[int]):
          pulumi.set(self, "min_capacity", value)
  
      @property
      @pulumi.getter(name="maxCapacity")
      def max_capacity(self) -> Optional[pulumi.Input[int]]:
          """
          Upper bound on number of Application Gateway capacity
          """
          return pulumi.get(self, "max_capacity")
  
      @max_capacity.setter
      def max_capacity(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_capacity", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayBackendAddressArgs:
      def __init__(__self__, *,
                   fqdn: Optional[pulumi.Input[str]] = None,
                   ip_address: Optional[pulumi.Input[str]] = None):
          """
          Backend address of an application gateway.
          :param pulumi.Input[str] fqdn: Fully qualified domain name (FQDN).
          :param pulumi.Input[str] ip_address: IP address
          """
          if fqdn is not None:
              pulumi.set(__self__, "fqdn", fqdn)
          if ip_address is not None:
              pulumi.set(__self__, "ip_address", ip_address)
  
      @property
      @pulumi.getter
      def fqdn(self) -> Optional[pulumi.Input[str]]:
          """
          Fully qualified domain name (FQDN).
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "fqdn", value)
  
      @property
      @pulumi.getter(name="ipAddress")
      def ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          IP address
          """
          return pulumi.get(self, "ip_address")
  
      @ip_address.setter
      def ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "ip_address", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayBackendAddressPoolArgs:
      def __init__(__self__, *,
                   backend_addresses: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayBackendAddressArgs']]]] = None,
                   backend_ip_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['NetworkInterfaceIPConfigurationArgs']]]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          Backend Address Pool of an application gateway.
          :param pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayBackendAddressArgs']]] backend_addresses: Backend addresses
          :param pulumi.Input[Sequence[pulumi.Input['NetworkInterfaceIPConfigurationArgs']]] backend_ip_configurations: Collection of references to IPs defined in network interfaces.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Name of the backend address pool that is unique within an Application Gateway.
          :param pulumi.Input[str] provisioning_state: Provisioning state of the backend address pool resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input[str] type: Type of the resource.
          """
          if backend_addresses is not None:
              pulumi.set(__self__, "backend_addresses", backend_addresses)
          if backend_ip_configurations is not None:
              pulumi.set(__self__, "backend_ip_configurations", backend_ip_configurations)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter(name="backendAddresses")
      def backend_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayBackendAddressArgs']]]]:
          """
          Backend addresses
          """
          return pulumi.get(self, "backend_addresses")
  
      @backend_addresses.setter
      def backend_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayBackendAddressArgs']]]]):
          pulumi.set(self, "backend_addresses", value)
  
      @property
      @pulumi.getter(name="backendIPConfigurations")
      def backend_ip_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NetworkInterfaceIPConfigurationArgs']]]]:
          """
          Collection of references to IPs defined in network interfaces.
          """
          return pulumi.get(self, "backend_ip_configurations")
  
      @backend_ip_configurations.setter
      def backend_ip_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NetworkInterfaceIPConfigurationArgs']]]]):
          pulumi.set(self, "backend_ip_configurations", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the backend address pool that is unique within an Application Gateway.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Provisioning state of the backend address pool resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the resource.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayBackendHttpSettingsArgs:
      def __init__(__self__, *,
                   affinity_cookie_name: Optional[pulumi.Input[str]] = None,
                   authentication_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]] = None,
                   connection_draining: Optional[pulumi.Input['ApplicationGatewayConnectionDrainingArgs']] = None,
                   cookie_based_affinity: Optional[pulumi.Input[Union[str, 'ApplicationGatewayCookieBasedAffinity']]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   host_name: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   path: Optional[pulumi.Input[str]] = None,
                   pick_host_name_from_backend_address: Optional[pulumi.Input[bool]] = None,
                   port: Optional[pulumi.Input[int]] = None,
                   probe: Optional[pulumi.Input['SubResourceArgs']] = None,
                   probe_enabled: Optional[pulumi.Input[bool]] = None,
                   protocol: Optional[pulumi.Input[Union[str, 'ApplicationGatewayProtocol']]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   request_timeout: Optional[pulumi.Input[int]] = None,
                   trusted_root_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          Backend address pool settings of an application gateway.
          :param pulumi.Input[str] affinity_cookie_name: Cookie name to use for the affinity cookie.
          :param pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]] authentication_certificates: Array of references to application gateway authentication certificates.
          :param pulumi.Input['ApplicationGatewayConnectionDrainingArgs'] connection_draining: Connection draining of the backend http settings resource.
          :param pulumi.Input[Union[str, 'ApplicationGatewayCookieBasedAffinity']] cookie_based_affinity: Cookie based affinity.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] host_name: Host header to be sent to the backend servers.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Name of the backend http settings that is unique within an Application Gateway.
          :param pulumi.Input[str] path: Path which should be used as a prefix for all HTTP requests. Null means no path will be prefixed. Default value is null.
          :param pulumi.Input[bool] pick_host_name_from_backend_address: Whether to pick host header should be picked from the host name of the backend server. Default value is false.
          :param pulumi.Input[int] port: The destination port on the backend.
          :param pulumi.Input['SubResourceArgs'] probe: Probe resource of an application gateway.
          :param pulumi.Input[bool] probe_enabled: Whether the probe is enabled. Default value is false.
          :param pulumi.Input[Union[str, 'ApplicationGatewayProtocol']] protocol: The protocol used to communicate with the backend. Possible values are 'Http' and 'Https'.
          :param pulumi.Input[str] provisioning_state: Provisioning state of the backend http settings resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input[int] request_timeout: Request timeout in seconds. Application Gateway will fail the request if response is not received within RequestTimeout. Acceptable values are from 1 second to 86400 seconds.
          :param pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]] trusted_root_certificates: Array of references to application gateway trusted root certificates.
          :param pulumi.Input[str] type: Type of the resource.
          """
          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 cookie_based_affinity is not None:
              pulumi.set(__self__, "cookie_based_affinity", cookie_based_affinity)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if host_name is not None:
              pulumi.set(__self__, "host_name", host_name)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          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 port is not None:
              pulumi.set(__self__, "port", port)
          if probe is not None:
              pulumi.set(__self__, "probe", probe)
          if probe_enabled is not None:
              pulumi.set(__self__, "probe_enabled", probe_enabled)
          if protocol is not None:
              pulumi.set(__self__, "protocol", protocol)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if request_timeout is not None:
              pulumi.set(__self__, "request_timeout", request_timeout)
          if trusted_root_certificates is not None:
              pulumi.set(__self__, "trusted_root_certificates", trusted_root_certificates)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter(name="affinityCookieName")
      def affinity_cookie_name(self) -> Optional[pulumi.Input[str]]:
          """
          Cookie name to use for the affinity cookie.
          """
          return pulumi.get(self, "affinity_cookie_name")
  
      @affinity_cookie_name.setter
      def affinity_cookie_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "affinity_cookie_name", value)
  
      @property
      @pulumi.getter(name="authenticationCertificates")
      def authentication_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]:
          """
          Array of references to application gateway authentication certificates.
          """
          return pulumi.get(self, "authentication_certificates")
  
      @authentication_certificates.setter
      def authentication_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]):
          pulumi.set(self, "authentication_certificates", value)
  
      @property
      @pulumi.getter(name="connectionDraining")
      def connection_draining(self) -> Optional[pulumi.Input['ApplicationGatewayConnectionDrainingArgs']]:
          """
          Connection draining of the backend http settings resource.
          """
          return pulumi.get(self, "connection_draining")
  
      @connection_draining.setter
      def connection_draining(self, value: Optional[pulumi.Input['ApplicationGatewayConnectionDrainingArgs']]):
          pulumi.set(self, "connection_draining", value)
  
      @property
      @pulumi.getter(name="cookieBasedAffinity")
      def cookie_based_affinity(self) -> Optional[pulumi.Input[Union[str, 'ApplicationGatewayCookieBasedAffinity']]]:
          """
          Cookie based affinity.
          """
          return pulumi.get(self, "cookie_based_affinity")
  
      @cookie_based_affinity.setter
      def cookie_based_affinity(self, value: Optional[pulumi.Input[Union[str, 'ApplicationGatewayCookieBasedAffinity']]]):
          pulumi.set(self, "cookie_based_affinity", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter(name="hostName")
      def host_name(self) -> Optional[pulumi.Input[str]]:
          """
          Host header to be sent to the backend servers.
          """
          return pulumi.get(self, "host_name")
  
      @host_name.setter
      def host_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "host_name", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the backend http settings that is unique within an Application Gateway.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def path(self) -> Optional[pulumi.Input[str]]:
          """
          Path which should be used as a prefix for all HTTP requests. Null means no path will be prefixed. Default value is null.
          """
          return pulumi.get(self, "path")
  
      @path.setter
      def path(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "path", value)
  
      @property
      @pulumi.getter(name="pickHostNameFromBackendAddress")
      def pick_host_name_from_backend_address(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether to pick host header should be picked from the host name of the backend server. Default value is false.
          """
          return pulumi.get(self, "pick_host_name_from_backend_address")
  
      @pick_host_name_from_backend_address.setter
      def pick_host_name_from_backend_address(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "pick_host_name_from_backend_address", value)
  
      @property
      @pulumi.getter
      def port(self) -> Optional[pulumi.Input[int]]:
          """
          The destination port on the backend.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter
      def probe(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Probe resource of an application gateway.
          """
          return pulumi.get(self, "probe")
  
      @probe.setter
      def probe(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "probe", value)
  
      @property
      @pulumi.getter(name="probeEnabled")
      def probe_enabled(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether the probe is enabled. Default value is false.
          """
          return pulumi.get(self, "probe_enabled")
  
      @probe_enabled.setter
      def probe_enabled(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "probe_enabled", value)
  
      @property
      @pulumi.getter
      def protocol(self) -> Optional[pulumi.Input[Union[str, 'ApplicationGatewayProtocol']]]:
          """
          The protocol used to communicate with the backend. Possible values are 'Http' and 'Https'.
          """
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: Optional[pulumi.Input[Union[str, 'ApplicationGatewayProtocol']]]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Provisioning state of the backend http settings resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter(name="requestTimeout")
      def request_timeout(self) -> Optional[pulumi.Input[int]]:
          """
          Request timeout in seconds. Application Gateway will fail the request if response is not received within RequestTimeout. Acceptable values are from 1 second to 86400 seconds.
          """
          return pulumi.get(self, "request_timeout")
  
      @request_timeout.setter
      def request_timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "request_timeout", value)
  
      @property
      @pulumi.getter(name="trustedRootCertificates")
      def trusted_root_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]:
          """
          Array of references to application gateway trusted root certificates.
          """
          return pulumi.get(self, "trusted_root_certificates")
  
      @trusted_root_certificates.setter
      def trusted_root_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]):
          pulumi.set(self, "trusted_root_certificates", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the resource.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayConnectionDrainingArgs:
      def __init__(__self__, *,
                   drain_timeout_in_sec: pulumi.Input[int],
                   enabled: pulumi.Input[bool]):
          """
          Connection draining allows open connections to a backend server to be active for a specified time after the backend server got removed from the configuration.
          :param pulumi.Input[int] drain_timeout_in_sec: The number of seconds connection draining is active. Acceptable values are from 1 second to 3600 seconds.
          :param pulumi.Input[bool] enabled: Whether connection draining is enabled or not.
          """
          pulumi.set(__self__, "drain_timeout_in_sec", drain_timeout_in_sec)
          pulumi.set(__self__, "enabled", enabled)
  
      @property
      @pulumi.getter(name="drainTimeoutInSec")
      def drain_timeout_in_sec(self) -> pulumi.Input[int]:
          """
          The number of seconds connection draining is active. Acceptable values are from 1 second to 3600 seconds.
          """
          return pulumi.get(self, "drain_timeout_in_sec")
  
      @drain_timeout_in_sec.setter
      def drain_timeout_in_sec(self, value: pulumi.Input[int]):
          pulumi.set(self, "drain_timeout_in_sec", value)
  
      @property
      @pulumi.getter
      def enabled(self) -> pulumi.Input[bool]:
          """
          Whether connection draining is enabled or not.
          """
          return pulumi.get(self, "enabled")
  
      @enabled.setter
      def enabled(self, value: pulumi.Input[bool]):
          pulumi.set(self, "enabled", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayCustomErrorArgs:
      def __init__(__self__, *,
                   custom_error_page_url: Optional[pulumi.Input[str]] = None,
                   status_code: Optional[pulumi.Input[Union[str, 'ApplicationGatewayCustomErrorStatusCode']]] = None):
          """
          Customer error of an application gateway.
          :param pulumi.Input[str] custom_error_page_url: Error page URL of the application gateway customer error.
          :param pulumi.Input[Union[str, 'ApplicationGatewayCustomErrorStatusCode']] status_code: Status code of the application gateway customer error.
          """
          if custom_error_page_url is not None:
              pulumi.set(__self__, "custom_error_page_url", custom_error_page_url)
          if status_code is not None:
              pulumi.set(__self__, "status_code", status_code)
  
      @property
      @pulumi.getter(name="customErrorPageUrl")
      def custom_error_page_url(self) -> Optional[pulumi.Input[str]]:
          """
          Error page URL of the application gateway customer error.
          """
          return pulumi.get(self, "custom_error_page_url")
  
      @custom_error_page_url.setter
      def custom_error_page_url(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "custom_error_page_url", value)
  
      @property
      @pulumi.getter(name="statusCode")
      def status_code(self) -> Optional[pulumi.Input[Union[str, 'ApplicationGatewayCustomErrorStatusCode']]]:
          """
          Status code of the application gateway customer error.
          """
          return pulumi.get(self, "status_code")
  
      @status_code.setter
      def status_code(self, value: Optional[pulumi.Input[Union[str, 'ApplicationGatewayCustomErrorStatusCode']]]):
          pulumi.set(self, "status_code", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayFirewallDisabledRuleGroupArgs:
      def __init__(__self__, *,
                   rule_group_name: pulumi.Input[str],
                   rules: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None):
          """
          Allows to disable rules within a rule group or an entire rule group.
          :param pulumi.Input[str] rule_group_name: The name of the rule group that will be disabled.
          :param pulumi.Input[Sequence[pulumi.Input[int]]] rules: The list of rules that will be disabled. If null, all rules of the rule group will be disabled.
          """
          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) -> pulumi.Input[str]:
          """
          The name of the rule group that will be disabled.
          """
          return pulumi.get(self, "rule_group_name")
  
      @rule_group_name.setter
      def rule_group_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "rule_group_name", value)
  
      @property
      @pulumi.getter
      def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
          """
          The list of rules that will be disabled. If null, all rules of the rule group will be disabled.
          """
          return pulumi.get(self, "rules")
  
      @rules.setter
      def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
          pulumi.set(self, "rules", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayFirewallExclusionArgs:
      def __init__(__self__, *,
                   match_variable: pulumi.Input[str],
                   selector: pulumi.Input[str],
                   selector_match_operator: pulumi.Input[str]):
          """
          Allow to exclude some variable satisfy the condition for the WAF check
          :param pulumi.Input[str] match_variable: The variable to be excluded.
          :param pulumi.Input[str] selector: When matchVariable is a collection, operator used to specify which elements in the collection this exclusion applies to.
          :param pulumi.Input[str] selector_match_operator: When matchVariable is a collection, operate on the selector to specify which elements in the collection this exclusion applies to.
          """
          pulumi.set(__self__, "match_variable", match_variable)
          pulumi.set(__self__, "selector", selector)
          pulumi.set(__self__, "selector_match_operator", selector_match_operator)
  
      @property
      @pulumi.getter(name="matchVariable")
      def match_variable(self) -> pulumi.Input[str]:
          """
          The variable to be excluded.
          """
          return pulumi.get(self, "match_variable")
  
      @match_variable.setter
      def match_variable(self, value: pulumi.Input[str]):
          pulumi.set(self, "match_variable", value)
  
      @property
      @pulumi.getter
      def selector(self) -> pulumi.Input[str]:
          """
          When matchVariable is a collection, operator used to specify which elements in the collection this exclusion applies to.
          """
          return pulumi.get(self, "selector")
  
      @selector.setter
      def selector(self, value: pulumi.Input[str]):
          pulumi.set(self, "selector", value)
  
      @property
      @pulumi.getter(name="selectorMatchOperator")
      def selector_match_operator(self) -> pulumi.Input[str]:
          """
          When matchVariable is a collection, operate on the selector to specify which elements in the collection this exclusion applies to.
          """
          return pulumi.get(self, "selector_match_operator")
  
      @selector_match_operator.setter
      def selector_match_operator(self, value: pulumi.Input[str]):
          pulumi.set(self, "selector_match_operator", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayFrontendIPConfigurationArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   private_ip_address: Optional[pulumi.Input[str]] = None,
                   private_ip_allocation_method: Optional[pulumi.Input[Union[str, 'IPAllocationMethod']]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   public_ip_address: Optional[pulumi.Input['SubResourceArgs']] = None,
                   subnet: Optional[pulumi.Input['SubResourceArgs']] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          Frontend IP configuration of an application gateway.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Name of the frontend IP configuration that is unique within an Application Gateway.
          :param pulumi.Input[str] private_ip_address: PrivateIPAddress of the network interface IP Configuration.
          :param pulumi.Input[Union[str, 'IPAllocationMethod']] private_ip_allocation_method: PrivateIP allocation method.
          :param pulumi.Input[str] provisioning_state: Provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input['SubResourceArgs'] public_ip_address: Reference of the PublicIP resource.
          :param pulumi.Input['SubResourceArgs'] subnet: Reference of the subnet resource.
          :param pulumi.Input[str] type: Type of the resource.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if private_ip_address is not None:
              pulumi.set(__self__, "private_ip_address", private_ip_address)
          if private_ip_allocation_method is not None:
              pulumi.set(__self__, "private_ip_allocation_method", private_ip_allocation_method)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if public_ip_address is not None:
              pulumi.set(__self__, "public_ip_address", public_ip_address)
          if subnet is not None:
              pulumi.set(__self__, "subnet", subnet)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the frontend IP configuration that is unique within an Application Gateway.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="privateIPAddress")
      def private_ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          PrivateIPAddress of the network interface IP Configuration.
          """
          return pulumi.get(self, "private_ip_address")
  
      @private_ip_address.setter
      def private_ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "private_ip_address", value)
  
      @property
      @pulumi.getter(name="privateIPAllocationMethod")
      def private_ip_allocation_method(self) -> Optional[pulumi.Input[Union[str, 'IPAllocationMethod']]]:
          """
          PrivateIP allocation method.
          """
          return pulumi.get(self, "private_ip_allocation_method")
  
      @private_ip_allocation_method.setter
      def private_ip_allocation_method(self, value: Optional[pulumi.Input[Union[str, 'IPAllocationMethod']]]):
          pulumi.set(self, "private_ip_allocation_method", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter(name="publicIPAddress")
      def public_ip_address(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Reference of the PublicIP resource.
          """
          return pulumi.get(self, "public_ip_address")
  
      @public_ip_address.setter
      def public_ip_address(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "public_ip_address", value)
  
      @property
      @pulumi.getter
      def subnet(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Reference of the subnet resource.
          """
          return pulumi.get(self, "subnet")
  
      @subnet.setter
      def subnet(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "subnet", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the resource.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayFrontendPortArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   port: Optional[pulumi.Input[int]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          Frontend port of an application gateway.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Name of the frontend port that is unique within an Application Gateway
          :param pulumi.Input[int] port: Frontend port
          :param pulumi.Input[str] provisioning_state: Provisioning state of the frontend port resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input[str] type: Type of the resource.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if port is not None:
              pulumi.set(__self__, "port", port)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the frontend port that is unique within an Application Gateway
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def port(self) -> Optional[pulumi.Input[int]]:
          """
          Frontend port
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Provisioning state of the frontend port resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the resource.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayHeaderConfigurationArgs:
      def __init__(__self__, *,
                   header_name: Optional[pulumi.Input[str]] = None,
                   header_value: Optional[pulumi.Input[str]] = None):
          """
          Header configuration of the Actions set in Application Gateway.
          :param pulumi.Input[str] header_name: Header name of the header configuration
          :param pulumi.Input[str] header_value: Header value of the header configuration
          """
          if header_name is not None:
              pulumi.set(__self__, "header_name", header_name)
          if header_value is not None:
              pulumi.set(__self__, "header_value", header_value)
  
      @property
      @pulumi.getter(name="headerName")
      def header_name(self) -> Optional[pulumi.Input[str]]:
          """
          Header name of the header configuration
          """
          return pulumi.get(self, "header_name")
  
      @header_name.setter
      def header_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "header_name", value)
  
      @property
      @pulumi.getter(name="headerValue")
      def header_value(self) -> Optional[pulumi.Input[str]]:
          """
          Header value of the header configuration
          """
          return pulumi.get(self, "header_value")
  
      @header_value.setter
      def header_value(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "header_value", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayHttpListenerArgs:
      def __init__(__self__, *,
                   custom_error_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayCustomErrorArgs']]]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   frontend_ip_configuration: Optional[pulumi.Input['SubResourceArgs']] = None,
                   frontend_port: Optional[pulumi.Input['SubResourceArgs']] = None,
                   host_name: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   protocol: Optional[pulumi.Input[Union[str, 'ApplicationGatewayProtocol']]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   require_server_name_indication: Optional[pulumi.Input[bool]] = None,
                   ssl_certificate: Optional[pulumi.Input['SubResourceArgs']] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          Http listener of an application gateway.
          :param pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayCustomErrorArgs']]] custom_error_configurations: Custom error configurations of the HTTP listener.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input['SubResourceArgs'] frontend_ip_configuration: Frontend IP configuration resource of an application gateway.
          :param pulumi.Input['SubResourceArgs'] frontend_port: Frontend port resource of an application gateway.
          :param pulumi.Input[str] host_name: Host name of HTTP listener.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Name of the HTTP listener that is unique within an Application Gateway.
          :param pulumi.Input[Union[str, 'ApplicationGatewayProtocol']] protocol: Protocol of the HTTP listener. Possible values are 'Http' and 'Https'.
          :param pulumi.Input[str] provisioning_state: Provisioning state of the HTTP listener resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input[bool] require_server_name_indication: Applicable only if protocol is https. Enables SNI for multi-hosting.
          :param pulumi.Input['SubResourceArgs'] ssl_certificate: SSL certificate resource of an application gateway.
          :param pulumi.Input[str] type: Type of the resource.
          """
          if custom_error_configurations is not None:
              pulumi.set(__self__, "custom_error_configurations", custom_error_configurations)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if frontend_ip_configuration is not None:
              pulumi.set(__self__, "frontend_ip_configuration", frontend_ip_configuration)
          if frontend_port is not None:
              pulumi.set(__self__, "frontend_port", frontend_port)
          if host_name is not None:
              pulumi.set(__self__, "host_name", host_name)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if protocol is not None:
              pulumi.set(__self__, "protocol", protocol)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if require_server_name_indication is not None:
              pulumi.set(__self__, "require_server_name_indication", require_server_name_indication)
          if ssl_certificate is not None:
              pulumi.set(__self__, "ssl_certificate", ssl_certificate)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter(name="customErrorConfigurations")
      def custom_error_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayCustomErrorArgs']]]]:
          """
          Custom error configurations of the HTTP listener.
          """
          return pulumi.get(self, "custom_error_configurations")
  
      @custom_error_configurations.setter
      def custom_error_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayCustomErrorArgs']]]]):
          pulumi.set(self, "custom_error_configurations", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter(name="frontendIPConfiguration")
      def frontend_ip_configuration(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Frontend IP configuration resource of an application gateway.
          """
          return pulumi.get(self, "frontend_ip_configuration")
  
      @frontend_ip_configuration.setter
      def frontend_ip_configuration(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "frontend_ip_configuration", value)
  
      @property
      @pulumi.getter(name="frontendPort")
      def frontend_port(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Frontend port resource of an application gateway.
          """
          return pulumi.get(self, "frontend_port")
  
      @frontend_port.setter
      def frontend_port(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "frontend_port", value)
  
      @property
      @pulumi.getter(name="hostName")
      def host_name(self) -> Optional[pulumi.Input[str]]:
          """
          Host name of HTTP listener.
          """
          return pulumi.get(self, "host_name")
  
      @host_name.setter
      def host_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "host_name", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the HTTP listener that is unique within an Application Gateway.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def protocol(self) -> Optional[pulumi.Input[Union[str, 'ApplicationGatewayProtocol']]]:
          """
          Protocol of the HTTP listener. Possible values are 'Http' and 'Https'.
          """
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: Optional[pulumi.Input[Union[str, 'ApplicationGatewayProtocol']]]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Provisioning state of the HTTP listener resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter(name="requireServerNameIndication")
      def require_server_name_indication(self) -> Optional[pulumi.Input[bool]]:
          """
          Applicable only if protocol is https. Enables SNI for multi-hosting.
          """
          return pulumi.get(self, "require_server_name_indication")
  
      @require_server_name_indication.setter
      def require_server_name_indication(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "require_server_name_indication", value)
  
      @property
      @pulumi.getter(name="sslCertificate")
      def ssl_certificate(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          SSL certificate resource of an application gateway.
          """
          return pulumi.get(self, "ssl_certificate")
  
      @ssl_certificate.setter
      def ssl_certificate(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "ssl_certificate", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the resource.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayIPConfigurationArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   subnet: Optional[pulumi.Input['SubResourceArgs']] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          IP configuration of an application gateway. Currently 1 public and 1 private IP configuration is allowed.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Name of the IP configuration that is unique within an Application Gateway.
          :param pulumi.Input[str] provisioning_state: Provisioning state of the application gateway subnet resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input['SubResourceArgs'] subnet: Reference of the subnet resource. A subnet from where application gateway gets its private address.
          :param pulumi.Input[str] type: Type of the resource.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if subnet is not None:
              pulumi.set(__self__, "subnet", subnet)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the IP configuration that is unique within an Application Gateway.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Provisioning state of the application gateway subnet resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter
      def subnet(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Reference of the subnet resource. A subnet from where application gateway gets its private address.
          """
          return pulumi.get(self, "subnet")
  
      @subnet.setter
      def subnet(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "subnet", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the resource.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayPathRuleArgs:
      def __init__(__self__, *,
                   backend_address_pool: Optional[pulumi.Input['SubResourceArgs']] = None,
                   backend_http_settings: Optional[pulumi.Input['SubResourceArgs']] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   paths: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   redirect_configuration: Optional[pulumi.Input['SubResourceArgs']] = None,
                   rewrite_rule_set: Optional[pulumi.Input['SubResourceArgs']] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          Path rule of URL path map of an application gateway.
          :param pulumi.Input['SubResourceArgs'] backend_address_pool: Backend address pool resource of URL path map path rule.
          :param pulumi.Input['SubResourceArgs'] backend_http_settings: Backend http settings resource of URL path map path rule.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Name of the path rule that is unique within an Application Gateway.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] paths: Path rules of URL path map.
          :param pulumi.Input[str] provisioning_state: Path rule of URL path map resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input['SubResourceArgs'] redirect_configuration: Redirect configuration resource of URL path map path rule.
          :param pulumi.Input['SubResourceArgs'] rewrite_rule_set: Rewrite rule set resource of URL path map path rule.
          :param pulumi.Input[str] type: Type of the resource.
          """
          if backend_address_pool is not None:
              pulumi.set(__self__, "backend_address_pool", backend_address_pool)
          if backend_http_settings is not None:
              pulumi.set(__self__, "backend_http_settings", backend_http_settings)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if paths is not None:
              pulumi.set(__self__, "paths", paths)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if redirect_configuration is not None:
              pulumi.set(__self__, "redirect_configuration", redirect_configuration)
          if rewrite_rule_set is not None:
              pulumi.set(__self__, "rewrite_rule_set", rewrite_rule_set)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter(name="backendAddressPool")
      def backend_address_pool(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Backend address pool resource of URL path map path rule.
          """
          return pulumi.get(self, "backend_address_pool")
  
      @backend_address_pool.setter
      def backend_address_pool(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "backend_address_pool", value)
  
      @property
      @pulumi.getter(name="backendHttpSettings")
      def backend_http_settings(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Backend http settings resource of URL path map path rule.
          """
          return pulumi.get(self, "backend_http_settings")
  
      @backend_http_settings.setter
      def backend_http_settings(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "backend_http_settings", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the path rule that is unique within an Application Gateway.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def paths(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          Path rules of URL path map.
          """
          return pulumi.get(self, "paths")
  
      @paths.setter
      def paths(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "paths", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Path rule of URL path map resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter(name="redirectConfiguration")
      def redirect_configuration(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Redirect configuration resource of URL path map path rule.
          """
          return pulumi.get(self, "redirect_configuration")
  
      @redirect_configuration.setter
      def redirect_configuration(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "redirect_configuration", value)
  
      @property
      @pulumi.getter(name="rewriteRuleSet")
      def rewrite_rule_set(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Rewrite rule set resource of URL path map path rule.
          """
          return pulumi.get(self, "rewrite_rule_set")
  
      @rewrite_rule_set.setter
      def rewrite_rule_set(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "rewrite_rule_set", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the resource.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayProbeArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   host: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   interval: Optional[pulumi.Input[int]] = None,
                   match: Optional[pulumi.Input['ApplicationGatewayProbeHealthResponseMatchArgs']] = None,
                   min_servers: Optional[pulumi.Input[int]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   path: Optional[pulumi.Input[str]] = None,
                   pick_host_name_from_backend_http_settings: Optional[pulumi.Input[bool]] = None,
                   protocol: Optional[pulumi.Input[Union[str, 'ApplicationGatewayProtocol']]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   timeout: Optional[pulumi.Input[int]] = None,
                   type: Optional[pulumi.Input[str]] = None,
                   unhealthy_threshold: Optional[pulumi.Input[int]] = None):
          """
          Probe of the application gateway.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] host: Host name to send the probe to.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[int] interval: The probing interval in seconds. This is the time interval between two consecutive probes. Acceptable values are from 1 second to 86400 seconds.
          :param pulumi.Input['ApplicationGatewayProbeHealthResponseMatchArgs'] match: Criterion for classifying a healthy probe response.
          :param pulumi.Input[int] min_servers: Minimum number of servers that are always marked healthy. Default value is 0.
          :param pulumi.Input[str] name: Name of the probe that is unique within an Application Gateway.
          :param pulumi.Input[str] path: Relative path of probe. Valid path starts from '/'. Probe is sent to <Protocol>://<host>:<port><path>
          :param pulumi.Input[bool] pick_host_name_from_backend_http_settings: Whether the host header should be picked from the backend http settings. Default value is false.
          :param pulumi.Input[Union[str, 'ApplicationGatewayProtocol']] protocol: The protocol used for the probe. Possible values are 'Http' and 'Https'.
          :param pulumi.Input[str] provisioning_state: Provisioning state of the backend http settings resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input[int] timeout: the probe timeout in seconds. Probe marked as failed if valid response is not received with this timeout period. Acceptable values are from 1 second to 86400 seconds.
          :param pulumi.Input[str] type: Type of the resource.
          :param pulumi.Input[int] unhealthy_threshold: The probe retry count. Backend server is marked down after consecutive probe failure count reaches UnhealthyThreshold. Acceptable values are from 1 second to 20.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if host is not None:
              pulumi.set(__self__, "host", host)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if interval is not None:
              pulumi.set(__self__, "interval", interval)
          if match is not None:
              pulumi.set(__self__, "match", match)
          if min_servers is not None:
              pulumi.set(__self__, "min_servers", min_servers)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if path is not None:
              pulumi.set(__self__, "path", path)
          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 protocol is not None:
              pulumi.set(__self__, "protocol", protocol)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if timeout is not None:
              pulumi.set(__self__, "timeout", timeout)
          if type is not None:
              pulumi.set(__self__, "type", type)
          if unhealthy_threshold is not None:
              pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def host(self) -> Optional[pulumi.Input[str]]:
          """
          Host name to send the probe to.
          """
          return pulumi.get(self, "host")
  
      @host.setter
      def host(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "host", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def interval(self) -> Optional[pulumi.Input[int]]:
          """
          The probing interval in seconds. This is the time interval between two consecutive probes. Acceptable values are from 1 second to 86400 seconds.
          """
          return pulumi.get(self, "interval")
  
      @interval.setter
      def interval(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "interval", value)
  
      @property
      @pulumi.getter
      def match(self) -> Optional[pulumi.Input['ApplicationGatewayProbeHealthResponseMatchArgs']]:
          """
          Criterion for classifying a healthy probe response.
          """
          return pulumi.get(self, "match")
  
      @match.setter
      def match(self, value: Optional[pulumi.Input['ApplicationGatewayProbeHealthResponseMatchArgs']]):
          pulumi.set(self, "match", value)
  
      @property
      @pulumi.getter(name="minServers")
      def min_servers(self) -> Optional[pulumi.Input[int]]:
          """
          Minimum number of servers that are always marked healthy. Default value is 0.
          """
          return pulumi.get(self, "min_servers")
  
      @min_servers.setter
      def min_servers(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "min_servers", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the probe that is unique within an Application Gateway.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def path(self) -> Optional[pulumi.Input[str]]:
          """
          Relative path of probe. Valid path starts from '/'. Probe is sent to <Protocol>://<host>:<port><path>
          """
          return pulumi.get(self, "path")
  
      @path.setter
      def path(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "path", value)
  
      @property
      @pulumi.getter(name="pickHostNameFromBackendHttpSettings")
      def pick_host_name_from_backend_http_settings(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether the host header should be picked from the backend http settings. Default value is false.
          """
          return pulumi.get(self, "pick_host_name_from_backend_http_settings")
  
      @pick_host_name_from_backend_http_settings.setter
      def pick_host_name_from_backend_http_settings(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "pick_host_name_from_backend_http_settings", value)
  
      @property
      @pulumi.getter
      def protocol(self) -> Optional[pulumi.Input[Union[str, 'ApplicationGatewayProtocol']]]:
          """
          The protocol used for the probe. Possible values are 'Http' and 'Https'.
          """
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: Optional[pulumi.Input[Union[str, 'ApplicationGatewayProtocol']]]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Provisioning state of the backend http settings resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter
      def timeout(self) -> Optional[pulumi.Input[int]]:
          """
          the probe timeout in seconds. Probe marked as failed if valid response is not received with this timeout period. Acceptable values are from 1 second to 86400 seconds.
          """
          return pulumi.get(self, "timeout")
  
      @timeout.setter
      def timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "timeout", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the resource.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter(name="unhealthyThreshold")
      def unhealthy_threshold(self) -> Optional[pulumi.Input[int]]:
          """
          The probe retry count. Backend server is marked down after consecutive probe failure count reaches UnhealthyThreshold. Acceptable values are from 1 second to 20.
          """
          return pulumi.get(self, "unhealthy_threshold")
  
      @unhealthy_threshold.setter
      def unhealthy_threshold(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "unhealthy_threshold", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayProbeHealthResponseMatchArgs:
      def __init__(__self__, *,
                   body: Optional[pulumi.Input[str]] = None,
                   status_codes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          Application gateway probe health response match
          :param pulumi.Input[str] body: Body that must be contained in the health response. Default value is empty.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] status_codes: Allowed ranges of healthy status codes. Default range of healthy status codes is 200-399.
          """
          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[pulumi.Input[str]]:
          """
          Body that must be contained in the health response. Default value is empty.
          """
          return pulumi.get(self, "body")
  
      @body.setter
      def body(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "body", value)
  
      @property
      @pulumi.getter(name="statusCodes")
      def status_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          Allowed ranges of healthy status codes. Default range of healthy status codes is 200-399.
          """
          return pulumi.get(self, "status_codes")
  
      @status_codes.setter
      def status_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "status_codes", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayRedirectConfigurationArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   include_path: Optional[pulumi.Input[bool]] = None,
                   include_query_string: Optional[pulumi.Input[bool]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   path_rules: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]] = None,
                   redirect_type: Optional[pulumi.Input[Union[str, 'ApplicationGatewayRedirectType']]] = None,
                   request_routing_rules: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]] = None,
                   target_listener: Optional[pulumi.Input['SubResourceArgs']] = None,
                   target_url: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input[str]] = None,
                   url_path_maps: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]] = None):
          """
          Redirect configuration of an application gateway.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[bool] include_path: Include path in the redirected url.
          :param pulumi.Input[bool] include_query_string: Include query string in the redirected url.
          :param pulumi.Input[str] name: Name of the redirect configuration that is unique within an Application Gateway.
          :param pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]] path_rules: Path rules specifying redirect configuration.
          :param pulumi.Input[Union[str, 'ApplicationGatewayRedirectType']] redirect_type: Supported http redirection types - Permanent, Temporary, Found, SeeOther.
          :param pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]] request_routing_rules: Request routing specifying redirect configuration.
          :param pulumi.Input['SubResourceArgs'] target_listener: Reference to a listener to redirect the request to.
          :param pulumi.Input[str] target_url: Url to redirect the request to.
          :param pulumi.Input[str] type: Type of the resource.
          :param pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]] url_path_maps: Url path maps specifying default redirect configuration.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          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 name is not None:
              pulumi.set(__self__, "name", name)
          if path_rules is not None:
              pulumi.set(__self__, "path_rules", path_rules)
          if redirect_type is not None:
              pulumi.set(__self__, "redirect_type", redirect_type)
          if request_routing_rules is not None:
              pulumi.set(__self__, "request_routing_rules", request_routing_rules)
          if target_listener is not None:
              pulumi.set(__self__, "target_listener", target_listener)
          if target_url is not None:
              pulumi.set(__self__, "target_url", target_url)
          if type is not None:
              pulumi.set(__self__, "type", type)
          if url_path_maps is not None:
              pulumi.set(__self__, "url_path_maps", url_path_maps)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="includePath")
      def include_path(self) -> Optional[pulumi.Input[bool]]:
          """
          Include path in the redirected url.
          """
          return pulumi.get(self, "include_path")
  
      @include_path.setter
      def include_path(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "include_path", value)
  
      @property
      @pulumi.getter(name="includeQueryString")
      def include_query_string(self) -> Optional[pulumi.Input[bool]]:
          """
          Include query string in the redirected url.
          """
          return pulumi.get(self, "include_query_string")
  
      @include_query_string.setter
      def include_query_string(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "include_query_string", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the redirect configuration that is unique within an Application Gateway.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="pathRules")
      def path_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]:
          """
          Path rules specifying redirect configuration.
          """
          return pulumi.get(self, "path_rules")
  
      @path_rules.setter
      def path_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]):
          pulumi.set(self, "path_rules", value)
  
      @property
      @pulumi.getter(name="redirectType")
      def redirect_type(self) -> Optional[pulumi.Input[Union[str, 'ApplicationGatewayRedirectType']]]:
          """
          Supported http redirection types - Permanent, Temporary, Found, SeeOther.
          """
          return pulumi.get(self, "redirect_type")
  
      @redirect_type.setter
      def redirect_type(self, value: Optional[pulumi.Input[Union[str, 'ApplicationGatewayRedirectType']]]):
          pulumi.set(self, "redirect_type", value)
  
      @property
      @pulumi.getter(name="requestRoutingRules")
      def request_routing_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]:
          """
          Request routing specifying redirect configuration.
          """
          return pulumi.get(self, "request_routing_rules")
  
      @request_routing_rules.setter
      def request_routing_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]):
          pulumi.set(self, "request_routing_rules", value)
  
      @property
      @pulumi.getter(name="targetListener")
      def target_listener(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Reference to a listener to redirect the request to.
          """
          return pulumi.get(self, "target_listener")
  
      @target_listener.setter
      def target_listener(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "target_listener", value)
  
      @property
      @pulumi.getter(name="targetUrl")
      def target_url(self) -> Optional[pulumi.Input[str]]:
          """
          Url to redirect the request to.
          """
          return pulumi.get(self, "target_url")
  
      @target_url.setter
      def target_url(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "target_url", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the resource.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter(name="urlPathMaps")
      def url_path_maps(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]:
          """
          Url path maps specifying default redirect configuration.
          """
          return pulumi.get(self, "url_path_maps")
  
      @url_path_maps.setter
      def url_path_maps(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]):
          pulumi.set(self, "url_path_maps", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayRequestRoutingRuleArgs:
      def __init__(__self__, *,
                   backend_address_pool: Optional[pulumi.Input['SubResourceArgs']] = None,
                   backend_http_settings: Optional[pulumi.Input['SubResourceArgs']] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   http_listener: Optional[pulumi.Input['SubResourceArgs']] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   redirect_configuration: Optional[pulumi.Input['SubResourceArgs']] = None,
                   rewrite_rule_set: Optional[pulumi.Input['SubResourceArgs']] = None,
                   rule_type: Optional[pulumi.Input[Union[str, 'ApplicationGatewayRequestRoutingRuleType']]] = None,
                   type: Optional[pulumi.Input[str]] = None,
                   url_path_map: Optional[pulumi.Input['SubResourceArgs']] = None):
          """
          Request routing rule of an application gateway.
          :param pulumi.Input['SubResourceArgs'] backend_address_pool: Backend address pool resource of the application gateway. 
          :param pulumi.Input['SubResourceArgs'] backend_http_settings: Backend http settings resource of the application gateway.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input['SubResourceArgs'] http_listener: Http listener resource of the application gateway. 
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Name of the request routing rule that is unique within an Application Gateway.
          :param pulumi.Input[str] provisioning_state: Provisioning state of the request routing rule resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input['SubResourceArgs'] redirect_configuration: Redirect configuration resource of the application gateway.
          :param pulumi.Input['SubResourceArgs'] rewrite_rule_set: Rewrite Rule Set resource in Basic rule of the application gateway.
          :param pulumi.Input[Union[str, 'ApplicationGatewayRequestRoutingRuleType']] rule_type: Rule type.
          :param pulumi.Input[str] type: Type of the resource.
          :param pulumi.Input['SubResourceArgs'] url_path_map: URL path map resource of the application gateway.
          """
          if backend_address_pool is not None:
              pulumi.set(__self__, "backend_address_pool", backend_address_pool)
          if backend_http_settings is not None:
              pulumi.set(__self__, "backend_http_settings", backend_http_settings)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if http_listener is not None:
              pulumi.set(__self__, "http_listener", http_listener)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if redirect_configuration is not None:
              pulumi.set(__self__, "redirect_configuration", redirect_configuration)
          if rewrite_rule_set is not None:
              pulumi.set(__self__, "rewrite_rule_set", rewrite_rule_set)
          if rule_type is not None:
              pulumi.set(__self__, "rule_type", rule_type)
          if type is not None:
              pulumi.set(__self__, "type", type)
          if url_path_map is not None:
              pulumi.set(__self__, "url_path_map", url_path_map)
  
      @property
      @pulumi.getter(name="backendAddressPool")
      def backend_address_pool(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Backend address pool resource of the application gateway. 
          """
          return pulumi.get(self, "backend_address_pool")
  
      @backend_address_pool.setter
      def backend_address_pool(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "backend_address_pool", value)
  
      @property
      @pulumi.getter(name="backendHttpSettings")
      def backend_http_settings(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Backend http settings resource of the application gateway.
          """
          return pulumi.get(self, "backend_http_settings")
  
      @backend_http_settings.setter
      def backend_http_settings(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "backend_http_settings", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter(name="httpListener")
      def http_listener(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Http listener resource of the application gateway. 
          """
          return pulumi.get(self, "http_listener")
  
      @http_listener.setter
      def http_listener(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "http_listener", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the request routing rule that is unique within an Application Gateway.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Provisioning state of the request routing rule resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter(name="redirectConfiguration")
      def redirect_configuration(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Redirect configuration resource of the application gateway.
          """
          return pulumi.get(self, "redirect_configuration")
  
      @redirect_configuration.setter
      def redirect_configuration(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "redirect_configuration", value)
  
      @property
      @pulumi.getter(name="rewriteRuleSet")
      def rewrite_rule_set(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Rewrite Rule Set resource in Basic rule of the application gateway.
          """
          return pulumi.get(self, "rewrite_rule_set")
  
      @rewrite_rule_set.setter
      def rewrite_rule_set(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "rewrite_rule_set", value)
  
      @property
      @pulumi.getter(name="ruleType")
      def rule_type(self) -> Optional[pulumi.Input[Union[str, 'ApplicationGatewayRequestRoutingRuleType']]]:
          """
          Rule type.
          """
          return pulumi.get(self, "rule_type")
  
      @rule_type.setter
      def rule_type(self, value: Optional[pulumi.Input[Union[str, 'ApplicationGatewayRequestRoutingRuleType']]]):
          pulumi.set(self, "rule_type", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the resource.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter(name="urlPathMap")
      def url_path_map(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          URL path map resource of the application gateway.
          """
          return pulumi.get(self, "url_path_map")
  
      @url_path_map.setter
      def url_path_map(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "url_path_map", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayRewriteRuleArgs:
      def __init__(__self__, *,
                   action_set: Optional[pulumi.Input['ApplicationGatewayRewriteRuleActionSetArgs']] = None,
                   name: Optional[pulumi.Input[str]] = None):
          """
          Rewrite rule of an application gateway.
          :param pulumi.Input['ApplicationGatewayRewriteRuleActionSetArgs'] action_set: Set of actions to be done as part of the rewrite Rule.
          :param pulumi.Input[str] name: Name of the rewrite rule that is unique within an Application Gateway.
          """
          if action_set is not None:
              pulumi.set(__self__, "action_set", action_set)
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter(name="actionSet")
      def action_set(self) -> Optional[pulumi.Input['ApplicationGatewayRewriteRuleActionSetArgs']]:
          """
          Set of actions to be done as part of the rewrite Rule.
          """
          return pulumi.get(self, "action_set")
  
      @action_set.setter
      def action_set(self, value: Optional[pulumi.Input['ApplicationGatewayRewriteRuleActionSetArgs']]):
          pulumi.set(self, "action_set", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the rewrite rule that is unique within an Application Gateway.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayRewriteRuleActionSetArgs:
      def __init__(__self__, *,
                   request_header_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayHeaderConfigurationArgs']]]] = None,
                   response_header_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayHeaderConfigurationArgs']]]] = None):
          """
          Set of actions in the Rewrite Rule in Application Gateway.
          :param pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayHeaderConfigurationArgs']]] request_header_configurations: Request Header Actions in the Action Set
          :param pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayHeaderConfigurationArgs']]] response_header_configurations: Response Header Actions in the Action Set
          """
          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(name="requestHeaderConfigurations")
      def request_header_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayHeaderConfigurationArgs']]]]:
          """
          Request Header Actions in the Action Set
          """
          return pulumi.get(self, "request_header_configurations")
  
      @request_header_configurations.setter
      def request_header_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayHeaderConfigurationArgs']]]]):
          pulumi.set(self, "request_header_configurations", value)
  
      @property
      @pulumi.getter(name="responseHeaderConfigurations")
      def response_header_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayHeaderConfigurationArgs']]]]:
          """
          Response Header Actions in the Action Set
          """
          return pulumi.get(self, "response_header_configurations")
  
      @response_header_configurations.setter
      def response_header_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayHeaderConfigurationArgs']]]]):
          pulumi.set(self, "response_header_configurations", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayRewriteRuleSetArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   rewrite_rules: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayRewriteRuleArgs']]]] = None):
          """
          Rewrite rule set of an application gateway.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Name of the rewrite rule set that is unique within an Application Gateway.
          :param pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayRewriteRuleArgs']]] rewrite_rules: Rewrite rules in the rewrite rule set.
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if rewrite_rules is not None:
              pulumi.set(__self__, "rewrite_rules", rewrite_rules)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the rewrite rule set that is unique within an Application Gateway.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="rewriteRules")
      def rewrite_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayRewriteRuleArgs']]]]:
          """
          Rewrite rules in the rewrite rule set.
          """
          return pulumi.get(self, "rewrite_rules")
  
      @rewrite_rules.setter
      def rewrite_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayRewriteRuleArgs']]]]):
          pulumi.set(self, "rewrite_rules", value)
  
  
  @pulumi.input_type
  class ApplicationGatewaySkuArgs:
      def __init__(__self__, *,
                   capacity: Optional[pulumi.Input[int]] = None,
                   name: Optional[pulumi.Input[Union[str, 'ApplicationGatewaySkuName']]] = None,
                   tier: Optional[pulumi.Input[Union[str, 'ApplicationGatewayTier']]] = None):
          """
          SKU of an application gateway
          :param pulumi.Input[int] capacity: Capacity (instance count) of an application gateway.
          :param pulumi.Input[Union[str, 'ApplicationGatewaySkuName']] name: Name of an application gateway SKU.
          :param pulumi.Input[Union[str, 'ApplicationGatewayTier']] tier: Tier of an application gateway.
          """
          if capacity is not None:
              pulumi.set(__self__, "capacity", capacity)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if tier is not None:
              pulumi.set(__self__, "tier", tier)
  
      @property
      @pulumi.getter
      def capacity(self) -> Optional[pulumi.Input[int]]:
          """
          Capacity (instance count) of an application gateway.
          """
          return pulumi.get(self, "capacity")
  
      @capacity.setter
      def capacity(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "capacity", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[Union[str, 'ApplicationGatewaySkuName']]]:
          """
          Name of an application gateway SKU.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[Union[str, 'ApplicationGatewaySkuName']]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def tier(self) -> Optional[pulumi.Input[Union[str, 'ApplicationGatewayTier']]]:
          """
          Tier of an application gateway.
          """
          return pulumi.get(self, "tier")
  
      @tier.setter
      def tier(self, value: Optional[pulumi.Input[Union[str, 'ApplicationGatewayTier']]]):
          pulumi.set(self, "tier", value)
  
  
  @pulumi.input_type
  class ApplicationGatewaySslCertificateArgs:
      def __init__(__self__, *,
                   data: Optional[pulumi.Input[str]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   key_vault_secret_id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   password: Optional[pulumi.Input[str]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   public_cert_data: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          SSL certificates of an application gateway.
          :param pulumi.Input[str] data: Base-64 encoded pfx certificate. Only applicable in PUT Request.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] key_vault_secret_id: Secret Id of (base-64 encoded unencrypted pfx) 'Secret' or 'Certificate' object stored in KeyVault.
          :param pulumi.Input[str] name: Name of the SSL certificate that is unique within an Application Gateway.
          :param pulumi.Input[str] password: Password for the pfx file specified in data. Only applicable in PUT request.
          :param pulumi.Input[str] provisioning_state: Provisioning state of the SSL certificate resource Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input[str] public_cert_data: Base-64 encoded Public cert data corresponding to pfx specified in data. Only applicable in GET request.
          :param pulumi.Input[str] type: Type of the resource.
          """
          if data is not None:
              pulumi.set(__self__, "data", data)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          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 name is not None:
              pulumi.set(__self__, "name", name)
          if password is not None:
              pulumi.set(__self__, "password", password)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if public_cert_data is not None:
              pulumi.set(__self__, "public_cert_data", public_cert_data)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def data(self) -> Optional[pulumi.Input[str]]:
          """
          Base-64 encoded pfx certificate. Only applicable in PUT Request.
          """
          return pulumi.get(self, "data")
  
      @data.setter
      def data(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "data", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="keyVaultSecretId")
      def key_vault_secret_id(self) -> Optional[pulumi.Input[str]]:
          """
          Secret Id of (base-64 encoded unencrypted pfx) 'Secret' or 'Certificate' object stored in KeyVault.
          """
          return pulumi.get(self, "key_vault_secret_id")
  
      @key_vault_secret_id.setter
      def key_vault_secret_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "key_vault_secret_id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the SSL certificate that is unique within an Application Gateway.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def password(self) -> Optional[pulumi.Input[str]]:
          """
          Password for the pfx file specified in data. Only applicable in PUT request.
          """
          return pulumi.get(self, "password")
  
      @password.setter
      def password(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "password", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Provisioning state of the SSL certificate resource Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter(name="publicCertData")
      def public_cert_data(self) -> Optional[pulumi.Input[str]]:
          """
          Base-64 encoded Public cert data corresponding to pfx specified in data. Only applicable in GET request.
          """
          return pulumi.get(self, "public_cert_data")
  
      @public_cert_data.setter
      def public_cert_data(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "public_cert_data", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the resource.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ApplicationGatewaySslPolicyArgs:
      def __init__(__self__, *,
                   cipher_suites: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ApplicationGatewaySslCipherSuite']]]]] = None,
                   disabled_ssl_protocols: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ApplicationGatewaySslProtocol']]]]] = None,
                   min_protocol_version: Optional[pulumi.Input[Union[str, 'ApplicationGatewaySslProtocol']]] = None,
                   policy_name: Optional[pulumi.Input[Union[str, 'ApplicationGatewaySslPolicyName']]] = None,
                   policy_type: Optional[pulumi.Input[Union[str, 'ApplicationGatewaySslPolicyType']]] = None):
          """
          Application Gateway Ssl policy.
          :param pulumi.Input[Sequence[pulumi.Input[Union[str, 'ApplicationGatewaySslCipherSuite']]]] cipher_suites: Ssl cipher suites to be enabled in the specified order to application gateway.
          :param pulumi.Input[Sequence[pulumi.Input[Union[str, 'ApplicationGatewaySslProtocol']]]] disabled_ssl_protocols: Ssl protocols to be disabled on application gateway.
          :param pulumi.Input[Union[str, 'ApplicationGatewaySslProtocol']] min_protocol_version: Minimum version of Ssl protocol to be supported on application gateway.
          :param pulumi.Input[Union[str, 'ApplicationGatewaySslPolicyName']] policy_name: Name of Ssl predefined policy
          :param pulumi.Input[Union[str, 'ApplicationGatewaySslPolicyType']] policy_type: Type of Ssl Policy
          """
          if cipher_suites is not None:
              pulumi.set(__self__, "cipher_suites", cipher_suites)
          if disabled_ssl_protocols is not None:
              pulumi.set(__self__, "disabled_ssl_protocols", disabled_ssl_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[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ApplicationGatewaySslCipherSuite']]]]]:
          """
          Ssl cipher suites to be enabled in the specified order to application gateway.
          """
          return pulumi.get(self, "cipher_suites")
  
      @cipher_suites.setter
      def cipher_suites(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ApplicationGatewaySslCipherSuite']]]]]):
          pulumi.set(self, "cipher_suites", value)
  
      @property
      @pulumi.getter(name="disabledSslProtocols")
      def disabled_ssl_protocols(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ApplicationGatewaySslProtocol']]]]]:
          """
          Ssl protocols to be disabled on application gateway.
          """
          return pulumi.get(self, "disabled_ssl_protocols")
  
      @disabled_ssl_protocols.setter
      def disabled_ssl_protocols(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ApplicationGatewaySslProtocol']]]]]):
          pulumi.set(self, "disabled_ssl_protocols", value)
  
      @property
      @pulumi.getter(name="minProtocolVersion")
      def min_protocol_version(self) -> Optional[pulumi.Input[Union[str, 'ApplicationGatewaySslProtocol']]]:
          """
          Minimum version of Ssl protocol to be supported on application gateway.
          """
          return pulumi.get(self, "min_protocol_version")
  
      @min_protocol_version.setter
      def min_protocol_version(self, value: Optional[pulumi.Input[Union[str, 'ApplicationGatewaySslProtocol']]]):
          pulumi.set(self, "min_protocol_version", value)
  
      @property
      @pulumi.getter(name="policyName")
      def policy_name(self) -> Optional[pulumi.Input[Union[str, 'ApplicationGatewaySslPolicyName']]]:
          """
          Name of Ssl predefined policy
          """
          return pulumi.get(self, "policy_name")
  
      @policy_name.setter
      def policy_name(self, value: Optional[pulumi.Input[Union[str, 'ApplicationGatewaySslPolicyName']]]):
          pulumi.set(self, "policy_name", value)
  
      @property
      @pulumi.getter(name="policyType")
      def policy_type(self) -> Optional[pulumi.Input[Union[str, 'ApplicationGatewaySslPolicyType']]]:
          """
          Type of Ssl Policy
          """
          return pulumi.get(self, "policy_type")
  
      @policy_type.setter
      def policy_type(self, value: Optional[pulumi.Input[Union[str, 'ApplicationGatewaySslPolicyType']]]):
          pulumi.set(self, "policy_type", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayTrustedRootCertificateArgs:
      def __init__(__self__, *,
                   data: Optional[pulumi.Input[str]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   key_vault_secret_id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          Trusted Root certificates of an application gateway.
          :param pulumi.Input[str] data: Certificate public data.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] key_vault_secret_id: Secret Id of (base-64 encoded unencrypted pfx) 'Secret' or 'Certificate' object stored in KeyVault.
          :param pulumi.Input[str] name: Name of the trusted root certificate that is unique within an Application Gateway.
          :param pulumi.Input[str] provisioning_state: Provisioning state of the trusted root certificate resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input[str] type: Type of the resource.
          """
          if data is not None:
              pulumi.set(__self__, "data", data)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          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 name is not None:
              pulumi.set(__self__, "name", name)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def data(self) -> Optional[pulumi.Input[str]]:
          """
          Certificate public data.
          """
          return pulumi.get(self, "data")
  
      @data.setter
      def data(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "data", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="keyVaultSecretId")
      def key_vault_secret_id(self) -> Optional[pulumi.Input[str]]:
          """
          Secret Id of (base-64 encoded unencrypted pfx) 'Secret' or 'Certificate' object stored in KeyVault.
          """
          return pulumi.get(self, "key_vault_secret_id")
  
      @key_vault_secret_id.setter
      def key_vault_secret_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "key_vault_secret_id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the trusted root certificate that is unique within an Application Gateway.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Provisioning state of the trusted root certificate resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the resource.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayUrlPathMapArgs:
      def __init__(__self__, *,
                   default_backend_address_pool: Optional[pulumi.Input['SubResourceArgs']] = None,
                   default_backend_http_settings: Optional[pulumi.Input['SubResourceArgs']] = None,
                   default_redirect_configuration: Optional[pulumi.Input['SubResourceArgs']] = None,
                   default_rewrite_rule_set: Optional[pulumi.Input['SubResourceArgs']] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   path_rules: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayPathRuleArgs']]]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          UrlPathMaps give a url path to the backend mapping information for PathBasedRouting.
          :param pulumi.Input['SubResourceArgs'] default_backend_address_pool: Default backend address pool resource of URL path map.
          :param pulumi.Input['SubResourceArgs'] default_backend_http_settings: Default backend http settings resource of URL path map.
          :param pulumi.Input['SubResourceArgs'] default_redirect_configuration: Default redirect configuration resource of URL path map.
          :param pulumi.Input['SubResourceArgs'] default_rewrite_rule_set: Default Rewrite rule set resource of URL path map.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Name of the URL path map that is unique within an Application Gateway.
          :param pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayPathRuleArgs']]] path_rules: Path rule of URL path map resource.
          :param pulumi.Input[str] provisioning_state: Provisioning state of the backend http settings resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input[str] type: Type of the resource.
          """
          if default_backend_address_pool is not None:
              pulumi.set(__self__, "default_backend_address_pool", default_backend_address_pool)
          if default_backend_http_settings is not None:
              pulumi.set(__self__, "default_backend_http_settings", default_backend_http_settings)
          if default_redirect_configuration is not None:
              pulumi.set(__self__, "default_redirect_configuration", default_redirect_configuration)
          if default_rewrite_rule_set is not None:
              pulumi.set(__self__, "default_rewrite_rule_set", default_rewrite_rule_set)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if path_rules is not None:
              pulumi.set(__self__, "path_rules", path_rules)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter(name="defaultBackendAddressPool")
      def default_backend_address_pool(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Default backend address pool resource of URL path map.
          """
          return pulumi.get(self, "default_backend_address_pool")
  
      @default_backend_address_pool.setter
      def default_backend_address_pool(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "default_backend_address_pool", value)
  
      @property
      @pulumi.getter(name="defaultBackendHttpSettings")
      def default_backend_http_settings(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Default backend http settings resource of URL path map.
          """
          return pulumi.get(self, "default_backend_http_settings")
  
      @default_backend_http_settings.setter
      def default_backend_http_settings(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "default_backend_http_settings", value)
  
      @property
      @pulumi.getter(name="defaultRedirectConfiguration")
      def default_redirect_configuration(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Default redirect configuration resource of URL path map.
          """
          return pulumi.get(self, "default_redirect_configuration")
  
      @default_redirect_configuration.setter
      def default_redirect_configuration(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "default_redirect_configuration", value)
  
      @property
      @pulumi.getter(name="defaultRewriteRuleSet")
      def default_rewrite_rule_set(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Default Rewrite rule set resource of URL path map.
          """
          return pulumi.get(self, "default_rewrite_rule_set")
  
      @default_rewrite_rule_set.setter
      def default_rewrite_rule_set(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "default_rewrite_rule_set", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the URL path map that is unique within an Application Gateway.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="pathRules")
      def path_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayPathRuleArgs']]]]:
          """
          Path rule of URL path map resource.
          """
          return pulumi.get(self, "path_rules")
  
      @path_rules.setter
      def path_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayPathRuleArgs']]]]):
          pulumi.set(self, "path_rules", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Provisioning state of the backend http settings resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the resource.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ApplicationGatewayWebApplicationFirewallConfigurationArgs:
      def __init__(__self__, *,
                   enabled: pulumi.Input[bool],
                   firewall_mode: pulumi.Input[Union[str, 'ApplicationGatewayFirewallMode']],
                   rule_set_type: pulumi.Input[str],
                   rule_set_version: pulumi.Input[str],
                   disabled_rule_groups: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayFirewallDisabledRuleGroupArgs']]]] = None,
                   exclusions: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayFirewallExclusionArgs']]]] = None,
                   file_upload_limit_in_mb: Optional[pulumi.Input[int]] = None,
                   max_request_body_size: Optional[pulumi.Input[int]] = None,
                   max_request_body_size_in_kb: Optional[pulumi.Input[int]] = None,
                   request_body_check: Optional[pulumi.Input[bool]] = None):
          """
          Application gateway web application firewall configuration.
          :param pulumi.Input[bool] enabled: Whether the web application firewall is enabled or not.
          :param pulumi.Input[Union[str, 'ApplicationGatewayFirewallMode']] firewall_mode: Web application firewall mode.
          :param pulumi.Input[str] rule_set_type: The type of the web application firewall rule set. Possible values are: 'OWASP'.
          :param pulumi.Input[str] rule_set_version: The version of the rule set type.
          :param pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayFirewallDisabledRuleGroupArgs']]] disabled_rule_groups: The disabled rule groups.
          :param pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayFirewallExclusionArgs']]] exclusions: The exclusion list.
          :param pulumi.Input[int] file_upload_limit_in_mb: Maximum file upload size in Mb for WAF.
          :param pulumi.Input[int] max_request_body_size: Maximum request body size for WAF.
          :param pulumi.Input[int] max_request_body_size_in_kb: Maximum request body size in Kb for WAF.
          :param pulumi.Input[bool] request_body_check: Whether allow WAF to check request Body.
          """
          pulumi.set(__self__, "enabled", enabled)
          pulumi.set(__self__, "firewall_mode", firewall_mode)
          pulumi.set(__self__, "rule_set_type", rule_set_type)
          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_in_mb is not None:
              pulumi.set(__self__, "file_upload_limit_in_mb", file_upload_limit_in_mb)
          if max_request_body_size is not None:
              pulumi.set(__self__, "max_request_body_size", max_request_body_size)
          if max_request_body_size_in_kb is not None:
              pulumi.set(__self__, "max_request_body_size_in_kb", max_request_body_size_in_kb)
          if request_body_check is not None:
              pulumi.set(__self__, "request_body_check", request_body_check)
  
      @property
      @pulumi.getter
      def enabled(self) -> pulumi.Input[bool]:
          """
          Whether the web application firewall is enabled or not.
          """
          return pulumi.get(self, "enabled")
  
      @enabled.setter
      def enabled(self, value: pulumi.Input[bool]):
          pulumi.set(self, "enabled", value)
  
      @property
      @pulumi.getter(name="firewallMode")
      def firewall_mode(self) -> pulumi.Input[Union[str, 'ApplicationGatewayFirewallMode']]:
          """
          Web application firewall mode.
          """
          return pulumi.get(self, "firewall_mode")
  
      @firewall_mode.setter
      def firewall_mode(self, value: pulumi.Input[Union[str, 'ApplicationGatewayFirewallMode']]):
          pulumi.set(self, "firewall_mode", value)
  
      @property
      @pulumi.getter(name="ruleSetType")
      def rule_set_type(self) -> pulumi.Input[str]:
          """
          The type of the web application firewall rule set. Possible values are: 'OWASP'.
          """
          return pulumi.get(self, "rule_set_type")
  
      @rule_set_type.setter
      def rule_set_type(self, value: pulumi.Input[str]):
          pulumi.set(self, "rule_set_type", value)
  
      @property
      @pulumi.getter(name="ruleSetVersion")
      def rule_set_version(self) -> pulumi.Input[str]:
          """
          The version of the rule set type.
          """
          return pulumi.get(self, "rule_set_version")
  
      @rule_set_version.setter
      def rule_set_version(self, value: pulumi.Input[str]):
          pulumi.set(self, "rule_set_version", value)
  
      @property
      @pulumi.getter(name="disabledRuleGroups")
      def disabled_rule_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayFirewallDisabledRuleGroupArgs']]]]:
          """
          The disabled rule groups.
          """
          return pulumi.get(self, "disabled_rule_groups")
  
      @disabled_rule_groups.setter
      def disabled_rule_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayFirewallDisabledRuleGroupArgs']]]]):
          pulumi.set(self, "disabled_rule_groups", value)
  
      @property
      @pulumi.getter
      def exclusions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayFirewallExclusionArgs']]]]:
          """
          The exclusion list.
          """
          return pulumi.get(self, "exclusions")
  
      @exclusions.setter
      def exclusions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayFirewallExclusionArgs']]]]):
          pulumi.set(self, "exclusions", value)
  
      @property
      @pulumi.getter(name="fileUploadLimitInMb")
      def file_upload_limit_in_mb(self) -> Optional[pulumi.Input[int]]:
          """
          Maximum file upload size in Mb for WAF.
          """
          return pulumi.get(self, "file_upload_limit_in_mb")
  
      @file_upload_limit_in_mb.setter
      def file_upload_limit_in_mb(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "file_upload_limit_in_mb", value)
  
      @property
      @pulumi.getter(name="maxRequestBodySize")
      def max_request_body_size(self) -> Optional[pulumi.Input[int]]:
          """
          Maximum request body size for WAF.
          """
          return pulumi.get(self, "max_request_body_size")
  
      @max_request_body_size.setter
      def max_request_body_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_request_body_size", value)
  
      @property
      @pulumi.getter(name="maxRequestBodySizeInKb")
      def max_request_body_size_in_kb(self) -> Optional[pulumi.Input[int]]:
          """
          Maximum request body size in Kb for WAF.
          """
          return pulumi.get(self, "max_request_body_size_in_kb")
  
      @max_request_body_size_in_kb.setter
      def max_request_body_size_in_kb(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_request_body_size_in_kb", value)
  
      @property
      @pulumi.getter(name="requestBodyCheck")
      def request_body_check(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether allow WAF to check request Body.
          """
          return pulumi.get(self, "request_body_check")
  
      @request_body_check.setter
      def request_body_check(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "request_body_check", value)
  
  
  @pulumi.input_type
  class ApplicationSecurityGroupArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None,
                   location: Optional[pulumi.Input[str]] = None,
                   tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
          """
          An application security group in a resource group.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] location: Resource location.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags.
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
          if location is not None:
              pulumi.set(__self__, "location", location)
          if tags is not None:
              pulumi.set(__self__, "tags", tags)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def location(self) -> Optional[pulumi.Input[str]]:
          """
          Resource location.
          """
          return pulumi.get(self, "location")
  
      @location.setter
      def location(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "location", value)
  
      @property
      @pulumi.getter
      def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Resource tags.
          """
          return pulumi.get(self, "tags")
  
      @tags.setter
      def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "tags", value)
  
  
  @pulumi.input_type
  class AzureFirewallApplicationRuleArgs:
      def __init__(__self__, *,
                   description: Optional[pulumi.Input[str]] = None,
                   fqdn_tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   protocols: Optional[pulumi.Input[Sequence[pulumi.Input['AzureFirewallApplicationRuleProtocolArgs']]]] = None,
                   source_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   target_fqdns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          Properties of an application rule.
          :param pulumi.Input[str] description: Description of the rule.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] fqdn_tags: List of FQDN Tags for this rule.
          :param pulumi.Input[str] name: Name of the application rule.
          :param pulumi.Input[Sequence[pulumi.Input['AzureFirewallApplicationRuleProtocolArgs']]] protocols: Array of ApplicationRuleProtocols.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] source_addresses: List of source IP addresses for this rule.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] target_fqdns: List of FQDNs for this rule.
          """
          if description is not None:
              pulumi.set(__self__, "description", description)
          if fqdn_tags is not None:
              pulumi.set(__self__, "fqdn_tags", fqdn_tags)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if protocols is not None:
              pulumi.set(__self__, "protocols", protocols)
          if source_addresses is not None:
              pulumi.set(__self__, "source_addresses", source_addresses)
          if target_fqdns is not None:
              pulumi.set(__self__, "target_fqdns", target_fqdns)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          Description of the rule.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter(name="fqdnTags")
      def fqdn_tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List of FQDN Tags for this rule.
          """
          return pulumi.get(self, "fqdn_tags")
  
      @fqdn_tags.setter
      def fqdn_tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "fqdn_tags", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the application rule.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def protocols(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AzureFirewallApplicationRuleProtocolArgs']]]]:
          """
          Array of ApplicationRuleProtocols.
          """
          return pulumi.get(self, "protocols")
  
      @protocols.setter
      def protocols(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AzureFirewallApplicationRuleProtocolArgs']]]]):
          pulumi.set(self, "protocols", value)
  
      @property
      @pulumi.getter(name="sourceAddresses")
      def source_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List of source IP addresses for this rule.
          """
          return pulumi.get(self, "source_addresses")
  
      @source_addresses.setter
      def source_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "source_addresses", value)
  
      @property
      @pulumi.getter(name="targetFqdns")
      def target_fqdns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List of FQDNs for this rule.
          """
          return pulumi.get(self, "target_fqdns")
  
      @target_fqdns.setter
      def target_fqdns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "target_fqdns", value)
  
  
  @pulumi.input_type
  class AzureFirewallApplicationRuleCollectionArgs:
      def __init__(__self__, *,
                   action: Optional[pulumi.Input['AzureFirewallRCActionArgs']] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   priority: Optional[pulumi.Input[int]] = None,
                   rules: Optional[pulumi.Input[Sequence[pulumi.Input['AzureFirewallApplicationRuleArgs']]]] = None):
          """
          Application rule collection resource
          :param pulumi.Input['AzureFirewallRCActionArgs'] action: The action type of a rule collection
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[int] priority: Priority of the application rule collection resource.
          :param pulumi.Input[Sequence[pulumi.Input['AzureFirewallApplicationRuleArgs']]] rules: Collection of rules used by a application rule collection.
          """
          if action is not None:
              pulumi.set(__self__, "action", action)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if priority is not None:
              pulumi.set(__self__, "priority", priority)
          if rules is not None:
              pulumi.set(__self__, "rules", rules)
  
      @property
      @pulumi.getter
      def action(self) -> Optional[pulumi.Input['AzureFirewallRCActionArgs']]:
          """
          The action type of a rule collection
          """
          return pulumi.get(self, "action")
  
      @action.setter
      def action(self, value: Optional[pulumi.Input['AzureFirewallRCActionArgs']]):
          pulumi.set(self, "action", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def priority(self) -> Optional[pulumi.Input[int]]:
          """
          Priority of the application rule collection resource.
          """
          return pulumi.get(self, "priority")
  
      @priority.setter
      def priority(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "priority", value)
  
      @property
      @pulumi.getter
      def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AzureFirewallApplicationRuleArgs']]]]:
          """
          Collection of rules used by a application rule collection.
          """
          return pulumi.get(self, "rules")
  
      @rules.setter
      def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AzureFirewallApplicationRuleArgs']]]]):
          pulumi.set(self, "rules", value)
  
  
  @pulumi.input_type
  class AzureFirewallApplicationRuleProtocolArgs:
      def __init__(__self__, *,
                   port: Optional[pulumi.Input[int]] = None,
                   protocol_type: Optional[pulumi.Input[Union[str, 'AzureFirewallApplicationRuleProtocolType']]] = None):
          """
          Properties of the application rule protocol.
          :param pulumi.Input[int] port: Port number for the protocol, cannot be greater than 64000. This field is optional.
          :param pulumi.Input[Union[str, 'AzureFirewallApplicationRuleProtocolType']] protocol_type: Protocol type
          """
          if port is not None:
              pulumi.set(__self__, "port", port)
          if protocol_type is not None:
              pulumi.set(__self__, "protocol_type", protocol_type)
  
      @property
      @pulumi.getter
      def port(self) -> Optional[pulumi.Input[int]]:
          """
          Port number for the protocol, cannot be greater than 64000. This field is optional.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter(name="protocolType")
      def protocol_type(self) -> Optional[pulumi.Input[Union[str, 'AzureFirewallApplicationRuleProtocolType']]]:
          """
          Protocol type
          """
          return pulumi.get(self, "protocol_type")
  
      @protocol_type.setter
      def protocol_type(self, value: Optional[pulumi.Input[Union[str, 'AzureFirewallApplicationRuleProtocolType']]]):
          pulumi.set(self, "protocol_type", value)
  
  
  @pulumi.input_type
  class AzureFirewallIPConfigurationArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   public_ip_address: Optional[pulumi.Input['SubResourceArgs']] = None,
                   subnet: Optional[pulumi.Input['SubResourceArgs']] = None):
          """
          IP configuration of an Azure Firewall.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input['SubResourceArgs'] public_ip_address: Reference of the PublicIP resource. This field is a mandatory input if subnet is not null.
          :param pulumi.Input['SubResourceArgs'] subnet: Reference of the subnet resource. This resource must be named 'AzureFirewallSubnet'.
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if public_ip_address is not None:
              pulumi.set(__self__, "public_ip_address", public_ip_address)
          if subnet is not None:
              pulumi.set(__self__, "subnet", subnet)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="publicIPAddress")
      def public_ip_address(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Reference of the PublicIP resource. This field is a mandatory input if subnet is not null.
          """
          return pulumi.get(self, "public_ip_address")
  
      @public_ip_address.setter
      def public_ip_address(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "public_ip_address", value)
  
      @property
      @pulumi.getter
      def subnet(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Reference of the subnet resource. This resource must be named 'AzureFirewallSubnet'.
          """
          return pulumi.get(self, "subnet")
  
      @subnet.setter
      def subnet(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "subnet", value)
  
  
  @pulumi.input_type
  class AzureFirewallNatRCActionArgs:
      def __init__(__self__, *,
                   type: Optional[pulumi.Input[Union[str, 'AzureFirewallNatRCActionType']]] = None):
          """
          AzureFirewall NAT Rule Collection Action.
          :param pulumi.Input[Union[str, 'AzureFirewallNatRCActionType']] type: The type of action.
          """
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[Union[str, 'AzureFirewallNatRCActionType']]]:
          """
          The type of action.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[Union[str, 'AzureFirewallNatRCActionType']]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class AzureFirewallNatRuleArgs:
      def __init__(__self__, *,
                   description: Optional[pulumi.Input[str]] = None,
                   destination_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   destination_ports: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   protocols: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'AzureFirewallNetworkRuleProtocol']]]]] = None,
                   source_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   translated_address: Optional[pulumi.Input[str]] = None,
                   translated_port: Optional[pulumi.Input[str]] = None):
          """
          Properties of a NAT rule.
          :param pulumi.Input[str] description: Description of the rule.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] destination_addresses: List of destination IP addresses for this rule.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] destination_ports: List of destination ports.
          :param pulumi.Input[str] name: Name of the NAT rule.
          :param pulumi.Input[Sequence[pulumi.Input[Union[str, 'AzureFirewallNetworkRuleProtocol']]]] protocols: Array of AzureFirewallNetworkRuleProtocols applicable to this NAT rule.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] source_addresses: List of source IP addresses for this rule.
          :param pulumi.Input[str] translated_address: The translated address for this NAT rule.
          :param pulumi.Input[str] translated_port: The translated port for this NAT rule.
          """
          if description is not None:
              pulumi.set(__self__, "description", description)
          if destination_addresses is not None:
              pulumi.set(__self__, "destination_addresses", destination_addresses)
          if destination_ports is not None:
              pulumi.set(__self__, "destination_ports", destination_ports)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if protocols is not None:
              pulumi.set(__self__, "protocols", protocols)
          if source_addresses is not None:
              pulumi.set(__self__, "source_addresses", source_addresses)
          if translated_address is not None:
              pulumi.set(__self__, "translated_address", translated_address)
          if translated_port is not None:
              pulumi.set(__self__, "translated_port", translated_port)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          Description of the rule.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter(name="destinationAddresses")
      def destination_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List of destination IP addresses for this rule.
          """
          return pulumi.get(self, "destination_addresses")
  
      @destination_addresses.setter
      def destination_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "destination_addresses", value)
  
      @property
      @pulumi.getter(name="destinationPorts")
      def destination_ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List of destination ports.
          """
          return pulumi.get(self, "destination_ports")
  
      @destination_ports.setter
      def destination_ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "destination_ports", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the NAT rule.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def protocols(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'AzureFirewallNetworkRuleProtocol']]]]]:
          """
          Array of AzureFirewallNetworkRuleProtocols applicable to this NAT rule.
          """
          return pulumi.get(self, "protocols")
  
      @protocols.setter
      def protocols(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'AzureFirewallNetworkRuleProtocol']]]]]):
          pulumi.set(self, "protocols", value)
  
      @property
      @pulumi.getter(name="sourceAddresses")
      def source_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List of source IP addresses for this rule.
          """
          return pulumi.get(self, "source_addresses")
  
      @source_addresses.setter
      def source_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "source_addresses", value)
  
      @property
      @pulumi.getter(name="translatedAddress")
      def translated_address(self) -> Optional[pulumi.Input[str]]:
          """
          The translated address for this NAT rule.
          """
          return pulumi.get(self, "translated_address")
  
      @translated_address.setter
      def translated_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "translated_address", value)
  
      @property
      @pulumi.getter(name="translatedPort")
      def translated_port(self) -> Optional[pulumi.Input[str]]:
          """
          The translated port for this NAT rule.
          """
          return pulumi.get(self, "translated_port")
  
      @translated_port.setter
      def translated_port(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "translated_port", value)
  
  
  @pulumi.input_type
  class AzureFirewallNatRuleCollectionArgs:
      def __init__(__self__, *,
                   action: Optional[pulumi.Input['AzureFirewallNatRCActionArgs']] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   priority: Optional[pulumi.Input[int]] = None,
                   rules: Optional[pulumi.Input[Sequence[pulumi.Input['AzureFirewallNatRuleArgs']]]] = None):
          """
          NAT rule collection resource
          :param pulumi.Input['AzureFirewallNatRCActionArgs'] action: The action type of a NAT rule collection
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[int] priority: Priority of the NAT rule collection resource.
          :param pulumi.Input[Sequence[pulumi.Input['AzureFirewallNatRuleArgs']]] rules: Collection of rules used by a NAT rule collection.
          """
          if action is not None:
              pulumi.set(__self__, "action", action)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if priority is not None:
              pulumi.set(__self__, "priority", priority)
          if rules is not None:
              pulumi.set(__self__, "rules", rules)
  
      @property
      @pulumi.getter
      def action(self) -> Optional[pulumi.Input['AzureFirewallNatRCActionArgs']]:
          """
          The action type of a NAT rule collection
          """
          return pulumi.get(self, "action")
  
      @action.setter
      def action(self, value: Optional[pulumi.Input['AzureFirewallNatRCActionArgs']]):
          pulumi.set(self, "action", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def priority(self) -> Optional[pulumi.Input[int]]:
          """
          Priority of the NAT rule collection resource.
          """
          return pulumi.get(self, "priority")
  
      @priority.setter
      def priority(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "priority", value)
  
      @property
      @pulumi.getter
      def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AzureFirewallNatRuleArgs']]]]:
          """
          Collection of rules used by a NAT rule collection.
          """
          return pulumi.get(self, "rules")
  
      @rules.setter
      def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AzureFirewallNatRuleArgs']]]]):
          pulumi.set(self, "rules", value)
  
  
  @pulumi.input_type
  class AzureFirewallNetworkRuleArgs:
      def __init__(__self__, *,
                   description: Optional[pulumi.Input[str]] = None,
                   destination_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   destination_ports: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   protocols: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'AzureFirewallNetworkRuleProtocol']]]]] = None,
                   source_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          Properties of the network rule.
          :param pulumi.Input[str] description: Description of the rule.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] destination_addresses: List of destination IP addresses.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] destination_ports: List of destination ports.
          :param pulumi.Input[str] name: Name of the network rule.
          :param pulumi.Input[Sequence[pulumi.Input[Union[str, 'AzureFirewallNetworkRuleProtocol']]]] protocols: Array of AzureFirewallNetworkRuleProtocols.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] source_addresses: List of source IP addresses for this rule.
          """
          if description is not None:
              pulumi.set(__self__, "description", description)
          if destination_addresses is not None:
              pulumi.set(__self__, "destination_addresses", destination_addresses)
          if destination_ports is not None:
              pulumi.set(__self__, "destination_ports", destination_ports)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if protocols is not None:
              pulumi.set(__self__, "protocols", protocols)
          if source_addresses is not None:
              pulumi.set(__self__, "source_addresses", source_addresses)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          Description of the rule.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter(name="destinationAddresses")
      def destination_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List of destination IP addresses.
          """
          return pulumi.get(self, "destination_addresses")
  
      @destination_addresses.setter
      def destination_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "destination_addresses", value)
  
      @property
      @pulumi.getter(name="destinationPorts")
      def destination_ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List of destination ports.
          """
          return pulumi.get(self, "destination_ports")
  
      @destination_ports.setter
      def destination_ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "destination_ports", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the network rule.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def protocols(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'AzureFirewallNetworkRuleProtocol']]]]]:
          """
          Array of AzureFirewallNetworkRuleProtocols.
          """
          return pulumi.get(self, "protocols")
  
      @protocols.setter
      def protocols(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'AzureFirewallNetworkRuleProtocol']]]]]):
          pulumi.set(self, "protocols", value)
  
      @property
      @pulumi.getter(name="sourceAddresses")
      def source_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List of source IP addresses for this rule.
          """
          return pulumi.get(self, "source_addresses")
  
      @source_addresses.setter
      def source_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "source_addresses", value)
  
  
  @pulumi.input_type
  class AzureFirewallNetworkRuleCollectionArgs:
      def __init__(__self__, *,
                   action: Optional[pulumi.Input['AzureFirewallRCActionArgs']] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   priority: Optional[pulumi.Input[int]] = None,
                   rules: Optional[pulumi.Input[Sequence[pulumi.Input['AzureFirewallNetworkRuleArgs']]]] = None):
          """
          Network rule collection resource
          :param pulumi.Input['AzureFirewallRCActionArgs'] action: The action type of a rule collection
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[int] priority: Priority of the network rule collection resource.
          :param pulumi.Input[Sequence[pulumi.Input['AzureFirewallNetworkRuleArgs']]] rules: Collection of rules used by a network rule collection.
          """
          if action is not None:
              pulumi.set(__self__, "action", action)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if priority is not None:
              pulumi.set(__self__, "priority", priority)
          if rules is not None:
              pulumi.set(__self__, "rules", rules)
  
      @property
      @pulumi.getter
      def action(self) -> Optional[pulumi.Input['AzureFirewallRCActionArgs']]:
          """
          The action type of a rule collection
          """
          return pulumi.get(self, "action")
  
      @action.setter
      def action(self, value: Optional[pulumi.Input['AzureFirewallRCActionArgs']]):
          pulumi.set(self, "action", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def priority(self) -> Optional[pulumi.Input[int]]:
          """
          Priority of the network rule collection resource.
          """
          return pulumi.get(self, "priority")
  
      @priority.setter
      def priority(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "priority", value)
  
      @property
      @pulumi.getter
      def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AzureFirewallNetworkRuleArgs']]]]:
          """
          Collection of rules used by a network rule collection.
          """
          return pulumi.get(self, "rules")
  
      @rules.setter
      def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AzureFirewallNetworkRuleArgs']]]]):
          pulumi.set(self, "rules", value)
  
  
  @pulumi.input_type
  class AzureFirewallRCActionArgs:
      def __init__(__self__, *,
                   type: Optional[pulumi.Input[Union[str, 'AzureFirewallRCActionType']]] = None):
          """
          Properties of the AzureFirewallRCAction.
          :param pulumi.Input[Union[str, 'AzureFirewallRCActionType']] type: The type of action.
          """
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[Union[str, 'AzureFirewallRCActionType']]]:
          """
          The type of action.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[Union[str, 'AzureFirewallRCActionType']]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class BackendAddressPoolArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None):
          """
          Pool of backend IP addresses.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[str] provisioning_state: Get provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Get provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
  
  @pulumi.input_type
  class BgpSettingsArgs:
      def __init__(__self__, *,
                   asn: Optional[pulumi.Input[float]] = None,
                   bgp_peering_address: Optional[pulumi.Input[str]] = None,
                   peer_weight: Optional[pulumi.Input[int]] = None):
          """
          BGP settings details
          :param pulumi.Input[float] asn: The BGP speaker's ASN.
          :param pulumi.Input[str] bgp_peering_address: The BGP peering address and BGP identifier of this BGP speaker.
          :param pulumi.Input[int] peer_weight: The weight added to routes learned from this BGP speaker.
          """
          if asn is not None:
              pulumi.set(__self__, "asn", asn)
          if bgp_peering_address is not None:
              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) -> Optional[pulumi.Input[float]]:
          """
          The BGP speaker's ASN.
          """
          return pulumi.get(self, "asn")
  
      @asn.setter
      def asn(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "asn", value)
  
      @property
      @pulumi.getter(name="bgpPeeringAddress")
      def bgp_peering_address(self) -> Optional[pulumi.Input[str]]:
          """
          The BGP peering address and BGP identifier of this BGP speaker.
          """
          return pulumi.get(self, "bgp_peering_address")
  
      @bgp_peering_address.setter
      def bgp_peering_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "bgp_peering_address", value)
  
      @property
      @pulumi.getter(name="peerWeight")
      def peer_weight(self) -> Optional[pulumi.Input[int]]:
          """
          The weight added to routes learned from this BGP speaker.
          """
          return pulumi.get(self, "peer_weight")
  
      @peer_weight.setter
      def peer_weight(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "peer_weight", value)
  
  
  @pulumi.input_type
  class ConnectionMonitorDestinationArgs:
      def __init__(__self__, *,
                   address: Optional[pulumi.Input[str]] = None,
                   port: Optional[pulumi.Input[int]] = None,
                   resource_id: Optional[pulumi.Input[str]] = None):
          """
          Describes the destination of connection monitor.
          :param pulumi.Input[str] address: Address of the connection monitor destination (IP or domain name).
          :param pulumi.Input[int] port: The destination port used by connection monitor.
          :param pulumi.Input[str] resource_id: The ID of the resource used as the destination by connection monitor.
          """
          if address is not None:
              pulumi.set(__self__, "address", address)
          if port is not None:
              pulumi.set(__self__, "port", port)
          if resource_id is not None:
              pulumi.set(__self__, "resource_id", resource_id)
  
      @property
      @pulumi.getter
      def address(self) -> Optional[pulumi.Input[str]]:
          """
          Address of the connection monitor destination (IP or domain name).
          """
          return pulumi.get(self, "address")
  
      @address.setter
      def address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "address", value)
  
      @property
      @pulumi.getter
      def port(self) -> Optional[pulumi.Input[int]]:
          """
          The destination port used by connection monitor.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter(name="resourceId")
      def resource_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the resource used as the destination by connection monitor.
          """
          return pulumi.get(self, "resource_id")
  
      @resource_id.setter
      def resource_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "resource_id", value)
  
  
  @pulumi.input_type
  class ConnectionMonitorSourceArgs:
      def __init__(__self__, *,
                   resource_id: pulumi.Input[str],
                   port: Optional[pulumi.Input[int]] = None):
          """
          Describes the source of connection monitor.
          :param pulumi.Input[str] resource_id: The ID of the resource used as the source by connection monitor.
          :param pulumi.Input[int] port: The source port used by connection monitor.
          """
          pulumi.set(__self__, "resource_id", resource_id)
          if port is not None:
              pulumi.set(__self__, "port", port)
  
      @property
      @pulumi.getter(name="resourceId")
      def resource_id(self) -> pulumi.Input[str]:
          """
          The ID of the resource used as the source by connection monitor.
          """
          return pulumi.get(self, "resource_id")
  
      @resource_id.setter
      def resource_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "resource_id", value)
  
      @property
      @pulumi.getter
      def port(self) -> Optional[pulumi.Input[int]]:
          """
          The source port used by connection monitor.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "port", value)
  
  
  @pulumi.input_type
  class ContainerArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None):
          """
          Reference to container resource in remote resource provider.
          :param pulumi.Input[str] id: Resource ID.
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
  
  @pulumi.input_type
  class ContainerNetworkInterfaceArgs:
      def __init__(__self__, *,
                   container: Optional[pulumi.Input['ContainerArgs']] = None,
                   container_network_interface_configuration: Optional[pulumi.Input['ContainerNetworkInterfaceConfigurationArgs']] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   ip_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerNetworkInterfaceIpConfigurationArgs']]]] = None,
                   name: Optional[pulumi.Input[str]] = None):
          """
          Container network interface child resource.
          :param pulumi.Input['ContainerArgs'] container: Reference to the container to which this container network interface is attached.
          :param pulumi.Input['ContainerNetworkInterfaceConfigurationArgs'] container_network_interface_configuration: Container network interface configuration from which this container network interface is created.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[Sequence[pulumi.Input['ContainerNetworkInterfaceIpConfigurationArgs']]] ip_configurations: Reference to the ip configuration on this container nic.
          :param pulumi.Input[str] name: The name of the resource. This name can be used to access the resource.
          """
          if container is not None:
              pulumi.set(__self__, "container", container)
          if container_network_interface_configuration is not None:
              pulumi.set(__self__, "container_network_interface_configuration", container_network_interface_configuration)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if ip_configurations is not None:
              pulumi.set(__self__, "ip_configurations", ip_configurations)
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def container(self) -> Optional[pulumi.Input['ContainerArgs']]:
          """
          Reference to the container to which this container network interface is attached.
          """
          return pulumi.get(self, "container")
  
      @container.setter
      def container(self, value: Optional[pulumi.Input['ContainerArgs']]):
          pulumi.set(self, "container", value)
  
      @property
      @pulumi.getter(name="containerNetworkInterfaceConfiguration")
      def container_network_interface_configuration(self) -> Optional[pulumi.Input['ContainerNetworkInterfaceConfigurationArgs']]:
          """
          Container network interface configuration from which this container network interface is created.
          """
          return pulumi.get(self, "container_network_interface_configuration")
  
      @container_network_interface_configuration.setter
      def container_network_interface_configuration(self, value: Optional[pulumi.Input['ContainerNetworkInterfaceConfigurationArgs']]):
          pulumi.set(self, "container_network_interface_configuration", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="ipConfigurations")
      def ip_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerNetworkInterfaceIpConfigurationArgs']]]]:
          """
          Reference to the ip configuration on this container nic.
          """
          return pulumi.get(self, "ip_configurations")
  
      @ip_configurations.setter
      def ip_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerNetworkInterfaceIpConfigurationArgs']]]]):
          pulumi.set(self, "ip_configurations", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class ContainerNetworkInterfaceConfigurationArgs:
      def __init__(__self__, *,
                   container_network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   ip_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['IPConfigurationProfileArgs']]]] = None,
                   name: Optional[pulumi.Input[str]] = None):
          """
          Container network interface configuration child resource.
          :param pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]] container_network_interfaces: A list of container network interfaces created from this container network interface configuration.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[Sequence[pulumi.Input['IPConfigurationProfileArgs']]] ip_configurations: A list of ip configurations of the container network interface configuration.
          :param pulumi.Input[str] name: The name of the resource. This name can be used to access the resource.
          """
          if container_network_interfaces is not None:
              pulumi.set(__self__, "container_network_interfaces", container_network_interfaces)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if ip_configurations is not None:
              pulumi.set(__self__, "ip_configurations", ip_configurations)
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter(name="containerNetworkInterfaces")
      def container_network_interfaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]:
          """
          A list of container network interfaces created from this container network interface configuration.
          """
          return pulumi.get(self, "container_network_interfaces")
  
      @container_network_interfaces.setter
      def container_network_interfaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]]):
          pulumi.set(self, "container_network_interfaces", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="ipConfigurations")
      def ip_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IPConfigurationProfileArgs']]]]:
          """
          A list of ip configurations of the container network interface configuration.
          """
          return pulumi.get(self, "ip_configurations")
  
      @ip_configurations.setter
      def ip_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['IPConfigurationProfileArgs']]]]):
          pulumi.set(self, "ip_configurations", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class ContainerNetworkInterfaceIpConfigurationArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None):
          """
          The ip configuration for a container network interface.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] name: The name of the resource. This name can be used to access the resource.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class DdosSettingsArgs:
      def __init__(__self__, *,
                   ddos_custom_policy: Optional[pulumi.Input['SubResourceArgs']] = None,
                   protection_coverage: Optional[pulumi.Input[str]] = None):
          """
          Contains the DDoS protection settings of the public IP.
          :param pulumi.Input['SubResourceArgs'] ddos_custom_policy: The DDoS custom policy associated with the public IP.
          :param pulumi.Input[str] protection_coverage: The DDoS protection policy customizability of the public IP. Only standard coverage will have the ability to be customized.
          """
          if ddos_custom_policy is not None:
              pulumi.set(__self__, "ddos_custom_policy", ddos_custom_policy)
          if protection_coverage is not None:
              pulumi.set(__self__, "protection_coverage", protection_coverage)
  
      @property
      @pulumi.getter(name="ddosCustomPolicy")
      def ddos_custom_policy(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          The DDoS custom policy associated with the public IP.
          """
          return pulumi.get(self, "ddos_custom_policy")
  
      @ddos_custom_policy.setter
      def ddos_custom_policy(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "ddos_custom_policy", value)
  
      @property
      @pulumi.getter(name="protectionCoverage")
      def protection_coverage(self) -> Optional[pulumi.Input[str]]:
          """
          The DDoS protection policy customizability of the public IP. Only standard coverage will have the ability to be customized.
          """
          return pulumi.get(self, "protection_coverage")
  
      @protection_coverage.setter
      def protection_coverage(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "protection_coverage", value)
  
  
  @pulumi.input_type
  class DelegationArgs:
      def __init__(__self__, *,
                   actions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   service_name: Optional[pulumi.Input[str]] = None):
          """
          Details the service to which the subnet is delegated.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] actions: Describes the actions permitted to the service upon delegation
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a subnet. This name can be used to access the resource.
          :param pulumi.Input[str] service_name: The name of the service to whom the subnet should be delegated (e.g. Microsoft.Sql/servers)
          """
          if actions is not None:
              pulumi.set(__self__, "actions", actions)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if service_name is not None:
              pulumi.set(__self__, "service_name", service_name)
  
      @property
      @pulumi.getter
      def actions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          Describes the actions permitted to the service upon delegation
          """
          return pulumi.get(self, "actions")
  
      @actions.setter
      def actions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "actions", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a subnet. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="serviceName")
      def service_name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the service to whom the subnet should be delegated (e.g. Microsoft.Sql/servers)
          """
          return pulumi.get(self, "service_name")
  
      @service_name.setter
      def service_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "service_name", value)
  
  
  @pulumi.input_type
  class DevicePropertiesArgs:
      def __init__(__self__, *,
                   device_model: Optional[pulumi.Input[str]] = None,
                   device_vendor: Optional[pulumi.Input[str]] = None,
                   link_speed_in_mbps: Optional[pulumi.Input[int]] = None):
          """
          List of properties of the device.
          :param pulumi.Input[str] device_model: Model of the device.
          :param pulumi.Input[str] device_vendor: Name of the device Vendor.
          :param pulumi.Input[int] link_speed_in_mbps: Link speed.
          """
          if device_model is not None:
              pulumi.set(__self__, "device_model", device_model)
          if device_vendor is not None:
              pulumi.set(__self__, "device_vendor", device_vendor)
          if link_speed_in_mbps is not None:
              pulumi.set(__self__, "link_speed_in_mbps", link_speed_in_mbps)
  
      @property
      @pulumi.getter(name="deviceModel")
      def device_model(self) -> Optional[pulumi.Input[str]]:
          """
          Model of the device.
          """
          return pulumi.get(self, "device_model")
  
      @device_model.setter
      def device_model(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "device_model", value)
  
      @property
      @pulumi.getter(name="deviceVendor")
      def device_vendor(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the device Vendor.
          """
          return pulumi.get(self, "device_vendor")
  
      @device_vendor.setter
      def device_vendor(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "device_vendor", value)
  
      @property
      @pulumi.getter(name="linkSpeedInMbps")
      def link_speed_in_mbps(self) -> Optional[pulumi.Input[int]]:
          """
          Link speed.
          """
          return pulumi.get(self, "link_speed_in_mbps")
  
      @link_speed_in_mbps.setter
      def link_speed_in_mbps(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "link_speed_in_mbps", value)
  
  
  @pulumi.input_type
  class DhcpOptionsArgs:
      def __init__(__self__, *,
                   dns_servers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          DhcpOptions contains an array of DNS servers available to VMs deployed in the virtual network. Standard DHCP option for a subnet overrides VNET DHCP options.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] dns_servers: The list of DNS servers IP addresses.
          """
          if dns_servers is not None:
              pulumi.set(__self__, "dns_servers", dns_servers)
  
      @property
      @pulumi.getter(name="dnsServers")
      def dns_servers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          The list of DNS servers IP addresses.
          """
          return pulumi.get(self, "dns_servers")
  
      @dns_servers.setter
      def dns_servers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "dns_servers", value)
  
  
  @pulumi.input_type
  class EndpointServiceArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None):
          """
          Identifies the service being brought into the virtual network.
          :param pulumi.Input[str] id: A unique identifier of the service being referenced by the interface endpoint.
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          A unique identifier of the service being referenced by the interface endpoint.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
  
  @pulumi.input_type
  class ExpressRouteCircuitAuthorizationArgs:
      def __init__(__self__, *,
                   authorization_key: Optional[pulumi.Input[str]] = None,
                   authorization_use_status: Optional[pulumi.Input[Union[str, 'AuthorizationUseStatus']]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None):
          """
          Authorization in an ExpressRouteCircuit resource.
          :param pulumi.Input[str] authorization_key: The authorization key.
          :param pulumi.Input[Union[str, 'AuthorizationUseStatus']] authorization_use_status: AuthorizationUseStatus. Possible values are: 'Available' and 'InUse'.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[str] provisioning_state: Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          if authorization_key is not None:
              pulumi.set(__self__, "authorization_key", authorization_key)
          if authorization_use_status is not None:
              pulumi.set(__self__, "authorization_use_status", authorization_use_status)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
  
      @property
      @pulumi.getter(name="authorizationKey")
      def authorization_key(self) -> Optional[pulumi.Input[str]]:
          """
          The authorization key.
          """
          return pulumi.get(self, "authorization_key")
  
      @authorization_key.setter
      def authorization_key(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "authorization_key", value)
  
      @property
      @pulumi.getter(name="authorizationUseStatus")
      def authorization_use_status(self) -> Optional[pulumi.Input[Union[str, 'AuthorizationUseStatus']]]:
          """
          AuthorizationUseStatus. Possible values are: 'Available' and 'InUse'.
          """
          return pulumi.get(self, "authorization_use_status")
  
      @authorization_use_status.setter
      def authorization_use_status(self, value: Optional[pulumi.Input[Union[str, 'AuthorizationUseStatus']]]):
          pulumi.set(self, "authorization_use_status", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
  
  @pulumi.input_type
  class ExpressRouteCircuitConnectionArgs:
      def __init__(__self__, *,
                   address_prefix: Optional[pulumi.Input[str]] = None,
                   authorization_key: Optional[pulumi.Input[str]] = None,
                   express_route_circuit_peering: Optional[pulumi.Input['SubResourceArgs']] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   peer_express_route_circuit_peering: Optional[pulumi.Input['SubResourceArgs']] = None):
          """
          Express Route Circuit Connection in an ExpressRouteCircuitPeering resource.
          :param pulumi.Input[str] address_prefix: /29 IP address space to carve out Customer addresses for tunnels.
          :param pulumi.Input[str] authorization_key: The authorization key.
          :param pulumi.Input['SubResourceArgs'] express_route_circuit_peering: Reference to Express Route Circuit Private Peering Resource of the circuit initiating connection.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input['SubResourceArgs'] peer_express_route_circuit_peering: Reference to Express Route Circuit Private Peering Resource of the peered circuit.
          """
          if address_prefix is not None:
              pulumi.set(__self__, "address_prefix", address_prefix)
          if authorization_key is not None:
              pulumi.set(__self__, "authorization_key", authorization_key)
          if express_route_circuit_peering is not None:
              pulumi.set(__self__, "express_route_circuit_peering", express_route_circuit_peering)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if peer_express_route_circuit_peering is not None:
              pulumi.set(__self__, "peer_express_route_circuit_peering", peer_express_route_circuit_peering)
  
      @property
      @pulumi.getter(name="addressPrefix")
      def address_prefix(self) -> Optional[pulumi.Input[str]]:
          """
          /29 IP address space to carve out Customer addresses for tunnels.
          """
          return pulumi.get(self, "address_prefix")
  
      @address_prefix.setter
      def address_prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "address_prefix", value)
  
      @property
      @pulumi.getter(name="authorizationKey")
      def authorization_key(self) -> Optional[pulumi.Input[str]]:
          """
          The authorization key.
          """
          return pulumi.get(self, "authorization_key")
  
      @authorization_key.setter
      def authorization_key(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "authorization_key", value)
  
      @property
      @pulumi.getter(name="expressRouteCircuitPeering")
      def express_route_circuit_peering(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Reference to Express Route Circuit Private Peering Resource of the circuit initiating connection.
          """
          return pulumi.get(self, "express_route_circuit_peering")
  
      @express_route_circuit_peering.setter
      def express_route_circuit_peering(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "express_route_circuit_peering", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="peerExpressRouteCircuitPeering")
      def peer_express_route_circuit_peering(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Reference to Express Route Circuit Private Peering Resource of the peered circuit.
          """
          return pulumi.get(self, "peer_express_route_circuit_peering")
  
      @peer_express_route_circuit_peering.setter
      def peer_express_route_circuit_peering(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "peer_express_route_circuit_peering", value)
  
  
  @pulumi.input_type
  class ExpressRouteCircuitPeeringArgs:
      def __init__(__self__, *,
                   azure_asn: Optional[pulumi.Input[int]] = None,
                   connections: Optional[pulumi.Input[Sequence[pulumi.Input['ExpressRouteCircuitConnectionArgs']]]] = None,
                   gateway_manager_etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   ipv6_peering_config: Optional[pulumi.Input['Ipv6ExpressRouteCircuitPeeringConfigArgs']] = None,
                   last_modified_by: Optional[pulumi.Input[str]] = None,
                   microsoft_peering_config: Optional[pulumi.Input['ExpressRouteCircuitPeeringConfigArgs']] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   peer_asn: Optional[pulumi.Input[float]] = None,
                   peering_type: Optional[pulumi.Input[Union[str, 'ExpressRoutePeeringType']]] = None,
                   primary_azure_port: Optional[pulumi.Input[str]] = None,
                   primary_peer_address_prefix: Optional[pulumi.Input[str]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   route_filter: Optional[pulumi.Input['RouteFilterArgs']] = None,
                   secondary_azure_port: Optional[pulumi.Input[str]] = None,
                   secondary_peer_address_prefix: Optional[pulumi.Input[str]] = None,
                   shared_key: Optional[pulumi.Input[str]] = None,
                   state: Optional[pulumi.Input[Union[str, 'ExpressRoutePeeringState']]] = None,
                   stats: Optional[pulumi.Input['ExpressRouteCircuitStatsArgs']] = None,
                   vlan_id: Optional[pulumi.Input[int]] = None):
          """
          Peering in an ExpressRouteCircuit resource.
          :param pulumi.Input[int] azure_asn: The Azure ASN.
          :param pulumi.Input[Sequence[pulumi.Input['ExpressRouteCircuitConnectionArgs']]] connections: The list of circuit connections associated with Azure Private Peering for this circuit.
          :param pulumi.Input[str] gateway_manager_etag: The GatewayManager Etag.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input['Ipv6ExpressRouteCircuitPeeringConfigArgs'] ipv6_peering_config: The IPv6 peering configuration.
          :param pulumi.Input[str] last_modified_by: Gets whether the provider or the customer last modified the peering.
          :param pulumi.Input['ExpressRouteCircuitPeeringConfigArgs'] microsoft_peering_config: The Microsoft peering configuration.
          :param pulumi.Input[str] name: Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[float] peer_asn: The peer ASN.
          :param pulumi.Input[Union[str, 'ExpressRoutePeeringType']] peering_type: The peering type.
          :param pulumi.Input[str] primary_azure_port: The primary port.
          :param pulumi.Input[str] primary_peer_address_prefix: The primary address prefix.
          :param pulumi.Input[str] provisioning_state: Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input['RouteFilterArgs'] route_filter: The reference of the RouteFilter resource.
          :param pulumi.Input[str] secondary_azure_port: The secondary port.
          :param pulumi.Input[str] secondary_peer_address_prefix: The secondary address prefix.
          :param pulumi.Input[str] shared_key: The shared key.
          :param pulumi.Input[Union[str, 'ExpressRoutePeeringState']] state: The peering state.
          :param pulumi.Input['ExpressRouteCircuitStatsArgs'] stats: Gets peering stats.
          :param pulumi.Input[int] vlan_id: The VLAN ID.
          """
          if azure_asn is not None:
              pulumi.set(__self__, "azure_asn", azure_asn)
          if connections is not None:
              pulumi.set(__self__, "connections", connections)
          if gateway_manager_etag is not None:
              pulumi.set(__self__, "gateway_manager_etag", gateway_manager_etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if ipv6_peering_config is not None:
              pulumi.set(__self__, "ipv6_peering_config", ipv6_peering_config)
          if last_modified_by is not None:
              pulumi.set(__self__, "last_modified_by", last_modified_by)
          if microsoft_peering_config is not None:
              pulumi.set(__self__, "microsoft_peering_config", microsoft_peering_config)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if peer_asn is not None:
              pulumi.set(__self__, "peer_asn", peer_asn)
          if peering_type is not None:
              pulumi.set(__self__, "peering_type", peering_type)
          if primary_azure_port is not None:
              pulumi.set(__self__, "primary_azure_port", primary_azure_port)
          if primary_peer_address_prefix is not None:
              pulumi.set(__self__, "primary_peer_address_prefix", primary_peer_address_prefix)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if route_filter is not None:
              pulumi.set(__self__, "route_filter", route_filter)
          if secondary_azure_port is not None:
              pulumi.set(__self__, "secondary_azure_port", secondary_azure_port)
          if secondary_peer_address_prefix is not None:
              pulumi.set(__self__, "secondary_peer_address_prefix", secondary_peer_address_prefix)
          if shared_key is not None:
              pulumi.set(__self__, "shared_key", shared_key)
          if state is not None:
              pulumi.set(__self__, "state", state)
          if stats is not None:
              pulumi.set(__self__, "stats", stats)
          if vlan_id is not None:
              pulumi.set(__self__, "vlan_id", vlan_id)
  
      @property
      @pulumi.getter(name="azureASN")
      def azure_asn(self) -> Optional[pulumi.Input[int]]:
          """
          The Azure ASN.
          """
          return pulumi.get(self, "azure_asn")
  
      @azure_asn.setter
      def azure_asn(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "azure_asn", value)
  
      @property
      @pulumi.getter
      def connections(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ExpressRouteCircuitConnectionArgs']]]]:
          """
          The list of circuit connections associated with Azure Private Peering for this circuit.
          """
          return pulumi.get(self, "connections")
  
      @connections.setter
      def connections(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ExpressRouteCircuitConnectionArgs']]]]):
          pulumi.set(self, "connections", value)
  
      @property
      @pulumi.getter(name="gatewayManagerEtag")
      def gateway_manager_etag(self) -> Optional[pulumi.Input[str]]:
          """
          The GatewayManager Etag.
          """
          return pulumi.get(self, "gateway_manager_etag")
  
      @gateway_manager_etag.setter
      def gateway_manager_etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "gateway_manager_etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="ipv6PeeringConfig")
      def ipv6_peering_config(self) -> Optional[pulumi.Input['Ipv6ExpressRouteCircuitPeeringConfigArgs']]:
          """
          The IPv6 peering configuration.
          """
          return pulumi.get(self, "ipv6_peering_config")
  
      @ipv6_peering_config.setter
      def ipv6_peering_config(self, value: Optional[pulumi.Input['Ipv6ExpressRouteCircuitPeeringConfigArgs']]):
          pulumi.set(self, "ipv6_peering_config", value)
  
      @property
      @pulumi.getter(name="lastModifiedBy")
      def last_modified_by(self) -> Optional[pulumi.Input[str]]:
          """
          Gets whether the provider or the customer last modified the peering.
          """
          return pulumi.get(self, "last_modified_by")
  
      @last_modified_by.setter
      def last_modified_by(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "last_modified_by", value)
  
      @property
      @pulumi.getter(name="microsoftPeeringConfig")
      def microsoft_peering_config(self) -> Optional[pulumi.Input['ExpressRouteCircuitPeeringConfigArgs']]:
          """
          The Microsoft peering configuration.
          """
          return pulumi.get(self, "microsoft_peering_config")
  
      @microsoft_peering_config.setter
      def microsoft_peering_config(self, value: Optional[pulumi.Input['ExpressRouteCircuitPeeringConfigArgs']]):
          pulumi.set(self, "microsoft_peering_config", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="peerASN")
      def peer_asn(self) -> Optional[pulumi.Input[float]]:
          """
          The peer ASN.
          """
          return pulumi.get(self, "peer_asn")
  
      @peer_asn.setter
      def peer_asn(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "peer_asn", value)
  
      @property
      @pulumi.getter(name="peeringType")
      def peering_type(self) -> Optional[pulumi.Input[Union[str, 'ExpressRoutePeeringType']]]:
          """
          The peering type.
          """
          return pulumi.get(self, "peering_type")
  
      @peering_type.setter
      def peering_type(self, value: Optional[pulumi.Input[Union[str, 'ExpressRoutePeeringType']]]):
          pulumi.set(self, "peering_type", value)
  
      @property
      @pulumi.getter(name="primaryAzurePort")
      def primary_azure_port(self) -> Optional[pulumi.Input[str]]:
          """
          The primary port.
          """
          return pulumi.get(self, "primary_azure_port")
  
      @primary_azure_port.setter
      def primary_azure_port(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "primary_azure_port", value)
  
      @property
      @pulumi.getter(name="primaryPeerAddressPrefix")
      def primary_peer_address_prefix(self) -> Optional[pulumi.Input[str]]:
          """
          The primary address prefix.
          """
          return pulumi.get(self, "primary_peer_address_prefix")
  
      @primary_peer_address_prefix.setter
      def primary_peer_address_prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "primary_peer_address_prefix", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter(name="routeFilter")
      def route_filter(self) -> Optional[pulumi.Input['RouteFilterArgs']]:
          """
          The reference of the RouteFilter resource.
          """
          return pulumi.get(self, "route_filter")
  
      @route_filter.setter
      def route_filter(self, value: Optional[pulumi.Input['RouteFilterArgs']]):
          pulumi.set(self, "route_filter", value)
  
      @property
      @pulumi.getter(name="secondaryAzurePort")
      def secondary_azure_port(self) -> Optional[pulumi.Input[str]]:
          """
          The secondary port.
          """
          return pulumi.get(self, "secondary_azure_port")
  
      @secondary_azure_port.setter
      def secondary_azure_port(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "secondary_azure_port", value)
  
      @property
      @pulumi.getter(name="secondaryPeerAddressPrefix")
      def secondary_peer_address_prefix(self) -> Optional[pulumi.Input[str]]:
          """
          The secondary address prefix.
          """
          return pulumi.get(self, "secondary_peer_address_prefix")
  
      @secondary_peer_address_prefix.setter
      def secondary_peer_address_prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "secondary_peer_address_prefix", value)
  
      @property
      @pulumi.getter(name="sharedKey")
      def shared_key(self) -> Optional[pulumi.Input[str]]:
          """
          The shared key.
          """
          return pulumi.get(self, "shared_key")
  
      @shared_key.setter
      def shared_key(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "shared_key", value)
  
      @property
      @pulumi.getter
      def state(self) -> Optional[pulumi.Input[Union[str, 'ExpressRoutePeeringState']]]:
          """
          The peering state.
          """
          return pulumi.get(self, "state")
  
      @state.setter
      def state(self, value: Optional[pulumi.Input[Union[str, 'ExpressRoutePeeringState']]]):
          pulumi.set(self, "state", value)
  
      @property
      @pulumi.getter
      def stats(self) -> Optional[pulumi.Input['ExpressRouteCircuitStatsArgs']]:
          """
          Gets peering stats.
          """
          return pulumi.get(self, "stats")
  
      @stats.setter
      def stats(self, value: Optional[pulumi.Input['ExpressRouteCircuitStatsArgs']]):
          pulumi.set(self, "stats", value)
  
      @property
      @pulumi.getter(name="vlanId")
      def vlan_id(self) -> Optional[pulumi.Input[int]]:
          """
          The VLAN ID.
          """
          return pulumi.get(self, "vlan_id")
  
      @vlan_id.setter
      def vlan_id(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "vlan_id", value)
  
  
  @pulumi.input_type
  class ExpressRouteCircuitPeeringConfigArgs:
      def __init__(__self__, *,
                   advertised_communities: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   advertised_public_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   advertised_public_prefixes_state: Optional[pulumi.Input[Union[str, 'ExpressRouteCircuitPeeringAdvertisedPublicPrefixState']]] = None,
                   customer_asn: Optional[pulumi.Input[int]] = None,
                   legacy_mode: Optional[pulumi.Input[int]] = None,
                   routing_registry_name: Optional[pulumi.Input[str]] = None):
          """
          Specifies the peering configuration.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] advertised_communities: The communities of bgp peering. Specified for microsoft peering
          :param pulumi.Input[Sequence[pulumi.Input[str]]] advertised_public_prefixes: The reference of AdvertisedPublicPrefixes.
          :param pulumi.Input[Union[str, 'ExpressRouteCircuitPeeringAdvertisedPublicPrefixState']] advertised_public_prefixes_state: AdvertisedPublicPrefixState of the Peering resource. Possible values are 'NotConfigured', 'Configuring', 'Configured', and 'ValidationNeeded'.
          :param pulumi.Input[int] customer_asn: The CustomerASN of the peering.
          :param pulumi.Input[int] legacy_mode: The legacy mode of the peering.
          :param pulumi.Input[str] routing_registry_name: The RoutingRegistryName of the configuration.
          """
          if advertised_communities is not None:
              pulumi.set(__self__, "advertised_communities", advertised_communities)
          if advertised_public_prefixes is not None:
              pulumi.set(__self__, "advertised_public_prefixes", advertised_public_prefixes)
          if advertised_public_prefixes_state is not None:
              pulumi.set(__self__, "advertised_public_prefixes_state", advertised_public_prefixes_state)
          if customer_asn is not None:
              pulumi.set(__self__, "customer_asn", customer_asn)
          if legacy_mode is not None:
              pulumi.set(__self__, "legacy_mode", legacy_mode)
          if routing_registry_name is not None:
              pulumi.set(__self__, "routing_registry_name", routing_registry_name)
  
      @property
      @pulumi.getter(name="advertisedCommunities")
      def advertised_communities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          The communities of bgp peering. Specified for microsoft peering
          """
          return pulumi.get(self, "advertised_communities")
  
      @advertised_communities.setter
      def advertised_communities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "advertised_communities", value)
  
      @property
      @pulumi.getter(name="advertisedPublicPrefixes")
      def advertised_public_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          The reference of AdvertisedPublicPrefixes.
          """
          return pulumi.get(self, "advertised_public_prefixes")
  
      @advertised_public_prefixes.setter
      def advertised_public_prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "advertised_public_prefixes", value)
  
      @property
      @pulumi.getter(name="advertisedPublicPrefixesState")
      def advertised_public_prefixes_state(self) -> Optional[pulumi.Input[Union[str, 'ExpressRouteCircuitPeeringAdvertisedPublicPrefixState']]]:
          """
          AdvertisedPublicPrefixState of the Peering resource. Possible values are 'NotConfigured', 'Configuring', 'Configured', and 'ValidationNeeded'.
          """
          return pulumi.get(self, "advertised_public_prefixes_state")
  
      @advertised_public_prefixes_state.setter
      def advertised_public_prefixes_state(self, value: Optional[pulumi.Input[Union[str, 'ExpressRouteCircuitPeeringAdvertisedPublicPrefixState']]]):
          pulumi.set(self, "advertised_public_prefixes_state", value)
  
      @property
      @pulumi.getter(name="customerASN")
      def customer_asn(self) -> Optional[pulumi.Input[int]]:
          """
          The CustomerASN of the peering.
          """
          return pulumi.get(self, "customer_asn")
  
      @customer_asn.setter
      def customer_asn(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "customer_asn", value)
  
      @property
      @pulumi.getter(name="legacyMode")
      def legacy_mode(self) -> Optional[pulumi.Input[int]]:
          """
          The legacy mode of the peering.
          """
          return pulumi.get(self, "legacy_mode")
  
      @legacy_mode.setter
      def legacy_mode(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "legacy_mode", value)
  
      @property
      @pulumi.getter(name="routingRegistryName")
      def routing_registry_name(self) -> Optional[pulumi.Input[str]]:
          """
          The RoutingRegistryName of the configuration.
          """
          return pulumi.get(self, "routing_registry_name")
  
      @routing_registry_name.setter
      def routing_registry_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "routing_registry_name", value)
  
  
  @pulumi.input_type
  class ExpressRouteCircuitPeeringIdArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None):
          """
          ExpressRoute circuit peering identifier.
          :param pulumi.Input[str] id: The ID of the ExpressRoute circuit peering.
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the ExpressRoute circuit peering.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
  
  @pulumi.input_type
  class ExpressRouteCircuitServiceProviderPropertiesArgs:
      def __init__(__self__, *,
                   bandwidth_in_mbps: Optional[pulumi.Input[int]] = None,
                   peering_location: Optional[pulumi.Input[str]] = None,
                   service_provider_name: Optional[pulumi.Input[str]] = None):
          """
          Contains ServiceProviderProperties in an ExpressRouteCircuit.
          :param pulumi.Input[int] bandwidth_in_mbps: The BandwidthInMbps.
          :param pulumi.Input[str] peering_location: The peering location.
          :param pulumi.Input[str] service_provider_name: The serviceProviderName.
          """
          if bandwidth_in_mbps is not None:
              pulumi.set(__self__, "bandwidth_in_mbps", bandwidth_in_mbps)
          if peering_location is not None:
              pulumi.set(__self__, "peering_location", peering_location)
          if service_provider_name is not None:
              pulumi.set(__self__, "service_provider_name", service_provider_name)
  
      @property
      @pulumi.getter(name="bandwidthInMbps")
      def bandwidth_in_mbps(self) -> Optional[pulumi.Input[int]]:
          """
          The BandwidthInMbps.
          """
          return pulumi.get(self, "bandwidth_in_mbps")
  
      @bandwidth_in_mbps.setter
      def bandwidth_in_mbps(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "bandwidth_in_mbps", value)
  
      @property
      @pulumi.getter(name="peeringLocation")
      def peering_location(self) -> Optional[pulumi.Input[str]]:
          """
          The peering location.
          """
          return pulumi.get(self, "peering_location")
  
      @peering_location.setter
      def peering_location(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "peering_location", value)
  
      @property
      @pulumi.getter(name="serviceProviderName")
      def service_provider_name(self) -> Optional[pulumi.Input[str]]:
          """
          The serviceProviderName.
          """
          return pulumi.get(self, "service_provider_name")
  
      @service_provider_name.setter
      def service_provider_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "service_provider_name", value)
  
  
  @pulumi.input_type
  class ExpressRouteCircuitSkuArgs:
      def __init__(__self__, *,
                   family: Optional[pulumi.Input[Union[str, 'ExpressRouteCircuitSkuFamily']]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   tier: Optional[pulumi.Input[Union[str, 'ExpressRouteCircuitSkuTier']]] = None):
          """
          Contains SKU in an ExpressRouteCircuit.
          :param pulumi.Input[Union[str, 'ExpressRouteCircuitSkuFamily']] family: The family of the SKU. Possible values are: 'UnlimitedData' and 'MeteredData'.
          :param pulumi.Input[str] name: The name of the SKU.
          :param pulumi.Input[Union[str, 'ExpressRouteCircuitSkuTier']] tier: The tier of the SKU. Possible values are 'Standard', 'Premium' or 'Basic'.
          """
          if family is not None:
              pulumi.set(__self__, "family", family)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if tier is not None:
              pulumi.set(__self__, "tier", tier)
  
      @property
      @pulumi.getter
      def family(self) -> Optional[pulumi.Input[Union[str, 'ExpressRouteCircuitSkuFamily']]]:
          """
          The family of the SKU. Possible values are: 'UnlimitedData' and 'MeteredData'.
          """
          return pulumi.get(self, "family")
  
      @family.setter
      def family(self, value: Optional[pulumi.Input[Union[str, 'ExpressRouteCircuitSkuFamily']]]):
          pulumi.set(self, "family", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the SKU.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def tier(self) -> Optional[pulumi.Input[Union[str, 'ExpressRouteCircuitSkuTier']]]:
          """
          The tier of the SKU. Possible values are 'Standard', 'Premium' or 'Basic'.
          """
          return pulumi.get(self, "tier")
  
      @tier.setter
      def tier(self, value: Optional[pulumi.Input[Union[str, 'ExpressRouteCircuitSkuTier']]]):
          pulumi.set(self, "tier", value)
  
  
  @pulumi.input_type
  class ExpressRouteCircuitStatsArgs:
      def __init__(__self__, *,
                   primarybytes_in: Optional[pulumi.Input[float]] = None,
                   primarybytes_out: Optional[pulumi.Input[float]] = None,
                   secondarybytes_in: Optional[pulumi.Input[float]] = None,
                   secondarybytes_out: Optional[pulumi.Input[float]] = None):
          """
          Contains stats associated with the peering.
          :param pulumi.Input[float] primarybytes_in: Gets BytesIn of the peering.
          :param pulumi.Input[float] primarybytes_out: Gets BytesOut of the peering.
          :param pulumi.Input[float] secondarybytes_in: Gets BytesIn of the peering.
          :param pulumi.Input[float] secondarybytes_out: Gets BytesOut of the peering.
          """
          if primarybytes_in is not None:
              pulumi.set(__self__, "primarybytes_in", primarybytes_in)
          if primarybytes_out is not None:
              pulumi.set(__self__, "primarybytes_out", primarybytes_out)
          if secondarybytes_in is not None:
              pulumi.set(__self__, "secondarybytes_in", secondarybytes_in)
          if secondarybytes_out is not None:
              pulumi.set(__self__, "secondarybytes_out", secondarybytes_out)
  
      @property
      @pulumi.getter(name="primarybytesIn")
      def primarybytes_in(self) -> Optional[pulumi.Input[float]]:
          """
          Gets BytesIn of the peering.
          """
          return pulumi.get(self, "primarybytes_in")
  
      @primarybytes_in.setter
      def primarybytes_in(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "primarybytes_in", value)
  
      @property
      @pulumi.getter(name="primarybytesOut")
      def primarybytes_out(self) -> Optional[pulumi.Input[float]]:
          """
          Gets BytesOut of the peering.
          """
          return pulumi.get(self, "primarybytes_out")
  
      @primarybytes_out.setter
      def primarybytes_out(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "primarybytes_out", value)
  
      @property
      @pulumi.getter(name="secondarybytesIn")
      def secondarybytes_in(self) -> Optional[pulumi.Input[float]]:
          """
          Gets BytesIn of the peering.
          """
          return pulumi.get(self, "secondarybytes_in")
  
      @secondarybytes_in.setter
      def secondarybytes_in(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "secondarybytes_in", value)
  
      @property
      @pulumi.getter(name="secondarybytesOut")
      def secondarybytes_out(self) -> Optional[pulumi.Input[float]]:
          """
          Gets BytesOut of the peering.
          """
          return pulumi.get(self, "secondarybytes_out")
  
      @secondarybytes_out.setter
      def secondarybytes_out(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "secondarybytes_out", value)
  
  
  @pulumi.input_type
  class ExpressRouteGatewayPropertiesAutoScaleConfigurationArgs:
      def __init__(__self__, *,
                   bounds: Optional[pulumi.Input['ExpressRouteGatewayPropertiesBoundsArgs']] = None):
          """
          Configuration for auto scaling.
          :param pulumi.Input['ExpressRouteGatewayPropertiesBoundsArgs'] bounds: Minimum and maximum number of scale units to deploy.
          """
          if bounds is not None:
              pulumi.set(__self__, "bounds", bounds)
  
      @property
      @pulumi.getter
      def bounds(self) -> Optional[pulumi.Input['ExpressRouteGatewayPropertiesBoundsArgs']]:
          """
          Minimum and maximum number of scale units to deploy.
          """
          return pulumi.get(self, "bounds")
  
      @bounds.setter
      def bounds(self, value: Optional[pulumi.Input['ExpressRouteGatewayPropertiesBoundsArgs']]):
          pulumi.set(self, "bounds", value)
  
  
  @pulumi.input_type
  class ExpressRouteGatewayPropertiesBoundsArgs:
      def __init__(__self__, *,
                   max: Optional[pulumi.Input[int]] = None,
                   min: Optional[pulumi.Input[int]] = None):
          """
          Minimum and maximum number of scale units to deploy.
          :param pulumi.Input[int] max: Maximum number of scale units deployed for ExpressRoute gateway.
          :param pulumi.Input[int] min: Minimum number of scale units deployed for ExpressRoute gateway.
          """
          if max is not None:
              pulumi.set(__self__, "max", max)
          if min is not None:
              pulumi.set(__self__, "min", min)
  
      @property
      @pulumi.getter
      def max(self) -> Optional[pulumi.Input[int]]:
          """
          Maximum number of scale units deployed for ExpressRoute gateway.
          """
          return pulumi.get(self, "max")
  
      @max.setter
      def max(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max", value)
  
      @property
      @pulumi.getter
      def min(self) -> Optional[pulumi.Input[int]]:
          """
          Minimum number of scale units deployed for ExpressRoute gateway.
          """
          return pulumi.get(self, "min")
  
      @min.setter
      def min(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "min", value)
  
  
  @pulumi.input_type
  class ExpressRouteLinkArgs:
      def __init__(__self__, *,
                   admin_state: Optional[pulumi.Input[Union[str, 'ExpressRouteLinkAdminState']]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None):
          """
          ExpressRouteLink child resource definition.
          :param pulumi.Input[Union[str, 'ExpressRouteLinkAdminState']] admin_state: Administrative state of the physical port
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: Name of child port resource that is unique among child port resources of the parent.
          """
          if admin_state is not None:
              pulumi.set(__self__, "admin_state", admin_state)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter(name="adminState")
      def admin_state(self) -> Optional[pulumi.Input[Union[str, 'ExpressRouteLinkAdminState']]]:
          """
          Administrative state of the physical port
          """
          return pulumi.get(self, "admin_state")
  
      @admin_state.setter
      def admin_state(self, value: Optional[pulumi.Input[Union[str, 'ExpressRouteLinkAdminState']]]):
          pulumi.set(self, "admin_state", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of child port resource that is unique among child port resources of the parent.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class FrontendIPConfigurationArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   private_ip_address: Optional[pulumi.Input[str]] = None,
                   private_ip_allocation_method: Optional[pulumi.Input[Union[str, 'IPAllocationMethod']]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   public_ip_address: Optional[pulumi.Input['PublicIPAddressArgs']] = None,
                   public_ip_prefix: Optional[pulumi.Input['SubResourceArgs']] = None,
                   subnet: Optional[pulumi.Input['SubnetArgs']] = None,
                   zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          Frontend IP address of the load balancer.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[str] private_ip_address: The private IP address of the IP configuration.
          :param pulumi.Input[Union[str, 'IPAllocationMethod']] private_ip_allocation_method: The Private IP allocation method. Possible values are: 'Static' and 'Dynamic'.
          :param pulumi.Input[str] provisioning_state: Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input['PublicIPAddressArgs'] public_ip_address: The reference of the Public IP resource.
          :param pulumi.Input['SubResourceArgs'] public_ip_prefix: The reference of the Public IP Prefix resource.
          :param pulumi.Input['SubnetArgs'] subnet: The reference of the subnet resource.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] zones: A list of availability zones denoting the IP allocated for the resource needs to come from.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if private_ip_address is not None:
              pulumi.set(__self__, "private_ip_address", private_ip_address)
          if private_ip_allocation_method is not None:
              pulumi.set(__self__, "private_ip_allocation_method", private_ip_allocation_method)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if public_ip_address is not None:
              pulumi.set(__self__, "public_ip_address", public_ip_address)
          if public_ip_prefix is not None:
              pulumi.set(__self__, "public_ip_prefix", public_ip_prefix)
          if subnet is not None:
              pulumi.set(__self__, "subnet", subnet)
          if zones is not None:
              pulumi.set(__self__, "zones", zones)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="privateIPAddress")
      def private_ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          The private IP address of the IP configuration.
          """
          return pulumi.get(self, "private_ip_address")
  
      @private_ip_address.setter
      def private_ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "private_ip_address", value)
  
      @property
      @pulumi.getter(name="privateIPAllocationMethod")
      def private_ip_allocation_method(self) -> Optional[pulumi.Input[Union[str, 'IPAllocationMethod']]]:
          """
          The Private IP allocation method. Possible values are: 'Static' and 'Dynamic'.
          """
          return pulumi.get(self, "private_ip_allocation_method")
  
      @private_ip_allocation_method.setter
      def private_ip_allocation_method(self, value: Optional[pulumi.Input[Union[str, 'IPAllocationMethod']]]):
          pulumi.set(self, "private_ip_allocation_method", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter(name="publicIPAddress")
      def public_ip_address(self) -> Optional[pulumi.Input['PublicIPAddressArgs']]:
          """
          The reference of the Public IP resource.
          """
          return pulumi.get(self, "public_ip_address")
  
      @public_ip_address.setter
      def public_ip_address(self, value: Optional[pulumi.Input['PublicIPAddressArgs']]):
          pulumi.set(self, "public_ip_address", value)
  
      @property
      @pulumi.getter(name="publicIPPrefix")
      def public_ip_prefix(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          The reference of the Public IP Prefix resource.
          """
          return pulumi.get(self, "public_ip_prefix")
  
      @public_ip_prefix.setter
      def public_ip_prefix(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "public_ip_prefix", value)
  
      @property
      @pulumi.getter
      def subnet(self) -> Optional[pulumi.Input['SubnetArgs']]:
          """
          The reference of the subnet resource.
          """
          return pulumi.get(self, "subnet")
  
      @subnet.setter
      def subnet(self, value: Optional[pulumi.Input['SubnetArgs']]):
          pulumi.set(self, "subnet", value)
  
      @property
      @pulumi.getter
      def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          A list of availability zones denoting the IP allocated for the resource needs to come from.
          """
          return pulumi.get(self, "zones")
  
      @zones.setter
      def zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "zones", value)
  
  
  @pulumi.input_type
  class HubVirtualNetworkConnectionArgs:
      def __init__(__self__, *,
                   allow_hub_to_remote_vnet_transit: Optional[pulumi.Input[bool]] = None,
                   allow_remote_vnet_to_use_hub_vnet_gateways: Optional[pulumi.Input[bool]] = None,
                   enable_internet_security: Optional[pulumi.Input[bool]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   remote_virtual_network: Optional[pulumi.Input['SubResourceArgs']] = None):
          """
          HubVirtualNetworkConnection Resource.
          :param pulumi.Input[bool] allow_hub_to_remote_vnet_transit: VirtualHub to RemoteVnet transit to enabled or not.
          :param pulumi.Input[bool] allow_remote_vnet_to_use_hub_vnet_gateways: Allow RemoteVnet to use Virtual Hub's gateways.
          :param pulumi.Input[bool] enable_internet_security: Enable internet security
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input['SubResourceArgs'] remote_virtual_network: Reference to the remote virtual network.
          """
          if allow_hub_to_remote_vnet_transit is not None:
              pulumi.set(__self__, "allow_hub_to_remote_vnet_transit", allow_hub_to_remote_vnet_transit)
          if allow_remote_vnet_to_use_hub_vnet_gateways is not None:
              pulumi.set(__self__, "allow_remote_vnet_to_use_hub_vnet_gateways", allow_remote_vnet_to_use_hub_vnet_gateways)
          if enable_internet_security is not None:
              pulumi.set(__self__, "enable_internet_security", enable_internet_security)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if remote_virtual_network is not None:
              pulumi.set(__self__, "remote_virtual_network", remote_virtual_network)
  
      @property
      @pulumi.getter(name="allowHubToRemoteVnetTransit")
      def allow_hub_to_remote_vnet_transit(self) -> Optional[pulumi.Input[bool]]:
          """
          VirtualHub to RemoteVnet transit to enabled or not.
          """
          return pulumi.get(self, "allow_hub_to_remote_vnet_transit")
  
      @allow_hub_to_remote_vnet_transit.setter
      def allow_hub_to_remote_vnet_transit(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "allow_hub_to_remote_vnet_transit", value)
  
      @property
      @pulumi.getter(name="allowRemoteVnetToUseHubVnetGateways")
      def allow_remote_vnet_to_use_hub_vnet_gateways(self) -> Optional[pulumi.Input[bool]]:
          """
          Allow RemoteVnet to use Virtual Hub's gateways.
          """
          return pulumi.get(self, "allow_remote_vnet_to_use_hub_vnet_gateways")
  
      @allow_remote_vnet_to_use_hub_vnet_gateways.setter
      def allow_remote_vnet_to_use_hub_vnet_gateways(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "allow_remote_vnet_to_use_hub_vnet_gateways", value)
  
      @property
      @pulumi.getter(name="enableInternetSecurity")
      def enable_internet_security(self) -> Optional[pulumi.Input[bool]]:
          """
          Enable internet security
          """
          return pulumi.get(self, "enable_internet_security")
  
      @enable_internet_security.setter
      def enable_internet_security(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_internet_security", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="remoteVirtualNetwork")
      def remote_virtual_network(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Reference to the remote virtual network.
          """
          return pulumi.get(self, "remote_virtual_network")
  
      @remote_virtual_network.setter
      def remote_virtual_network(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "remote_virtual_network", value)
  
  
  @pulumi.input_type
  class IPConfigurationProfileArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   subnet: Optional[pulumi.Input['SubnetArgs']] = None):
          """
          IP configuration profile child resource.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource. This name can be used to access the resource.
          :param pulumi.Input['SubnetArgs'] subnet: The reference of the subnet resource to create a container network interface ip configuration.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if subnet is not None:
              pulumi.set(__self__, "subnet", subnet)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def subnet(self) -> Optional[pulumi.Input['SubnetArgs']]:
          """
          The reference of the subnet resource to create a container network interface ip configuration.
          """
          return pulumi.get(self, "subnet")
  
      @subnet.setter
      def subnet(self, value: Optional[pulumi.Input['SubnetArgs']]):
          pulumi.set(self, "subnet", value)
  
  
  @pulumi.input_type
  class InboundNatPoolArgs:
      def __init__(__self__, *,
                   backend_port: pulumi.Input[int],
                   frontend_port_range_end: pulumi.Input[int],
                   frontend_port_range_start: pulumi.Input[int],
                   protocol: pulumi.Input[Union[str, 'TransportProtocol']],
                   enable_floating_ip: Optional[pulumi.Input[bool]] = None,
                   enable_tcp_reset: Optional[pulumi.Input[bool]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   frontend_ip_configuration: Optional[pulumi.Input['SubResourceArgs']] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   idle_timeout_in_minutes: Optional[pulumi.Input[int]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None):
          """
          Inbound NAT pool of the load balancer.
          :param pulumi.Input[int] backend_port: The port used for internal connections on the endpoint. Acceptable values are between 1 and 65535.
          :param pulumi.Input[int] frontend_port_range_end: The last port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with a load balancer. Acceptable values range between 1 and 65535.
          :param pulumi.Input[int] frontend_port_range_start: The first port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with a load balancer. Acceptable values range between 1 and 65534.
          :param pulumi.Input[Union[str, 'TransportProtocol']] protocol: The transport protocol for the endpoint. Possible values are 'Udp' or 'Tcp' or 'All'.
          :param pulumi.Input[bool] enable_floating_ip: Configures a virtual machine's endpoint for the floating IP capability required to configure a SQL AlwaysOn Availability Group. This setting is required when using the SQL AlwaysOn Availability Groups in SQL server. This setting can't be changed after you create the endpoint.
          :param pulumi.Input[bool] enable_tcp_reset: Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input['SubResourceArgs'] frontend_ip_configuration: A reference to frontend IP addresses.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[int] idle_timeout_in_minutes: The timeout for the TCP idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to TCP.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[str] provisioning_state: Gets the provisioning state of the PublicIP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          pulumi.set(__self__, "backend_port", backend_port)
          pulumi.set(__self__, "frontend_port_range_end", frontend_port_range_end)
          pulumi.set(__self__, "frontend_port_range_start", frontend_port_range_start)
          pulumi.set(__self__, "protocol", protocol)
          if enable_floating_ip is not None:
              pulumi.set(__self__, "enable_floating_ip", enable_floating_ip)
          if enable_tcp_reset is not None:
              pulumi.set(__self__, "enable_tcp_reset", enable_tcp_reset)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if frontend_ip_configuration is not None:
              pulumi.set(__self__, "frontend_ip_configuration", frontend_ip_configuration)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if idle_timeout_in_minutes is not None:
              pulumi.set(__self__, "idle_timeout_in_minutes", idle_timeout_in_minutes)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
  
      @property
      @pulumi.getter(name="backendPort")
      def backend_port(self) -> pulumi.Input[int]:
          """
          The port used for internal connections on the endpoint. Acceptable values are between 1 and 65535.
          """
          return pulumi.get(self, "backend_port")
  
      @backend_port.setter
      def backend_port(self, value: pulumi.Input[int]):
          pulumi.set(self, "backend_port", value)
  
      @property
      @pulumi.getter(name="frontendPortRangeEnd")
      def frontend_port_range_end(self) -> pulumi.Input[int]:
          """
          The last port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with a load balancer. Acceptable values range between 1 and 65535.
          """
          return pulumi.get(self, "frontend_port_range_end")
  
      @frontend_port_range_end.setter
      def frontend_port_range_end(self, value: pulumi.Input[int]):
          pulumi.set(self, "frontend_port_range_end", value)
  
      @property
      @pulumi.getter(name="frontendPortRangeStart")
      def frontend_port_range_start(self) -> pulumi.Input[int]:
          """
          The first port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with a load balancer. Acceptable values range between 1 and 65534.
          """
          return pulumi.get(self, "frontend_port_range_start")
  
      @frontend_port_range_start.setter
      def frontend_port_range_start(self, value: pulumi.Input[int]):
          pulumi.set(self, "frontend_port_range_start", value)
  
      @property
      @pulumi.getter
      def protocol(self) -> pulumi.Input[Union[str, 'TransportProtocol']]:
          """
          The transport protocol for the endpoint. Possible values are 'Udp' or 'Tcp' or 'All'.
          """
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: pulumi.Input[Union[str, 'TransportProtocol']]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter(name="enableFloatingIP")
      def enable_floating_ip(self) -> Optional[pulumi.Input[bool]]:
          """
          Configures a virtual machine's endpoint for the floating IP capability required to configure a SQL AlwaysOn Availability Group. This setting is required when using the SQL AlwaysOn Availability Groups in SQL server. This setting can't be changed after you create the endpoint.
          """
          return pulumi.get(self, "enable_floating_ip")
  
      @enable_floating_ip.setter
      def enable_floating_ip(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_floating_ip", value)
  
      @property
      @pulumi.getter(name="enableTcpReset")
      def enable_tcp_reset(self) -> Optional[pulumi.Input[bool]]:
          """
          Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
          """
          return pulumi.get(self, "enable_tcp_reset")
  
      @enable_tcp_reset.setter
      def enable_tcp_reset(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_tcp_reset", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter(name="frontendIPConfiguration")
      def frontend_ip_configuration(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          A reference to frontend IP addresses.
          """
          return pulumi.get(self, "frontend_ip_configuration")
  
      @frontend_ip_configuration.setter
      def frontend_ip_configuration(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "frontend_ip_configuration", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="idleTimeoutInMinutes")
      def idle_timeout_in_minutes(self) -> Optional[pulumi.Input[int]]:
          """
          The timeout for the TCP idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to TCP.
          """
          return pulumi.get(self, "idle_timeout_in_minutes")
  
      @idle_timeout_in_minutes.setter
      def idle_timeout_in_minutes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "idle_timeout_in_minutes", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Gets the provisioning state of the PublicIP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
  
  @pulumi.input_type
  class InboundNatRuleArgs:
      def __init__(__self__, *,
                   backend_port: Optional[pulumi.Input[int]] = None,
                   enable_floating_ip: Optional[pulumi.Input[bool]] = None,
                   enable_tcp_reset: Optional[pulumi.Input[bool]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   frontend_ip_configuration: Optional[pulumi.Input['SubResourceArgs']] = None,
                   frontend_port: Optional[pulumi.Input[int]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   idle_timeout_in_minutes: Optional[pulumi.Input[int]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   protocol: Optional[pulumi.Input[Union[str, 'TransportProtocol']]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None):
          """
          Inbound NAT rule of the load balancer.
          :param pulumi.Input[int] backend_port: The port used for the internal endpoint. Acceptable values range from 1 to 65535.
          :param pulumi.Input[bool] enable_floating_ip: Configures a virtual machine's endpoint for the floating IP capability required to configure a SQL AlwaysOn Availability Group. This setting is required when using the SQL AlwaysOn Availability Groups in SQL server. This setting can't be changed after you create the endpoint.
          :param pulumi.Input[bool] enable_tcp_reset: Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input['SubResourceArgs'] frontend_ip_configuration: A reference to frontend IP addresses.
          :param pulumi.Input[int] frontend_port: The port for the external endpoint. Port numbers for each rule must be unique within the Load Balancer. Acceptable values range from 1 to 65534.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[int] idle_timeout_in_minutes: The timeout for the TCP idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to TCP.
          :param pulumi.Input[str] name: Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[Union[str, 'TransportProtocol']] protocol: The transport protocol for the endpoint. Possible values are 'Udp' or 'Tcp' or 'All'.
          :param pulumi.Input[str] provisioning_state: Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          if backend_port is not None:
              pulumi.set(__self__, "backend_port", backend_port)
          if enable_floating_ip is not None:
              pulumi.set(__self__, "enable_floating_ip", enable_floating_ip)
          if enable_tcp_reset is not None:
              pulumi.set(__self__, "enable_tcp_reset", enable_tcp_reset)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if frontend_ip_configuration is not None:
              pulumi.set(__self__, "frontend_ip_configuration", frontend_ip_configuration)
          if frontend_port is not None:
              pulumi.set(__self__, "frontend_port", frontend_port)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if idle_timeout_in_minutes is not None:
              pulumi.set(__self__, "idle_timeout_in_minutes", idle_timeout_in_minutes)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if protocol is not None:
              pulumi.set(__self__, "protocol", protocol)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
  
      @property
      @pulumi.getter(name="backendPort")
      def backend_port(self) -> Optional[pulumi.Input[int]]:
          """
          The port used for the internal endpoint. Acceptable values range from 1 to 65535.
          """
          return pulumi.get(self, "backend_port")
  
      @backend_port.setter
      def backend_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "backend_port", value)
  
      @property
      @pulumi.getter(name="enableFloatingIP")
      def enable_floating_ip(self) -> Optional[pulumi.Input[bool]]:
          """
          Configures a virtual machine's endpoint for the floating IP capability required to configure a SQL AlwaysOn Availability Group. This setting is required when using the SQL AlwaysOn Availability Groups in SQL server. This setting can't be changed after you create the endpoint.
          """
          return pulumi.get(self, "enable_floating_ip")
  
      @enable_floating_ip.setter
      def enable_floating_ip(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_floating_ip", value)
  
      @property
      @pulumi.getter(name="enableTcpReset")
      def enable_tcp_reset(self) -> Optional[pulumi.Input[bool]]:
          """
          Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
          """
          return pulumi.get(self, "enable_tcp_reset")
  
      @enable_tcp_reset.setter
      def enable_tcp_reset(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_tcp_reset", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter(name="frontendIPConfiguration")
      def frontend_ip_configuration(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          A reference to frontend IP addresses.
          """
          return pulumi.get(self, "frontend_ip_configuration")
  
      @frontend_ip_configuration.setter
      def frontend_ip_configuration(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "frontend_ip_configuration", value)
  
      @property
      @pulumi.getter(name="frontendPort")
      def frontend_port(self) -> Optional[pulumi.Input[int]]:
          """
          The port for the external endpoint. Port numbers for each rule must be unique within the Load Balancer. Acceptable values range from 1 to 65534.
          """
          return pulumi.get(self, "frontend_port")
  
      @frontend_port.setter
      def frontend_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "frontend_port", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="idleTimeoutInMinutes")
      def idle_timeout_in_minutes(self) -> Optional[pulumi.Input[int]]:
          """
          The timeout for the TCP idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to TCP.
          """
          return pulumi.get(self, "idle_timeout_in_minutes")
  
      @idle_timeout_in_minutes.setter
      def idle_timeout_in_minutes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "idle_timeout_in_minutes", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def protocol(self) -> Optional[pulumi.Input[Union[str, 'TransportProtocol']]]:
          """
          The transport protocol for the endpoint. Possible values are 'Udp' or 'Tcp' or 'All'.
          """
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: Optional[pulumi.Input[Union[str, 'TransportProtocol']]]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
  
  @pulumi.input_type
  class IpTagArgs:
      def __init__(__self__, *,
                   ip_tag_type: Optional[pulumi.Input[str]] = None,
                   tag: Optional[pulumi.Input[str]] = None):
          """
          Contains the IpTag associated with the object
          :param pulumi.Input[str] ip_tag_type: Gets or sets the ipTag type: Example FirstPartyUsage.
          :param pulumi.Input[str] tag: Gets or sets value of the IpTag associated with the public IP. Example SQL, Storage etc
          """
          if ip_tag_type is not None:
              pulumi.set(__self__, "ip_tag_type", ip_tag_type)
          if tag is not None:
              pulumi.set(__self__, "tag", tag)
  
      @property
      @pulumi.getter(name="ipTagType")
      def ip_tag_type(self) -> Optional[pulumi.Input[str]]:
          """
          Gets or sets the ipTag type: Example FirstPartyUsage.
          """
          return pulumi.get(self, "ip_tag_type")
  
      @ip_tag_type.setter
      def ip_tag_type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "ip_tag_type", value)
  
      @property
      @pulumi.getter
      def tag(self) -> Optional[pulumi.Input[str]]:
          """
          Gets or sets value of the IpTag associated with the public IP. Example SQL, Storage etc
          """
          return pulumi.get(self, "tag")
  
      @tag.setter
      def tag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "tag", value)
  
  
  @pulumi.input_type
  class IpsecPolicyArgs:
      def __init__(__self__, *,
                   dh_group: pulumi.Input[Union[str, 'DhGroup']],
                   ike_encryption: pulumi.Input[Union[str, 'IkeEncryption']],
                   ike_integrity: pulumi.Input[Union[str, 'IkeIntegrity']],
                   ipsec_encryption: pulumi.Input[Union[str, 'IpsecEncryption']],
                   ipsec_integrity: pulumi.Input[Union[str, 'IpsecIntegrity']],
                   pfs_group: pulumi.Input[Union[str, 'PfsGroup']],
                   sa_data_size_kilobytes: pulumi.Input[int],
                   sa_life_time_seconds: pulumi.Input[int]):
          """
          An IPSec Policy configuration for a virtual network gateway connection
          :param pulumi.Input[Union[str, 'DhGroup']] dh_group: The DH Groups used in IKE Phase 1 for initial SA.
          :param pulumi.Input[Union[str, 'IkeEncryption']] ike_encryption: The IKE encryption algorithm (IKE phase 2).
          :param pulumi.Input[Union[str, 'IkeIntegrity']] ike_integrity: The IKE integrity algorithm (IKE phase 2).
          :param pulumi.Input[Union[str, 'IpsecEncryption']] ipsec_encryption: The IPSec encryption algorithm (IKE phase 1).
          :param pulumi.Input[Union[str, 'IpsecIntegrity']] ipsec_integrity: The IPSec integrity algorithm (IKE phase 1).
          :param pulumi.Input[Union[str, 'PfsGroup']] pfs_group: The Pfs Groups used in IKE Phase 2 for new child SA.
          :param pulumi.Input[int] sa_data_size_kilobytes: The IPSec Security Association (also called Quick Mode or Phase 2 SA) payload size in KB for a site to site VPN tunnel.
          :param pulumi.Input[int] sa_life_time_seconds: The IPSec Security Association (also called Quick Mode or Phase 2 SA) 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_life_time_seconds", sa_life_time_seconds)
  
      @property
      @pulumi.getter(name="dhGroup")
      def dh_group(self) -> pulumi.Input[Union[str, 'DhGroup']]:
          """
          The DH Groups used in IKE Phase 1 for initial SA.
          """
          return pulumi.get(self, "dh_group")
  
      @dh_group.setter
      def dh_group(self, value: pulumi.Input[Union[str, 'DhGroup']]):
          pulumi.set(self, "dh_group", value)
  
      @property
      @pulumi.getter(name="ikeEncryption")
      def ike_encryption(self) -> pulumi.Input[Union[str, 'IkeEncryption']]:
          """
          The IKE encryption algorithm (IKE phase 2).
          """
          return pulumi.get(self, "ike_encryption")
  
      @ike_encryption.setter
      def ike_encryption(self, value: pulumi.Input[Union[str, 'IkeEncryption']]):
          pulumi.set(self, "ike_encryption", value)
  
      @property
      @pulumi.getter(name="ikeIntegrity")
      def ike_integrity(self) -> pulumi.Input[Union[str, 'IkeIntegrity']]:
          """
          The IKE integrity algorithm (IKE phase 2).
          """
          return pulumi.get(self, "ike_integrity")
  
      @ike_integrity.setter
      def ike_integrity(self, value: pulumi.Input[Union[str, 'IkeIntegrity']]):
          pulumi.set(self, "ike_integrity", value)
  
      @property
      @pulumi.getter(name="ipsecEncryption")
      def ipsec_encryption(self) -> pulumi.Input[Union[str, 'IpsecEncryption']]:
          """
          The IPSec encryption algorithm (IKE phase 1).
          """
          return pulumi.get(self, "ipsec_encryption")
  
      @ipsec_encryption.setter
      def ipsec_encryption(self, value: pulumi.Input[Union[str, 'IpsecEncryption']]):
          pulumi.set(self, "ipsec_encryption", value)
  
      @property
      @pulumi.getter(name="ipsecIntegrity")
      def ipsec_integrity(self) -> pulumi.Input[Union[str, 'IpsecIntegrity']]:
          """
          The IPSec integrity algorithm (IKE phase 1).
          """
          return pulumi.get(self, "ipsec_integrity")
  
      @ipsec_integrity.setter
      def ipsec_integrity(self, value: pulumi.Input[Union[str, 'IpsecIntegrity']]):
          pulumi.set(self, "ipsec_integrity", value)
  
      @property
      @pulumi.getter(name="pfsGroup")
      def pfs_group(self) -> pulumi.Input[Union[str, 'PfsGroup']]:
          """
          The Pfs Groups used in IKE Phase 2 for new child SA.
          """
          return pulumi.get(self, "pfs_group")
  
      @pfs_group.setter
      def pfs_group(self, value: pulumi.Input[Union[str, 'PfsGroup']]):
          pulumi.set(self, "pfs_group", value)
  
      @property
      @pulumi.getter(name="saDataSizeKilobytes")
      def sa_data_size_kilobytes(self) -> pulumi.Input[int]:
          """
          The IPSec Security Association (also called Quick Mode or Phase 2 SA) payload size in KB for a site to site VPN tunnel.
          """
          return pulumi.get(self, "sa_data_size_kilobytes")
  
      @sa_data_size_kilobytes.setter
      def sa_data_size_kilobytes(self, value: pulumi.Input[int]):
          pulumi.set(self, "sa_data_size_kilobytes", value)
  
      @property
      @pulumi.getter(name="saLifeTimeSeconds")
      def sa_life_time_seconds(self) -> pulumi.Input[int]:
          """
          The IPSec Security Association (also called Quick Mode or Phase 2 SA) lifetime in seconds for a site to site VPN tunnel.
          """
          return pulumi.get(self, "sa_life_time_seconds")
  
      @sa_life_time_seconds.setter
      def sa_life_time_seconds(self, value: pulumi.Input[int]):
          pulumi.set(self, "sa_life_time_seconds", value)
  
  
  @pulumi.input_type
  class Ipv6ExpressRouteCircuitPeeringConfigArgs:
      def __init__(__self__, *,
                   microsoft_peering_config: Optional[pulumi.Input['ExpressRouteCircuitPeeringConfigArgs']] = None,
                   primary_peer_address_prefix: Optional[pulumi.Input[str]] = None,
                   route_filter: Optional[pulumi.Input['RouteFilterArgs']] = None,
                   secondary_peer_address_prefix: Optional[pulumi.Input[str]] = None,
                   state: Optional[pulumi.Input[Union[str, 'ExpressRouteCircuitPeeringState']]] = None):
          """
          Contains IPv6 peering config.
          :param pulumi.Input['ExpressRouteCircuitPeeringConfigArgs'] microsoft_peering_config: The Microsoft peering configuration.
          :param pulumi.Input[str] primary_peer_address_prefix: The primary address prefix.
          :param pulumi.Input['RouteFilterArgs'] route_filter: The reference of the RouteFilter resource.
          :param pulumi.Input[str] secondary_peer_address_prefix: The secondary address prefix.
          :param pulumi.Input[Union[str, 'ExpressRouteCircuitPeeringState']] state: The state of peering. Possible values are: 'Disabled' and 'Enabled'
          """
          if microsoft_peering_config is not None:
              pulumi.set(__self__, "microsoft_peering_config", microsoft_peering_config)
          if primary_peer_address_prefix is not None:
              pulumi.set(__self__, "primary_peer_address_prefix", primary_peer_address_prefix)
          if route_filter is not None:
              pulumi.set(__self__, "route_filter", route_filter)
          if secondary_peer_address_prefix is not None:
              pulumi.set(__self__, "secondary_peer_address_prefix", secondary_peer_address_prefix)
          if state is not None:
              pulumi.set(__self__, "state", state)
  
      @property
      @pulumi.getter(name="microsoftPeeringConfig")
      def microsoft_peering_config(self) -> Optional[pulumi.Input['ExpressRouteCircuitPeeringConfigArgs']]:
          """
          The Microsoft peering configuration.
          """
          return pulumi.get(self, "microsoft_peering_config")
  
      @microsoft_peering_config.setter
      def microsoft_peering_config(self, value: Optional[pulumi.Input['ExpressRouteCircuitPeeringConfigArgs']]):
          pulumi.set(self, "microsoft_peering_config", value)
  
      @property
      @pulumi.getter(name="primaryPeerAddressPrefix")
      def primary_peer_address_prefix(self) -> Optional[pulumi.Input[str]]:
          """
          The primary address prefix.
          """
          return pulumi.get(self, "primary_peer_address_prefix")
  
      @primary_peer_address_prefix.setter
      def primary_peer_address_prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "primary_peer_address_prefix", value)
  
      @property
      @pulumi.getter(name="routeFilter")
      def route_filter(self) -> Optional[pulumi.Input['RouteFilterArgs']]:
          """
          The reference of the RouteFilter resource.
          """
          return pulumi.get(self, "route_filter")
  
      @route_filter.setter
      def route_filter(self, value: Optional[pulumi.Input['RouteFilterArgs']]):
          pulumi.set(self, "route_filter", value)
  
      @property
      @pulumi.getter(name="secondaryPeerAddressPrefix")
      def secondary_peer_address_prefix(self) -> Optional[pulumi.Input[str]]:
          """
          The secondary address prefix.
          """
          return pulumi.get(self, "secondary_peer_address_prefix")
  
      @secondary_peer_address_prefix.setter
      def secondary_peer_address_prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "secondary_peer_address_prefix", value)
  
      @property
      @pulumi.getter
      def state(self) -> Optional[pulumi.Input[Union[str, 'ExpressRouteCircuitPeeringState']]]:
          """
          The state of peering. Possible values are: 'Disabled' and 'Enabled'
          """
          return pulumi.get(self, "state")
  
      @state.setter
      def state(self, value: Optional[pulumi.Input[Union[str, 'ExpressRouteCircuitPeeringState']]]):
          pulumi.set(self, "state", value)
  
  
  @pulumi.input_type
  class LoadBalancerSkuArgs:
      def __init__(__self__, *,
                   name: Optional[pulumi.Input[Union[str, 'LoadBalancerSkuName']]] = None):
          """
          SKU of a load balancer
          :param pulumi.Input[Union[str, 'LoadBalancerSkuName']] name: Name of a load balancer SKU.
          """
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[Union[str, 'LoadBalancerSkuName']]]:
          """
          Name of a load balancer SKU.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[Union[str, 'LoadBalancerSkuName']]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class LoadBalancingRuleArgs:
      def __init__(__self__, *,
                   frontend_port: pulumi.Input[int],
                   protocol: pulumi.Input[Union[str, 'TransportProtocol']],
                   backend_address_pool: Optional[pulumi.Input['SubResourceArgs']] = None,
                   backend_port: Optional[pulumi.Input[int]] = None,
                   disable_outbound_snat: Optional[pulumi.Input[bool]] = None,
                   enable_floating_ip: Optional[pulumi.Input[bool]] = None,
                   enable_tcp_reset: Optional[pulumi.Input[bool]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   frontend_ip_configuration: Optional[pulumi.Input['SubResourceArgs']] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   idle_timeout_in_minutes: Optional[pulumi.Input[int]] = None,
                   load_distribution: Optional[pulumi.Input[Union[str, 'LoadDistribution']]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   probe: Optional[pulumi.Input['SubResourceArgs']] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None):
          """
          A load balancing rule for a load balancer.
          :param pulumi.Input[int] frontend_port: The port for the external endpoint. Port numbers for each rule must be unique within the Load Balancer. Acceptable values are between 0 and 65534. Note that value 0 enables "Any Port"
          :param pulumi.Input[Union[str, 'TransportProtocol']] protocol: The transport protocol for the endpoint. Possible values are 'Udp' or 'Tcp' or 'All'.
          :param pulumi.Input['SubResourceArgs'] backend_address_pool: A reference to a pool of DIPs. Inbound traffic is randomly load balanced across IPs in the backend IPs.
          :param pulumi.Input[int] backend_port: The port used for internal connections on the endpoint. Acceptable values are between 0 and 65535. Note that value 0 enables "Any Port"
          :param pulumi.Input[bool] disable_outbound_snat: Configures SNAT for the VMs in the backend pool to use the publicIP address specified in the frontend of the load balancing rule.
          :param pulumi.Input[bool] enable_floating_ip: Configures a virtual machine's endpoint for the floating IP capability required to configure a SQL AlwaysOn Availability Group. This setting is required when using the SQL AlwaysOn Availability Groups in SQL server. This setting can't be changed after you create the endpoint.
          :param pulumi.Input[bool] enable_tcp_reset: Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input['SubResourceArgs'] frontend_ip_configuration: A reference to frontend IP addresses.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[int] idle_timeout_in_minutes: The timeout for the TCP idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to TCP.
          :param pulumi.Input[Union[str, 'LoadDistribution']] load_distribution: The load distribution policy for this rule. Possible values are 'Default', 'SourceIP', and 'SourceIPProtocol'.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input['SubResourceArgs'] probe: The reference of the load balancer probe used by the load balancing rule.
          :param pulumi.Input[str] provisioning_state: Gets the provisioning state of the PublicIP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          pulumi.set(__self__, "frontend_port", frontend_port)
          pulumi.set(__self__, "protocol", protocol)
          if backend_address_pool is not None:
              pulumi.set(__self__, "backend_address_pool", backend_address_pool)
          if backend_port is not None:
              pulumi.set(__self__, "backend_port", backend_port)
          if disable_outbound_snat is not None:
              pulumi.set(__self__, "disable_outbound_snat", disable_outbound_snat)
          if enable_floating_ip is not None:
              pulumi.set(__self__, "enable_floating_ip", enable_floating_ip)
          if enable_tcp_reset is not None:
              pulumi.set(__self__, "enable_tcp_reset", enable_tcp_reset)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if frontend_ip_configuration is not None:
              pulumi.set(__self__, "frontend_ip_configuration", frontend_ip_configuration)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if idle_timeout_in_minutes is not None:
              pulumi.set(__self__, "idle_timeout_in_minutes", idle_timeout_in_minutes)
          if load_distribution is not None:
              pulumi.set(__self__, "load_distribution", load_distribution)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if probe is not None:
              pulumi.set(__self__, "probe", probe)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
  
      @property
      @pulumi.getter(name="frontendPort")
      def frontend_port(self) -> pulumi.Input[int]:
          """
          The port for the external endpoint. Port numbers for each rule must be unique within the Load Balancer. Acceptable values are between 0 and 65534. Note that value 0 enables "Any Port"
          """
          return pulumi.get(self, "frontend_port")
  
      @frontend_port.setter
      def frontend_port(self, value: pulumi.Input[int]):
          pulumi.set(self, "frontend_port", value)
  
      @property
      @pulumi.getter
      def protocol(self) -> pulumi.Input[Union[str, 'TransportProtocol']]:
          """
          The transport protocol for the endpoint. Possible values are 'Udp' or 'Tcp' or 'All'.
          """
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: pulumi.Input[Union[str, 'TransportProtocol']]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter(name="backendAddressPool")
      def backend_address_pool(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          A reference to a pool of DIPs. Inbound traffic is randomly load balanced across IPs in the backend IPs.
          """
          return pulumi.get(self, "backend_address_pool")
  
      @backend_address_pool.setter
      def backend_address_pool(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "backend_address_pool", value)
  
      @property
      @pulumi.getter(name="backendPort")
      def backend_port(self) -> Optional[pulumi.Input[int]]:
          """
          The port used for internal connections on the endpoint. Acceptable values are between 0 and 65535. Note that value 0 enables "Any Port"
          """
          return pulumi.get(self, "backend_port")
  
      @backend_port.setter
      def backend_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "backend_port", value)
  
      @property
      @pulumi.getter(name="disableOutboundSnat")
      def disable_outbound_snat(self) -> Optional[pulumi.Input[bool]]:
          """
          Configures SNAT for the VMs in the backend pool to use the publicIP address specified in the frontend of the load balancing rule.
          """
          return pulumi.get(self, "disable_outbound_snat")
  
      @disable_outbound_snat.setter
      def disable_outbound_snat(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "disable_outbound_snat", value)
  
      @property
      @pulumi.getter(name="enableFloatingIP")
      def enable_floating_ip(self) -> Optional[pulumi.Input[bool]]:
          """
          Configures a virtual machine's endpoint for the floating IP capability required to configure a SQL AlwaysOn Availability Group. This setting is required when using the SQL AlwaysOn Availability Groups in SQL server. This setting can't be changed after you create the endpoint.
          """
          return pulumi.get(self, "enable_floating_ip")
  
      @enable_floating_ip.setter
      def enable_floating_ip(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_floating_ip", value)
  
      @property
      @pulumi.getter(name="enableTcpReset")
      def enable_tcp_reset(self) -> Optional[pulumi.Input[bool]]:
          """
          Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
          """
          return pulumi.get(self, "enable_tcp_reset")
  
      @enable_tcp_reset.setter
      def enable_tcp_reset(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_tcp_reset", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter(name="frontendIPConfiguration")
      def frontend_ip_configuration(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          A reference to frontend IP addresses.
          """
          return pulumi.get(self, "frontend_ip_configuration")
  
      @frontend_ip_configuration.setter
      def frontend_ip_configuration(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "frontend_ip_configuration", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="idleTimeoutInMinutes")
      def idle_timeout_in_minutes(self) -> Optional[pulumi.Input[int]]:
          """
          The timeout for the TCP idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to TCP.
          """
          return pulumi.get(self, "idle_timeout_in_minutes")
  
      @idle_timeout_in_minutes.setter
      def idle_timeout_in_minutes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "idle_timeout_in_minutes", value)
  
      @property
      @pulumi.getter(name="loadDistribution")
      def load_distribution(self) -> Optional[pulumi.Input[Union[str, 'LoadDistribution']]]:
          """
          The load distribution policy for this rule. Possible values are 'Default', 'SourceIP', and 'SourceIPProtocol'.
          """
          return pulumi.get(self, "load_distribution")
  
      @load_distribution.setter
      def load_distribution(self, value: Optional[pulumi.Input[Union[str, 'LoadDistribution']]]):
          pulumi.set(self, "load_distribution", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def probe(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          The reference of the load balancer probe used by the load balancing rule.
          """
          return pulumi.get(self, "probe")
  
      @probe.setter
      def probe(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "probe", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Gets the provisioning state of the PublicIP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
  
  @pulumi.input_type
  class LocalNetworkGatewayArgs:
      def __init__(__self__, *,
                   bgp_settings: Optional[pulumi.Input['BgpSettingsArgs']] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   gateway_ip_address: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   local_network_address_space: Optional[pulumi.Input['AddressSpaceArgs']] = None,
                   location: Optional[pulumi.Input[str]] = None,
                   resource_guid: Optional[pulumi.Input[str]] = None,
                   tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
          """
          A common class for general resource information
          :param pulumi.Input['BgpSettingsArgs'] bgp_settings: Local network gateway's BGP speaker settings.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] gateway_ip_address: IP address of local network gateway.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input['AddressSpaceArgs'] local_network_address_space: Local network site address space.
          :param pulumi.Input[str] location: Resource location.
          :param pulumi.Input[str] resource_guid: The resource GUID property of the LocalNetworkGateway resource.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags.
          """
          if bgp_settings is not None:
              pulumi.set(__self__, "bgp_settings", bgp_settings)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if gateway_ip_address is not None:
              pulumi.set(__self__, "gateway_ip_address", gateway_ip_address)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if local_network_address_space is not None:
              pulumi.set(__self__, "local_network_address_space", local_network_address_space)
          if location is not None:
              pulumi.set(__self__, "location", location)
          if resource_guid is not None:
              pulumi.set(__self__, "resource_guid", resource_guid)
          if tags is not None:
              pulumi.set(__self__, "tags", tags)
  
      @property
      @pulumi.getter(name="bgpSettings")
      def bgp_settings(self) -> Optional[pulumi.Input['BgpSettingsArgs']]:
          """
          Local network gateway's BGP speaker settings.
          """
          return pulumi.get(self, "bgp_settings")
  
      @bgp_settings.setter
      def bgp_settings(self, value: Optional[pulumi.Input['BgpSettingsArgs']]):
          pulumi.set(self, "bgp_settings", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter(name="gatewayIpAddress")
      def gateway_ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          IP address of local network gateway.
          """
          return pulumi.get(self, "gateway_ip_address")
  
      @gateway_ip_address.setter
      def gateway_ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "gateway_ip_address", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="localNetworkAddressSpace")
      def local_network_address_space(self) -> Optional[pulumi.Input['AddressSpaceArgs']]:
          """
          Local network site address space.
          """
          return pulumi.get(self, "local_network_address_space")
  
      @local_network_address_space.setter
      def local_network_address_space(self, value: Optional[pulumi.Input['AddressSpaceArgs']]):
          pulumi.set(self, "local_network_address_space", value)
  
      @property
      @pulumi.getter
      def location(self) -> Optional[pulumi.Input[str]]:
          """
          Resource location.
          """
          return pulumi.get(self, "location")
  
      @location.setter
      def location(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "location", value)
  
      @property
      @pulumi.getter(name="resourceGuid")
      def resource_guid(self) -> Optional[pulumi.Input[str]]:
          """
          The resource GUID property of the LocalNetworkGateway resource.
          """
          return pulumi.get(self, "resource_guid")
  
      @resource_guid.setter
      def resource_guid(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "resource_guid", value)
  
      @property
      @pulumi.getter
      def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Resource tags.
          """
          return pulumi.get(self, "tags")
  
      @tags.setter
      def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "tags", value)
  
  
  @pulumi.input_type
  class ManagedServiceIdentityArgs:
      def __init__(__self__, *,
                   type: Optional[pulumi.Input['ResourceIdentityType']] = None,
                   user_assigned_identities: Optional[pulumi.Input[Mapping[str, Any]]] = None):
          """
          Identity for the resource.
          :param pulumi.Input['ResourceIdentityType'] type: The type of identity used for the resource. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user assigned identities. The type 'None' will remove any identities from the virtual machine.
          :param pulumi.Input[Mapping[str, Any]] user_assigned_identities: The list of user identities associated with resource. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
          """
          if type is not None:
              pulumi.set(__self__, "type", type)
          if user_assigned_identities is not None:
              pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input['ResourceIdentityType']]:
          """
          The type of identity used for the resource. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user assigned identities. The type 'None' will remove any identities from the virtual machine.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input['ResourceIdentityType']]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter(name="userAssignedIdentities")
      def user_assigned_identities(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
          """
          The list of user identities associated with resource. The user identity dictionary key references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
          """
          return pulumi.get(self, "user_assigned_identities")
  
      @user_assigned_identities.setter
      def user_assigned_identities(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
          pulumi.set(self, "user_assigned_identities", value)
  
  
  @pulumi.input_type
  class NetworkInterfaceDnsSettingsArgs:
      def __init__(__self__, *,
                   applied_dns_servers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   dns_servers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   internal_dns_name_label: Optional[pulumi.Input[str]] = None,
                   internal_domain_name_suffix: Optional[pulumi.Input[str]] = None,
                   internal_fqdn: Optional[pulumi.Input[str]] = None):
          """
          DNS settings of a network interface.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] applied_dns_servers: If the VM that uses this NIC is part of an Availability Set, then this list will have the union of all DNS servers from all NICs that are part of the Availability Set. This property is what is configured on each of those VMs.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] dns_servers: List of DNS servers IP addresses. Use 'AzureProvidedDNS' to switch to azure provided DNS resolution. 'AzureProvidedDNS' value cannot be combined with other IPs, it must be the only value in dnsServers collection.
          :param pulumi.Input[str] internal_dns_name_label: Relative DNS name for this NIC used for internal communications between VMs in the same virtual network.
          :param pulumi.Input[str] internal_domain_name_suffix: Even if internalDnsNameLabel is not specified, a DNS entry is created for the primary NIC of the VM. This DNS name can be constructed by concatenating the VM name with the value of internalDomainNameSuffix.
          :param pulumi.Input[str] internal_fqdn: Fully qualified DNS name supporting internal communications between VMs in the same virtual network.
          """
          if applied_dns_servers is not None:
              pulumi.set(__self__, "applied_dns_servers", applied_dns_servers)
          if dns_servers is not None:
              pulumi.set(__self__, "dns_servers", dns_servers)
          if internal_dns_name_label is not None:
              pulumi.set(__self__, "internal_dns_name_label", internal_dns_name_label)
          if internal_domain_name_suffix is not None:
              pulumi.set(__self__, "internal_domain_name_suffix", internal_domain_name_suffix)
          if internal_fqdn is not None:
              pulumi.set(__self__, "internal_fqdn", internal_fqdn)
  
      @property
      @pulumi.getter(name="appliedDnsServers")
      def applied_dns_servers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          If the VM that uses this NIC is part of an Availability Set, then this list will have the union of all DNS servers from all NICs that are part of the Availability Set. This property is what is configured on each of those VMs.
          """
          return pulumi.get(self, "applied_dns_servers")
  
      @applied_dns_servers.setter
      def applied_dns_servers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "applied_dns_servers", value)
  
      @property
      @pulumi.getter(name="dnsServers")
      def dns_servers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List of DNS servers IP addresses. Use 'AzureProvidedDNS' to switch to azure provided DNS resolution. 'AzureProvidedDNS' value cannot be combined with other IPs, it must be the only value in dnsServers collection.
          """
          return pulumi.get(self, "dns_servers")
  
      @dns_servers.setter
      def dns_servers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "dns_servers", value)
  
      @property
      @pulumi.getter(name="internalDnsNameLabel")
      def internal_dns_name_label(self) -> Optional[pulumi.Input[str]]:
          """
          Relative DNS name for this NIC used for internal communications between VMs in the same virtual network.
          """
          return pulumi.get(self, "internal_dns_name_label")
  
      @internal_dns_name_label.setter
      def internal_dns_name_label(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "internal_dns_name_label", value)
  
      @property
      @pulumi.getter(name="internalDomainNameSuffix")
      def internal_domain_name_suffix(self) -> Optional[pulumi.Input[str]]:
          """
          Even if internalDnsNameLabel is not specified, a DNS entry is created for the primary NIC of the VM. This DNS name can be constructed by concatenating the VM name with the value of internalDomainNameSuffix.
          """
          return pulumi.get(self, "internal_domain_name_suffix")
  
      @internal_domain_name_suffix.setter
      def internal_domain_name_suffix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "internal_domain_name_suffix", value)
  
      @property
      @pulumi.getter(name="internalFqdn")
      def internal_fqdn(self) -> Optional[pulumi.Input[str]]:
          """
          Fully qualified DNS name supporting internal communications between VMs in the same virtual network.
          """
          return pulumi.get(self, "internal_fqdn")
  
      @internal_fqdn.setter
      def internal_fqdn(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "internal_fqdn", value)
  
  
  @pulumi.input_type
  class NetworkInterfaceIPConfigurationArgs:
      def __init__(__self__, *,
                   application_gateway_backend_address_pools: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayBackendAddressPoolArgs']]]] = None,
                   application_security_groups: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSecurityGroupArgs']]]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   load_balancer_backend_address_pools: Optional[pulumi.Input[Sequence[pulumi.Input['BackendAddressPoolArgs']]]] = None,
                   load_balancer_inbound_nat_rules: Optional[pulumi.Input[Sequence[pulumi.Input['InboundNatRuleArgs']]]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   primary: Optional[pulumi.Input[bool]] = None,
                   private_ip_address: Optional[pulumi.Input[str]] = None,
                   private_ip_address_version: Optional[pulumi.Input[Union[str, 'IPVersion']]] = None,
                   private_ip_allocation_method: Optional[pulumi.Input[Union[str, 'IPAllocationMethod']]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   public_ip_address: Optional[pulumi.Input['PublicIPAddressArgs']] = None,
                   subnet: Optional[pulumi.Input['SubnetArgs']] = None,
                   virtual_network_taps: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualNetworkTapArgs']]]] = None):
          """
          IPConfiguration in a network interface.
          :param pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayBackendAddressPoolArgs']]] application_gateway_backend_address_pools: The reference of ApplicationGatewayBackendAddressPool resource.
          :param pulumi.Input[Sequence[pulumi.Input['ApplicationSecurityGroupArgs']]] application_security_groups: Application security groups in which the IP configuration is included.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[Sequence[pulumi.Input['BackendAddressPoolArgs']]] load_balancer_backend_address_pools: The reference of LoadBalancerBackendAddressPool resource.
          :param pulumi.Input[Sequence[pulumi.Input['InboundNatRuleArgs']]] load_balancer_inbound_nat_rules: A list of references of LoadBalancerInboundNatRules.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[bool] primary: Gets whether this is a primary customer address on the network interface.
          :param pulumi.Input[str] private_ip_address: Private IP address of the IP configuration.
          :param pulumi.Input[Union[str, 'IPVersion']] private_ip_address_version: Available from Api-Version 2016-03-30 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4.  Possible values are: 'IPv4' and 'IPv6'.
          :param pulumi.Input[Union[str, 'IPAllocationMethod']] private_ip_allocation_method: Defines how a private IP address is assigned. Possible values are: 'Static' and 'Dynamic'.
          :param pulumi.Input[str] provisioning_state: The provisioning state of the network interface IP configuration. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input['PublicIPAddressArgs'] public_ip_address: Public IP address bound to the IP configuration.
          :param pulumi.Input['SubnetArgs'] subnet: Subnet bound to the IP configuration.
          :param pulumi.Input[Sequence[pulumi.Input['VirtualNetworkTapArgs']]] virtual_network_taps: The reference to Virtual Network Taps.
          """
          if application_gateway_backend_address_pools is not None:
              pulumi.set(__self__, "application_gateway_backend_address_pools", application_gateway_backend_address_pools)
          if application_security_groups is not None:
              pulumi.set(__self__, "application_security_groups", application_security_groups)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if load_balancer_backend_address_pools is not None:
              pulumi.set(__self__, "load_balancer_backend_address_pools", load_balancer_backend_address_pools)
          if load_balancer_inbound_nat_rules is not None:
              pulumi.set(__self__, "load_balancer_inbound_nat_rules", load_balancer_inbound_nat_rules)
          if name is not None:
              pulumi.set(__self__, "name", name)
          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 private_ip_allocation_method is not None:
              pulumi.set(__self__, "private_ip_allocation_method", private_ip_allocation_method)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if public_ip_address is not None:
              pulumi.set(__self__, "public_ip_address", public_ip_address)
          if subnet is not None:
              pulumi.set(__self__, "subnet", subnet)
          if virtual_network_taps is not None:
              pulumi.set(__self__, "virtual_network_taps", virtual_network_taps)
  
      @property
      @pulumi.getter(name="applicationGatewayBackendAddressPools")
      def application_gateway_backend_address_pools(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayBackendAddressPoolArgs']]]]:
          """
          The reference of ApplicationGatewayBackendAddressPool resource.
          """
          return pulumi.get(self, "application_gateway_backend_address_pools")
  
      @application_gateway_backend_address_pools.setter
      def application_gateway_backend_address_pools(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationGatewayBackendAddressPoolArgs']]]]):
          pulumi.set(self, "application_gateway_backend_address_pools", value)
  
      @property
      @pulumi.getter(name="applicationSecurityGroups")
      def application_security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSecurityGroupArgs']]]]:
          """
          Application security groups in which the IP configuration is included.
          """
          return pulumi.get(self, "application_security_groups")
  
      @application_security_groups.setter
      def application_security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSecurityGroupArgs']]]]):
          pulumi.set(self, "application_security_groups", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="loadBalancerBackendAddressPools")
      def load_balancer_backend_address_pools(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BackendAddressPoolArgs']]]]:
          """
          The reference of LoadBalancerBackendAddressPool resource.
          """
          return pulumi.get(self, "load_balancer_backend_address_pools")
  
      @load_balancer_backend_address_pools.setter
      def load_balancer_backend_address_pools(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BackendAddressPoolArgs']]]]):
          pulumi.set(self, "load_balancer_backend_address_pools", value)
  
      @property
      @pulumi.getter(name="loadBalancerInboundNatRules")
      def load_balancer_inbound_nat_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InboundNatRuleArgs']]]]:
          """
          A list of references of LoadBalancerInboundNatRules.
          """
          return pulumi.get(self, "load_balancer_inbound_nat_rules")
  
      @load_balancer_inbound_nat_rules.setter
      def load_balancer_inbound_nat_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InboundNatRuleArgs']]]]):
          pulumi.set(self, "load_balancer_inbound_nat_rules", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def primary(self) -> Optional[pulumi.Input[bool]]:
          """
          Gets whether this is a primary customer address on the network interface.
          """
          return pulumi.get(self, "primary")
  
      @primary.setter
      def primary(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "primary", value)
  
      @property
      @pulumi.getter(name="privateIPAddress")
      def private_ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          Private IP address of the IP configuration.
          """
          return pulumi.get(self, "private_ip_address")
  
      @private_ip_address.setter
      def private_ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "private_ip_address", value)
  
      @property
      @pulumi.getter(name="privateIPAddressVersion")
      def private_ip_address_version(self) -> Optional[pulumi.Input[Union[str, 'IPVersion']]]:
          """
          Available from Api-Version 2016-03-30 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4.  Possible values are: 'IPv4' and 'IPv6'.
          """
          return pulumi.get(self, "private_ip_address_version")
  
      @private_ip_address_version.setter
      def private_ip_address_version(self, value: Optional[pulumi.Input[Union[str, 'IPVersion']]]):
          pulumi.set(self, "private_ip_address_version", value)
  
      @property
      @pulumi.getter(name="privateIPAllocationMethod")
      def private_ip_allocation_method(self) -> Optional[pulumi.Input[Union[str, 'IPAllocationMethod']]]:
          """
          Defines how a private IP address is assigned. Possible values are: 'Static' and 'Dynamic'.
          """
          return pulumi.get(self, "private_ip_allocation_method")
  
      @private_ip_allocation_method.setter
      def private_ip_allocation_method(self, value: Optional[pulumi.Input[Union[str, 'IPAllocationMethod']]]):
          pulumi.set(self, "private_ip_allocation_method", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          The provisioning state of the network interface IP configuration. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter(name="publicIPAddress")
      def public_ip_address(self) -> Optional[pulumi.Input['PublicIPAddressArgs']]:
          """
          Public IP address bound to the IP configuration.
          """
          return pulumi.get(self, "public_ip_address")
  
      @public_ip_address.setter
      def public_ip_address(self, value: Optional[pulumi.Input['PublicIPAddressArgs']]):
          pulumi.set(self, "public_ip_address", value)
  
      @property
      @pulumi.getter
      def subnet(self) -> Optional[pulumi.Input['SubnetArgs']]:
          """
          Subnet bound to the IP configuration.
          """
          return pulumi.get(self, "subnet")
  
      @subnet.setter
      def subnet(self, value: Optional[pulumi.Input['SubnetArgs']]):
          pulumi.set(self, "subnet", value)
  
      @property
      @pulumi.getter(name="virtualNetworkTaps")
      def virtual_network_taps(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VirtualNetworkTapArgs']]]]:
          """
          The reference to Virtual Network Taps.
          """
          return pulumi.get(self, "virtual_network_taps")
  
      @virtual_network_taps.setter
      def virtual_network_taps(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualNetworkTapArgs']]]]):
          pulumi.set(self, "virtual_network_taps", value)
  
  
  @pulumi.input_type
  class NetworkInterfaceTapConfigurationArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   virtual_network_tap: Optional[pulumi.Input['VirtualNetworkTapArgs']] = None):
          """
          Tap configuration in a Network Interface
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input['VirtualNetworkTapArgs'] virtual_network_tap: The reference of the Virtual Network Tap resource.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if virtual_network_tap is not None:
              pulumi.set(__self__, "virtual_network_tap", virtual_network_tap)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="virtualNetworkTap")
      def virtual_network_tap(self) -> Optional[pulumi.Input['VirtualNetworkTapArgs']]:
          """
          The reference of the Virtual Network Tap resource.
          """
          return pulumi.get(self, "virtual_network_tap")
  
      @virtual_network_tap.setter
      def virtual_network_tap(self, value: Optional[pulumi.Input['VirtualNetworkTapArgs']]):
          pulumi.set(self, "virtual_network_tap", value)
  
  
  @pulumi.input_type
  class NetworkSecurityGroupArgs:
      def __init__(__self__, *,
                   default_security_rules: Optional[pulumi.Input[Sequence[pulumi.Input['SecurityRuleArgs']]]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   location: Optional[pulumi.Input[str]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   resource_guid: Optional[pulumi.Input[str]] = None,
                   security_rules: Optional[pulumi.Input[Sequence[pulumi.Input['SecurityRuleArgs']]]] = None,
                   tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
          """
          NetworkSecurityGroup resource.
          :param pulumi.Input[Sequence[pulumi.Input['SecurityRuleArgs']]] default_security_rules: The default security rules of network security group.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] location: Resource location.
          :param pulumi.Input[str] provisioning_state: The provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input[str] resource_guid: The resource GUID property of the network security group resource.
          :param pulumi.Input[Sequence[pulumi.Input['SecurityRuleArgs']]] security_rules: A collection of security rules of the network security group.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags.
          """
          if default_security_rules is not None:
              pulumi.set(__self__, "default_security_rules", default_security_rules)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if location is not None:
              pulumi.set(__self__, "location", location)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if resource_guid is not None:
              pulumi.set(__self__, "resource_guid", resource_guid)
          if security_rules is not None:
              pulumi.set(__self__, "security_rules", security_rules)
          if tags is not None:
              pulumi.set(__self__, "tags", tags)
  
      @property
      @pulumi.getter(name="defaultSecurityRules")
      def default_security_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SecurityRuleArgs']]]]:
          """
          The default security rules of network security group.
          """
          return pulumi.get(self, "default_security_rules")
  
      @default_security_rules.setter
      def default_security_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SecurityRuleArgs']]]]):
          pulumi.set(self, "default_security_rules", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def location(self) -> Optional[pulumi.Input[str]]:
          """
          Resource location.
          """
          return pulumi.get(self, "location")
  
      @location.setter
      def location(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "location", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          The provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter(name="resourceGuid")
      def resource_guid(self) -> Optional[pulumi.Input[str]]:
          """
          The resource GUID property of the network security group resource.
          """
          return pulumi.get(self, "resource_guid")
  
      @resource_guid.setter
      def resource_guid(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "resource_guid", value)
  
      @property
      @pulumi.getter(name="securityRules")
      def security_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SecurityRuleArgs']]]]:
          """
          A collection of security rules of the network security group.
          """
          return pulumi.get(self, "security_rules")
  
      @security_rules.setter
      def security_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SecurityRuleArgs']]]]):
          pulumi.set(self, "security_rules", value)
  
      @property
      @pulumi.getter
      def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Resource tags.
          """
          return pulumi.get(self, "tags")
  
      @tags.setter
      def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "tags", value)
  
  
  @pulumi.input_type
  class OutboundRuleArgs:
      def __init__(__self__, *,
                   backend_address_pool: pulumi.Input['SubResourceArgs'],
                   frontend_ip_configurations: pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]],
                   protocol: pulumi.Input[str],
                   allocated_outbound_ports: Optional[pulumi.Input[int]] = None,
                   enable_tcp_reset: Optional[pulumi.Input[bool]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   idle_timeout_in_minutes: Optional[pulumi.Input[int]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None):
          """
          Outbound rule of the load balancer.
          :param pulumi.Input['SubResourceArgs'] backend_address_pool: A reference to a pool of DIPs. Outbound traffic is randomly load balanced across IPs in the backend IPs.
          :param pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]] frontend_ip_configurations: The Frontend IP addresses of the load balancer.
          :param pulumi.Input[str] protocol: Protocol - TCP, UDP or All
          :param pulumi.Input[int] allocated_outbound_ports: The number of outbound ports to be used for NAT.
          :param pulumi.Input[bool] enable_tcp_reset: Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[int] idle_timeout_in_minutes: The timeout for the TCP idle connection
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[str] provisioning_state: Gets the provisioning state of the PublicIP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          pulumi.set(__self__, "backend_address_pool", backend_address_pool)
          pulumi.set(__self__, "frontend_ip_configurations", frontend_ip_configurations)
          pulumi.set(__self__, "protocol", protocol)
          if allocated_outbound_ports is not None:
              pulumi.set(__self__, "allocated_outbound_ports", allocated_outbound_ports)
          if enable_tcp_reset is not None:
              pulumi.set(__self__, "enable_tcp_reset", enable_tcp_reset)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if idle_timeout_in_minutes is not None:
              pulumi.set(__self__, "idle_timeout_in_minutes", idle_timeout_in_minutes)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
  
      @property
      @pulumi.getter(name="backendAddressPool")
      def backend_address_pool(self) -> pulumi.Input['SubResourceArgs']:
          """
          A reference to a pool of DIPs. Outbound traffic is randomly load balanced across IPs in the backend IPs.
          """
          return pulumi.get(self, "backend_address_pool")
  
      @backend_address_pool.setter
      def backend_address_pool(self, value: pulumi.Input['SubResourceArgs']):
          pulumi.set(self, "backend_address_pool", value)
  
      @property
      @pulumi.getter(name="frontendIPConfigurations")
      def frontend_ip_configurations(self) -> pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]:
          """
          The Frontend IP addresses of the load balancer.
          """
          return pulumi.get(self, "frontend_ip_configurations")
  
      @frontend_ip_configurations.setter
      def frontend_ip_configurations(self, value: pulumi.Input[Sequence[pulumi.Input['SubResourceArgs']]]):
          pulumi.set(self, "frontend_ip_configurations", value)
  
      @property
      @pulumi.getter
      def protocol(self) -> pulumi.Input[str]:
          """
          Protocol - TCP, UDP or All
          """
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: pulumi.Input[str]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter(name="allocatedOutboundPorts")
      def allocated_outbound_ports(self) -> Optional[pulumi.Input[int]]:
          """
          The number of outbound ports to be used for NAT.
          """
          return pulumi.get(self, "allocated_outbound_ports")
  
      @allocated_outbound_ports.setter
      def allocated_outbound_ports(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "allocated_outbound_ports", value)
  
      @property
      @pulumi.getter(name="enableTcpReset")
      def enable_tcp_reset(self) -> Optional[pulumi.Input[bool]]:
          """
          Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
          """
          return pulumi.get(self, "enable_tcp_reset")
  
      @enable_tcp_reset.setter
      def enable_tcp_reset(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_tcp_reset", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="idleTimeoutInMinutes")
      def idle_timeout_in_minutes(self) -> Optional[pulumi.Input[int]]:
          """
          The timeout for the TCP idle connection
          """
          return pulumi.get(self, "idle_timeout_in_minutes")
  
      @idle_timeout_in_minutes.setter
      def idle_timeout_in_minutes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "idle_timeout_in_minutes", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Gets the provisioning state of the PublicIP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
  
  @pulumi.input_type
  class P2SVpnServerConfigRadiusClientRootCertificateArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   thumbprint: Optional[pulumi.Input[str]] = None):
          """
          Radius client root certificate of P2SVpnServerConfiguration.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[str] thumbprint: The Radius client root certificate thumbprint.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if thumbprint is not None:
              pulumi.set(__self__, "thumbprint", thumbprint)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def thumbprint(self) -> Optional[pulumi.Input[str]]:
          """
          The Radius client root certificate thumbprint.
          """
          return pulumi.get(self, "thumbprint")
  
      @thumbprint.setter
      def thumbprint(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "thumbprint", value)
  
  
  @pulumi.input_type
  class P2SVpnServerConfigRadiusServerRootCertificateArgs:
      def __init__(__self__, *,
                   public_cert_data: pulumi.Input[str],
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None):
          """
          Radius Server root certificate of P2SVpnServerConfiguration.
          :param pulumi.Input[str] public_cert_data: The certificate public data.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          pulumi.set(__self__, "public_cert_data", public_cert_data)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter(name="publicCertData")
      def public_cert_data(self) -> pulumi.Input[str]:
          """
          The certificate public data.
          """
          return pulumi.get(self, "public_cert_data")
  
      @public_cert_data.setter
      def public_cert_data(self, value: pulumi.Input[str]):
          pulumi.set(self, "public_cert_data", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class P2SVpnServerConfigVpnClientRevokedCertificateArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   thumbprint: Optional[pulumi.Input[str]] = None):
          """
          VPN client revoked certificate of P2SVpnServerConfiguration.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[str] thumbprint: The revoked VPN client certificate thumbprint.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if thumbprint is not None:
              pulumi.set(__self__, "thumbprint", thumbprint)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def thumbprint(self) -> Optional[pulumi.Input[str]]:
          """
          The revoked VPN client certificate thumbprint.
          """
          return pulumi.get(self, "thumbprint")
  
      @thumbprint.setter
      def thumbprint(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "thumbprint", value)
  
  
  @pulumi.input_type
  class P2SVpnServerConfigVpnClientRootCertificateArgs:
      def __init__(__self__, *,
                   public_cert_data: pulumi.Input[str],
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None):
          """
          VPN client root certificate of P2SVpnServerConfiguration.
          :param pulumi.Input[str] public_cert_data: The certificate public data.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          pulumi.set(__self__, "public_cert_data", public_cert_data)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter(name="publicCertData")
      def public_cert_data(self) -> pulumi.Input[str]:
          """
          The certificate public data.
          """
          return pulumi.get(self, "public_cert_data")
  
      @public_cert_data.setter
      def public_cert_data(self, value: pulumi.Input[str]):
          pulumi.set(self, "public_cert_data", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class P2SVpnServerConfigurationArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   p2_s_vpn_server_config_radius_client_root_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigRadiusClientRootCertificateArgs']]]] = None,
                   p2_s_vpn_server_config_radius_server_root_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigRadiusServerRootCertificateArgs']]]] = None,
                   p2_s_vpn_server_config_vpn_client_revoked_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigVpnClientRevokedCertificateArgs']]]] = None,
                   p2_s_vpn_server_config_vpn_client_root_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigVpnClientRootCertificateArgs']]]] = None,
                   radius_server_address: Optional[pulumi.Input[str]] = None,
                   radius_server_secret: Optional[pulumi.Input[str]] = None,
                   vpn_client_ipsec_policies: Optional[pulumi.Input[Sequence[pulumi.Input['IpsecPolicyArgs']]]] = None,
                   vpn_protocols: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'VpnGatewayTunnelingProtocol']]]]] = None):
          """
          P2SVpnServerConfiguration Resource.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the P2SVpnServerConfiguration that is unique within a VirtualWan in a resource group. This name can be used to access the resource along with Paren VirtualWan resource name.
          :param pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigRadiusClientRootCertificateArgs']]] p2_s_vpn_server_config_radius_client_root_certificates: Radius client root certificate of P2SVpnServerConfiguration.
          :param pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigRadiusServerRootCertificateArgs']]] p2_s_vpn_server_config_radius_server_root_certificates: Radius Server root certificate of P2SVpnServerConfiguration.
          :param pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigVpnClientRevokedCertificateArgs']]] p2_s_vpn_server_config_vpn_client_revoked_certificates: VPN client revoked certificate of P2SVpnServerConfiguration.
          :param pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigVpnClientRootCertificateArgs']]] p2_s_vpn_server_config_vpn_client_root_certificates: VPN client root certificate of P2SVpnServerConfiguration.
          :param pulumi.Input[str] radius_server_address: The radius server address property of the P2SVpnServerConfiguration resource for point to site client connection.
          :param pulumi.Input[str] radius_server_secret: The radius secret property of the P2SVpnServerConfiguration resource for point to site client connection.
          :param pulumi.Input[Sequence[pulumi.Input['IpsecPolicyArgs']]] vpn_client_ipsec_policies: VpnClientIpsecPolicies for P2SVpnServerConfiguration.
          :param pulumi.Input[Sequence[pulumi.Input[Union[str, 'VpnGatewayTunnelingProtocol']]]] vpn_protocols: vpnProtocols for the P2SVpnServerConfiguration.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if p2_s_vpn_server_config_radius_client_root_certificates is not None:
              pulumi.set(__self__, "p2_s_vpn_server_config_radius_client_root_certificates", p2_s_vpn_server_config_radius_client_root_certificates)
          if p2_s_vpn_server_config_radius_server_root_certificates is not None:
              pulumi.set(__self__, "p2_s_vpn_server_config_radius_server_root_certificates", p2_s_vpn_server_config_radius_server_root_certificates)
          if p2_s_vpn_server_config_vpn_client_revoked_certificates is not None:
              pulumi.set(__self__, "p2_s_vpn_server_config_vpn_client_revoked_certificates", p2_s_vpn_server_config_vpn_client_revoked_certificates)
          if p2_s_vpn_server_config_vpn_client_root_certificates is not None:
              pulumi.set(__self__, "p2_s_vpn_server_config_vpn_client_root_certificates", p2_s_vpn_server_config_vpn_client_root_certificates)
          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 vpn_client_ipsec_policies is not None:
              pulumi.set(__self__, "vpn_client_ipsec_policies", vpn_client_ipsec_policies)
          if vpn_protocols is not None:
              pulumi.set(__self__, "vpn_protocols", vpn_protocols)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the P2SVpnServerConfiguration that is unique within a VirtualWan in a resource group. This name can be used to access the resource along with Paren VirtualWan resource name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="p2SVpnServerConfigRadiusClientRootCertificates")
      def p2_s_vpn_server_config_radius_client_root_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigRadiusClientRootCertificateArgs']]]]:
          """
          Radius client root certificate of P2SVpnServerConfiguration.
          """
          return pulumi.get(self, "p2_s_vpn_server_config_radius_client_root_certificates")
  
      @p2_s_vpn_server_config_radius_client_root_certificates.setter
      def p2_s_vpn_server_config_radius_client_root_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigRadiusClientRootCertificateArgs']]]]):
          pulumi.set(self, "p2_s_vpn_server_config_radius_client_root_certificates", value)
  
      @property
      @pulumi.getter(name="p2SVpnServerConfigRadiusServerRootCertificates")
      def p2_s_vpn_server_config_radius_server_root_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigRadiusServerRootCertificateArgs']]]]:
          """
          Radius Server root certificate of P2SVpnServerConfiguration.
          """
          return pulumi.get(self, "p2_s_vpn_server_config_radius_server_root_certificates")
  
      @p2_s_vpn_server_config_radius_server_root_certificates.setter
      def p2_s_vpn_server_config_radius_server_root_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigRadiusServerRootCertificateArgs']]]]):
          pulumi.set(self, "p2_s_vpn_server_config_radius_server_root_certificates", value)
  
      @property
      @pulumi.getter(name="p2SVpnServerConfigVpnClientRevokedCertificates")
      def p2_s_vpn_server_config_vpn_client_revoked_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigVpnClientRevokedCertificateArgs']]]]:
          """
          VPN client revoked certificate of P2SVpnServerConfiguration.
          """
          return pulumi.get(self, "p2_s_vpn_server_config_vpn_client_revoked_certificates")
  
      @p2_s_vpn_server_config_vpn_client_revoked_certificates.setter
      def p2_s_vpn_server_config_vpn_client_revoked_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigVpnClientRevokedCertificateArgs']]]]):
          pulumi.set(self, "p2_s_vpn_server_config_vpn_client_revoked_certificates", value)
  
      @property
      @pulumi.getter(name="p2SVpnServerConfigVpnClientRootCertificates")
      def p2_s_vpn_server_config_vpn_client_root_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigVpnClientRootCertificateArgs']]]]:
          """
          VPN client root certificate of P2SVpnServerConfiguration.
          """
          return pulumi.get(self, "p2_s_vpn_server_config_vpn_client_root_certificates")
  
      @p2_s_vpn_server_config_vpn_client_root_certificates.setter
      def p2_s_vpn_server_config_vpn_client_root_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['P2SVpnServerConfigVpnClientRootCertificateArgs']]]]):
          pulumi.set(self, "p2_s_vpn_server_config_vpn_client_root_certificates", value)
  
      @property
      @pulumi.getter(name="radiusServerAddress")
      def radius_server_address(self) -> Optional[pulumi.Input[str]]:
          """
          The radius server address property of the P2SVpnServerConfiguration resource for point to site client connection.
          """
          return pulumi.get(self, "radius_server_address")
  
      @radius_server_address.setter
      def radius_server_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "radius_server_address", value)
  
      @property
      @pulumi.getter(name="radiusServerSecret")
      def radius_server_secret(self) -> Optional[pulumi.Input[str]]:
          """
          The radius secret property of the P2SVpnServerConfiguration resource for point to site client connection.
          """
          return pulumi.get(self, "radius_server_secret")
  
      @radius_server_secret.setter
      def radius_server_secret(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "radius_server_secret", value)
  
      @property
      @pulumi.getter(name="vpnClientIpsecPolicies")
      def vpn_client_ipsec_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IpsecPolicyArgs']]]]:
          """
          VpnClientIpsecPolicies for P2SVpnServerConfiguration.
          """
          return pulumi.get(self, "vpn_client_ipsec_policies")
  
      @vpn_client_ipsec_policies.setter
      def vpn_client_ipsec_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['IpsecPolicyArgs']]]]):
          pulumi.set(self, "vpn_client_ipsec_policies", value)
  
      @property
      @pulumi.getter(name="vpnProtocols")
      def vpn_protocols(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'VpnGatewayTunnelingProtocol']]]]]:
          """
          vpnProtocols for the P2SVpnServerConfiguration.
          """
          return pulumi.get(self, "vpn_protocols")
  
      @vpn_protocols.setter
      def vpn_protocols(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'VpnGatewayTunnelingProtocol']]]]]):
          pulumi.set(self, "vpn_protocols", value)
  
  
  @pulumi.input_type
  class PacketCaptureFilterArgs:
      def __init__(__self__, *,
                   local_ip_address: Optional[pulumi.Input[str]] = None,
                   local_port: Optional[pulumi.Input[str]] = None,
                   protocol: Optional[pulumi.Input[Union[str, 'PcProtocol']]] = None,
                   remote_ip_address: Optional[pulumi.Input[str]] = None,
                   remote_port: Optional[pulumi.Input[str]] = None):
          """
          Filter that is applied to packet capture request. Multiple filters can be applied.
          :param pulumi.Input[str] local_ip_address: 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. Default = null.
          :param pulumi.Input[str] local_port: 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. Default = null.
          :param pulumi.Input[Union[str, 'PcProtocol']] protocol: Protocol to be filtered on.
          :param pulumi.Input[str] remote_ip_address: 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. Default = null.
          :param pulumi.Input[str] remote_port: 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. Default = null.
          """
          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 protocol is None:
              protocol = 'Any'
          if protocol is not None:
              pulumi.set(__self__, "protocol", protocol)
          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(name="localIPAddress")
      def local_ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          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. Default = null.
          """
          return pulumi.get(self, "local_ip_address")
  
      @local_ip_address.setter
      def local_ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "local_ip_address", value)
  
      @property
      @pulumi.getter(name="localPort")
      def local_port(self) -> Optional[pulumi.Input[str]]:
          """
          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. Default = null.
          """
          return pulumi.get(self, "local_port")
  
      @local_port.setter
      def local_port(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "local_port", value)
  
      @property
      @pulumi.getter
      def protocol(self) -> Optional[pulumi.Input[Union[str, 'PcProtocol']]]:
          """
          Protocol to be filtered on.
          """
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: Optional[pulumi.Input[Union[str, 'PcProtocol']]]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter(name="remoteIPAddress")
      def remote_ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          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. Default = null.
          """
          return pulumi.get(self, "remote_ip_address")
  
      @remote_ip_address.setter
      def remote_ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "remote_ip_address", value)
  
      @property
      @pulumi.getter(name="remotePort")
      def remote_port(self) -> Optional[pulumi.Input[str]]:
          """
          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. Default = null.
          """
          return pulumi.get(self, "remote_port")
  
      @remote_port.setter
      def remote_port(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "remote_port", value)
  
  
  @pulumi.input_type
  class PacketCaptureStorageLocationArgs:
      def __init__(__self__, *,
                   file_path: Optional[pulumi.Input[str]] = None,
                   storage_id: Optional[pulumi.Input[str]] = None,
                   storage_path: Optional[pulumi.Input[str]] = None):
          """
          Describes the storage location for a packet capture session.
          :param pulumi.Input[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. Required if no storage ID is provided, otherwise optional.
          :param pulumi.Input[str] storage_id: The ID of the storage account to save the packet capture session. Required if no local file path is provided.
          :param pulumi.Input[str] storage_path: The URI of the storage path to save the packet capture. Must be a well-formed URI describing the location to save the packet capture.
          """
          if file_path is not None:
              pulumi.set(__self__, "file_path", file_path)
          if storage_id is not None:
              pulumi.set(__self__, "storage_id", storage_id)
          if storage_path is not None:
              pulumi.set(__self__, "storage_path", storage_path)
  
      @property
      @pulumi.getter(name="filePath")
      def file_path(self) -> Optional[pulumi.Input[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. Required if no storage ID is provided, otherwise optional.
          """
          return pulumi.get(self, "file_path")
  
      @file_path.setter
      def file_path(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "file_path", value)
  
      @property
      @pulumi.getter(name="storageId")
      def storage_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the storage account to save the packet capture session. Required if no local file path is provided.
          """
          return pulumi.get(self, "storage_id")
  
      @storage_id.setter
      def storage_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "storage_id", value)
  
      @property
      @pulumi.getter(name="storagePath")
      def storage_path(self) -> Optional[pulumi.Input[str]]:
          """
          The URI of the storage path to save the packet capture. Must be a well-formed URI describing the location to save the packet capture.
          """
          return pulumi.get(self, "storage_path")
  
      @storage_path.setter
      def storage_path(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "storage_path", value)
  
  
  @pulumi.input_type
  class ProbeArgs:
      def __init__(__self__, *,
                   port: pulumi.Input[int],
                   protocol: pulumi.Input[Union[str, 'ProbeProtocol']],
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   interval_in_seconds: Optional[pulumi.Input[int]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   number_of_probes: Optional[pulumi.Input[int]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   request_path: Optional[pulumi.Input[str]] = None):
          """
          A load balancer probe.
          :param pulumi.Input[int] port: The port for communicating the probe. Possible values range from 1 to 65535, inclusive.
          :param pulumi.Input[Union[str, 'ProbeProtocol']] protocol: The protocol of the end point. Possible values are: 'Http', 'Tcp', or 'Https'. If 'Tcp' is specified, a received ACK is required for the probe to be successful. If 'Http' or 'Https' is specified, a 200 OK response from the specifies URI is required for the probe to be successful.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[int] interval_in_seconds: The interval, in seconds, for how frequently to probe the endpoint for health status. Typically, the interval is slightly less than half the allocated timeout period (in seconds) which allows two full probes before taking the instance out of rotation. The default value is 15, the minimum value is 5.
          :param pulumi.Input[str] name: Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[int] number_of_probes: The number of probes where if no response, will result in stopping further traffic from being delivered to the endpoint. This values allows endpoints to be taken out of rotation faster or slower than the typical times used in Azure.
          :param pulumi.Input[str] provisioning_state: Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input[str] request_path: The URI used for requesting health status from the VM. Path is required if a protocol is set to http. Otherwise, it is not allowed. There is no default value.
          """
          pulumi.set(__self__, "port", port)
          pulumi.set(__self__, "protocol", protocol)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if interval_in_seconds is not None:
              pulumi.set(__self__, "interval_in_seconds", interval_in_seconds)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if number_of_probes is not None:
              pulumi.set(__self__, "number_of_probes", number_of_probes)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if request_path is not None:
              pulumi.set(__self__, "request_path", request_path)
  
      @property
      @pulumi.getter
      def port(self) -> pulumi.Input[int]:
          """
          The port for communicating the probe. Possible values range from 1 to 65535, inclusive.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: pulumi.Input[int]):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter
      def protocol(self) -> pulumi.Input[Union[str, 'ProbeProtocol']]:
          """
          The protocol of the end point. Possible values are: 'Http', 'Tcp', or 'Https'. If 'Tcp' is specified, a received ACK is required for the probe to be successful. If 'Http' or 'Https' is specified, a 200 OK response from the specifies URI is required for the probe to be successful.
          """
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: pulumi.Input[Union[str, 'ProbeProtocol']]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="intervalInSeconds")
      def interval_in_seconds(self) -> Optional[pulumi.Input[int]]:
          """
          The interval, in seconds, for how frequently to probe the endpoint for health status. Typically, the interval is slightly less than half the allocated timeout period (in seconds) which allows two full probes before taking the instance out of rotation. The default value is 15, the minimum value is 5.
          """
          return pulumi.get(self, "interval_in_seconds")
  
      @interval_in_seconds.setter
      def interval_in_seconds(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "interval_in_seconds", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="numberOfProbes")
      def number_of_probes(self) -> Optional[pulumi.Input[int]]:
          """
          The number of probes where if no response, will result in stopping further traffic from being delivered to the endpoint. This values allows endpoints to be taken out of rotation faster or slower than the typical times used in Azure.
          """
          return pulumi.get(self, "number_of_probes")
  
      @number_of_probes.setter
      def number_of_probes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "number_of_probes", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter(name="requestPath")
      def request_path(self) -> Optional[pulumi.Input[str]]:
          """
          The URI used for requesting health status from the VM. Path is required if a protocol is set to http. Otherwise, it is not allowed. There is no default value.
          """
          return pulumi.get(self, "request_path")
  
      @request_path.setter
      def request_path(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "request_path", value)
  
  
  @pulumi.input_type
  class ProtocolCustomSettingsFormatArgs:
      def __init__(__self__, *,
                   protocol: Optional[pulumi.Input[Union[str, 'DdosCustomPolicyProtocol']]] = None,
                   source_rate_override: Optional[pulumi.Input[str]] = None,
                   trigger_rate_override: Optional[pulumi.Input[str]] = None,
                   trigger_sensitivity_override: Optional[pulumi.Input[Union[str, 'DdosCustomPolicyTriggerSensitivityOverride']]] = None):
          """
          DDoS custom policy properties.
          :param pulumi.Input[Union[str, 'DdosCustomPolicyProtocol']] protocol: The protocol for which the DDoS protection policy is being customized.
          :param pulumi.Input[str] source_rate_override: The customized DDoS protection source rate.
          :param pulumi.Input[str] trigger_rate_override: The customized DDoS protection trigger rate.
          :param pulumi.Input[Union[str, 'DdosCustomPolicyTriggerSensitivityOverride']] trigger_sensitivity_override: The customized DDoS protection trigger rate sensitivity degrees. High: Trigger rate set with most sensitivity w.r.t. normal traffic. Default: Trigger rate set with moderate sensitivity w.r.t. normal traffic. Low: Trigger rate set with less sensitivity w.r.t. normal traffic. Relaxed: Trigger rate set with least sensitivity w.r.t. normal traffic.
          """
          if protocol is not None:
              pulumi.set(__self__, "protocol", protocol)
          if source_rate_override is not None:
              pulumi.set(__self__, "source_rate_override", source_rate_override)
          if trigger_rate_override is not None:
              pulumi.set(__self__, "trigger_rate_override", trigger_rate_override)
          if trigger_sensitivity_override is not None:
              pulumi.set(__self__, "trigger_sensitivity_override", trigger_sensitivity_override)
  
      @property
      @pulumi.getter
      def protocol(self) -> Optional[pulumi.Input[Union[str, 'DdosCustomPolicyProtocol']]]:
          """
          The protocol for which the DDoS protection policy is being customized.
          """
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: Optional[pulumi.Input[Union[str, 'DdosCustomPolicyProtocol']]]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter(name="sourceRateOverride")
      def source_rate_override(self) -> Optional[pulumi.Input[str]]:
          """
          The customized DDoS protection source rate.
          """
          return pulumi.get(self, "source_rate_override")
  
      @source_rate_override.setter
      def source_rate_override(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "source_rate_override", value)
  
      @property
      @pulumi.getter(name="triggerRateOverride")
      def trigger_rate_override(self) -> Optional[pulumi.Input[str]]:
          """
          The customized DDoS protection trigger rate.
          """
          return pulumi.get(self, "trigger_rate_override")
  
      @trigger_rate_override.setter
      def trigger_rate_override(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "trigger_rate_override", value)
  
      @property
      @pulumi.getter(name="triggerSensitivityOverride")
      def trigger_sensitivity_override(self) -> Optional[pulumi.Input[Union[str, 'DdosCustomPolicyTriggerSensitivityOverride']]]:
          """
          The customized DDoS protection trigger rate sensitivity degrees. High: Trigger rate set with most sensitivity w.r.t. normal traffic. Default: Trigger rate set with moderate sensitivity w.r.t. normal traffic. Low: Trigger rate set with less sensitivity w.r.t. normal traffic. Relaxed: Trigger rate set with least sensitivity w.r.t. normal traffic.
          """
          return pulumi.get(self, "trigger_sensitivity_override")
  
      @trigger_sensitivity_override.setter
      def trigger_sensitivity_override(self, value: Optional[pulumi.Input[Union[str, 'DdosCustomPolicyTriggerSensitivityOverride']]]):
          pulumi.set(self, "trigger_sensitivity_override", value)
  
  
  @pulumi.input_type
  class PublicIPAddressArgs:
      def __init__(__self__, *,
                   ddos_settings: Optional[pulumi.Input['DdosSettingsArgs']] = None,
                   dns_settings: Optional[pulumi.Input['PublicIPAddressDnsSettingsArgs']] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   idle_timeout_in_minutes: Optional[pulumi.Input[int]] = None,
                   ip_address: Optional[pulumi.Input[str]] = None,
                   ip_tags: Optional[pulumi.Input[Sequence[pulumi.Input['IpTagArgs']]]] = None,
                   location: Optional[pulumi.Input[str]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   public_ip_address_version: Optional[pulumi.Input[Union[str, 'IPVersion']]] = None,
                   public_ip_allocation_method: Optional[pulumi.Input[Union[str, 'IPAllocationMethod']]] = None,
                   public_ip_prefix: Optional[pulumi.Input['SubResourceArgs']] = None,
                   resource_guid: Optional[pulumi.Input[str]] = None,
                   sku: Optional[pulumi.Input['PublicIPAddressSkuArgs']] = None,
                   tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          Public IP address resource.
          :param pulumi.Input['DdosSettingsArgs'] ddos_settings: The DDoS protection custom policy associated with the public IP address.
          :param pulumi.Input['PublicIPAddressDnsSettingsArgs'] dns_settings: The FQDN of the DNS record associated with the public IP address.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[int] idle_timeout_in_minutes: The idle timeout of the public IP address.
          :param pulumi.Input[str] ip_address: The IP address associated with the public IP address resource.
          :param pulumi.Input[Sequence[pulumi.Input['IpTagArgs']]] ip_tags: The list of tags associated with the public IP address.
          :param pulumi.Input[str] location: Resource location.
          :param pulumi.Input[str] provisioning_state: The provisioning state of the PublicIP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input[Union[str, 'IPVersion']] public_ip_address_version: The public IP address version. Possible values are: 'IPv4' and 'IPv6'.
          :param pulumi.Input[Union[str, 'IPAllocationMethod']] public_ip_allocation_method: The public IP allocation method. Possible values are: 'Static' and 'Dynamic'.
          :param pulumi.Input['SubResourceArgs'] public_ip_prefix: The Public IP Prefix this Public IP Address should be allocated from.
          :param pulumi.Input[str] resource_guid: The resource GUID property of the public IP resource.
          :param pulumi.Input['PublicIPAddressSkuArgs'] sku: The public IP address SKU.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] zones: A list of availability zones denoting the IP allocated for the resource needs to come from.
          """
          if ddos_settings is not None:
              pulumi.set(__self__, "ddos_settings", ddos_settings)
          if dns_settings is not None:
              pulumi.set(__self__, "dns_settings", dns_settings)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if idle_timeout_in_minutes is not None:
              pulumi.set(__self__, "idle_timeout_in_minutes", idle_timeout_in_minutes)
          if ip_address is not None:
              pulumi.set(__self__, "ip_address", ip_address)
          if ip_tags is not None:
              pulumi.set(__self__, "ip_tags", ip_tags)
          if location is not None:
              pulumi.set(__self__, "location", location)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if public_ip_address_version is not None:
              pulumi.set(__self__, "public_ip_address_version", public_ip_address_version)
          if public_ip_allocation_method is not None:
              pulumi.set(__self__, "public_ip_allocation_method", public_ip_allocation_method)
          if public_ip_prefix is not None:
              pulumi.set(__self__, "public_ip_prefix", public_ip_prefix)
          if resource_guid is not None:
              pulumi.set(__self__, "resource_guid", resource_guid)
          if sku is not None:
              pulumi.set(__self__, "sku", sku)
          if tags is not None:
              pulumi.set(__self__, "tags", tags)
          if zones is not None:
              pulumi.set(__self__, "zones", zones)
  
      @property
      @pulumi.getter(name="ddosSettings")
      def ddos_settings(self) -> Optional[pulumi.Input['DdosSettingsArgs']]:
          """
          The DDoS protection custom policy associated with the public IP address.
          """
          return pulumi.get(self, "ddos_settings")
  
      @ddos_settings.setter
      def ddos_settings(self, value: Optional[pulumi.Input['DdosSettingsArgs']]):
          pulumi.set(self, "ddos_settings", value)
  
      @property
      @pulumi.getter(name="dnsSettings")
      def dns_settings(self) -> Optional[pulumi.Input['PublicIPAddressDnsSettingsArgs']]:
          """
          The FQDN of the DNS record associated with the public IP address.
          """
          return pulumi.get(self, "dns_settings")
  
      @dns_settings.setter
      def dns_settings(self, value: Optional[pulumi.Input['PublicIPAddressDnsSettingsArgs']]):
          pulumi.set(self, "dns_settings", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="idleTimeoutInMinutes")
      def idle_timeout_in_minutes(self) -> Optional[pulumi.Input[int]]:
          """
          The idle timeout of the public IP address.
          """
          return pulumi.get(self, "idle_timeout_in_minutes")
  
      @idle_timeout_in_minutes.setter
      def idle_timeout_in_minutes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "idle_timeout_in_minutes", value)
  
      @property
      @pulumi.getter(name="ipAddress")
      def ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          The IP address associated with the public IP address resource.
          """
          return pulumi.get(self, "ip_address")
  
      @ip_address.setter
      def ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "ip_address", value)
  
      @property
      @pulumi.getter(name="ipTags")
      def ip_tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IpTagArgs']]]]:
          """
          The list of tags associated with the public IP address.
          """
          return pulumi.get(self, "ip_tags")
  
      @ip_tags.setter
      def ip_tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['IpTagArgs']]]]):
          pulumi.set(self, "ip_tags", value)
  
      @property
      @pulumi.getter
      def location(self) -> Optional[pulumi.Input[str]]:
          """
          Resource location.
          """
          return pulumi.get(self, "location")
  
      @location.setter
      def location(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "location", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          The provisioning state of the PublicIP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter(name="publicIPAddressVersion")
      def public_ip_address_version(self) -> Optional[pulumi.Input[Union[str, 'IPVersion']]]:
          """
          The public IP address version. Possible values are: 'IPv4' and 'IPv6'.
          """
          return pulumi.get(self, "public_ip_address_version")
  
      @public_ip_address_version.setter
      def public_ip_address_version(self, value: Optional[pulumi.Input[Union[str, 'IPVersion']]]):
          pulumi.set(self, "public_ip_address_version", value)
  
      @property
      @pulumi.getter(name="publicIPAllocationMethod")
      def public_ip_allocation_method(self) -> Optional[pulumi.Input[Union[str, 'IPAllocationMethod']]]:
          """
          The public IP allocation method. Possible values are: 'Static' and 'Dynamic'.
          """
          return pulumi.get(self, "public_ip_allocation_method")
  
      @public_ip_allocation_method.setter
      def public_ip_allocation_method(self, value: Optional[pulumi.Input[Union[str, 'IPAllocationMethod']]]):
          pulumi.set(self, "public_ip_allocation_method", value)
  
      @property
      @pulumi.getter(name="publicIPPrefix")
      def public_ip_prefix(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          The Public IP Prefix this Public IP Address should be allocated from.
          """
          return pulumi.get(self, "public_ip_prefix")
  
      @public_ip_prefix.setter
      def public_ip_prefix(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "public_ip_prefix", value)
  
      @property
      @pulumi.getter(name="resourceGuid")
      def resource_guid(self) -> Optional[pulumi.Input[str]]:
          """
          The resource GUID property of the public IP resource.
          """
          return pulumi.get(self, "resource_guid")
  
      @resource_guid.setter
      def resource_guid(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "resource_guid", value)
  
      @property
      @pulumi.getter
      def sku(self) -> Optional[pulumi.Input['PublicIPAddressSkuArgs']]:
          """
          The public IP address SKU.
          """
          return pulumi.get(self, "sku")
  
      @sku.setter
      def sku(self, value: Optional[pulumi.Input['PublicIPAddressSkuArgs']]):
          pulumi.set(self, "sku", value)
  
      @property
      @pulumi.getter
      def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Resource tags.
          """
          return pulumi.get(self, "tags")
  
      @tags.setter
      def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "tags", value)
  
      @property
      @pulumi.getter
      def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          A list of availability zones denoting the IP allocated for the resource needs to come from.
          """
          return pulumi.get(self, "zones")
  
      @zones.setter
      def zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "zones", value)
  
  
  @pulumi.input_type
  class PublicIPAddressDnsSettingsArgs:
      def __init__(__self__, *,
                   domain_name_label: Optional[pulumi.Input[str]] = None,
                   fqdn: Optional[pulumi.Input[str]] = None,
                   reverse_fqdn: Optional[pulumi.Input[str]] = None):
          """
          Contains FQDN of the DNS record associated with the public IP address
          :param pulumi.Input[str] domain_name_label: Gets or sets the Domain name label.The concatenation of the domain name label and the regionalized DNS zone make up the fully qualified domain name associated with the public IP address. If a domain name label is specified, an A DNS record is created for the public IP in the Microsoft Azure DNS system.
          :param pulumi.Input[str] fqdn: Gets the FQDN, Fully qualified domain name of the A DNS record associated with the public IP. This is the concatenation of the domainNameLabel and the regionalized DNS zone.
          :param pulumi.Input[str] reverse_fqdn: Gets or Sets the Reverse FQDN. A user-visible, fully qualified domain name that resolves to this public IP address. If the reverseFqdn is specified, then a PTR DNS record is created pointing from the IP address in the in-addr.arpa domain to the reverse FQDN. 
          """
          if domain_name_label is not None:
              pulumi.set(__self__, "domain_name_label", domain_name_label)
          if fqdn is not None:
              pulumi.set(__self__, "fqdn", fqdn)
          if reverse_fqdn is not None:
              pulumi.set(__self__, "reverse_fqdn", reverse_fqdn)
  
      @property
      @pulumi.getter(name="domainNameLabel")
      def domain_name_label(self) -> Optional[pulumi.Input[str]]:
          """
          Gets or sets the Domain name label.The concatenation of the domain name label and the regionalized DNS zone make up the fully qualified domain name associated with the public IP address. If a domain name label is specified, an A DNS record is created for the public IP in the Microsoft Azure DNS system.
          """
          return pulumi.get(self, "domain_name_label")
  
      @domain_name_label.setter
      def domain_name_label(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "domain_name_label", value)
  
      @property
      @pulumi.getter
      def fqdn(self) -> Optional[pulumi.Input[str]]:
          """
          Gets the FQDN, Fully qualified domain name of the A DNS record associated with the public IP. This is the concatenation of the domainNameLabel and the regionalized DNS zone.
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "fqdn", value)
  
      @property
      @pulumi.getter(name="reverseFqdn")
      def reverse_fqdn(self) -> Optional[pulumi.Input[str]]:
          """
          Gets or Sets the Reverse FQDN. A user-visible, fully qualified domain name that resolves to this public IP address. If the reverseFqdn is specified, then a PTR DNS record is created pointing from the IP address in the in-addr.arpa domain to the reverse FQDN. 
          """
          return pulumi.get(self, "reverse_fqdn")
  
      @reverse_fqdn.setter
      def reverse_fqdn(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "reverse_fqdn", value)
  
  
  @pulumi.input_type
  class PublicIPAddressSkuArgs:
      def __init__(__self__, *,
                   name: Optional[pulumi.Input[Union[str, 'PublicIPAddressSkuName']]] = None):
          """
          SKU of a public IP address
          :param pulumi.Input[Union[str, 'PublicIPAddressSkuName']] name: Name of a public IP address SKU.
          """
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[Union[str, 'PublicIPAddressSkuName']]]:
          """
          Name of a public IP address SKU.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[Union[str, 'PublicIPAddressSkuName']]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class PublicIPPrefixSkuArgs:
      def __init__(__self__, *,
                   name: Optional[pulumi.Input[Union[str, 'PublicIPPrefixSkuName']]] = None):
          """
          SKU of a public IP prefix
          :param pulumi.Input[Union[str, 'PublicIPPrefixSkuName']] name: Name of a public IP prefix SKU.
          """
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[Union[str, 'PublicIPPrefixSkuName']]]:
          """
          Name of a public IP prefix SKU.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[Union[str, 'PublicIPPrefixSkuName']]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class ReferencedPublicIpAddressArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] id: The PublicIPAddress Reference
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          The PublicIPAddress Reference
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
  
  @pulumi.input_type
  class ResourceNavigationLinkArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None,
                   link: Optional[pulumi.Input[str]] = None,
                   linked_resource_type: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None):
          """
          ResourceNavigationLink resource.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] link: Link to the external resource
          :param pulumi.Input[str] linked_resource_type: Resource type of the linked resource.
          :param pulumi.Input[str] name: Name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
          if link is not None:
              pulumi.set(__self__, "link", link)
          if linked_resource_type is not None:
              pulumi.set(__self__, "linked_resource_type", linked_resource_type)
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def link(self) -> Optional[pulumi.Input[str]]:
          """
          Link to the external resource
          """
          return pulumi.get(self, "link")
  
      @link.setter
      def link(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "link", value)
  
      @property
      @pulumi.getter(name="linkedResourceType")
      def linked_resource_type(self) -> Optional[pulumi.Input[str]]:
          """
          Resource type of the linked resource.
          """
          return pulumi.get(self, "linked_resource_type")
  
      @linked_resource_type.setter
      def linked_resource_type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "linked_resource_type", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class RouteArgs:
      def __init__(__self__, *,
                   next_hop_type: pulumi.Input[Union[str, 'RouteNextHopType']],
                   address_prefix: Optional[pulumi.Input[str]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   next_hop_ip_address: Optional[pulumi.Input[str]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None):
          """
          Route resource
          :param pulumi.Input[Union[str, 'RouteNextHopType']] next_hop_type: The type of Azure hop the packet should be sent to. Possible values are: 'VirtualNetworkGateway', 'VnetLocal', 'Internet', 'VirtualAppliance', and 'None'
          :param pulumi.Input[str] address_prefix: The destination CIDR to which the route applies.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[str] next_hop_ip_address: The IP address packets should be forwarded to. Next hop values are only allowed in routes where the next hop type is VirtualAppliance.
          :param pulumi.Input[str] provisioning_state: The provisioning state of the resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          pulumi.set(__self__, "next_hop_type", next_hop_type)
          if address_prefix is not None:
              pulumi.set(__self__, "address_prefix", address_prefix)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if next_hop_ip_address is not None:
              pulumi.set(__self__, "next_hop_ip_address", next_hop_ip_address)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
  
      @property
      @pulumi.getter(name="nextHopType")
      def next_hop_type(self) -> pulumi.Input[Union[str, 'RouteNextHopType']]:
          """
          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")
  
      @next_hop_type.setter
      def next_hop_type(self, value: pulumi.Input[Union[str, 'RouteNextHopType']]):
          pulumi.set(self, "next_hop_type", value)
  
      @property
      @pulumi.getter(name="addressPrefix")
      def address_prefix(self) -> Optional[pulumi.Input[str]]:
          """
          The destination CIDR to which the route applies.
          """
          return pulumi.get(self, "address_prefix")
  
      @address_prefix.setter
      def address_prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "address_prefix", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="nextHopIpAddress")
      def next_hop_ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          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_ip_address")
  
      @next_hop_ip_address.setter
      def next_hop_ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "next_hop_ip_address", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          The provisioning state of the resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
  
  @pulumi.input_type
  class RouteFilterArgs:
      def __init__(__self__, *,
                   location: pulumi.Input[str],
                   id: Optional[pulumi.Input[str]] = None,
                   peerings: Optional[pulumi.Input[Sequence[pulumi.Input['ExpressRouteCircuitPeeringArgs']]]] = None,
                   rules: Optional[pulumi.Input[Sequence[pulumi.Input['RouteFilterRuleArgs']]]] = None,
                   tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
          """
          Route Filter Resource.
          :param pulumi.Input[str] location: Resource location.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[Sequence[pulumi.Input['ExpressRouteCircuitPeeringArgs']]] peerings: A collection of references to express route circuit peerings.
          :param pulumi.Input[Sequence[pulumi.Input['RouteFilterRuleArgs']]] rules: Collection of RouteFilterRules contained within a route filter.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags.
          """
          pulumi.set(__self__, "location", location)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if peerings is not None:
              pulumi.set(__self__, "peerings", peerings)
          if rules is not None:
              pulumi.set(__self__, "rules", rules)
          if tags is not None:
              pulumi.set(__self__, "tags", tags)
  
      @property
      @pulumi.getter
      def location(self) -> pulumi.Input[str]:
          """
          Resource location.
          """
          return pulumi.get(self, "location")
  
      @location.setter
      def location(self, value: pulumi.Input[str]):
          pulumi.set(self, "location", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def peerings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ExpressRouteCircuitPeeringArgs']]]]:
          """
          A collection of references to express route circuit peerings.
          """
          return pulumi.get(self, "peerings")
  
      @peerings.setter
      def peerings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ExpressRouteCircuitPeeringArgs']]]]):
          pulumi.set(self, "peerings", value)
  
      @property
      @pulumi.getter
      def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouteFilterRuleArgs']]]]:
          """
          Collection of RouteFilterRules contained within a route filter.
          """
          return pulumi.get(self, "rules")
  
      @rules.setter
      def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RouteFilterRuleArgs']]]]):
          pulumi.set(self, "rules", value)
  
      @property
      @pulumi.getter
      def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Resource tags.
          """
          return pulumi.get(self, "tags")
  
      @tags.setter
      def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "tags", value)
  
  
  @pulumi.input_type
  class RouteFilterRuleArgs:
      def __init__(__self__, *,
                   access: pulumi.Input[Union[str, 'Access']],
                   communities: pulumi.Input[Sequence[pulumi.Input[str]]],
                   route_filter_rule_type: pulumi.Input[Union[str, 'RouteFilterRuleType']],
                   id: Optional[pulumi.Input[str]] = None,
                   location: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None):
          """
          Route Filter Rule Resource
          :param pulumi.Input[Union[str, 'Access']] access: The access type of the rule. Valid values are: 'Allow', 'Deny'
          :param pulumi.Input[Sequence[pulumi.Input[str]]] communities: The collection for bgp community values to filter on. e.g. ['12076:5010','12076:5020']
          :param pulumi.Input[Union[str, 'RouteFilterRuleType']] route_filter_rule_type: The rule type of the rule. Valid value is: 'Community'
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] location: Resource location.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          pulumi.set(__self__, "access", access)
          pulumi.set(__self__, "communities", communities)
          pulumi.set(__self__, "route_filter_rule_type", route_filter_rule_type)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if location is not None:
              pulumi.set(__self__, "location", location)
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def access(self) -> pulumi.Input[Union[str, 'Access']]:
          """
          The access type of the rule. Valid values are: 'Allow', 'Deny'
          """
          return pulumi.get(self, "access")
  
      @access.setter
      def access(self, value: pulumi.Input[Union[str, 'Access']]):
          pulumi.set(self, "access", value)
  
      @property
      @pulumi.getter
      def communities(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          """
          The collection for bgp community values to filter on. e.g. ['12076:5010','12076:5020']
          """
          return pulumi.get(self, "communities")
  
      @communities.setter
      def communities(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "communities", value)
  
      @property
      @pulumi.getter(name="routeFilterRuleType")
      def route_filter_rule_type(self) -> pulumi.Input[Union[str, 'RouteFilterRuleType']]:
          """
          The rule type of the rule. Valid value is: 'Community'
          """
          return pulumi.get(self, "route_filter_rule_type")
  
      @route_filter_rule_type.setter
      def route_filter_rule_type(self, value: pulumi.Input[Union[str, 'RouteFilterRuleType']]):
          pulumi.set(self, "route_filter_rule_type", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def location(self) -> Optional[pulumi.Input[str]]:
          """
          Resource location.
          """
          return pulumi.get(self, "location")
  
      @location.setter
      def location(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "location", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class RouteTableArgs:
      def __init__(__self__, *,
                   disable_bgp_route_propagation: Optional[pulumi.Input[bool]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   location: Optional[pulumi.Input[str]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   routes: Optional[pulumi.Input[Sequence[pulumi.Input['RouteArgs']]]] = None,
                   tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
          """
          Route table resource.
          :param pulumi.Input[bool] disable_bgp_route_propagation: Gets or sets whether to disable the routes learned by BGP on that route table. True means disable.
          :param pulumi.Input[str] etag: Gets a unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] location: Resource location.
          :param pulumi.Input[str] provisioning_state: The provisioning state of the resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input[Sequence[pulumi.Input['RouteArgs']]] routes: Collection of routes contained within a route table.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags.
          """
          if disable_bgp_route_propagation is not None:
              pulumi.set(__self__, "disable_bgp_route_propagation", disable_bgp_route_propagation)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if location is not None:
              pulumi.set(__self__, "location", location)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if routes is not None:
              pulumi.set(__self__, "routes", routes)
          if tags is not None:
              pulumi.set(__self__, "tags", tags)
  
      @property
      @pulumi.getter(name="disableBgpRoutePropagation")
      def disable_bgp_route_propagation(self) -> Optional[pulumi.Input[bool]]:
          """
          Gets or sets whether to disable the routes learned by BGP on that route table. True means disable.
          """
          return pulumi.get(self, "disable_bgp_route_propagation")
  
      @disable_bgp_route_propagation.setter
      def disable_bgp_route_propagation(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "disable_bgp_route_propagation", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          Gets a unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def location(self) -> Optional[pulumi.Input[str]]:
          """
          Resource location.
          """
          return pulumi.get(self, "location")
  
      @location.setter
      def location(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "location", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          The provisioning state of the resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter
      def routes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouteArgs']]]]:
          """
          Collection of routes contained within a route table.
          """
          return pulumi.get(self, "routes")
  
      @routes.setter
      def routes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RouteArgs']]]]):
          pulumi.set(self, "routes", value)
  
      @property
      @pulumi.getter
      def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Resource tags.
          """
          return pulumi.get(self, "tags")
  
      @tags.setter
      def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "tags", value)
  
  
  @pulumi.input_type
  class SecurityRuleArgs:
      def __init__(__self__, *,
                   access: pulumi.Input[Union[str, 'SecurityRuleAccess']],
                   direction: pulumi.Input[Union[str, 'SecurityRuleDirection']],
                   protocol: pulumi.Input[Union[str, 'SecurityRuleProtocol']],
                   description: Optional[pulumi.Input[str]] = None,
                   destination_address_prefix: Optional[pulumi.Input[str]] = None,
                   destination_address_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   destination_application_security_groups: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSecurityGroupArgs']]]] = None,
                   destination_port_range: Optional[pulumi.Input[str]] = None,
                   destination_port_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   priority: Optional[pulumi.Input[int]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   source_address_prefix: Optional[pulumi.Input[str]] = None,
                   source_address_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   source_application_security_groups: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSecurityGroupArgs']]]] = None,
                   source_port_range: Optional[pulumi.Input[str]] = None,
                   source_port_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          Network security rule.
          :param pulumi.Input[Union[str, 'SecurityRuleAccess']] access: The network traffic is allowed or denied. Possible values are: 'Allow' and 'Deny'.
          :param pulumi.Input[Union[str, 'SecurityRuleDirection']] direction: The direction of the rule. The direction specifies if rule will be evaluated on incoming or outgoing traffic. Possible values are: 'Inbound' and 'Outbound'.
          :param pulumi.Input[Union[str, 'SecurityRuleProtocol']] protocol: Network protocol this rule applies to. Possible values are 'Tcp', 'Udp', and '*'.
          :param pulumi.Input[str] description: A description for this rule. Restricted to 140 chars.
          :param pulumi.Input[str] destination_address_prefix: The destination address prefix. CIDR or destination IP range. Asterisks '*' can also be used to match all source IPs. Default tags such as 'VirtualNetwork', 'AzureLoadBalancer' and 'Internet' can also be used.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] destination_address_prefixes: The destination address prefixes. CIDR or destination IP ranges.
          :param pulumi.Input[Sequence[pulumi.Input['ApplicationSecurityGroupArgs']]] destination_application_security_groups: The application security group specified as destination.
          :param pulumi.Input[str] destination_port_range: The destination port or range. Integer or range between 0 and 65535. Asterisks '*' can also be used to match all ports.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] destination_port_ranges: The destination port ranges.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[int] priority: 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 pulumi.Input[str] provisioning_state: The provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          :param pulumi.Input[str] source_address_prefix: The CIDR or source IP range. Asterisks '*' can also be used to match all source IPs. Default tags such as 'VirtualNetwork', 'AzureLoadBalancer' and 'Internet' can also be used. If this is an ingress rule, specifies where network traffic originates from. 
          :param pulumi.Input[Sequence[pulumi.Input[str]]] source_address_prefixes: The CIDR or source IP ranges.
          :param pulumi.Input[Sequence[pulumi.Input['ApplicationSecurityGroupArgs']]] source_application_security_groups: The application security group specified as source.
          :param pulumi.Input[str] source_port_range: The source port or range. Integer or range between 0 and 65535. Asterisks '*' can also be used to match all ports.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] source_port_ranges: The source port ranges.
          """
          pulumi.set(__self__, "access", access)
          pulumi.set(__self__, "direction", direction)
          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_groups is not None:
              pulumi.set(__self__, "destination_application_security_groups", destination_application_security_groups)
          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 etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if priority is not None:
              pulumi.set(__self__, "priority", priority)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          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_groups is not None:
              pulumi.set(__self__, "source_application_security_groups", source_application_security_groups)
          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) -> pulumi.Input[Union[str, 'SecurityRuleAccess']]:
          """
          The network traffic is allowed or denied. Possible values are: 'Allow' and 'Deny'.
          """
          return pulumi.get(self, "access")
  
      @access.setter
      def access(self, value: pulumi.Input[Union[str, 'SecurityRuleAccess']]):
          pulumi.set(self, "access", value)
  
      @property
      @pulumi.getter
      def direction(self) -> pulumi.Input[Union[str, 'SecurityRuleDirection']]:
          """
          The direction of the rule. The direction specifies if rule will be evaluated on incoming or outgoing traffic. Possible values are: 'Inbound' and 'Outbound'.
          """
          return pulumi.get(self, "direction")
  
      @direction.setter
      def direction(self, value: pulumi.Input[Union[str, 'SecurityRuleDirection']]):
          pulumi.set(self, "direction", value)
  
      @property
      @pulumi.getter
      def protocol(self) -> pulumi.Input[Union[str, 'SecurityRuleProtocol']]:
          """
          Network protocol this rule applies to. Possible values are 'Tcp', 'Udp', and '*'.
          """
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: pulumi.Input[Union[str, 'SecurityRuleProtocol']]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          A description for this rule. Restricted to 140 chars.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter(name="destinationAddressPrefix")
      def destination_address_prefix(self) -> Optional[pulumi.Input[str]]:
          """
          The destination address prefix. CIDR or destination IP range. Asterisks '*' can also be used to match all source IPs. Default tags such as 'VirtualNetwork', 'AzureLoadBalancer' and 'Internet' can also be used.
          """
          return pulumi.get(self, "destination_address_prefix")
  
      @destination_address_prefix.setter
      def destination_address_prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "destination_address_prefix", value)
  
      @property
      @pulumi.getter(name="destinationAddressPrefixes")
      def destination_address_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          The destination address prefixes. CIDR or destination IP ranges.
          """
          return pulumi.get(self, "destination_address_prefixes")
  
      @destination_address_prefixes.setter
      def destination_address_prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "destination_address_prefixes", value)
  
      @property
      @pulumi.getter(name="destinationApplicationSecurityGroups")
      def destination_application_security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSecurityGroupArgs']]]]:
          """
          The application security group specified as destination.
          """
          return pulumi.get(self, "destination_application_security_groups")
  
      @destination_application_security_groups.setter
      def destination_application_security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSecurityGroupArgs']]]]):
          pulumi.set(self, "destination_application_security_groups", value)
  
      @property
      @pulumi.getter(name="destinationPortRange")
      def destination_port_range(self) -> Optional[pulumi.Input[str]]:
          """
          The destination port or range. Integer or range between 0 and 65535. Asterisks '*' can also be used to match all ports.
          """
          return pulumi.get(self, "destination_port_range")
  
      @destination_port_range.setter
      def destination_port_range(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "destination_port_range", value)
  
      @property
      @pulumi.getter(name="destinationPortRanges")
      def destination_port_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          The destination port ranges.
          """
          return pulumi.get(self, "destination_port_ranges")
  
      @destination_port_ranges.setter
      def destination_port_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "destination_port_ranges", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def priority(self) -> Optional[pulumi.Input[int]]:
          """
          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")
  
      @priority.setter
      def priority(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "priority", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          The provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter(name="sourceAddressPrefix")
      def source_address_prefix(self) -> Optional[pulumi.Input[str]]:
          """
          The CIDR or source IP range. Asterisks '*' can also be used to match all source IPs. Default tags such as 'VirtualNetwork', 'AzureLoadBalancer' and 'Internet' can also be used. If this is an ingress rule, specifies where network traffic originates from. 
          """
          return pulumi.get(self, "source_address_prefix")
  
      @source_address_prefix.setter
      def source_address_prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "source_address_prefix", value)
  
      @property
      @pulumi.getter(name="sourceAddressPrefixes")
      def source_address_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          The CIDR or source IP ranges.
          """
          return pulumi.get(self, "source_address_prefixes")
  
      @source_address_prefixes.setter
      def source_address_prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "source_address_prefixes", value)
  
      @property
      @pulumi.getter(name="sourceApplicationSecurityGroups")
      def source_application_security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSecurityGroupArgs']]]]:
          """
          The application security group specified as source.
          """
          return pulumi.get(self, "source_application_security_groups")
  
      @source_application_security_groups.setter
      def source_application_security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSecurityGroupArgs']]]]):
          pulumi.set(self, "source_application_security_groups", value)
  
      @property
      @pulumi.getter(name="sourcePortRange")
      def source_port_range(self) -> Optional[pulumi.Input[str]]:
          """
          The source port or range. Integer or range between 0 and 65535. Asterisks '*' can also be used to match all ports.
          """
          return pulumi.get(self, "source_port_range")
  
      @source_port_range.setter
      def source_port_range(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "source_port_range", value)
  
      @property
      @pulumi.getter(name="sourcePortRanges")
      def source_port_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          The source port ranges.
          """
          return pulumi.get(self, "source_port_ranges")
  
      @source_port_ranges.setter
      def source_port_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "source_port_ranges", value)
  
  
  @pulumi.input_type
  class ServiceAssociationLinkArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None,
                   link: Optional[pulumi.Input[str]] = None,
                   linked_resource_type: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None):
          """
          ServiceAssociationLink resource.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] link: Link to the external resource.
          :param pulumi.Input[str] linked_resource_type: Resource type of the linked resource.
          :param pulumi.Input[str] name: Name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
          if link is not None:
              pulumi.set(__self__, "link", link)
          if linked_resource_type is not None:
              pulumi.set(__self__, "linked_resource_type", linked_resource_type)
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def link(self) -> Optional[pulumi.Input[str]]:
          """
          Link to the external resource.
          """
          return pulumi.get(self, "link")
  
      @link.setter
      def link(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "link", value)
  
      @property
      @pulumi.getter(name="linkedResourceType")
      def linked_resource_type(self) -> Optional[pulumi.Input[str]]:
          """
          Resource type of the linked resource.
          """
          return pulumi.get(self, "linked_resource_type")
  
      @linked_resource_type.setter
      def linked_resource_type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "linked_resource_type", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class ServiceEndpointPolicyArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   location: Optional[pulumi.Input[str]] = None,
                   service_endpoint_policy_definitions: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceEndpointPolicyDefinitionArgs']]]] = None,
                   tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
          """
          Service End point policy resource.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] location: Resource location.
          :param pulumi.Input[Sequence[pulumi.Input['ServiceEndpointPolicyDefinitionArgs']]] service_endpoint_policy_definitions: A collection of service endpoint policy definitions of the service endpoint policy.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if location is not None:
              pulumi.set(__self__, "location", location)
          if service_endpoint_policy_definitions is not None:
              pulumi.set(__self__, "service_endpoint_policy_definitions", service_endpoint_policy_definitions)
          if tags is not None:
              pulumi.set(__self__, "tags", tags)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def location(self) -> Optional[pulumi.Input[str]]:
          """
          Resource location.
          """
          return pulumi.get(self, "location")
  
      @location.setter
      def location(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "location", value)
  
      @property
      @pulumi.getter(name="serviceEndpointPolicyDefinitions")
      def service_endpoint_policy_definitions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceEndpointPolicyDefinitionArgs']]]]:
          """
          A collection of service endpoint policy definitions of the service endpoint policy.
          """
          return pulumi.get(self, "service_endpoint_policy_definitions")
  
      @service_endpoint_policy_definitions.setter
      def service_endpoint_policy_definitions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceEndpointPolicyDefinitionArgs']]]]):
          pulumi.set(self, "service_endpoint_policy_definitions", value)
  
      @property
      @pulumi.getter
      def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Resource tags.
          """
          return pulumi.get(self, "tags")
  
      @tags.setter
      def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "tags", value)
  
  
  @pulumi.input_type
  class ServiceEndpointPolicyDefinitionArgs:
      def __init__(__self__, *,
                   description: Optional[pulumi.Input[str]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   service: Optional[pulumi.Input[str]] = None,
                   service_resources: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          Service Endpoint policy definitions.
          :param pulumi.Input[str] description: A description for this rule. Restricted to 140 chars.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[str] service: service endpoint name.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] service_resources: A list of service resources.
          """
          if description is not None:
              pulumi.set(__self__, "description", description)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if service is not None:
              pulumi.set(__self__, "service", service)
          if service_resources is not None:
              pulumi.set(__self__, "service_resources", service_resources)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          A description for this rule. Restricted to 140 chars.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def service(self) -> Optional[pulumi.Input[str]]:
          """
          service endpoint name.
          """
          return pulumi.get(self, "service")
  
      @service.setter
      def service(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "service", value)
  
      @property
      @pulumi.getter(name="serviceResources")
      def service_resources(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          A list of service resources.
          """
          return pulumi.get(self, "service_resources")
  
      @service_resources.setter
      def service_resources(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "service_resources", value)
  
  
  @pulumi.input_type
  class ServiceEndpointPropertiesFormatArgs:
      def __init__(__self__, *,
                   locations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   service: Optional[pulumi.Input[str]] = None):
          """
          The service endpoint properties.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] locations: A list of locations.
          :param pulumi.Input[str] provisioning_state: The provisioning state of the resource.
          :param pulumi.Input[str] service: The type of the endpoint service.
          """
          if locations is not None:
              pulumi.set(__self__, "locations", locations)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if service is not None:
              pulumi.set(__self__, "service", service)
  
      @property
      @pulumi.getter
      def locations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          A list of locations.
          """
          return pulumi.get(self, "locations")
  
      @locations.setter
      def locations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "locations", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          The provisioning state of the resource.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter
      def service(self) -> Optional[pulumi.Input[str]]:
          """
          The type of the endpoint service.
          """
          return pulumi.get(self, "service")
  
      @service.setter
      def service(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "service", value)
  
  
  @pulumi.input_type
  class SubResourceArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None):
          """
          Reference to another subresource.
          :param pulumi.Input[str] id: Resource ID.
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
  
  @pulumi.input_type
  class SubnetArgs:
      def __init__(__self__, *,
                   address_prefix: Optional[pulumi.Input[str]] = None,
                   address_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   delegations: Optional[pulumi.Input[Sequence[pulumi.Input['DelegationArgs']]]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   network_security_group: Optional[pulumi.Input['NetworkSecurityGroupArgs']] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   resource_navigation_links: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceNavigationLinkArgs']]]] = None,
                   route_table: Optional[pulumi.Input['RouteTableArgs']] = None,
                   service_association_links: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceAssociationLinkArgs']]]] = None,
                   service_endpoint_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceEndpointPolicyArgs']]]] = None,
                   service_endpoints: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceEndpointPropertiesFormatArgs']]]] = None):
          """
          Subnet in a virtual network resource.
          :param pulumi.Input[str] address_prefix: The address prefix for the subnet.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] address_prefixes: List of  address prefixes for the subnet.
          :param pulumi.Input[Sequence[pulumi.Input['DelegationArgs']]] delegations: Gets an array of references to the delegations on the subnet.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input['NetworkSecurityGroupArgs'] network_security_group: The reference of the NetworkSecurityGroup resource.
          :param pulumi.Input[str] provisioning_state: The provisioning state of the resource.
          :param pulumi.Input[Sequence[pulumi.Input['ResourceNavigationLinkArgs']]] resource_navigation_links: Gets an array of references to the external resources using subnet.
          :param pulumi.Input['RouteTableArgs'] route_table: The reference of the RouteTable resource.
          :param pulumi.Input[Sequence[pulumi.Input['ServiceAssociationLinkArgs']]] service_association_links: Gets an array of references to services injecting into this subnet.
          :param pulumi.Input[Sequence[pulumi.Input['ServiceEndpointPolicyArgs']]] service_endpoint_policies: An array of service endpoint policies.
          :param pulumi.Input[Sequence[pulumi.Input['ServiceEndpointPropertiesFormatArgs']]] service_endpoints: An array of service endpoints.
          """
          if address_prefix is not None:
              pulumi.set(__self__, "address_prefix", address_prefix)
          if address_prefixes is not None:
              pulumi.set(__self__, "address_prefixes", address_prefixes)
          if delegations is not None:
              pulumi.set(__self__, "delegations", delegations)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if network_security_group is not None:
              pulumi.set(__self__, "network_security_group", network_security_group)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if resource_navigation_links is not None:
              pulumi.set(__self__, "resource_navigation_links", resource_navigation_links)
          if route_table is not None:
              pulumi.set(__self__, "route_table", route_table)
          if service_association_links is not None:
              pulumi.set(__self__, "service_association_links", service_association_links)
          if service_endpoint_policies is not None:
              pulumi.set(__self__, "service_endpoint_policies", service_endpoint_policies)
          if service_endpoints is not None:
              pulumi.set(__self__, "service_endpoints", service_endpoints)
  
      @property
      @pulumi.getter(name="addressPrefix")
      def address_prefix(self) -> Optional[pulumi.Input[str]]:
          """
          The address prefix for the subnet.
          """
          return pulumi.get(self, "address_prefix")
  
      @address_prefix.setter
      def address_prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "address_prefix", value)
  
      @property
      @pulumi.getter(name="addressPrefixes")
      def address_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List of  address prefixes for the subnet.
          """
          return pulumi.get(self, "address_prefixes")
  
      @address_prefixes.setter
      def address_prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "address_prefixes", value)
  
      @property
      @pulumi.getter
      def delegations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DelegationArgs']]]]:
          """
          Gets an array of references to the delegations on the subnet.
          """
          return pulumi.get(self, "delegations")
  
      @delegations.setter
      def delegations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DelegationArgs']]]]):
          pulumi.set(self, "delegations", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="networkSecurityGroup")
      def network_security_group(self) -> Optional[pulumi.Input['NetworkSecurityGroupArgs']]:
          """
          The reference of the NetworkSecurityGroup resource.
          """
          return pulumi.get(self, "network_security_group")
  
      @network_security_group.setter
      def network_security_group(self, value: Optional[pulumi.Input['NetworkSecurityGroupArgs']]):
          pulumi.set(self, "network_security_group", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          The provisioning state of the resource.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter(name="resourceNavigationLinks")
      def resource_navigation_links(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceNavigationLinkArgs']]]]:
          """
          Gets an array of references to the external resources using subnet.
          """
          return pulumi.get(self, "resource_navigation_links")
  
      @resource_navigation_links.setter
      def resource_navigation_links(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceNavigationLinkArgs']]]]):
          pulumi.set(self, "resource_navigation_links", value)
  
      @property
      @pulumi.getter(name="routeTable")
      def route_table(self) -> Optional[pulumi.Input['RouteTableArgs']]:
          """
          The reference of the RouteTable resource.
          """
          return pulumi.get(self, "route_table")
  
      @route_table.setter
      def route_table(self, value: Optional[pulumi.Input['RouteTableArgs']]):
          pulumi.set(self, "route_table", value)
  
      @property
      @pulumi.getter(name="serviceAssociationLinks")
      def service_association_links(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceAssociationLinkArgs']]]]:
          """
          Gets an array of references to services injecting into this subnet.
          """
          return pulumi.get(self, "service_association_links")
  
      @service_association_links.setter
      def service_association_links(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceAssociationLinkArgs']]]]):
          pulumi.set(self, "service_association_links", value)
  
      @property
      @pulumi.getter(name="serviceEndpointPolicies")
      def service_endpoint_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceEndpointPolicyArgs']]]]:
          """
          An array of service endpoint policies.
          """
          return pulumi.get(self, "service_endpoint_policies")
  
      @service_endpoint_policies.setter
      def service_endpoint_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceEndpointPolicyArgs']]]]):
          pulumi.set(self, "service_endpoint_policies", value)
  
      @property
      @pulumi.getter(name="serviceEndpoints")
      def service_endpoints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceEndpointPropertiesFormatArgs']]]]:
          """
          An array of service endpoints.
          """
          return pulumi.get(self, "service_endpoints")
  
      @service_endpoints.setter
      def service_endpoints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceEndpointPropertiesFormatArgs']]]]):
          pulumi.set(self, "service_endpoints", value)
  
  
  @pulumi.input_type
  class VirtualHubIdArgs:
      def __init__(__self__, *,
                   id: Optional[pulumi.Input[str]] = None):
          """
          Virtual Hub identifier.
          :param pulumi.Input[str] id: The resource URI for the Virtual Hub where the ExpressRoute gateway is or will be deployed. The Virtual Hub resource and the ExpressRoute gateway resource reside in the same subscription.
          """
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          The resource URI for the Virtual Hub where the ExpressRoute gateway is or will be deployed. The Virtual Hub resource and the ExpressRoute gateway resource reside in the same subscription.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
  
  @pulumi.input_type
  class VirtualHubRouteArgs:
      def __init__(__self__, *,
                   address_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   next_hop_ip_address: Optional[pulumi.Input[str]] = None):
          """
          VirtualHub route
          :param pulumi.Input[Sequence[pulumi.Input[str]]] address_prefixes: list of all addressPrefixes.
          :param pulumi.Input[str] next_hop_ip_address: NextHop ip address.
          """
          if address_prefixes is not None:
              pulumi.set(__self__, "address_prefixes", address_prefixes)
          if next_hop_ip_address is not None:
              pulumi.set(__self__, "next_hop_ip_address", next_hop_ip_address)
  
      @property
      @pulumi.getter(name="addressPrefixes")
      def address_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          list of all addressPrefixes.
          """
          return pulumi.get(self, "address_prefixes")
  
      @address_prefixes.setter
      def address_prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "address_prefixes", value)
  
      @property
      @pulumi.getter(name="nextHopIpAddress")
      def next_hop_ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          NextHop ip address.
          """
          return pulumi.get(self, "next_hop_ip_address")
  
      @next_hop_ip_address.setter
      def next_hop_ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "next_hop_ip_address", value)
  
  
  @pulumi.input_type
  class VirtualHubRouteTableArgs:
      def __init__(__self__, *,
                   routes: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualHubRouteArgs']]]] = None):
          """
          VirtualHub route table
          :param pulumi.Input[Sequence[pulumi.Input['VirtualHubRouteArgs']]] routes: list of all routes.
          """
          if routes is not None:
              pulumi.set(__self__, "routes", routes)
  
      @property
      @pulumi.getter
      def routes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VirtualHubRouteArgs']]]]:
          """
          list of all routes.
          """
          return pulumi.get(self, "routes")
  
      @routes.setter
      def routes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualHubRouteArgs']]]]):
          pulumi.set(self, "routes", value)
  
  
  @pulumi.input_type
  class VirtualNetworkGatewayArgs:
      def __init__(__self__, *,
                   active_active: Optional[pulumi.Input[bool]] = None,
                   bgp_settings: Optional[pulumi.Input['BgpSettingsArgs']] = None,
                   enable_bgp: Optional[pulumi.Input[bool]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   gateway_default_site: Optional[pulumi.Input['SubResourceArgs']] = None,
                   gateway_type: Optional[pulumi.Input[Union[str, 'VirtualNetworkGatewayType']]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   ip_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualNetworkGatewayIPConfigurationArgs']]]] = None,
                   location: Optional[pulumi.Input[str]] = None,
                   resource_guid: Optional[pulumi.Input[str]] = None,
                   sku: Optional[pulumi.Input['VirtualNetworkGatewaySkuArgs']] = None,
                   tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   vpn_client_configuration: Optional[pulumi.Input['VpnClientConfigurationArgs']] = None,
                   vpn_type: Optional[pulumi.Input[Union[str, 'VpnType']]] = None):
          """
          A common class for general resource information
          :param pulumi.Input[bool] active_active: ActiveActive flag
          :param pulumi.Input['BgpSettingsArgs'] bgp_settings: Virtual network gateway's BGP speaker settings.
          :param pulumi.Input[bool] enable_bgp: Whether BGP is enabled for this virtual network gateway or not.
          :param pulumi.Input[str] etag: Gets a unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input['SubResourceArgs'] gateway_default_site: The reference of the LocalNetworkGateway resource which represents local network site having default routes. Assign Null value in case of removing existing default site setting.
          :param pulumi.Input[Union[str, 'VirtualNetworkGatewayType']] gateway_type: The type of this virtual network gateway. Possible values are: 'Vpn' and 'ExpressRoute'.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[Sequence[pulumi.Input['VirtualNetworkGatewayIPConfigurationArgs']]] ip_configurations: IP configurations for virtual network gateway.
          :param pulumi.Input[str] location: Resource location.
          :param pulumi.Input[str] resource_guid: The resource GUID property of the VirtualNetworkGateway resource.
          :param pulumi.Input['VirtualNetworkGatewaySkuArgs'] sku: The reference of the VirtualNetworkGatewaySku resource which represents the SKU selected for Virtual network gateway.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags.
          :param pulumi.Input['VpnClientConfigurationArgs'] vpn_client_configuration: The reference of the VpnClientConfiguration resource which represents the P2S VpnClient configurations.
          :param pulumi.Input[Union[str, 'VpnType']] vpn_type: The type of this virtual network gateway. Possible values are: 'PolicyBased' and 'RouteBased'.
          """
          if active_active is not None:
              pulumi.set(__self__, "active_active", active_active)
          if bgp_settings is not None:
              pulumi.set(__self__, "bgp_settings", bgp_settings)
          if enable_bgp is not None:
              pulumi.set(__self__, "enable_bgp", enable_bgp)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if gateway_default_site is not None:
              pulumi.set(__self__, "gateway_default_site", gateway_default_site)
          if gateway_type is not None:
              pulumi.set(__self__, "gateway_type", gateway_type)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if ip_configurations is not None:
              pulumi.set(__self__, "ip_configurations", ip_configurations)
          if location is not None:
              pulumi.set(__self__, "location", location)
          if resource_guid is not None:
              pulumi.set(__self__, "resource_guid", resource_guid)
          if sku is not None:
              pulumi.set(__self__, "sku", sku)
          if tags is not None:
              pulumi.set(__self__, "tags", tags)
          if vpn_client_configuration is not None:
              pulumi.set(__self__, "vpn_client_configuration", vpn_client_configuration)
          if vpn_type is not None:
              pulumi.set(__self__, "vpn_type", vpn_type)
  
      @property
      @pulumi.getter(name="activeActive")
      def active_active(self) -> Optional[pulumi.Input[bool]]:
          """
          ActiveActive flag
          """
          return pulumi.get(self, "active_active")
  
      @active_active.setter
      def active_active(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "active_active", value)
  
      @property
      @pulumi.getter(name="bgpSettings")
      def bgp_settings(self) -> Optional[pulumi.Input['BgpSettingsArgs']]:
          """
          Virtual network gateway's BGP speaker settings.
          """
          return pulumi.get(self, "bgp_settings")
  
      @bgp_settings.setter
      def bgp_settings(self, value: Optional[pulumi.Input['BgpSettingsArgs']]):
          pulumi.set(self, "bgp_settings", value)
  
      @property
      @pulumi.getter(name="enableBgp")
      def enable_bgp(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether BGP is enabled for this virtual network gateway or not.
          """
          return pulumi.get(self, "enable_bgp")
  
      @enable_bgp.setter
      def enable_bgp(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_bgp", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          Gets a unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter(name="gatewayDefaultSite")
      def gateway_default_site(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          The reference of the LocalNetworkGateway resource which represents local network site having default routes. Assign Null value in case of removing existing default site setting.
          """
          return pulumi.get(self, "gateway_default_site")
  
      @gateway_default_site.setter
      def gateway_default_site(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "gateway_default_site", value)
  
      @property
      @pulumi.getter(name="gatewayType")
      def gateway_type(self) -> Optional[pulumi.Input[Union[str, 'VirtualNetworkGatewayType']]]:
          """
          The type of this virtual network gateway. Possible values are: 'Vpn' and 'ExpressRoute'.
          """
          return pulumi.get(self, "gateway_type")
  
      @gateway_type.setter
      def gateway_type(self, value: Optional[pulumi.Input[Union[str, 'VirtualNetworkGatewayType']]]):
          pulumi.set(self, "gateway_type", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="ipConfigurations")
      def ip_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VirtualNetworkGatewayIPConfigurationArgs']]]]:
          """
          IP configurations for virtual network gateway.
          """
          return pulumi.get(self, "ip_configurations")
  
      @ip_configurations.setter
      def ip_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualNetworkGatewayIPConfigurationArgs']]]]):
          pulumi.set(self, "ip_configurations", value)
  
      @property
      @pulumi.getter
      def location(self) -> Optional[pulumi.Input[str]]:
          """
          Resource location.
          """
          return pulumi.get(self, "location")
  
      @location.setter
      def location(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "location", value)
  
      @property
      @pulumi.getter(name="resourceGuid")
      def resource_guid(self) -> Optional[pulumi.Input[str]]:
          """
          The resource GUID property of the VirtualNetworkGateway resource.
          """
          return pulumi.get(self, "resource_guid")
  
      @resource_guid.setter
      def resource_guid(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "resource_guid", value)
  
      @property
      @pulumi.getter
      def sku(self) -> Optional[pulumi.Input['VirtualNetworkGatewaySkuArgs']]:
          """
          The reference of the VirtualNetworkGatewaySku resource which represents the SKU selected for Virtual network gateway.
          """
          return pulumi.get(self, "sku")
  
      @sku.setter
      def sku(self, value: Optional[pulumi.Input['VirtualNetworkGatewaySkuArgs']]):
          pulumi.set(self, "sku", value)
  
      @property
      @pulumi.getter
      def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Resource tags.
          """
          return pulumi.get(self, "tags")
  
      @tags.setter
      def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "tags", value)
  
      @property
      @pulumi.getter(name="vpnClientConfiguration")
      def vpn_client_configuration(self) -> Optional[pulumi.Input['VpnClientConfigurationArgs']]:
          """
          The reference of the VpnClientConfiguration resource which represents the P2S VpnClient configurations.
          """
          return pulumi.get(self, "vpn_client_configuration")
  
      @vpn_client_configuration.setter
      def vpn_client_configuration(self, value: Optional[pulumi.Input['VpnClientConfigurationArgs']]):
          pulumi.set(self, "vpn_client_configuration", value)
  
      @property
      @pulumi.getter(name="vpnType")
      def vpn_type(self) -> Optional[pulumi.Input[Union[str, 'VpnType']]]:
          """
          The type of this virtual network gateway. Possible values are: 'PolicyBased' and 'RouteBased'.
          """
          return pulumi.get(self, "vpn_type")
  
      @vpn_type.setter
      def vpn_type(self, value: Optional[pulumi.Input[Union[str, 'VpnType']]]):
          pulumi.set(self, "vpn_type", value)
  
  
  @pulumi.input_type
  class VirtualNetworkGatewayIPConfigurationArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   private_ip_allocation_method: Optional[pulumi.Input[Union[str, 'IPAllocationMethod']]] = None,
                   public_ip_address: Optional[pulumi.Input['SubResourceArgs']] = None,
                   subnet: Optional[pulumi.Input['SubResourceArgs']] = None):
          """
          IP configuration for virtual network gateway
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[Union[str, 'IPAllocationMethod']] private_ip_allocation_method: The private IP allocation method. Possible values are: 'Static' and 'Dynamic'.
          :param pulumi.Input['SubResourceArgs'] public_ip_address: The reference of the public IP resource.
          :param pulumi.Input['SubResourceArgs'] subnet: The reference of the subnet resource.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if private_ip_allocation_method is not None:
              pulumi.set(__self__, "private_ip_allocation_method", private_ip_allocation_method)
          if public_ip_address is not None:
              pulumi.set(__self__, "public_ip_address", public_ip_address)
          if subnet is not None:
              pulumi.set(__self__, "subnet", subnet)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="privateIPAllocationMethod")
      def private_ip_allocation_method(self) -> Optional[pulumi.Input[Union[str, 'IPAllocationMethod']]]:
          """
          The private IP allocation method. Possible values are: 'Static' and 'Dynamic'.
          """
          return pulumi.get(self, "private_ip_allocation_method")
  
      @private_ip_allocation_method.setter
      def private_ip_allocation_method(self, value: Optional[pulumi.Input[Union[str, 'IPAllocationMethod']]]):
          pulumi.set(self, "private_ip_allocation_method", value)
  
      @property
      @pulumi.getter(name="publicIPAddress")
      def public_ip_address(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          The reference of the public IP resource.
          """
          return pulumi.get(self, "public_ip_address")
  
      @public_ip_address.setter
      def public_ip_address(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "public_ip_address", value)
  
      @property
      @pulumi.getter
      def subnet(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          The reference of the subnet resource.
          """
          return pulumi.get(self, "subnet")
  
      @subnet.setter
      def subnet(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "subnet", value)
  
  
  @pulumi.input_type
  class VirtualNetworkGatewaySkuArgs:
      def __init__(__self__, *,
                   capacity: Optional[pulumi.Input[int]] = None,
                   name: Optional[pulumi.Input[Union[str, 'VirtualNetworkGatewaySkuName']]] = None,
                   tier: Optional[pulumi.Input[Union[str, 'VirtualNetworkGatewaySkuTier']]] = None):
          """
          VirtualNetworkGatewaySku details
          :param pulumi.Input[int] capacity: The capacity.
          :param pulumi.Input[Union[str, 'VirtualNetworkGatewaySkuName']] name: Gateway SKU name.
          :param pulumi.Input[Union[str, 'VirtualNetworkGatewaySkuTier']] tier: Gateway SKU tier.
          """
          if capacity is not None:
              pulumi.set(__self__, "capacity", capacity)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if tier is not None:
              pulumi.set(__self__, "tier", tier)
  
      @property
      @pulumi.getter
      def capacity(self) -> Optional[pulumi.Input[int]]:
          """
          The capacity.
          """
          return pulumi.get(self, "capacity")
  
      @capacity.setter
      def capacity(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "capacity", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[Union[str, 'VirtualNetworkGatewaySkuName']]]:
          """
          Gateway SKU name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[Union[str, 'VirtualNetworkGatewaySkuName']]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def tier(self) -> Optional[pulumi.Input[Union[str, 'VirtualNetworkGatewaySkuTier']]]:
          """
          Gateway SKU tier.
          """
          return pulumi.get(self, "tier")
  
      @tier.setter
      def tier(self, value: Optional[pulumi.Input[Union[str, 'VirtualNetworkGatewaySkuTier']]]):
          pulumi.set(self, "tier", value)
  
  
  @pulumi.input_type
  class VirtualNetworkPeeringArgs:
      def __init__(__self__, *,
                   allow_forwarded_traffic: Optional[pulumi.Input[bool]] = None,
                   allow_gateway_transit: Optional[pulumi.Input[bool]] = None,
                   allow_virtual_network_access: Optional[pulumi.Input[bool]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   peering_state: Optional[pulumi.Input[Union[str, 'VirtualNetworkPeeringState']]] = None,
                   provisioning_state: Optional[pulumi.Input[str]] = None,
                   remote_address_space: Optional[pulumi.Input['AddressSpaceArgs']] = None,
                   remote_virtual_network: Optional[pulumi.Input['SubResourceArgs']] = None,
                   use_remote_gateways: Optional[pulumi.Input[bool]] = None):
          """
          Peerings in a virtual network resource.
          :param pulumi.Input[bool] allow_forwarded_traffic: Whether the forwarded traffic from the VMs in the remote virtual network will be allowed/disallowed.
          :param pulumi.Input[bool] allow_gateway_transit: If gateway links can be used in remote virtual networking to link to this virtual network.
          :param pulumi.Input[bool] allow_virtual_network_access: Whether the VMs in the linked virtual network space would be able to access all the VMs in local Virtual network space.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[Union[str, 'VirtualNetworkPeeringState']] peering_state: The status of the virtual network peering. Possible values are 'Initiated', 'Connected', and 'Disconnected'.
          :param pulumi.Input[str] provisioning_state: The provisioning state of the resource.
          :param pulumi.Input['AddressSpaceArgs'] remote_address_space: The reference of the remote virtual network address space.
          :param pulumi.Input['SubResourceArgs'] remote_virtual_network: The reference of the remote virtual network. The remote virtual network can be in the same or different region (preview). See here to register for the preview and learn more (https://docs.microsoft.com/en-us/azure/virtual-network/virtual-network-create-peering).
          :param pulumi.Input[bool] use_remote_gateways: If remote gateways can be used on this virtual network. If the flag is set to true, and allowGatewayTransit on remote peering is also true, virtual network will use gateways of remote virtual network for transit. Only one peering can have this flag set to true. This flag cannot be set if virtual network already has a gateway.
          """
          if allow_forwarded_traffic is not None:
              pulumi.set(__self__, "allow_forwarded_traffic", allow_forwarded_traffic)
          if allow_gateway_transit is not None:
              pulumi.set(__self__, "allow_gateway_transit", allow_gateway_transit)
          if allow_virtual_network_access is not None:
              pulumi.set(__self__, "allow_virtual_network_access", allow_virtual_network_access)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if peering_state is not None:
              pulumi.set(__self__, "peering_state", peering_state)
          if provisioning_state is not None:
              pulumi.set(__self__, "provisioning_state", provisioning_state)
          if remote_address_space is not None:
              pulumi.set(__self__, "remote_address_space", remote_address_space)
          if remote_virtual_network is not None:
              pulumi.set(__self__, "remote_virtual_network", remote_virtual_network)
          if use_remote_gateways is not None:
              pulumi.set(__self__, "use_remote_gateways", use_remote_gateways)
  
      @property
      @pulumi.getter(name="allowForwardedTraffic")
      def allow_forwarded_traffic(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether the forwarded traffic from the VMs in the remote virtual network will be allowed/disallowed.
          """
          return pulumi.get(self, "allow_forwarded_traffic")
  
      @allow_forwarded_traffic.setter
      def allow_forwarded_traffic(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "allow_forwarded_traffic", value)
  
      @property
      @pulumi.getter(name="allowGatewayTransit")
      def allow_gateway_transit(self) -> Optional[pulumi.Input[bool]]:
          """
          If gateway links can be used in remote virtual networking to link to this virtual network.
          """
          return pulumi.get(self, "allow_gateway_transit")
  
      @allow_gateway_transit.setter
      def allow_gateway_transit(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "allow_gateway_transit", value)
  
      @property
      @pulumi.getter(name="allowVirtualNetworkAccess")
      def allow_virtual_network_access(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether the VMs in the linked virtual network space would be able to access all the VMs in local Virtual network space.
          """
          return pulumi.get(self, "allow_virtual_network_access")
  
      @allow_virtual_network_access.setter
      def allow_virtual_network_access(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "allow_virtual_network_access", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="peeringState")
      def peering_state(self) -> Optional[pulumi.Input[Union[str, 'VirtualNetworkPeeringState']]]:
          """
          The status of the virtual network peering. Possible values are 'Initiated', 'Connected', and 'Disconnected'.
          """
          return pulumi.get(self, "peering_state")
  
      @peering_state.setter
      def peering_state(self, value: Optional[pulumi.Input[Union[str, 'VirtualNetworkPeeringState']]]):
          pulumi.set(self, "peering_state", value)
  
      @property
      @pulumi.getter(name="provisioningState")
      def provisioning_state(self) -> Optional[pulumi.Input[str]]:
          """
          The provisioning state of the resource.
          """
          return pulumi.get(self, "provisioning_state")
  
      @provisioning_state.setter
      def provisioning_state(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "provisioning_state", value)
  
      @property
      @pulumi.getter(name="remoteAddressSpace")
      def remote_address_space(self) -> Optional[pulumi.Input['AddressSpaceArgs']]:
          """
          The reference of the remote virtual network address space.
          """
          return pulumi.get(self, "remote_address_space")
  
      @remote_address_space.setter
      def remote_address_space(self, value: Optional[pulumi.Input['AddressSpaceArgs']]):
          pulumi.set(self, "remote_address_space", value)
  
      @property
      @pulumi.getter(name="remoteVirtualNetwork")
      def remote_virtual_network(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          The reference of the remote virtual network. The remote virtual network can be in the same or different region (preview). See here to register for the preview and learn more (https://docs.microsoft.com/en-us/azure/virtual-network/virtual-network-create-peering).
          """
          return pulumi.get(self, "remote_virtual_network")
  
      @remote_virtual_network.setter
      def remote_virtual_network(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "remote_virtual_network", value)
  
      @property
      @pulumi.getter(name="useRemoteGateways")
      def use_remote_gateways(self) -> Optional[pulumi.Input[bool]]:
          """
          If remote gateways can be used on this virtual network. If the flag is set to true, and allowGatewayTransit on remote peering is also true, virtual network will use gateways of remote virtual network for transit. Only one peering can have this flag set to true. This flag cannot be set if virtual network already has a gateway.
          """
          return pulumi.get(self, "use_remote_gateways")
  
      @use_remote_gateways.setter
      def use_remote_gateways(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "use_remote_gateways", value)
  
  
  @pulumi.input_type
  class VirtualNetworkTapArgs:
      def __init__(__self__, *,
                   destination_load_balancer_front_end_ip_configuration: Optional[pulumi.Input['FrontendIPConfigurationArgs']] = None,
                   destination_network_interface_ip_configuration: Optional[pulumi.Input['NetworkInterfaceIPConfigurationArgs']] = None,
                   destination_port: Optional[pulumi.Input[int]] = None,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   location: Optional[pulumi.Input[str]] = None,
                   tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
          """
          Virtual Network Tap resource
          :param pulumi.Input['FrontendIPConfigurationArgs'] destination_load_balancer_front_end_ip_configuration: The reference to the private IP address on the internal Load Balancer that will receive the tap
          :param pulumi.Input['NetworkInterfaceIPConfigurationArgs'] destination_network_interface_ip_configuration: The reference to the private IP Address of the collector nic that will receive the tap
          :param pulumi.Input[int] destination_port: The VXLAN destination port that will receive the tapped traffic.
          :param pulumi.Input[str] etag: Gets a unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] location: Resource location.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags.
          """
          if destination_load_balancer_front_end_ip_configuration is not None:
              pulumi.set(__self__, "destination_load_balancer_front_end_ip_configuration", destination_load_balancer_front_end_ip_configuration)
          if destination_network_interface_ip_configuration is not None:
              pulumi.set(__self__, "destination_network_interface_ip_configuration", destination_network_interface_ip_configuration)
          if destination_port is not None:
              pulumi.set(__self__, "destination_port", destination_port)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if location is not None:
              pulumi.set(__self__, "location", location)
          if tags is not None:
              pulumi.set(__self__, "tags", tags)
  
      @property
      @pulumi.getter(name="destinationLoadBalancerFrontEndIPConfiguration")
      def destination_load_balancer_front_end_ip_configuration(self) -> Optional[pulumi.Input['FrontendIPConfigurationArgs']]:
          """
          The reference to the private IP address on the internal Load Balancer that will receive the tap
          """
          return pulumi.get(self, "destination_load_balancer_front_end_ip_configuration")
  
      @destination_load_balancer_front_end_ip_configuration.setter
      def destination_load_balancer_front_end_ip_configuration(self, value: Optional[pulumi.Input['FrontendIPConfigurationArgs']]):
          pulumi.set(self, "destination_load_balancer_front_end_ip_configuration", value)
  
      @property
      @pulumi.getter(name="destinationNetworkInterfaceIPConfiguration")
      def destination_network_interface_ip_configuration(self) -> Optional[pulumi.Input['NetworkInterfaceIPConfigurationArgs']]:
          """
          The reference to the private IP Address of the collector nic that will receive the tap
          """
          return pulumi.get(self, "destination_network_interface_ip_configuration")
  
      @destination_network_interface_ip_configuration.setter
      def destination_network_interface_ip_configuration(self, value: Optional[pulumi.Input['NetworkInterfaceIPConfigurationArgs']]):
          pulumi.set(self, "destination_network_interface_ip_configuration", value)
  
      @property
      @pulumi.getter(name="destinationPort")
      def destination_port(self) -> Optional[pulumi.Input[int]]:
          """
          The VXLAN destination port that will receive the tapped traffic.
          """
          return pulumi.get(self, "destination_port")
  
      @destination_port.setter
      def destination_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "destination_port", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          Gets a unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def location(self) -> Optional[pulumi.Input[str]]:
          """
          Resource location.
          """
          return pulumi.get(self, "location")
  
      @location.setter
      def location(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "location", value)
  
      @property
      @pulumi.getter
      def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Resource tags.
          """
          return pulumi.get(self, "tags")
  
      @tags.setter
      def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "tags", value)
  
  
  @pulumi.input_type
  class VpnClientConfigurationArgs:
      def __init__(__self__, *,
                   radius_server_address: Optional[pulumi.Input[str]] = None,
                   radius_server_secret: Optional[pulumi.Input[str]] = None,
                   vpn_client_address_pool: Optional[pulumi.Input['AddressSpaceArgs']] = None,
                   vpn_client_ipsec_policies: Optional[pulumi.Input[Sequence[pulumi.Input['IpsecPolicyArgs']]]] = None,
                   vpn_client_protocols: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'VpnClientProtocol']]]]] = None,
                   vpn_client_revoked_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['VpnClientRevokedCertificateArgs']]]] = None,
                   vpn_client_root_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['VpnClientRootCertificateArgs']]]] = None):
          """
          VpnClientConfiguration for P2S client.
          :param pulumi.Input[str] radius_server_address: The radius server address property of the VirtualNetworkGateway resource for vpn client connection.
          :param pulumi.Input[str] radius_server_secret: The radius secret property of the VirtualNetworkGateway resource for vpn client connection.
          :param pulumi.Input['AddressSpaceArgs'] vpn_client_address_pool: The reference of the address space resource which represents Address space for P2S VpnClient.
          :param pulumi.Input[Sequence[pulumi.Input['IpsecPolicyArgs']]] vpn_client_ipsec_policies: VpnClientIpsecPolicies for virtual network gateway P2S client.
          :param pulumi.Input[Sequence[pulumi.Input[Union[str, 'VpnClientProtocol']]]] vpn_client_protocols: VpnClientProtocols for Virtual network gateway.
          :param pulumi.Input[Sequence[pulumi.Input['VpnClientRevokedCertificateArgs']]] vpn_client_revoked_certificates: VpnClientRevokedCertificate for Virtual network gateway.
          :param pulumi.Input[Sequence[pulumi.Input['VpnClientRootCertificateArgs']]] vpn_client_root_certificates: VpnClientRootCertificate for virtual network gateway.
          """
          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 vpn_client_address_pool is not None:
              pulumi.set(__self__, "vpn_client_address_pool", vpn_client_address_pool)
          if vpn_client_ipsec_policies is not None:
              pulumi.set(__self__, "vpn_client_ipsec_policies", vpn_client_ipsec_policies)
          if vpn_client_protocols is not None:
              pulumi.set(__self__, "vpn_client_protocols", vpn_client_protocols)
          if vpn_client_revoked_certificates is not None:
              pulumi.set(__self__, "vpn_client_revoked_certificates", vpn_client_revoked_certificates)
          if vpn_client_root_certificates is not None:
              pulumi.set(__self__, "vpn_client_root_certificates", vpn_client_root_certificates)
  
      @property
      @pulumi.getter(name="radiusServerAddress")
      def radius_server_address(self) -> Optional[pulumi.Input[str]]:
          """
          The radius server address property of the VirtualNetworkGateway resource for vpn client connection.
          """
          return pulumi.get(self, "radius_server_address")
  
      @radius_server_address.setter
      def radius_server_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "radius_server_address", value)
  
      @property
      @pulumi.getter(name="radiusServerSecret")
      def radius_server_secret(self) -> Optional[pulumi.Input[str]]:
          """
          The radius secret property of the VirtualNetworkGateway resource for vpn client connection.
          """
          return pulumi.get(self, "radius_server_secret")
  
      @radius_server_secret.setter
      def radius_server_secret(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "radius_server_secret", value)
  
      @property
      @pulumi.getter(name="vpnClientAddressPool")
      def vpn_client_address_pool(self) -> Optional[pulumi.Input['AddressSpaceArgs']]:
          """
          The reference of the address space resource which represents Address space for P2S VpnClient.
          """
          return pulumi.get(self, "vpn_client_address_pool")
  
      @vpn_client_address_pool.setter
      def vpn_client_address_pool(self, value: Optional[pulumi.Input['AddressSpaceArgs']]):
          pulumi.set(self, "vpn_client_address_pool", value)
  
      @property
      @pulumi.getter(name="vpnClientIpsecPolicies")
      def vpn_client_ipsec_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IpsecPolicyArgs']]]]:
          """
          VpnClientIpsecPolicies for virtual network gateway P2S client.
          """
          return pulumi.get(self, "vpn_client_ipsec_policies")
  
      @vpn_client_ipsec_policies.setter
      def vpn_client_ipsec_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['IpsecPolicyArgs']]]]):
          pulumi.set(self, "vpn_client_ipsec_policies", value)
  
      @property
      @pulumi.getter(name="vpnClientProtocols")
      def vpn_client_protocols(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'VpnClientProtocol']]]]]:
          """
          VpnClientProtocols for Virtual network gateway.
          """
          return pulumi.get(self, "vpn_client_protocols")
  
      @vpn_client_protocols.setter
      def vpn_client_protocols(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'VpnClientProtocol']]]]]):
          pulumi.set(self, "vpn_client_protocols", value)
  
      @property
      @pulumi.getter(name="vpnClientRevokedCertificates")
      def vpn_client_revoked_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VpnClientRevokedCertificateArgs']]]]:
          """
          VpnClientRevokedCertificate for Virtual network gateway.
          """
          return pulumi.get(self, "vpn_client_revoked_certificates")
  
      @vpn_client_revoked_certificates.setter
      def vpn_client_revoked_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VpnClientRevokedCertificateArgs']]]]):
          pulumi.set(self, "vpn_client_revoked_certificates", value)
  
      @property
      @pulumi.getter(name="vpnClientRootCertificates")
      def vpn_client_root_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VpnClientRootCertificateArgs']]]]:
          """
          VpnClientRootCertificate for virtual network gateway.
          """
          return pulumi.get(self, "vpn_client_root_certificates")
  
      @vpn_client_root_certificates.setter
      def vpn_client_root_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VpnClientRootCertificateArgs']]]]):
          pulumi.set(self, "vpn_client_root_certificates", value)
  
  
  @pulumi.input_type
  class VpnClientRevokedCertificateArgs:
      def __init__(__self__, *,
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   thumbprint: Optional[pulumi.Input[str]] = None):
          """
          VPN client revoked certificate of virtual network gateway.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input[str] thumbprint: The revoked VPN client certificate thumbprint.
          """
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if thumbprint is not None:
              pulumi.set(__self__, "thumbprint", thumbprint)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def thumbprint(self) -> Optional[pulumi.Input[str]]:
          """
          The revoked VPN client certificate thumbprint.
          """
          return pulumi.get(self, "thumbprint")
  
      @thumbprint.setter
      def thumbprint(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "thumbprint", value)
  
  
  @pulumi.input_type
  class VpnClientRootCertificateArgs:
      def __init__(__self__, *,
                   public_cert_data: pulumi.Input[str],
                   etag: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None):
          """
          VPN client root certificate of virtual network gateway
          :param pulumi.Input[str] public_cert_data: The certificate public data.
          :param pulumi.Input[str] etag: A unique read-only string that changes whenever the resource is updated.
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          pulumi.set(__self__, "public_cert_data", public_cert_data)
          if etag is not None:
              pulumi.set(__self__, "etag", etag)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter(name="publicCertData")
      def public_cert_data(self) -> pulumi.Input[str]:
          """
          The certificate public data.
          """
          return pulumi.get(self, "public_cert_data")
  
      @public_cert_data.setter
      def public_cert_data(self, value: pulumi.Input[str]):
          pulumi.set(self, "public_cert_data", value)
  
      @property
      @pulumi.getter
      def etag(self) -> Optional[pulumi.Input[str]]:
          """
          A unique read-only string that changes whenever the resource is updated.
          """
          return pulumi.get(self, "etag")
  
      @etag.setter
      def etag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "etag", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class VpnConnectionArgs:
      def __init__(__self__, *,
                   connection_bandwidth: Optional[pulumi.Input[int]] = None,
                   enable_bgp: Optional[pulumi.Input[bool]] = None,
                   enable_internet_security: Optional[pulumi.Input[bool]] = None,
                   enable_rate_limiting: Optional[pulumi.Input[bool]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   ipsec_policies: Optional[pulumi.Input[Sequence[pulumi.Input['IpsecPolicyArgs']]]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   remote_vpn_site: Optional[pulumi.Input['SubResourceArgs']] = None,
                   routing_weight: Optional[pulumi.Input[int]] = None,
                   shared_key: Optional[pulumi.Input[str]] = None,
                   vpn_connection_protocol_type: Optional[pulumi.Input[Union[str, 'VirtualNetworkGatewayConnectionProtocol']]] = None):
          """
          VpnConnection Resource.
          :param pulumi.Input[int] connection_bandwidth: Expected bandwidth in MBPS.
          :param pulumi.Input[bool] enable_bgp: EnableBgp flag
          :param pulumi.Input[bool] enable_internet_security: Enable internet security
          :param pulumi.Input[bool] enable_rate_limiting: EnableBgp flag
          :param pulumi.Input[str] id: Resource ID.
          :param pulumi.Input[Sequence[pulumi.Input['IpsecPolicyArgs']]] ipsec_policies: The IPSec Policies to be considered by this connection.
          :param pulumi.Input[str] name: The name of the resource that is unique within a resource group. This name can be used to access the resource.
          :param pulumi.Input['SubResourceArgs'] remote_vpn_site: Id of the connected vpn site.
          :param pulumi.Input[int] routing_weight: routing weight for vpn connection.
          :param pulumi.Input[str] shared_key: SharedKey for the vpn connection.
          :param pulumi.Input[Union[str, 'VirtualNetworkGatewayConnectionProtocol']] vpn_connection_protocol_type: Connection protocol used for this connection
          """
          if connection_bandwidth is not None:
              pulumi.set(__self__, "connection_bandwidth", connection_bandwidth)
          if enable_bgp is not None:
              pulumi.set(__self__, "enable_bgp", enable_bgp)
          if enable_internet_security is not None:
              pulumi.set(__self__, "enable_internet_security", enable_internet_security)
          if enable_rate_limiting is not None:
              pulumi.set(__self__, "enable_rate_limiting", enable_rate_limiting)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if ipsec_policies is not None:
              pulumi.set(__self__, "ipsec_policies", ipsec_policies)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if remote_vpn_site is not None:
              pulumi.set(__self__, "remote_vpn_site", remote_vpn_site)
          if routing_weight is not None:
              pulumi.set(__self__, "routing_weight", routing_weight)
          if shared_key is not None:
              pulumi.set(__self__, "shared_key", shared_key)
          if vpn_connection_protocol_type is not None:
              pulumi.set(__self__, "vpn_connection_protocol_type", vpn_connection_protocol_type)
  
      @property
      @pulumi.getter(name="connectionBandwidth")
      def connection_bandwidth(self) -> Optional[pulumi.Input[int]]:
          """
          Expected bandwidth in MBPS.
          """
          return pulumi.get(self, "connection_bandwidth")
  
      @connection_bandwidth.setter
      def connection_bandwidth(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "connection_bandwidth", value)
  
      @property
      @pulumi.getter(name="enableBgp")
      def enable_bgp(self) -> Optional[pulumi.Input[bool]]:
          """
          EnableBgp flag
          """
          return pulumi.get(self, "enable_bgp")
  
      @enable_bgp.setter
      def enable_bgp(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_bgp", value)
  
      @property
      @pulumi.getter(name="enableInternetSecurity")
      def enable_internet_security(self) -> Optional[pulumi.Input[bool]]:
          """
          Enable internet security
          """
          return pulumi.get(self, "enable_internet_security")
  
      @enable_internet_security.setter
      def enable_internet_security(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_internet_security", value)
  
      @property
      @pulumi.getter(name="enableRateLimiting")
      def enable_rate_limiting(self) -> Optional[pulumi.Input[bool]]:
          """
          EnableBgp flag
          """
          return pulumi.get(self, "enable_rate_limiting")
  
      @enable_rate_limiting.setter
      def enable_rate_limiting(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_rate_limiting", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Resource ID.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="ipsecPolicies")
      def ipsec_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IpsecPolicyArgs']]]]:
          """
          The IPSec Policies to be considered by this connection.
          """
          return pulumi.get(self, "ipsec_policies")
  
      @ipsec_policies.setter
      def ipsec_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['IpsecPolicyArgs']]]]):
          pulumi.set(self, "ipsec_policies", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the resource that is unique within a resource group. This name can be used to access the resource.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="remoteVpnSite")
      def remote_vpn_site(self) -> Optional[pulumi.Input['SubResourceArgs']]:
          """
          Id of the connected vpn site.
          """
          return pulumi.get(self, "remote_vpn_site")
  
      @remote_vpn_site.setter
      def remote_vpn_site(self, value: Optional[pulumi.Input['SubResourceArgs']]):
          pulumi.set(self, "remote_vpn_site", value)
  
      @property
      @pulumi.getter(name="routingWeight")
      def routing_weight(self) -> Optional[pulumi.Input[int]]:
          """
          routing weight for vpn connection.
          """
          return pulumi.get(self, "routing_weight")
  
      @routing_weight.setter
      def routing_weight(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "routing_weight", value)
  
      @property
      @pulumi.getter(name="sharedKey")
      def shared_key(self) -> Optional[pulumi.Input[str]]:
          """
          SharedKey for the vpn connection.
          """
          return pulumi.get(self, "shared_key")
  
      @shared_key.setter
      def shared_key(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "shared_key", value)
  
      @property
      @pulumi.getter(name="vpnConnectionProtocolType")
      def vpn_connection_protocol_type(self) -> Optional[pulumi.Input[Union[str, 'VirtualNetworkGatewayConnectionProtocol']]]:
          """
          Connection protocol used for this connection
          """
          return pulumi.get(self, "vpn_connection_protocol_type")
  
      @vpn_connection_protocol_type.setter
      def vpn_connection_protocol_type(self, value: Optional[pulumi.Input[Union[str, 'VirtualNetworkGatewayConnectionProtocol']]]):
          pulumi.set(self, "vpn_connection_protocol_type", value)
  
  
  