pulumi-azure-native 3.1.0a1744041749__py3-none-any.whl → 3.1.0a1744104520__py3-none-any.whl

pulumi_azure_native/monitor/outputs.py

@@ -19,7 +19,12 @@ from ._enums import *
 __all__ = [
     'AccessModeSettingsExclusionResponse',
     'AccessModeSettingsResponse',
+    'ActionGroupResponse',
+    'ActionListResponse',
     'ActionsResponse',
+    'AlertRuleAllOfConditionResponse',
+    'AlertRuleAnyOfOrLeafConditionResponse',
+    'AlertRuleLeafConditionResponse',
     'ArmRoleReceiverResponse',
     'AutomationRunbookReceiverResponse',
     'AutoscaleNotificationResponse',
@@ -57,6 +62,8 @@ __all__ = [
     'DestinationsSpecResponseAzureMonitorMetrics',
     'DiagnosticSettingsCategoryResourceResponse',
     'DimensionResponse',
+    'DynamicMetricCriteriaResponse',
+    'DynamicThresholdFailingPeriodsResponse',
     'EmailNotificationResponse',
     'EmailReceiverResponse',
     'EventHubDestinationResponse',
@@ -82,6 +89,11 @@ __all__ = [
     'LogicAppReceiverResponse',
     'ManagedServiceIdentityResponse',
     'ManagementGroupLogSettingsResponse',
+    'MetricAlertActionResponse',
+    'MetricAlertMultipleResourceMultipleMetricCriteriaResponse',
+    'MetricAlertSingleResourceMultipleMetricCriteriaResponse',
+    'MetricCriteriaResponse',
+    'MetricDimensionResponse',
     'MetricSettingsResponse',
     'MetricTriggerResponse',
     'MetricsResponse',
@@ -132,6 +144,7 @@ __all__ = [
     'VoiceReceiverResponse',
     'WebhookNotificationResponse',
     'WebhookReceiverResponse',
+    'WebtestLocationAvailabilityCriteriaResponse',
     'WindowsEventLogDataSourceResponse',
     'WindowsFirewallLogsDataSourceResponse',
 ]
@@ -268,6 +281,99 @@ class AccessModeSettingsResponse(dict):
         return pulumi.get(self, "exclusions")
 
 
+@pulumi.output_type
+class ActionGroupResponse(dict):
+    """
+    A pointer to an Azure Action Group.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "actionGroupId":
+            suggest = "action_group_id"
+        elif key == "webhookProperties":
+            suggest = "webhook_properties"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ActionGroupResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ActionGroupResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ActionGroupResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 action_group_id: str,
+                 webhook_properties: Optional[Mapping[str, str]] = None):
+        """
+        A pointer to an Azure Action Group.
+        :param str action_group_id: The resource ID of the Action Group. This cannot be null or empty.
+        :param Mapping[str, str] webhook_properties: the dictionary of custom properties to include with the post operation. These data are appended to the webhook payload.
+        """
+        pulumi.set(__self__, "action_group_id", action_group_id)
+        if webhook_properties is not None:
+            pulumi.set(__self__, "webhook_properties", webhook_properties)
+
+    @property
+    @pulumi.getter(name="actionGroupId")
+    def action_group_id(self) -> str:
+        """
+        The resource ID of the Action Group. This cannot be null or empty.
+        """
+        return pulumi.get(self, "action_group_id")
+
+    @property
+    @pulumi.getter(name="webhookProperties")
+    def webhook_properties(self) -> Optional[Mapping[str, str]]:
+        """
+        the dictionary of custom properties to include with the post operation. These data are appended to the webhook payload.
+        """
+        return pulumi.get(self, "webhook_properties")
+
+
+@pulumi.output_type
+class ActionListResponse(dict):
+    """
+    A list of Activity Log Alert rule actions.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "actionGroups":
+            suggest = "action_groups"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ActionListResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ActionListResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ActionListResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 action_groups: Optional[Sequence['outputs.ActionGroupResponse']] = None):
+        """
+        A list of Activity Log Alert rule actions.
+        :param Sequence['ActionGroupResponse'] action_groups: The list of the Action Groups.
+        """
+        if action_groups is not None:
+            pulumi.set(__self__, "action_groups", action_groups)
+
+    @property
+    @pulumi.getter(name="actionGroups")
+    def action_groups(self) -> Optional[Sequence['outputs.ActionGroupResponse']]:
+        """
+        The list of the Action Groups.
+        """
+        return pulumi.get(self, "action_groups")
+
+
 @pulumi.output_type
 class ActionsResponse(dict):
     """
@@ -336,6 +442,206 @@ class ActionsResponse(dict):
         return pulumi.get(self, "custom_properties")
 
 
+@pulumi.output_type
+class AlertRuleAllOfConditionResponse(dict):
+    """
+    An Activity Log Alert rule condition that is met when all its member conditions are met.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "allOf":
+            suggest = "all_of"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AlertRuleAllOfConditionResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AlertRuleAllOfConditionResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AlertRuleAllOfConditionResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 all_of: Sequence['outputs.AlertRuleAnyOfOrLeafConditionResponse']):
+        """
+        An Activity Log Alert rule condition that is met when all its member conditions are met.
+        :param Sequence['AlertRuleAnyOfOrLeafConditionResponse'] all_of: The list of Activity Log Alert rule conditions.
+        """
+        pulumi.set(__self__, "all_of", all_of)
+
+    @property
+    @pulumi.getter(name="allOf")
+    def all_of(self) -> Sequence['outputs.AlertRuleAnyOfOrLeafConditionResponse']:
+        """
+        The list of Activity Log Alert rule conditions.
+        """
+        return pulumi.get(self, "all_of")
+
+
+@pulumi.output_type
+class AlertRuleAnyOfOrLeafConditionResponse(dict):
+    """
+    An Activity Log Alert rule condition that is met when all its member conditions are met.
+    Each condition can be of one of the following types:
+    __Important__: Each type has its unique subset of properties. Properties from different types CANNOT exist in one condition.
+       * __Leaf Condition -__ must contain 'field' and either 'equals' or 'containsAny'.
+      _Please note, 'anyOf' should __not__ be set in a Leaf Condition._
+      * __AnyOf Condition -__ must contain __only__ 'anyOf' (which is an array of Leaf Conditions).
+      _Please note, 'field', 'equals' and 'containsAny' should __not__ be set in an AnyOf Condition._
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "anyOf":
+            suggest = "any_of"
+        elif key == "containsAny":
+            suggest = "contains_any"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AlertRuleAnyOfOrLeafConditionResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AlertRuleAnyOfOrLeafConditionResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AlertRuleAnyOfOrLeafConditionResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 any_of: Optional[Sequence['outputs.AlertRuleLeafConditionResponse']] = None,
+                 contains_any: Optional[Sequence[str]] = None,
+                 equals: Optional[str] = None,
+                 field: Optional[str] = None):
+        """
+        An Activity Log Alert rule condition that is met when all its member conditions are met.
+        Each condition can be of one of the following types:
+        __Important__: Each type has its unique subset of properties. Properties from different types CANNOT exist in one condition.
+           * __Leaf Condition -__ must contain 'field' and either 'equals' or 'containsAny'.
+          _Please note, 'anyOf' should __not__ be set in a Leaf Condition._
+          * __AnyOf Condition -__ must contain __only__ 'anyOf' (which is an array of Leaf Conditions).
+          _Please note, 'field', 'equals' and 'containsAny' should __not__ be set in an AnyOf Condition._
+
+        :param Sequence['AlertRuleLeafConditionResponse'] any_of: An Activity Log Alert rule condition that is met when at least one of its member leaf conditions are met.
+        :param Sequence[str] contains_any: The value of the event's field will be compared to the values in this array (case-insensitive) to determine if the condition is met.
+        :param str equals: The value of the event's field will be compared to this value (case-insensitive) to determine if the condition is met.
+        :param str field: The name of the Activity Log event's field that this condition will examine.
+               The possible values for this field are (case-insensitive): 'resourceId', 'category', 'caller', 'level', 'operationName', 'resourceGroup', 'resourceProvider', 'status', 'subStatus', 'resourceType', or anything beginning with 'properties'.
+        """
+        if any_of is not None:
+            pulumi.set(__self__, "any_of", any_of)
+        if contains_any is not None:
+            pulumi.set(__self__, "contains_any", contains_any)
+        if equals is not None:
+            pulumi.set(__self__, "equals", equals)
+        if field is not None:
+            pulumi.set(__self__, "field", field)
+
+    @property
+    @pulumi.getter(name="anyOf")
+    def any_of(self) -> Optional[Sequence['outputs.AlertRuleLeafConditionResponse']]:
+        """
+        An Activity Log Alert rule condition that is met when at least one of its member leaf conditions are met.
+        """
+        return pulumi.get(self, "any_of")
+
+    @property
+    @pulumi.getter(name="containsAny")
+    def contains_any(self) -> Optional[Sequence[str]]:
+        """
+        The value of the event's field will be compared to the values in this array (case-insensitive) to determine if the condition is met.
+        """
+        return pulumi.get(self, "contains_any")
+
+    @property
+    @pulumi.getter
+    def equals(self) -> Optional[str]:
+        """
+        The value of the event's field will be compared to this value (case-insensitive) to determine if the condition is met.
+        """
+        return pulumi.get(self, "equals")
+
+    @property
+    @pulumi.getter
+    def field(self) -> Optional[str]:
+        """
+        The name of the Activity Log event's field that this condition will examine.
+        The possible values for this field are (case-insensitive): 'resourceId', 'category', 'caller', 'level', 'operationName', 'resourceGroup', 'resourceProvider', 'status', 'subStatus', 'resourceType', or anything beginning with 'properties'.
+        """
+        return pulumi.get(self, "field")
+
+
+@pulumi.output_type
+class AlertRuleLeafConditionResponse(dict):
+    """
+    An Activity Log Alert rule condition that is met by comparing the field and value of an Activity Log event.
+    This condition must contain 'field' and either 'equals' or 'containsAny'.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "containsAny":
+            suggest = "contains_any"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AlertRuleLeafConditionResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AlertRuleLeafConditionResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AlertRuleLeafConditionResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 contains_any: Optional[Sequence[str]] = None,
+                 equals: Optional[str] = None,
+                 field: Optional[str] = None):
+        """
+        An Activity Log Alert rule condition that is met by comparing the field and value of an Activity Log event.
+        This condition must contain 'field' and either 'equals' or 'containsAny'.
+        :param Sequence[str] contains_any: The value of the event's field will be compared to the values in this array (case-insensitive) to determine if the condition is met.
+        :param str equals: The value of the event's field will be compared to this value (case-insensitive) to determine if the condition is met.
+        :param str field: The name of the Activity Log event's field that this condition will examine.
+               The possible values for this field are (case-insensitive): 'resourceId', 'category', 'caller', 'level', 'operationName', 'resourceGroup', 'resourceProvider', 'status', 'subStatus', 'resourceType', or anything beginning with 'properties'.
+        """
+        if contains_any is not None:
+            pulumi.set(__self__, "contains_any", contains_any)
+        if equals is not None:
+            pulumi.set(__self__, "equals", equals)
+        if field is not None:
+            pulumi.set(__self__, "field", field)
+
+    @property
+    @pulumi.getter(name="containsAny")
+    def contains_any(self) -> Optional[Sequence[str]]:
+        """
+        The value of the event's field will be compared to the values in this array (case-insensitive) to determine if the condition is met.
+        """
+        return pulumi.get(self, "contains_any")
+
+    @property
+    @pulumi.getter
+    def equals(self) -> Optional[str]:
+        """
+        The value of the event's field will be compared to this value (case-insensitive) to determine if the condition is met.
+        """
+        return pulumi.get(self, "equals")
+
+    @property
+    @pulumi.getter
+    def field(self) -> Optional[str]:
+        """
+        The name of the Activity Log event's field that this condition will examine.
+        The possible values for this field are (case-insensitive): 'resourceId', 'category', 'caller', 'level', 'operationName', 'resourceGroup', 'resourceProvider', 'status', 'subStatus', 'resourceType', or anything beginning with 'properties'.
+        """
+        return pulumi.get(self, "field")
+
+
 @pulumi.output_type
 class ArmRoleReceiverResponse(dict):
     """
@@ -2987,84 +3293,305 @@ class DimensionResponse(dict):
 
 
 @pulumi.output_type
-class EmailNotificationResponse(dict):
+class DynamicMetricCriteriaResponse(dict):
     """
-    Email notification of an autoscale event.
+    Criterion for dynamic threshold.
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "customEmails":
-            suggest = "custom_emails"
-        elif key == "sendToSubscriptionAdministrator":
-            suggest = "send_to_subscription_administrator"
-        elif key == "sendToSubscriptionCoAdministrators":
-            suggest = "send_to_subscription_co_administrators"
+        if key == "alertSensitivity":
+            suggest = "alert_sensitivity"
+        elif key == "criterionType":
+            suggest = "criterion_type"
+        elif key == "failingPeriods":
+            suggest = "failing_periods"
+        elif key == "metricName":
+            suggest = "metric_name"
+        elif key == "timeAggregation":
+            suggest = "time_aggregation"
+        elif key == "ignoreDataBefore":
+            suggest = "ignore_data_before"
+        elif key == "metricNamespace":
+            suggest = "metric_namespace"
+        elif key == "skipMetricValidation":
+            suggest = "skip_metric_validation"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in EmailNotificationResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in DynamicMetricCriteriaResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        EmailNotificationResponse.__key_warning(key)
+        DynamicMetricCriteriaResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        EmailNotificationResponse.__key_warning(key)
+        DynamicMetricCriteriaResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 custom_emails: Optional[Sequence[str]] = None,
-                 send_to_subscription_administrator: Optional[bool] = None,
-                 send_to_subscription_co_administrators: Optional[bool] = None):
+                 alert_sensitivity: str,
+                 criterion_type: str,
+                 failing_periods: 'outputs.DynamicThresholdFailingPeriodsResponse',
+                 metric_name: str,
+                 name: str,
+                 operator: str,
+                 time_aggregation: str,
+                 dimensions: Optional[Sequence['outputs.MetricDimensionResponse']] = None,
+                 ignore_data_before: Optional[str] = None,
+                 metric_namespace: Optional[str] = None,
+                 skip_metric_validation: Optional[bool] = None):
         """
-        Email notification of an autoscale event.
-        :param Sequence[str] custom_emails: the custom e-mails list. This value can be null or empty, in which case this attribute will be ignored.
-        :param bool send_to_subscription_administrator: a value indicating whether to send email to subscription administrator.
-        :param bool send_to_subscription_co_administrators: a value indicating whether to send email to subscription co-administrators.
+        Criterion for dynamic threshold.
+        :param str alert_sensitivity: The extent of deviation required to trigger an alert. This will affect how tight the threshold is to the metric series pattern.
+        :param str criterion_type: Specifies the type of threshold criteria
+               Expected value is 'DynamicThresholdCriterion'.
+        :param 'DynamicThresholdFailingPeriodsResponse' failing_periods: The minimum number of violations required within the selected lookback time window required to raise an alert.
+        :param str metric_name: Name of the metric.
+        :param str name: Name of the criteria.
+        :param str operator: The operator used to compare the metric value against the threshold.
+        :param str time_aggregation: the criteria time aggregation types.
+        :param Sequence['MetricDimensionResponse'] dimensions: List of dimension conditions.
+        :param str ignore_data_before: Use this option to set the date from which to start learning the metric historical data and calculate the dynamic thresholds (in ISO8601 format)
+        :param str metric_namespace: Namespace of the metric.
+        :param bool skip_metric_validation: Allows creating an alert rule on a custom metric that isn't yet emitted, by causing the metric validation to be skipped.
+        """
+        pulumi.set(__self__, "alert_sensitivity", alert_sensitivity)
+        pulumi.set(__self__, "criterion_type", 'DynamicThresholdCriterion')
+        pulumi.set(__self__, "failing_periods", failing_periods)
+        pulumi.set(__self__, "metric_name", metric_name)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "operator", operator)
+        pulumi.set(__self__, "time_aggregation", time_aggregation)
+        if dimensions is not None:
+            pulumi.set(__self__, "dimensions", dimensions)
+        if ignore_data_before is not None:
+            pulumi.set(__self__, "ignore_data_before", ignore_data_before)
+        if metric_namespace is not None:
+            pulumi.set(__self__, "metric_namespace", metric_namespace)
+        if skip_metric_validation is not None:
+            pulumi.set(__self__, "skip_metric_validation", skip_metric_validation)
+
+    @property
+    @pulumi.getter(name="alertSensitivity")
+    def alert_sensitivity(self) -> str:
         """
-        if custom_emails is not None:
-            pulumi.set(__self__, "custom_emails", custom_emails)
-        if send_to_subscription_administrator is None:
-            send_to_subscription_administrator = False
-        if send_to_subscription_administrator is not None:
-            pulumi.set(__self__, "send_to_subscription_administrator", send_to_subscription_administrator)
-        if send_to_subscription_co_administrators is None:
-            send_to_subscription_co_administrators = False
-        if send_to_subscription_co_administrators is not None:
-            pulumi.set(__self__, "send_to_subscription_co_administrators", send_to_subscription_co_administrators)
+        The extent of deviation required to trigger an alert. This will affect how tight the threshold is to the metric series pattern.
+        """
+        return pulumi.get(self, "alert_sensitivity")
 
     @property
-    @pulumi.getter(name="customEmails")
-    def custom_emails(self) -> Optional[Sequence[str]]:
+    @pulumi.getter(name="criterionType")
+    def criterion_type(self) -> str:
         """
-        the custom e-mails list. This value can be null or empty, in which case this attribute will be ignored.
+        Specifies the type of threshold criteria
+        Expected value is 'DynamicThresholdCriterion'.
         """
-        return pulumi.get(self, "custom_emails")
+        return pulumi.get(self, "criterion_type")
 
     @property
-    @pulumi.getter(name="sendToSubscriptionAdministrator")
-    def send_to_subscription_administrator(self) -> Optional[bool]:
+    @pulumi.getter(name="failingPeriods")
+    def failing_periods(self) -> 'outputs.DynamicThresholdFailingPeriodsResponse':
         """
-        a value indicating whether to send email to subscription administrator.
+        The minimum number of violations required within the selected lookback time window required to raise an alert.
         """
-        return pulumi.get(self, "send_to_subscription_administrator")
+        return pulumi.get(self, "failing_periods")
 
     @property
-    @pulumi.getter(name="sendToSubscriptionCoAdministrators")
-    def send_to_subscription_co_administrators(self) -> Optional[bool]:
+    @pulumi.getter(name="metricName")
+    def metric_name(self) -> str:
         """
-        a value indicating whether to send email to subscription co-administrators.
+        Name of the metric.
         """
-        return pulumi.get(self, "send_to_subscription_co_administrators")
+        return pulumi.get(self, "metric_name")
 
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        Name of the criteria.
+        """
+        return pulumi.get(self, "name")
 
-@pulumi.output_type
-class EmailReceiverResponse(dict):
-    """
-    An email receiver.
-    """
-    @staticmethod
-    def __key_warning(key: str):
+    @property
+    @pulumi.getter
+    def operator(self) -> str:
+        """
+        The operator used to compare the metric value against the threshold.
+        """
+        return pulumi.get(self, "operator")
+
+    @property
+    @pulumi.getter(name="timeAggregation")
+    def time_aggregation(self) -> str:
+        """
+        the criteria time aggregation types.
+        """
+        return pulumi.get(self, "time_aggregation")
+
+    @property
+    @pulumi.getter
+    def dimensions(self) -> Optional[Sequence['outputs.MetricDimensionResponse']]:
+        """
+        List of dimension conditions.
+        """
+        return pulumi.get(self, "dimensions")
+
+    @property
+    @pulumi.getter(name="ignoreDataBefore")
+    def ignore_data_before(self) -> Optional[str]:
+        """
+        Use this option to set the date from which to start learning the metric historical data and calculate the dynamic thresholds (in ISO8601 format)
+        """
+        return pulumi.get(self, "ignore_data_before")
+
+    @property
+    @pulumi.getter(name="metricNamespace")
+    def metric_namespace(self) -> Optional[str]:
+        """
+        Namespace of the metric.
+        """
+        return pulumi.get(self, "metric_namespace")
+
+    @property
+    @pulumi.getter(name="skipMetricValidation")
+    def skip_metric_validation(self) -> Optional[bool]:
+        """
+        Allows creating an alert rule on a custom metric that isn't yet emitted, by causing the metric validation to be skipped.
+        """
+        return pulumi.get(self, "skip_metric_validation")
+
+
+@pulumi.output_type
+class DynamicThresholdFailingPeriodsResponse(dict):
+    """
+    The minimum number of violations required within the selected lookback time window required to raise an alert.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "minFailingPeriodsToAlert":
+            suggest = "min_failing_periods_to_alert"
+        elif key == "numberOfEvaluationPeriods":
+            suggest = "number_of_evaluation_periods"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DynamicThresholdFailingPeriodsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DynamicThresholdFailingPeriodsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DynamicThresholdFailingPeriodsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 min_failing_periods_to_alert: float,
+                 number_of_evaluation_periods: float):
+        """
+        The minimum number of violations required within the selected lookback time window required to raise an alert.
+        :param float min_failing_periods_to_alert: The number of violations to trigger an alert. Should be smaller or equal to numberOfEvaluationPeriods.
+        :param float number_of_evaluation_periods: The number of aggregated lookback points. The lookback time window is calculated based on the aggregation granularity (windowSize) and the selected number of aggregated points.
+        """
+        pulumi.set(__self__, "min_failing_periods_to_alert", min_failing_periods_to_alert)
+        pulumi.set(__self__, "number_of_evaluation_periods", number_of_evaluation_periods)
+
+    @property
+    @pulumi.getter(name="minFailingPeriodsToAlert")
+    def min_failing_periods_to_alert(self) -> float:
+        """
+        The number of violations to trigger an alert. Should be smaller or equal to numberOfEvaluationPeriods.
+        """
+        return pulumi.get(self, "min_failing_periods_to_alert")
+
+    @property
+    @pulumi.getter(name="numberOfEvaluationPeriods")
+    def number_of_evaluation_periods(self) -> float:
+        """
+        The number of aggregated lookback points. The lookback time window is calculated based on the aggregation granularity (windowSize) and the selected number of aggregated points.
+        """
+        return pulumi.get(self, "number_of_evaluation_periods")
+
+
+@pulumi.output_type
+class EmailNotificationResponse(dict):
+    """
+    Email notification of an autoscale event.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "customEmails":
+            suggest = "custom_emails"
+        elif key == "sendToSubscriptionAdministrator":
+            suggest = "send_to_subscription_administrator"
+        elif key == "sendToSubscriptionCoAdministrators":
+            suggest = "send_to_subscription_co_administrators"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EmailNotificationResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EmailNotificationResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EmailNotificationResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 custom_emails: Optional[Sequence[str]] = None,
+                 send_to_subscription_administrator: Optional[bool] = None,
+                 send_to_subscription_co_administrators: Optional[bool] = None):
+        """
+        Email notification of an autoscale event.
+        :param Sequence[str] custom_emails: the custom e-mails list. This value can be null or empty, in which case this attribute will be ignored.
+        :param bool send_to_subscription_administrator: a value indicating whether to send email to subscription administrator.
+        :param bool send_to_subscription_co_administrators: a value indicating whether to send email to subscription co-administrators.
+        """
+        if custom_emails is not None:
+            pulumi.set(__self__, "custom_emails", custom_emails)
+        if send_to_subscription_administrator is None:
+            send_to_subscription_administrator = False
+        if send_to_subscription_administrator is not None:
+            pulumi.set(__self__, "send_to_subscription_administrator", send_to_subscription_administrator)
+        if send_to_subscription_co_administrators is None:
+            send_to_subscription_co_administrators = False
+        if send_to_subscription_co_administrators is not None:
+            pulumi.set(__self__, "send_to_subscription_co_administrators", send_to_subscription_co_administrators)
+
+    @property
+    @pulumi.getter(name="customEmails")
+    def custom_emails(self) -> Optional[Sequence[str]]:
+        """
+        the custom e-mails list. This value can be null or empty, in which case this attribute will be ignored.
+        """
+        return pulumi.get(self, "custom_emails")
+
+    @property
+    @pulumi.getter(name="sendToSubscriptionAdministrator")
+    def send_to_subscription_administrator(self) -> Optional[bool]:
+        """
+        a value indicating whether to send email to subscription administrator.
+        """
+        return pulumi.get(self, "send_to_subscription_administrator")
+
+    @property
+    @pulumi.getter(name="sendToSubscriptionCoAdministrators")
+    def send_to_subscription_co_administrators(self) -> Optional[bool]:
+        """
+        a value indicating whether to send email to subscription co-administrators.
+        """
+        return pulumi.get(self, "send_to_subscription_co_administrators")
+
+
+@pulumi.output_type
+class EmailReceiverResponse(dict):
+    """
+    An email receiver.
+    """
+    @staticmethod
+    def __key_warning(key: str):
         suggest = None
         if key == "emailAddress":
             suggest = "email_address"
@@ -4401,250 +4928,598 @@ class LogSettingsResponse(dict):
     @pulumi.getter(name="categoryGroup")
     def category_group(self) -> Optional[str]:
         """
-        Name of a Diagnostic Log category group for a resource type this setting is applied to. To obtain the list of Diagnostic Log categories for a resource, first perform a GET diagnostic settings operation.
+        Name of a Diagnostic Log category group for a resource type this setting is applied to. To obtain the list of Diagnostic Log categories for a resource, first perform a GET diagnostic settings operation.
+        """
+        return pulumi.get(self, "category_group")
+
+    @property
+    @pulumi.getter(name="retentionPolicy")
+    def retention_policy(self) -> Optional['outputs.RetentionPolicyResponse']:
+        """
+        the retention policy for this log.
+        """
+        return pulumi.get(self, "retention_policy")
+
+
+@pulumi.output_type
+class LogicAppReceiverResponse(dict):
+    """
+    A logic app receiver.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "callbackUrl":
+            suggest = "callback_url"
+        elif key == "resourceId":
+            suggest = "resource_id"
+        elif key == "managedIdentity":
+            suggest = "managed_identity"
+        elif key == "useCommonAlertSchema":
+            suggest = "use_common_alert_schema"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in LogicAppReceiverResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        LogicAppReceiverResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        LogicAppReceiverResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 callback_url: str,
+                 name: str,
+                 resource_id: str,
+                 managed_identity: Optional[str] = None,
+                 use_common_alert_schema: Optional[bool] = None):
+        """
+        A logic app receiver.
+        :param str callback_url: The callback url where http request sent to.
+        :param str name: The name of the logic app receiver. Names must be unique across all receivers within an action group.
+        :param str resource_id: The azure resource id of the logic app receiver.
+        :param str managed_identity: The principal id of the managed identity. The value can be "None", "SystemAssigned" 
+        :param bool use_common_alert_schema: Indicates whether to use common alert schema.
+        """
+        pulumi.set(__self__, "callback_url", callback_url)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "resource_id", resource_id)
+        if managed_identity is not None:
+            pulumi.set(__self__, "managed_identity", managed_identity)
+        if use_common_alert_schema is None:
+            use_common_alert_schema = False
+        if use_common_alert_schema is not None:
+            pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)
+
+    @property
+    @pulumi.getter(name="callbackUrl")
+    def callback_url(self) -> str:
+        """
+        The callback url where http request sent to.
+        """
+        return pulumi.get(self, "callback_url")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of the logic app receiver. Names must be unique across all receivers within an action group.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="resourceId")
+    def resource_id(self) -> str:
+        """
+        The azure resource id of the logic app receiver.
+        """
+        return pulumi.get(self, "resource_id")
+
+    @property
+    @pulumi.getter(name="managedIdentity")
+    def managed_identity(self) -> Optional[str]:
+        """
+        The principal id of the managed identity. The value can be "None", "SystemAssigned" 
+        """
+        return pulumi.get(self, "managed_identity")
+
+    @property
+    @pulumi.getter(name="useCommonAlertSchema")
+    def use_common_alert_schema(self) -> Optional[bool]:
+        """
+        Indicates whether to use common alert schema.
+        """
+        return pulumi.get(self, "use_common_alert_schema")
+
+
+@pulumi.output_type
+class ManagedServiceIdentityResponse(dict):
+    """
+    Managed service identity (system assigned and/or user assigned identities)
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "principalId":
+            suggest = "principal_id"
+        elif key == "tenantId":
+            suggest = "tenant_id"
+        elif key == "userAssignedIdentities":
+            suggest = "user_assigned_identities"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ManagedServiceIdentityResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ManagedServiceIdentityResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ManagedServiceIdentityResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 principal_id: str,
+                 tenant_id: str,
+                 type: str,
+                 user_assigned_identities: Optional[Mapping[str, 'outputs.UserAssignedIdentityResponse']] = None):
+        """
+        Managed service identity (system assigned and/or user assigned identities)
+        :param str principal_id: The service principal ID of the system assigned identity. This property will only be provided for a system assigned identity.
+        :param str tenant_id: The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity.
+        :param str type: Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
+        :param Mapping[str, 'UserAssignedIdentityResponse'] user_assigned_identities: The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. The dictionary values can be empty objects ({}) in requests.
+        """
+        pulumi.set(__self__, "principal_id", principal_id)
+        pulumi.set(__self__, "tenant_id", tenant_id)
+        pulumi.set(__self__, "type", type)
+        if user_assigned_identities is not None:
+            pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
+
+    @property
+    @pulumi.getter(name="principalId")
+    def principal_id(self) -> str:
+        """
+        The service principal ID of the system assigned identity. This property will only be provided for a system assigned identity.
+        """
+        return pulumi.get(self, "principal_id")
+
+    @property
+    @pulumi.getter(name="tenantId")
+    def tenant_id(self) -> str:
+        """
+        The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity.
+        """
+        return pulumi.get(self, "tenant_id")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="userAssignedIdentities")
+    def user_assigned_identities(self) -> Optional[Mapping[str, 'outputs.UserAssignedIdentityResponse']]:
+        """
+        The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. The dictionary values can be empty objects ({}) in requests.
+        """
+        return pulumi.get(self, "user_assigned_identities")
+
+
+@pulumi.output_type
+class ManagementGroupLogSettingsResponse(dict):
+    """
+    Part of Management Group diagnostic setting. Specifies the settings for a particular log.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "categoryGroup":
+            suggest = "category_group"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ManagementGroupLogSettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ManagementGroupLogSettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ManagementGroupLogSettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 enabled: bool,
+                 category: Optional[str] = None,
+                 category_group: Optional[str] = None):
+        """
+        Part of Management Group diagnostic setting. Specifies the settings for a particular log.
+        :param bool enabled: a value indicating whether this log is enabled.
+        :param str category: Name of a Management Group Diagnostic Log category for a resource type this setting is applied to.
+        :param str category_group: Name of a Management Group Diagnostic Log category group for a resource type this setting is applied to.
+        """
+        pulumi.set(__self__, "enabled", enabled)
+        if category is not None:
+            pulumi.set(__self__, "category", category)
+        if category_group is not None:
+            pulumi.set(__self__, "category_group", category_group)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> bool:
+        """
+        a value indicating whether this log is enabled.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter
+    def category(self) -> Optional[str]:
+        """
+        Name of a Management Group Diagnostic Log category for a resource type this setting is applied to.
+        """
+        return pulumi.get(self, "category")
+
+    @property
+    @pulumi.getter(name="categoryGroup")
+    def category_group(self) -> Optional[str]:
+        """
+        Name of a Management Group Diagnostic Log category group for a resource type this setting is applied to.
+        """
+        return pulumi.get(self, "category_group")
+
+
+@pulumi.output_type
+class MetricAlertActionResponse(dict):
+    """
+    An alert action.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "actionGroupId":
+            suggest = "action_group_id"
+        elif key == "webHookProperties":
+            suggest = "web_hook_properties"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in MetricAlertActionResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        MetricAlertActionResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        MetricAlertActionResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 action_group_id: Optional[str] = None,
+                 web_hook_properties: Optional[Mapping[str, str]] = None):
+        """
+        An alert action.
+        :param str action_group_id: the id of the action group to use.
+        :param Mapping[str, str] web_hook_properties: This field allows specifying custom properties, which would be appended to the alert payload sent as input to the webhook.
+        """
+        if action_group_id is not None:
+            pulumi.set(__self__, "action_group_id", action_group_id)
+        if web_hook_properties is not None:
+            pulumi.set(__self__, "web_hook_properties", web_hook_properties)
+
+    @property
+    @pulumi.getter(name="actionGroupId")
+    def action_group_id(self) -> Optional[str]:
+        """
+        the id of the action group to use.
+        """
+        return pulumi.get(self, "action_group_id")
+
+    @property
+    @pulumi.getter(name="webHookProperties")
+    def web_hook_properties(self) -> Optional[Mapping[str, str]]:
+        """
+        This field allows specifying custom properties, which would be appended to the alert payload sent as input to the webhook.
+        """
+        return pulumi.get(self, "web_hook_properties")
+
+
+@pulumi.output_type
+class MetricAlertMultipleResourceMultipleMetricCriteriaResponse(dict):
+    """
+    Specifies the metric alert criteria for multiple resource that has multiple metric criteria.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "odataType":
+            suggest = "odata_type"
+        elif key == "allOf":
+            suggest = "all_of"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in MetricAlertMultipleResourceMultipleMetricCriteriaResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        MetricAlertMultipleResourceMultipleMetricCriteriaResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        MetricAlertMultipleResourceMultipleMetricCriteriaResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 odata_type: str,
+                 all_of: Optional[Sequence[Any]] = None):
+        """
+        Specifies the metric alert criteria for multiple resource that has multiple metric criteria.
+        :param str odata_type: specifies the type of the alert criteria.
+               Expected value is 'Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria'.
+        :param Sequence[Union['DynamicMetricCriteriaResponse', 'MetricCriteriaResponse']] all_of: the list of multiple metric criteria for this 'all of' operation. 
+        """
+        pulumi.set(__self__, "odata_type", 'Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria')
+        if all_of is not None:
+            pulumi.set(__self__, "all_of", all_of)
+
+    @property
+    @pulumi.getter(name="odataType")
+    def odata_type(self) -> str:
+        """
+        specifies the type of the alert criteria.
+        Expected value is 'Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria'.
+        """
+        return pulumi.get(self, "odata_type")
+
+    @property
+    @pulumi.getter(name="allOf")
+    def all_of(self) -> Optional[Sequence[Any]]:
+        """
+        the list of multiple metric criteria for this 'all of' operation. 
+        """
+        return pulumi.get(self, "all_of")
+
+
+@pulumi.output_type
+class MetricAlertSingleResourceMultipleMetricCriteriaResponse(dict):
+    """
+    Specifies the metric alert criteria for a single resource that has multiple metric criteria.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "odataType":
+            suggest = "odata_type"
+        elif key == "allOf":
+            suggest = "all_of"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in MetricAlertSingleResourceMultipleMetricCriteriaResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        MetricAlertSingleResourceMultipleMetricCriteriaResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        MetricAlertSingleResourceMultipleMetricCriteriaResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 odata_type: str,
+                 all_of: Optional[Sequence['outputs.MetricCriteriaResponse']] = None):
+        """
+        Specifies the metric alert criteria for a single resource that has multiple metric criteria.
+        :param str odata_type: specifies the type of the alert criteria.
+               Expected value is 'Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria'.
+        :param Sequence['MetricCriteriaResponse'] all_of: The list of metric criteria for this 'all of' operation. 
+        """
+        pulumi.set(__self__, "odata_type", 'Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria')
+        if all_of is not None:
+            pulumi.set(__self__, "all_of", all_of)
+
+    @property
+    @pulumi.getter(name="odataType")
+    def odata_type(self) -> str:
+        """
+        specifies the type of the alert criteria.
+        Expected value is 'Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria'.
         """
-        return pulumi.get(self, "category_group")
+        return pulumi.get(self, "odata_type")
 
     @property
-    @pulumi.getter(name="retentionPolicy")
-    def retention_policy(self) -> Optional['outputs.RetentionPolicyResponse']:
+    @pulumi.getter(name="allOf")
+    def all_of(self) -> Optional[Sequence['outputs.MetricCriteriaResponse']]:
         """
-        the retention policy for this log.
+        The list of metric criteria for this 'all of' operation. 
         """
-        return pulumi.get(self, "retention_policy")
+        return pulumi.get(self, "all_of")
 
 
 @pulumi.output_type
-class LogicAppReceiverResponse(dict):
+class MetricCriteriaResponse(dict):
     """
-    A logic app receiver.
+    Criterion to filter metrics.
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "callbackUrl":
-            suggest = "callback_url"
-        elif key == "resourceId":
-            suggest = "resource_id"
-        elif key == "managedIdentity":
-            suggest = "managed_identity"
-        elif key == "useCommonAlertSchema":
-            suggest = "use_common_alert_schema"
+        if key == "criterionType":
+            suggest = "criterion_type"
+        elif key == "metricName":
+            suggest = "metric_name"
+        elif key == "timeAggregation":
+            suggest = "time_aggregation"
+        elif key == "metricNamespace":
+            suggest = "metric_namespace"
+        elif key == "skipMetricValidation":
+            suggest = "skip_metric_validation"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in LogicAppReceiverResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in MetricCriteriaResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        LogicAppReceiverResponse.__key_warning(key)
+        MetricCriteriaResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        LogicAppReceiverResponse.__key_warning(key)
+        MetricCriteriaResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 callback_url: str,
+                 criterion_type: str,
+                 metric_name: str,
                  name: str,
-                 resource_id: str,
-                 managed_identity: Optional[str] = None,
-                 use_common_alert_schema: Optional[bool] = None):
-        """
-        A logic app receiver.
-        :param str callback_url: The callback url where http request sent to.
-        :param str name: The name of the logic app receiver. Names must be unique across all receivers within an action group.
-        :param str resource_id: The azure resource id of the logic app receiver.
-        :param str managed_identity: The principal id of the managed identity. The value can be "None", "SystemAssigned" 
-        :param bool use_common_alert_schema: Indicates whether to use common alert schema.
+                 operator: str,
+                 threshold: float,
+                 time_aggregation: str,
+                 dimensions: Optional[Sequence['outputs.MetricDimensionResponse']] = None,
+                 metric_namespace: Optional[str] = None,
+                 skip_metric_validation: Optional[bool] = None):
         """
-        pulumi.set(__self__, "callback_url", callback_url)
+        Criterion to filter metrics.
+        :param str criterion_type: Specifies the type of threshold criteria
+               Expected value is 'StaticThresholdCriterion'.
+        :param str metric_name: Name of the metric.
+        :param str name: Name of the criteria.
+        :param str operator: the criteria operator.
+        :param float threshold: the criteria threshold value that activates the alert.
+        :param str time_aggregation: the criteria time aggregation types.
+        :param Sequence['MetricDimensionResponse'] dimensions: List of dimension conditions.
+        :param str metric_namespace: Namespace of the metric.
+        :param bool skip_metric_validation: Allows creating an alert rule on a custom metric that isn't yet emitted, by causing the metric validation to be skipped.
+        """
+        pulumi.set(__self__, "criterion_type", 'StaticThresholdCriterion')
+        pulumi.set(__self__, "metric_name", metric_name)
         pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "resource_id", resource_id)
-        if managed_identity is not None:
-            pulumi.set(__self__, "managed_identity", managed_identity)
-        if use_common_alert_schema is None:
-            use_common_alert_schema = False
-        if use_common_alert_schema is not None:
-            pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)
+        pulumi.set(__self__, "operator", operator)
+        pulumi.set(__self__, "threshold", threshold)
+        pulumi.set(__self__, "time_aggregation", time_aggregation)
+        if dimensions is not None:
+            pulumi.set(__self__, "dimensions", dimensions)
+        if metric_namespace is not None:
+            pulumi.set(__self__, "metric_namespace", metric_namespace)
+        if skip_metric_validation is not None:
+            pulumi.set(__self__, "skip_metric_validation", skip_metric_validation)
 
     @property
-    @pulumi.getter(name="callbackUrl")
-    def callback_url(self) -> str:
+    @pulumi.getter(name="criterionType")
+    def criterion_type(self) -> str:
         """
-        The callback url where http request sent to.
+        Specifies the type of threshold criteria
+        Expected value is 'StaticThresholdCriterion'.
         """
-        return pulumi.get(self, "callback_url")
+        return pulumi.get(self, "criterion_type")
 
     @property
-    @pulumi.getter
-    def name(self) -> str:
+    @pulumi.getter(name="metricName")
+    def metric_name(self) -> str:
         """
-        The name of the logic app receiver. Names must be unique across all receivers within an action group.
+        Name of the metric.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "metric_name")
 
     @property
-    @pulumi.getter(name="resourceId")
-    def resource_id(self) -> str:
+    @pulumi.getter
+    def name(self) -> str:
         """
-        The azure resource id of the logic app receiver.
+        Name of the criteria.
         """
-        return pulumi.get(self, "resource_id")
+        return pulumi.get(self, "name")
 
     @property
-    @pulumi.getter(name="managedIdentity")
-    def managed_identity(self) -> Optional[str]:
+    @pulumi.getter
+    def operator(self) -> str:
         """
-        The principal id of the managed identity. The value can be "None", "SystemAssigned" 
+        the criteria operator.
         """
-        return pulumi.get(self, "managed_identity")
+        return pulumi.get(self, "operator")
 
     @property
-    @pulumi.getter(name="useCommonAlertSchema")
-    def use_common_alert_schema(self) -> Optional[bool]:
-        """
-        Indicates whether to use common alert schema.
-        """
-        return pulumi.get(self, "use_common_alert_schema")
-
-
-@pulumi.output_type
-class ManagedServiceIdentityResponse(dict):
-    """
-    Managed service identity (system assigned and/or user assigned identities)
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "principalId":
-            suggest = "principal_id"
-        elif key == "tenantId":
-            suggest = "tenant_id"
-        elif key == "userAssignedIdentities":
-            suggest = "user_assigned_identities"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ManagedServiceIdentityResponse. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        ManagedServiceIdentityResponse.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        ManagedServiceIdentityResponse.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 principal_id: str,
-                 tenant_id: str,
-                 type: str,
-                 user_assigned_identities: Optional[Mapping[str, 'outputs.UserAssignedIdentityResponse']] = None):
+    @pulumi.getter
+    def threshold(self) -> float:
         """
-        Managed service identity (system assigned and/or user assigned identities)
-        :param str principal_id: The service principal ID of the system assigned identity. This property will only be provided for a system assigned identity.
-        :param str tenant_id: The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity.
-        :param str type: Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
-        :param Mapping[str, 'UserAssignedIdentityResponse'] user_assigned_identities: The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. The dictionary values can be empty objects ({}) in requests.
+        the criteria threshold value that activates the alert.
         """
-        pulumi.set(__self__, "principal_id", principal_id)
-        pulumi.set(__self__, "tenant_id", tenant_id)
-        pulumi.set(__self__, "type", type)
-        if user_assigned_identities is not None:
-            pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
+        return pulumi.get(self, "threshold")
 
     @property
-    @pulumi.getter(name="principalId")
-    def principal_id(self) -> str:
+    @pulumi.getter(name="timeAggregation")
+    def time_aggregation(self) -> str:
         """
-        The service principal ID of the system assigned identity. This property will only be provided for a system assigned identity.
+        the criteria time aggregation types.
         """
-        return pulumi.get(self, "principal_id")
+        return pulumi.get(self, "time_aggregation")
 
     @property
-    @pulumi.getter(name="tenantId")
-    def tenant_id(self) -> str:
+    @pulumi.getter
+    def dimensions(self) -> Optional[Sequence['outputs.MetricDimensionResponse']]:
         """
-        The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity.
+        List of dimension conditions.
         """
-        return pulumi.get(self, "tenant_id")
+        return pulumi.get(self, "dimensions")
 
     @property
-    @pulumi.getter
-    def type(self) -> str:
+    @pulumi.getter(name="metricNamespace")
+    def metric_namespace(self) -> Optional[str]:
         """
-        Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
+        Namespace of the metric.
         """
-        return pulumi.get(self, "type")
+        return pulumi.get(self, "metric_namespace")
 
     @property
-    @pulumi.getter(name="userAssignedIdentities")
-    def user_assigned_identities(self) -> Optional[Mapping[str, 'outputs.UserAssignedIdentityResponse']]:
+    @pulumi.getter(name="skipMetricValidation")
+    def skip_metric_validation(self) -> Optional[bool]:
         """
-        The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. The dictionary values can be empty objects ({}) in requests.
+        Allows creating an alert rule on a custom metric that isn't yet emitted, by causing the metric validation to be skipped.
         """
-        return pulumi.get(self, "user_assigned_identities")
+        return pulumi.get(self, "skip_metric_validation")
 
 
 @pulumi.output_type
-class ManagementGroupLogSettingsResponse(dict):
+class MetricDimensionResponse(dict):
     """
-    Part of Management Group diagnostic setting. Specifies the settings for a particular log.
+    Specifies a metric dimension.
     """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "categoryGroup":
-            suggest = "category_group"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ManagementGroupLogSettingsResponse. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        ManagementGroupLogSettingsResponse.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        ManagementGroupLogSettingsResponse.__key_warning(key)
-        return super().get(key, default)
-
     def __init__(__self__, *,
-                 enabled: bool,
-                 category: Optional[str] = None,
-                 category_group: Optional[str] = None):
+                 name: str,
+                 operator: str,
+                 values: Sequence[str]):
         """
-        Part of Management Group diagnostic setting. Specifies the settings for a particular log.
-        :param bool enabled: a value indicating whether this log is enabled.
-        :param str category: Name of a Management Group Diagnostic Log category for a resource type this setting is applied to.
-        :param str category_group: Name of a Management Group Diagnostic Log category group for a resource type this setting is applied to.
+        Specifies a metric dimension.
+        :param str name: Name of the dimension.
+        :param str operator: the dimension operator. Only 'Include' and 'Exclude' are supported
+        :param Sequence[str] values: list of dimension values.
         """
-        pulumi.set(__self__, "enabled", enabled)
-        if category is not None:
-            pulumi.set(__self__, "category", category)
-        if category_group is not None:
-            pulumi.set(__self__, "category_group", category_group)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "operator", operator)
+        pulumi.set(__self__, "values", values)
 
     @property
     @pulumi.getter
-    def enabled(self) -> bool:
+    def name(self) -> str:
         """
-        a value indicating whether this log is enabled.
+        Name of the dimension.
         """
-        return pulumi.get(self, "enabled")
+        return pulumi.get(self, "name")
 
     @property
     @pulumi.getter
-    def category(self) -> Optional[str]:
+    def operator(self) -> str:
         """
-        Name of a Management Group Diagnostic Log category for a resource type this setting is applied to.
+        the dimension operator. Only 'Include' and 'Exclude' are supported
         """
-        return pulumi.get(self, "category")
+        return pulumi.get(self, "operator")
 
     @property
-    @pulumi.getter(name="categoryGroup")
-    def category_group(self) -> Optional[str]:
+    @pulumi.getter
+    def values(self) -> Sequence[str]:
         """
-        Name of a Management Group Diagnostic Log category group for a resource type this setting is applied to.
+        list of dimension values.
         """
-        return pulumi.get(self, "category_group")
+        return pulumi.get(self, "values")
 
 
 @pulumi.output_type
@@ -7740,6 +8615,86 @@ class WebhookReceiverResponse(dict):
         return pulumi.get(self, "use_common_alert_schema")
 
 
+@pulumi.output_type
+class WebtestLocationAvailabilityCriteriaResponse(dict):
+    """
+    Specifies the metric alert rule criteria for a web test resource.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "componentId":
+            suggest = "component_id"
+        elif key == "failedLocationCount":
+            suggest = "failed_location_count"
+        elif key == "odataType":
+            suggest = "odata_type"
+        elif key == "webTestId":
+            suggest = "web_test_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WebtestLocationAvailabilityCriteriaResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WebtestLocationAvailabilityCriteriaResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WebtestLocationAvailabilityCriteriaResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 component_id: str,
+                 failed_location_count: float,
+                 odata_type: str,
+                 web_test_id: str):
+        """
+        Specifies the metric alert rule criteria for a web test resource.
+        :param str component_id: The Application Insights resource Id.
+        :param float failed_location_count: The number of failed locations.
+        :param str odata_type: specifies the type of the alert criteria.
+               Expected value is 'Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria'.
+        :param str web_test_id: The Application Insights web test Id.
+        """
+        pulumi.set(__self__, "component_id", component_id)
+        pulumi.set(__self__, "failed_location_count", failed_location_count)
+        pulumi.set(__self__, "odata_type", 'Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria')
+        pulumi.set(__self__, "web_test_id", web_test_id)
+
+    @property
+    @pulumi.getter(name="componentId")
+    def component_id(self) -> str:
+        """
+        The Application Insights resource Id.
+        """
+        return pulumi.get(self, "component_id")
+
+    @property
+    @pulumi.getter(name="failedLocationCount")
+    def failed_location_count(self) -> float:
+        """
+        The number of failed locations.
+        """
+        return pulumi.get(self, "failed_location_count")
+
+    @property
+    @pulumi.getter(name="odataType")
+    def odata_type(self) -> str:
+        """
+        specifies the type of the alert criteria.
+        Expected value is 'Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria'.
+        """
+        return pulumi.get(self, "odata_type")
+
+    @property
+    @pulumi.getter(name="webTestId")
+    def web_test_id(self) -> str:
+        """
+        The Application Insights web test Id.
+        """
+        return pulumi.get(self, "web_test_id")
+
+
 @pulumi.output_type
 class WindowsEventLogDataSourceResponse(dict):
     """