pulumi-azure-native 2.76.0a1733162443__py3-none-any.whl → 2.76.0a1733488793__py3-none-any.whl

pulumi_azure_native/insights/_inputs.py

@@ -110,8 +110,6 @@ __all__ = [
     'IisLogsDataSourceArgsDict',
     'ItsmReceiverArgs',
     'ItsmReceiverArgsDict',
-    'LocationThresholdRuleConditionArgs',
-    'LocationThresholdRuleConditionArgsDict',
     'LogAnalyticsDestinationArgs',
     'LogAnalyticsDestinationArgsDict',
     'LogFileSettingsTextArgs',
@@ -124,10 +122,6 @@ __all__ = [
     'LogSettingsArgsDict',
     'LogicAppReceiverArgs',
     'LogicAppReceiverArgsDict',
-    'ManagementEventAggregationConditionArgs',
-    'ManagementEventAggregationConditionArgsDict',
-    'ManagementEventRuleConditionArgs',
-    'ManagementEventRuleConditionArgsDict',
     'ManagementGroupLogSettingsArgs',
     'ManagementGroupLogSettingsArgsDict',
     'MetricAlertActionArgs',
@@ -166,18 +160,8 @@ __all__ = [
     'RecurrentScheduleArgsDict',
     'RetentionPolicyArgs',
     'RetentionPolicyArgsDict',
-    'RuleEmailActionArgs',
-    'RuleEmailActionArgsDict',
-    'RuleManagementEventClaimsDataSourceArgs',
-    'RuleManagementEventClaimsDataSourceArgsDict',
-    'RuleManagementEventDataSourceArgs',
-    'RuleManagementEventDataSourceArgsDict',
-    'RuleMetricDataSourceArgs',
-    'RuleMetricDataSourceArgsDict',
     'RuleResolveConfigurationArgs',
     'RuleResolveConfigurationArgsDict',
-    'RuleWebhookActionArgs',
-    'RuleWebhookActionArgsDict',
     'ScaleActionArgs',
     'ScaleActionArgsDict',
     'ScaleCapacityArgs',
@@ -202,8 +186,6 @@ __all__ = [
     'SubscriptionLogSettingsArgsDict',
     'SyslogDataSourceArgs',
     'SyslogDataSourceArgsDict',
-    'ThresholdRuleConditionArgs',
-    'ThresholdRuleConditionArgsDict',
     'TimeWindowArgs',
     'TimeWindowArgsDict',
     'VoiceReceiverArgs',
@@ -4228,103 +4210,6 @@ class ItsmReceiverArgs:
         pulumi.set(self, "workspace_id", value)
 
 
-if not MYPY:
-    class LocationThresholdRuleConditionArgsDict(TypedDict):
-        """
-        A rule condition based on a certain number of locations failing.
-        """
-        failed_location_count: pulumi.Input[int]
-        """
-        the number of locations that must fail to activate the alert.
-        """
-        odata_type: pulumi.Input[str]
-        """
-        specifies the type of condition. This can be one of three types: ManagementEventRuleCondition (occurrences of management events), LocationThresholdRuleCondition (based on the number of failures of a web test), and ThresholdRuleCondition (based on the threshold of a metric).
-        Expected value is 'Microsoft.Azure.Management.Insights.Models.LocationThresholdRuleCondition'.
-        """
-        data_source: NotRequired[pulumi.Input[Union['RuleManagementEventDataSourceArgsDict', 'RuleMetricDataSourceArgsDict']]]
-        """
-        the resource from which the rule collects its data. For this type dataSource will always be of type RuleMetricDataSource.
-        """
-        window_size: NotRequired[pulumi.Input[str]]
-        """
-        the period of time (in ISO 8601 duration format) that is used to monitor alert activity based on the threshold. If specified then it must be between 5 minutes and 1 day.
-        """
-elif False:
-    LocationThresholdRuleConditionArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class LocationThresholdRuleConditionArgs:
-    def __init__(__self__, *,
-                 failed_location_count: pulumi.Input[int],
-                 odata_type: pulumi.Input[str],
-                 data_source: Optional[pulumi.Input[Union['RuleManagementEventDataSourceArgs', 'RuleMetricDataSourceArgs']]] = None,
-                 window_size: Optional[pulumi.Input[str]] = None):
-        """
-        A rule condition based on a certain number of locations failing.
-        :param pulumi.Input[int] failed_location_count: the number of locations that must fail to activate the alert.
-        :param pulumi.Input[str] odata_type: specifies the type of condition. This can be one of three types: ManagementEventRuleCondition (occurrences of management events), LocationThresholdRuleCondition (based on the number of failures of a web test), and ThresholdRuleCondition (based on the threshold of a metric).
-               Expected value is 'Microsoft.Azure.Management.Insights.Models.LocationThresholdRuleCondition'.
-        :param pulumi.Input[Union['RuleManagementEventDataSourceArgs', 'RuleMetricDataSourceArgs']] data_source: the resource from which the rule collects its data. For this type dataSource will always be of type RuleMetricDataSource.
-        :param pulumi.Input[str] window_size: the period of time (in ISO 8601 duration format) that is used to monitor alert activity based on the threshold. If specified then it must be between 5 minutes and 1 day.
-        """
-        pulumi.set(__self__, "failed_location_count", failed_location_count)
-        pulumi.set(__self__, "odata_type", 'Microsoft.Azure.Management.Insights.Models.LocationThresholdRuleCondition')
-        if data_source is not None:
-            pulumi.set(__self__, "data_source", data_source)
-        if window_size is not None:
-            pulumi.set(__self__, "window_size", window_size)
-
-    @property
-    @pulumi.getter(name="failedLocationCount")
-    def failed_location_count(self) -> pulumi.Input[int]:
-        """
-        the number of locations that must fail to activate the alert.
-        """
-        return pulumi.get(self, "failed_location_count")
-
-    @failed_location_count.setter
-    def failed_location_count(self, value: pulumi.Input[int]):
-        pulumi.set(self, "failed_location_count", value)
-
-    @property
-    @pulumi.getter(name="odataType")
-    def odata_type(self) -> pulumi.Input[str]:
-        """
-        specifies the type of condition. This can be one of three types: ManagementEventRuleCondition (occurrences of management events), LocationThresholdRuleCondition (based on the number of failures of a web test), and ThresholdRuleCondition (based on the threshold of a metric).
-        Expected value is 'Microsoft.Azure.Management.Insights.Models.LocationThresholdRuleCondition'.
-        """
-        return pulumi.get(self, "odata_type")
-
-    @odata_type.setter
-    def odata_type(self, value: pulumi.Input[str]):
-        pulumi.set(self, "odata_type", value)
-
-    @property
-    @pulumi.getter(name="dataSource")
-    def data_source(self) -> Optional[pulumi.Input[Union['RuleManagementEventDataSourceArgs', 'RuleMetricDataSourceArgs']]]:
-        """
-        the resource from which the rule collects its data. For this type dataSource will always be of type RuleMetricDataSource.
-        """
-        return pulumi.get(self, "data_source")
-
-    @data_source.setter
-    def data_source(self, value: Optional[pulumi.Input[Union['RuleManagementEventDataSourceArgs', 'RuleMetricDataSourceArgs']]]):
-        pulumi.set(self, "data_source", value)
-
-    @property
-    @pulumi.getter(name="windowSize")
-    def window_size(self) -> Optional[pulumi.Input[str]]:
-        """
-        the period of time (in ISO 8601 duration format) that is used to monitor alert activity based on the threshold. If specified then it must be between 5 minutes and 1 day.
-        """
-        return pulumi.get(self, "window_size")
-
-    @window_size.setter
-    def window_size(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "window_size", value)
-
-
 if not MYPY:
     class LogAnalyticsDestinationArgsDict(TypedDict):
         """
@@ -4764,160 +4649,6 @@ class LogicAppReceiverArgs:
         pulumi.set(self, "use_common_alert_schema", value)
 
 
-if not MYPY:
-    class ManagementEventAggregationConditionArgsDict(TypedDict):
-        """
-        How the data that is collected should be combined over time.
-        """
-        operator: NotRequired[pulumi.Input['ConditionOperator']]
-        """
-        the condition operator.
-        """
-        threshold: NotRequired[pulumi.Input[float]]
-        """
-        The threshold value that activates the alert.
-        """
-        window_size: NotRequired[pulumi.Input[str]]
-        """
-        the period of time (in ISO 8601 duration format) that is used to monitor alert activity based on the threshold. If specified then it must be between 5 minutes and 1 day.
-        """
-elif False:
-    ManagementEventAggregationConditionArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ManagementEventAggregationConditionArgs:
-    def __init__(__self__, *,
-                 operator: Optional[pulumi.Input['ConditionOperator']] = None,
-                 threshold: Optional[pulumi.Input[float]] = None,
-                 window_size: Optional[pulumi.Input[str]] = None):
-        """
-        How the data that is collected should be combined over time.
-        :param pulumi.Input['ConditionOperator'] operator: the condition operator.
-        :param pulumi.Input[float] threshold: The threshold value that activates the alert.
-        :param pulumi.Input[str] window_size: the period of time (in ISO 8601 duration format) that is used to monitor alert activity based on the threshold. If specified then it must be between 5 minutes and 1 day.
-        """
-        if operator is not None:
-            pulumi.set(__self__, "operator", operator)
-        if threshold is not None:
-            pulumi.set(__self__, "threshold", threshold)
-        if window_size is not None:
-            pulumi.set(__self__, "window_size", window_size)
-
-    @property
-    @pulumi.getter
-    def operator(self) -> Optional[pulumi.Input['ConditionOperator']]:
-        """
-        the condition operator.
-        """
-        return pulumi.get(self, "operator")
-
-    @operator.setter
-    def operator(self, value: Optional[pulumi.Input['ConditionOperator']]):
-        pulumi.set(self, "operator", value)
-
-    @property
-    @pulumi.getter
-    def threshold(self) -> Optional[pulumi.Input[float]]:
-        """
-        The threshold value that activates the alert.
-        """
-        return pulumi.get(self, "threshold")
-
-    @threshold.setter
-    def threshold(self, value: Optional[pulumi.Input[float]]):
-        pulumi.set(self, "threshold", value)
-
-    @property
-    @pulumi.getter(name="windowSize")
-    def window_size(self) -> Optional[pulumi.Input[str]]:
-        """
-        the period of time (in ISO 8601 duration format) that is used to monitor alert activity based on the threshold. If specified then it must be between 5 minutes and 1 day.
-        """
-        return pulumi.get(self, "window_size")
-
-    @window_size.setter
-    def window_size(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "window_size", value)
-
-
-if not MYPY:
-    class ManagementEventRuleConditionArgsDict(TypedDict):
-        """
-        A management event rule condition.
-        """
-        odata_type: pulumi.Input[str]
-        """
-        specifies the type of condition. This can be one of three types: ManagementEventRuleCondition (occurrences of management events), LocationThresholdRuleCondition (based on the number of failures of a web test), and ThresholdRuleCondition (based on the threshold of a metric).
-        Expected value is 'Microsoft.Azure.Management.Insights.Models.ManagementEventRuleCondition'.
-        """
-        aggregation: NotRequired[pulumi.Input['ManagementEventAggregationConditionArgsDict']]
-        """
-        How the data that is collected should be combined over time and when the alert is activated. Note that for management event alerts aggregation is optional – if it is not provided then any event will cause the alert to activate.
-        """
-        data_source: NotRequired[pulumi.Input[Union['RuleManagementEventDataSourceArgsDict', 'RuleMetricDataSourceArgsDict']]]
-        """
-        the resource from which the rule collects its data. For this type dataSource will always be of type RuleMetricDataSource.
-        """
-elif False:
-    ManagementEventRuleConditionArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ManagementEventRuleConditionArgs:
-    def __init__(__self__, *,
-                 odata_type: pulumi.Input[str],
-                 aggregation: Optional[pulumi.Input['ManagementEventAggregationConditionArgs']] = None,
-                 data_source: Optional[pulumi.Input[Union['RuleManagementEventDataSourceArgs', 'RuleMetricDataSourceArgs']]] = None):
-        """
-        A management event rule condition.
-        :param pulumi.Input[str] odata_type: specifies the type of condition. This can be one of three types: ManagementEventRuleCondition (occurrences of management events), LocationThresholdRuleCondition (based on the number of failures of a web test), and ThresholdRuleCondition (based on the threshold of a metric).
-               Expected value is 'Microsoft.Azure.Management.Insights.Models.ManagementEventRuleCondition'.
-        :param pulumi.Input['ManagementEventAggregationConditionArgs'] aggregation: How the data that is collected should be combined over time and when the alert is activated. Note that for management event alerts aggregation is optional – if it is not provided then any event will cause the alert to activate.
-        :param pulumi.Input[Union['RuleManagementEventDataSourceArgs', 'RuleMetricDataSourceArgs']] data_source: the resource from which the rule collects its data. For this type dataSource will always be of type RuleMetricDataSource.
-        """
-        pulumi.set(__self__, "odata_type", 'Microsoft.Azure.Management.Insights.Models.ManagementEventRuleCondition')
-        if aggregation is not None:
-            pulumi.set(__self__, "aggregation", aggregation)
-        if data_source is not None:
-            pulumi.set(__self__, "data_source", data_source)
-
-    @property
-    @pulumi.getter(name="odataType")
-    def odata_type(self) -> pulumi.Input[str]:
-        """
-        specifies the type of condition. This can be one of three types: ManagementEventRuleCondition (occurrences of management events), LocationThresholdRuleCondition (based on the number of failures of a web test), and ThresholdRuleCondition (based on the threshold of a metric).
-        Expected value is 'Microsoft.Azure.Management.Insights.Models.ManagementEventRuleCondition'.
-        """
-        return pulumi.get(self, "odata_type")
-
-    @odata_type.setter
-    def odata_type(self, value: pulumi.Input[str]):
-        pulumi.set(self, "odata_type", value)
-
-    @property
-    @pulumi.getter
-    def aggregation(self) -> Optional[pulumi.Input['ManagementEventAggregationConditionArgs']]:
-        """
-        How the data that is collected should be combined over time and when the alert is activated. Note that for management event alerts aggregation is optional – if it is not provided then any event will cause the alert to activate.
-        """
-        return pulumi.get(self, "aggregation")
-
-    @aggregation.setter
-    def aggregation(self, value: Optional[pulumi.Input['ManagementEventAggregationConditionArgs']]):
-        pulumi.set(self, "aggregation", value)
-
-    @property
-    @pulumi.getter(name="dataSource")
-    def data_source(self) -> Optional[pulumi.Input[Union['RuleManagementEventDataSourceArgs', 'RuleMetricDataSourceArgs']]]:
-        """
-        the resource from which the rule collects its data. For this type dataSource will always be of type RuleMetricDataSource.
-        """
-        return pulumi.get(self, "data_source")
-
-    @data_source.setter
-    def data_source(self, value: Optional[pulumi.Input[Union['RuleManagementEventDataSourceArgs', 'RuleMetricDataSourceArgs']]]):
-        pulumi.set(self, "data_source", value)
-
-
 if not MYPY:
     class ManagementGroupLogSettingsArgsDict(TypedDict):
         """
@@ -6501,752 +6232,124 @@ class RetentionPolicyArgs:
 
 
 if not MYPY:
-    class RuleEmailActionArgsDict(TypedDict):
-        """
-        Specifies the action to send email when the rule condition is evaluated. The discriminator is always RuleEmailAction in this case.
-        """
-        odata_type: pulumi.Input[str]
+    class RuleResolveConfigurationArgsDict(TypedDict):
         """
-        specifies the type of the action. There are two types of actions: RuleEmailAction and RuleWebhookAction.
-        Expected value is 'Microsoft.Azure.Management.Insights.Models.RuleEmailAction'.
+        TBD. Relevant only for rules of the kind LogAlert.
         """
-        custom_emails: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        auto_resolved: NotRequired[pulumi.Input[bool]]
         """
-        the list of administrator's custom email addresses to notify of the activation of the alert.
+        The flag that indicates whether or not to auto resolve a fired alert.
         """
-        send_to_service_owners: NotRequired[pulumi.Input[bool]]
+        time_to_resolve: NotRequired[pulumi.Input[str]]
         """
-        Whether the administrators (service and co-administrators) of the service should be notified when the alert is activated.
+        The duration a rule must evaluate as healthy before the fired alert is automatically resolved represented in ISO 8601 duration format.
         """
 elif False:
-    RuleEmailActionArgsDict: TypeAlias = Mapping[str, Any]
+    RuleResolveConfigurationArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class RuleEmailActionArgs:
+class RuleResolveConfigurationArgs:
     def __init__(__self__, *,
-                 odata_type: pulumi.Input[str],
-                 custom_emails: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-                 send_to_service_owners: Optional[pulumi.Input[bool]] = None):
-        """
-        Specifies the action to send email when the rule condition is evaluated. The discriminator is always RuleEmailAction in this case.
-        :param pulumi.Input[str] odata_type: specifies the type of the action. There are two types of actions: RuleEmailAction and RuleWebhookAction.
-               Expected value is 'Microsoft.Azure.Management.Insights.Models.RuleEmailAction'.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] custom_emails: the list of administrator's custom email addresses to notify of the activation of the alert.
-        :param pulumi.Input[bool] send_to_service_owners: Whether the administrators (service and co-administrators) of the service should be notified when the alert is activated.
-        """
-        pulumi.set(__self__, "odata_type", 'Microsoft.Azure.Management.Insights.Models.RuleEmailAction')
-        if custom_emails is not None:
-            pulumi.set(__self__, "custom_emails", custom_emails)
-        if send_to_service_owners is not None:
-            pulumi.set(__self__, "send_to_service_owners", send_to_service_owners)
-
-    @property
-    @pulumi.getter(name="odataType")
-    def odata_type(self) -> pulumi.Input[str]:
+                 auto_resolved: Optional[pulumi.Input[bool]] = None,
+                 time_to_resolve: Optional[pulumi.Input[str]] = None):
         """
-        specifies the type of the action. There are two types of actions: RuleEmailAction and RuleWebhookAction.
-        Expected value is 'Microsoft.Azure.Management.Insights.Models.RuleEmailAction'.
+        TBD. Relevant only for rules of the kind LogAlert.
+        :param pulumi.Input[bool] auto_resolved: The flag that indicates whether or not to auto resolve a fired alert.
+        :param pulumi.Input[str] time_to_resolve: The duration a rule must evaluate as healthy before the fired alert is automatically resolved represented in ISO 8601 duration format.
         """
-        return pulumi.get(self, "odata_type")
-
-    @odata_type.setter
-    def odata_type(self, value: pulumi.Input[str]):
-        pulumi.set(self, "odata_type", value)
+        if auto_resolved is not None:
+            pulumi.set(__self__, "auto_resolved", auto_resolved)
+        if time_to_resolve is not None:
+            pulumi.set(__self__, "time_to_resolve", time_to_resolve)
 
     @property
-    @pulumi.getter(name="customEmails")
-    def custom_emails(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+    @pulumi.getter(name="autoResolved")
+    def auto_resolved(self) -> Optional[pulumi.Input[bool]]:
         """
-        the list of administrator's custom email addresses to notify of the activation of the alert.
+        The flag that indicates whether or not to auto resolve a fired alert.
         """
-        return pulumi.get(self, "custom_emails")
+        return pulumi.get(self, "auto_resolved")
 
-    @custom_emails.setter
-    def custom_emails(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
-        pulumi.set(self, "custom_emails", value)
+    @auto_resolved.setter
+    def auto_resolved(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "auto_resolved", value)
 
     @property
-    @pulumi.getter(name="sendToServiceOwners")
-    def send_to_service_owners(self) -> Optional[pulumi.Input[bool]]:
+    @pulumi.getter(name="timeToResolve")
+    def time_to_resolve(self) -> Optional[pulumi.Input[str]]:
         """
-        Whether the administrators (service and co-administrators) of the service should be notified when the alert is activated.
+        The duration a rule must evaluate as healthy before the fired alert is automatically resolved represented in ISO 8601 duration format.
         """
-        return pulumi.get(self, "send_to_service_owners")
+        return pulumi.get(self, "time_to_resolve")
 
-    @send_to_service_owners.setter
-    def send_to_service_owners(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "send_to_service_owners", value)
+    @time_to_resolve.setter
+    def time_to_resolve(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_to_resolve", value)
 
 
 if not MYPY:
-    class RuleManagementEventClaimsDataSourceArgsDict(TypedDict):
+    class ScaleActionArgsDict(TypedDict):
+        """
+        The parameters for the scaling action.
+        """
+        cooldown: pulumi.Input[str]
+        """
+        the amount of time to wait since the last scaling action before this action occurs. It must be between 1 week and 1 minute in ISO 8601 format.
+        """
+        direction: pulumi.Input['ScaleDirection']
+        """
+        the scale direction. Whether the scaling action increases or decreases the number of instances.
         """
-        The claims for a rule management event data source.
+        type: pulumi.Input['ScaleType']
+        """
+        the type of action that should occur when the scale rule fires.
         """
-        email_address: NotRequired[pulumi.Input[str]]
+        value: NotRequired[pulumi.Input[str]]
         """
-        the email address.
+        the number of instances that are involved in the scaling action. This value must be 1 or greater. The default value is 1.
         """
 elif False:
-    RuleManagementEventClaimsDataSourceArgsDict: TypeAlias = Mapping[str, Any]
+    ScaleActionArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class RuleManagementEventClaimsDataSourceArgs:
+class ScaleActionArgs:
     def __init__(__self__, *,
-                 email_address: Optional[pulumi.Input[str]] = None):
+                 cooldown: pulumi.Input[str],
+                 direction: pulumi.Input['ScaleDirection'],
+                 type: pulumi.Input['ScaleType'],
+                 value: Optional[pulumi.Input[str]] = None):
         """
-        The claims for a rule management event data source.
-        :param pulumi.Input[str] email_address: the email address.
+        The parameters for the scaling action.
+        :param pulumi.Input[str] cooldown: the amount of time to wait since the last scaling action before this action occurs. It must be between 1 week and 1 minute in ISO 8601 format.
+        :param pulumi.Input['ScaleDirection'] direction: the scale direction. Whether the scaling action increases or decreases the number of instances.
+        :param pulumi.Input['ScaleType'] type: the type of action that should occur when the scale rule fires.
+        :param pulumi.Input[str] value: the number of instances that are involved in the scaling action. This value must be 1 or greater. The default value is 1.
         """
-        if email_address is not None:
-            pulumi.set(__self__, "email_address", email_address)
+        pulumi.set(__self__, "cooldown", cooldown)
+        pulumi.set(__self__, "direction", direction)
+        pulumi.set(__self__, "type", type)
+        if value is None:
+            value = '1'
+        if value is not None:
+            pulumi.set(__self__, "value", value)
 
     @property
-    @pulumi.getter(name="emailAddress")
-    def email_address(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter
+    def cooldown(self) -> pulumi.Input[str]:
         """
-        the email address.
+        the amount of time to wait since the last scaling action before this action occurs. It must be between 1 week and 1 minute in ISO 8601 format.
         """
-        return pulumi.get(self, "email_address")
-
-    @email_address.setter
-    def email_address(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "email_address", value)
+        return pulumi.get(self, "cooldown")
 
+    @cooldown.setter
+    def cooldown(self, value: pulumi.Input[str]):
+        pulumi.set(self, "cooldown", value)
 
-if not MYPY:
-    class RuleManagementEventDataSourceArgsDict(TypedDict):
-        """
-        A rule management event data source. The discriminator fields is always RuleManagementEventDataSource in this case.
-        """
-        odata_type: pulumi.Input[str]
-        """
-        specifies the type of data source. There are two types of rule data sources: RuleMetricDataSource and RuleManagementEventDataSource
-        Expected value is 'Microsoft.Azure.Management.Insights.Models.RuleManagementEventDataSource'.
-        """
-        claims: NotRequired[pulumi.Input['RuleManagementEventClaimsDataSourceArgsDict']]
-        """
-        the claims.
-        """
-        event_name: NotRequired[pulumi.Input[str]]
-        """
-        the event name.
+    @property
+    @pulumi.getter
+    def direction(self) -> pulumi.Input['ScaleDirection']:
         """
-        event_source: NotRequired[pulumi.Input[str]]
-        """
-        the event source.
-        """
-        legacy_resource_id: NotRequired[pulumi.Input[str]]
-        """
-        the legacy resource identifier of the resource the rule monitors. **NOTE**: this property cannot be updated for an existing rule.
-        """
-        level: NotRequired[pulumi.Input[str]]
-        """
-        the level.
-        """
-        metric_namespace: NotRequired[pulumi.Input[str]]
-        """
-        the namespace of the metric.
-        """
-        operation_name: NotRequired[pulumi.Input[str]]
-        """
-        The name of the operation that should be checked for. If no name is provided, any operation will match.
-        """
-        resource_group_name: NotRequired[pulumi.Input[str]]
-        """
-        the resource group name.
-        """
-        resource_location: NotRequired[pulumi.Input[str]]
-        """
-        the location of the resource.
-        """
-        resource_provider_name: NotRequired[pulumi.Input[str]]
-        """
-        the resource provider name.
-        """
-        resource_uri: NotRequired[pulumi.Input[str]]
-        """
-        the resource identifier of the resource the rule monitors. **NOTE**: this property cannot be updated for an existing rule.
-        """
-        status: NotRequired[pulumi.Input[str]]
-        """
-        The status of the operation that should be checked for. If no status is provided, any status will match.
-        """
-        sub_status: NotRequired[pulumi.Input[str]]
-        """
-        the substatus.
-        """
-elif False:
-    RuleManagementEventDataSourceArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class RuleManagementEventDataSourceArgs:
-    def __init__(__self__, *,
-                 odata_type: pulumi.Input[str],
-                 claims: Optional[pulumi.Input['RuleManagementEventClaimsDataSourceArgs']] = None,
-                 event_name: Optional[pulumi.Input[str]] = None,
-                 event_source: Optional[pulumi.Input[str]] = None,
-                 legacy_resource_id: Optional[pulumi.Input[str]] = None,
-                 level: Optional[pulumi.Input[str]] = None,
-                 metric_namespace: Optional[pulumi.Input[str]] = None,
-                 operation_name: Optional[pulumi.Input[str]] = None,
-                 resource_group_name: Optional[pulumi.Input[str]] = None,
-                 resource_location: Optional[pulumi.Input[str]] = None,
-                 resource_provider_name: Optional[pulumi.Input[str]] = None,
-                 resource_uri: Optional[pulumi.Input[str]] = None,
-                 status: Optional[pulumi.Input[str]] = None,
-                 sub_status: Optional[pulumi.Input[str]] = None):
-        """
-        A rule management event data source. The discriminator fields is always RuleManagementEventDataSource in this case.
-        :param pulumi.Input[str] odata_type: specifies the type of data source. There are two types of rule data sources: RuleMetricDataSource and RuleManagementEventDataSource
-               Expected value is 'Microsoft.Azure.Management.Insights.Models.RuleManagementEventDataSource'.
-        :param pulumi.Input['RuleManagementEventClaimsDataSourceArgs'] claims: the claims.
-        :param pulumi.Input[str] event_name: the event name.
-        :param pulumi.Input[str] event_source: the event source.
-        :param pulumi.Input[str] legacy_resource_id: the legacy resource identifier of the resource the rule monitors. **NOTE**: this property cannot be updated for an existing rule.
-        :param pulumi.Input[str] level: the level.
-        :param pulumi.Input[str] metric_namespace: the namespace of the metric.
-        :param pulumi.Input[str] operation_name: The name of the operation that should be checked for. If no name is provided, any operation will match.
-        :param pulumi.Input[str] resource_group_name: the resource group name.
-        :param pulumi.Input[str] resource_location: the location of the resource.
-        :param pulumi.Input[str] resource_provider_name: the resource provider name.
-        :param pulumi.Input[str] resource_uri: the resource identifier of the resource the rule monitors. **NOTE**: this property cannot be updated for an existing rule.
-        :param pulumi.Input[str] status: The status of the operation that should be checked for. If no status is provided, any status will match.
-        :param pulumi.Input[str] sub_status: the substatus.
-        """
-        pulumi.set(__self__, "odata_type", 'Microsoft.Azure.Management.Insights.Models.RuleManagementEventDataSource')
-        if claims is not None:
-            pulumi.set(__self__, "claims", claims)
-        if event_name is not None:
-            pulumi.set(__self__, "event_name", event_name)
-        if event_source is not None:
-            pulumi.set(__self__, "event_source", event_source)
-        if legacy_resource_id is not None:
-            pulumi.set(__self__, "legacy_resource_id", legacy_resource_id)
-        if level is not None:
-            pulumi.set(__self__, "level", level)
-        if metric_namespace is not None:
-            pulumi.set(__self__, "metric_namespace", metric_namespace)
-        if operation_name is not None:
-            pulumi.set(__self__, "operation_name", operation_name)
-        if resource_group_name is not None:
-            pulumi.set(__self__, "resource_group_name", resource_group_name)
-        if resource_location is not None:
-            pulumi.set(__self__, "resource_location", resource_location)
-        if resource_provider_name is not None:
-            pulumi.set(__self__, "resource_provider_name", resource_provider_name)
-        if resource_uri is not None:
-            pulumi.set(__self__, "resource_uri", resource_uri)
-        if status is not None:
-            pulumi.set(__self__, "status", status)
-        if sub_status is not None:
-            pulumi.set(__self__, "sub_status", sub_status)
-
-    @property
-    @pulumi.getter(name="odataType")
-    def odata_type(self) -> pulumi.Input[str]:
-        """
-        specifies the type of data source. There are two types of rule data sources: RuleMetricDataSource and RuleManagementEventDataSource
-        Expected value is 'Microsoft.Azure.Management.Insights.Models.RuleManagementEventDataSource'.
-        """
-        return pulumi.get(self, "odata_type")
-
-    @odata_type.setter
-    def odata_type(self, value: pulumi.Input[str]):
-        pulumi.set(self, "odata_type", value)
-
-    @property
-    @pulumi.getter
-    def claims(self) -> Optional[pulumi.Input['RuleManagementEventClaimsDataSourceArgs']]:
-        """
-        the claims.
-        """
-        return pulumi.get(self, "claims")
-
-    @claims.setter
-    def claims(self, value: Optional[pulumi.Input['RuleManagementEventClaimsDataSourceArgs']]):
-        pulumi.set(self, "claims", value)
-
-    @property
-    @pulumi.getter(name="eventName")
-    def event_name(self) -> Optional[pulumi.Input[str]]:
-        """
-        the event name.
-        """
-        return pulumi.get(self, "event_name")
-
-    @event_name.setter
-    def event_name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "event_name", value)
-
-    @property
-    @pulumi.getter(name="eventSource")
-    def event_source(self) -> Optional[pulumi.Input[str]]:
-        """
-        the event source.
-        """
-        return pulumi.get(self, "event_source")
-
-    @event_source.setter
-    def event_source(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "event_source", value)
-
-    @property
-    @pulumi.getter(name="legacyResourceId")
-    def legacy_resource_id(self) -> Optional[pulumi.Input[str]]:
-        """
-        the legacy resource identifier of the resource the rule monitors. **NOTE**: this property cannot be updated for an existing rule.
-        """
-        return pulumi.get(self, "legacy_resource_id")
-
-    @legacy_resource_id.setter
-    def legacy_resource_id(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "legacy_resource_id", value)
-
-    @property
-    @pulumi.getter
-    def level(self) -> Optional[pulumi.Input[str]]:
-        """
-        the level.
-        """
-        return pulumi.get(self, "level")
-
-    @level.setter
-    def level(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "level", value)
-
-    @property
-    @pulumi.getter(name="metricNamespace")
-    def metric_namespace(self) -> Optional[pulumi.Input[str]]:
-        """
-        the namespace of the metric.
-        """
-        return pulumi.get(self, "metric_namespace")
-
-    @metric_namespace.setter
-    def metric_namespace(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "metric_namespace", value)
-
-    @property
-    @pulumi.getter(name="operationName")
-    def operation_name(self) -> Optional[pulumi.Input[str]]:
-        """
-        The name of the operation that should be checked for. If no name is provided, any operation will match.
-        """
-        return pulumi.get(self, "operation_name")
-
-    @operation_name.setter
-    def operation_name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "operation_name", value)
-
-    @property
-    @pulumi.getter(name="resourceGroupName")
-    def resource_group_name(self) -> Optional[pulumi.Input[str]]:
-        """
-        the resource group name.
-        """
-        return pulumi.get(self, "resource_group_name")
-
-    @resource_group_name.setter
-    def resource_group_name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "resource_group_name", value)
-
-    @property
-    @pulumi.getter(name="resourceLocation")
-    def resource_location(self) -> Optional[pulumi.Input[str]]:
-        """
-        the location of the resource.
-        """
-        return pulumi.get(self, "resource_location")
-
-    @resource_location.setter
-    def resource_location(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "resource_location", value)
-
-    @property
-    @pulumi.getter(name="resourceProviderName")
-    def resource_provider_name(self) -> Optional[pulumi.Input[str]]:
-        """
-        the resource provider name.
-        """
-        return pulumi.get(self, "resource_provider_name")
-
-    @resource_provider_name.setter
-    def resource_provider_name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "resource_provider_name", value)
-
-    @property
-    @pulumi.getter(name="resourceUri")
-    def resource_uri(self) -> Optional[pulumi.Input[str]]:
-        """
-        the resource identifier of the resource the rule monitors. **NOTE**: this property cannot be updated for an existing rule.
-        """
-        return pulumi.get(self, "resource_uri")
-
-    @resource_uri.setter
-    def resource_uri(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "resource_uri", value)
-
-    @property
-    @pulumi.getter
-    def status(self) -> Optional[pulumi.Input[str]]:
-        """
-        The status of the operation that should be checked for. If no status is provided, any status will match.
-        """
-        return pulumi.get(self, "status")
-
-    @status.setter
-    def status(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "status", value)
-
-    @property
-    @pulumi.getter(name="subStatus")
-    def sub_status(self) -> Optional[pulumi.Input[str]]:
-        """
-        the substatus.
-        """
-        return pulumi.get(self, "sub_status")
-
-    @sub_status.setter
-    def sub_status(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "sub_status", value)
-
-
-if not MYPY:
-    class RuleMetricDataSourceArgsDict(TypedDict):
-        """
-        A rule metric data source. The discriminator value is always RuleMetricDataSource in this case.
-        """
-        odata_type: pulumi.Input[str]
-        """
-        specifies the type of data source. There are two types of rule data sources: RuleMetricDataSource and RuleManagementEventDataSource
-        Expected value is 'Microsoft.Azure.Management.Insights.Models.RuleMetricDataSource'.
-        """
-        legacy_resource_id: NotRequired[pulumi.Input[str]]
-        """
-        the legacy resource identifier of the resource the rule monitors. **NOTE**: this property cannot be updated for an existing rule.
-        """
-        metric_name: NotRequired[pulumi.Input[str]]
-        """
-        the name of the metric that defines what the rule monitors.
-        """
-        metric_namespace: NotRequired[pulumi.Input[str]]
-        """
-        the namespace of the metric.
-        """
-        resource_location: NotRequired[pulumi.Input[str]]
-        """
-        the location of the resource.
-        """
-        resource_uri: NotRequired[pulumi.Input[str]]
-        """
-        the resource identifier of the resource the rule monitors. **NOTE**: this property cannot be updated for an existing rule.
-        """
-elif False:
-    RuleMetricDataSourceArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class RuleMetricDataSourceArgs:
-    def __init__(__self__, *,
-                 odata_type: pulumi.Input[str],
-                 legacy_resource_id: Optional[pulumi.Input[str]] = None,
-                 metric_name: Optional[pulumi.Input[str]] = None,
-                 metric_namespace: Optional[pulumi.Input[str]] = None,
-                 resource_location: Optional[pulumi.Input[str]] = None,
-                 resource_uri: Optional[pulumi.Input[str]] = None):
-        """
-        A rule metric data source. The discriminator value is always RuleMetricDataSource in this case.
-        :param pulumi.Input[str] odata_type: specifies the type of data source. There are two types of rule data sources: RuleMetricDataSource and RuleManagementEventDataSource
-               Expected value is 'Microsoft.Azure.Management.Insights.Models.RuleMetricDataSource'.
-        :param pulumi.Input[str] legacy_resource_id: the legacy resource identifier of the resource the rule monitors. **NOTE**: this property cannot be updated for an existing rule.
-        :param pulumi.Input[str] metric_name: the name of the metric that defines what the rule monitors.
-        :param pulumi.Input[str] metric_namespace: the namespace of the metric.
-        :param pulumi.Input[str] resource_location: the location of the resource.
-        :param pulumi.Input[str] resource_uri: the resource identifier of the resource the rule monitors. **NOTE**: this property cannot be updated for an existing rule.
-        """
-        pulumi.set(__self__, "odata_type", 'Microsoft.Azure.Management.Insights.Models.RuleMetricDataSource')
-        if legacy_resource_id is not None:
-            pulumi.set(__self__, "legacy_resource_id", legacy_resource_id)
-        if metric_name is not None:
-            pulumi.set(__self__, "metric_name", metric_name)
-        if metric_namespace is not None:
-            pulumi.set(__self__, "metric_namespace", metric_namespace)
-        if resource_location is not None:
-            pulumi.set(__self__, "resource_location", resource_location)
-        if resource_uri is not None:
-            pulumi.set(__self__, "resource_uri", resource_uri)
-
-    @property
-    @pulumi.getter(name="odataType")
-    def odata_type(self) -> pulumi.Input[str]:
-        """
-        specifies the type of data source. There are two types of rule data sources: RuleMetricDataSource and RuleManagementEventDataSource
-        Expected value is 'Microsoft.Azure.Management.Insights.Models.RuleMetricDataSource'.
-        """
-        return pulumi.get(self, "odata_type")
-
-    @odata_type.setter
-    def odata_type(self, value: pulumi.Input[str]):
-        pulumi.set(self, "odata_type", value)
-
-    @property
-    @pulumi.getter(name="legacyResourceId")
-    def legacy_resource_id(self) -> Optional[pulumi.Input[str]]:
-        """
-        the legacy resource identifier of the resource the rule monitors. **NOTE**: this property cannot be updated for an existing rule.
-        """
-        return pulumi.get(self, "legacy_resource_id")
-
-    @legacy_resource_id.setter
-    def legacy_resource_id(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "legacy_resource_id", value)
-
-    @property
-    @pulumi.getter(name="metricName")
-    def metric_name(self) -> Optional[pulumi.Input[str]]:
-        """
-        the name of the metric that defines what the rule monitors.
-        """
-        return pulumi.get(self, "metric_name")
-
-    @metric_name.setter
-    def metric_name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "metric_name", value)
-
-    @property
-    @pulumi.getter(name="metricNamespace")
-    def metric_namespace(self) -> Optional[pulumi.Input[str]]:
-        """
-        the namespace of the metric.
-        """
-        return pulumi.get(self, "metric_namespace")
-
-    @metric_namespace.setter
-    def metric_namespace(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "metric_namespace", value)
-
-    @property
-    @pulumi.getter(name="resourceLocation")
-    def resource_location(self) -> Optional[pulumi.Input[str]]:
-        """
-        the location of the resource.
-        """
-        return pulumi.get(self, "resource_location")
-
-    @resource_location.setter
-    def resource_location(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "resource_location", value)
-
-    @property
-    @pulumi.getter(name="resourceUri")
-    def resource_uri(self) -> Optional[pulumi.Input[str]]:
-        """
-        the resource identifier of the resource the rule monitors. **NOTE**: this property cannot be updated for an existing rule.
-        """
-        return pulumi.get(self, "resource_uri")
-
-    @resource_uri.setter
-    def resource_uri(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "resource_uri", value)
-
-
-if not MYPY:
-    class RuleResolveConfigurationArgsDict(TypedDict):
-        """
-        TBD. Relevant only for rules of the kind LogAlert.
-        """
-        auto_resolved: NotRequired[pulumi.Input[bool]]
-        """
-        The flag that indicates whether or not to auto resolve a fired alert.
-        """
-        time_to_resolve: NotRequired[pulumi.Input[str]]
-        """
-        The duration a rule must evaluate as healthy before the fired alert is automatically resolved represented in ISO 8601 duration format.
-        """
-elif False:
-    RuleResolveConfigurationArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class RuleResolveConfigurationArgs:
-    def __init__(__self__, *,
-                 auto_resolved: Optional[pulumi.Input[bool]] = None,
-                 time_to_resolve: Optional[pulumi.Input[str]] = None):
-        """
-        TBD. Relevant only for rules of the kind LogAlert.
-        :param pulumi.Input[bool] auto_resolved: The flag that indicates whether or not to auto resolve a fired alert.
-        :param pulumi.Input[str] time_to_resolve: The duration a rule must evaluate as healthy before the fired alert is automatically resolved represented in ISO 8601 duration format.
-        """
-        if auto_resolved is not None:
-            pulumi.set(__self__, "auto_resolved", auto_resolved)
-        if time_to_resolve is not None:
-            pulumi.set(__self__, "time_to_resolve", time_to_resolve)
-
-    @property
-    @pulumi.getter(name="autoResolved")
-    def auto_resolved(self) -> Optional[pulumi.Input[bool]]:
-        """
-        The flag that indicates whether or not to auto resolve a fired alert.
-        """
-        return pulumi.get(self, "auto_resolved")
-
-    @auto_resolved.setter
-    def auto_resolved(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "auto_resolved", value)
-
-    @property
-    @pulumi.getter(name="timeToResolve")
-    def time_to_resolve(self) -> Optional[pulumi.Input[str]]:
-        """
-        The duration a rule must evaluate as healthy before the fired alert is automatically resolved represented in ISO 8601 duration format.
-        """
-        return pulumi.get(self, "time_to_resolve")
-
-    @time_to_resolve.setter
-    def time_to_resolve(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "time_to_resolve", value)
-
-
-if not MYPY:
-    class RuleWebhookActionArgsDict(TypedDict):
-        """
-        Specifies the action to post to service when the rule condition is evaluated. The discriminator is always RuleWebhookAction in this case.
-        """
-        odata_type: pulumi.Input[str]
-        """
-        specifies the type of the action. There are two types of actions: RuleEmailAction and RuleWebhookAction.
-        Expected value is 'Microsoft.Azure.Management.Insights.Models.RuleWebhookAction'.
-        """
-        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        the dictionary of custom properties to include with the post operation. These data are appended to the webhook payload.
-        """
-        service_uri: NotRequired[pulumi.Input[str]]
-        """
-        the service uri to Post the notification when the alert activates or resolves.
-        """
-elif False:
-    RuleWebhookActionArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class RuleWebhookActionArgs:
-    def __init__(__self__, *,
-                 odata_type: pulumi.Input[str],
-                 properties: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
-                 service_uri: Optional[pulumi.Input[str]] = None):
-        """
-        Specifies the action to post to service when the rule condition is evaluated. The discriminator is always RuleWebhookAction in this case.
-        :param pulumi.Input[str] odata_type: specifies the type of the action. There are two types of actions: RuleEmailAction and RuleWebhookAction.
-               Expected value is 'Microsoft.Azure.Management.Insights.Models.RuleWebhookAction'.
-        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] properties: the dictionary of custom properties to include with the post operation. These data are appended to the webhook payload.
-        :param pulumi.Input[str] service_uri: the service uri to Post the notification when the alert activates or resolves.
-        """
-        pulumi.set(__self__, "odata_type", 'Microsoft.Azure.Management.Insights.Models.RuleWebhookAction')
-        if properties is not None:
-            pulumi.set(__self__, "properties", properties)
-        if service_uri is not None:
-            pulumi.set(__self__, "service_uri", service_uri)
-
-    @property
-    @pulumi.getter(name="odataType")
-    def odata_type(self) -> pulumi.Input[str]:
-        """
-        specifies the type of the action. There are two types of actions: RuleEmailAction and RuleWebhookAction.
-        Expected value is 'Microsoft.Azure.Management.Insights.Models.RuleWebhookAction'.
-        """
-        return pulumi.get(self, "odata_type")
-
-    @odata_type.setter
-    def odata_type(self, value: pulumi.Input[str]):
-        pulumi.set(self, "odata_type", value)
-
-    @property
-    @pulumi.getter
-    def properties(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
-        """
-        the dictionary of custom properties to include with the post operation. These data are appended to the webhook payload.
-        """
-        return pulumi.get(self, "properties")
-
-    @properties.setter
-    def properties(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
-        pulumi.set(self, "properties", value)
-
-    @property
-    @pulumi.getter(name="serviceUri")
-    def service_uri(self) -> Optional[pulumi.Input[str]]:
-        """
-        the service uri to Post the notification when the alert activates or resolves.
-        """
-        return pulumi.get(self, "service_uri")
-
-    @service_uri.setter
-    def service_uri(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "service_uri", value)
-
-
-if not MYPY:
-    class ScaleActionArgsDict(TypedDict):
-        """
-        The parameters for the scaling action.
-        """
-        cooldown: pulumi.Input[str]
-        """
-        the amount of time to wait since the last scaling action before this action occurs. It must be between 1 week and 1 minute in ISO 8601 format.
-        """
-        direction: pulumi.Input['ScaleDirection']
-        """
-        the scale direction. Whether the scaling action increases or decreases the number of instances.
-        """
-        type: pulumi.Input['ScaleType']
-        """
-        the type of action that should occur when the scale rule fires.
-        """
-        value: NotRequired[pulumi.Input[str]]
-        """
-        the number of instances that are involved in the scaling action. This value must be 1 or greater. The default value is 1.
-        """
-elif False:
-    ScaleActionArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ScaleActionArgs:
-    def __init__(__self__, *,
-                 cooldown: pulumi.Input[str],
-                 direction: pulumi.Input['ScaleDirection'],
-                 type: pulumi.Input['ScaleType'],
-                 value: Optional[pulumi.Input[str]] = None):
-        """
-        The parameters for the scaling action.
-        :param pulumi.Input[str] cooldown: the amount of time to wait since the last scaling action before this action occurs. It must be between 1 week and 1 minute in ISO 8601 format.
-        :param pulumi.Input['ScaleDirection'] direction: the scale direction. Whether the scaling action increases or decreases the number of instances.
-        :param pulumi.Input['ScaleType'] type: the type of action that should occur when the scale rule fires.
-        :param pulumi.Input[str] value: the number of instances that are involved in the scaling action. This value must be 1 or greater. The default value is 1.
-        """
-        pulumi.set(__self__, "cooldown", cooldown)
-        pulumi.set(__self__, "direction", direction)
-        pulumi.set(__self__, "type", type)
-        if value is None:
-            value = '1'
-        if value is not None:
-            pulumi.set(__self__, "value", value)
-
-    @property
-    @pulumi.getter
-    def cooldown(self) -> pulumi.Input[str]:
-        """
-        the amount of time to wait since the last scaling action before this action occurs. It must be between 1 week and 1 minute in ISO 8601 format.
-        """
-        return pulumi.get(self, "cooldown")
-
-    @cooldown.setter
-    def cooldown(self, value: pulumi.Input[str]):
-        pulumi.set(self, "cooldown", value)
-
-    @property
-    @pulumi.getter
-    def direction(self) -> pulumi.Input['ScaleDirection']:
-        """
-        the scale direction. Whether the scaling action increases or decreases the number of instances.
+        the scale direction. Whether the scaling action increases or decreases the number of instances.
         """
         return pulumi.get(self, "direction")
 
@@ -7975,142 +7078,6 @@ class SyslogDataSourceArgs:
         pulumi.set(self, "streams", value)
 
 
-if not MYPY:
-    class ThresholdRuleConditionArgsDict(TypedDict):
-        """
-        A rule condition based on a metric crossing a threshold.
-        """
-        odata_type: pulumi.Input[str]
-        """
-        specifies the type of condition. This can be one of three types: ManagementEventRuleCondition (occurrences of management events), LocationThresholdRuleCondition (based on the number of failures of a web test), and ThresholdRuleCondition (based on the threshold of a metric).
-        Expected value is 'Microsoft.Azure.Management.Insights.Models.ThresholdRuleCondition'.
-        """
-        operator: pulumi.Input['ConditionOperator']
-        """
-        the operator used to compare the data and the threshold.
-        """
-        threshold: pulumi.Input[float]
-        """
-        the threshold value that activates the alert.
-        """
-        data_source: NotRequired[pulumi.Input[Union['RuleManagementEventDataSourceArgsDict', 'RuleMetricDataSourceArgsDict']]]
-        """
-        the resource from which the rule collects its data. For this type dataSource will always be of type RuleMetricDataSource.
-        """
-        time_aggregation: NotRequired[pulumi.Input['TimeAggregationOperator']]
-        """
-        the time aggregation operator. How the data that are collected should be combined over time. The default value is the PrimaryAggregationType of the Metric.
-        """
-        window_size: NotRequired[pulumi.Input[str]]
-        """
-        the period of time (in ISO 8601 duration format) that is used to monitor alert activity based on the threshold. If specified then it must be between 5 minutes and 1 day.
-        """
-elif False:
-    ThresholdRuleConditionArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ThresholdRuleConditionArgs:
-    def __init__(__self__, *,
-                 odata_type: pulumi.Input[str],
-                 operator: pulumi.Input['ConditionOperator'],
-                 threshold: pulumi.Input[float],
-                 data_source: Optional[pulumi.Input[Union['RuleManagementEventDataSourceArgs', 'RuleMetricDataSourceArgs']]] = None,
-                 time_aggregation: Optional[pulumi.Input['TimeAggregationOperator']] = None,
-                 window_size: Optional[pulumi.Input[str]] = None):
-        """
-        A rule condition based on a metric crossing a threshold.
-        :param pulumi.Input[str] odata_type: specifies the type of condition. This can be one of three types: ManagementEventRuleCondition (occurrences of management events), LocationThresholdRuleCondition (based on the number of failures of a web test), and ThresholdRuleCondition (based on the threshold of a metric).
-               Expected value is 'Microsoft.Azure.Management.Insights.Models.ThresholdRuleCondition'.
-        :param pulumi.Input['ConditionOperator'] operator: the operator used to compare the data and the threshold.
-        :param pulumi.Input[float] threshold: the threshold value that activates the alert.
-        :param pulumi.Input[Union['RuleManagementEventDataSourceArgs', 'RuleMetricDataSourceArgs']] data_source: the resource from which the rule collects its data. For this type dataSource will always be of type RuleMetricDataSource.
-        :param pulumi.Input['TimeAggregationOperator'] time_aggregation: the time aggregation operator. How the data that are collected should be combined over time. The default value is the PrimaryAggregationType of the Metric.
-        :param pulumi.Input[str] window_size: the period of time (in ISO 8601 duration format) that is used to monitor alert activity based on the threshold. If specified then it must be between 5 minutes and 1 day.
-        """
-        pulumi.set(__self__, "odata_type", 'Microsoft.Azure.Management.Insights.Models.ThresholdRuleCondition')
-        pulumi.set(__self__, "operator", operator)
-        pulumi.set(__self__, "threshold", threshold)
-        if data_source is not None:
-            pulumi.set(__self__, "data_source", data_source)
-        if time_aggregation is not None:
-            pulumi.set(__self__, "time_aggregation", time_aggregation)
-        if window_size is not None:
-            pulumi.set(__self__, "window_size", window_size)
-
-    @property
-    @pulumi.getter(name="odataType")
-    def odata_type(self) -> pulumi.Input[str]:
-        """
-        specifies the type of condition. This can be one of three types: ManagementEventRuleCondition (occurrences of management events), LocationThresholdRuleCondition (based on the number of failures of a web test), and ThresholdRuleCondition (based on the threshold of a metric).
-        Expected value is 'Microsoft.Azure.Management.Insights.Models.ThresholdRuleCondition'.
-        """
-        return pulumi.get(self, "odata_type")
-
-    @odata_type.setter
-    def odata_type(self, value: pulumi.Input[str]):
-        pulumi.set(self, "odata_type", value)
-
-    @property
-    @pulumi.getter
-    def operator(self) -> pulumi.Input['ConditionOperator']:
-        """
-        the operator used to compare the data and the threshold.
-        """
-        return pulumi.get(self, "operator")
-
-    @operator.setter
-    def operator(self, value: pulumi.Input['ConditionOperator']):
-        pulumi.set(self, "operator", value)
-
-    @property
-    @pulumi.getter
-    def threshold(self) -> pulumi.Input[float]:
-        """
-        the threshold value that activates the alert.
-        """
-        return pulumi.get(self, "threshold")
-
-    @threshold.setter
-    def threshold(self, value: pulumi.Input[float]):
-        pulumi.set(self, "threshold", value)
-
-    @property
-    @pulumi.getter(name="dataSource")
-    def data_source(self) -> Optional[pulumi.Input[Union['RuleManagementEventDataSourceArgs', 'RuleMetricDataSourceArgs']]]:
-        """
-        the resource from which the rule collects its data. For this type dataSource will always be of type RuleMetricDataSource.
-        """
-        return pulumi.get(self, "data_source")
-
-    @data_source.setter
-    def data_source(self, value: Optional[pulumi.Input[Union['RuleManagementEventDataSourceArgs', 'RuleMetricDataSourceArgs']]]):
-        pulumi.set(self, "data_source", value)
-
-    @property
-    @pulumi.getter(name="timeAggregation")
-    def time_aggregation(self) -> Optional[pulumi.Input['TimeAggregationOperator']]:
-        """
-        the time aggregation operator. How the data that are collected should be combined over time. The default value is the PrimaryAggregationType of the Metric.
-        """
-        return pulumi.get(self, "time_aggregation")
-
-    @time_aggregation.setter
-    def time_aggregation(self, value: Optional[pulumi.Input['TimeAggregationOperator']]):
-        pulumi.set(self, "time_aggregation", value)
-
-    @property
-    @pulumi.getter(name="windowSize")
-    def window_size(self) -> Optional[pulumi.Input[str]]:
-        """
-        the period of time (in ISO 8601 duration format) that is used to monitor alert activity based on the threshold. If specified then it must be between 5 minutes and 1 day.
-        """
-        return pulumi.get(self, "window_size")
-
-    @window_size.setter
-    def window_size(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "window_size", value)
-
-
 if not MYPY:
     class TimeWindowArgsDict(TypedDict):
         """