# 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
from . import outputs

__all__ = [
    'AlertConfiguration',
    'AlertConfigurationAnnotation',
    'AlertConfigurationConditionConfiguration',
    'AlertConfigurationGroupConfiguration',
    'AlertConfigurationJoinConfiguration',
    'AlertConfigurationLabel',
    'AlertConfigurationPolicyConfiguration',
    'AlertConfigurationQueryList',
    'AlertConfigurationSeverityConfiguration',
    'AlertConfigurationSeverityConfigurationEvalCondition',
    'AlertConfigurationSinkAlerthub',
    'AlertConfigurationSinkCms',
    'AlertConfigurationSinkEventStore',
    'AlertConfigurationTemplateConfiguration',
    'AlertSchedule',
    'CollectionPolicyCentralizeConfig',
    'CollectionPolicyDataConfig',
    'CollectionPolicyPolicyConfig',
    'CollectionPolicyResourceDirectory',
    'ScheduledSqlSchedule',
    'ScheduledSqlScheduledSqlConfiguration',
]

@pulumi.output_type
class AlertConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoAnnotation":
            suggest = "auto_annotation"
        elif key == "conditionConfiguration":
            suggest = "condition_configuration"
        elif key == "groupConfiguration":
            suggest = "group_configuration"
        elif key == "joinConfigurations":
            suggest = "join_configurations"
        elif key == "muteUntil":
            suggest = "mute_until"
        elif key == "noDataFire":
            suggest = "no_data_fire"
        elif key == "noDataSeverity":
            suggest = "no_data_severity"
        elif key == "policyConfiguration":
            suggest = "policy_configuration"
        elif key == "queryLists":
            suggest = "query_lists"
        elif key == "sendResolved":
            suggest = "send_resolved"
        elif key == "severityConfigurations":
            suggest = "severity_configurations"
        elif key == "sinkAlerthub":
            suggest = "sink_alerthub"
        elif key == "sinkCms":
            suggest = "sink_cms"
        elif key == "sinkEventStore":
            suggest = "sink_event_store"
        elif key == "templateConfiguration":
            suggest = "template_configuration"

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

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

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

    def __init__(__self__, *,
                 annotations: Optional[Sequence['outputs.AlertConfigurationAnnotation']] = None,
                 auto_annotation: Optional[bool] = None,
                 condition_configuration: Optional['outputs.AlertConfigurationConditionConfiguration'] = None,
                 dashboard: Optional[str] = None,
                 group_configuration: Optional['outputs.AlertConfigurationGroupConfiguration'] = None,
                 join_configurations: Optional[Sequence['outputs.AlertConfigurationJoinConfiguration']] = None,
                 labels: Optional[Sequence['outputs.AlertConfigurationLabel']] = None,
                 mute_until: Optional[int] = None,
                 no_data_fire: Optional[bool] = None,
                 no_data_severity: Optional[int] = None,
                 policy_configuration: Optional['outputs.AlertConfigurationPolicyConfiguration'] = None,
                 query_lists: Optional[Sequence['outputs.AlertConfigurationQueryList']] = None,
                 send_resolved: Optional[bool] = None,
                 severity_configurations: Optional[Sequence['outputs.AlertConfigurationSeverityConfiguration']] = None,
                 sink_alerthub: Optional['outputs.AlertConfigurationSinkAlerthub'] = None,
                 sink_cms: Optional['outputs.AlertConfigurationSinkCms'] = None,
                 sink_event_store: Optional['outputs.AlertConfigurationSinkEventStore'] = None,
                 tags: Optional[Sequence[str]] = None,
                 template_configuration: Optional['outputs.AlertConfigurationTemplateConfiguration'] = None,
                 threshold: Optional[int] = None,
                 type: Optional[str] = None,
                 version: Optional[str] = None):
        """
        :param Sequence['AlertConfigurationAnnotationArgs'] annotations: Template Annotations.
        :param 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 'AlertConfigurationConditionConfigurationArgs' condition_configuration: Alarm trigger condition. See `condition_configuration` below.
        :param str dashboard: The instrument cluster associated with the alarm. It is recommended to set to internal-alert-analysis.
        :param 'AlertConfigurationGroupConfigurationArgs' group_configuration: Group evaluation configuration. See `group_configuration` below.
        :param Sequence['AlertConfigurationJoinConfigurationArgs'] join_configurations: Set operation configuration. See `join_configurations` below.
        :param Sequence['AlertConfigurationLabelArgs'] labels: Label. See `labels` below.
        :param int mute_until: Second-level timestamp representing the temporary shutdown deadline.
        :param 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 int no_data_severity: Alarm severity when no data triggers an alarm.
        :param 'AlertConfigurationPolicyConfigurationArgs' policy_configuration: Alert policy configuration. See `policy_configuration` below.
        :param Sequence['AlertConfigurationQueryListArgs'] query_lists: Query the statistical list. See `query_list` below.
        :param 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 Sequence['AlertConfigurationSeverityConfigurationArgs'] severity_configurations: Trigger condition, set at least one trigger condition. See `severity_configurations` below.
        :param 'AlertConfigurationSinkAlerthubArgs' sink_alerthub: Configuration of Alerts Sent to Alerthub. See `sink_alerthub` below.
        :param 'AlertConfigurationSinkCmsArgs' sink_cms: Configure alerts sent to CloudMonitor. See `sink_cms` below.
        :param 'AlertConfigurationSinkEventStoreArgs' sink_event_store: Configuration of sending alarms to EventStore. See `sink_event_store` below.
        :param Sequence[str] tags: Customize the category of alarm monitoring rules.
        :param 'AlertConfigurationTemplateConfigurationArgs' template_configuration: Alarm rule template configuration. See `template_configuration` below.
        :param 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 str type: Template Type.
        :param 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[Sequence['outputs.AlertConfigurationAnnotation']]:
        """
        Template Annotations.
        """
        return pulumi.get(self, "annotations")

    @property
    @pulumi.getter(name="autoAnnotation")
    def auto_annotation(self) -> Optional[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")

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

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

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

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

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

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

    @property
    @pulumi.getter(name="noDataFire")
    def no_data_fire(self) -> Optional[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")

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

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

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

    @property
    @pulumi.getter(name="sendResolved")
    def send_resolved(self) -> Optional[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")

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

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

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

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

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

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

    @property
    @pulumi.getter
    def threshold(self) -> Optional[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")

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

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


@pulumi.output_type
class AlertConfigurationAnnotation(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str key: Field name.
        :param 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[str]:
        """
        Field name.
        """
        return pulumi.get(self, "key")

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


@pulumi.output_type
class AlertConfigurationConditionConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "countCondition":
            suggest = "count_condition"

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

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

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

    def __init__(__self__, *,
                 condition: Optional[str] = None,
                 count_condition: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter(name="countCondition")
    def count_condition(self) -> Optional[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")


@pulumi.output_type
class AlertConfigurationGroupConfiguration(dict):
    def __init__(__self__, *,
                 fields: Optional[Sequence[str]] = None,
                 type: Optional[str] = None):
        """
        :param Sequence[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[Sequence[str]]:
        """
        The field used for grouping evaluation. When type is set to custom, fields must be set.
        """
        return pulumi.get(self, "fields")

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


@pulumi.output_type
class AlertConfigurationJoinConfiguration(dict):
    def __init__(__self__, *,
                 condition: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param 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[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")

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


@pulumi.output_type
class AlertConfigurationLabel(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str key: Field name.
        :param 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[str]:
        """
        Field name.
        """
        return pulumi.get(self, "key")

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


@pulumi.output_type
class AlertConfigurationPolicyConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "actionPolicyId":
            suggest = "action_policy_id"
        elif key == "alertPolicyId":
            suggest = "alert_policy_id"
        elif key == "repeatInterval":
            suggest = "repeat_interval"

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

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

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

    def __init__(__self__, *,
                 action_policy_id: Optional[str] = None,
                 alert_policy_id: Optional[str] = None,
                 repeat_interval: Optional[str] = None):
        """
        :param 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 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 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[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")

    @property
    @pulumi.getter(name="alertPolicyId")
    def alert_policy_id(self) -> Optional[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")

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


@pulumi.output_type
class AlertConfigurationQueryList(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "chartTitle":
            suggest = "chart_title"
        elif key == "dashboardId":
            suggest = "dashboard_id"
        elif key == "powerSqlMode":
            suggest = "power_sql_mode"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "storeType":
            suggest = "store_type"
        elif key == "timeSpanType":
            suggest = "time_span_type"

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

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

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

    def __init__(__self__, *,
                 chart_title: Optional[str] = None,
                 dashboard_id: Optional[str] = None,
                 end: Optional[str] = None,
                 power_sql_mode: Optional[str] = None,
                 project: Optional[str] = None,
                 query: Optional[str] = None,
                 region: Optional[str] = None,
                 role_arn: Optional[str] = None,
                 start: Optional[str] = None,
                 store: Optional[str] = None,
                 store_type: Optional[str] = None,
                 time_span_type: Optional[str] = None,
                 ui: Optional[str] = None):
        """
        :param str chart_title: Chart Name.
        :param str dashboard_id: Dashboard ID.
        :param str end: End time. When storeType is set to log or metric, end must be set.
        :param str power_sql_mode: Whether to use exclusive SQL. The value is as follows: auto: automatic switching. enable: Starts. disable: disable.
        :param str project: Project Name.
        :param 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 str region: Region of the target Project.
        :param str role_arn: Roles used to write alarm data to the event Library.
        :param str start: Start time. When storeType is set to log or metric, start must be set.
        :param 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 str store_type: Query the data source type. The value is as follows: log: Logstore. metric: Time series Library. meta: resource data.
        :param str time_span_type: Time Type.
        :param 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[str]:
        """
        Chart Name.
        """
        return pulumi.get(self, "chart_title")

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

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

    @property
    @pulumi.getter(name="powerSqlMode")
    def power_sql_mode(self) -> Optional[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")

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

    @property
    @pulumi.getter
    def query(self) -> Optional[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")

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

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

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

    @property
    @pulumi.getter
    def store(self) -> Optional[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")

    @property
    @pulumi.getter(name="storeType")
    def store_type(self) -> Optional[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")

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

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


@pulumi.output_type
class AlertConfigurationSeverityConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "evalCondition":
            suggest = "eval_condition"

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

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

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

    def __init__(__self__, *,
                 eval_condition: Optional['outputs.AlertConfigurationSeverityConfigurationEvalCondition'] = None,
                 severity: Optional[int] = None):
        """
        :param 'AlertConfigurationSeverityConfigurationEvalConditionArgs' eval_condition: Trigger condition. See `eval_condition` below.
        :param 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['outputs.AlertConfigurationSeverityConfigurationEvalCondition']:
        """
        Trigger condition. See `eval_condition` below.
        """
        return pulumi.get(self, "eval_condition")

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


@pulumi.output_type
class AlertConfigurationSeverityConfigurationEvalCondition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "countCondition":
            suggest = "count_condition"

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

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

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

    def __init__(__self__, *,
                 condition: Optional[str] = None,
                 count_condition: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter(name="countCondition")
    def count_condition(self) -> Optional[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")


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

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


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

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


@pulumi.output_type
class AlertConfigurationSinkEventStore(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "eventStore":
            suggest = "event_store"
        elif key == "roleArn":
            suggest = "role_arn"

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

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

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

    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 endpoint: Optional[str] = None,
                 event_store: Optional[str] = None,
                 project: Optional[str] = None,
                 role_arn: Optional[str] = None):
        """
        :param bool enabled: Open.
        :param str endpoint: SLS service endpoint.
        :param str event_store: Event Library Name.
        :param str project: Project Name.
        :param 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[bool]:
        """
        Open.
        """
        return pulumi.get(self, "enabled")

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

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

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

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


@pulumi.output_type
class AlertConfigurationTemplateConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "templateId":
            suggest = "template_id"

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

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

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

    def __init__(__self__, *,
                 annotations: Optional[Mapping[str, str]] = None,
                 lang: Optional[str] = None,
                 template_id: Optional[str] = None,
                 tokens: Optional[Mapping[str, str]] = None,
                 type: Optional[str] = None,
                 version: Optional[str] = None):
        """
        :param Mapping[str, str] annotations: Template Annotations.
        :param str lang: Template Language.
        :param str template_id: Template ID.
        :param Mapping[str, str] tokens: Template Variables.
        :param 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[Mapping[str, str]]:
        """
        Template Annotations.
        """
        return pulumi.get(self, "annotations")

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

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

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

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

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


@pulumi.output_type
class AlertSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cronExpression":
            suggest = "cron_expression"
        elif key == "runImmdiately":
            suggest = "run_immdiately"
        elif key == "timeZone":
            suggest = "time_zone"

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

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

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

    def __init__(__self__, *,
                 cron_expression: Optional[str] = None,
                 delay: Optional[int] = None,
                 interval: Optional[str] = None,
                 run_immdiately: Optional[bool] = None,
                 time_zone: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param 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 int delay: Timed task execution delay (unit: s).
        :param str interval: Fixed interval for scheduling.
        :param bool run_immdiately: Dispatch immediately.
        :param 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 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[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")

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

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

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

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> Optional[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")

    @property
    @pulumi.getter
    def type(self) -> Optional[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")


@pulumi.output_type
class CollectionPolicyCentralizeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "destLogstore":
            suggest = "dest_logstore"
        elif key == "destProject":
            suggest = "dest_project"
        elif key == "destRegion":
            suggest = "dest_region"
        elif key == "destTtl":
            suggest = "dest_ttl"

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

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

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

    def __init__(__self__, *,
                 dest_logstore: Optional[str] = None,
                 dest_project: Optional[str] = None,
                 dest_region: Optional[str] = None,
                 dest_ttl: Optional[int] = None):
        """
        :param 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 str dest_project: The geographical attributes of the centralized transfer project should be consistent with the destRegion.
        :param str dest_region: Centralized transfer destination area.
        :param 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[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")

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

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

    @property
    @pulumi.getter(name="destTtl")
    def dest_ttl(self) -> Optional[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")


@pulumi.output_type
class CollectionPolicyDataConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dataProject":
            suggest = "data_project"
        elif key == "dataRegion":
            suggest = "data_region"

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

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

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

    def __init__(__self__, *,
                 data_project: Optional[str] = None,
                 data_region: Optional[str] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter(name="dataRegion")
    def data_region(self) -> Optional[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")


@pulumi.output_type
class CollectionPolicyPolicyConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceMode":
            suggest = "resource_mode"
        elif key == "instanceIds":
            suggest = "instance_ids"
        elif key == "resourceTags":
            suggest = "resource_tags"

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

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

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

    def __init__(__self__, *,
                 resource_mode: str,
                 instance_ids: Optional[Sequence[str]] = None,
                 regions: Optional[Sequence[str]] = None,
                 resource_tags: Optional[Mapping[str, str]] = None):
        """
        :param 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 Sequence[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 Sequence[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 Mapping[str, 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) -> 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")

    @property
    @pulumi.getter(name="instanceIds")
    def instance_ids(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter
    def regions(self) -> Optional[Sequence[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")

    @property
    @pulumi.getter(name="resourceTags")
    def resource_tags(self) -> Optional[Mapping[str, 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")


@pulumi.output_type
class CollectionPolicyResourceDirectory(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountGroupType":
            suggest = "account_group_type"

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

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

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

    def __init__(__self__, *,
                 account_group_type: Optional[str] = None,
                 members: Optional[Sequence[str]] = None):
        """
        :param str account_group_type: Support all mode all and custom mode custom under this resource directory
        :param Sequence[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[str]:
        """
        Support all mode all and custom mode custom under this resource directory
        """
        return pulumi.get(self, "account_group_type")

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


@pulumi.output_type
class ScheduledSqlSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cronExpression":
            suggest = "cron_expression"
        elif key == "runImmediately":
            suggest = "run_immediately"
        elif key == "timeZone":
            suggest = "time_zone"

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

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

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

    def __init__(__self__, *,
                 cron_expression: Optional[str] = None,
                 delay: Optional[int] = None,
                 interval: Optional[str] = None,
                 run_immediately: Optional[bool] = None,
                 time_zone: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param 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 int delay: Delay time.
        :param str interval: Time interval, such as 5m, 1H.
        :param bool run_immediately: Whether to execute the OSS import task immediately after it is created.
        :param str time_zone: Time Zone.
        :param 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[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")

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

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

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

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

    @property
    @pulumi.getter
    def type(self) -> Optional[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")


@pulumi.output_type
class ScheduledSqlScheduledSqlConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dataFormat":
            suggest = "data_format"
        elif key == "destEndpoint":
            suggest = "dest_endpoint"
        elif key == "destLogstore":
            suggest = "dest_logstore"
        elif key == "destProject":
            suggest = "dest_project"
        elif key == "destRoleArn":
            suggest = "dest_role_arn"
        elif key == "fromTime":
            suggest = "from_time"
        elif key == "fromTimeExpr":
            suggest = "from_time_expr"
        elif key == "maxRetries":
            suggest = "max_retries"
        elif key == "maxRunTimeInSeconds":
            suggest = "max_run_time_in_seconds"
        elif key == "resourcePool":
            suggest = "resource_pool"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "sourceLogstore":
            suggest = "source_logstore"
        elif key == "sqlType":
            suggest = "sql_type"
        elif key == "toTime":
            suggest = "to_time"
        elif key == "toTimeExpr":
            suggest = "to_time_expr"

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

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

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

    def __init__(__self__, *,
                 data_format: Optional[str] = None,
                 dest_endpoint: Optional[str] = None,
                 dest_logstore: Optional[str] = None,
                 dest_project: Optional[str] = None,
                 dest_role_arn: Optional[str] = None,
                 from_time: Optional[int] = None,
                 from_time_expr: Optional[str] = None,
                 max_retries: Optional[int] = None,
                 max_run_time_in_seconds: Optional[int] = None,
                 parameters: Optional[Mapping[str, str]] = None,
                 resource_pool: Optional[str] = None,
                 role_arn: Optional[str] = None,
                 script: Optional[str] = None,
                 source_logstore: Optional[str] = None,
                 sql_type: Optional[str] = None,
                 to_time: Optional[int] = None,
                 to_time_expr: Optional[str] = None):
        """
        :param str data_format: Write Mode.
        :param str dest_endpoint: Target Endpoint.
        :param str dest_logstore: Target Logstore.
        :param str dest_project: Target Project.
        :param str dest_role_arn: Write target role ARN.
        :param int from_time: Schedule Start Time.
        :param str from_time_expr: SQL time window-start.
        :param int max_retries: Maximum retries.
        :param int max_run_time_in_seconds: SQL timeout.
        :param Mapping[str, str] parameters: Parameter configuration.
        :param str resource_pool: Resource Pool.
        :param str role_arn: Read role ARN.
        :param str script: SQL statement.
        :param str source_logstore: Source Logstore.
        :param str sql_type: SQL type.
        :param int to_time: Time at end of schedule.
        :param 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[str]:
        """
        Write Mode.
        """
        return pulumi.get(self, "data_format")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


