pulumi-azure-native 2.52.0a1722242159__py3-none-any.whl → 2.52.1__py3-none-any.whl

pulumi_azure_native/cdn/v20240201/outputs.py

@@ -555,11 +555,13 @@ class CacheExpirationActionParametersResponse(dict):
         Defines the parameters for the cache expiration action.
         :param str cache_behavior: Caching behavior for the requests
         :param str cache_type: The level at which the content needs to be cached.
+        :param str type_name: 
+               Expected value is 'DeliveryRuleCacheExpirationActionParameters'.
         :param str cache_duration: The duration for which the content needs to be cached. Allowed format is [d.]hh:mm:ss
         """
         pulumi.set(__self__, "cache_behavior", cache_behavior)
         pulumi.set(__self__, "cache_type", cache_type)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleCacheExpirationActionParameters')
         if cache_duration is not None:
             pulumi.set(__self__, "cache_duration", cache_duration)
 
@@ -582,6 +584,10 @@ class CacheExpirationActionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleCacheExpirationActionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -626,10 +632,12 @@ class CacheKeyQueryStringActionParametersResponse(dict):
         """
         Defines the parameters for the cache-key query string action.
         :param str query_string_behavior: Caching behavior for the requests
+        :param str type_name: 
+               Expected value is 'DeliveryRuleCacheKeyQueryStringBehaviorActionParameters'.
         :param str query_parameters: query parameters to include or exclude (comma separated).
         """
         pulumi.set(__self__, "query_string_behavior", query_string_behavior)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleCacheKeyQueryStringBehaviorActionParameters')
         if query_parameters is not None:
             pulumi.set(__self__, "query_parameters", query_parameters)
 
@@ -644,6 +652,10 @@ class CacheKeyQueryStringActionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleCacheKeyQueryStringBehaviorActionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -685,9 +697,11 @@ class CdnCertificateSourceParametersResponse(dict):
         """
         Defines the parameters for using CDN managed certificate for securing custom domain.
         :param str certificate_type: Type of certificate used
+        :param str type_name: 
+               Expected value is 'CdnCertificateSourceParameters'.
         """
         pulumi.set(__self__, "certificate_type", certificate_type)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'CdnCertificateSourceParameters')
 
     @property
     @pulumi.getter(name="certificateType")
@@ -700,6 +714,10 @@ class CdnCertificateSourceParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'CdnCertificateSourceParameters'.
+        """
         return pulumi.get(self, "type_name")
 
 
@@ -842,12 +860,14 @@ class ClientPortMatchConditionParametersResponse(dict):
         """
         Defines the parameters for ClientPort match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleClientPortConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleClientPortConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -868,6 +888,10 @@ class ClientPortMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleClientPortConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -985,13 +1009,15 @@ class CookiesMatchConditionParametersResponse(dict):
         """
         Defines the parameters for Cookies match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleCookiesConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param str selector: Name of Cookies to be matched
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleCookiesConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -1014,6 +1040,10 @@ class CookiesMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleCookiesConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -2755,11 +2785,13 @@ class HeaderActionParametersResponse(dict):
         Defines the parameters for the request header action.
         :param str header_action: Action to perform
         :param str header_name: Name of the header to modify
+        :param str type_name: 
+               Expected value is 'DeliveryRuleHeaderActionParameters'.
         :param str value: Value for the specified action
         """
         pulumi.set(__self__, "header_action", header_action)
         pulumi.set(__self__, "header_name", header_name)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleHeaderActionParameters')
         if value is not None:
             pulumi.set(__self__, "value", value)
 
@@ -2782,6 +2814,10 @@ class HeaderActionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleHeaderActionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -2910,12 +2946,14 @@ class HostNameMatchConditionParametersResponse(dict):
         """
         Defines the parameters for HostName match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleHostNameConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleHostNameConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -2936,6 +2974,10 @@ class HostNameMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleHostNameConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -3033,12 +3075,14 @@ class HttpVersionMatchConditionParametersResponse(dict):
         """
         Defines the parameters for HttpVersion match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleHttpVersionConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleHttpVersionConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -3059,6 +3103,10 @@ class HttpVersionMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleHttpVersionConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -3121,12 +3169,14 @@ class IsDeviceMatchConditionParametersResponse(dict):
         """
         Defines the parameters for IsDevice match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleIsDeviceConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleIsDeviceConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -3147,6 +3197,10 @@ class IsDeviceMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleIsDeviceConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -3225,6 +3279,8 @@ class KeyVaultCertificateSourceParametersResponse(dict):
         :param str resource_group_name: Resource group of the user's Key Vault containing the SSL certificate
         :param str secret_name: The name of Key Vault Secret (representing the full certificate PFX) in Key Vault.
         :param str subscription_id: Subscription Id of the user's Key Vault containing the SSL certificate
+        :param str type_name: 
+               Expected value is 'KeyVaultCertificateSourceParameters'.
         :param str update_rule: Describes the action that shall be taken when the certificate is updated in Key Vault.
         :param str vault_name: The name of the user's Key Vault containing the SSL certificate
         :param str secret_version: The version(GUID) of Key Vault Secret in Key Vault.
@@ -3233,7 +3289,7 @@ class KeyVaultCertificateSourceParametersResponse(dict):
         pulumi.set(__self__, "resource_group_name", resource_group_name)
         pulumi.set(__self__, "secret_name", secret_name)
         pulumi.set(__self__, "subscription_id", subscription_id)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'KeyVaultCertificateSourceParameters')
         pulumi.set(__self__, "update_rule", update_rule)
         pulumi.set(__self__, "vault_name", vault_name)
         if secret_version is not None:
@@ -3274,6 +3330,10 @@ class KeyVaultCertificateSourceParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'KeyVaultCertificateSourceParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -3976,9 +4036,11 @@ class OriginGroupOverrideActionParametersResponse(dict):
         """
         Defines the parameters for the origin group override action.
         :param 'ResourceReferenceResponse' origin_group: defines the OriginGroup that would override the DefaultOriginGroup.
+        :param str type_name: 
+               Expected value is 'DeliveryRuleOriginGroupOverrideActionParameters'.
         """
         pulumi.set(__self__, "origin_group", origin_group)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleOriginGroupOverrideActionParameters')
 
     @property
     @pulumi.getter(name="originGroup")
@@ -3991,6 +4053,10 @@ class OriginGroupOverrideActionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleOriginGroupOverrideActionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
 
@@ -4213,13 +4279,15 @@ class PostArgsMatchConditionParametersResponse(dict):
         """
         Defines the parameters for PostArgs match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRulePostArgsConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param str selector: Name of PostArg to be matched
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRulePostArgsConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -4242,6 +4310,10 @@ class PostArgsMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRulePostArgsConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -4440,12 +4512,14 @@ class QueryStringMatchConditionParametersResponse(dict):
         """
         Defines the parameters for QueryString match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleQueryStringConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleQueryStringConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -4466,6 +4540,10 @@ class QueryStringMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleQueryStringConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -4663,12 +4741,14 @@ class RemoteAddressMatchConditionParametersResponse(dict):
         """
         Defines the parameters for RemoteAddress match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleRemoteAddressConditionParameters'.
         :param Sequence[str] match_values: Match values to match against. The operator will apply to each value in here with OR semantics. If any of them match the variable with the given operator this match condition is considered a match.
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleRemoteAddressConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -4689,6 +4769,10 @@ class RemoteAddressMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleRemoteAddressConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -4751,12 +4835,14 @@ class RequestBodyMatchConditionParametersResponse(dict):
         """
         Defines the parameters for RequestBody match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleRequestBodyConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleRequestBodyConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -4777,6 +4863,10 @@ class RequestBodyMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleRequestBodyConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -4840,13 +4930,15 @@ class RequestHeaderMatchConditionParametersResponse(dict):
         """
         Defines the parameters for RequestHeader match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleRequestHeaderConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param str selector: Name of Header to be matched
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleRequestHeaderConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -4869,6 +4961,10 @@ class RequestHeaderMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleRequestHeaderConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -4939,12 +5035,14 @@ class RequestMethodMatchConditionParametersResponse(dict):
         """
         Defines the parameters for RequestMethod match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleRequestMethodConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleRequestMethodConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -4965,6 +5063,10 @@ class RequestMethodMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleRequestMethodConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -5027,12 +5129,14 @@ class RequestSchemeMatchConditionParametersResponse(dict):
         """
         Defines the parameters for RequestScheme match conditions 
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleRequestSchemeConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleRequestSchemeConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -5053,6 +5157,10 @@ class RequestSchemeMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleRequestSchemeConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -5115,12 +5223,14 @@ class RequestUriMatchConditionParametersResponse(dict):
         """
         Defines the parameters for RequestUri match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleRequestUriConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleRequestUriConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -5141,6 +5251,10 @@ class RequestUriMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleRequestUriConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -5291,10 +5405,12 @@ class RouteConfigurationOverrideActionParametersResponse(dict):
                  origin_group_override: Optional['outputs.OriginGroupOverrideResponse'] = None):
         """
         Defines the parameters for the route configuration override action.
+        :param str type_name: 
+               Expected value is 'DeliveryRuleRouteConfigurationOverrideActionParameters'.
         :param 'CacheConfigurationResponse' cache_configuration: The caching configuration associated with this rule. To disable caching, do not provide a cacheConfiguration object.
         :param 'OriginGroupOverrideResponse' origin_group_override: A reference to the origin group override configuration. Leave empty to use the default origin group on route.
         """
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleRouteConfigurationOverrideActionParameters')
         if cache_configuration is not None:
             pulumi.set(__self__, "cache_configuration", cache_configuration)
         if origin_group_override is not None:
@@ -5303,6 +5419,10 @@ class RouteConfigurationOverrideActionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleRouteConfigurationOverrideActionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -5474,12 +5594,14 @@ class ServerPortMatchConditionParametersResponse(dict):
         """
         Defines the parameters for ServerPort match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleServerPortConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleServerPortConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -5500,6 +5622,10 @@ class ServerPortMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleServerPortConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -5704,12 +5830,14 @@ class SocketAddrMatchConditionParametersResponse(dict):
         """
         Defines the parameters for SocketAddress match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleSocketAddrConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleSocketAddrConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -5730,6 +5858,10 @@ class SocketAddrMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleSocketAddrConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -5792,12 +5924,14 @@ class SslProtocolMatchConditionParametersResponse(dict):
         """
         Defines the parameters for SslProtocol match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleSslProtocolConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleSslProtocolConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -5818,6 +5952,10 @@ class SslProtocolMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleSslProtocolConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -5990,12 +6128,14 @@ class UrlFileExtensionMatchConditionParametersResponse(dict):
         """
         Defines the parameters for UrlFileExtension match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleUrlFileExtensionMatchConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleUrlFileExtensionMatchConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -6016,6 +6156,10 @@ class UrlFileExtensionMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleUrlFileExtensionMatchConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -6078,12 +6222,14 @@ class UrlFileNameMatchConditionParametersResponse(dict):
         """
         Defines the parameters for UrlFilename match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleUrlFilenameConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleUrlFilenameConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -6104,6 +6250,10 @@ class UrlFileNameMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleUrlFilenameConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -6166,12 +6316,14 @@ class UrlPathMatchConditionParametersResponse(dict):
         """
         Defines the parameters for UrlPath match conditions
         :param str operator: Describes operator to be matched
+        :param str type_name: 
+               Expected value is 'DeliveryRuleUrlPathMatchConditionParameters'.
         :param Sequence[str] match_values: The match value for the condition of the delivery rule
         :param bool negate_condition: Describes if this is negate condition or not
         :param Sequence[str] transforms: List of transforms
         """
         pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleUrlPathMatchConditionParameters')
         if match_values is not None:
             pulumi.set(__self__, "match_values", match_values)
         if negate_condition is None:
@@ -6192,6 +6344,10 @@ class UrlPathMatchConditionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleUrlPathMatchConditionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -6264,6 +6420,8 @@ class UrlRedirectActionParametersResponse(dict):
         """
         Defines the parameters for the url redirect action.
         :param str redirect_type: The redirect type the rule will use when redirecting traffic.
+        :param str type_name: 
+               Expected value is 'DeliveryRuleUrlRedirectActionParameters'.
         :param str custom_fragment: Fragment to add to the redirect URL. Fragment is the part of the URL that comes after #. Do not include the #.
         :param str custom_hostname: Host to redirect. Leave empty to use the incoming host as the destination host.
         :param str custom_path: The full path to redirect. Path cannot be empty and must start with /. Leave empty to use the incoming path as destination path.
@@ -6271,7 +6429,7 @@ class UrlRedirectActionParametersResponse(dict):
         :param str destination_protocol: Protocol to use for the redirect. The default value is MatchRequest
         """
         pulumi.set(__self__, "redirect_type", redirect_type)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleUrlRedirectActionParameters')
         if custom_fragment is not None:
             pulumi.set(__self__, "custom_fragment", custom_fragment)
         if custom_hostname is not None:
@@ -6294,6 +6452,10 @@ class UrlRedirectActionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleUrlRedirectActionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -6407,11 +6569,13 @@ class UrlRewriteActionParametersResponse(dict):
         Defines the parameters for the url rewrite action.
         :param str destination: Define the relative URL to which the above requests will be rewritten by.
         :param str source_pattern: define a request URI pattern that identifies the type of requests that may be rewritten. If value is blank, all strings are matched.
+        :param str type_name: 
+               Expected value is 'DeliveryRuleUrlRewriteActionParameters'.
         :param bool preserve_unmatched_path: Whether to preserve unmatched path. Default value is true.
         """
         pulumi.set(__self__, "destination", destination)
         pulumi.set(__self__, "source_pattern", source_pattern)
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleUrlRewriteActionParameters')
         if preserve_unmatched_path is not None:
             pulumi.set(__self__, "preserve_unmatched_path", preserve_unmatched_path)
 
@@ -6434,6 +6598,10 @@ class UrlRewriteActionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleUrlRewriteActionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property
@@ -6510,10 +6678,12 @@ class UrlSigningActionParametersResponse(dict):
                  parameter_name_override: Optional[Sequence['outputs.UrlSigningParamIdentifierResponse']] = None):
         """
         Defines the parameters for the Url Signing action.
+        :param str type_name: 
+               Expected value is 'DeliveryRuleUrlSigningActionParameters'.
         :param str algorithm: Algorithm to use for URL signing
         :param Sequence['UrlSigningParamIdentifierResponse'] parameter_name_override: Defines which query string parameters in the url to be considered for expires, key id etc. 
         """
-        pulumi.set(__self__, "type_name", type_name)
+        pulumi.set(__self__, "type_name", 'DeliveryRuleUrlSigningActionParameters')
         if algorithm is not None:
             pulumi.set(__self__, "algorithm", algorithm)
         if parameter_name_override is not None:
@@ -6522,6 +6692,10 @@ class UrlSigningActionParametersResponse(dict):
     @property
     @pulumi.getter(name="typeName")
     def type_name(self) -> str:
+        """
+
+        Expected value is 'DeliveryRuleUrlSigningActionParameters'.
+        """
         return pulumi.get(self, "type_name")
 
     @property