pulumi-azure-native 2.72.0a1731506636__py3-none-any.whl → 2.73.0a1732101729__py3-none-any.whl

pulumi_azure_native/workloads/_inputs.py

@@ -16,6 +16,10 @@ from .. import _utilities
 from ._enums import *
 
 __all__ = [
+    'AlertQueryParameterArgs',
+    'AlertQueryParameterArgsDict',
+    'AlertRulePropertiesArgs',
+    'AlertRulePropertiesArgsDict',
     'ApplicationServerConfigurationArgs',
     'ApplicationServerConfigurationArgsDict',
     'ApplicationServerFullResourceNamesArgs',
@@ -190,6 +194,338 @@ __all__ = [
 
 MYPY = False
 
+if not MYPY:
+    class AlertQueryParameterArgsDict(TypedDict):
+        """
+        Defines the Alert Query Parameter.
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        The name of the alert query parameter.
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        The value of the alert query parameter.
+        """
+elif False:
+    AlertQueryParameterArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AlertQueryParameterArgs:
+    def __init__(__self__, *,
+                 name: Optional[pulumi.Input[str]] = None,
+                 value: Optional[pulumi.Input[str]] = None):
+        """
+        Defines the Alert Query Parameter.
+        :param pulumi.Input[str] name: The name of the alert query parameter.
+        :param pulumi.Input[str] value: The value of the alert query parameter.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        The name of the alert query parameter.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def value(self) -> Optional[pulumi.Input[str]]:
+        """
+        The value of the alert query parameter.
+        """
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "value", value)
+
+
+if not MYPY:
+    class AlertRulePropertiesArgsDict(TypedDict):
+        """
+        Describes the properties of an alert.
+        """
+        action_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Action Group resource Ids to invoke when the alert fires
+        """
+        alert_query_parameters: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertQueryParameterArgsDict']]]]
+        """
+        The alert query parameters.
+        """
+        auto_mitigate: NotRequired[pulumi.Input[Union[str, 'AlertAutoMitigate']]]
+        """
+        The value that indicates whether the alert should be automatically resolved or not. The default is Disable.
+        """
+        dimension: NotRequired[pulumi.Input[str]]
+        """
+        Evaluation of metric on a particular column.
+        """
+        evaluation_frequency: NotRequired[pulumi.Input[int]]
+        """
+        How often the scheduled query rule is evaluated.
+        """
+        failing_periods_operator: NotRequired[pulumi.Input[Union[str, 'ConditionalOperator']]]
+        """
+        The operator for failing periods.
+        """
+        failing_periods_to_alert: NotRequired[pulumi.Input[int]]
+        """
+        The number of failing periods to trigger an alert.
+        """
+        mute_actions_duration: NotRequired[pulumi.Input[int]]
+        """
+        Mute actions for the chosen period of time after the alert is fired.
+        """
+        severity: NotRequired[pulumi.Input[int]]
+        """
+        Severity of the alert. Should be an integer between [0-4]. Value of 0 is severest.
+        """
+        status: NotRequired[pulumi.Input[Union[str, 'AlertRuleStatus']]]
+        """
+        Indicates whether the alert is in an enabled state.
+        """
+        threshold: NotRequired[pulumi.Input[int]]
+        """
+        The threshold of the alert.
+        """
+        threshold_operator: NotRequired[pulumi.Input[Union[str, 'ConditionalOperator']]]
+        """
+        The threshold operator of the alert.
+        """
+        window_size: NotRequired[pulumi.Input[int]]
+        """
+        The period of time on which the Alert query will be executed.
+        """
+elif False:
+    AlertRulePropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AlertRulePropertiesArgs:
+    def __init__(__self__, *,
+                 action_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 alert_query_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['AlertQueryParameterArgs']]]] = None,
+                 auto_mitigate: Optional[pulumi.Input[Union[str, 'AlertAutoMitigate']]] = None,
+                 dimension: Optional[pulumi.Input[str]] = None,
+                 evaluation_frequency: Optional[pulumi.Input[int]] = None,
+                 failing_periods_operator: Optional[pulumi.Input[Union[str, 'ConditionalOperator']]] = None,
+                 failing_periods_to_alert: Optional[pulumi.Input[int]] = None,
+                 mute_actions_duration: Optional[pulumi.Input[int]] = None,
+                 severity: Optional[pulumi.Input[int]] = None,
+                 status: Optional[pulumi.Input[Union[str, 'AlertRuleStatus']]] = None,
+                 threshold: Optional[pulumi.Input[int]] = None,
+                 threshold_operator: Optional[pulumi.Input[Union[str, 'ConditionalOperator']]] = None,
+                 window_size: Optional[pulumi.Input[int]] = None):
+        """
+        Describes the properties of an alert.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] action_groups: Action Group resource Ids to invoke when the alert fires
+        :param pulumi.Input[Sequence[pulumi.Input['AlertQueryParameterArgs']]] alert_query_parameters: The alert query parameters.
+        :param pulumi.Input[Union[str, 'AlertAutoMitigate']] auto_mitigate: The value that indicates whether the alert should be automatically resolved or not. The default is Disable.
+        :param pulumi.Input[str] dimension: Evaluation of metric on a particular column.
+        :param pulumi.Input[int] evaluation_frequency: How often the scheduled query rule is evaluated.
+        :param pulumi.Input[Union[str, 'ConditionalOperator']] failing_periods_operator: The operator for failing periods.
+        :param pulumi.Input[int] failing_periods_to_alert: The number of failing periods to trigger an alert.
+        :param pulumi.Input[int] mute_actions_duration: Mute actions for the chosen period of time after the alert is fired.
+        :param pulumi.Input[int] severity: Severity of the alert. Should be an integer between [0-4]. Value of 0 is severest.
+        :param pulumi.Input[Union[str, 'AlertRuleStatus']] status: Indicates whether the alert is in an enabled state.
+        :param pulumi.Input[int] threshold: The threshold of the alert.
+        :param pulumi.Input[Union[str, 'ConditionalOperator']] threshold_operator: The threshold operator of the alert.
+        :param pulumi.Input[int] window_size: The period of time on which the Alert query will be executed.
+        """
+        if action_groups is not None:
+            pulumi.set(__self__, "action_groups", action_groups)
+        if alert_query_parameters is not None:
+            pulumi.set(__self__, "alert_query_parameters", alert_query_parameters)
+        if auto_mitigate is not None:
+            pulumi.set(__self__, "auto_mitigate", auto_mitigate)
+        if dimension is not None:
+            pulumi.set(__self__, "dimension", dimension)
+        if evaluation_frequency is not None:
+            pulumi.set(__self__, "evaluation_frequency", evaluation_frequency)
+        if failing_periods_operator is not None:
+            pulumi.set(__self__, "failing_periods_operator", failing_periods_operator)
+        if failing_periods_to_alert is not None:
+            pulumi.set(__self__, "failing_periods_to_alert", failing_periods_to_alert)
+        if mute_actions_duration is not None:
+            pulumi.set(__self__, "mute_actions_duration", mute_actions_duration)
+        if severity is not None:
+            pulumi.set(__self__, "severity", severity)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+        if threshold is not None:
+            pulumi.set(__self__, "threshold", threshold)
+        if threshold_operator is not None:
+            pulumi.set(__self__, "threshold_operator", threshold_operator)
+        if window_size is not None:
+            pulumi.set(__self__, "window_size", window_size)
+
+    @property
+    @pulumi.getter(name="actionGroups")
+    def action_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Action Group resource Ids to invoke when the alert fires
+        """
+        return pulumi.get(self, "action_groups")
+
+    @action_groups.setter
+    def action_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "action_groups", value)
+
+    @property
+    @pulumi.getter(name="alertQueryParameters")
+    def alert_query_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlertQueryParameterArgs']]]]:
+        """
+        The alert query parameters.
+        """
+        return pulumi.get(self, "alert_query_parameters")
+
+    @alert_query_parameters.setter
+    def alert_query_parameters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AlertQueryParameterArgs']]]]):
+        pulumi.set(self, "alert_query_parameters", value)
+
+    @property
+    @pulumi.getter(name="autoMitigate")
+    def auto_mitigate(self) -> Optional[pulumi.Input[Union[str, 'AlertAutoMitigate']]]:
+        """
+        The value that indicates whether the alert should be automatically resolved or not. The default is Disable.
+        """
+        return pulumi.get(self, "auto_mitigate")
+
+    @auto_mitigate.setter
+    def auto_mitigate(self, value: Optional[pulumi.Input[Union[str, 'AlertAutoMitigate']]]):
+        pulumi.set(self, "auto_mitigate", value)
+
+    @property
+    @pulumi.getter
+    def dimension(self) -> Optional[pulumi.Input[str]]:
+        """
+        Evaluation of metric on a particular column.
+        """
+        return pulumi.get(self, "dimension")
+
+    @dimension.setter
+    def dimension(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "dimension", value)
+
+    @property
+    @pulumi.getter(name="evaluationFrequency")
+    def evaluation_frequency(self) -> Optional[pulumi.Input[int]]:
+        """
+        How often the scheduled query rule is evaluated.
+        """
+        return pulumi.get(self, "evaluation_frequency")
+
+    @evaluation_frequency.setter
+    def evaluation_frequency(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "evaluation_frequency", value)
+
+    @property
+    @pulumi.getter(name="failingPeriodsOperator")
+    def failing_periods_operator(self) -> Optional[pulumi.Input[Union[str, 'ConditionalOperator']]]:
+        """
+        The operator for failing periods.
+        """
+        return pulumi.get(self, "failing_periods_operator")
+
+    @failing_periods_operator.setter
+    def failing_periods_operator(self, value: Optional[pulumi.Input[Union[str, 'ConditionalOperator']]]):
+        pulumi.set(self, "failing_periods_operator", value)
+
+    @property
+    @pulumi.getter(name="failingPeriodsToAlert")
+    def failing_periods_to_alert(self) -> Optional[pulumi.Input[int]]:
+        """
+        The number of failing periods to trigger an alert.
+        """
+        return pulumi.get(self, "failing_periods_to_alert")
+
+    @failing_periods_to_alert.setter
+    def failing_periods_to_alert(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "failing_periods_to_alert", value)
+
+    @property
+    @pulumi.getter(name="muteActionsDuration")
+    def mute_actions_duration(self) -> Optional[pulumi.Input[int]]:
+        """
+        Mute actions for the chosen period of time after the alert is fired.
+        """
+        return pulumi.get(self, "mute_actions_duration")
+
+    @mute_actions_duration.setter
+    def mute_actions_duration(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "mute_actions_duration", value)
+
+    @property
+    @pulumi.getter
+    def severity(self) -> Optional[pulumi.Input[int]]:
+        """
+        Severity of the alert. Should be an integer between [0-4]. Value of 0 is severest.
+        """
+        return pulumi.get(self, "severity")
+
+    @severity.setter
+    def severity(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "severity", value)
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[pulumi.Input[Union[str, 'AlertRuleStatus']]]:
+        """
+        Indicates whether the alert is in an enabled state.
+        """
+        return pulumi.get(self, "status")
+
+    @status.setter
+    def status(self, value: Optional[pulumi.Input[Union[str, 'AlertRuleStatus']]]):
+        pulumi.set(self, "status", value)
+
+    @property
+    @pulumi.getter
+    def threshold(self) -> Optional[pulumi.Input[int]]:
+        """
+        The threshold of the alert.
+        """
+        return pulumi.get(self, "threshold")
+
+    @threshold.setter
+    def threshold(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "threshold", value)
+
+    @property
+    @pulumi.getter(name="thresholdOperator")
+    def threshold_operator(self) -> Optional[pulumi.Input[Union[str, 'ConditionalOperator']]]:
+        """
+        The threshold operator of the alert.
+        """
+        return pulumi.get(self, "threshold_operator")
+
+    @threshold_operator.setter
+    def threshold_operator(self, value: Optional[pulumi.Input[Union[str, 'ConditionalOperator']]]):
+        pulumi.set(self, "threshold_operator", value)
+
+    @property
+    @pulumi.getter(name="windowSize")
+    def window_size(self) -> Optional[pulumi.Input[int]]:
+        """
+        The period of time on which the Alert query will be executed.
+        """
+        return pulumi.get(self, "window_size")
+
+    @window_size.setter
+    def window_size(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "window_size", value)
+
+
 if not MYPY:
     class ApplicationServerConfigurationArgsDict(TypedDict):
         """

pulumi_azure_native/workloads/alert.py

@@ -0,0 +1,340 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from .. import _utilities
+from . import outputs
+from ._enums import *
+from ._inputs import *
+
+__all__ = ['AlertArgs', 'Alert']
+
+@pulumi.input_type
+class AlertArgs:
+    def __init__(__self__, *,
+                 monitor_name: pulumi.Input[str],
+                 resource_group_name: pulumi.Input[str],
+                 alert_name: Optional[pulumi.Input[str]] = None,
+                 alert_rule_properties: Optional[pulumi.Input['AlertRulePropertiesArgs']] = None,
+                 provider_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 provider_type: Optional[pulumi.Input[str]] = None,
+                 template_name: Optional[pulumi.Input[str]] = None):
+        """
+        The set of arguments for constructing a Alert resource.
+        :param pulumi.Input[str] monitor_name: Name of the SAP monitor resource.
+        :param pulumi.Input[str] resource_group_name: The name of the resource group. The name is case insensitive.
+        :param pulumi.Input[str] alert_name: Name of the SAP monitor alert resource.
+        :param pulumi.Input['AlertRulePropertiesArgs'] alert_rule_properties: Describes the properties of an alert.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] provider_names: Name of provider instances associated with the alert.
+        :param pulumi.Input[str] provider_type: The provider type for alert. For example, the value can be SapHana.
+        :param pulumi.Input[str] template_name: Name of the alert template from which it was created.
+        """
+        pulumi.set(__self__, "monitor_name", monitor_name)
+        pulumi.set(__self__, "resource_group_name", resource_group_name)
+        if alert_name is not None:
+            pulumi.set(__self__, "alert_name", alert_name)
+        if alert_rule_properties is not None:
+            pulumi.set(__self__, "alert_rule_properties", alert_rule_properties)
+        if provider_names is not None:
+            pulumi.set(__self__, "provider_names", provider_names)
+        if provider_type is not None:
+            pulumi.set(__self__, "provider_type", provider_type)
+        if template_name is not None:
+            pulumi.set(__self__, "template_name", template_name)
+
+    @property
+    @pulumi.getter(name="monitorName")
+    def monitor_name(self) -> pulumi.Input[str]:
+        """
+        Name of the SAP monitor resource.
+        """
+        return pulumi.get(self, "monitor_name")
+
+    @monitor_name.setter
+    def monitor_name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "monitor_name", value)
+
+    @property
+    @pulumi.getter(name="resourceGroupName")
+    def resource_group_name(self) -> pulumi.Input[str]:
+        """
+        The name of the resource group. The name is case insensitive.
+        """
+        return pulumi.get(self, "resource_group_name")
+
+    @resource_group_name.setter
+    def resource_group_name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "resource_group_name", value)
+
+    @property
+    @pulumi.getter(name="alertName")
+    def alert_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name of the SAP monitor alert resource.
+        """
+        return pulumi.get(self, "alert_name")
+
+    @alert_name.setter
+    def alert_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "alert_name", value)
+
+    @property
+    @pulumi.getter(name="alertRuleProperties")
+    def alert_rule_properties(self) -> Optional[pulumi.Input['AlertRulePropertiesArgs']]:
+        """
+        Describes the properties of an alert.
+        """
+        return pulumi.get(self, "alert_rule_properties")
+
+    @alert_rule_properties.setter
+    def alert_rule_properties(self, value: Optional[pulumi.Input['AlertRulePropertiesArgs']]):
+        pulumi.set(self, "alert_rule_properties", value)
+
+    @property
+    @pulumi.getter(name="providerNames")
+    def provider_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Name of provider instances associated with the alert.
+        """
+        return pulumi.get(self, "provider_names")
+
+    @provider_names.setter
+    def provider_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "provider_names", value)
+
+    @property
+    @pulumi.getter(name="providerType")
+    def provider_type(self) -> Optional[pulumi.Input[str]]:
+        """
+        The provider type for alert. For example, the value can be SapHana.
+        """
+        return pulumi.get(self, "provider_type")
+
+    @provider_type.setter
+    def provider_type(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "provider_type", value)
+
+    @property
+    @pulumi.getter(name="templateName")
+    def template_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name of the alert template from which it was created.
+        """
+        return pulumi.get(self, "template_name")
+
+    @template_name.setter
+    def template_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "template_name", value)
+
+
+class Alert(pulumi.CustomResource):
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 alert_name: Optional[pulumi.Input[str]] = None,
+                 alert_rule_properties: Optional[pulumi.Input[Union['AlertRulePropertiesArgs', 'AlertRulePropertiesArgsDict']]] = None,
+                 monitor_name: Optional[pulumi.Input[str]] = None,
+                 provider_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 provider_type: Optional[pulumi.Input[str]] = None,
+                 resource_group_name: Optional[pulumi.Input[str]] = None,
+                 template_name: Optional[pulumi.Input[str]] = None,
+                 __props__=None):
+        """
+        A alert associated with SAP monitor.
+        Azure REST API version: 2024-02-01-preview.
+
+        :param str resource_name: The name of the resource.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[str] alert_name: Name of the SAP monitor alert resource.
+        :param pulumi.Input[Union['AlertRulePropertiesArgs', 'AlertRulePropertiesArgsDict']] alert_rule_properties: Describes the properties of an alert.
+        :param pulumi.Input[str] monitor_name: Name of the SAP monitor resource.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] provider_names: Name of provider instances associated with the alert.
+        :param pulumi.Input[str] provider_type: The provider type for alert. For example, the value can be SapHana.
+        :param pulumi.Input[str] resource_group_name: The name of the resource group. The name is case insensitive.
+        :param pulumi.Input[str] template_name: Name of the alert template from which it was created.
+        """
+        ...
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 args: AlertArgs,
+                 opts: Optional[pulumi.ResourceOptions] = None):
+        """
+        A alert associated with SAP monitor.
+        Azure REST API version: 2024-02-01-preview.
+
+        :param str resource_name: The name of the resource.
+        :param AlertArgs args: The arguments to use to populate this resource's properties.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        """
+        ...
+    def __init__(__self__, resource_name: str, *args, **kwargs):
+        resource_args, opts = _utilities.get_resource_args_opts(AlertArgs, pulumi.ResourceOptions, *args, **kwargs)
+        if resource_args is not None:
+            __self__._internal_init(resource_name, opts, **resource_args.__dict__)
+        else:
+            __self__._internal_init(resource_name, *args, **kwargs)
+
+    def _internal_init(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 alert_name: Optional[pulumi.Input[str]] = None,
+                 alert_rule_properties: Optional[pulumi.Input[Union['AlertRulePropertiesArgs', 'AlertRulePropertiesArgsDict']]] = None,
+                 monitor_name: Optional[pulumi.Input[str]] = None,
+                 provider_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 provider_type: Optional[pulumi.Input[str]] = None,
+                 resource_group_name: Optional[pulumi.Input[str]] = None,
+                 template_name: Optional[pulumi.Input[str]] = None,
+                 __props__=None):
+        opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
+        if not isinstance(opts, pulumi.ResourceOptions):
+            raise TypeError('Expected resource options to be a ResourceOptions instance')
+        if opts.id is None:
+            if __props__ is not None:
+                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
+            __props__ = AlertArgs.__new__(AlertArgs)
+
+            __props__.__dict__["alert_name"] = alert_name
+            __props__.__dict__["alert_rule_properties"] = alert_rule_properties
+            if monitor_name is None and not opts.urn:
+                raise TypeError("Missing required property 'monitor_name'")
+            __props__.__dict__["monitor_name"] = monitor_name
+            __props__.__dict__["provider_names"] = provider_names
+            __props__.__dict__["provider_type"] = provider_type
+            if resource_group_name is None and not opts.urn:
+                raise TypeError("Missing required property 'resource_group_name'")
+            __props__.__dict__["resource_group_name"] = resource_group_name
+            __props__.__dict__["template_name"] = template_name
+            __props__.__dict__["alert_rule_resource_id"] = None
+            __props__.__dict__["errors"] = None
+            __props__.__dict__["name"] = None
+            __props__.__dict__["provisioning_state"] = None
+            __props__.__dict__["system_data"] = None
+            __props__.__dict__["type"] = None
+        alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_="azure-native:workloads/v20240201preview:Alert")])
+        opts = pulumi.ResourceOptions.merge(opts, alias_opts)
+        super(Alert, __self__).__init__(
+            'azure-native:workloads:Alert',
+            resource_name,
+            __props__,
+            opts)
+
+    @staticmethod
+    def get(resource_name: str,
+            id: pulumi.Input[str],
+            opts: Optional[pulumi.ResourceOptions] = None) -> 'Alert':
+        """
+        Get an existing Alert resource's state with the given name, id, and optional extra
+        properties used to qualify the lookup.
+
+        :param str resource_name: The unique name of the resulting resource.
+        :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        """
+        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
+
+        __props__ = AlertArgs.__new__(AlertArgs)
+
+        __props__.__dict__["alert_rule_properties"] = None
+        __props__.__dict__["alert_rule_resource_id"] = None
+        __props__.__dict__["errors"] = None
+        __props__.__dict__["name"] = None
+        __props__.__dict__["provider_names"] = None
+        __props__.__dict__["provider_type"] = None
+        __props__.__dict__["provisioning_state"] = None
+        __props__.__dict__["system_data"] = None
+        __props__.__dict__["template_name"] = None
+        __props__.__dict__["type"] = None
+        return Alert(resource_name, opts=opts, __props__=__props__)
+
+    @property
+    @pulumi.getter(name="alertRuleProperties")
+    def alert_rule_properties(self) -> pulumi.Output[Optional['outputs.AlertRulePropertiesResponse']]:
+        """
+        Describes the properties of an alert.
+        """
+        return pulumi.get(self, "alert_rule_properties")
+
+    @property
+    @pulumi.getter(name="alertRuleResourceId")
+    def alert_rule_resource_id(self) -> pulumi.Output[str]:
+        """
+        ID of the alert rule resource created.
+        """
+        return pulumi.get(self, "alert_rule_resource_id")
+
+    @property
+    @pulumi.getter
+    def errors(self) -> pulumi.Output['outputs.ErrorDetailResponse']:
+        """
+        Defines the alert instance errors.
+        """
+        return pulumi.get(self, "errors")
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Output[str]:
+        """
+        The name of the resource
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="providerNames")
+    def provider_names(self) -> pulumi.Output[Optional[Sequence[str]]]:
+        """
+        Name of provider instances associated with the alert.
+        """
+        return pulumi.get(self, "provider_names")
+
+    @property
+    @pulumi.getter(name="providerType")
+    def provider_type(self) -> pulumi.Output[Optional[str]]:
+        """
+        The provider type for alert. For example, the value can be SapHana.
+        """
+        return pulumi.get(self, "provider_type")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> pulumi.Output[str]:
+        """
+        State of provisioning of the alert instance
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="systemData")
+    def system_data(self) -> pulumi.Output['outputs.SystemDataResponse']:
+        """
+        Azure Resource Manager metadata containing createdBy and modifiedBy information.
+        """
+        return pulumi.get(self, "system_data")
+
+    @property
+    @pulumi.getter(name="templateName")
+    def template_name(self) -> pulumi.Output[Optional[str]]:
+        """
+        Name of the alert template from which it was created.
+        """
+        return pulumi.get(self, "template_name")
+
+    @property
+    @pulumi.getter
+    def type(self) -> pulumi.Output[str]:
+        """
+        The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
+        """
+        return pulumi.get(self, "type")
+