pulumi-alicloud 3.63.0a1727705137__py3-none-any.whl → 3.64.0__py3-none-any.whl

pulumi_alicloud/sls/_inputs.py

@@ -4,31 +4,156 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 
 __all__ = [
     'AlertConfigurationArgs',
+    'AlertConfigurationArgsDict',
     'AlertConfigurationAnnotationArgs',
+    'AlertConfigurationAnnotationArgsDict',
     'AlertConfigurationConditionConfigurationArgs',
+    'AlertConfigurationConditionConfigurationArgsDict',
     'AlertConfigurationGroupConfigurationArgs',
+    'AlertConfigurationGroupConfigurationArgsDict',
     'AlertConfigurationJoinConfigurationArgs',
+    'AlertConfigurationJoinConfigurationArgsDict',
     'AlertConfigurationLabelArgs',
+    'AlertConfigurationLabelArgsDict',
     'AlertConfigurationPolicyConfigurationArgs',
+    'AlertConfigurationPolicyConfigurationArgsDict',
     'AlertConfigurationQueryListArgs',
+    'AlertConfigurationQueryListArgsDict',
     'AlertConfigurationSeverityConfigurationArgs',
+    'AlertConfigurationSeverityConfigurationArgsDict',
     'AlertConfigurationSeverityConfigurationEvalConditionArgs',
+    'AlertConfigurationSeverityConfigurationEvalConditionArgsDict',
     'AlertConfigurationSinkAlerthubArgs',
+    'AlertConfigurationSinkAlerthubArgsDict',
     'AlertConfigurationSinkCmsArgs',
+    'AlertConfigurationSinkCmsArgsDict',
     'AlertConfigurationSinkEventStoreArgs',
+    'AlertConfigurationSinkEventStoreArgsDict',
     'AlertConfigurationTemplateConfigurationArgs',
+    'AlertConfigurationTemplateConfigurationArgsDict',
     'AlertScheduleArgs',
+    'AlertScheduleArgsDict',
+    'CollectionPolicyCentralizeConfigArgs',
+    'CollectionPolicyCentralizeConfigArgsDict',
+    'CollectionPolicyDataConfigArgs',
+    'CollectionPolicyDataConfigArgsDict',
+    'CollectionPolicyPolicyConfigArgs',
+    'CollectionPolicyPolicyConfigArgsDict',
+    'CollectionPolicyResourceDirectoryArgs',
+    'CollectionPolicyResourceDirectoryArgsDict',
     'ScheduledSqlScheduleArgs',
+    'ScheduledSqlScheduleArgsDict',
     'ScheduledSqlScheduledSqlConfigurationArgs',
+    'ScheduledSqlScheduledSqlConfigurationArgsDict',
 ]
 
+MYPY = False
+
+if not MYPY:
+    class AlertConfigurationArgsDict(TypedDict):
+        annotations: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationAnnotationArgsDict']]]]
+        """
+        Template Annotations.
+        """
+        auto_annotation: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to turn on automatic labeling. true (default): The automatic annotation function is enabled, and the system automatically adds information such as__county__to the alarm. For more information, see Automatic Labeling. false: Turn off the automatic annotation function.
+        """
+        condition_configuration: NotRequired[pulumi.Input['AlertConfigurationConditionConfigurationArgsDict']]
+        """
+        Alarm trigger condition. See `condition_configuration` below.
+        """
+        dashboard: NotRequired[pulumi.Input[str]]
+        """
+        The instrument cluster associated with the alarm. It is recommended to set to internal-alert-analysis.
+        """
+        group_configuration: NotRequired[pulumi.Input['AlertConfigurationGroupConfigurationArgsDict']]
+        """
+        Group evaluation configuration. See `group_configuration` below.
+        """
+        join_configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationJoinConfigurationArgsDict']]]]
+        """
+        Set operation configuration. See `join_configurations` below.
+        """
+        labels: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationLabelArgsDict']]]]
+        """
+        Label. See `labels` below.
+        """
+        mute_until: NotRequired[pulumi.Input[int]]
+        """
+        Second-level timestamp representing the temporary shutdown deadline.
+        """
+        no_data_fire: NotRequired[pulumi.Input[bool]]
+        """
+        Whether no data triggers an alarm. true: If the number of times the query and analysis results (if there are multiple results, the result after the collection operation) is no data exceeds the continuous trigger threshold, an alarm is generated. false (default): Turn off the no data alarm function.
+        """
+        no_data_severity: NotRequired[pulumi.Input[int]]
+        """
+        Alarm severity when no data triggers an alarm.
+        """
+        policy_configuration: NotRequired[pulumi.Input['AlertConfigurationPolicyConfigurationArgsDict']]
+        """
+        Alert policy configuration. See `policy_configuration` below.
+        """
+        query_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationQueryListArgsDict']]]]
+        """
+        Query the statistical list. See `query_list` below.
+        """
+        send_resolved: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to send a recovery notification. true: A recovery alarm is triggered when the alarm is restored. false (default): Turn off the alarm recovery notification function.
+        """
+        severity_configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertConfigurationSeverityConfigurationArgsDict']]]]
+        """
+        Trigger condition, set at least one trigger condition. See `severity_configurations` below.
+        """
+        sink_alerthub: NotRequired[pulumi.Input['AlertConfigurationSinkAlerthubArgsDict']]
+        """
+        Configuration of Alerts Sent to Alerthub. See `sink_alerthub` below.
+        """
+        sink_cms: NotRequired[pulumi.Input['AlertConfigurationSinkCmsArgsDict']]
+        """
+        Configure alerts sent to CloudMonitor. See `sink_cms` below.
+        """
+        sink_event_store: NotRequired[pulumi.Input['AlertConfigurationSinkEventStoreArgsDict']]
+        """
+        Configuration of sending alarms to EventStore. See `sink_event_store` below.
+        """
+        tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Customize the category of alarm monitoring rules.
+        """
+        template_configuration: NotRequired[pulumi.Input['AlertConfigurationTemplateConfigurationArgsDict']]
+        """
+        Alarm rule template configuration. See `template_configuration` below.
+        """
+        threshold: NotRequired[pulumi.Input[int]]
+        """
+        Set the continuous trigger threshold. When the cumulative number of triggers reaches this value, an alarm is generated. The statistics are not counted when the trigger condition is not met.
+        """
+        type: NotRequired[pulumi.Input[str]]
+        """
+        Template Type.
+        """
+        version: NotRequired[pulumi.Input[str]]
+        """
+        Template Version.
+        """
+elif False:
+    AlertConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertConfigurationArgs:
     def __init__(__self__, *,
@@ -388,6 +513,19 @@ class AlertConfigurationArgs:
         pulumi.set(self, "version", value)
 
 
+if not MYPY:
+    class AlertConfigurationAnnotationArgsDict(TypedDict):
+        key: NotRequired[pulumi.Input[str]]
+        """
+        Field name.
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        Field value.
+        """
+elif False:
+    AlertConfigurationAnnotationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertConfigurationAnnotationArgs:
     def __init__(__self__, *,
@@ -427,6 +565,19 @@ class AlertConfigurationAnnotationArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class AlertConfigurationConditionConfigurationArgsDict(TypedDict):
+        condition: NotRequired[pulumi.Input[str]]
+        """
+        Data matching expression. When the data content does not need to be determined, set it to an empty string. In other cases, it needs to be set as an expression, for example, errCnt> 10.
+        """
+        count_condition: NotRequired[pulumi.Input[str]]
+        """
+        The number of pieces of data to determine the number of pieces of data to indicate how many pieces of data meet the conditions. If data exists, it is satisfied. Set it to an empty string. In other cases, it needs to be set as an expression, such as__count__> 3.
+        """
+elif False:
+    AlertConfigurationConditionConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertConfigurationConditionConfigurationArgs:
     def __init__(__self__, *,
@@ -466,6 +617,16 @@ class AlertConfigurationConditionConfigurationArgs:
         pulumi.set(self, "count_condition", value)
 
 
+if not MYPY:
+    class AlertConfigurationGroupConfigurationArgsDict(TypedDict):
+        fields: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The field used for grouping evaluation. When type is set to custom, fields must be set.
+        """
+        type: NotRequired[pulumi.Input[str]]
+elif False:
+    AlertConfigurationGroupConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertConfigurationGroupConfigurationArgs:
     def __init__(__self__, *,
@@ -501,6 +662,16 @@ class AlertConfigurationGroupConfigurationArgs:
         pulumi.set(self, "type", value)
 
 
+if not MYPY:
+    class AlertConfigurationJoinConfigurationArgsDict(TypedDict):
+        condition: NotRequired[pulumi.Input[str]]
+        """
+        Data matching expression. When the data content does not need to be determined, set it to an empty string. In other cases, it needs to be set as an expression, for example, errCnt> 10.
+        """
+        type: NotRequired[pulumi.Input[str]]
+elif False:
+    AlertConfigurationJoinConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertConfigurationJoinConfigurationArgs:
     def __init__(__self__, *,
@@ -536,6 +707,19 @@ class AlertConfigurationJoinConfigurationArgs:
         pulumi.set(self, "type", value)
 
 
+if not MYPY:
+    class AlertConfigurationLabelArgsDict(TypedDict):
+        key: NotRequired[pulumi.Input[str]]
+        """
+        Field name.
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        Field value.
+        """
+elif False:
+    AlertConfigurationLabelArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertConfigurationLabelArgs:
     def __init__(__self__, *,
@@ -575,6 +759,23 @@ class AlertConfigurationLabelArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class AlertConfigurationPolicyConfigurationArgsDict(TypedDict):
+        action_policy_id: NotRequired[pulumi.Input[str]]
+        """
+        The ID of the action policy used. If the alert policy is in advanced mode and the selected alert policy is not configured with a dynamic action policy, set the actionPolicyId to an empty string.
+        """
+        alert_policy_id: NotRequired[pulumi.Input[str]]
+        """
+        Alarm policy ID. If it is in simple mode or normal mode, set it to sls.builtin.dynamic (dynamic alarm policy built into the system). For advanced mode, set it to the specified alarm policy ID.
+        """
+        repeat_interval: NotRequired[pulumi.Input[str]]
+        """
+        Repeat the waiting time. For example, 5m, 1H, etc.
+        """
+elif False:
+    AlertConfigurationPolicyConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertConfigurationPolicyConfigurationArgs:
     def __init__(__self__, *,
@@ -630,6 +831,63 @@ class AlertConfigurationPolicyConfigurationArgs:
         pulumi.set(self, "repeat_interval", value)
 
 
+if not MYPY:
+    class AlertConfigurationQueryListArgsDict(TypedDict):
+        chart_title: NotRequired[pulumi.Input[str]]
+        """
+        Chart Name.
+        """
+        dashboard_id: NotRequired[pulumi.Input[str]]
+        """
+        Dashboard ID.
+        """
+        end: NotRequired[pulumi.Input[str]]
+        """
+        End time. When storeType is set to log or metric, end must be set.
+        """
+        power_sql_mode: NotRequired[pulumi.Input[str]]
+        """
+        Whether to use exclusive SQL. The value is as follows: auto: automatic switching. enable: Starts. disable: disable.
+        """
+        project: NotRequired[pulumi.Input[str]]
+        """
+        Project Name.
+        """
+        query: NotRequired[pulumi.Input[str]]
+        """
+        Query and analysis statements. When storeType is set to log or metric, query is set to the query analysis statement. When storeType is set to meta, set query to an empty string.
+        """
+        region: NotRequired[pulumi.Input[str]]
+        """
+        Region of the target Project.
+        """
+        role_arn: NotRequired[pulumi.Input[str]]
+        """
+        Roles used to write alarm data to the event Library.
+        """
+        start: NotRequired[pulumi.Input[str]]
+        """
+        Start time. When storeType is set to log or metric, start must be set.
+        """
+        store: NotRequired[pulumi.Input[str]]
+        """
+        Query the Logstore, Metricstore, or resource data associated with the statistics. When storeType is set to log, store is set to the target Logstore. When storeType is set to metric, store is set to the target Metricstore. When storeType is set to meta, store is set to the target resource data name.
+        """
+        store_type: NotRequired[pulumi.Input[str]]
+        """
+        Query the data source type. The value is as follows: log: Logstore. metric: Time series Library. meta: resource data.
+        """
+        time_span_type: NotRequired[pulumi.Input[str]]
+        """
+        Time Type.
+        """
+        ui: NotRequired[pulumi.Input[str]]
+        """
+        Use of specific scene alarm front end.
+        """
+elif False:
+    AlertConfigurationQueryListArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertConfigurationQueryListArgs:
     def __init__(__self__, *,
@@ -845,6 +1103,19 @@ class AlertConfigurationQueryListArgs:
         pulumi.set(self, "ui", value)
 
 
+if not MYPY:
+    class AlertConfigurationSeverityConfigurationArgsDict(TypedDict):
+        eval_condition: NotRequired[pulumi.Input['AlertConfigurationSeverityConfigurationEvalConditionArgsDict']]
+        """
+        Trigger condition. See `eval_condition` below.
+        """
+        severity: NotRequired[pulumi.Input[int]]
+        """
+        Alarm severity.
+        """
+elif False:
+    AlertConfigurationSeverityConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertConfigurationSeverityConfigurationArgs:
     def __init__(__self__, *,
@@ -884,6 +1155,19 @@ class AlertConfigurationSeverityConfigurationArgs:
         pulumi.set(self, "severity", value)
 
 
+if not MYPY:
+    class AlertConfigurationSeverityConfigurationEvalConditionArgsDict(TypedDict):
+        condition: NotRequired[pulumi.Input[str]]
+        """
+        Data matching expression. When the data content does not need to be determined, set it to an empty string. In other cases, it needs to be set as an expression, for example, errCnt> 10.
+        """
+        count_condition: NotRequired[pulumi.Input[str]]
+        """
+        The number of pieces of data to determine the number of pieces of data to indicate how many pieces of data meet the conditions. If data exists, it is satisfied. Set it to an empty string. In other cases, it needs to be set as an expression, such as__count__> 3.
+        """
+elif False:
+    AlertConfigurationSeverityConfigurationEvalConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertConfigurationSeverityConfigurationEvalConditionArgs:
     def __init__(__self__, *,
@@ -923,6 +1207,15 @@ class AlertConfigurationSeverityConfigurationEvalConditionArgs:
         pulumi.set(self, "count_condition", value)
 
 
+if not MYPY:
+    class AlertConfigurationSinkAlerthubArgsDict(TypedDict):
+        enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Open.
+        """
+elif False:
+    AlertConfigurationSinkAlerthubArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertConfigurationSinkAlerthubArgs:
     def __init__(__self__, *,
@@ -946,6 +1239,15 @@ class AlertConfigurationSinkAlerthubArgs:
         pulumi.set(self, "enabled", value)
 
 
+if not MYPY:
+    class AlertConfigurationSinkCmsArgsDict(TypedDict):
+        enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Open.
+        """
+elif False:
+    AlertConfigurationSinkCmsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertConfigurationSinkCmsArgs:
     def __init__(__self__, *,
@@ -969,6 +1271,31 @@ class AlertConfigurationSinkCmsArgs:
         pulumi.set(self, "enabled", value)
 
 
+if not MYPY:
+    class AlertConfigurationSinkEventStoreArgsDict(TypedDict):
+        enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Open.
+        """
+        endpoint: NotRequired[pulumi.Input[str]]
+        """
+        SLS service endpoint.
+        """
+        event_store: NotRequired[pulumi.Input[str]]
+        """
+        Event Library Name.
+        """
+        project: NotRequired[pulumi.Input[str]]
+        """
+        Project Name.
+        """
+        role_arn: NotRequired[pulumi.Input[str]]
+        """
+        Roles used to write alarm data to the event Library.
+        """
+elif False:
+    AlertConfigurationSinkEventStoreArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertConfigurationSinkEventStoreArgs:
     def __init__(__self__, *,
@@ -1056,6 +1383,32 @@ class AlertConfigurationSinkEventStoreArgs:
         pulumi.set(self, "role_arn", value)
 
 
+if not MYPY:
+    class AlertConfigurationTemplateConfigurationArgsDict(TypedDict):
+        annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Template Annotations.
+        """
+        lang: NotRequired[pulumi.Input[str]]
+        """
+        Template Language.
+        """
+        template_id: NotRequired[pulumi.Input[str]]
+        """
+        Template ID.
+        """
+        tokens: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Template Variables.
+        """
+        type: NotRequired[pulumi.Input[str]]
+        version: NotRequired[pulumi.Input[str]]
+        """
+        Template Version.
+        """
+elif False:
+    AlertConfigurationTemplateConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertConfigurationTemplateConfigurationArgs:
     def __init__(__self__, *,
@@ -1155,6 +1508,35 @@ class AlertConfigurationTemplateConfigurationArgs:
         pulumi.set(self, "version", value)
 
 
+if not MYPY:
+    class AlertScheduleArgsDict(TypedDict):
+        cron_expression: NotRequired[pulumi.Input[str]]
+        """
+        Cron expression, the minimum accuracy is minutes, 24 hours. For example, 0 0/1 * * * means that the check is conducted every 1 hour from 00:00. When type is set to Cron, cronExpression must be set.
+        """
+        delay: NotRequired[pulumi.Input[int]]
+        """
+        Timed task execution delay (unit: s).
+        """
+        interval: NotRequired[pulumi.Input[str]]
+        """
+        Fixed interval for scheduling.
+        """
+        run_immdiately: NotRequired[pulumi.Input[bool]]
+        """
+        Dispatch immediately.
+        """
+        time_zone: NotRequired[pulumi.Input[str]]
+        """
+        The time zone where the Cron expression is located. The default value is null, indicating the eighth zone in the east.
+        """
+        type: NotRequired[pulumi.Input[str]]
+        """
+        Check the frequency type. Log Service checks the query and analysis results according to the frequency you configured. The values are as follows: Fixedate: checks query and analysis results at regular intervals. Cron: specifies the time interval by using the Cron expression, and checks the query and analysis results at the specified time interval.
+        """
+elif False:
+    AlertScheduleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertScheduleArgs:
     def __init__(__self__, *,
@@ -1258,6 +1640,334 @@ class AlertScheduleArgs:
         pulumi.set(self, "type", value)
 
 
+if not MYPY:
+    class CollectionPolicyCentralizeConfigArgsDict(TypedDict):
+        dest_logstore: NotRequired[pulumi.Input[str]]
+        """
+        When the central logstore is transferred to the destination logstore, its geographical attribute should be consistent with the destRegion and belong to the destProject.
+        """
+        dest_project: NotRequired[pulumi.Input[str]]
+        """
+        The geographical attributes of the centralized transfer project should be consistent with the destRegion.
+        """
+        dest_region: NotRequired[pulumi.Input[str]]
+        """
+        Centralized transfer destination area.
+        """
+        dest_ttl: NotRequired[pulumi.Input[int]]
+        """
+        The number of days for the central transfer destination. This is valid only if the central transfer destination log store is not created for the first time.
+        """
+elif False:
+    CollectionPolicyCentralizeConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class CollectionPolicyCentralizeConfigArgs:
+    def __init__(__self__, *,
+                 dest_logstore: Optional[pulumi.Input[str]] = None,
+                 dest_project: Optional[pulumi.Input[str]] = None,
+                 dest_region: Optional[pulumi.Input[str]] = None,
+                 dest_ttl: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[str] dest_logstore: When the central logstore is transferred to the destination logstore, its geographical attribute should be consistent with the destRegion and belong to the destProject.
+        :param pulumi.Input[str] dest_project: The geographical attributes of the centralized transfer project should be consistent with the destRegion.
+        :param pulumi.Input[str] dest_region: Centralized transfer destination area.
+        :param pulumi.Input[int] dest_ttl: The number of days for the central transfer destination. This is valid only if the central transfer destination log store is not created for the first time.
+        """
+        if dest_logstore is not None:
+            pulumi.set(__self__, "dest_logstore", dest_logstore)
+        if dest_project is not None:
+            pulumi.set(__self__, "dest_project", dest_project)
+        if dest_region is not None:
+            pulumi.set(__self__, "dest_region", dest_region)
+        if dest_ttl is not None:
+            pulumi.set(__self__, "dest_ttl", dest_ttl)
+
+    @property
+    @pulumi.getter(name="destLogstore")
+    def dest_logstore(self) -> Optional[pulumi.Input[str]]:
+        """
+        When the central logstore is transferred to the destination logstore, its geographical attribute should be consistent with the destRegion and belong to the destProject.
+        """
+        return pulumi.get(self, "dest_logstore")
+
+    @dest_logstore.setter
+    def dest_logstore(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "dest_logstore", value)
+
+    @property
+    @pulumi.getter(name="destProject")
+    def dest_project(self) -> Optional[pulumi.Input[str]]:
+        """
+        The geographical attributes of the centralized transfer project should be consistent with the destRegion.
+        """
+        return pulumi.get(self, "dest_project")
+
+    @dest_project.setter
+    def dest_project(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "dest_project", value)
+
+    @property
+    @pulumi.getter(name="destRegion")
+    def dest_region(self) -> Optional[pulumi.Input[str]]:
+        """
+        Centralized transfer destination area.
+        """
+        return pulumi.get(self, "dest_region")
+
+    @dest_region.setter
+    def dest_region(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "dest_region", value)
+
+    @property
+    @pulumi.getter(name="destTtl")
+    def dest_ttl(self) -> Optional[pulumi.Input[int]]:
+        """
+        The number of days for the central transfer destination. This is valid only if the central transfer destination log store is not created for the first time.
+        """
+        return pulumi.get(self, "dest_ttl")
+
+    @dest_ttl.setter
+    def dest_ttl(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "dest_ttl", value)
+
+
+if not MYPY:
+    class CollectionPolicyDataConfigArgsDict(TypedDict):
+        data_project: NotRequired[pulumi.Input[str]]
+        """
+        Valid only when the log type is global. For example, if the productCode is sls, the log is collected to the default dedicated Project of the account in a specific dataRegion.
+        """
+        data_region: NotRequired[pulumi.Input[str]]
+        """
+        If and only if the log type is global log type, for example, if productCode is sls, global logs will be collected to the corresponding region during the first configuration.
+        """
+elif False:
+    CollectionPolicyDataConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class CollectionPolicyDataConfigArgs:
+    def __init__(__self__, *,
+                 data_project: Optional[pulumi.Input[str]] = None,
+                 data_region: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] data_project: Valid only when the log type is global. For example, if the productCode is sls, the log is collected to the default dedicated Project of the account in a specific dataRegion.
+        :param pulumi.Input[str] data_region: If and only if the log type is global log type, for example, if productCode is sls, global logs will be collected to the corresponding region during the first configuration.
+        """
+        if data_project is not None:
+            pulumi.set(__self__, "data_project", data_project)
+        if data_region is not None:
+            pulumi.set(__self__, "data_region", data_region)
+
+    @property
+    @pulumi.getter(name="dataProject")
+    def data_project(self) -> Optional[pulumi.Input[str]]:
+        """
+        Valid only when the log type is global. For example, if the productCode is sls, the log is collected to the default dedicated Project of the account in a specific dataRegion.
+        """
+        return pulumi.get(self, "data_project")
+
+    @data_project.setter
+    def data_project(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "data_project", value)
+
+    @property
+    @pulumi.getter(name="dataRegion")
+    def data_region(self) -> Optional[pulumi.Input[str]]:
+        """
+        If and only if the log type is global log type, for example, if productCode is sls, global logs will be collected to the corresponding region during the first configuration.
+        """
+        return pulumi.get(self, "data_region")
+
+    @data_region.setter
+    def data_region(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "data_region", value)
+
+
+if not MYPY:
+    class CollectionPolicyPolicyConfigArgsDict(TypedDict):
+        resource_mode: pulumi.Input[str]
+        """
+        Resource collection mode. If all is configured, all instances under the account will be collected to the default logstore. If attributeMode is configured, filtering will be performed according to the region attribute and resource label of the instance. If instanceMode is configured, filtering will be performed according to the instance ID.
+        """
+        instance_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        A collection of instance IDs, valid only if resourceMode is instanceMode. Only instances whose instance ID is in the instance ID collection are collected.
+        """
+        regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The region collection to which the instance belongs. Valid only when resourceMode is set to attributeMode. Wildcard characters are supported. If the region collection filter item is an empty array, it means that you do not need to filter by region, and all instances meet the filtering condition of the region collection. Otherwise, only instances with region attributes in the region collection are collected. The region collection and resource label of the instance. The instance objects are collected only when all of them are met.
+        """
+        resource_tags: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Resource label, valid if and only if resourceMode is attributeMode.
+
+        If the resource label filter item is empty, it means that you do not need to filter by resource label, and all instances meet the resource label filter condition. Otherwise, only instances whose resource label attributes meet the resource label configuration are collected.
+
+        The resource tag and the region collection to which the instance belongs work together. The instance objects are collected only when all of them are met.
+        """
+elif False:
+    CollectionPolicyPolicyConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class CollectionPolicyPolicyConfigArgs:
+    def __init__(__self__, *,
+                 resource_mode: pulumi.Input[str],
+                 instance_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 regions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 resource_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[str] resource_mode: Resource collection mode. If all is configured, all instances under the account will be collected to the default logstore. If attributeMode is configured, filtering will be performed according to the region attribute and resource label of the instance. If instanceMode is configured, filtering will be performed according to the instance ID.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] instance_ids: A collection of instance IDs, valid only if resourceMode is instanceMode. Only instances whose instance ID is in the instance ID collection are collected.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] regions: The region collection to which the instance belongs. Valid only when resourceMode is set to attributeMode. Wildcard characters are supported. If the region collection filter item is an empty array, it means that you do not need to filter by region, and all instances meet the filtering condition of the region collection. Otherwise, only instances with region attributes in the region collection are collected. The region collection and resource label of the instance. The instance objects are collected only when all of them are met.
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] resource_tags: Resource label, valid if and only if resourceMode is attributeMode.
+               
+               If the resource label filter item is empty, it means that you do not need to filter by resource label, and all instances meet the resource label filter condition. Otherwise, only instances whose resource label attributes meet the resource label configuration are collected.
+               
+               The resource tag and the region collection to which the instance belongs work together. The instance objects are collected only when all of them are met.
+        """
+        pulumi.set(__self__, "resource_mode", resource_mode)
+        if instance_ids is not None:
+            pulumi.set(__self__, "instance_ids", instance_ids)
+        if regions is not None:
+            pulumi.set(__self__, "regions", regions)
+        if resource_tags is not None:
+            pulumi.set(__self__, "resource_tags", resource_tags)
+
+    @property
+    @pulumi.getter(name="resourceMode")
+    def resource_mode(self) -> pulumi.Input[str]:
+        """
+        Resource collection mode. If all is configured, all instances under the account will be collected to the default logstore. If attributeMode is configured, filtering will be performed according to the region attribute and resource label of the instance. If instanceMode is configured, filtering will be performed according to the instance ID.
+        """
+        return pulumi.get(self, "resource_mode")
+
+    @resource_mode.setter
+    def resource_mode(self, value: pulumi.Input[str]):
+        pulumi.set(self, "resource_mode", value)
+
+    @property
+    @pulumi.getter(name="instanceIds")
+    def instance_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        A collection of instance IDs, valid only if resourceMode is instanceMode. Only instances whose instance ID is in the instance ID collection are collected.
+        """
+        return pulumi.get(self, "instance_ids")
+
+    @instance_ids.setter
+    def instance_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "instance_ids", value)
+
+    @property
+    @pulumi.getter
+    def regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The region collection to which the instance belongs. Valid only when resourceMode is set to attributeMode. Wildcard characters are supported. If the region collection filter item is an empty array, it means that you do not need to filter by region, and all instances meet the filtering condition of the region collection. Otherwise, only instances with region attributes in the region collection are collected. The region collection and resource label of the instance. The instance objects are collected only when all of them are met.
+        """
+        return pulumi.get(self, "regions")
+
+    @regions.setter
+    def regions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "regions", value)
+
+    @property
+    @pulumi.getter(name="resourceTags")
+    def resource_tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
+        """
+        Resource label, valid if and only if resourceMode is attributeMode.
+
+        If the resource label filter item is empty, it means that you do not need to filter by resource label, and all instances meet the resource label filter condition. Otherwise, only instances whose resource label attributes meet the resource label configuration are collected.
+
+        The resource tag and the region collection to which the instance belongs work together. The instance objects are collected only when all of them are met.
+        """
+        return pulumi.get(self, "resource_tags")
+
+    @resource_tags.setter
+    def resource_tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
+        pulumi.set(self, "resource_tags", value)
+
+
+if not MYPY:
+    class CollectionPolicyResourceDirectoryArgsDict(TypedDict):
+        account_group_type: NotRequired[pulumi.Input[str]]
+        """
+        Support all mode all and custom mode custom under this resource directory
+        """
+        members: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        When the resource directory is configured in the custom mode, the corresponding member account list
+        """
+elif False:
+    CollectionPolicyResourceDirectoryArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class CollectionPolicyResourceDirectoryArgs:
+    def __init__(__self__, *,
+                 account_group_type: Optional[pulumi.Input[str]] = None,
+                 members: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[str] account_group_type: Support all mode all and custom mode custom under this resource directory
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] members: When the resource directory is configured in the custom mode, the corresponding member account list
+        """
+        if account_group_type is not None:
+            pulumi.set(__self__, "account_group_type", account_group_type)
+        if members is not None:
+            pulumi.set(__self__, "members", members)
+
+    @property
+    @pulumi.getter(name="accountGroupType")
+    def account_group_type(self) -> Optional[pulumi.Input[str]]:
+        """
+        Support all mode all and custom mode custom under this resource directory
+        """
+        return pulumi.get(self, "account_group_type")
+
+    @account_group_type.setter
+    def account_group_type(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "account_group_type", value)
+
+    @property
+    @pulumi.getter
+    def members(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        When the resource directory is configured in the custom mode, the corresponding member account list
+        """
+        return pulumi.get(self, "members")
+
+    @members.setter
+    def members(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "members", value)
+
+
+if not MYPY:
+    class ScheduledSqlScheduleArgsDict(TypedDict):
+        cron_expression: NotRequired[pulumi.Input[str]]
+        """
+        Cron expression, minimum precision is minutes, 24-hour clock. For example, 0 0/1 **indicates that the check is performed every one hour from 00:00. When type is set to Cron, cronExpression must be set.
+        """
+        delay: NotRequired[pulumi.Input[int]]
+        """
+        Delay time.
+        """
+        interval: NotRequired[pulumi.Input[str]]
+        """
+        Time interval, such as 5m, 1H.
+        """
+        run_immediately: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to execute the OSS import task immediately after it is created.
+        """
+        time_zone: NotRequired[pulumi.Input[str]]
+        """
+        Time Zone.
+        """
+        type: NotRequired[pulumi.Input[str]]
+        """
+        Check the frequency type. Log Service checks the query and analysis results based on the frequency you configured. The value is as follows: FixedRate: checks the query and analysis results at fixed intervals. Cron: specifies a time interval through a Cron expression, and checks the query and analysis results at the specified time interval. Weekly: Check the query and analysis results at a fixed point in time on the day of the week. Daily: checks the query and analysis results at a fixed time point every day. Hourly: Check query and analysis results every hour.
+        """
+elif False:
+    ScheduledSqlScheduleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ScheduledSqlScheduleArgs:
     def __init__(__self__, *,
@@ -1361,6 +2071,79 @@ class ScheduledSqlScheduleArgs:
         pulumi.set(self, "type", value)
 
 
+if not MYPY:
+    class ScheduledSqlScheduledSqlConfigurationArgsDict(TypedDict):
+        data_format: NotRequired[pulumi.Input[str]]
+        """
+        Write Mode.
+        """
+        dest_endpoint: NotRequired[pulumi.Input[str]]
+        """
+        Target Endpoint.
+        """
+        dest_logstore: NotRequired[pulumi.Input[str]]
+        """
+        Target Logstore.
+        """
+        dest_project: NotRequired[pulumi.Input[str]]
+        """
+        Target Project.
+        """
+        dest_role_arn: NotRequired[pulumi.Input[str]]
+        """
+        Write target role ARN.
+        """
+        from_time: NotRequired[pulumi.Input[int]]
+        """
+        Schedule Start Time.
+        """
+        from_time_expr: NotRequired[pulumi.Input[str]]
+        """
+        SQL time window-start.
+        """
+        max_retries: NotRequired[pulumi.Input[int]]
+        """
+        Maximum retries.
+        """
+        max_run_time_in_seconds: NotRequired[pulumi.Input[int]]
+        """
+        SQL timeout.
+        """
+        parameters: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Parameter configuration.
+        """
+        resource_pool: NotRequired[pulumi.Input[str]]
+        """
+        Resource Pool.
+        """
+        role_arn: NotRequired[pulumi.Input[str]]
+        """
+        Read role ARN.
+        """
+        script: NotRequired[pulumi.Input[str]]
+        """
+        SQL statement.
+        """
+        source_logstore: NotRequired[pulumi.Input[str]]
+        """
+        Source Logstore.
+        """
+        sql_type: NotRequired[pulumi.Input[str]]
+        """
+        SQL type.
+        """
+        to_time: NotRequired[pulumi.Input[int]]
+        """
+        Time at end of schedule.
+        """
+        to_time_expr: NotRequired[pulumi.Input[str]]
+        """
+        SQL time window-end.
+        """
+elif False:
+    ScheduledSqlScheduledSqlConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ScheduledSqlScheduledSqlConfigurationArgs:
     def __init__(__self__, *,