# 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 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

__all__ = [
    'AlertConfigurationArgs',
    'AlertConfigurationArgsDict',
    'AlertConfigurationAnnotationArgs',
    'AlertConfigurationAnnotationArgsDict',
    'AlertConfigurationConditionConfigurationArgs',
    'AlertConfigurationConditionConfigurationArgsDict',
    'AlertConfigurationGroupConfigurationArgs',
    'AlertConfigurationGroupConfigurationArgsDict',
    'AlertConfigurationJoinConfigurationArgs',
    'AlertConfigurationJoinConfigurationArgsDict',
    'AlertConfigurationLabelArgs',
    'AlertConfigurationLabelArgsDict',
    'AlertConfigurationPolicyConfigurationArgs',
    'AlertConfigurationPolicyConfigurationArgsDict',
    'AlertConfigurationQueryListArgs',
    'AlertConfigurationQueryListArgsDict',
    'AlertConfigurationSeverityConfigurationArgs',
    'AlertConfigurationSeverityConfigurationArgsDict',
    'AlertConfigurationSeverityConfigurationEvalConditionArgs',
    'AlertConfigurationSeverityConfigurationEvalConditionArgsDict',
    'AlertConfigurationSinkAlerthubArgs',
    'AlertConfigurationSinkAlerthubArgsDict',
    'AlertConfigurationSinkCmsArgs',
    'AlertConfigurationSinkCmsArgsDict',
    'AlertConfigurationSinkEventStoreArgs',
    'AlertConfigurationSinkEventStoreArgsDict',
    'AlertConfigurationTemplateConfigurationArgs',
    'AlertConfigurationTemplateConfigurationArgsDict',
    'AlertScheduleArgs',
    'AlertScheduleArgsDict',
    'CollectionPolicyCentralizeConfigArgs',
    'CollectionPolicyCentralizeConfigArgsDict',
    'CollectionPolicyDataConfigArgs',
    'CollectionPolicyDataConfigArgsDict',
    'CollectionPolicyPolicyConfigArgs',
    'CollectionPolicyPolicyConfigArgsDict',
    'CollectionPolicyResourceDirectoryArgs',
    'CollectionPolicyResourceDirectoryArgsDict',
    'ScheduledSqlScheduleArgs',
    'ScheduledSqlScheduleArgsDict',
    'ScheduledSqlScheduledSqlConfigurationArgs',
    'ScheduledSqlScheduledSqlConfigurationArgsDict',
]

MYPY = False

if not MYPY:
    class AlertConfigurationArgsDict(TypedDict):
        annotations: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationAnnotationArgsDict']]]]
        """
        Template Annotations.
        """
        auto_annotation: NotRequired[pulumi.Input[bool]]
        """
        Whether to turn on automatic labeling. true (default): The automatic annotation function is enabled, and the system automatically adds information such as__county__to the alarm. For more information, see Automatic Labeling. false: Turn off the automatic annotation function.
        """
        condition_configuration: NotRequired[pulumi.Input['AlertConfigurationConditionConfigurationArgsDict']]
        """
        Alarm trigger condition. See `condition_configuration` below.
        """
        dashboard: NotRequired[pulumi.Input[str]]
        """
        The instrument cluster associated with the alarm. It is recommended to set to internal-alert-analysis.
        """
        group_configuration: NotRequired[pulumi.Input['AlertConfigurationGroupConfigurationArgsDict']]
        """
        Group evaluation configuration. See `group_configuration` below.
        """
        join_configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationJoinConfigurationArgsDict']]]]
        """
        Set operation configuration. See `join_configurations` below.
        """
        labels: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationLabelArgsDict']]]]
        """
        Label. See `labels` below.
        """
        mute_until: NotRequired[pulumi.Input[int]]
        """
        Second-level timestamp representing the temporary shutdown deadline.
        """
        no_data_fire: NotRequired[pulumi.Input[bool]]
        """
        Whether no data triggers an alarm. true: If the number of times the query and analysis results (if there are multiple results, the result after the collection operation) is no data exceeds the continuous trigger threshold, an alarm is generated. false (default): Turn off the no data alarm function.
        """
        no_data_severity: NotRequired[pulumi.Input[int]]
        """
        Alarm severity when no data triggers an alarm.
        """
        policy_configuration: NotRequired[pulumi.Input['AlertConfigurationPolicyConfigurationArgsDict']]
        """
        Alert policy configuration. See `policy_configuration` below.
        """
        query_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationQueryListArgsDict']]]]
        """
        Query the statistical list. See `query_list` below.
        """
        send_resolved: NotRequired[pulumi.Input[bool]]
        """
        Whether to send a recovery notification. true: A recovery alarm is triggered when the alarm is restored. false (default): Turn off the alarm recovery notification function.
        """
        severity_configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationSeverityConfigurationArgsDict']]]]
        """
        Trigger condition, set at least one trigger condition. See `severity_configurations` below.
        """
        sink_alerthub: NotRequired[pulumi.Input['AlertConfigurationSinkAlerthubArgsDict']]
        """
        Configuration of Alerts Sent to Alerthub. See `sink_alerthub` below.
        """
        sink_cms: NotRequired[pulumi.Input['AlertConfigurationSinkCmsArgsDict']]
        """
        Configure alerts sent to CloudMonitor. See `sink_cms` below.
        """
        sink_event_store: NotRequired[pulumi.Input['AlertConfigurationSinkEventStoreArgsDict']]
        """
        Configuration of sending alarms to EventStore. See `sink_event_store` below.
        """
        tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Customize the category of alarm monitoring rules.
        """
        template_configuration: NotRequired[pulumi.Input['AlertConfigurationTemplateConfigurationArgsDict']]
        """
        Alarm rule template configuration. See `template_configuration` below.
        """
        threshold: NotRequired[pulumi.Input[int]]
        """
        Set the continuous trigger threshold. When the cumulative number of triggers reaches this value, an alarm is generated. The statistics are not counted when the trigger condition is not met.
        """
        type: NotRequired[pulumi.Input[str]]
        """
        Template Type.
        """
        version: NotRequired[pulumi.Input[str]]
        """
        Template Version.
        """
elif False:
    AlertConfigurationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlertConfigurationArgs:
    def __init__(__self__, *,
                 annotations: Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationAnnotationArgs']]]] = None,
                 auto_annotation: Optional[pulumi.Input[bool]] = None,
                 condition_configuration: Optional[pulumi.Input['AlertConfigurationConditionConfigurationArgs']] = None,
                 dashboard: Optional[pulumi.Input[str]] = None,
                 group_configuration: Optional[pulumi.Input['AlertConfigurationGroupConfigurationArgs']] = None,
                 join_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationJoinConfigurationArgs']]]] = None,
                 labels: Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationLabelArgs']]]] = None,
                 mute_until: Optional[pulumi.Input[int]] = None,
                 no_data_fire: Optional[pulumi.Input[bool]] = None,
                 no_data_severity: Optional[pulumi.Input[int]] = None,
                 policy_configuration: Optional[pulumi.Input['AlertConfigurationPolicyConfigurationArgs']] = None,
                 query_lists: Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationQueryListArgs']]]] = None,
                 send_resolved: Optional[pulumi.Input[bool]] = None,
                 severity_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationSeverityConfigurationArgs']]]] = None,
                 sink_alerthub: Optional[pulumi.Input['AlertConfigurationSinkAlerthubArgs']] = None,
                 sink_cms: Optional[pulumi.Input['AlertConfigurationSinkCmsArgs']] = None,
                 sink_event_store: Optional[pulumi.Input['AlertConfigurationSinkEventStoreArgs']] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 template_configuration: Optional[pulumi.Input['AlertConfigurationTemplateConfigurationArgs']] = None,
                 threshold: Optional[pulumi.Input[int]] = None,
                 type: Optional[pulumi.Input[str]] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['AlertConfigurationAnnotationArgs']]] annotations: Template Annotations.
        :param pulumi.Input[bool] auto_annotation: Whether to turn on automatic labeling. true (default): The automatic annotation function is enabled, and the system automatically adds information such as__county__to the alarm. For more information, see Automatic Labeling. false: Turn off the automatic annotation function.
        :param pulumi.Input['AlertConfigurationConditionConfigurationArgs'] condition_configuration: Alarm trigger condition. See `condition_configuration` below.
        :param pulumi.Input[str] dashboard: The instrument cluster associated with the alarm. It is recommended to set to internal-alert-analysis.
        :param pulumi.Input['AlertConfigurationGroupConfigurationArgs'] group_configuration: Group evaluation configuration. See `group_configuration` below.
        :param pulumi.Input[Sequence[pulumi.Input['AlertConfigurationJoinConfigurationArgs']]] join_configurations: Set operation configuration. See `join_configurations` below.
        :param pulumi.Input[Sequence[pulumi.Input['AlertConfigurationLabelArgs']]] labels: Label. See `labels` below.
        :param pulumi.Input[int] mute_until: Second-level timestamp representing the temporary shutdown deadline.
        :param pulumi.Input[bool] no_data_fire: Whether no data triggers an alarm. true: If the number of times the query and analysis results (if there are multiple results, the result after the collection operation) is no data exceeds the continuous trigger threshold, an alarm is generated. false (default): Turn off the no data alarm function.
        :param pulumi.Input[int] no_data_severity: Alarm severity when no data triggers an alarm.
        :param pulumi.Input['AlertConfigurationPolicyConfigurationArgs'] policy_configuration: Alert policy configuration. See `policy_configuration` below.
        :param pulumi.Input[Sequence[pulumi.Input['AlertConfigurationQueryListArgs']]] query_lists: Query the statistical list. See `query_list` below.
        :param pulumi.Input[bool] send_resolved: Whether to send a recovery notification. true: A recovery alarm is triggered when the alarm is restored. false (default): Turn off the alarm recovery notification function.
        :param pulumi.Input[Sequence[pulumi.Input['AlertConfigurationSeverityConfigurationArgs']]] severity_configurations: Trigger condition, set at least one trigger condition. See `severity_configurations` below.
        :param pulumi.Input['AlertConfigurationSinkAlerthubArgs'] sink_alerthub: Configuration of Alerts Sent to Alerthub. See `sink_alerthub` below.
        :param pulumi.Input['AlertConfigurationSinkCmsArgs'] sink_cms: Configure alerts sent to CloudMonitor. See `sink_cms` below.
        :param pulumi.Input['AlertConfigurationSinkEventStoreArgs'] sink_event_store: Configuration of sending alarms to EventStore. See `sink_event_store` below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: Customize the category of alarm monitoring rules.
        :param pulumi.Input['AlertConfigurationTemplateConfigurationArgs'] template_configuration: Alarm rule template configuration. See `template_configuration` below.
        :param pulumi.Input[int] threshold: Set the continuous trigger threshold. When the cumulative number of triggers reaches this value, an alarm is generated. The statistics are not counted when the trigger condition is not met.
        :param pulumi.Input[str] type: Template Type.
        :param pulumi.Input[str] version: Template Version.
        """
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if auto_annotation is not None:
            pulumi.set(__self__, "auto_annotation", auto_annotation)
        if condition_configuration is not None:
            pulumi.set(__self__, "condition_configuration", condition_configuration)
        if dashboard is not None:
            pulumi.set(__self__, "dashboard", dashboard)
        if group_configuration is not None:
            pulumi.set(__self__, "group_configuration", group_configuration)
        if join_configurations is not None:
            pulumi.set(__self__, "join_configurations", join_configurations)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if mute_until is not None:
            pulumi.set(__self__, "mute_until", mute_until)
        if no_data_fire is not None:
            pulumi.set(__self__, "no_data_fire", no_data_fire)
        if no_data_severity is not None:
            pulumi.set(__self__, "no_data_severity", no_data_severity)
        if policy_configuration is not None:
            pulumi.set(__self__, "policy_configuration", policy_configuration)
        if query_lists is not None:
            pulumi.set(__self__, "query_lists", query_lists)
        if send_resolved is not None:
            pulumi.set(__self__, "send_resolved", send_resolved)
        if severity_configurations is not None:
            pulumi.set(__self__, "severity_configurations", severity_configurations)
        if sink_alerthub is not None:
            pulumi.set(__self__, "sink_alerthub", sink_alerthub)
        if sink_cms is not None:
            pulumi.set(__self__, "sink_cms", sink_cms)
        if sink_event_store is not None:
            pulumi.set(__self__, "sink_event_store", sink_event_store)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if template_configuration is not None:
            pulumi.set(__self__, "template_configuration", template_configuration)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def annotations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationAnnotationArgs']]]]:
        """
        Template Annotations.
        """
        return pulumi.get(self, "annotations")

    @annotations.setter
    def annotations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationAnnotationArgs']]]]):
        pulumi.set(self, "annotations", value)

    @property
    @pulumi.getter(name="autoAnnotation")
    def auto_annotation(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to turn on automatic labeling. true (default): The automatic annotation function is enabled, and the system automatically adds information such as__county__to the alarm. For more information, see Automatic Labeling. false: Turn off the automatic annotation function.
        """
        return pulumi.get(self, "auto_annotation")

    @auto_annotation.setter
    def auto_annotation(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "auto_annotation", value)

    @property
    @pulumi.getter(name="conditionConfiguration")
    def condition_configuration(self) -> Optional[pulumi.Input['AlertConfigurationConditionConfigurationArgs']]:
        """
        Alarm trigger condition. See `condition_configuration` below.
        """
        return pulumi.get(self, "condition_configuration")

    @condition_configuration.setter
    def condition_configuration(self, value: Optional[pulumi.Input['AlertConfigurationConditionConfigurationArgs']]):
        pulumi.set(self, "condition_configuration", value)

    @property
    @pulumi.getter
    def dashboard(self) -> Optional[pulumi.Input[str]]:
        """
        The instrument cluster associated with the alarm. It is recommended to set to internal-alert-analysis.
        """
        return pulumi.get(self, "dashboard")

    @dashboard.setter
    def dashboard(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dashboard", value)

    @property
    @pulumi.getter(name="groupConfiguration")
    def group_configuration(self) -> Optional[pulumi.Input['AlertConfigurationGroupConfigurationArgs']]:
        """
        Group evaluation configuration. See `group_configuration` below.
        """
        return pulumi.get(self, "group_configuration")

    @group_configuration.setter
    def group_configuration(self, value: Optional[pulumi.Input['AlertConfigurationGroupConfigurationArgs']]):
        pulumi.set(self, "group_configuration", value)

    @property
    @pulumi.getter(name="joinConfigurations")
    def join_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationJoinConfigurationArgs']]]]:
        """
        Set operation configuration. See `join_configurations` below.
        """
        return pulumi.get(self, "join_configurations")

    @join_configurations.setter
    def join_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationJoinConfigurationArgs']]]]):
        pulumi.set(self, "join_configurations", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationLabelArgs']]]]:
        """
        Label. See `labels` below.
        """
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationLabelArgs']]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter(name="muteUntil")
    def mute_until(self) -> Optional[pulumi.Input[int]]:
        """
        Second-level timestamp representing the temporary shutdown deadline.
        """
        return pulumi.get(self, "mute_until")

    @mute_until.setter
    def mute_until(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "mute_until", value)

    @property
    @pulumi.getter(name="noDataFire")
    def no_data_fire(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether no data triggers an alarm. true: If the number of times the query and analysis results (if there are multiple results, the result after the collection operation) is no data exceeds the continuous trigger threshold, an alarm is generated. false (default): Turn off the no data alarm function.
        """
        return pulumi.get(self, "no_data_fire")

    @no_data_fire.setter
    def no_data_fire(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "no_data_fire", value)

    @property
    @pulumi.getter(name="noDataSeverity")
    def no_data_severity(self) -> Optional[pulumi.Input[int]]:
        """
        Alarm severity when no data triggers an alarm.
        """
        return pulumi.get(self, "no_data_severity")

    @no_data_severity.setter
    def no_data_severity(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "no_data_severity", value)

    @property
    @pulumi.getter(name="policyConfiguration")
    def policy_configuration(self) -> Optional[pulumi.Input['AlertConfigurationPolicyConfigurationArgs']]:
        """
        Alert policy configuration. See `policy_configuration` below.
        """
        return pulumi.get(self, "policy_configuration")

    @policy_configuration.setter
    def policy_configuration(self, value: Optional[pulumi.Input['AlertConfigurationPolicyConfigurationArgs']]):
        pulumi.set(self, "policy_configuration", value)

    @property
    @pulumi.getter(name="queryLists")
    def query_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationQueryListArgs']]]]:
        """
        Query the statistical list. See `query_list` below.
        """
        return pulumi.get(self, "query_lists")

    @query_lists.setter
    def query_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationQueryListArgs']]]]):
        pulumi.set(self, "query_lists", value)

    @property
    @pulumi.getter(name="sendResolved")
    def send_resolved(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to send a recovery notification. true: A recovery alarm is triggered when the alarm is restored. false (default): Turn off the alarm recovery notification function.
        """
        return pulumi.get(self, "send_resolved")

    @send_resolved.setter
    def send_resolved(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "send_resolved", value)

    @property
    @pulumi.getter(name="severityConfigurations")
    def severity_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationSeverityConfigurationArgs']]]]:
        """
        Trigger condition, set at least one trigger condition. See `severity_configurations` below.
        """
        return pulumi.get(self, "severity_configurations")

    @severity_configurations.setter
    def severity_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationSeverityConfigurationArgs']]]]):
        pulumi.set(self, "severity_configurations", value)

    @property
    @pulumi.getter(name="sinkAlerthub")
    def sink_alerthub(self) -> Optional[pulumi.Input['AlertConfigurationSinkAlerthubArgs']]:
        """
        Configuration of Alerts Sent to Alerthub. See `sink_alerthub` below.
        """
        return pulumi.get(self, "sink_alerthub")

    @sink_alerthub.setter
    def sink_alerthub(self, value: Optional[pulumi.Input['AlertConfigurationSinkAlerthubArgs']]):
        pulumi.set(self, "sink_alerthub", value)

    @property
    @pulumi.getter(name="sinkCms")
    def sink_cms(self) -> Optional[pulumi.Input['AlertConfigurationSinkCmsArgs']]:
        """
        Configure alerts sent to CloudMonitor. See `sink_cms` below.
        """
        return pulumi.get(self, "sink_cms")

    @sink_cms.setter
    def sink_cms(self, value: Optional[pulumi.Input['AlertConfigurationSinkCmsArgs']]):
        pulumi.set(self, "sink_cms", value)

    @property
    @pulumi.getter(name="sinkEventStore")
    def sink_event_store(self) -> Optional[pulumi.Input['AlertConfigurationSinkEventStoreArgs']]:
        """
        Configuration of sending alarms to EventStore. See `sink_event_store` below.
        """
        return pulumi.get(self, "sink_event_store")

    @sink_event_store.setter
    def sink_event_store(self, value: Optional[pulumi.Input['AlertConfigurationSinkEventStoreArgs']]):
        pulumi.set(self, "sink_event_store", value)

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Customize the category of alarm monitoring rules.
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter(name="templateConfiguration")
    def template_configuration(self) -> Optional[pulumi.Input['AlertConfigurationTemplateConfigurationArgs']]:
        """
        Alarm rule template configuration. See `template_configuration` below.
        """
        return pulumi.get(self, "template_configuration")

    @template_configuration.setter
    def template_configuration(self, value: Optional[pulumi.Input['AlertConfigurationTemplateConfigurationArgs']]):
        pulumi.set(self, "template_configuration", value)

    @property
    @pulumi.getter
    def threshold(self) -> Optional[pulumi.Input[int]]:
        """
        Set the continuous trigger threshold. When the cumulative number of triggers reaches this value, an alarm is generated. The statistics are not counted when the trigger condition is not met.
        """
        return pulumi.get(self, "threshold")

    @threshold.setter
    def threshold(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "threshold", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Template Type.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[str]]:
        """
        Template Version.
        """
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version", value)


if not MYPY:
    class AlertConfigurationAnnotationArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[str]]
        """
        Field name.
        """
        value: NotRequired[pulumi.Input[str]]
        """
        Field value.
        """
elif False:
    AlertConfigurationAnnotationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlertConfigurationAnnotationArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] key: Field name.
        :param pulumi.Input[str] value: Field value.
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        """
        Field name.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        """
        Field value.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)


if not MYPY:
    class AlertConfigurationConditionConfigurationArgsDict(TypedDict):
        condition: NotRequired[pulumi.Input[str]]
        """
        Data matching expression. When the data content does not need to be determined, set it to an empty string. In other cases, it needs to be set as an expression, for example, errCnt> 10.
        """
        count_condition: NotRequired[pulumi.Input[str]]
        """
        The number of pieces of data to determine the number of pieces of data to indicate how many pieces of data meet the conditions. If data exists, it is satisfied. Set it to an empty string. In other cases, it needs to be set as an expression, such as__count__> 3.
        """
elif False:
    AlertConfigurationConditionConfigurationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlertConfigurationConditionConfigurationArgs:
    def __init__(__self__, *,
                 condition: Optional[pulumi.Input[str]] = None,
                 count_condition: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] condition: Data matching expression. When the data content does not need to be determined, set it to an empty string. In other cases, it needs to be set as an expression, for example, errCnt> 10.
        :param pulumi.Input[str] count_condition: The number of pieces of data to determine the number of pieces of data to indicate how many pieces of data meet the conditions. If data exists, it is satisfied. Set it to an empty string. In other cases, it needs to be set as an expression, such as__count__> 3.
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if count_condition is not None:
            pulumi.set(__self__, "count_condition", count_condition)

    @property
    @pulumi.getter
    def condition(self) -> Optional[pulumi.Input[str]]:
        """
        Data matching expression. When the data content does not need to be determined, set it to an empty string. In other cases, it needs to be set as an expression, for example, errCnt> 10.
        """
        return pulumi.get(self, "condition")

    @condition.setter
    def condition(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "condition", value)

    @property
    @pulumi.getter(name="countCondition")
    def count_condition(self) -> Optional[pulumi.Input[str]]:
        """
        The number of pieces of data to determine the number of pieces of data to indicate how many pieces of data meet the conditions. If data exists, it is satisfied. Set it to an empty string. In other cases, it needs to be set as an expression, such as__count__> 3.
        """
        return pulumi.get(self, "count_condition")

    @count_condition.setter
    def count_condition(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "count_condition", value)


if not MYPY:
    class AlertConfigurationGroupConfigurationArgsDict(TypedDict):
        fields: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        The field used for grouping evaluation. When type is set to custom, fields must be set.
        """
        type: NotRequired[pulumi.Input[str]]
elif False:
    AlertConfigurationGroupConfigurationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlertConfigurationGroupConfigurationArgs:
    def __init__(__self__, *,
                 fields: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] fields: The field used for grouping evaluation. When type is set to custom, fields must be set.
        """
        if fields is not None:
            pulumi.set(__self__, "fields", fields)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The field used for grouping evaluation. When type is set to custom, fields must be set.
        """
        return pulumi.get(self, "fields")

    @fields.setter
    def fields(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "fields", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


if not MYPY:
    class AlertConfigurationJoinConfigurationArgsDict(TypedDict):
        condition: NotRequired[pulumi.Input[str]]
        """
        Data matching expression. When the data content does not need to be determined, set it to an empty string. In other cases, it needs to be set as an expression, for example, errCnt> 10.
        """
        type: NotRequired[pulumi.Input[str]]
elif False:
    AlertConfigurationJoinConfigurationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlertConfigurationJoinConfigurationArgs:
    def __init__(__self__, *,
                 condition: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] condition: Data matching expression. When the data content does not need to be determined, set it to an empty string. In other cases, it needs to be set as an expression, for example, errCnt> 10.
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def condition(self) -> Optional[pulumi.Input[str]]:
        """
        Data matching expression. When the data content does not need to be determined, set it to an empty string. In other cases, it needs to be set as an expression, for example, errCnt> 10.
        """
        return pulumi.get(self, "condition")

    @condition.setter
    def condition(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "condition", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


if not MYPY:
    class AlertConfigurationLabelArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[str]]
        """
        Field name.
        """
        value: NotRequired[pulumi.Input[str]]
        """
        Field value.
        """
elif False:
    AlertConfigurationLabelArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlertConfigurationLabelArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] key: Field name.
        :param pulumi.Input[str] value: Field value.
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        """
        Field name.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        """
        Field value.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)


if not MYPY:
    class AlertConfigurationPolicyConfigurationArgsDict(TypedDict):
        action_policy_id: NotRequired[pulumi.Input[str]]
        """
        The ID of the action policy used. If the alert policy is in advanced mode and the selected alert policy is not configured with a dynamic action policy, set the actionPolicyId to an empty string.
        """
        alert_policy_id: NotRequired[pulumi.Input[str]]
        """
        Alarm policy ID. If it is in simple mode or normal mode, set it to sls.builtin.dynamic (dynamic alarm policy built into the system). For advanced mode, set it to the specified alarm policy ID.
        """
        repeat_interval: NotRequired[pulumi.Input[str]]
        """
        Repeat the waiting time. For example, 5m, 1H, etc.
        """
elif False:
    AlertConfigurationPolicyConfigurationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlertConfigurationPolicyConfigurationArgs:
    def __init__(__self__, *,
                 action_policy_id: Optional[pulumi.Input[str]] = None,
                 alert_policy_id: Optional[pulumi.Input[str]] = None,
                 repeat_interval: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] action_policy_id: The ID of the action policy used. If the alert policy is in advanced mode and the selected alert policy is not configured with a dynamic action policy, set the actionPolicyId to an empty string.
        :param pulumi.Input[str] alert_policy_id: Alarm policy ID. If it is in simple mode or normal mode, set it to sls.builtin.dynamic (dynamic alarm policy built into the system). For advanced mode, set it to the specified alarm policy ID.
        :param pulumi.Input[str] repeat_interval: Repeat the waiting time. For example, 5m, 1H, etc.
        """
        if action_policy_id is not None:
            pulumi.set(__self__, "action_policy_id", action_policy_id)
        if alert_policy_id is not None:
            pulumi.set(__self__, "alert_policy_id", alert_policy_id)
        if repeat_interval is not None:
            pulumi.set(__self__, "repeat_interval", repeat_interval)

    @property
    @pulumi.getter(name="actionPolicyId")
    def action_policy_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the action policy used. If the alert policy is in advanced mode and the selected alert policy is not configured with a dynamic action policy, set the actionPolicyId to an empty string.
        """
        return pulumi.get(self, "action_policy_id")

    @action_policy_id.setter
    def action_policy_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "action_policy_id", value)

    @property
    @pulumi.getter(name="alertPolicyId")
    def alert_policy_id(self) -> Optional[pulumi.Input[str]]:
        """
        Alarm policy ID. If it is in simple mode or normal mode, set it to sls.builtin.dynamic (dynamic alarm policy built into the system). For advanced mode, set it to the specified alarm policy ID.
        """
        return pulumi.get(self, "alert_policy_id")

    @alert_policy_id.setter
    def alert_policy_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "alert_policy_id", value)

    @property
    @pulumi.getter(name="repeatInterval")
    def repeat_interval(self) -> Optional[pulumi.Input[str]]:
        """
        Repeat the waiting time. For example, 5m, 1H, etc.
        """
        return pulumi.get(self, "repeat_interval")

    @repeat_interval.setter
    def repeat_interval(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "repeat_interval", value)


if not MYPY:
    class AlertConfigurationQueryListArgsDict(TypedDict):
        chart_title: NotRequired[pulumi.Input[str]]
        """
        Chart Name.
        """
        dashboard_id: NotRequired[pulumi.Input[str]]
        """
        Dashboard ID.
        """
        end: NotRequired[pulumi.Input[str]]
        """
        End time. When storeType is set to log or metric, end must be set.
        """
        power_sql_mode: NotRequired[pulumi.Input[str]]
        """
        Whether to use exclusive SQL. The value is as follows: auto: automatic switching. enable: Starts. disable: disable.
        """
        project: NotRequired[pulumi.Input[str]]
        """
        Project Name.
        """
        query: NotRequired[pulumi.Input[str]]
        """
        Query and analysis statements. When storeType is set to log or metric, query is set to the query analysis statement. When storeType is set to meta, set query to an empty string.
        """
        region: NotRequired[pulumi.Input[str]]
        """
        Region of the target Project.
        """
        role_arn: NotRequired[pulumi.Input[str]]
        """
        Roles used to write alarm data to the event Library.
        """
        start: NotRequired[pulumi.Input[str]]
        """
        Start time. When storeType is set to log or metric, start must be set.
        """
        store: NotRequired[pulumi.Input[str]]
        """
        Query the Logstore, Metricstore, or resource data associated with the statistics. When storeType is set to log, store is set to the target Logstore. When storeType is set to metric, store is set to the target Metricstore. When storeType is set to meta, store is set to the target resource data name.
        """
        store_type: NotRequired[pulumi.Input[str]]
        """
        Query the data source type. The value is as follows: log: Logstore. metric: Time series Library. meta: resource data.
        """
        time_span_type: NotRequired[pulumi.Input[str]]
        """
        Time Type.
        """
        ui: NotRequired[pulumi.Input[str]]
        """
        Use of specific scene alarm front end.
        """
elif False:
    AlertConfigurationQueryListArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlertConfigurationQueryListArgs:
    def __init__(__self__, *,
                 chart_title: Optional[pulumi.Input[str]] = None,
                 dashboard_id: Optional[pulumi.Input[str]] = None,
                 end: Optional[pulumi.Input[str]] = None,
                 power_sql_mode: Optional[pulumi.Input[str]] = None,
                 project: Optional[pulumi.Input[str]] = None,
                 query: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None,
                 role_arn: Optional[pulumi.Input[str]] = None,
                 start: Optional[pulumi.Input[str]] = None,
                 store: Optional[pulumi.Input[str]] = None,
                 store_type: Optional[pulumi.Input[str]] = None,
                 time_span_type: Optional[pulumi.Input[str]] = None,
                 ui: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] chart_title: Chart Name.
        :param pulumi.Input[str] dashboard_id: Dashboard ID.
        :param pulumi.Input[str] end: End time. When storeType is set to log or metric, end must be set.
        :param pulumi.Input[str] power_sql_mode: Whether to use exclusive SQL. The value is as follows: auto: automatic switching. enable: Starts. disable: disable.
        :param pulumi.Input[str] project: Project Name.
        :param pulumi.Input[str] query: Query and analysis statements. When storeType is set to log or metric, query is set to the query analysis statement. When storeType is set to meta, set query to an empty string.
        :param pulumi.Input[str] region: Region of the target Project.
        :param pulumi.Input[str] role_arn: Roles used to write alarm data to the event Library.
        :param pulumi.Input[str] start: Start time. When storeType is set to log or metric, start must be set.
        :param pulumi.Input[str] store: Query the Logstore, Metricstore, or resource data associated with the statistics. When storeType is set to log, store is set to the target Logstore. When storeType is set to metric, store is set to the target Metricstore. When storeType is set to meta, store is set to the target resource data name.
        :param pulumi.Input[str] store_type: Query the data source type. The value is as follows: log: Logstore. metric: Time series Library. meta: resource data.
        :param pulumi.Input[str] time_span_type: Time Type.
        :param pulumi.Input[str] ui: Use of specific scene alarm front end.
        """
        if chart_title is not None:
            pulumi.set(__self__, "chart_title", chart_title)
        if dashboard_id is not None:
            pulumi.set(__self__, "dashboard_id", dashboard_id)
        if end is not None:
            pulumi.set(__self__, "end", end)
        if power_sql_mode is not None:
            pulumi.set(__self__, "power_sql_mode", power_sql_mode)
        if project is not None:
            pulumi.set(__self__, "project", project)
        if query is not None:
            pulumi.set(__self__, "query", query)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if start is not None:
            pulumi.set(__self__, "start", start)
        if store is not None:
            pulumi.set(__self__, "store", store)
        if store_type is not None:
            pulumi.set(__self__, "store_type", store_type)
        if time_span_type is not None:
            pulumi.set(__self__, "time_span_type", time_span_type)
        if ui is not None:
            pulumi.set(__self__, "ui", ui)

    @property
    @pulumi.getter(name="chartTitle")
    def chart_title(self) -> Optional[pulumi.Input[str]]:
        """
        Chart Name.
        """
        return pulumi.get(self, "chart_title")

    @chart_title.setter
    def chart_title(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "chart_title", value)

    @property
    @pulumi.getter(name="dashboardId")
    def dashboard_id(self) -> Optional[pulumi.Input[str]]:
        """
        Dashboard ID.
        """
        return pulumi.get(self, "dashboard_id")

    @dashboard_id.setter
    def dashboard_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dashboard_id", value)

    @property
    @pulumi.getter
    def end(self) -> Optional[pulumi.Input[str]]:
        """
        End time. When storeType is set to log or metric, end must be set.
        """
        return pulumi.get(self, "end")

    @end.setter
    def end(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "end", value)

    @property
    @pulumi.getter(name="powerSqlMode")
    def power_sql_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Whether to use exclusive SQL. The value is as follows: auto: automatic switching. enable: Starts. disable: disable.
        """
        return pulumi.get(self, "power_sql_mode")

    @power_sql_mode.setter
    def power_sql_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "power_sql_mode", value)

    @property
    @pulumi.getter
    def project(self) -> Optional[pulumi.Input[str]]:
        """
        Project Name.
        """
        return pulumi.get(self, "project")

    @project.setter
    def project(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project", value)

    @property
    @pulumi.getter
    def query(self) -> Optional[pulumi.Input[str]]:
        """
        Query and analysis statements. When storeType is set to log or metric, query is set to the query analysis statement. When storeType is set to meta, set query to an empty string.
        """
        return pulumi.get(self, "query")

    @query.setter
    def query(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "query", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[str]]:
        """
        Region of the target Project.
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> Optional[pulumi.Input[str]]:
        """
        Roles used to write alarm data to the event Library.
        """
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "role_arn", value)

    @property
    @pulumi.getter
    def start(self) -> Optional[pulumi.Input[str]]:
        """
        Start time. When storeType is set to log or metric, start must be set.
        """
        return pulumi.get(self, "start")

    @start.setter
    def start(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "start", value)

    @property
    @pulumi.getter
    def store(self) -> Optional[pulumi.Input[str]]:
        """
        Query the Logstore, Metricstore, or resource data associated with the statistics. When storeType is set to log, store is set to the target Logstore. When storeType is set to metric, store is set to the target Metricstore. When storeType is set to meta, store is set to the target resource data name.
        """
        return pulumi.get(self, "store")

    @store.setter
    def store(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "store", value)

    @property
    @pulumi.getter(name="storeType")
    def store_type(self) -> Optional[pulumi.Input[str]]:
        """
        Query the data source type. The value is as follows: log: Logstore. metric: Time series Library. meta: resource data.
        """
        return pulumi.get(self, "store_type")

    @store_type.setter
    def store_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "store_type", value)

    @property
    @pulumi.getter(name="timeSpanType")
    def time_span_type(self) -> Optional[pulumi.Input[str]]:
        """
        Time Type.
        """
        return pulumi.get(self, "time_span_type")

    @time_span_type.setter
    def time_span_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "time_span_type", value)

    @property
    @pulumi.getter
    def ui(self) -> Optional[pulumi.Input[str]]:
        """
        Use of specific scene alarm front end.
        """
        return pulumi.get(self, "ui")

    @ui.setter
    def ui(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ui", value)


if not MYPY:
    class AlertConfigurationSeverityConfigurationArgsDict(TypedDict):
        eval_condition: NotRequired[pulumi.Input['AlertConfigurationSeverityConfigurationEvalConditionArgsDict']]
        """
        Trigger condition. See `eval_condition` below.
        """
        severity: NotRequired[pulumi.Input[int]]
        """
        Alarm severity.
        """
elif False:
    AlertConfigurationSeverityConfigurationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlertConfigurationSeverityConfigurationArgs:
    def __init__(__self__, *,
                 eval_condition: Optional[pulumi.Input['AlertConfigurationSeverityConfigurationEvalConditionArgs']] = None,
                 severity: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input['AlertConfigurationSeverityConfigurationEvalConditionArgs'] eval_condition: Trigger condition. See `eval_condition` below.
        :param pulumi.Input[int] severity: Alarm severity.
        """
        if eval_condition is not None:
            pulumi.set(__self__, "eval_condition", eval_condition)
        if severity is not None:
            pulumi.set(__self__, "severity", severity)

    @property
    @pulumi.getter(name="evalCondition")
    def eval_condition(self) -> Optional[pulumi.Input['AlertConfigurationSeverityConfigurationEvalConditionArgs']]:
        """
        Trigger condition. See `eval_condition` below.
        """
        return pulumi.get(self, "eval_condition")

    @eval_condition.setter
    def eval_condition(self, value: Optional[pulumi.Input['AlertConfigurationSeverityConfigurationEvalConditionArgs']]):
        pulumi.set(self, "eval_condition", value)

    @property
    @pulumi.getter
    def severity(self) -> Optional[pulumi.Input[int]]:
        """
        Alarm severity.
        """
        return pulumi.get(self, "severity")

    @severity.setter
    def severity(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "severity", value)


if not MYPY:
    class AlertConfigurationSeverityConfigurationEvalConditionArgsDict(TypedDict):
        condition: NotRequired[pulumi.Input[str]]
        """
        Data matching expression. When the data content does not need to be determined, set it to an empty string. In other cases, it needs to be set as an expression, for example, errCnt> 10.
        """
        count_condition: NotRequired[pulumi.Input[str]]
        """
        The number of pieces of data to determine the number of pieces of data to indicate how many pieces of data meet the conditions. If data exists, it is satisfied. Set it to an empty string. In other cases, it needs to be set as an expression, such as__count__> 3.
        """
elif False:
    AlertConfigurationSeverityConfigurationEvalConditionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlertConfigurationSeverityConfigurationEvalConditionArgs:
    def __init__(__self__, *,
                 condition: Optional[pulumi.Input[str]] = None,
                 count_condition: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] condition: Data matching expression. When the data content does not need to be determined, set it to an empty string. In other cases, it needs to be set as an expression, for example, errCnt> 10.
        :param pulumi.Input[str] count_condition: The number of pieces of data to determine the number of pieces of data to indicate how many pieces of data meet the conditions. If data exists, it is satisfied. Set it to an empty string. In other cases, it needs to be set as an expression, such as__count__> 3.
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if count_condition is not None:
            pulumi.set(__self__, "count_condition", count_condition)

    @property
    @pulumi.getter
    def condition(self) -> Optional[pulumi.Input[str]]:
        """
        Data matching expression. When the data content does not need to be determined, set it to an empty string. In other cases, it needs to be set as an expression, for example, errCnt> 10.
        """
        return pulumi.get(self, "condition")

    @condition.setter
    def condition(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "condition", value)

    @property
    @pulumi.getter(name="countCondition")
    def count_condition(self) -> Optional[pulumi.Input[str]]:
        """
        The number of pieces of data to determine the number of pieces of data to indicate how many pieces of data meet the conditions. If data exists, it is satisfied. Set it to an empty string. In other cases, it needs to be set as an expression, such as__count__> 3.
        """
        return pulumi.get(self, "count_condition")

    @count_condition.setter
    def count_condition(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "count_condition", value)


if not MYPY:
    class AlertConfigurationSinkAlerthubArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[bool]]
        """
        Open.
        """
elif False:
    AlertConfigurationSinkAlerthubArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlertConfigurationSinkAlerthubArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enabled: Open.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Open.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


if not MYPY:
    class AlertConfigurationSinkCmsArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[bool]]
        """
        Open.
        """
elif False:
    AlertConfigurationSinkCmsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlertConfigurationSinkCmsArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] enabled: Open.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Open.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


if not MYPY:
    class AlertConfigurationSinkEventStoreArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[bool]]
        """
        Open.
        """
        endpoint: NotRequired[pulumi.Input[str]]
        """
        SLS service endpoint.
        """
        event_store: NotRequired[pulumi.Input[str]]
        """
        Event Library Name.
        """
        project: NotRequired[pulumi.Input[str]]
        """
        Project Name.
        """
        role_arn: NotRequired[pulumi.Input[str]]
        """
        Roles used to write alarm data to the event Library.
        """
elif False:
    AlertConfigurationSinkEventStoreArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlertConfigurationSinkEventStoreArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 endpoint: Optional[pulumi.Input[str]] = None,
                 event_store: Optional[pulumi.Input[str]] = None,
                 project: Optional[pulumi.Input[str]] = None,
                 role_arn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] enabled: Open.
        :param pulumi.Input[str] endpoint: SLS service endpoint.
        :param pulumi.Input[str] event_store: Event Library Name.
        :param pulumi.Input[str] project: Project Name.
        :param pulumi.Input[str] role_arn: Roles used to write alarm data to the event Library.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if endpoint is not None:
            pulumi.set(__self__, "endpoint", endpoint)
        if event_store is not None:
            pulumi.set(__self__, "event_store", event_store)
        if project is not None:
            pulumi.set(__self__, "project", project)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Open.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def endpoint(self) -> Optional[pulumi.Input[str]]:
        """
        SLS service endpoint.
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "endpoint", value)

    @property
    @pulumi.getter(name="eventStore")
    def event_store(self) -> Optional[pulumi.Input[str]]:
        """
        Event Library Name.
        """
        return pulumi.get(self, "event_store")

    @event_store.setter
    def event_store(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "event_store", value)

    @property
    @pulumi.getter
    def project(self) -> Optional[pulumi.Input[str]]:
        """
        Project Name.
        """
        return pulumi.get(self, "project")

    @project.setter
    def project(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project", value)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> Optional[pulumi.Input[str]]:
        """
        Roles used to write alarm data to the event Library.
        """
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "role_arn", value)


if not MYPY:
    class AlertConfigurationTemplateConfigurationArgsDict(TypedDict):
        annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
        """
        Template Annotations.
        """
        lang: NotRequired[pulumi.Input[str]]
        """
        Template Language.
        """
        template_id: NotRequired[pulumi.Input[str]]
        """
        Template ID.
        """
        tokens: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
        """
        Template Variables.
        """
        type: NotRequired[pulumi.Input[str]]
        version: NotRequired[pulumi.Input[str]]
        """
        Template Version.
        """
elif False:
    AlertConfigurationTemplateConfigurationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlertConfigurationTemplateConfigurationArgs:
    def __init__(__self__, *,
                 annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 lang: Optional[pulumi.Input[str]] = None,
                 template_id: Optional[pulumi.Input[str]] = None,
                 tokens: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 type: Optional[pulumi.Input[str]] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] annotations: Template Annotations.
        :param pulumi.Input[str] lang: Template Language.
        :param pulumi.Input[str] template_id: Template ID.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tokens: Template Variables.
        :param pulumi.Input[str] version: Template Version.
        """
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if lang is not None:
            pulumi.set(__self__, "lang", lang)
        if template_id is not None:
            pulumi.set(__self__, "template_id", template_id)
        if tokens is not None:
            pulumi.set(__self__, "tokens", tokens)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Template Annotations.
        """
        return pulumi.get(self, "annotations")

    @annotations.setter
    def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "annotations", value)

    @property
    @pulumi.getter
    def lang(self) -> Optional[pulumi.Input[str]]:
        """
        Template Language.
        """
        return pulumi.get(self, "lang")

    @lang.setter
    def lang(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "lang", value)

    @property
    @pulumi.getter(name="templateId")
    def template_id(self) -> Optional[pulumi.Input[str]]:
        """
        Template ID.
        """
        return pulumi.get(self, "template_id")

    @template_id.setter
    def template_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "template_id", value)

    @property
    @pulumi.getter
    def tokens(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Template Variables.
        """
        return pulumi.get(self, "tokens")

    @tokens.setter
    def tokens(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "tokens", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[str]]:
        """
        Template Version.
        """
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version", value)


if not MYPY:
    class AlertScheduleArgsDict(TypedDict):
        cron_expression: NotRequired[pulumi.Input[str]]
        """
        Cron expression, the minimum accuracy is minutes, 24 hours. For example, 0 0/1 * * * means that the check is conducted every 1 hour from 00:00. When type is set to Cron, cronExpression must be set.
        """
        delay: NotRequired[pulumi.Input[int]]
        """
        Timed task execution delay (unit: s).
        """
        interval: NotRequired[pulumi.Input[str]]
        """
        Fixed interval for scheduling.
        """
        run_immdiately: NotRequired[pulumi.Input[bool]]
        """
        Dispatch immediately.
        """
        time_zone: NotRequired[pulumi.Input[str]]
        """
        The time zone where the Cron expression is located. The default value is null, indicating the eighth zone in the east.
        """
        type: NotRequired[pulumi.Input[str]]
        """
        Check the frequency type. Log Service checks the query and analysis results according to the frequency you configured. The values are as follows: Fixedate: checks query and analysis results at regular intervals. Cron: specifies the time interval by using the Cron expression, and checks the query and analysis results at the specified time interval.
        """
elif False:
    AlertScheduleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlertScheduleArgs:
    def __init__(__self__, *,
                 cron_expression: Optional[pulumi.Input[str]] = None,
                 delay: Optional[pulumi.Input[int]] = None,
                 interval: Optional[pulumi.Input[str]] = None,
                 run_immdiately: Optional[pulumi.Input[bool]] = None,
                 time_zone: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] cron_expression: Cron expression, the minimum accuracy is minutes, 24 hours. For example, 0 0/1 * * * means that the check is conducted every 1 hour from 00:00. When type is set to Cron, cronExpression must be set.
        :param pulumi.Input[int] delay: Timed task execution delay (unit: s).
        :param pulumi.Input[str] interval: Fixed interval for scheduling.
        :param pulumi.Input[bool] run_immdiately: Dispatch immediately.
        :param pulumi.Input[str] time_zone: The time zone where the Cron expression is located. The default value is null, indicating the eighth zone in the east.
        :param pulumi.Input[str] type: Check the frequency type. Log Service checks the query and analysis results according to the frequency you configured. The values are as follows: Fixedate: checks query and analysis results at regular intervals. Cron: specifies the time interval by using the Cron expression, and checks the query and analysis results at the specified time interval.
        """
        if cron_expression is not None:
            pulumi.set(__self__, "cron_expression", cron_expression)
        if delay is not None:
            pulumi.set(__self__, "delay", delay)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if run_immdiately is not None:
            pulumi.set(__self__, "run_immdiately", run_immdiately)
        if time_zone is not None:
            pulumi.set(__self__, "time_zone", time_zone)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="cronExpression")
    def cron_expression(self) -> Optional[pulumi.Input[str]]:
        """
        Cron expression, the minimum accuracy is minutes, 24 hours. For example, 0 0/1 * * * means that the check is conducted every 1 hour from 00:00. When type is set to Cron, cronExpression must be set.
        """
        return pulumi.get(self, "cron_expression")

    @cron_expression.setter
    def cron_expression(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cron_expression", value)

    @property
    @pulumi.getter
    def delay(self) -> Optional[pulumi.Input[int]]:
        """
        Timed task execution delay (unit: s).
        """
        return pulumi.get(self, "delay")

    @delay.setter
    def delay(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "delay", value)

    @property
    @pulumi.getter
    def interval(self) -> Optional[pulumi.Input[str]]:
        """
        Fixed interval for scheduling.
        """
        return pulumi.get(self, "interval")

    @interval.setter
    def interval(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "interval", value)

    @property
    @pulumi.getter(name="runImmdiately")
    def run_immdiately(self) -> Optional[pulumi.Input[bool]]:
        """
        Dispatch immediately.
        """
        return pulumi.get(self, "run_immdiately")

    @run_immdiately.setter
    def run_immdiately(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "run_immdiately", value)

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> Optional[pulumi.Input[str]]:
        """
        The time zone where the Cron expression is located. The default value is null, indicating the eighth zone in the east.
        """
        return pulumi.get(self, "time_zone")

    @time_zone.setter
    def time_zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "time_zone", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Check the frequency type. Log Service checks the query and analysis results according to the frequency you configured. The values are as follows: Fixedate: checks query and analysis results at regular intervals. Cron: specifies the time interval by using the Cron expression, and checks the query and analysis results at the specified time interval.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


if not MYPY:
    class CollectionPolicyCentralizeConfigArgsDict(TypedDict):
        dest_logstore: NotRequired[pulumi.Input[str]]
        """
        When the central logstore is transferred to the destination logstore, its geographical attribute should be consistent with the destRegion and belong to the destProject.
        """
        dest_project: NotRequired[pulumi.Input[str]]
        """
        The geographical attributes of the centralized transfer project should be consistent with the destRegion.
        """
        dest_region: NotRequired[pulumi.Input[str]]
        """
        Centralized transfer destination area.
        """
        dest_ttl: NotRequired[pulumi.Input[int]]
        """
        The number of days for the central transfer destination. This is valid only if the central transfer destination log store is not created for the first time.
        """
elif False:
    CollectionPolicyCentralizeConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CollectionPolicyCentralizeConfigArgs:
    def __init__(__self__, *,
                 dest_logstore: Optional[pulumi.Input[str]] = None,
                 dest_project: Optional[pulumi.Input[str]] = None,
                 dest_region: Optional[pulumi.Input[str]] = None,
                 dest_ttl: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] dest_logstore: When the central logstore is transferred to the destination logstore, its geographical attribute should be consistent with the destRegion and belong to the destProject.
        :param pulumi.Input[str] dest_project: The geographical attributes of the centralized transfer project should be consistent with the destRegion.
        :param pulumi.Input[str] dest_region: Centralized transfer destination area.
        :param pulumi.Input[int] dest_ttl: The number of days for the central transfer destination. This is valid only if the central transfer destination log store is not created for the first time.
        """
        if dest_logstore is not None:
            pulumi.set(__self__, "dest_logstore", dest_logstore)
        if dest_project is not None:
            pulumi.set(__self__, "dest_project", dest_project)
        if dest_region is not None:
            pulumi.set(__self__, "dest_region", dest_region)
        if dest_ttl is not None:
            pulumi.set(__self__, "dest_ttl", dest_ttl)

    @property
    @pulumi.getter(name="destLogstore")
    def dest_logstore(self) -> Optional[pulumi.Input[str]]:
        """
        When the central logstore is transferred to the destination logstore, its geographical attribute should be consistent with the destRegion and belong to the destProject.
        """
        return pulumi.get(self, "dest_logstore")

    @dest_logstore.setter
    def dest_logstore(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dest_logstore", value)

    @property
    @pulumi.getter(name="destProject")
    def dest_project(self) -> Optional[pulumi.Input[str]]:
        """
        The geographical attributes of the centralized transfer project should be consistent with the destRegion.
        """
        return pulumi.get(self, "dest_project")

    @dest_project.setter
    def dest_project(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dest_project", value)

    @property
    @pulumi.getter(name="destRegion")
    def dest_region(self) -> Optional[pulumi.Input[str]]:
        """
        Centralized transfer destination area.
        """
        return pulumi.get(self, "dest_region")

    @dest_region.setter
    def dest_region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dest_region", value)

    @property
    @pulumi.getter(name="destTtl")
    def dest_ttl(self) -> Optional[pulumi.Input[int]]:
        """
        The number of days for the central transfer destination. This is valid only if the central transfer destination log store is not created for the first time.
        """
        return pulumi.get(self, "dest_ttl")

    @dest_ttl.setter
    def dest_ttl(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "dest_ttl", value)


if not MYPY:
    class CollectionPolicyDataConfigArgsDict(TypedDict):
        data_project: NotRequired[pulumi.Input[str]]
        """
        Valid only when the log type is global. For example, if the productCode is sls, the log is collected to the default dedicated Project of the account in a specific dataRegion.
        """
        data_region: NotRequired[pulumi.Input[str]]
        """
        If and only if the log type is global log type, for example, if productCode is sls, global logs will be collected to the corresponding region during the first configuration.
        """
elif False:
    CollectionPolicyDataConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CollectionPolicyDataConfigArgs:
    def __init__(__self__, *,
                 data_project: Optional[pulumi.Input[str]] = None,
                 data_region: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] data_project: Valid only when the log type is global. For example, if the productCode is sls, the log is collected to the default dedicated Project of the account in a specific dataRegion.
        :param pulumi.Input[str] data_region: If and only if the log type is global log type, for example, if productCode is sls, global logs will be collected to the corresponding region during the first configuration.
        """
        if data_project is not None:
            pulumi.set(__self__, "data_project", data_project)
        if data_region is not None:
            pulumi.set(__self__, "data_region", data_region)

    @property
    @pulumi.getter(name="dataProject")
    def data_project(self) -> Optional[pulumi.Input[str]]:
        """
        Valid only when the log type is global. For example, if the productCode is sls, the log is collected to the default dedicated Project of the account in a specific dataRegion.
        """
        return pulumi.get(self, "data_project")

    @data_project.setter
    def data_project(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "data_project", value)

    @property
    @pulumi.getter(name="dataRegion")
    def data_region(self) -> Optional[pulumi.Input[str]]:
        """
        If and only if the log type is global log type, for example, if productCode is sls, global logs will be collected to the corresponding region during the first configuration.
        """
        return pulumi.get(self, "data_region")

    @data_region.setter
    def data_region(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "data_region", value)


if not MYPY:
    class CollectionPolicyPolicyConfigArgsDict(TypedDict):
        resource_mode: pulumi.Input[str]
        """
        Resource collection mode. If all is configured, all instances under the account will be collected to the default logstore. If attributeMode is configured, filtering will be performed according to the region attribute and resource label of the instance. If instanceMode is configured, filtering will be performed according to the instance ID.
        """
        instance_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        A collection of instance IDs, valid only if resourceMode is instanceMode. Only instances whose instance ID is in the instance ID collection are collected.
        """
        regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        The region collection to which the instance belongs. Valid only when resourceMode is set to attributeMode. Wildcard characters are supported. If the region collection filter item is an empty array, it means that you do not need to filter by region, and all instances meet the filtering condition of the region collection. Otherwise, only instances with region attributes in the region collection are collected. The region collection and resource label of the instance. The instance objects are collected only when all of them are met.
        """
        resource_tags: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
        """
        Resource label, valid if and only if resourceMode is attributeMode.

        If the resource label filter item is empty, it means that you do not need to filter by resource label, and all instances meet the resource label filter condition. Otherwise, only instances whose resource label attributes meet the resource label configuration are collected.

        The resource tag and the region collection to which the instance belongs work together. The instance objects are collected only when all of them are met.
        """
elif False:
    CollectionPolicyPolicyConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CollectionPolicyPolicyConfigArgs:
    def __init__(__self__, *,
                 resource_mode: pulumi.Input[str],
                 instance_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 regions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 resource_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] resource_mode: Resource collection mode. If all is configured, all instances under the account will be collected to the default logstore. If attributeMode is configured, filtering will be performed according to the region attribute and resource label of the instance. If instanceMode is configured, filtering will be performed according to the instance ID.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] instance_ids: A collection of instance IDs, valid only if resourceMode is instanceMode. Only instances whose instance ID is in the instance ID collection are collected.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] regions: The region collection to which the instance belongs. Valid only when resourceMode is set to attributeMode. Wildcard characters are supported. If the region collection filter item is an empty array, it means that you do not need to filter by region, and all instances meet the filtering condition of the region collection. Otherwise, only instances with region attributes in the region collection are collected. The region collection and resource label of the instance. The instance objects are collected only when all of them are met.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] resource_tags: Resource label, valid if and only if resourceMode is attributeMode.
               
               If the resource label filter item is empty, it means that you do not need to filter by resource label, and all instances meet the resource label filter condition. Otherwise, only instances whose resource label attributes meet the resource label configuration are collected.
               
               The resource tag and the region collection to which the instance belongs work together. The instance objects are collected only when all of them are met.
        """
        pulumi.set(__self__, "resource_mode", resource_mode)
        if instance_ids is not None:
            pulumi.set(__self__, "instance_ids", instance_ids)
        if regions is not None:
            pulumi.set(__self__, "regions", regions)
        if resource_tags is not None:
            pulumi.set(__self__, "resource_tags", resource_tags)

    @property
    @pulumi.getter(name="resourceMode")
    def resource_mode(self) -> pulumi.Input[str]:
        """
        Resource collection mode. If all is configured, all instances under the account will be collected to the default logstore. If attributeMode is configured, filtering will be performed according to the region attribute and resource label of the instance. If instanceMode is configured, filtering will be performed according to the instance ID.
        """
        return pulumi.get(self, "resource_mode")

    @resource_mode.setter
    def resource_mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "resource_mode", value)

    @property
    @pulumi.getter(name="instanceIds")
    def instance_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A collection of instance IDs, valid only if resourceMode is instanceMode. Only instances whose instance ID is in the instance ID collection are collected.
        """
        return pulumi.get(self, "instance_ids")

    @instance_ids.setter
    def instance_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "instance_ids", value)

    @property
    @pulumi.getter
    def regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The region collection to which the instance belongs. Valid only when resourceMode is set to attributeMode. Wildcard characters are supported. If the region collection filter item is an empty array, it means that you do not need to filter by region, and all instances meet the filtering condition of the region collection. Otherwise, only instances with region attributes in the region collection are collected. The region collection and resource label of the instance. The instance objects are collected only when all of them are met.
        """
        return pulumi.get(self, "regions")

    @regions.setter
    def regions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "regions", value)

    @property
    @pulumi.getter(name="resourceTags")
    def resource_tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Resource label, valid if and only if resourceMode is attributeMode.

        If the resource label filter item is empty, it means that you do not need to filter by resource label, and all instances meet the resource label filter condition. Otherwise, only instances whose resource label attributes meet the resource label configuration are collected.

        The resource tag and the region collection to which the instance belongs work together. The instance objects are collected only when all of them are met.
        """
        return pulumi.get(self, "resource_tags")

    @resource_tags.setter
    def resource_tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "resource_tags", value)


if not MYPY:
    class CollectionPolicyResourceDirectoryArgsDict(TypedDict):
        account_group_type: NotRequired[pulumi.Input[str]]
        """
        Support all mode all and custom mode custom under this resource directory
        """
        members: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        When the resource directory is configured in the custom mode, the corresponding member account list
        """
elif False:
    CollectionPolicyResourceDirectoryArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CollectionPolicyResourceDirectoryArgs:
    def __init__(__self__, *,
                 account_group_type: Optional[pulumi.Input[str]] = None,
                 members: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] account_group_type: Support all mode all and custom mode custom under this resource directory
        :param pulumi.Input[Sequence[pulumi.Input[str]]] members: When the resource directory is configured in the custom mode, the corresponding member account list
        """
        if account_group_type is not None:
            pulumi.set(__self__, "account_group_type", account_group_type)
        if members is not None:
            pulumi.set(__self__, "members", members)

    @property
    @pulumi.getter(name="accountGroupType")
    def account_group_type(self) -> Optional[pulumi.Input[str]]:
        """
        Support all mode all and custom mode custom under this resource directory
        """
        return pulumi.get(self, "account_group_type")

    @account_group_type.setter
    def account_group_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "account_group_type", value)

    @property
    @pulumi.getter
    def members(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        When the resource directory is configured in the custom mode, the corresponding member account list
        """
        return pulumi.get(self, "members")

    @members.setter
    def members(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "members", value)


if not MYPY:
    class ScheduledSqlScheduleArgsDict(TypedDict):
        cron_expression: NotRequired[pulumi.Input[str]]
        """
        Cron expression, minimum precision is minutes, 24-hour clock. For example, 0 0/1 **indicates that the check is performed every one hour from 00:00. When type is set to Cron, cronExpression must be set.
        """
        delay: NotRequired[pulumi.Input[int]]
        """
        Delay time.
        """
        interval: NotRequired[pulumi.Input[str]]
        """
        Time interval, such as 5m, 1H.
        """
        run_immediately: NotRequired[pulumi.Input[bool]]
        """
        Whether to execute the OSS import task immediately after it is created.
        """
        time_zone: NotRequired[pulumi.Input[str]]
        """
        Time Zone.
        """
        type: NotRequired[pulumi.Input[str]]
        """
        Check the frequency type. Log Service checks the query and analysis results based on the frequency you configured. The value is as follows: FixedRate: checks the query and analysis results at fixed intervals. Cron: specifies a time interval through a Cron expression, and checks the query and analysis results at the specified time interval. Weekly: Check the query and analysis results at a fixed point in time on the day of the week. Daily: checks the query and analysis results at a fixed time point every day. Hourly: Check query and analysis results every hour.
        """
elif False:
    ScheduledSqlScheduleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScheduledSqlScheduleArgs:
    def __init__(__self__, *,
                 cron_expression: Optional[pulumi.Input[str]] = None,
                 delay: Optional[pulumi.Input[int]] = None,
                 interval: Optional[pulumi.Input[str]] = None,
                 run_immediately: Optional[pulumi.Input[bool]] = None,
                 time_zone: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] cron_expression: Cron expression, minimum precision is minutes, 24-hour clock. For example, 0 0/1 **indicates that the check is performed every one hour from 00:00. When type is set to Cron, cronExpression must be set.
        :param pulumi.Input[int] delay: Delay time.
        :param pulumi.Input[str] interval: Time interval, such as 5m, 1H.
        :param pulumi.Input[bool] run_immediately: Whether to execute the OSS import task immediately after it is created.
        :param pulumi.Input[str] time_zone: Time Zone.
        :param pulumi.Input[str] type: Check the frequency type. Log Service checks the query and analysis results based on the frequency you configured. The value is as follows: FixedRate: checks the query and analysis results at fixed intervals. Cron: specifies a time interval through a Cron expression, and checks the query and analysis results at the specified time interval. Weekly: Check the query and analysis results at a fixed point in time on the day of the week. Daily: checks the query and analysis results at a fixed time point every day. Hourly: Check query and analysis results every hour.
        """
        if cron_expression is not None:
            pulumi.set(__self__, "cron_expression", cron_expression)
        if delay is not None:
            pulumi.set(__self__, "delay", delay)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if run_immediately is not None:
            pulumi.set(__self__, "run_immediately", run_immediately)
        if time_zone is not None:
            pulumi.set(__self__, "time_zone", time_zone)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="cronExpression")
    def cron_expression(self) -> Optional[pulumi.Input[str]]:
        """
        Cron expression, minimum precision is minutes, 24-hour clock. For example, 0 0/1 **indicates that the check is performed every one hour from 00:00. When type is set to Cron, cronExpression must be set.
        """
        return pulumi.get(self, "cron_expression")

    @cron_expression.setter
    def cron_expression(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cron_expression", value)

    @property
    @pulumi.getter
    def delay(self) -> Optional[pulumi.Input[int]]:
        """
        Delay time.
        """
        return pulumi.get(self, "delay")

    @delay.setter
    def delay(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "delay", value)

    @property
    @pulumi.getter
    def interval(self) -> Optional[pulumi.Input[str]]:
        """
        Time interval, such as 5m, 1H.
        """
        return pulumi.get(self, "interval")

    @interval.setter
    def interval(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "interval", value)

    @property
    @pulumi.getter(name="runImmediately")
    def run_immediately(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to execute the OSS import task immediately after it is created.
        """
        return pulumi.get(self, "run_immediately")

    @run_immediately.setter
    def run_immediately(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "run_immediately", value)

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> Optional[pulumi.Input[str]]:
        """
        Time Zone.
        """
        return pulumi.get(self, "time_zone")

    @time_zone.setter
    def time_zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "time_zone", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Check the frequency type. Log Service checks the query and analysis results based on the frequency you configured. The value is as follows: FixedRate: checks the query and analysis results at fixed intervals. Cron: specifies a time interval through a Cron expression, and checks the query and analysis results at the specified time interval. Weekly: Check the query and analysis results at a fixed point in time on the day of the week. Daily: checks the query and analysis results at a fixed time point every day. Hourly: Check query and analysis results every hour.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


if not MYPY:
    class ScheduledSqlScheduledSqlConfigurationArgsDict(TypedDict):
        data_format: NotRequired[pulumi.Input[str]]
        """
        Write Mode.
        """
        dest_endpoint: NotRequired[pulumi.Input[str]]
        """
        Target Endpoint.
        """
        dest_logstore: NotRequired[pulumi.Input[str]]
        """
        Target Logstore.
        """
        dest_project: NotRequired[pulumi.Input[str]]
        """
        Target Project.
        """
        dest_role_arn: NotRequired[pulumi.Input[str]]
        """
        Write target role ARN.
        """
        from_time: NotRequired[pulumi.Input[int]]
        """
        Schedule Start Time.
        """
        from_time_expr: NotRequired[pulumi.Input[str]]
        """
        SQL time window-start.
        """
        max_retries: NotRequired[pulumi.Input[int]]
        """
        Maximum retries.
        """
        max_run_time_in_seconds: NotRequired[pulumi.Input[int]]
        """
        SQL timeout.
        """
        parameters: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
        """
        Parameter configuration.
        """
        resource_pool: NotRequired[pulumi.Input[str]]
        """
        Resource Pool.
        """
        role_arn: NotRequired[pulumi.Input[str]]
        """
        Read role ARN.
        """
        script: NotRequired[pulumi.Input[str]]
        """
        SQL statement.
        """
        source_logstore: NotRequired[pulumi.Input[str]]
        """
        Source Logstore.
        """
        sql_type: NotRequired[pulumi.Input[str]]
        """
        SQL type.
        """
        to_time: NotRequired[pulumi.Input[int]]
        """
        Time at end of schedule.
        """
        to_time_expr: NotRequired[pulumi.Input[str]]
        """
        SQL time window-end.
        """
elif False:
    ScheduledSqlScheduledSqlConfigurationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScheduledSqlScheduledSqlConfigurationArgs:
    def __init__(__self__, *,
                 data_format: Optional[pulumi.Input[str]] = None,
                 dest_endpoint: Optional[pulumi.Input[str]] = None,
                 dest_logstore: Optional[pulumi.Input[str]] = None,
                 dest_project: Optional[pulumi.Input[str]] = None,
                 dest_role_arn: Optional[pulumi.Input[str]] = None,
                 from_time: Optional[pulumi.Input[int]] = None,
                 from_time_expr: Optional[pulumi.Input[str]] = None,
                 max_retries: Optional[pulumi.Input[int]] = None,
                 max_run_time_in_seconds: Optional[pulumi.Input[int]] = None,
                 parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 resource_pool: Optional[pulumi.Input[str]] = None,
                 role_arn: Optional[pulumi.Input[str]] = None,
                 script: Optional[pulumi.Input[str]] = None,
                 source_logstore: Optional[pulumi.Input[str]] = None,
                 sql_type: Optional[pulumi.Input[str]] = None,
                 to_time: Optional[pulumi.Input[int]] = None,
                 to_time_expr: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] data_format: Write Mode.
        :param pulumi.Input[str] dest_endpoint: Target Endpoint.
        :param pulumi.Input[str] dest_logstore: Target Logstore.
        :param pulumi.Input[str] dest_project: Target Project.
        :param pulumi.Input[str] dest_role_arn: Write target role ARN.
        :param pulumi.Input[int] from_time: Schedule Start Time.
        :param pulumi.Input[str] from_time_expr: SQL time window-start.
        :param pulumi.Input[int] max_retries: Maximum retries.
        :param pulumi.Input[int] max_run_time_in_seconds: SQL timeout.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] parameters: Parameter configuration.
        :param pulumi.Input[str] resource_pool: Resource Pool.
        :param pulumi.Input[str] role_arn: Read role ARN.
        :param pulumi.Input[str] script: SQL statement.
        :param pulumi.Input[str] source_logstore: Source Logstore.
        :param pulumi.Input[str] sql_type: SQL type.
        :param pulumi.Input[int] to_time: Time at end of schedule.
        :param pulumi.Input[str] to_time_expr: SQL time window-end.
        """
        if data_format is not None:
            pulumi.set(__self__, "data_format", data_format)
        if dest_endpoint is not None:
            pulumi.set(__self__, "dest_endpoint", dest_endpoint)
        if dest_logstore is not None:
            pulumi.set(__self__, "dest_logstore", dest_logstore)
        if dest_project is not None:
            pulumi.set(__self__, "dest_project", dest_project)
        if dest_role_arn is not None:
            pulumi.set(__self__, "dest_role_arn", dest_role_arn)
        if from_time is not None:
            pulumi.set(__self__, "from_time", from_time)
        if from_time_expr is not None:
            pulumi.set(__self__, "from_time_expr", from_time_expr)
        if max_retries is not None:
            pulumi.set(__self__, "max_retries", max_retries)
        if max_run_time_in_seconds is not None:
            pulumi.set(__self__, "max_run_time_in_seconds", max_run_time_in_seconds)
        if parameters is not None:
            pulumi.set(__self__, "parameters", parameters)
        if resource_pool is not None:
            pulumi.set(__self__, "resource_pool", resource_pool)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if script is not None:
            pulumi.set(__self__, "script", script)
        if source_logstore is not None:
            pulumi.set(__self__, "source_logstore", source_logstore)
        if sql_type is not None:
            pulumi.set(__self__, "sql_type", sql_type)
        if to_time is not None:
            pulumi.set(__self__, "to_time", to_time)
        if to_time_expr is not None:
            pulumi.set(__self__, "to_time_expr", to_time_expr)

    @property
    @pulumi.getter(name="dataFormat")
    def data_format(self) -> Optional[pulumi.Input[str]]:
        """
        Write Mode.
        """
        return pulumi.get(self, "data_format")

    @data_format.setter
    def data_format(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "data_format", value)

    @property
    @pulumi.getter(name="destEndpoint")
    def dest_endpoint(self) -> Optional[pulumi.Input[str]]:
        """
        Target Endpoint.
        """
        return pulumi.get(self, "dest_endpoint")

    @dest_endpoint.setter
    def dest_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dest_endpoint", value)

    @property
    @pulumi.getter(name="destLogstore")
    def dest_logstore(self) -> Optional[pulumi.Input[str]]:
        """
        Target Logstore.
        """
        return pulumi.get(self, "dest_logstore")

    @dest_logstore.setter
    def dest_logstore(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dest_logstore", value)

    @property
    @pulumi.getter(name="destProject")
    def dest_project(self) -> Optional[pulumi.Input[str]]:
        """
        Target Project.
        """
        return pulumi.get(self, "dest_project")

    @dest_project.setter
    def dest_project(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dest_project", value)

    @property
    @pulumi.getter(name="destRoleArn")
    def dest_role_arn(self) -> Optional[pulumi.Input[str]]:
        """
        Write target role ARN.
        """
        return pulumi.get(self, "dest_role_arn")

    @dest_role_arn.setter
    def dest_role_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dest_role_arn", value)

    @property
    @pulumi.getter(name="fromTime")
    def from_time(self) -> Optional[pulumi.Input[int]]:
        """
        Schedule Start Time.
        """
        return pulumi.get(self, "from_time")

    @from_time.setter
    def from_time(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "from_time", value)

    @property
    @pulumi.getter(name="fromTimeExpr")
    def from_time_expr(self) -> Optional[pulumi.Input[str]]:
        """
        SQL time window-start.
        """
        return pulumi.get(self, "from_time_expr")

    @from_time_expr.setter
    def from_time_expr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "from_time_expr", value)

    @property
    @pulumi.getter(name="maxRetries")
    def max_retries(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum retries.
        """
        return pulumi.get(self, "max_retries")

    @max_retries.setter
    def max_retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_retries", value)

    @property
    @pulumi.getter(name="maxRunTimeInSeconds")
    def max_run_time_in_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        SQL timeout.
        """
        return pulumi.get(self, "max_run_time_in_seconds")

    @max_run_time_in_seconds.setter
    def max_run_time_in_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_run_time_in_seconds", value)

    @property
    @pulumi.getter
    def parameters(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Parameter configuration.
        """
        return pulumi.get(self, "parameters")

    @parameters.setter
    def parameters(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "parameters", value)

    @property
    @pulumi.getter(name="resourcePool")
    def resource_pool(self) -> Optional[pulumi.Input[str]]:
        """
        Resource Pool.
        """
        return pulumi.get(self, "resource_pool")

    @resource_pool.setter
    def resource_pool(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resource_pool", value)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> Optional[pulumi.Input[str]]:
        """
        Read role ARN.
        """
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "role_arn", value)

    @property
    @pulumi.getter
    def script(self) -> Optional[pulumi.Input[str]]:
        """
        SQL statement.
        """
        return pulumi.get(self, "script")

    @script.setter
    def script(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "script", value)

    @property
    @pulumi.getter(name="sourceLogstore")
    def source_logstore(self) -> Optional[pulumi.Input[str]]:
        """
        Source Logstore.
        """
        return pulumi.get(self, "source_logstore")

    @source_logstore.setter
    def source_logstore(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "source_logstore", value)

    @property
    @pulumi.getter(name="sqlType")
    def sql_type(self) -> Optional[pulumi.Input[str]]:
        """
        SQL type.
        """
        return pulumi.get(self, "sql_type")

    @sql_type.setter
    def sql_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sql_type", value)

    @property
    @pulumi.getter(name="toTime")
    def to_time(self) -> Optional[pulumi.Input[int]]:
        """
        Time at end of schedule.
        """
        return pulumi.get(self, "to_time")

    @to_time.setter
    def to_time(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "to_time", value)

    @property
    @pulumi.getter(name="toTimeExpr")
    def to_time_expr(self) -> Optional[pulumi.Input[str]]:
        """
        SQL time window-end.
        """
        return pulumi.get(self, "to_time_expr")

    @to_time_expr.setter
    def to_time_expr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "to_time_expr", value)


