pulumi-azure-native 2.33.1a1711356993__py3-none-any.whl → 2.34.0__py3-none-any.whl

pulumi_azure_native/cloudngfw/v20220829/outputs.py

@@ -0,0 +1,2143 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+from ... import _utilities
+from . import outputs
+from ._enums import *
+
+__all__ = [
+    'AdvSecurityObjectModelResponse',
+    'AppSeenDataResponse',
+    'AppSeenInfoResponse',
+    'ApplicationInsightsResponse',
+    'AzureResourceManagerManagedIdentityPropertiesResponse',
+    'AzureResourceManagerUserAssignedIdentityResponse',
+    'CategoryResponse',
+    'CountryResponse',
+    'DNSSettingsResponse',
+    'DestinationAddrResponse',
+    'EndpointConfigurationResponse',
+    'EventHubResponse',
+    'FrontendSettingResponse',
+    'IPAddressResponse',
+    'IPAddressSpaceResponse',
+    'LogDestinationResponse',
+    'MarketplaceDetailsResponse',
+    'MonitorLogResponse',
+    'NameDescriptionObjectResponse',
+    'NetworkProfileResponse',
+    'PanoramaConfigResponse',
+    'PlanDataResponse',
+    'PredefinedUrlCategoryResponse',
+    'RulestackDetailsResponse',
+    'SecurityServicesResponse',
+    'SecurityServicesTypeListResponse',
+    'SourceAddrResponse',
+    'StorageAccountResponse',
+    'SystemDataResponse',
+    'TagInfoResponse',
+    'VnetConfigurationResponse',
+    'VwanConfigurationResponse',
+]
+
+@pulumi.output_type
+class AdvSecurityObjectModelResponse(dict):
+    """
+    List of custom and predefined url category
+    """
+    def __init__(__self__, *,
+                 entry: Sequence['outputs.NameDescriptionObjectResponse'],
+                 type: Optional[str] = None):
+        """
+        List of custom and predefined url category
+        :param Sequence['NameDescriptionObjectResponse'] entry: URL entry
+        :param str type: type of object
+        """
+        pulumi.set(__self__, "entry", entry)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def entry(self) -> Sequence['outputs.NameDescriptionObjectResponse']:
+        """
+        URL entry
+        """
+        return pulumi.get(self, "entry")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        type of object
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class AppSeenDataResponse(dict):
+    """
+    Data Type for App Seen
+    """
+    def __init__(__self__, *,
+                 app_seen_list: Sequence['outputs.AppSeenInfoResponse'],
+                 count: int):
+        """
+        Data Type for App Seen
+        :param Sequence['AppSeenInfoResponse'] app_seen_list: array of appSeen
+        :param int count: number of rows
+        """
+        pulumi.set(__self__, "app_seen_list", app_seen_list)
+        pulumi.set(__self__, "count", count)
+
+    @property
+    @pulumi.getter(name="appSeenList")
+    def app_seen_list(self) -> Sequence['outputs.AppSeenInfoResponse']:
+        """
+        array of appSeen
+        """
+        return pulumi.get(self, "app_seen_list")
+
+    @property
+    @pulumi.getter
+    def count(self) -> int:
+        """
+        number of rows
+        """
+        return pulumi.get(self, "count")
+
+
+@pulumi.output_type
+class AppSeenInfoResponse(dict):
+    """
+    Definition for App Seen
+    """
+    def __init__(__self__, *,
+                 category: str,
+                 risk: str,
+                 standard_ports: str,
+                 sub_category: str,
+                 tag: str,
+                 technology: str,
+                 title: str):
+        """
+        Definition for App Seen
+        :param str category: category
+        :param str risk: risk
+        :param str standard_ports: standardPorts
+        :param str sub_category: subCategory
+        :param str tag: tag
+        :param str technology: technology
+        :param str title: title
+        """
+        pulumi.set(__self__, "category", category)
+        pulumi.set(__self__, "risk", risk)
+        pulumi.set(__self__, "standard_ports", standard_ports)
+        pulumi.set(__self__, "sub_category", sub_category)
+        pulumi.set(__self__, "tag", tag)
+        pulumi.set(__self__, "technology", technology)
+        pulumi.set(__self__, "title", title)
+
+    @property
+    @pulumi.getter
+    def category(self) -> str:
+        """
+        category
+        """
+        return pulumi.get(self, "category")
+
+    @property
+    @pulumi.getter
+    def risk(self) -> str:
+        """
+        risk
+        """
+        return pulumi.get(self, "risk")
+
+    @property
+    @pulumi.getter(name="standardPorts")
+    def standard_ports(self) -> str:
+        """
+        standardPorts
+        """
+        return pulumi.get(self, "standard_ports")
+
+    @property
+    @pulumi.getter(name="subCategory")
+    def sub_category(self) -> str:
+        """
+        subCategory
+        """
+        return pulumi.get(self, "sub_category")
+
+    @property
+    @pulumi.getter
+    def tag(self) -> str:
+        """
+        tag
+        """
+        return pulumi.get(self, "tag")
+
+    @property
+    @pulumi.getter
+    def technology(self) -> str:
+        """
+        technology
+        """
+        return pulumi.get(self, "technology")
+
+    @property
+    @pulumi.getter
+    def title(self) -> str:
+        """
+        title
+        """
+        return pulumi.get(self, "title")
+
+
+@pulumi.output_type
+class ApplicationInsightsResponse(dict):
+    """
+    Application Insights key
+    """
+    def __init__(__self__, *,
+                 id: Optional[str] = None,
+                 key: Optional[str] = None):
+        """
+        Application Insights key
+        :param str id: Resource id for Application Insights
+        :param str key: Application Insights key
+        """
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if key is not None:
+            pulumi.set(__self__, "key", key)
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[str]:
+        """
+        Resource id for Application Insights
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def key(self) -> Optional[str]:
+        """
+        Application Insights key
+        """
+        return pulumi.get(self, "key")
+
+
+@pulumi.output_type
+class AzureResourceManagerManagedIdentityPropertiesResponse(dict):
+    """
+    The properties of the managed service identities assigned to this resource.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "principalId":
+            suggest = "principal_id"
+        elif key == "tenantId":
+            suggest = "tenant_id"
+        elif key == "userAssignedIdentities":
+            suggest = "user_assigned_identities"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AzureResourceManagerManagedIdentityPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AzureResourceManagerManagedIdentityPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AzureResourceManagerManagedIdentityPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 principal_id: str,
+                 tenant_id: str,
+                 type: str,
+                 user_assigned_identities: Optional[Mapping[str, 'outputs.AzureResourceManagerUserAssignedIdentityResponse']] = None):
+        """
+        The properties of the managed service identities assigned to this resource.
+        :param str principal_id: The active directory identifier of this principal.
+        :param str tenant_id: The Active Directory tenant id of the principal.
+        :param str type: The type of managed identity assigned to this resource.
+        :param Mapping[str, 'AzureResourceManagerUserAssignedIdentityResponse'] user_assigned_identities: The identities assigned to this resource by the user.
+        """
+        pulumi.set(__self__, "principal_id", principal_id)
+        pulumi.set(__self__, "tenant_id", tenant_id)
+        pulumi.set(__self__, "type", type)
+        if user_assigned_identities is not None:
+            pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
+
+    @property
+    @pulumi.getter(name="principalId")
+    def principal_id(self) -> str:
+        """
+        The active directory identifier of this principal.
+        """
+        return pulumi.get(self, "principal_id")
+
+    @property
+    @pulumi.getter(name="tenantId")
+    def tenant_id(self) -> str:
+        """
+        The Active Directory tenant id of the principal.
+        """
+        return pulumi.get(self, "tenant_id")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        The type of managed identity assigned to this resource.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="userAssignedIdentities")
+    def user_assigned_identities(self) -> Optional[Mapping[str, 'outputs.AzureResourceManagerUserAssignedIdentityResponse']]:
+        """
+        The identities assigned to this resource by the user.
+        """
+        return pulumi.get(self, "user_assigned_identities")
+
+
+@pulumi.output_type
+class AzureResourceManagerUserAssignedIdentityResponse(dict):
+    """
+    A managed identity assigned by the user.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "clientId":
+            suggest = "client_id"
+        elif key == "principalId":
+            suggest = "principal_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AzureResourceManagerUserAssignedIdentityResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AzureResourceManagerUserAssignedIdentityResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AzureResourceManagerUserAssignedIdentityResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 client_id: Optional[str] = None,
+                 principal_id: Optional[str] = None):
+        """
+        A managed identity assigned by the user.
+        :param str client_id: The active directory client identifier for this principal.
+        :param str principal_id: The active directory identifier for this principal.
+        """
+        if client_id is not None:
+            pulumi.set(__self__, "client_id", client_id)
+        if principal_id is not None:
+            pulumi.set(__self__, "principal_id", principal_id)
+
+    @property
+    @pulumi.getter(name="clientId")
+    def client_id(self) -> Optional[str]:
+        """
+        The active directory client identifier for this principal.
+        """
+        return pulumi.get(self, "client_id")
+
+    @property
+    @pulumi.getter(name="principalId")
+    def principal_id(self) -> Optional[str]:
+        """
+        The active directory identifier for this principal.
+        """
+        return pulumi.get(self, "principal_id")
+
+
+@pulumi.output_type
+class CategoryResponse(dict):
+    """
+    URL/EDL to match
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "urlCustom":
+            suggest = "url_custom"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CategoryResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CategoryResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CategoryResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 feeds: Sequence[str],
+                 url_custom: Sequence[str]):
+        """
+        URL/EDL to match
+        :param Sequence[str] feeds: feed list
+        :param Sequence[str] url_custom: custom URL
+        """
+        pulumi.set(__self__, "feeds", feeds)
+        pulumi.set(__self__, "url_custom", url_custom)
+
+    @property
+    @pulumi.getter
+    def feeds(self) -> Sequence[str]:
+        """
+        feed list
+        """
+        return pulumi.get(self, "feeds")
+
+    @property
+    @pulumi.getter(name="urlCustom")
+    def url_custom(self) -> Sequence[str]:
+        """
+        custom URL
+        """
+        return pulumi.get(self, "url_custom")
+
+
+@pulumi.output_type
+class CountryResponse(dict):
+    """
+    Country Description
+    """
+    def __init__(__self__, *,
+                 code: str,
+                 description: Optional[str] = None):
+        """
+        Country Description
+        :param str code: country code
+        :param str description: code description
+        """
+        pulumi.set(__self__, "code", code)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def code(self) -> str:
+        """
+        country code
+        """
+        return pulumi.get(self, "code")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[str]:
+        """
+        code description
+        """
+        return pulumi.get(self, "description")
+
+
+@pulumi.output_type
+class DNSSettingsResponse(dict):
+    """
+    DNS Proxy settings for Firewall
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dnsServers":
+            suggest = "dns_servers"
+        elif key == "enableDnsProxy":
+            suggest = "enable_dns_proxy"
+        elif key == "enabledDnsType":
+            suggest = "enabled_dns_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DNSSettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DNSSettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DNSSettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 dns_servers: Optional[Sequence['outputs.IPAddressResponse']] = None,
+                 enable_dns_proxy: Optional[str] = None,
+                 enabled_dns_type: Optional[str] = None):
+        """
+        DNS Proxy settings for Firewall
+        :param Sequence['IPAddressResponse'] dns_servers: List of IPs associated with the Firewall
+        :param str enable_dns_proxy: Enable DNS proxy, disabled by default
+        :param str enabled_dns_type: Enabled DNS proxy type, disabled by default
+        """
+        if dns_servers is not None:
+            pulumi.set(__self__, "dns_servers", dns_servers)
+        if enable_dns_proxy is not None:
+            pulumi.set(__self__, "enable_dns_proxy", enable_dns_proxy)
+        if enabled_dns_type is not None:
+            pulumi.set(__self__, "enabled_dns_type", enabled_dns_type)
+
+    @property
+    @pulumi.getter(name="dnsServers")
+    def dns_servers(self) -> Optional[Sequence['outputs.IPAddressResponse']]:
+        """
+        List of IPs associated with the Firewall
+        """
+        return pulumi.get(self, "dns_servers")
+
+    @property
+    @pulumi.getter(name="enableDnsProxy")
+    def enable_dns_proxy(self) -> Optional[str]:
+        """
+        Enable DNS proxy, disabled by default
+        """
+        return pulumi.get(self, "enable_dns_proxy")
+
+    @property
+    @pulumi.getter(name="enabledDnsType")
+    def enabled_dns_type(self) -> Optional[str]:
+        """
+        Enabled DNS proxy type, disabled by default
+        """
+        return pulumi.get(self, "enabled_dns_type")
+
+
+@pulumi.output_type
+class DestinationAddrResponse(dict):
+    """
+    destination address
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "fqdnLists":
+            suggest = "fqdn_lists"
+        elif key == "prefixLists":
+            suggest = "prefix_lists"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DestinationAddrResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DestinationAddrResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DestinationAddrResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 cidrs: Optional[Sequence[str]] = None,
+                 countries: Optional[Sequence[str]] = None,
+                 feeds: Optional[Sequence[str]] = None,
+                 fqdn_lists: Optional[Sequence[str]] = None,
+                 prefix_lists: Optional[Sequence[str]] = None):
+        """
+        destination address
+        :param Sequence[str] cidrs: special value 'any'
+        :param Sequence[str] countries: list of countries
+        :param Sequence[str] feeds: list of feeds
+        :param Sequence[str] fqdn_lists: fqdn list
+        :param Sequence[str] prefix_lists: prefix list
+        """
+        if cidrs is not None:
+            pulumi.set(__self__, "cidrs", cidrs)
+        if countries is not None:
+            pulumi.set(__self__, "countries", countries)
+        if feeds is not None:
+            pulumi.set(__self__, "feeds", feeds)
+        if fqdn_lists is not None:
+            pulumi.set(__self__, "fqdn_lists", fqdn_lists)
+        if prefix_lists is not None:
+            pulumi.set(__self__, "prefix_lists", prefix_lists)
+
+    @property
+    @pulumi.getter
+    def cidrs(self) -> Optional[Sequence[str]]:
+        """
+        special value 'any'
+        """
+        return pulumi.get(self, "cidrs")
+
+    @property
+    @pulumi.getter
+    def countries(self) -> Optional[Sequence[str]]:
+        """
+        list of countries
+        """
+        return pulumi.get(self, "countries")
+
+    @property
+    @pulumi.getter
+    def feeds(self) -> Optional[Sequence[str]]:
+        """
+        list of feeds
+        """
+        return pulumi.get(self, "feeds")
+
+    @property
+    @pulumi.getter(name="fqdnLists")
+    def fqdn_lists(self) -> Optional[Sequence[str]]:
+        """
+        fqdn list
+        """
+        return pulumi.get(self, "fqdn_lists")
+
+    @property
+    @pulumi.getter(name="prefixLists")
+    def prefix_lists(self) -> Optional[Sequence[str]]:
+        """
+        prefix list
+        """
+        return pulumi.get(self, "prefix_lists")
+
+
+@pulumi.output_type
+class EndpointConfigurationResponse(dict):
+    """
+    Endpoint Configuration for frontend and backend
+    """
+    def __init__(__self__, *,
+                 address: 'outputs.IPAddressResponse',
+                 port: str):
+        """
+        Endpoint Configuration for frontend and backend
+        :param 'IPAddressResponse' address: Address Space
+        :param str port: port ID
+        """
+        pulumi.set(__self__, "address", address)
+        pulumi.set(__self__, "port", port)
+
+    @property
+    @pulumi.getter
+    def address(self) -> 'outputs.IPAddressResponse':
+        """
+        Address Space
+        """
+        return pulumi.get(self, "address")
+
+    @property
+    @pulumi.getter
+    def port(self) -> str:
+        """
+        port ID
+        """
+        return pulumi.get(self, "port")
+
+
+@pulumi.output_type
+class EventHubResponse(dict):
+    """
+    EventHub configurations
+    """
+    def __init__(__self__, *,
+                 id: Optional[str] = None,
+                 name: Optional[str] = None,
+                 name_space: Optional[str] = None,
+                 policy_name: Optional[str] = None,
+                 subscription_id: Optional[str] = None):
+        """
+        EventHub configurations
+        :param str id: Resource ID of EventHub
+        :param str name: EventHub name
+        :param str name_space: EventHub namespace
+        :param str policy_name: EventHub policy name
+        :param str subscription_id: Subscription Id
+        """
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if name_space is not None:
+            pulumi.set(__self__, "name_space", name_space)
+        if policy_name is not None:
+            pulumi.set(__self__, "policy_name", policy_name)
+        if subscription_id is not None:
+            pulumi.set(__self__, "subscription_id", subscription_id)
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[str]:
+        """
+        Resource ID of EventHub
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        EventHub name
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="nameSpace")
+    def name_space(self) -> Optional[str]:
+        """
+        EventHub namespace
+        """
+        return pulumi.get(self, "name_space")
+
+    @property
+    @pulumi.getter(name="policyName")
+    def policy_name(self) -> Optional[str]:
+        """
+        EventHub policy name
+        """
+        return pulumi.get(self, "policy_name")
+
+    @property
+    @pulumi.getter(name="subscriptionId")
+    def subscription_id(self) -> Optional[str]:
+        """
+        Subscription Id
+        """
+        return pulumi.get(self, "subscription_id")
+
+
+@pulumi.output_type
+class FrontendSettingResponse(dict):
+    """
+    Frontend setting for Firewall
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "backendConfiguration":
+            suggest = "backend_configuration"
+        elif key == "frontendConfiguration":
+            suggest = "frontend_configuration"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FrontendSettingResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FrontendSettingResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FrontendSettingResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 backend_configuration: 'outputs.EndpointConfigurationResponse',
+                 frontend_configuration: 'outputs.EndpointConfigurationResponse',
+                 name: str,
+                 protocol: str):
+        """
+        Frontend setting for Firewall
+        :param 'EndpointConfigurationResponse' backend_configuration: Backend configurations
+        :param 'EndpointConfigurationResponse' frontend_configuration: Frontend configurations
+        :param str name: Settings name
+        :param str protocol: Protocol Type
+        """
+        pulumi.set(__self__, "backend_configuration", backend_configuration)
+        pulumi.set(__self__, "frontend_configuration", frontend_configuration)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "protocol", protocol)
+
+    @property
+    @pulumi.getter(name="backendConfiguration")
+    def backend_configuration(self) -> 'outputs.EndpointConfigurationResponse':
+        """
+        Backend configurations
+        """
+        return pulumi.get(self, "backend_configuration")
+
+    @property
+    @pulumi.getter(name="frontendConfiguration")
+    def frontend_configuration(self) -> 'outputs.EndpointConfigurationResponse':
+        """
+        Frontend configurations
+        """
+        return pulumi.get(self, "frontend_configuration")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        Settings name
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def protocol(self) -> str:
+        """
+        Protocol Type
+        """
+        return pulumi.get(self, "protocol")
+
+
+@pulumi.output_type
+class IPAddressResponse(dict):
+    """
+    IP Address
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "resourceId":
+            suggest = "resource_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in IPAddressResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        IPAddressResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        IPAddressResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 address: Optional[str] = None,
+                 resource_id: Optional[str] = None):
+        """
+        IP Address
+        :param str address: Address value
+        :param str resource_id: Resource Id
+        """
+        if address is not None:
+            pulumi.set(__self__, "address", address)
+        if resource_id is not None:
+            pulumi.set(__self__, "resource_id", resource_id)
+
+    @property
+    @pulumi.getter
+    def address(self) -> Optional[str]:
+        """
+        Address value
+        """
+        return pulumi.get(self, "address")
+
+    @property
+    @pulumi.getter(name="resourceId")
+    def resource_id(self) -> Optional[str]:
+        """
+        Resource Id
+        """
+        return pulumi.get(self, "resource_id")
+
+
+@pulumi.output_type
+class IPAddressSpaceResponse(dict):
+    """
+    IP Address Space
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "addressSpace":
+            suggest = "address_space"
+        elif key == "resourceId":
+            suggest = "resource_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in IPAddressSpaceResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        IPAddressSpaceResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        IPAddressSpaceResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 address_space: Optional[str] = None,
+                 resource_id: Optional[str] = None):
+        """
+        IP Address Space
+        :param str address_space: Address Space
+        :param str resource_id: Resource Id
+        """
+        if address_space is not None:
+            pulumi.set(__self__, "address_space", address_space)
+        if resource_id is not None:
+            pulumi.set(__self__, "resource_id", resource_id)
+
+    @property
+    @pulumi.getter(name="addressSpace")
+    def address_space(self) -> Optional[str]:
+        """
+        Address Space
+        """
+        return pulumi.get(self, "address_space")
+
+    @property
+    @pulumi.getter(name="resourceId")
+    def resource_id(self) -> Optional[str]:
+        """
+        Resource Id
+        """
+        return pulumi.get(self, "resource_id")
+
+
+@pulumi.output_type
+class LogDestinationResponse(dict):
+    """
+    Log Destination
+    """
+    def __init__(__self__, *,
+                 event_hub_configurations: Optional['outputs.EventHubResponse'] = None,
+                 monitor_configurations: Optional['outputs.MonitorLogResponse'] = None,
+                 storage_configurations: Optional['outputs.StorageAccountResponse'] = None):
+        """
+        Log Destination
+        :param 'EventHubResponse' event_hub_configurations: Event Hub configurations
+        :param 'MonitorLogResponse' monitor_configurations: Monitor Log configurations
+        :param 'StorageAccountResponse' storage_configurations: Storage account configurations
+        """
+        if event_hub_configurations is not None:
+            pulumi.set(__self__, "event_hub_configurations", event_hub_configurations)
+        if monitor_configurations is not None:
+            pulumi.set(__self__, "monitor_configurations", monitor_configurations)
+        if storage_configurations is not None:
+            pulumi.set(__self__, "storage_configurations", storage_configurations)
+
+    @property
+    @pulumi.getter(name="eventHubConfigurations")
+    def event_hub_configurations(self) -> Optional['outputs.EventHubResponse']:
+        """
+        Event Hub configurations
+        """
+        return pulumi.get(self, "event_hub_configurations")
+
+    @property
+    @pulumi.getter(name="monitorConfigurations")
+    def monitor_configurations(self) -> Optional['outputs.MonitorLogResponse']:
+        """
+        Monitor Log configurations
+        """
+        return pulumi.get(self, "monitor_configurations")
+
+    @property
+    @pulumi.getter(name="storageConfigurations")
+    def storage_configurations(self) -> Optional['outputs.StorageAccountResponse']:
+        """
+        Storage account configurations
+        """
+        return pulumi.get(self, "storage_configurations")
+
+
+@pulumi.output_type
+class MarketplaceDetailsResponse(dict):
+    """
+    MarketplaceDetails of PAN Firewall resource
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "marketplaceSubscriptionId":
+            suggest = "marketplace_subscription_id"
+        elif key == "offerId":
+            suggest = "offer_id"
+        elif key == "publisherId":
+            suggest = "publisher_id"
+        elif key == "marketplaceSubscriptionStatus":
+            suggest = "marketplace_subscription_status"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in MarketplaceDetailsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        MarketplaceDetailsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        MarketplaceDetailsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 marketplace_subscription_id: str,
+                 offer_id: str,
+                 publisher_id: str,
+                 marketplace_subscription_status: Optional[str] = None):
+        """
+        MarketplaceDetails of PAN Firewall resource
+        :param str marketplace_subscription_id: Marketplace Subscription Id
+        :param str offer_id: Offer Id
+        :param str publisher_id: Publisher Id
+        :param str marketplace_subscription_status: Marketplace Subscription Status
+        """
+        pulumi.set(__self__, "marketplace_subscription_id", marketplace_subscription_id)
+        pulumi.set(__self__, "offer_id", offer_id)
+        pulumi.set(__self__, "publisher_id", publisher_id)
+        if marketplace_subscription_status is not None:
+            pulumi.set(__self__, "marketplace_subscription_status", marketplace_subscription_status)
+
+    @property
+    @pulumi.getter(name="marketplaceSubscriptionId")
+    def marketplace_subscription_id(self) -> str:
+        """
+        Marketplace Subscription Id
+        """
+        return pulumi.get(self, "marketplace_subscription_id")
+
+    @property
+    @pulumi.getter(name="offerId")
+    def offer_id(self) -> str:
+        """
+        Offer Id
+        """
+        return pulumi.get(self, "offer_id")
+
+    @property
+    @pulumi.getter(name="publisherId")
+    def publisher_id(self) -> str:
+        """
+        Publisher Id
+        """
+        return pulumi.get(self, "publisher_id")
+
+    @property
+    @pulumi.getter(name="marketplaceSubscriptionStatus")
+    def marketplace_subscription_status(self) -> Optional[str]:
+        """
+        Marketplace Subscription Status
+        """
+        return pulumi.get(self, "marketplace_subscription_status")
+
+
+@pulumi.output_type
+class MonitorLogResponse(dict):
+    """
+    MonitorLog configurations
+    """
+    def __init__(__self__, *,
+                 id: Optional[str] = None,
+                 primary_key: Optional[str] = None,
+                 secondary_key: Optional[str] = None,
+                 subscription_id: Optional[str] = None,
+                 workspace: Optional[str] = None):
+        """
+        MonitorLog configurations
+        :param str id: Resource ID of MonitorLog
+        :param str primary_key: Primary Key value for Monitor
+        :param str secondary_key: Secondary Key value for Monitor
+        :param str subscription_id: Subscription Id
+        :param str workspace: MonitorLog workspace
+        """
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if primary_key is not None:
+            pulumi.set(__self__, "primary_key", primary_key)
+        if secondary_key is not None:
+            pulumi.set(__self__, "secondary_key", secondary_key)
+        if subscription_id is not None:
+            pulumi.set(__self__, "subscription_id", subscription_id)
+        if workspace is not None:
+            pulumi.set(__self__, "workspace", workspace)
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[str]:
+        """
+        Resource ID of MonitorLog
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="primaryKey")
+    def primary_key(self) -> Optional[str]:
+        """
+        Primary Key value for Monitor
+        """
+        return pulumi.get(self, "primary_key")
+
+    @property
+    @pulumi.getter(name="secondaryKey")
+    def secondary_key(self) -> Optional[str]:
+        """
+        Secondary Key value for Monitor
+        """
+        return pulumi.get(self, "secondary_key")
+
+    @property
+    @pulumi.getter(name="subscriptionId")
+    def subscription_id(self) -> Optional[str]:
+        """
+        Subscription Id
+        """
+        return pulumi.get(self, "subscription_id")
+
+    @property
+    @pulumi.getter
+    def workspace(self) -> Optional[str]:
+        """
+        MonitorLog workspace
+        """
+        return pulumi.get(self, "workspace")
+
+
+@pulumi.output_type
+class NameDescriptionObjectResponse(dict):
+    """
+    object type info
+    """
+    def __init__(__self__, *,
+                 name: str,
+                 description: Optional[str] = None):
+        """
+        object type info
+        :param str name: name value
+        :param str description: description value
+        """
+        pulumi.set(__self__, "name", name)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        name value
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[str]:
+        """
+        description value
+        """
+        return pulumi.get(self, "description")
+
+
+@pulumi.output_type
+class NetworkProfileResponse(dict):
+    """
+    Network settings for Firewall
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "enableEgressNat":
+            suggest = "enable_egress_nat"
+        elif key == "networkType":
+            suggest = "network_type"
+        elif key == "publicIps":
+            suggest = "public_ips"
+        elif key == "egressNatIp":
+            suggest = "egress_nat_ip"
+        elif key == "vnetConfiguration":
+            suggest = "vnet_configuration"
+        elif key == "vwanConfiguration":
+            suggest = "vwan_configuration"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NetworkProfileResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NetworkProfileResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NetworkProfileResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 enable_egress_nat: str,
+                 network_type: str,
+                 public_ips: Sequence['outputs.IPAddressResponse'],
+                 egress_nat_ip: Optional[Sequence['outputs.IPAddressResponse']] = None,
+                 vnet_configuration: Optional['outputs.VnetConfigurationResponse'] = None,
+                 vwan_configuration: Optional['outputs.VwanConfigurationResponse'] = None):
+        """
+        Network settings for Firewall
+        :param str enable_egress_nat: Enable egress NAT, enabled by default
+        :param str network_type: vnet or vwan, cannot be updated
+        :param Sequence['IPAddressResponse'] public_ips: List of IPs associated with the Firewall
+        :param Sequence['IPAddressResponse'] egress_nat_ip: Egress nat IP to use
+        :param 'VnetConfigurationResponse' vnet_configuration: Vnet configurations
+        :param 'VwanConfigurationResponse' vwan_configuration: Vwan configurations
+        """
+        pulumi.set(__self__, "enable_egress_nat", enable_egress_nat)
+        pulumi.set(__self__, "network_type", network_type)
+        pulumi.set(__self__, "public_ips", public_ips)
+        if egress_nat_ip is not None:
+            pulumi.set(__self__, "egress_nat_ip", egress_nat_ip)
+        if vnet_configuration is not None:
+            pulumi.set(__self__, "vnet_configuration", vnet_configuration)
+        if vwan_configuration is not None:
+            pulumi.set(__self__, "vwan_configuration", vwan_configuration)
+
+    @property
+    @pulumi.getter(name="enableEgressNat")
+    def enable_egress_nat(self) -> str:
+        """
+        Enable egress NAT, enabled by default
+        """
+        return pulumi.get(self, "enable_egress_nat")
+
+    @property
+    @pulumi.getter(name="networkType")
+    def network_type(self) -> str:
+        """
+        vnet or vwan, cannot be updated
+        """
+        return pulumi.get(self, "network_type")
+
+    @property
+    @pulumi.getter(name="publicIps")
+    def public_ips(self) -> Sequence['outputs.IPAddressResponse']:
+        """
+        List of IPs associated with the Firewall
+        """
+        return pulumi.get(self, "public_ips")
+
+    @property
+    @pulumi.getter(name="egressNatIp")
+    def egress_nat_ip(self) -> Optional[Sequence['outputs.IPAddressResponse']]:
+        """
+        Egress nat IP to use
+        """
+        return pulumi.get(self, "egress_nat_ip")
+
+    @property
+    @pulumi.getter(name="vnetConfiguration")
+    def vnet_configuration(self) -> Optional['outputs.VnetConfigurationResponse']:
+        """
+        Vnet configurations
+        """
+        return pulumi.get(self, "vnet_configuration")
+
+    @property
+    @pulumi.getter(name="vwanConfiguration")
+    def vwan_configuration(self) -> Optional['outputs.VwanConfigurationResponse']:
+        """
+        Vwan configurations
+        """
+        return pulumi.get(self, "vwan_configuration")
+
+
+@pulumi.output_type
+class PanoramaConfigResponse(dict):
+    """
+    Panorama Config
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "cgName":
+            suggest = "cg_name"
+        elif key == "configString":
+            suggest = "config_string"
+        elif key == "dgName":
+            suggest = "dg_name"
+        elif key == "hostName":
+            suggest = "host_name"
+        elif key == "panoramaServer":
+            suggest = "panorama_server"
+        elif key == "panoramaServer2":
+            suggest = "panorama_server2"
+        elif key == "tplName":
+            suggest = "tpl_name"
+        elif key == "vmAuthKey":
+            suggest = "vm_auth_key"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PanoramaConfigResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PanoramaConfigResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PanoramaConfigResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 cg_name: str,
+                 config_string: str,
+                 dg_name: str,
+                 host_name: str,
+                 panorama_server: str,
+                 panorama_server2: str,
+                 tpl_name: str,
+                 vm_auth_key: str):
+        """
+        Panorama Config
+        :param str cg_name: Panorama Collector Group to join - (Once configured we can not edit the value)
+        :param str config_string: Base64 encoded string representing Panorama parameters to be used by Firewall to connect to Panorama. This string is generated via azure plugin in Panorama
+        :param str dg_name: Panorama Device Group to join
+        :param str host_name: Resource name(may be unique) for PN admin
+        :param str panorama_server: Primary Panorama Server IP address value in dotted format for IPv4
+        :param str panorama_server2: Secondary Panorama Server IP address value in dotted format for IPv4
+        :param str tpl_name: Panorama Template Stack to join - (Once configured we can not edit the value)
+        :param str vm_auth_key: VM auth key for panorama connectivity
+        """
+        pulumi.set(__self__, "cg_name", cg_name)
+        pulumi.set(__self__, "config_string", config_string)
+        pulumi.set(__self__, "dg_name", dg_name)
+        pulumi.set(__self__, "host_name", host_name)
+        pulumi.set(__self__, "panorama_server", panorama_server)
+        pulumi.set(__self__, "panorama_server2", panorama_server2)
+        pulumi.set(__self__, "tpl_name", tpl_name)
+        pulumi.set(__self__, "vm_auth_key", vm_auth_key)
+
+    @property
+    @pulumi.getter(name="cgName")
+    def cg_name(self) -> str:
+        """
+        Panorama Collector Group to join - (Once configured we can not edit the value)
+        """
+        return pulumi.get(self, "cg_name")
+
+    @property
+    @pulumi.getter(name="configString")
+    def config_string(self) -> str:
+        """
+        Base64 encoded string representing Panorama parameters to be used by Firewall to connect to Panorama. This string is generated via azure plugin in Panorama
+        """
+        return pulumi.get(self, "config_string")
+
+    @property
+    @pulumi.getter(name="dgName")
+    def dg_name(self) -> str:
+        """
+        Panorama Device Group to join
+        """
+        return pulumi.get(self, "dg_name")
+
+    @property
+    @pulumi.getter(name="hostName")
+    def host_name(self) -> str:
+        """
+        Resource name(may be unique) for PN admin
+        """
+        return pulumi.get(self, "host_name")
+
+    @property
+    @pulumi.getter(name="panoramaServer")
+    def panorama_server(self) -> str:
+        """
+        Primary Panorama Server IP address value in dotted format for IPv4
+        """
+        return pulumi.get(self, "panorama_server")
+
+    @property
+    @pulumi.getter(name="panoramaServer2")
+    def panorama_server2(self) -> str:
+        """
+        Secondary Panorama Server IP address value in dotted format for IPv4
+        """
+        return pulumi.get(self, "panorama_server2")
+
+    @property
+    @pulumi.getter(name="tplName")
+    def tpl_name(self) -> str:
+        """
+        Panorama Template Stack to join - (Once configured we can not edit the value)
+        """
+        return pulumi.get(self, "tpl_name")
+
+    @property
+    @pulumi.getter(name="vmAuthKey")
+    def vm_auth_key(self) -> str:
+        """
+        VM auth key for panorama connectivity
+        """
+        return pulumi.get(self, "vm_auth_key")
+
+
+@pulumi.output_type
+class PlanDataResponse(dict):
+    """
+    Billing plan information.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "billingCycle":
+            suggest = "billing_cycle"
+        elif key == "effectiveDate":
+            suggest = "effective_date"
+        elif key == "planId":
+            suggest = "plan_id"
+        elif key == "usageType":
+            suggest = "usage_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PlanDataResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PlanDataResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PlanDataResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 billing_cycle: str,
+                 effective_date: str,
+                 plan_id: str,
+                 usage_type: Optional[str] = None):
+        """
+        Billing plan information.
+        :param str billing_cycle: different billing cycles like MONTHLY/WEEKLY
+        :param str effective_date: date when plan was applied
+        :param str plan_id: plan id as published by Liftr.PAN
+        :param str usage_type: different usage type like PAYG/COMMITTED
+        """
+        pulumi.set(__self__, "billing_cycle", billing_cycle)
+        pulumi.set(__self__, "effective_date", effective_date)
+        pulumi.set(__self__, "plan_id", plan_id)
+        if usage_type is not None:
+            pulumi.set(__self__, "usage_type", usage_type)
+
+    @property
+    @pulumi.getter(name="billingCycle")
+    def billing_cycle(self) -> str:
+        """
+        different billing cycles like MONTHLY/WEEKLY
+        """
+        return pulumi.get(self, "billing_cycle")
+
+    @property
+    @pulumi.getter(name="effectiveDate")
+    def effective_date(self) -> str:
+        """
+        date when plan was applied
+        """
+        return pulumi.get(self, "effective_date")
+
+    @property
+    @pulumi.getter(name="planId")
+    def plan_id(self) -> str:
+        """
+        plan id as published by Liftr.PAN
+        """
+        return pulumi.get(self, "plan_id")
+
+    @property
+    @pulumi.getter(name="usageType")
+    def usage_type(self) -> Optional[str]:
+        """
+        different usage type like PAYG/COMMITTED
+        """
+        return pulumi.get(self, "usage_type")
+
+
+@pulumi.output_type
+class PredefinedUrlCategoryResponse(dict):
+    """
+    Predefined URL category object
+    """
+    def __init__(__self__, *,
+                 action: str,
+                 name: str):
+        """
+        Predefined URL category object
+        """
+        pulumi.set(__self__, "action", action)
+        pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def action(self) -> str:
+        return pulumi.get(self, "action")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        return pulumi.get(self, "name")
+
+
+@pulumi.output_type
+class RulestackDetailsResponse(dict):
+    """
+    Associated rulestack details
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "resourceId":
+            suggest = "resource_id"
+        elif key == "rulestackId":
+            suggest = "rulestack_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in RulestackDetailsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        RulestackDetailsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        RulestackDetailsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 location: Optional[str] = None,
+                 resource_id: Optional[str] = None,
+                 rulestack_id: Optional[str] = None):
+        """
+        Associated rulestack details
+        :param str location: Rulestack location
+        :param str resource_id: Resource Id
+        :param str rulestack_id: Associated rulestack Id
+        """
+        if location is not None:
+            pulumi.set(__self__, "location", location)
+        if resource_id is not None:
+            pulumi.set(__self__, "resource_id", resource_id)
+        if rulestack_id is not None:
+            pulumi.set(__self__, "rulestack_id", rulestack_id)
+
+    @property
+    @pulumi.getter
+    def location(self) -> Optional[str]:
+        """
+        Rulestack location
+        """
+        return pulumi.get(self, "location")
+
+    @property
+    @pulumi.getter(name="resourceId")
+    def resource_id(self) -> Optional[str]:
+        """
+        Resource Id
+        """
+        return pulumi.get(self, "resource_id")
+
+    @property
+    @pulumi.getter(name="rulestackId")
+    def rulestack_id(self) -> Optional[str]:
+        """
+        Associated rulestack Id
+        """
+        return pulumi.get(self, "rulestack_id")
+
+
+@pulumi.output_type
+class SecurityServicesResponse(dict):
+    """
+    security services
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "antiSpywareProfile":
+            suggest = "anti_spyware_profile"
+        elif key == "antiVirusProfile":
+            suggest = "anti_virus_profile"
+        elif key == "dnsSubscription":
+            suggest = "dns_subscription"
+        elif key == "fileBlockingProfile":
+            suggest = "file_blocking_profile"
+        elif key == "outboundTrustCertificate":
+            suggest = "outbound_trust_certificate"
+        elif key == "outboundUnTrustCertificate":
+            suggest = "outbound_un_trust_certificate"
+        elif key == "urlFilteringProfile":
+            suggest = "url_filtering_profile"
+        elif key == "vulnerabilityProfile":
+            suggest = "vulnerability_profile"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SecurityServicesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SecurityServicesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SecurityServicesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 anti_spyware_profile: Optional[str] = None,
+                 anti_virus_profile: Optional[str] = None,
+                 dns_subscription: Optional[str] = None,
+                 file_blocking_profile: Optional[str] = None,
+                 outbound_trust_certificate: Optional[str] = None,
+                 outbound_un_trust_certificate: Optional[str] = None,
+                 url_filtering_profile: Optional[str] = None,
+                 vulnerability_profile: Optional[str] = None):
+        """
+        security services
+        :param str anti_spyware_profile: Anti spyware Profile data
+        :param str anti_virus_profile: anti virus profile data
+        :param str dns_subscription: DNS Subscription profile data
+        :param str file_blocking_profile: File blocking profile data
+        :param str outbound_trust_certificate: Trusted Egress Decryption profile data
+        :param str outbound_un_trust_certificate: Untrusted Egress Decryption profile data
+        :param str url_filtering_profile: URL filtering profile data
+        :param str vulnerability_profile: IPs Vulnerability Profile Data
+        """
+        if anti_spyware_profile is not None:
+            pulumi.set(__self__, "anti_spyware_profile", anti_spyware_profile)
+        if anti_virus_profile is not None:
+            pulumi.set(__self__, "anti_virus_profile", anti_virus_profile)
+        if dns_subscription is not None:
+            pulumi.set(__self__, "dns_subscription", dns_subscription)
+        if file_blocking_profile is not None:
+            pulumi.set(__self__, "file_blocking_profile", file_blocking_profile)
+        if outbound_trust_certificate is not None:
+            pulumi.set(__self__, "outbound_trust_certificate", outbound_trust_certificate)
+        if outbound_un_trust_certificate is not None:
+            pulumi.set(__self__, "outbound_un_trust_certificate", outbound_un_trust_certificate)
+        if url_filtering_profile is not None:
+            pulumi.set(__self__, "url_filtering_profile", url_filtering_profile)
+        if vulnerability_profile is not None:
+            pulumi.set(__self__, "vulnerability_profile", vulnerability_profile)
+
+    @property
+    @pulumi.getter(name="antiSpywareProfile")
+    def anti_spyware_profile(self) -> Optional[str]:
+        """
+        Anti spyware Profile data
+        """
+        return pulumi.get(self, "anti_spyware_profile")
+
+    @property
+    @pulumi.getter(name="antiVirusProfile")
+    def anti_virus_profile(self) -> Optional[str]:
+        """
+        anti virus profile data
+        """
+        return pulumi.get(self, "anti_virus_profile")
+
+    @property
+    @pulumi.getter(name="dnsSubscription")
+    def dns_subscription(self) -> Optional[str]:
+        """
+        DNS Subscription profile data
+        """
+        return pulumi.get(self, "dns_subscription")
+
+    @property
+    @pulumi.getter(name="fileBlockingProfile")
+    def file_blocking_profile(self) -> Optional[str]:
+        """
+        File blocking profile data
+        """
+        return pulumi.get(self, "file_blocking_profile")
+
+    @property
+    @pulumi.getter(name="outboundTrustCertificate")
+    def outbound_trust_certificate(self) -> Optional[str]:
+        """
+        Trusted Egress Decryption profile data
+        """
+        return pulumi.get(self, "outbound_trust_certificate")
+
+    @property
+    @pulumi.getter(name="outboundUnTrustCertificate")
+    def outbound_un_trust_certificate(self) -> Optional[str]:
+        """
+        Untrusted Egress Decryption profile data
+        """
+        return pulumi.get(self, "outbound_un_trust_certificate")
+
+    @property
+    @pulumi.getter(name="urlFilteringProfile")
+    def url_filtering_profile(self) -> Optional[str]:
+        """
+        URL filtering profile data
+        """
+        return pulumi.get(self, "url_filtering_profile")
+
+    @property
+    @pulumi.getter(name="vulnerabilityProfile")
+    def vulnerability_profile(self) -> Optional[str]:
+        """
+        IPs Vulnerability Profile Data
+        """
+        return pulumi.get(self, "vulnerability_profile")
+
+
+@pulumi.output_type
+class SecurityServicesTypeListResponse(dict):
+    """
+    Security services type list
+    """
+    def __init__(__self__, *,
+                 entry: Sequence['outputs.NameDescriptionObjectResponse'],
+                 type: Optional[str] = None):
+        """
+        Security services type list
+        :param Sequence['NameDescriptionObjectResponse'] entry: list
+        :param str type: security services type
+        """
+        pulumi.set(__self__, "entry", entry)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def entry(self) -> Sequence['outputs.NameDescriptionObjectResponse']:
+        """
+        list
+        """
+        return pulumi.get(self, "entry")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        security services type
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class SourceAddrResponse(dict):
+    """
+    Address properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "prefixLists":
+            suggest = "prefix_lists"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SourceAddrResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SourceAddrResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SourceAddrResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 cidrs: Optional[Sequence[str]] = None,
+                 countries: Optional[Sequence[str]] = None,
+                 feeds: Optional[Sequence[str]] = None,
+                 prefix_lists: Optional[Sequence[str]] = None):
+        """
+        Address properties
+        :param Sequence[str] cidrs: special value 'any'
+        :param Sequence[str] countries: list of countries
+        :param Sequence[str] feeds: list of feeds
+        :param Sequence[str] prefix_lists: prefix list
+        """
+        if cidrs is not None:
+            pulumi.set(__self__, "cidrs", cidrs)
+        if countries is not None:
+            pulumi.set(__self__, "countries", countries)
+        if feeds is not None:
+            pulumi.set(__self__, "feeds", feeds)
+        if prefix_lists is not None:
+            pulumi.set(__self__, "prefix_lists", prefix_lists)
+
+    @property
+    @pulumi.getter
+    def cidrs(self) -> Optional[Sequence[str]]:
+        """
+        special value 'any'
+        """
+        return pulumi.get(self, "cidrs")
+
+    @property
+    @pulumi.getter
+    def countries(self) -> Optional[Sequence[str]]:
+        """
+        list of countries
+        """
+        return pulumi.get(self, "countries")
+
+    @property
+    @pulumi.getter
+    def feeds(self) -> Optional[Sequence[str]]:
+        """
+        list of feeds
+        """
+        return pulumi.get(self, "feeds")
+
+    @property
+    @pulumi.getter(name="prefixLists")
+    def prefix_lists(self) -> Optional[Sequence[str]]:
+        """
+        prefix list
+        """
+        return pulumi.get(self, "prefix_lists")
+
+
+@pulumi.output_type
+class StorageAccountResponse(dict):
+    """
+    Storage Account configurations
+    """
+    def __init__(__self__, *,
+                 account_name: Optional[str] = None,
+                 id: Optional[str] = None,
+                 subscription_id: Optional[str] = None):
+        """
+        Storage Account configurations
+        :param str account_name: Storage account name
+        :param str id: Resource ID of storage account
+        :param str subscription_id: Subscription Id
+        """
+        if account_name is not None:
+            pulumi.set(__self__, "account_name", account_name)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if subscription_id is not None:
+            pulumi.set(__self__, "subscription_id", subscription_id)
+
+    @property
+    @pulumi.getter(name="accountName")
+    def account_name(self) -> Optional[str]:
+        """
+        Storage account name
+        """
+        return pulumi.get(self, "account_name")
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[str]:
+        """
+        Resource ID of storage account
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="subscriptionId")
+    def subscription_id(self) -> Optional[str]:
+        """
+        Subscription Id
+        """
+        return pulumi.get(self, "subscription_id")
+
+
+@pulumi.output_type
+class SystemDataResponse(dict):
+    """
+    Metadata pertaining to creation and last modification of the resource.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "createdAt":
+            suggest = "created_at"
+        elif key == "createdBy":
+            suggest = "created_by"
+        elif key == "createdByType":
+            suggest = "created_by_type"
+        elif key == "lastModifiedAt":
+            suggest = "last_modified_at"
+        elif key == "lastModifiedBy":
+            suggest = "last_modified_by"
+        elif key == "lastModifiedByType":
+            suggest = "last_modified_by_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SystemDataResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SystemDataResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SystemDataResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 created_at: Optional[str] = None,
+                 created_by: Optional[str] = None,
+                 created_by_type: Optional[str] = None,
+                 last_modified_at: Optional[str] = None,
+                 last_modified_by: Optional[str] = None,
+                 last_modified_by_type: Optional[str] = None):
+        """
+        Metadata pertaining to creation and last modification of the resource.
+        :param str created_at: The timestamp of resource creation (UTC).
+        :param str created_by: The identity that created the resource.
+        :param str created_by_type: The type of identity that created the resource.
+        :param str last_modified_at: The timestamp of resource last modification (UTC)
+        :param str last_modified_by: The identity that last modified the resource.
+        :param str last_modified_by_type: The type of identity that last modified the resource.
+        """
+        if created_at is not None:
+            pulumi.set(__self__, "created_at", created_at)
+        if created_by is not None:
+            pulumi.set(__self__, "created_by", created_by)
+        if created_by_type is not None:
+            pulumi.set(__self__, "created_by_type", created_by_type)
+        if last_modified_at is not None:
+            pulumi.set(__self__, "last_modified_at", last_modified_at)
+        if last_modified_by is not None:
+            pulumi.set(__self__, "last_modified_by", last_modified_by)
+        if last_modified_by_type is not None:
+            pulumi.set(__self__, "last_modified_by_type", last_modified_by_type)
+
+    @property
+    @pulumi.getter(name="createdAt")
+    def created_at(self) -> Optional[str]:
+        """
+        The timestamp of resource creation (UTC).
+        """
+        return pulumi.get(self, "created_at")
+
+    @property
+    @pulumi.getter(name="createdBy")
+    def created_by(self) -> Optional[str]:
+        """
+        The identity that created the resource.
+        """
+        return pulumi.get(self, "created_by")
+
+    @property
+    @pulumi.getter(name="createdByType")
+    def created_by_type(self) -> Optional[str]:
+        """
+        The type of identity that created the resource.
+        """
+        return pulumi.get(self, "created_by_type")
+
+    @property
+    @pulumi.getter(name="lastModifiedAt")
+    def last_modified_at(self) -> Optional[str]:
+        """
+        The timestamp of resource last modification (UTC)
+        """
+        return pulumi.get(self, "last_modified_at")
+
+    @property
+    @pulumi.getter(name="lastModifiedBy")
+    def last_modified_by(self) -> Optional[str]:
+        """
+        The identity that last modified the resource.
+        """
+        return pulumi.get(self, "last_modified_by")
+
+    @property
+    @pulumi.getter(name="lastModifiedByType")
+    def last_modified_by_type(self) -> Optional[str]:
+        """
+        The type of identity that last modified the resource.
+        """
+        return pulumi.get(self, "last_modified_by_type")
+
+
+@pulumi.output_type
+class TagInfoResponse(dict):
+    """
+    Tag
+    """
+    def __init__(__self__, *,
+                 key: str,
+                 value: str):
+        """
+        Tag
+        :param str key: tag name
+        :param str value: tag value
+        """
+        pulumi.set(__self__, "key", key)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def key(self) -> str:
+        """
+        tag name
+        """
+        return pulumi.get(self, "key")
+
+    @property
+    @pulumi.getter
+    def value(self) -> str:
+        """
+        tag value
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class VnetConfigurationResponse(dict):
+    """
+    VnetInfo for Firewall Networking
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "trustSubnet":
+            suggest = "trust_subnet"
+        elif key == "unTrustSubnet":
+            suggest = "un_trust_subnet"
+        elif key == "ipOfTrustSubnetForUdr":
+            suggest = "ip_of_trust_subnet_for_udr"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in VnetConfigurationResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        VnetConfigurationResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        VnetConfigurationResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 trust_subnet: 'outputs.IPAddressSpaceResponse',
+                 un_trust_subnet: 'outputs.IPAddressSpaceResponse',
+                 vnet: 'outputs.IPAddressSpaceResponse',
+                 ip_of_trust_subnet_for_udr: Optional['outputs.IPAddressResponse'] = None):
+        """
+        VnetInfo for Firewall Networking
+        :param 'IPAddressSpaceResponse' trust_subnet: Trust Subnet
+        :param 'IPAddressSpaceResponse' un_trust_subnet: Untrust Subnet
+        :param 'IPAddressSpaceResponse' vnet: Azure Virtual Network
+        :param 'IPAddressResponse' ip_of_trust_subnet_for_udr: IP of trust subnet for UDR
+        """
+        pulumi.set(__self__, "trust_subnet", trust_subnet)
+        pulumi.set(__self__, "un_trust_subnet", un_trust_subnet)
+        pulumi.set(__self__, "vnet", vnet)
+        if ip_of_trust_subnet_for_udr is not None:
+            pulumi.set(__self__, "ip_of_trust_subnet_for_udr", ip_of_trust_subnet_for_udr)
+
+    @property
+    @pulumi.getter(name="trustSubnet")
+    def trust_subnet(self) -> 'outputs.IPAddressSpaceResponse':
+        """
+        Trust Subnet
+        """
+        return pulumi.get(self, "trust_subnet")
+
+    @property
+    @pulumi.getter(name="unTrustSubnet")
+    def un_trust_subnet(self) -> 'outputs.IPAddressSpaceResponse':
+        """
+        Untrust Subnet
+        """
+        return pulumi.get(self, "un_trust_subnet")
+
+    @property
+    @pulumi.getter
+    def vnet(self) -> 'outputs.IPAddressSpaceResponse':
+        """
+        Azure Virtual Network
+        """
+        return pulumi.get(self, "vnet")
+
+    @property
+    @pulumi.getter(name="ipOfTrustSubnetForUdr")
+    def ip_of_trust_subnet_for_udr(self) -> Optional['outputs.IPAddressResponse']:
+        """
+        IP of trust subnet for UDR
+        """
+        return pulumi.get(self, "ip_of_trust_subnet_for_udr")
+
+
+@pulumi.output_type
+class VwanConfigurationResponse(dict):
+    """
+    VwanInfo for Firewall Networking
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "vHub":
+            suggest = "v_hub"
+        elif key == "ipOfTrustSubnetForUdr":
+            suggest = "ip_of_trust_subnet_for_udr"
+        elif key == "networkVirtualApplianceId":
+            suggest = "network_virtual_appliance_id"
+        elif key == "trustSubnet":
+            suggest = "trust_subnet"
+        elif key == "unTrustSubnet":
+            suggest = "un_trust_subnet"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in VwanConfigurationResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        VwanConfigurationResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        VwanConfigurationResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 v_hub: 'outputs.IPAddressSpaceResponse',
+                 ip_of_trust_subnet_for_udr: Optional['outputs.IPAddressResponse'] = None,
+                 network_virtual_appliance_id: Optional[str] = None,
+                 trust_subnet: Optional['outputs.IPAddressSpaceResponse'] = None,
+                 un_trust_subnet: Optional['outputs.IPAddressSpaceResponse'] = None):
+        """
+        VwanInfo for Firewall Networking
+        :param 'IPAddressSpaceResponse' v_hub: vHub Address
+        :param 'IPAddressResponse' ip_of_trust_subnet_for_udr: IP of trust subnet for UDR
+        :param str network_virtual_appliance_id: Network Virtual Appliance resource ID 
+        :param 'IPAddressSpaceResponse' trust_subnet: Trust Subnet
+        :param 'IPAddressSpaceResponse' un_trust_subnet: Untrust Subnet
+        """
+        pulumi.set(__self__, "v_hub", v_hub)
+        if ip_of_trust_subnet_for_udr is not None:
+            pulumi.set(__self__, "ip_of_trust_subnet_for_udr", ip_of_trust_subnet_for_udr)
+        if network_virtual_appliance_id is not None:
+            pulumi.set(__self__, "network_virtual_appliance_id", network_virtual_appliance_id)
+        if trust_subnet is not None:
+            pulumi.set(__self__, "trust_subnet", trust_subnet)
+        if un_trust_subnet is not None:
+            pulumi.set(__self__, "un_trust_subnet", un_trust_subnet)
+
+    @property
+    @pulumi.getter(name="vHub")
+    def v_hub(self) -> 'outputs.IPAddressSpaceResponse':
+        """
+        vHub Address
+        """
+        return pulumi.get(self, "v_hub")
+
+    @property
+    @pulumi.getter(name="ipOfTrustSubnetForUdr")
+    def ip_of_trust_subnet_for_udr(self) -> Optional['outputs.IPAddressResponse']:
+        """
+        IP of trust subnet for UDR
+        """
+        return pulumi.get(self, "ip_of_trust_subnet_for_udr")
+
+    @property
+    @pulumi.getter(name="networkVirtualApplianceId")
+    def network_virtual_appliance_id(self) -> Optional[str]:
+        """
+        Network Virtual Appliance resource ID 
+        """
+        return pulumi.get(self, "network_virtual_appliance_id")
+
+    @property
+    @pulumi.getter(name="trustSubnet")
+    def trust_subnet(self) -> Optional['outputs.IPAddressSpaceResponse']:
+        """
+        Trust Subnet
+        """
+        return pulumi.get(self, "trust_subnet")
+
+    @property
+    @pulumi.getter(name="unTrustSubnet")
+    def un_trust_subnet(self) -> Optional['outputs.IPAddressSpaceResponse']:
+        """
+        Untrust Subnet
+        """
+        return pulumi.get(self, "un_trust_subnet")
+
+