# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'AlarmEscalationsCritical',
    'AlarmEscalationsInfo',
    'AlarmEscalationsWarn',
    'DynamicTagGroupMatchExpress',
    'GroupMetricRuleEscalations',
    'GroupMetricRuleEscalationsCritical',
    'GroupMetricRuleEscalationsInfo',
    'GroupMetricRuleEscalationsWarn',
    'MetricRuleTemplateAlertTemplate',
    'MetricRuleTemplateAlertTemplateEscalations',
    'MetricRuleTemplateAlertTemplateEscalationsCritical',
    'MetricRuleTemplateAlertTemplateEscalationsInfo',
    'MetricRuleTemplateAlertTemplateEscalationsWarn',
    'MonitorGroupInstancesInstance',
    'SiteMonitorIspCity',
    'GetAlarmContactGroupsGroupResult',
    'GetAlarmContactsContactResult',
    'GetDynamicTagGroupsGroupResult',
    'GetDynamicTagGroupsGroupMatchExpressResult',
    'GetGroupMetricRulesRuleResult',
    'GetGroupMetricRulesRuleEscalationResult',
    'GetGroupMetricRulesRuleEscalationCriticalResult',
    'GetGroupMetricRulesRuleEscalationInfoResult',
    'GetGroupMetricRulesRuleEscalationWarnResult',
    'GetMetricRuleTemplatesTemplateResult',
    'GetMetricRuleTemplatesTemplateAlertTemplateResult',
    'GetMetricRuleTemplatesTemplateAlertTemplateEscalationResult',
    'GetMetricRuleTemplatesTemplateAlertTemplateEscalationCriticalResult',
    'GetMetricRuleTemplatesTemplateAlertTemplateEscalationInfoResult',
    'GetMetricRuleTemplatesTemplateAlertTemplateEscalationWarnResult',
    'GetMonitorGroupInstancesInstanceResult',
    'GetMonitorGroupInstancesInstanceInstanceResult',
    'GetMonitorGroupsGroupResult',
]

@pulumi.output_type
class AlarmEscalationsCritical(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "comparisonOperator":
            suggest = "comparison_operator"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AlarmEscalationsCritical. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AlarmEscalationsCritical.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AlarmEscalationsCritical.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 comparison_operator: Optional[str] = None,
                 statistics: Optional[str] = None,
                 threshold: Optional[str] = None,
                 times: Optional[int] = None):
        """
        :param str comparison_operator: Critical level alarm comparison operator. Valid values: ["<=", "<", ">", ">=", "==", "!="]. Default to "==".
        :param str statistics: Critical level alarm statistics method. It must be consistent with that defined for metrics. Valid values: ["Average", "Minimum", "Maximum", "Value", "ErrorCodeMaximum", "Sum", "Count"]. Default to "Average".
        :param str threshold: Critical level alarm threshold value, which must be a numeric value currently.
        :param int times: Critical level alarm retry times. Default to 3.
        """
        if comparison_operator is not None:
            pulumi.set(__self__, "comparison_operator", comparison_operator)
        if statistics is not None:
            pulumi.set(__self__, "statistics", statistics)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)
        if times is not None:
            pulumi.set(__self__, "times", times)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> Optional[str]:
        """
        Critical level alarm comparison operator. Valid values: ["<=", "<", ">", ">=", "==", "!="]. Default to "==".
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def statistics(self) -> Optional[str]:
        """
        Critical level alarm statistics method. It must be consistent with that defined for metrics. Valid values: ["Average", "Minimum", "Maximum", "Value", "ErrorCodeMaximum", "Sum", "Count"]. Default to "Average".
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> Optional[str]:
        """
        Critical level alarm threshold value, which must be a numeric value currently.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def times(self) -> Optional[int]:
        """
        Critical level alarm retry times. Default to 3.
        """
        return pulumi.get(self, "times")


@pulumi.output_type
class AlarmEscalationsInfo(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "comparisonOperator":
            suggest = "comparison_operator"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AlarmEscalationsInfo. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AlarmEscalationsInfo.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AlarmEscalationsInfo.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 comparison_operator: Optional[str] = None,
                 statistics: Optional[str] = None,
                 threshold: Optional[str] = None,
                 times: Optional[int] = None):
        """
        :param str comparison_operator: Critical level alarm comparison operator. Valid values: ["<=", "<", ">", ">=", "==", "!="]. Default to "==".
        :param str statistics: Critical level alarm statistics method. It must be consistent with that defined for metrics. Valid values: ["Average", "Minimum", "Maximum", "Value", "ErrorCodeMaximum", "Sum", "Count"]. Default to "Average".
        :param str threshold: Critical level alarm threshold value, which must be a numeric value currently.
        :param int times: Critical level alarm retry times. Default to 3.
        """
        if comparison_operator is not None:
            pulumi.set(__self__, "comparison_operator", comparison_operator)
        if statistics is not None:
            pulumi.set(__self__, "statistics", statistics)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)
        if times is not None:
            pulumi.set(__self__, "times", times)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> Optional[str]:
        """
        Critical level alarm comparison operator. Valid values: ["<=", "<", ">", ">=", "==", "!="]. Default to "==".
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def statistics(self) -> Optional[str]:
        """
        Critical level alarm statistics method. It must be consistent with that defined for metrics. Valid values: ["Average", "Minimum", "Maximum", "Value", "ErrorCodeMaximum", "Sum", "Count"]. Default to "Average".
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> Optional[str]:
        """
        Critical level alarm threshold value, which must be a numeric value currently.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def times(self) -> Optional[int]:
        """
        Critical level alarm retry times. Default to 3.
        """
        return pulumi.get(self, "times")


@pulumi.output_type
class AlarmEscalationsWarn(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "comparisonOperator":
            suggest = "comparison_operator"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AlarmEscalationsWarn. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AlarmEscalationsWarn.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AlarmEscalationsWarn.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 comparison_operator: Optional[str] = None,
                 statistics: Optional[str] = None,
                 threshold: Optional[str] = None,
                 times: Optional[int] = None):
        """
        :param str comparison_operator: Critical level alarm comparison operator. Valid values: ["<=", "<", ">", ">=", "==", "!="]. Default to "==".
        :param str statistics: Critical level alarm statistics method. It must be consistent with that defined for metrics. Valid values: ["Average", "Minimum", "Maximum", "Value", "ErrorCodeMaximum", "Sum", "Count"]. Default to "Average".
        :param str threshold: Critical level alarm threshold value, which must be a numeric value currently.
        :param int times: Critical level alarm retry times. Default to 3.
        """
        if comparison_operator is not None:
            pulumi.set(__self__, "comparison_operator", comparison_operator)
        if statistics is not None:
            pulumi.set(__self__, "statistics", statistics)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)
        if times is not None:
            pulumi.set(__self__, "times", times)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> Optional[str]:
        """
        Critical level alarm comparison operator. Valid values: ["<=", "<", ">", ">=", "==", "!="]. Default to "==".
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def statistics(self) -> Optional[str]:
        """
        Critical level alarm statistics method. It must be consistent with that defined for metrics. Valid values: ["Average", "Minimum", "Maximum", "Value", "ErrorCodeMaximum", "Sum", "Count"]. Default to "Average".
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> Optional[str]:
        """
        Critical level alarm threshold value, which must be a numeric value currently.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def times(self) -> Optional[int]:
        """
        Critical level alarm retry times. Default to 3.
        """
        return pulumi.get(self, "times")


@pulumi.output_type
class DynamicTagGroupMatchExpress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "tagValue":
            suggest = "tag_value"
        elif key == "tagValueMatchFunction":
            suggest = "tag_value_match_function"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DynamicTagGroupMatchExpress. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DynamicTagGroupMatchExpress.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DynamicTagGroupMatchExpress.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 tag_value: str,
                 tag_value_match_function: str):
        """
        :param str tag_value: The tag value. The Tag value must be used in conjunction with the tag value matching method TagValueMatchFunction.
        :param str tag_value_match_function: Matching method of tag value. Valid values: `all`, `startWith`,`endWith`,`contains`,`notContains`,`equals`.
        """
        pulumi.set(__self__, "tag_value", tag_value)
        pulumi.set(__self__, "tag_value_match_function", tag_value_match_function)

    @property
    @pulumi.getter(name="tagValue")
    def tag_value(self) -> str:
        """
        The tag value. The Tag value must be used in conjunction with the tag value matching method TagValueMatchFunction.
        """
        return pulumi.get(self, "tag_value")

    @property
    @pulumi.getter(name="tagValueMatchFunction")
    def tag_value_match_function(self) -> str:
        """
        Matching method of tag value. Valid values: `all`, `startWith`,`endWith`,`contains`,`notContains`,`equals`.
        """
        return pulumi.get(self, "tag_value_match_function")


@pulumi.output_type
class GroupMetricRuleEscalations(dict):
    def __init__(__self__, *,
                 critical: Optional['outputs.GroupMetricRuleEscalationsCritical'] = None,
                 info: Optional['outputs.GroupMetricRuleEscalationsInfo'] = None,
                 warn: Optional['outputs.GroupMetricRuleEscalationsWarn'] = None):
        """
        :param 'GroupMetricRuleEscalationsCriticalArgs' critical: The critical level.
        :param 'GroupMetricRuleEscalationsInfoArgs' info: The info level.
        :param 'GroupMetricRuleEscalationsWarnArgs' warn: The warn level.
        """
        if critical is not None:
            pulumi.set(__self__, "critical", critical)
        if info is not None:
            pulumi.set(__self__, "info", info)
        if warn is not None:
            pulumi.set(__self__, "warn", warn)

    @property
    @pulumi.getter
    def critical(self) -> Optional['outputs.GroupMetricRuleEscalationsCritical']:
        """
        The critical level.
        """
        return pulumi.get(self, "critical")

    @property
    @pulumi.getter
    def info(self) -> Optional['outputs.GroupMetricRuleEscalationsInfo']:
        """
        The info level.
        """
        return pulumi.get(self, "info")

    @property
    @pulumi.getter
    def warn(self) -> Optional['outputs.GroupMetricRuleEscalationsWarn']:
        """
        The warn level.
        """
        return pulumi.get(self, "warn")


@pulumi.output_type
class GroupMetricRuleEscalationsCritical(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "comparisonOperator":
            suggest = "comparison_operator"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GroupMetricRuleEscalationsCritical. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GroupMetricRuleEscalationsCritical.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GroupMetricRuleEscalationsCritical.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 comparison_operator: Optional[str] = None,
                 statistics: Optional[str] = None,
                 threshold: Optional[str] = None,
                 times: Optional[int] = None):
        """
        :param str comparison_operator: The comparison operator of the threshold for warn-level alerts.
        :param str statistics: The statistical aggregation method for warn-level alerts.
        :param str threshold: The threshold for warn-level alerts.
        :param int times: The consecutive number of times for which the metric value is measured before a warn-level alert is triggered.
        """
        if comparison_operator is not None:
            pulumi.set(__self__, "comparison_operator", comparison_operator)
        if statistics is not None:
            pulumi.set(__self__, "statistics", statistics)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)
        if times is not None:
            pulumi.set(__self__, "times", times)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> Optional[str]:
        """
        The comparison operator of the threshold for warn-level alerts.
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def statistics(self) -> Optional[str]:
        """
        The statistical aggregation method for warn-level alerts.
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> Optional[str]:
        """
        The threshold for warn-level alerts.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def times(self) -> Optional[int]:
        """
        The consecutive number of times for which the metric value is measured before a warn-level alert is triggered.
        """
        return pulumi.get(self, "times")


@pulumi.output_type
class GroupMetricRuleEscalationsInfo(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "comparisonOperator":
            suggest = "comparison_operator"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GroupMetricRuleEscalationsInfo. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GroupMetricRuleEscalationsInfo.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GroupMetricRuleEscalationsInfo.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 comparison_operator: Optional[str] = None,
                 statistics: Optional[str] = None,
                 threshold: Optional[str] = None,
                 times: Optional[int] = None):
        """
        :param str comparison_operator: The comparison operator of the threshold for warn-level alerts.
        :param str statistics: The statistical aggregation method for warn-level alerts.
        :param str threshold: The threshold for warn-level alerts.
        :param int times: The consecutive number of times for which the metric value is measured before a warn-level alert is triggered.
        """
        if comparison_operator is not None:
            pulumi.set(__self__, "comparison_operator", comparison_operator)
        if statistics is not None:
            pulumi.set(__self__, "statistics", statistics)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)
        if times is not None:
            pulumi.set(__self__, "times", times)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> Optional[str]:
        """
        The comparison operator of the threshold for warn-level alerts.
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def statistics(self) -> Optional[str]:
        """
        The statistical aggregation method for warn-level alerts.
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> Optional[str]:
        """
        The threshold for warn-level alerts.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def times(self) -> Optional[int]:
        """
        The consecutive number of times for which the metric value is measured before a warn-level alert is triggered.
        """
        return pulumi.get(self, "times")


@pulumi.output_type
class GroupMetricRuleEscalationsWarn(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "comparisonOperator":
            suggest = "comparison_operator"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GroupMetricRuleEscalationsWarn. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GroupMetricRuleEscalationsWarn.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GroupMetricRuleEscalationsWarn.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 comparison_operator: Optional[str] = None,
                 statistics: Optional[str] = None,
                 threshold: Optional[str] = None,
                 times: Optional[int] = None):
        """
        :param str comparison_operator: The comparison operator of the threshold for warn-level alerts.
        :param str statistics: The statistical aggregation method for warn-level alerts.
        :param str threshold: The threshold for warn-level alerts.
        :param int times: The consecutive number of times for which the metric value is measured before a warn-level alert is triggered.
        """
        if comparison_operator is not None:
            pulumi.set(__self__, "comparison_operator", comparison_operator)
        if statistics is not None:
            pulumi.set(__self__, "statistics", statistics)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)
        if times is not None:
            pulumi.set(__self__, "times", times)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> Optional[str]:
        """
        The comparison operator of the threshold for warn-level alerts.
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def statistics(self) -> Optional[str]:
        """
        The statistical aggregation method for warn-level alerts.
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> Optional[str]:
        """
        The threshold for warn-level alerts.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def times(self) -> Optional[int]:
        """
        The consecutive number of times for which the metric value is measured before a warn-level alert is triggered.
        """
        return pulumi.get(self, "times")


@pulumi.output_type
class MetricRuleTemplateAlertTemplate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "metricName":
            suggest = "metric_name"
        elif key == "ruleName":
            suggest = "rule_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MetricRuleTemplateAlertTemplate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MetricRuleTemplateAlertTemplate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MetricRuleTemplateAlertTemplate.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 category: str,
                 metric_name: str,
                 namespace: str,
                 rule_name: str,
                 escalations: Optional['outputs.MetricRuleTemplateAlertTemplateEscalations'] = None,
                 webhook: Optional[str] = None):
        """
        :param str category: The abbreviation of the service name. Valid values: `ecs`, `rds`, `ads`, `slb`, `vpc`, `apigateway`, `cdn`, `cs`, `dcdn`, `ddos`, `eip`, `elasticsearch`, `emr`, `ess`, `hbase`, `iot_edge`, `kvstore_sharding`, `kvstore_splitrw`, `kvstore_standard`, `memcache`, `mns`, `mongodb`, `mongodb_cluster`, `mongodb_sharding`, `mq_topic`, `ocs`, `opensearch`, `oss`, `polardb`, `petadata`, `scdn`, `sharebandwidthpackages`, `sls`, `vpn`.
        :param str metric_name: The name of the metric.
        :param str namespace: The namespace of the service.
        :param str rule_name: The name of the alert rule.
        :param 'MetricRuleTemplateAlertTemplateEscalationsArgs' escalations: The information about the trigger condition based on the alert level. See the following `Block escalations`.
        :param str webhook: The callback URL to which a POST request is sent when an alert is triggered based on the alert rule.
        """
        pulumi.set(__self__, "category", category)
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "rule_name", rule_name)
        if escalations is not None:
            pulumi.set(__self__, "escalations", escalations)
        if webhook is not None:
            pulumi.set(__self__, "webhook", webhook)

    @property
    @pulumi.getter
    def category(self) -> str:
        """
        The abbreviation of the service name. Valid values: `ecs`, `rds`, `ads`, `slb`, `vpc`, `apigateway`, `cdn`, `cs`, `dcdn`, `ddos`, `eip`, `elasticsearch`, `emr`, `ess`, `hbase`, `iot_edge`, `kvstore_sharding`, `kvstore_splitrw`, `kvstore_standard`, `memcache`, `mns`, `mongodb`, `mongodb_cluster`, `mongodb_sharding`, `mq_topic`, `ocs`, `opensearch`, `oss`, `polardb`, `petadata`, `scdn`, `sharebandwidthpackages`, `sls`, `vpn`.
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> str:
        """
        The name of the metric.
        """
        return pulumi.get(self, "metric_name")

    @property
    @pulumi.getter
    def namespace(self) -> str:
        """
        The namespace of the service.
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter(name="ruleName")
    def rule_name(self) -> str:
        """
        The name of the alert rule.
        """
        return pulumi.get(self, "rule_name")

    @property
    @pulumi.getter
    def escalations(self) -> Optional['outputs.MetricRuleTemplateAlertTemplateEscalations']:
        """
        The information about the trigger condition based on the alert level. See the following `Block escalations`.
        """
        return pulumi.get(self, "escalations")

    @property
    @pulumi.getter
    def webhook(self) -> Optional[str]:
        """
        The callback URL to which a POST request is sent when an alert is triggered based on the alert rule.
        """
        return pulumi.get(self, "webhook")


@pulumi.output_type
class MetricRuleTemplateAlertTemplateEscalations(dict):
    def __init__(__self__, *,
                 critical: Optional['outputs.MetricRuleTemplateAlertTemplateEscalationsCritical'] = None,
                 info: Optional['outputs.MetricRuleTemplateAlertTemplateEscalationsInfo'] = None,
                 warn: Optional['outputs.MetricRuleTemplateAlertTemplateEscalationsWarn'] = None):
        """
        :param 'MetricRuleTemplateAlertTemplateEscalationsCriticalArgs' critical: The condition for triggering critical-level alerts. See the following `Block critical`.
        :param 'MetricRuleTemplateAlertTemplateEscalationsInfoArgs' info: The condition for triggering info-level alerts. See the following `Block info`.
        :param 'MetricRuleTemplateAlertTemplateEscalationsWarnArgs' warn: The condition for triggering warn-level alerts. See the following `Block warn`.
        """
        if critical is not None:
            pulumi.set(__self__, "critical", critical)
        if info is not None:
            pulumi.set(__self__, "info", info)
        if warn is not None:
            pulumi.set(__self__, "warn", warn)

    @property
    @pulumi.getter
    def critical(self) -> Optional['outputs.MetricRuleTemplateAlertTemplateEscalationsCritical']:
        """
        The condition for triggering critical-level alerts. See the following `Block critical`.
        """
        return pulumi.get(self, "critical")

    @property
    @pulumi.getter
    def info(self) -> Optional['outputs.MetricRuleTemplateAlertTemplateEscalationsInfo']:
        """
        The condition for triggering info-level alerts. See the following `Block info`.
        """
        return pulumi.get(self, "info")

    @property
    @pulumi.getter
    def warn(self) -> Optional['outputs.MetricRuleTemplateAlertTemplateEscalationsWarn']:
        """
        The condition for triggering warn-level alerts. See the following `Block warn`.
        """
        return pulumi.get(self, "warn")


@pulumi.output_type
class MetricRuleTemplateAlertTemplateEscalationsCritical(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "comparisonOperator":
            suggest = "comparison_operator"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MetricRuleTemplateAlertTemplateEscalationsCritical. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MetricRuleTemplateAlertTemplateEscalationsCritical.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MetricRuleTemplateAlertTemplateEscalationsCritical.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 comparison_operator: Optional[str] = None,
                 statistics: Optional[str] = None,
                 threshold: Optional[str] = None,
                 times: Optional[str] = None):
        """
        :param str comparison_operator: The comparison operator of the threshold for critical-level alerts. Valid values: `GreaterThanOrEqualToThreshold`, `GreaterThanThreshold`, `LessThanOrEqualToThreshold`, `LessThanThreshold`, `NotEqualToThreshold`, `GreaterThanYesterday`, `LessThanYesterday`, `GreaterThanLastWeek`, `LessThanLastWeek`, `GreaterThanLastPeriod`, `LessThanLastPeriod`.
        :param str statistics: The statistical aggregation method for critical-level alerts.
        :param str threshold: The threshold for critical-level alerts.
        :param str times: The consecutive number of times for which the metric value is measured before a critical-level alert is triggered.
        """
        if comparison_operator is not None:
            pulumi.set(__self__, "comparison_operator", comparison_operator)
        if statistics is not None:
            pulumi.set(__self__, "statistics", statistics)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)
        if times is not None:
            pulumi.set(__self__, "times", times)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> Optional[str]:
        """
        The comparison operator of the threshold for critical-level alerts. Valid values: `GreaterThanOrEqualToThreshold`, `GreaterThanThreshold`, `LessThanOrEqualToThreshold`, `LessThanThreshold`, `NotEqualToThreshold`, `GreaterThanYesterday`, `LessThanYesterday`, `GreaterThanLastWeek`, `LessThanLastWeek`, `GreaterThanLastPeriod`, `LessThanLastPeriod`.
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def statistics(self) -> Optional[str]:
        """
        The statistical aggregation method for critical-level alerts.
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> Optional[str]:
        """
        The threshold for critical-level alerts.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def times(self) -> Optional[str]:
        """
        The consecutive number of times for which the metric value is measured before a critical-level alert is triggered.
        """
        return pulumi.get(self, "times")


@pulumi.output_type
class MetricRuleTemplateAlertTemplateEscalationsInfo(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "comparisonOperator":
            suggest = "comparison_operator"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MetricRuleTemplateAlertTemplateEscalationsInfo. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MetricRuleTemplateAlertTemplateEscalationsInfo.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MetricRuleTemplateAlertTemplateEscalationsInfo.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 comparison_operator: Optional[str] = None,
                 statistics: Optional[str] = None,
                 threshold: Optional[str] = None,
                 times: Optional[str] = None):
        """
        :param str comparison_operator: The comparison operator of the threshold for critical-level alerts. Valid values: `GreaterThanOrEqualToThreshold`, `GreaterThanThreshold`, `LessThanOrEqualToThreshold`, `LessThanThreshold`, `NotEqualToThreshold`, `GreaterThanYesterday`, `LessThanYesterday`, `GreaterThanLastWeek`, `LessThanLastWeek`, `GreaterThanLastPeriod`, `LessThanLastPeriod`.
        :param str statistics: The statistical aggregation method for critical-level alerts.
        :param str threshold: The threshold for critical-level alerts.
        :param str times: The consecutive number of times for which the metric value is measured before a critical-level alert is triggered.
        """
        if comparison_operator is not None:
            pulumi.set(__self__, "comparison_operator", comparison_operator)
        if statistics is not None:
            pulumi.set(__self__, "statistics", statistics)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)
        if times is not None:
            pulumi.set(__self__, "times", times)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> Optional[str]:
        """
        The comparison operator of the threshold for critical-level alerts. Valid values: `GreaterThanOrEqualToThreshold`, `GreaterThanThreshold`, `LessThanOrEqualToThreshold`, `LessThanThreshold`, `NotEqualToThreshold`, `GreaterThanYesterday`, `LessThanYesterday`, `GreaterThanLastWeek`, `LessThanLastWeek`, `GreaterThanLastPeriod`, `LessThanLastPeriod`.
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def statistics(self) -> Optional[str]:
        """
        The statistical aggregation method for critical-level alerts.
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> Optional[str]:
        """
        The threshold for critical-level alerts.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def times(self) -> Optional[str]:
        """
        The consecutive number of times for which the metric value is measured before a critical-level alert is triggered.
        """
        return pulumi.get(self, "times")


@pulumi.output_type
class MetricRuleTemplateAlertTemplateEscalationsWarn(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "comparisonOperator":
            suggest = "comparison_operator"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MetricRuleTemplateAlertTemplateEscalationsWarn. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MetricRuleTemplateAlertTemplateEscalationsWarn.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MetricRuleTemplateAlertTemplateEscalationsWarn.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 comparison_operator: Optional[str] = None,
                 statistics: Optional[str] = None,
                 threshold: Optional[str] = None,
                 times: Optional[str] = None):
        """
        :param str comparison_operator: The comparison operator of the threshold for critical-level alerts. Valid values: `GreaterThanOrEqualToThreshold`, `GreaterThanThreshold`, `LessThanOrEqualToThreshold`, `LessThanThreshold`, `NotEqualToThreshold`, `GreaterThanYesterday`, `LessThanYesterday`, `GreaterThanLastWeek`, `LessThanLastWeek`, `GreaterThanLastPeriod`, `LessThanLastPeriod`.
        :param str statistics: The statistical aggregation method for critical-level alerts.
        :param str threshold: The threshold for critical-level alerts.
        :param str times: The consecutive number of times for which the metric value is measured before a critical-level alert is triggered.
        """
        if comparison_operator is not None:
            pulumi.set(__self__, "comparison_operator", comparison_operator)
        if statistics is not None:
            pulumi.set(__self__, "statistics", statistics)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)
        if times is not None:
            pulumi.set(__self__, "times", times)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> Optional[str]:
        """
        The comparison operator of the threshold for critical-level alerts. Valid values: `GreaterThanOrEqualToThreshold`, `GreaterThanThreshold`, `LessThanOrEqualToThreshold`, `LessThanThreshold`, `NotEqualToThreshold`, `GreaterThanYesterday`, `LessThanYesterday`, `GreaterThanLastWeek`, `LessThanLastWeek`, `GreaterThanLastPeriod`, `LessThanLastPeriod`.
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def statistics(self) -> Optional[str]:
        """
        The statistical aggregation method for critical-level alerts.
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> Optional[str]:
        """
        The threshold for critical-level alerts.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def times(self) -> Optional[str]:
        """
        The consecutive number of times for which the metric value is measured before a critical-level alert is triggered.
        """
        return pulumi.get(self, "times")


@pulumi.output_type
class MonitorGroupInstancesInstance(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceId":
            suggest = "instance_id"
        elif key == "instanceName":
            suggest = "instance_name"
        elif key == "regionId":
            suggest = "region_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MonitorGroupInstancesInstance. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MonitorGroupInstancesInstance.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MonitorGroupInstancesInstance.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 category: str,
                 instance_id: str,
                 instance_name: str,
                 region_id: str):
        """
        :param str category: The category of instance.
        :param str instance_id: The id of instance.
        :param str instance_name: The name of instance.
        :param str region_id: The region id of instance.
        """
        pulumi.set(__self__, "category", category)
        pulumi.set(__self__, "instance_id", instance_id)
        pulumi.set(__self__, "instance_name", instance_name)
        pulumi.set(__self__, "region_id", region_id)

    @property
    @pulumi.getter
    def category(self) -> str:
        """
        The category of instance.
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> str:
        """
        The id of instance.
        """
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter(name="instanceName")
    def instance_name(self) -> str:
        """
        The name of instance.
        """
        return pulumi.get(self, "instance_name")

    @property
    @pulumi.getter(name="regionId")
    def region_id(self) -> str:
        """
        The region id of instance.
        """
        return pulumi.get(self, "region_id")


@pulumi.output_type
class SiteMonitorIspCity(dict):
    def __init__(__self__, *,
                 city: str,
                 isp: str):
        pulumi.set(__self__, "city", city)
        pulumi.set(__self__, "isp", isp)

    @property
    @pulumi.getter
    def city(self) -> str:
        return pulumi.get(self, "city")

    @property
    @pulumi.getter
    def isp(self) -> str:
        return pulumi.get(self, "isp")


@pulumi.output_type
class GetAlarmContactGroupsGroupResult(dict):
    def __init__(__self__, *,
                 alarm_contact_group_name: str,
                 contacts: Sequence[str],
                 describe: str,
                 enable_subscribed: bool,
                 id: str):
        """
        :param str alarm_contact_group_name: The name of Alarm Contact Group.
        :param Sequence[str] contacts: The alarm contacts in the alarm group.
        :param str describe: The description of the Alarm Group.
        :param bool enable_subscribed: Indicates whether the alarm group subscribes to weekly reports.
        :param str id: The ID of the CMS.
        """
        pulumi.set(__self__, "alarm_contact_group_name", alarm_contact_group_name)
        pulumi.set(__self__, "contacts", contacts)
        pulumi.set(__self__, "describe", describe)
        pulumi.set(__self__, "enable_subscribed", enable_subscribed)
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter(name="alarmContactGroupName")
    def alarm_contact_group_name(self) -> str:
        """
        The name of Alarm Contact Group.
        """
        return pulumi.get(self, "alarm_contact_group_name")

    @property
    @pulumi.getter
    def contacts(self) -> Sequence[str]:
        """
        The alarm contacts in the alarm group.
        """
        return pulumi.get(self, "contacts")

    @property
    @pulumi.getter
    def describe(self) -> str:
        """
        The description of the Alarm Group.
        """
        return pulumi.get(self, "describe")

    @property
    @pulumi.getter(name="enableSubscribed")
    def enable_subscribed(self) -> bool:
        """
        Indicates whether the alarm group subscribes to weekly reports.
        """
        return pulumi.get(self, "enable_subscribed")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the CMS.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetAlarmContactsContactResult(dict):
    def __init__(__self__, *,
                 alarm_contact_name: str,
                 channels_aliim: str,
                 channels_ding_web_hook: str,
                 channels_mail: str,
                 channels_sms: str,
                 channels_state_aliim: str,
                 channels_state_ding_web_hook: str,
                 channels_state_mail: str,
                 channels_status_sms: str,
                 contact_groups: Sequence[str],
                 describe: str,
                 id: str,
                 lang: str):
        """
        :param str alarm_contact_name: The name of the alarm contact.
        :param str channels_aliim: The TradeManager ID of the alarm contact.
        :param str channels_ding_web_hook: The webhook URL of the DingTalk chatbot.
        :param str channels_mail: The email address of the alarm contact.
        :param str channels_sms: The phone number of the alarm contact.
        :param str channels_state_aliim: Indicates whether the TradeManager ID is valid.
        :param str channels_state_ding_web_hook: Indicates whether the DingTalk chatbot is normal.
        :param str channels_state_mail: The status of the email address.
        :param str channels_status_sms: The status of the phone number.
        :param Sequence[str] contact_groups: The alert groups to which the alarm contact is added.
        :param str describe: The description of the alarm contact.
        :param str id: The ID of the alarm contact.
        """
        pulumi.set(__self__, "alarm_contact_name", alarm_contact_name)
        pulumi.set(__self__, "channels_aliim", channels_aliim)
        pulumi.set(__self__, "channels_ding_web_hook", channels_ding_web_hook)
        pulumi.set(__self__, "channels_mail", channels_mail)
        pulumi.set(__self__, "channels_sms", channels_sms)
        pulumi.set(__self__, "channels_state_aliim", channels_state_aliim)
        pulumi.set(__self__, "channels_state_ding_web_hook", channels_state_ding_web_hook)
        pulumi.set(__self__, "channels_state_mail", channels_state_mail)
        pulumi.set(__self__, "channels_status_sms", channels_status_sms)
        pulumi.set(__self__, "contact_groups", contact_groups)
        pulumi.set(__self__, "describe", describe)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "lang", lang)

    @property
    @pulumi.getter(name="alarmContactName")
    def alarm_contact_name(self) -> str:
        """
        The name of the alarm contact.
        """
        return pulumi.get(self, "alarm_contact_name")

    @property
    @pulumi.getter(name="channelsAliim")
    def channels_aliim(self) -> str:
        """
        The TradeManager ID of the alarm contact.
        """
        return pulumi.get(self, "channels_aliim")

    @property
    @pulumi.getter(name="channelsDingWebHook")
    def channels_ding_web_hook(self) -> str:
        """
        The webhook URL of the DingTalk chatbot.
        """
        return pulumi.get(self, "channels_ding_web_hook")

    @property
    @pulumi.getter(name="channelsMail")
    def channels_mail(self) -> str:
        """
        The email address of the alarm contact.
        """
        return pulumi.get(self, "channels_mail")

    @property
    @pulumi.getter(name="channelsSms")
    def channels_sms(self) -> str:
        """
        The phone number of the alarm contact.
        """
        return pulumi.get(self, "channels_sms")

    @property
    @pulumi.getter(name="channelsStateAliim")
    def channels_state_aliim(self) -> str:
        """
        Indicates whether the TradeManager ID is valid.
        """
        return pulumi.get(self, "channels_state_aliim")

    @property
    @pulumi.getter(name="channelsStateDingWebHook")
    def channels_state_ding_web_hook(self) -> str:
        """
        Indicates whether the DingTalk chatbot is normal.
        """
        return pulumi.get(self, "channels_state_ding_web_hook")

    @property
    @pulumi.getter(name="channelsStateMail")
    def channels_state_mail(self) -> str:
        """
        The status of the email address.
        """
        return pulumi.get(self, "channels_state_mail")

    @property
    @pulumi.getter(name="channelsStatusSms")
    def channels_status_sms(self) -> str:
        """
        The status of the phone number.
        """
        return pulumi.get(self, "channels_status_sms")

    @property
    @pulumi.getter(name="contactGroups")
    def contact_groups(self) -> Sequence[str]:
        """
        The alert groups to which the alarm contact is added.
        """
        return pulumi.get(self, "contact_groups")

    @property
    @pulumi.getter
    def describe(self) -> str:
        """
        The description of the alarm contact.
        """
        return pulumi.get(self, "describe")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the alarm contact.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def lang(self) -> str:
        return pulumi.get(self, "lang")


@pulumi.output_type
class GetDynamicTagGroupsGroupResult(dict):
    def __init__(__self__, *,
                 dynamic_tag_rule_id: str,
                 id: str,
                 match_express_filter_relation: str,
                 match_expresses: Sequence['outputs.GetDynamicTagGroupsGroupMatchExpressResult'],
                 status: str,
                 tag_key: str):
        """
        :param str dynamic_tag_rule_id: The ID of the tag rule.
        :param str id: The ID of the Dynamic Tag Group.
        :param str match_express_filter_relation: The relationship between conditional expressions. Valid values: `and`, `or`.
        :param Sequence['GetDynamicTagGroupsGroupMatchExpressArgs'] match_expresses: The label generates a matching expression that applies the grouping. See the following `Block match_express`.
        :param str status: The status of the resource. Valid values: `RUNNING`, `FINISH`.
        :param str tag_key: The tag key of the tag.
        """
        pulumi.set(__self__, "dynamic_tag_rule_id", dynamic_tag_rule_id)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "match_express_filter_relation", match_express_filter_relation)
        pulumi.set(__self__, "match_expresses", match_expresses)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tag_key", tag_key)

    @property
    @pulumi.getter(name="dynamicTagRuleId")
    def dynamic_tag_rule_id(self) -> str:
        """
        The ID of the tag rule.
        """
        return pulumi.get(self, "dynamic_tag_rule_id")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Dynamic Tag Group.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="matchExpressFilterRelation")
    def match_express_filter_relation(self) -> str:
        """
        The relationship between conditional expressions. Valid values: `and`, `or`.
        """
        return pulumi.get(self, "match_express_filter_relation")

    @property
    @pulumi.getter(name="matchExpresses")
    def match_expresses(self) -> Sequence['outputs.GetDynamicTagGroupsGroupMatchExpressResult']:
        """
        The label generates a matching expression that applies the grouping. See the following `Block match_express`.
        """
        return pulumi.get(self, "match_expresses")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the resource. Valid values: `RUNNING`, `FINISH`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="tagKey")
    def tag_key(self) -> str:
        """
        The tag key of the tag.
        """
        return pulumi.get(self, "tag_key")


@pulumi.output_type
class GetDynamicTagGroupsGroupMatchExpressResult(dict):
    def __init__(__self__, *,
                 tag_value: str,
                 tag_value_match_function: str):
        """
        :param str tag_value: The tag value. The Tag value must be used in conjunction with the tag value matching method TagValueMatchFunction.
        :param str tag_value_match_function: Matching method of tag value. Valid values: `all`, `startWith`,`endWith`,`contains`,`notContains`,`equals`.
        """
        pulumi.set(__self__, "tag_value", tag_value)
        pulumi.set(__self__, "tag_value_match_function", tag_value_match_function)

    @property
    @pulumi.getter(name="tagValue")
    def tag_value(self) -> str:
        """
        The tag value. The Tag value must be used in conjunction with the tag value matching method TagValueMatchFunction.
        """
        return pulumi.get(self, "tag_value")

    @property
    @pulumi.getter(name="tagValueMatchFunction")
    def tag_value_match_function(self) -> str:
        """
        Matching method of tag value. Valid values: `all`, `startWith`,`endWith`,`contains`,`notContains`,`equals`.
        """
        return pulumi.get(self, "tag_value_match_function")


@pulumi.output_type
class GetGroupMetricRulesRuleResult(dict):
    def __init__(__self__, *,
                 contact_groups: str,
                 dimensions: str,
                 effective_interval: str,
                 email_subject: str,
                 enable_state: bool,
                 escalations: Sequence['outputs.GetGroupMetricRulesRuleEscalationResult'],
                 group_id: str,
                 group_metric_rule_name: str,
                 id: str,
                 metric_name: str,
                 namespace: str,
                 no_effective_interval: str,
                 period: int,
                 resources: str,
                 rule_id: str,
                 silence_time: int,
                 source_type: str,
                 status: str,
                 webhook: str):
        """
        :param str contact_groups: Alarm contact group.
        :param str dimensions: The dimensions that specify the resources to be associated with the alert rule.
        :param str effective_interval: The time period during which the alert rule is effective.
        :param str email_subject: The subject of the alert notification email.
        :param bool enable_state: Indicates whether the alert rule is enabled.
        :param Sequence['GetGroupMetricRulesRuleEscalationArgs'] escalations: Alarm level.
        :param str group_id: The ID of the application group.
        :param str group_metric_rule_name: The name of the alert rule.
        :param str id: The ID of the Group Metric Rule.
        :param str metric_name: The name of the metric.
        :param str namespace: The namespace of the service.
        :param str no_effective_interval: The time period during which the alert rule is ineffective.
        :param int period: The aggregation period of the monitoring data. Unit: seconds. The value is an integral multiple of 60. Default value: `300`.
        :param str resources: The resources that are associated with the alert rule.
        :param str rule_id: The ID of the alert rule.
        :param int silence_time: The mute period during which new alerts are not reported even if the alert trigger conditions are met. Unit: seconds. Default value: `86400`, which is equivalent to one day.
        :param str source_type: The type of the alert rule. The value is fixed to METRIC, indicating an alert rule for time series metrics.
        :param str status: The status of Group Metric Rule..
        :param str webhook: The callback URL.
        """
        pulumi.set(__self__, "contact_groups", contact_groups)
        pulumi.set(__self__, "dimensions", dimensions)
        pulumi.set(__self__, "effective_interval", effective_interval)
        pulumi.set(__self__, "email_subject", email_subject)
        pulumi.set(__self__, "enable_state", enable_state)
        pulumi.set(__self__, "escalations", escalations)
        pulumi.set(__self__, "group_id", group_id)
        pulumi.set(__self__, "group_metric_rule_name", group_metric_rule_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "no_effective_interval", no_effective_interval)
        pulumi.set(__self__, "period", period)
        pulumi.set(__self__, "resources", resources)
        pulumi.set(__self__, "rule_id", rule_id)
        pulumi.set(__self__, "silence_time", silence_time)
        pulumi.set(__self__, "source_type", source_type)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "webhook", webhook)

    @property
    @pulumi.getter(name="contactGroups")
    def contact_groups(self) -> str:
        """
        Alarm contact group.
        """
        return pulumi.get(self, "contact_groups")

    @property
    @pulumi.getter
    def dimensions(self) -> str:
        """
        The dimensions that specify the resources to be associated with the alert rule.
        """
        return pulumi.get(self, "dimensions")

    @property
    @pulumi.getter(name="effectiveInterval")
    def effective_interval(self) -> str:
        """
        The time period during which the alert rule is effective.
        """
        return pulumi.get(self, "effective_interval")

    @property
    @pulumi.getter(name="emailSubject")
    def email_subject(self) -> str:
        """
        The subject of the alert notification email.
        """
        return pulumi.get(self, "email_subject")

    @property
    @pulumi.getter(name="enableState")
    def enable_state(self) -> bool:
        """
        Indicates whether the alert rule is enabled.
        """
        return pulumi.get(self, "enable_state")

    @property
    @pulumi.getter
    def escalations(self) -> Sequence['outputs.GetGroupMetricRulesRuleEscalationResult']:
        """
        Alarm level.
        """
        return pulumi.get(self, "escalations")

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> str:
        """
        The ID of the application group.
        """
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter(name="groupMetricRuleName")
    def group_metric_rule_name(self) -> str:
        """
        The name of the alert rule.
        """
        return pulumi.get(self, "group_metric_rule_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Group Metric Rule.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> str:
        """
        The name of the metric.
        """
        return pulumi.get(self, "metric_name")

    @property
    @pulumi.getter
    def namespace(self) -> str:
        """
        The namespace of the service.
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter(name="noEffectiveInterval")
    def no_effective_interval(self) -> str:
        """
        The time period during which the alert rule is ineffective.
        """
        return pulumi.get(self, "no_effective_interval")

    @property
    @pulumi.getter
    def period(self) -> int:
        """
        The aggregation period of the monitoring data. Unit: seconds. The value is an integral multiple of 60. Default value: `300`.
        """
        return pulumi.get(self, "period")

    @property
    @pulumi.getter
    def resources(self) -> str:
        """
        The resources that are associated with the alert rule.
        """
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter(name="ruleId")
    def rule_id(self) -> str:
        """
        The ID of the alert rule.
        """
        return pulumi.get(self, "rule_id")

    @property
    @pulumi.getter(name="silenceTime")
    def silence_time(self) -> int:
        """
        The mute period during which new alerts are not reported even if the alert trigger conditions are met. Unit: seconds. Default value: `86400`, which is equivalent to one day.
        """
        return pulumi.get(self, "silence_time")

    @property
    @pulumi.getter(name="sourceType")
    def source_type(self) -> str:
        """
        The type of the alert rule. The value is fixed to METRIC, indicating an alert rule for time series metrics.
        """
        return pulumi.get(self, "source_type")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of Group Metric Rule..
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter
    def webhook(self) -> str:
        """
        The callback URL.
        """
        return pulumi.get(self, "webhook")


@pulumi.output_type
class GetGroupMetricRulesRuleEscalationResult(dict):
    def __init__(__self__, *,
                 criticals: Sequence['outputs.GetGroupMetricRulesRuleEscalationCriticalResult'],
                 infos: Sequence['outputs.GetGroupMetricRulesRuleEscalationInfoResult'],
                 warns: Sequence['outputs.GetGroupMetricRulesRuleEscalationWarnResult']):
        """
        :param Sequence['GetGroupMetricRulesRuleEscalationCriticalArgs'] criticals: The critical level.
        :param Sequence['GetGroupMetricRulesRuleEscalationInfoArgs'] infos: The info level.
        :param Sequence['GetGroupMetricRulesRuleEscalationWarnArgs'] warns: The warn level.
        """
        pulumi.set(__self__, "criticals", criticals)
        pulumi.set(__self__, "infos", infos)
        pulumi.set(__self__, "warns", warns)

    @property
    @pulumi.getter
    def criticals(self) -> Sequence['outputs.GetGroupMetricRulesRuleEscalationCriticalResult']:
        """
        The critical level.
        """
        return pulumi.get(self, "criticals")

    @property
    @pulumi.getter
    def infos(self) -> Sequence['outputs.GetGroupMetricRulesRuleEscalationInfoResult']:
        """
        The info level.
        """
        return pulumi.get(self, "infos")

    @property
    @pulumi.getter
    def warns(self) -> Sequence['outputs.GetGroupMetricRulesRuleEscalationWarnResult']:
        """
        The warn level.
        """
        return pulumi.get(self, "warns")


@pulumi.output_type
class GetGroupMetricRulesRuleEscalationCriticalResult(dict):
    def __init__(__self__, *,
                 comparison_operator: str,
                 statistics: str,
                 threshold: str,
                 times: int):
        """
        :param str comparison_operator: The comparison operator of the threshold for warn-level alerts.
        :param str statistics: The statistical aggregation method for warn-level alerts.
        :param str threshold: The threshold for warn-level alerts.
        :param int times: The consecutive number of times for which the metric value is measured before a warn-level alert is triggered.
        """
        pulumi.set(__self__, "comparison_operator", comparison_operator)
        pulumi.set(__self__, "statistics", statistics)
        pulumi.set(__self__, "threshold", threshold)
        pulumi.set(__self__, "times", times)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> str:
        """
        The comparison operator of the threshold for warn-level alerts.
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def statistics(self) -> str:
        """
        The statistical aggregation method for warn-level alerts.
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> str:
        """
        The threshold for warn-level alerts.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def times(self) -> int:
        """
        The consecutive number of times for which the metric value is measured before a warn-level alert is triggered.
        """
        return pulumi.get(self, "times")


@pulumi.output_type
class GetGroupMetricRulesRuleEscalationInfoResult(dict):
    def __init__(__self__, *,
                 comparison_operator: str,
                 statistics: str,
                 threshold: str,
                 times: int):
        """
        :param str comparison_operator: The comparison operator of the threshold for warn-level alerts.
        :param str statistics: The statistical aggregation method for warn-level alerts.
        :param str threshold: The threshold for warn-level alerts.
        :param int times: The consecutive number of times for which the metric value is measured before a warn-level alert is triggered.
        """
        pulumi.set(__self__, "comparison_operator", comparison_operator)
        pulumi.set(__self__, "statistics", statistics)
        pulumi.set(__self__, "threshold", threshold)
        pulumi.set(__self__, "times", times)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> str:
        """
        The comparison operator of the threshold for warn-level alerts.
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def statistics(self) -> str:
        """
        The statistical aggregation method for warn-level alerts.
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> str:
        """
        The threshold for warn-level alerts.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def times(self) -> int:
        """
        The consecutive number of times for which the metric value is measured before a warn-level alert is triggered.
        """
        return pulumi.get(self, "times")


@pulumi.output_type
class GetGroupMetricRulesRuleEscalationWarnResult(dict):
    def __init__(__self__, *,
                 comparison_operator: str,
                 statistics: str,
                 threshold: str,
                 times: int):
        """
        :param str comparison_operator: The comparison operator of the threshold for warn-level alerts.
        :param str statistics: The statistical aggregation method for warn-level alerts.
        :param str threshold: The threshold for warn-level alerts.
        :param int times: The consecutive number of times for which the metric value is measured before a warn-level alert is triggered.
        """
        pulumi.set(__self__, "comparison_operator", comparison_operator)
        pulumi.set(__self__, "statistics", statistics)
        pulumi.set(__self__, "threshold", threshold)
        pulumi.set(__self__, "times", times)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> str:
        """
        The comparison operator of the threshold for warn-level alerts.
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def statistics(self) -> str:
        """
        The statistical aggregation method for warn-level alerts.
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> str:
        """
        The threshold for warn-level alerts.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def times(self) -> int:
        """
        The consecutive number of times for which the metric value is measured before a warn-level alert is triggered.
        """
        return pulumi.get(self, "times")


@pulumi.output_type
class GetMetricRuleTemplatesTemplateResult(dict):
    def __init__(__self__, *,
                 alert_templates: Sequence['outputs.GetMetricRuleTemplatesTemplateAlertTemplateResult'],
                 description: str,
                 group_id: str,
                 id: str,
                 metric_rule_template_name: str,
                 rest_version: str,
                 template_id: str):
        """
        :param Sequence['GetMetricRuleTemplatesTemplateAlertTemplateArgs'] alert_templates: The details of alert rules that are generated based on the alert template.
        :param str description: The description of the alert template.
        :param str group_id: GroupId.
        :param str id: The ID of the Metric Rule Template.
        :param str metric_rule_template_name: The name of the alert template.
        :param str rest_version: The version of the alert template.
        :param str template_id: The ID of the alert template.
        """
        pulumi.set(__self__, "alert_templates", alert_templates)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "group_id", group_id)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "metric_rule_template_name", metric_rule_template_name)
        pulumi.set(__self__, "rest_version", rest_version)
        pulumi.set(__self__, "template_id", template_id)

    @property
    @pulumi.getter(name="alertTemplates")
    def alert_templates(self) -> Sequence['outputs.GetMetricRuleTemplatesTemplateAlertTemplateResult']:
        """
        The details of alert rules that are generated based on the alert template.
        """
        return pulumi.get(self, "alert_templates")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        The description of the alert template.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> str:
        """
        GroupId.
        """
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Metric Rule Template.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="metricRuleTemplateName")
    def metric_rule_template_name(self) -> str:
        """
        The name of the alert template.
        """
        return pulumi.get(self, "metric_rule_template_name")

    @property
    @pulumi.getter(name="restVersion")
    def rest_version(self) -> str:
        """
        The version of the alert template.
        """
        return pulumi.get(self, "rest_version")

    @property
    @pulumi.getter(name="templateId")
    def template_id(self) -> str:
        """
        The ID of the alert template.
        """
        return pulumi.get(self, "template_id")


@pulumi.output_type
class GetMetricRuleTemplatesTemplateAlertTemplateResult(dict):
    def __init__(__self__, *,
                 category: str,
                 escalations: Sequence['outputs.GetMetricRuleTemplatesTemplateAlertTemplateEscalationResult'],
                 metric_name: str,
                 namespace: str,
                 rule_name: str,
                 selector: str,
                 webhook: str):
        """
        :param str category: The abbreviation of the service name. Valid values: `ecs`, `rds`, `ads`, `slb`, `vpc`, `apigateway`, `cdn`, `cs`, `dcdn`, `ddos`, `eip`, `elasticsearch`, `emr`, `ess`, `hbase`, `iot_edge`, `kvstore_sharding`, `kvstore_splitrw`, `kvstore_standard`, `memcache`, `mns`, `mongodb`, `mongodb_cluster`, `mongodb_sharding`, `mq_topic`, `ocs`, `opensearch`, `oss`, `polardb`, `petadata`, `scdn`, `sharebandwidthpackages`, `sls`, `vpn`.
        :param Sequence['GetMetricRuleTemplatesTemplateAlertTemplateEscalationArgs'] escalations: The information about the trigger condition based on the alert level.
        :param str metric_name: The name of the metric.
        :param str namespace: The namespace of the service.
        :param str rule_name: The name of the alert rule.
        :param str webhook: The callback URL to which a POST request is sent when an alert is triggered based on the alert rule.
        """
        pulumi.set(__self__, "category", category)
        pulumi.set(__self__, "escalations", escalations)
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "rule_name", rule_name)
        pulumi.set(__self__, "selector", selector)
        pulumi.set(__self__, "webhook", webhook)

    @property
    @pulumi.getter
    def category(self) -> str:
        """
        The abbreviation of the service name. Valid values: `ecs`, `rds`, `ads`, `slb`, `vpc`, `apigateway`, `cdn`, `cs`, `dcdn`, `ddos`, `eip`, `elasticsearch`, `emr`, `ess`, `hbase`, `iot_edge`, `kvstore_sharding`, `kvstore_splitrw`, `kvstore_standard`, `memcache`, `mns`, `mongodb`, `mongodb_cluster`, `mongodb_sharding`, `mq_topic`, `ocs`, `opensearch`, `oss`, `polardb`, `petadata`, `scdn`, `sharebandwidthpackages`, `sls`, `vpn`.
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter
    def escalations(self) -> Sequence['outputs.GetMetricRuleTemplatesTemplateAlertTemplateEscalationResult']:
        """
        The information about the trigger condition based on the alert level.
        """
        return pulumi.get(self, "escalations")

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> str:
        """
        The name of the metric.
        """
        return pulumi.get(self, "metric_name")

    @property
    @pulumi.getter
    def namespace(self) -> str:
        """
        The namespace of the service.
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter(name="ruleName")
    def rule_name(self) -> str:
        """
        The name of the alert rule.
        """
        return pulumi.get(self, "rule_name")

    @property
    @pulumi.getter
    def selector(self) -> str:
        return pulumi.get(self, "selector")

    @property
    @pulumi.getter
    def webhook(self) -> str:
        """
        The callback URL to which a POST request is sent when an alert is triggered based on the alert rule.
        """
        return pulumi.get(self, "webhook")


@pulumi.output_type
class GetMetricRuleTemplatesTemplateAlertTemplateEscalationResult(dict):
    def __init__(__self__, *,
                 criticals: Sequence['outputs.GetMetricRuleTemplatesTemplateAlertTemplateEscalationCriticalResult'],
                 infos: Sequence['outputs.GetMetricRuleTemplatesTemplateAlertTemplateEscalationInfoResult'],
                 warns: Sequence['outputs.GetMetricRuleTemplatesTemplateAlertTemplateEscalationWarnResult']):
        """
        :param Sequence['GetMetricRuleTemplatesTemplateAlertTemplateEscalationCriticalArgs'] criticals: The condition for triggering critical-level alerts.
        :param Sequence['GetMetricRuleTemplatesTemplateAlertTemplateEscalationInfoArgs'] infos: The condition for triggering info-level alerts.
        :param Sequence['GetMetricRuleTemplatesTemplateAlertTemplateEscalationWarnArgs'] warns: The condition for triggering warn-level alerts.
        """
        pulumi.set(__self__, "criticals", criticals)
        pulumi.set(__self__, "infos", infos)
        pulumi.set(__self__, "warns", warns)

    @property
    @pulumi.getter
    def criticals(self) -> Sequence['outputs.GetMetricRuleTemplatesTemplateAlertTemplateEscalationCriticalResult']:
        """
        The condition for triggering critical-level alerts.
        """
        return pulumi.get(self, "criticals")

    @property
    @pulumi.getter
    def infos(self) -> Sequence['outputs.GetMetricRuleTemplatesTemplateAlertTemplateEscalationInfoResult']:
        """
        The condition for triggering info-level alerts.
        """
        return pulumi.get(self, "infos")

    @property
    @pulumi.getter
    def warns(self) -> Sequence['outputs.GetMetricRuleTemplatesTemplateAlertTemplateEscalationWarnResult']:
        """
        The condition for triggering warn-level alerts.
        """
        return pulumi.get(self, "warns")


@pulumi.output_type
class GetMetricRuleTemplatesTemplateAlertTemplateEscalationCriticalResult(dict):
    def __init__(__self__, *,
                 comparison_operator: str,
                 statistics: str,
                 threshold: str,
                 times: str):
        """
        :param str comparison_operator: The comparison operator of the threshold for warn-level alerts.Valid values: `GreaterThanOrEqualToThreshold`, `GreaterThanThreshold`, `LessThanOrEqualToThreshold`, `LessThanThreshold`, `NotEqualToThreshold`, `GreaterThanYesterday`, `LessThanYesterday`, `GreaterThanLastWeek`, `LessThanLastWeek`, `GreaterThanLastPeriod`, `LessThanLastPeriod`.
        :param str statistics: The statistical aggregation method for warn-level alerts.
        :param str threshold: The threshold for warn-level alerts.
        :param str times: The consecutive number of times for which the metric value is measured before a warn-level
               alert is triggered.
        """
        pulumi.set(__self__, "comparison_operator", comparison_operator)
        pulumi.set(__self__, "statistics", statistics)
        pulumi.set(__self__, "threshold", threshold)
        pulumi.set(__self__, "times", times)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> str:
        """
        The comparison operator of the threshold for warn-level alerts.Valid values: `GreaterThanOrEqualToThreshold`, `GreaterThanThreshold`, `LessThanOrEqualToThreshold`, `LessThanThreshold`, `NotEqualToThreshold`, `GreaterThanYesterday`, `LessThanYesterday`, `GreaterThanLastWeek`, `LessThanLastWeek`, `GreaterThanLastPeriod`, `LessThanLastPeriod`.
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def statistics(self) -> str:
        """
        The statistical aggregation method for warn-level alerts.
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> str:
        """
        The threshold for warn-level alerts.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def times(self) -> str:
        """
        The consecutive number of times for which the metric value is measured before a warn-level
        alert is triggered.
        """
        return pulumi.get(self, "times")


@pulumi.output_type
class GetMetricRuleTemplatesTemplateAlertTemplateEscalationInfoResult(dict):
    def __init__(__self__, *,
                 comparison_operator: str,
                 statistics: str,
                 threshold: str,
                 times: str):
        """
        :param str comparison_operator: The comparison operator of the threshold for warn-level alerts.Valid values: `GreaterThanOrEqualToThreshold`, `GreaterThanThreshold`, `LessThanOrEqualToThreshold`, `LessThanThreshold`, `NotEqualToThreshold`, `GreaterThanYesterday`, `LessThanYesterday`, `GreaterThanLastWeek`, `LessThanLastWeek`, `GreaterThanLastPeriod`, `LessThanLastPeriod`.
        :param str statistics: The statistical aggregation method for warn-level alerts.
        :param str threshold: The threshold for warn-level alerts.
        :param str times: The consecutive number of times for which the metric value is measured before a warn-level
               alert is triggered.
        """
        pulumi.set(__self__, "comparison_operator", comparison_operator)
        pulumi.set(__self__, "statistics", statistics)
        pulumi.set(__self__, "threshold", threshold)
        pulumi.set(__self__, "times", times)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> str:
        """
        The comparison operator of the threshold for warn-level alerts.Valid values: `GreaterThanOrEqualToThreshold`, `GreaterThanThreshold`, `LessThanOrEqualToThreshold`, `LessThanThreshold`, `NotEqualToThreshold`, `GreaterThanYesterday`, `LessThanYesterday`, `GreaterThanLastWeek`, `LessThanLastWeek`, `GreaterThanLastPeriod`, `LessThanLastPeriod`.
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def statistics(self) -> str:
        """
        The statistical aggregation method for warn-level alerts.
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> str:
        """
        The threshold for warn-level alerts.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def times(self) -> str:
        """
        The consecutive number of times for which the metric value is measured before a warn-level
        alert is triggered.
        """
        return pulumi.get(self, "times")


@pulumi.output_type
class GetMetricRuleTemplatesTemplateAlertTemplateEscalationWarnResult(dict):
    def __init__(__self__, *,
                 comparison_operator: str,
                 statistics: str,
                 threshold: str,
                 times: str):
        """
        :param str comparison_operator: The comparison operator of the threshold for warn-level alerts.Valid values: `GreaterThanOrEqualToThreshold`, `GreaterThanThreshold`, `LessThanOrEqualToThreshold`, `LessThanThreshold`, `NotEqualToThreshold`, `GreaterThanYesterday`, `LessThanYesterday`, `GreaterThanLastWeek`, `LessThanLastWeek`, `GreaterThanLastPeriod`, `LessThanLastPeriod`.
        :param str statistics: The statistical aggregation method for warn-level alerts.
        :param str threshold: The threshold for warn-level alerts.
        :param str times: The consecutive number of times for which the metric value is measured before a warn-level
               alert is triggered.
        """
        pulumi.set(__self__, "comparison_operator", comparison_operator)
        pulumi.set(__self__, "statistics", statistics)
        pulumi.set(__self__, "threshold", threshold)
        pulumi.set(__self__, "times", times)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> str:
        """
        The comparison operator of the threshold for warn-level alerts.Valid values: `GreaterThanOrEqualToThreshold`, `GreaterThanThreshold`, `LessThanOrEqualToThreshold`, `LessThanThreshold`, `NotEqualToThreshold`, `GreaterThanYesterday`, `LessThanYesterday`, `GreaterThanLastWeek`, `LessThanLastWeek`, `GreaterThanLastPeriod`, `LessThanLastPeriod`.
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def statistics(self) -> str:
        """
        The statistical aggregation method for warn-level alerts.
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> str:
        """
        The threshold for warn-level alerts.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def times(self) -> str:
        """
        The consecutive number of times for which the metric value is measured before a warn-level
        alert is triggered.
        """
        return pulumi.get(self, "times")


@pulumi.output_type
class GetMonitorGroupInstancesInstanceResult(dict):
    def __init__(__self__, *,
                 instances: Sequence['outputs.GetMonitorGroupInstancesInstanceInstanceResult']):
        pulumi.set(__self__, "instances", instances)

    @property
    @pulumi.getter
    def instances(self) -> Sequence['outputs.GetMonitorGroupInstancesInstanceInstanceResult']:
        return pulumi.get(self, "instances")


@pulumi.output_type
class GetMonitorGroupInstancesInstanceInstanceResult(dict):
    def __init__(__self__, *,
                 category: str,
                 instance_id: str,
                 instance_name: str,
                 region_id: str):
        pulumi.set(__self__, "category", category)
        pulumi.set(__self__, "instance_id", instance_id)
        pulumi.set(__self__, "instance_name", instance_name)
        pulumi.set(__self__, "region_id", region_id)

    @property
    @pulumi.getter
    def category(self) -> str:
        return pulumi.get(self, "category")

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> str:
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter(name="instanceName")
    def instance_name(self) -> str:
        return pulumi.get(self, "instance_name")

    @property
    @pulumi.getter(name="regionId")
    def region_id(self) -> str:
        return pulumi.get(self, "region_id")


@pulumi.output_type
class GetMonitorGroupsGroupResult(dict):
    def __init__(__self__, *,
                 bind_url: str,
                 contact_groups: Sequence[str],
                 dynamic_tag_rule_id: str,
                 gmt_create: int,
                 gmt_modified: int,
                 group_id: str,
                 id: str,
                 monitor_group_name: str,
                 service_id: str,
                 tags: Mapping[str, Any],
                 template_ids: Sequence[str],
                 type: str):
        """
        :param str bind_url: The URL of the Kubernetes cluster from which the application group is synchronized.
        :param Sequence[str] contact_groups: The list of  alert groups that receive alert notifications for the application group.
        :param str dynamic_tag_rule_id: The ID of the tag rule.
        :param int gmt_create: The time when the application group was created.
        :param int gmt_modified: The time when the application group was modified.
        :param str group_id: The ID of the application group.
        :param str id: The ID of the Monitor Group.
        :param str monitor_group_name: The name of the application group.
        :param str service_id: The ID of the Alibaba Cloud service.
        :param Mapping[str, Any] tags: A map of tags assigned to the Cms Monitor Group.
        :param Sequence[str] template_ids: The alert templates applied to the application group.
        :param str type: The type of the application group.
        """
        pulumi.set(__self__, "bind_url", bind_url)
        pulumi.set(__self__, "contact_groups", contact_groups)
        pulumi.set(__self__, "dynamic_tag_rule_id", dynamic_tag_rule_id)
        pulumi.set(__self__, "gmt_create", gmt_create)
        pulumi.set(__self__, "gmt_modified", gmt_modified)
        pulumi.set(__self__, "group_id", group_id)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "monitor_group_name", monitor_group_name)
        pulumi.set(__self__, "service_id", service_id)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "template_ids", template_ids)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="bindUrl")
    def bind_url(self) -> str:
        """
        The URL of the Kubernetes cluster from which the application group is synchronized.
        """
        return pulumi.get(self, "bind_url")

    @property
    @pulumi.getter(name="contactGroups")
    def contact_groups(self) -> Sequence[str]:
        """
        The list of  alert groups that receive alert notifications for the application group.
        """
        return pulumi.get(self, "contact_groups")

    @property
    @pulumi.getter(name="dynamicTagRuleId")
    def dynamic_tag_rule_id(self) -> str:
        """
        The ID of the tag rule.
        """
        return pulumi.get(self, "dynamic_tag_rule_id")

    @property
    @pulumi.getter(name="gmtCreate")
    def gmt_create(self) -> int:
        """
        The time when the application group was created.
        """
        return pulumi.get(self, "gmt_create")

    @property
    @pulumi.getter(name="gmtModified")
    def gmt_modified(self) -> int:
        """
        The time when the application group was modified.
        """
        return pulumi.get(self, "gmt_modified")

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> str:
        """
        The ID of the application group.
        """
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Monitor Group.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="monitorGroupName")
    def monitor_group_name(self) -> str:
        """
        The name of the application group.
        """
        return pulumi.get(self, "monitor_group_name")

    @property
    @pulumi.getter(name="serviceId")
    def service_id(self) -> str:
        """
        The ID of the Alibaba Cloud service.
        """
        return pulumi.get(self, "service_id")

    @property
    @pulumi.getter
    def tags(self) -> Mapping[str, Any]:
        """
        A map of tags assigned to the Cms Monitor Group.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="templateIds")
    def template_ids(self) -> Sequence[str]:
        """
        The alert templates applied to the application group.
        """
        return pulumi.get(self, "template_ids")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of the application group.
        """
        return pulumi.get(self, "type")


