pulumi-alicloud 3.53.0a1713354491__py3-none-any.whl → 3.73.0a1736850863__py3-none-any.whl

pulumi_alicloud/sls/outputs.py

@@ -0,0 +1,2148 @@
+# 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',
+    'OssExportSinkConfiguration',
+    'OssExportSinkConfigurationSink',
+    '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 OssExportSinkConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "fromTime":
+            suggest = "from_time"
+        elif key == "roleArn":
+            suggest = "role_arn"
+        elif key == "toTime":
+            suggest = "to_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OssExportSinkConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OssExportSinkConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OssExportSinkConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 from_time: int,
+                 logstore: str,
+                 role_arn: str,
+                 sink: 'outputs.OssExportSinkConfigurationSink',
+                 to_time: int):
+        """
+        :param int from_time: The beginning of the time range to ship data. The value 1 specifies that the data shipping job ships data from the first log in the Logstore. Example value: 1718380800
+        :param str logstore: The name of the Logstore.
+        :param str role_arn: The ARN of the RAM role that is used to write data to OSS. Example value: acs:ram::xxxxxxx
+        :param 'OssExportSinkConfigurationSinkArgs' sink: The configurations of the Object Storage Service (OSS) data shipping job. See `sink` below.
+        :param int to_time: The end of the time range to ship data. The value 0 specifies that the data shipping job continuously ships data until the job is manually stopped. Example value: 1718380800
+        """
+        pulumi.set(__self__, "from_time", from_time)
+        pulumi.set(__self__, "logstore", logstore)
+        pulumi.set(__self__, "role_arn", role_arn)
+        pulumi.set(__self__, "sink", sink)
+        pulumi.set(__self__, "to_time", to_time)
+
+    @property
+    @pulumi.getter(name="fromTime")
+    def from_time(self) -> int:
+        """
+        The beginning of the time range to ship data. The value 1 specifies that the data shipping job ships data from the first log in the Logstore. Example value: 1718380800
+        """
+        return pulumi.get(self, "from_time")
+
+    @property
+    @pulumi.getter
+    def logstore(self) -> str:
+        """
+        The name of the Logstore.
+        """
+        return pulumi.get(self, "logstore")
+
+    @property
+    @pulumi.getter(name="roleArn")
+    def role_arn(self) -> str:
+        """
+        The ARN of the RAM role that is used to write data to OSS. Example value: acs:ram::xxxxxxx
+        """
+        return pulumi.get(self, "role_arn")
+
+    @property
+    @pulumi.getter
+    def sink(self) -> 'outputs.OssExportSinkConfigurationSink':
+        """
+        The configurations of the Object Storage Service (OSS) data shipping job. See `sink` below.
+        """
+        return pulumi.get(self, "sink")
+
+    @property
+    @pulumi.getter(name="toTime")
+    def to_time(self) -> int:
+        """
+        The end of the time range to ship data. The value 0 specifies that the data shipping job continuously ships data until the job is manually stopped. Example value: 1718380800
+        """
+        return pulumi.get(self, "to_time")
+
+
+@pulumi.output_type
+class OssExportSinkConfigurationSink(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "bufferInterval":
+            suggest = "buffer_interval"
+        elif key == "bufferSize":
+            suggest = "buffer_size"
+        elif key == "compressionType":
+            suggest = "compression_type"
+        elif key == "contentDetail":
+            suggest = "content_detail"
+        elif key == "contentType":
+            suggest = "content_type"
+        elif key == "roleArn":
+            suggest = "role_arn"
+        elif key == "timeZone":
+            suggest = "time_zone"
+        elif key == "delaySeconds":
+            suggest = "delay_seconds"
+        elif key == "pathFormat":
+            suggest = "path_format"
+        elif key == "pathFormatType":
+            suggest = "path_format_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OssExportSinkConfigurationSink. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OssExportSinkConfigurationSink.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OssExportSinkConfigurationSink.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bucket: str,
+                 buffer_interval: str,
+                 buffer_size: str,
+                 compression_type: str,
+                 content_detail: str,
+                 content_type: str,
+                 endpoint: str,
+                 role_arn: str,
+                 time_zone: str,
+                 delay_seconds: Optional[int] = None,
+                 path_format: Optional[str] = None,
+                 path_format_type: Optional[str] = None,
+                 prefix: Optional[str] = None,
+                 suffix: Optional[str] = None):
+        """
+        :param str bucket: The OSS bucket.
+        :param str buffer_interval: The interval between two data shipping operations. Valid values: 300 to 900. Unit: seconds.
+        :param str buffer_size: The size of the OSS object to which data is shipped. Valid values: 5 to 256. Unit: MB.
+        :param str compression_type: Supports four compression types, such as snappy, gzip, zstd, and none.
+        :param str content_detail: The OSS file content details. Note: the value of this parameter should be updated based on the value of the contentType parameter.
+               
+               If the contentType value is JSON, the parameters of the contentDetail value are as follows:
+               
+               If the tag is allowed to be posted, the value of the parameter enableTag is true. Example:{"enableTag": true}
+               
+               You are not allowed to post tags. The value of the parameter enableTag is false. Example:{"enableTag": false}
+               
+               If the contentType value is csv, the parameters of the contentDetail value are as follows:
+               
+               The parameter columns is the key of the log in the source logstore.
+               
+               The delimiter parameter, which can be ",","|","", or "\\t".
+               
+               The header parameter determines whether the OSS file retains the header. The optional value is true or false.
+               
+               The lineFeed parameter. Optional values are "\\t", "\\n", or "".
+               
+               The invalid field content parameter is null to specify the delivery content when the field name does not exist.
+               
+               The escape character parameter "quote". Optional values are "" "," '", or" ".
+               
+               Example:{"null": "-", "header": false, "lineFeed": "\\n", "quote": "", "delimiter": ",", "columns": ["a", "B", "c", "d"]}
+               
+               When the contentType value is parquet, the parameters of the contentDetail value are as follows:
+               
+               The columns parameter is the key of the log in the source Logstore and must carry the data type of the key, for example:{"columns": [{"name": "a", "type": "string"}, {"name": "B", "type": "string"}, {"name": "c", "type": "string": "string"}]}
+               
+               When the contentType value is set to orc, the parameters of the contentDetail value are as follows:
+               
+               The columns parameter is the key of the log in the source Logstore and must carry the data type of the key, for example:{"columns": [{"name": "a", "type": "string"}, {"name": "B", "type": "string"}, {"name": "c", "type": "string": "string"}]}
+        :param str content_type: The storage format of the OSS object. Valid values: json, parquet, csv, and orc.
+        :param str endpoint: The OSS Endpoint can only be an OSS intranet Endpoint and only supports the same region. Example value: https://oss-cn-hangzhou-internal.aliyuncs.com
+        :param str role_arn: The ARN of the RAM role that is used to write data to OSS. Example value: acs:ram::xxxxxxx
+        :param str time_zone: The time zone. Example value: +0800
+        :param int delay_seconds: The latency of data shipping. The value of this parameter cannot exceed the data retention period of the source Logstore.
+        :param str path_format: The directory is dynamically generated according to the time. The default value is% Y/%m/%d/%H/%M. The corresponding generated directory is, for example, 2017/01/23/12/00. Note that the partition format cannot start and end. Example values:%Y/%m/%d
+        :param str path_format_type: The partition format type. only support time
+        :param str prefix: The prefix of the OSS object.
+        :param str suffix: The suffix of the OSS object.
+        """
+        pulumi.set(__self__, "bucket", bucket)
+        pulumi.set(__self__, "buffer_interval", buffer_interval)
+        pulumi.set(__self__, "buffer_size", buffer_size)
+        pulumi.set(__self__, "compression_type", compression_type)
+        pulumi.set(__self__, "content_detail", content_detail)
+        pulumi.set(__self__, "content_type", content_type)
+        pulumi.set(__self__, "endpoint", endpoint)
+        pulumi.set(__self__, "role_arn", role_arn)
+        pulumi.set(__self__, "time_zone", time_zone)
+        if delay_seconds is not None:
+            pulumi.set(__self__, "delay_seconds", delay_seconds)
+        if path_format is not None:
+            pulumi.set(__self__, "path_format", path_format)
+        if path_format_type is not None:
+            pulumi.set(__self__, "path_format_type", path_format_type)
+        if prefix is not None:
+            pulumi.set(__self__, "prefix", prefix)
+        if suffix is not None:
+            pulumi.set(__self__, "suffix", suffix)
+
+    @property
+    @pulumi.getter
+    def bucket(self) -> str:
+        """
+        The OSS bucket.
+        """
+        return pulumi.get(self, "bucket")
+
+    @property
+    @pulumi.getter(name="bufferInterval")
+    def buffer_interval(self) -> str:
+        """
+        The interval between two data shipping operations. Valid values: 300 to 900. Unit: seconds.
+        """
+        return pulumi.get(self, "buffer_interval")
+
+    @property
+    @pulumi.getter(name="bufferSize")
+    def buffer_size(self) -> str:
+        """
+        The size of the OSS object to which data is shipped. Valid values: 5 to 256. Unit: MB.
+        """
+        return pulumi.get(self, "buffer_size")
+
+    @property
+    @pulumi.getter(name="compressionType")
+    def compression_type(self) -> str:
+        """
+        Supports four compression types, such as snappy, gzip, zstd, and none.
+        """
+        return pulumi.get(self, "compression_type")
+
+    @property
+    @pulumi.getter(name="contentDetail")
+    def content_detail(self) -> str:
+        """
+        The OSS file content details. Note: the value of this parameter should be updated based on the value of the contentType parameter.
+
+        If the contentType value is JSON, the parameters of the contentDetail value are as follows:
+
+        If the tag is allowed to be posted, the value of the parameter enableTag is true. Example:{"enableTag": true}
+
+        You are not allowed to post tags. The value of the parameter enableTag is false. Example:{"enableTag": false}
+
+        If the contentType value is csv, the parameters of the contentDetail value are as follows:
+
+        The parameter columns is the key of the log in the source logstore.
+
+        The delimiter parameter, which can be ",","|","", or "\\t".
+
+        The header parameter determines whether the OSS file retains the header. The optional value is true or false.
+
+        The lineFeed parameter. Optional values are "\\t", "\\n", or "".
+
+        The invalid field content parameter is null to specify the delivery content when the field name does not exist.
+
+        The escape character parameter "quote". Optional values are "" "," '", or" ".
+
+        Example:{"null": "-", "header": false, "lineFeed": "\\n", "quote": "", "delimiter": ",", "columns": ["a", "B", "c", "d"]}
+
+        When the contentType value is parquet, the parameters of the contentDetail value are as follows:
+
+        The columns parameter is the key of the log in the source Logstore and must carry the data type of the key, for example:{"columns": [{"name": "a", "type": "string"}, {"name": "B", "type": "string"}, {"name": "c", "type": "string": "string"}]}
+
+        When the contentType value is set to orc, the parameters of the contentDetail value are as follows:
+
+        The columns parameter is the key of the log in the source Logstore and must carry the data type of the key, for example:{"columns": [{"name": "a", "type": "string"}, {"name": "B", "type": "string"}, {"name": "c", "type": "string": "string"}]}
+        """
+        return pulumi.get(self, "content_detail")
+
+    @property
+    @pulumi.getter(name="contentType")
+    def content_type(self) -> str:
+        """
+        The storage format of the OSS object. Valid values: json, parquet, csv, and orc.
+        """
+        return pulumi.get(self, "content_type")
+
+    @property
+    @pulumi.getter
+    def endpoint(self) -> str:
+        """
+        The OSS Endpoint can only be an OSS intranet Endpoint and only supports the same region. Example value: https://oss-cn-hangzhou-internal.aliyuncs.com
+        """
+        return pulumi.get(self, "endpoint")
+
+    @property
+    @pulumi.getter(name="roleArn")
+    def role_arn(self) -> str:
+        """
+        The ARN of the RAM role that is used to write data to OSS. Example value: acs:ram::xxxxxxx
+        """
+        return pulumi.get(self, "role_arn")
+
+    @property
+    @pulumi.getter(name="timeZone")
+    def time_zone(self) -> str:
+        """
+        The time zone. Example value: +0800
+        """
+        return pulumi.get(self, "time_zone")
+
+    @property
+    @pulumi.getter(name="delaySeconds")
+    def delay_seconds(self) -> Optional[int]:
+        """
+        The latency of data shipping. The value of this parameter cannot exceed the data retention period of the source Logstore.
+        """
+        return pulumi.get(self, "delay_seconds")
+
+    @property
+    @pulumi.getter(name="pathFormat")
+    def path_format(self) -> Optional[str]:
+        """
+        The directory is dynamically generated according to the time. The default value is% Y/%m/%d/%H/%M. The corresponding generated directory is, for example, 2017/01/23/12/00. Note that the partition format cannot start and end. Example values:%Y/%m/%d
+        """
+        return pulumi.get(self, "path_format")
+
+    @property
+    @pulumi.getter(name="pathFormatType")
+    def path_format_type(self) -> Optional[str]:
+        """
+        The partition format type. only support time
+        """
+        return pulumi.get(self, "path_format_type")
+
+    @property
+    @pulumi.getter
+    def prefix(self) -> Optional[str]:
+        """
+        The prefix of the OSS object.
+        """
+        return pulumi.get(self, "prefix")
+
+    @property
+    @pulumi.getter
+    def suffix(self) -> Optional[str]:
+        """
+        The suffix of the OSS object.
+        """
+        return pulumi.get(self, "suffix")
+
+
+@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")
+
+