pulumi-alicloud 3.59.1a1721928270__py3-none-any.whl → 3.60.0a1720848019__py3-none-any.whl

pulumi_alicloud/sls/outputs.py

@@ -351,10 +351,6 @@ 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:
@@ -363,17 +359,11 @@ class AlertConfigurationAnnotation(dict):
     @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")
 
 
@@ -399,10 +389,6 @@ class AlertConfigurationConditionConfiguration(dict):
     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:
@@ -411,17 +397,11 @@ class AlertConfigurationConditionConfiguration(dict):
     @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")
 
 
@@ -430,9 +410,6 @@ 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:
@@ -441,9 +418,6 @@ class AlertConfigurationGroupConfiguration(dict):
     @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
@@ -457,9 +431,6 @@ 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:
@@ -468,9 +439,6 @@ class AlertConfigurationJoinConfiguration(dict):
     @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
@@ -484,10 +452,6 @@ 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:
@@ -496,17 +460,11 @@ class AlertConfigurationLabel(dict):
     @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")
 
 
@@ -537,11 +495,6 @@ class AlertConfigurationPolicyConfiguration(dict):
                  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:
@@ -552,25 +505,16 @@ class AlertConfigurationPolicyConfiguration(dict):
     @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")
 
 
@@ -617,21 +561,6 @@ class AlertConfigurationQueryList(dict):
                  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:
@@ -662,105 +591,66 @@ class AlertConfigurationQueryList(dict):
     @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")
 
 
@@ -786,10 +676,6 @@ class AlertConfigurationSeverityConfiguration(dict):
     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:
@@ -798,17 +684,11 @@ class AlertConfigurationSeverityConfiguration(dict):
     @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")
 
 
@@ -834,10 +714,6 @@ class AlertConfigurationSeverityConfigurationEvalCondition(dict):
     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:
@@ -846,17 +722,11 @@ class AlertConfigurationSeverityConfigurationEvalCondition(dict):
     @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")
 
 
@@ -864,18 +734,12 @@ class AlertConfigurationSeverityConfigurationEvalCondition(dict):
 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")
 
 
@@ -883,18 +747,12 @@ class AlertConfigurationSinkAlerthub(dict):
 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")
 
 
@@ -925,13 +783,6 @@ class AlertConfigurationSinkEventStore(dict):
                  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:
@@ -946,41 +797,26 @@ class AlertConfigurationSinkEventStore(dict):
     @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")
 
 
@@ -1010,13 +846,6 @@ class AlertConfigurationTemplateConfiguration(dict):
                  tokens: Optional[Mapping[str, Any]] = None,
                  type: Optional[str] = None,
                  version: Optional[str] = None):
-        """
-        :param Mapping[str, Any] annotations: Template Annotations.
-        :param str lang: Template Language.
-        :param str template_id: Template ID.
-        :param Mapping[str, Any] tokens: Template Variables.
-        :param str version: Template Version.
-        """
         if annotations is not None:
             pulumi.set(__self__, "annotations", annotations)
         if lang is not None:
@@ -1033,33 +862,21 @@ class AlertConfigurationTemplateConfiguration(dict):
     @property
     @pulumi.getter
     def annotations(self) -> Optional[Mapping[str, Any]]:
-        """
-        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, Any]]:
-        """
-        Template Variables.
-        """
         return pulumi.get(self, "tokens")
 
     @property
@@ -1070,9 +887,6 @@ class AlertConfigurationTemplateConfiguration(dict):
     @property
     @pulumi.getter
     def version(self) -> Optional[str]:
-        """
-        Template Version.
-        """
         return pulumi.get(self, "version")
 
 

pulumi_alicloud/threatdetection/_inputs.py

@@ -75,10 +75,6 @@ class HoneypotProbeHoneypotBindListArgs:
     def __init__(__self__, *,
                  bind_port_lists: Optional[pulumi.Input[Sequence[pulumi.Input['HoneypotProbeHoneypotBindListBindPortListArgs']]]] = None,
                  honeypot_id: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input[Sequence[pulumi.Input['HoneypotProbeHoneypotBindListBindPortListArgs']]] bind_port_lists: List of listening ports.See the following `Block BindPortList`.
-        :param pulumi.Input[str] honeypot_id: Honeypot ID.
-        """
         if bind_port_lists is not None:
             pulumi.set(__self__, "bind_port_lists", bind_port_lists)
         if honeypot_id is not None:
@@ -87,9 +83,6 @@ class HoneypotProbeHoneypotBindListArgs:
     @property
     @pulumi.getter(name="bindPortLists")
     def bind_port_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HoneypotProbeHoneypotBindListBindPortListArgs']]]]:
-        """
-        List of listening ports.See the following `Block BindPortList`.
-        """
         return pulumi.get(self, "bind_port_lists")
 
     @bind_port_lists.setter
@@ -99,9 +92,6 @@ class HoneypotProbeHoneypotBindListArgs:
     @property
     @pulumi.getter(name="honeypotId")
     def honeypot_id(self) -> Optional[pulumi.Input[str]]:
-        """
-        Honeypot ID.
-        """
         return pulumi.get(self, "honeypot_id")
 
     @honeypot_id.setter
@@ -117,13 +107,6 @@ class HoneypotProbeHoneypotBindListBindPortListArgs:
                  fixed: Optional[pulumi.Input[bool]] = None,
                  start_port: Optional[pulumi.Input[int]] = None,
                  target_port: Optional[pulumi.Input[int]] = None):
-        """
-        :param pulumi.Input[bool] bind_port: Whether to bind the port.
-        :param pulumi.Input[int] end_port: End port.
-        :param pulumi.Input[bool] fixed: Whether the port is fixed.
-        :param pulumi.Input[int] start_port: Start port.
-        :param pulumi.Input[int] target_port: Destination port.
-        """
         if bind_port is not None:
             pulumi.set(__self__, "bind_port", bind_port)
         if end_port is not None:
@@ -138,9 +121,6 @@ class HoneypotProbeHoneypotBindListBindPortListArgs:
     @property
     @pulumi.getter(name="bindPort")
     def bind_port(self) -> Optional[pulumi.Input[bool]]:
-        """
-        Whether to bind the port.
-        """
         return pulumi.get(self, "bind_port")
 
     @bind_port.setter
@@ -150,9 +130,6 @@ class HoneypotProbeHoneypotBindListBindPortListArgs:
     @property
     @pulumi.getter(name="endPort")
     def end_port(self) -> Optional[pulumi.Input[int]]:
-        """
-        End port.
-        """
         return pulumi.get(self, "end_port")
 
     @end_port.setter
@@ -162,9 +139,6 @@ class HoneypotProbeHoneypotBindListBindPortListArgs:
     @property
     @pulumi.getter
     def fixed(self) -> Optional[pulumi.Input[bool]]:
-        """
-        Whether the port is fixed.
-        """
         return pulumi.get(self, "fixed")
 
     @fixed.setter
@@ -174,9 +148,6 @@ class HoneypotProbeHoneypotBindListBindPortListArgs:
     @property
     @pulumi.getter(name="startPort")
     def start_port(self) -> Optional[pulumi.Input[int]]:
-        """
-        Start port.
-        """
         return pulumi.get(self, "start_port")
 
     @start_port.setter
@@ -186,9 +157,6 @@ class HoneypotProbeHoneypotBindListBindPortListArgs:
     @property
     @pulumi.getter(name="targetPort")
     def target_port(self) -> Optional[pulumi.Input[int]]:
-        """
-        Destination port.
-        """
         return pulumi.get(self, "target_port")
 
     @target_port.setter

pulumi_alicloud/threatdetection/outputs.py

@@ -117,10 +117,6 @@ class HoneypotProbeHoneypotBindList(dict):
     def __init__(__self__, *,
                  bind_port_lists: Optional[Sequence['outputs.HoneypotProbeHoneypotBindListBindPortList']] = None,
                  honeypot_id: Optional[str] = None):
-        """
-        :param Sequence['HoneypotProbeHoneypotBindListBindPortListArgs'] bind_port_lists: List of listening ports.See the following `Block BindPortList`.
-        :param str honeypot_id: Honeypot ID.
-        """
         if bind_port_lists is not None:
             pulumi.set(__self__, "bind_port_lists", bind_port_lists)
         if honeypot_id is not None:
@@ -129,17 +125,11 @@ class HoneypotProbeHoneypotBindList(dict):
     @property
     @pulumi.getter(name="bindPortLists")
     def bind_port_lists(self) -> Optional[Sequence['outputs.HoneypotProbeHoneypotBindListBindPortList']]:
-        """
-        List of listening ports.See the following `Block BindPortList`.
-        """
         return pulumi.get(self, "bind_port_lists")
 
     @property
     @pulumi.getter(name="honeypotId")
     def honeypot_id(self) -> Optional[str]:
-        """
-        Honeypot ID.
-        """
         return pulumi.get(self, "honeypot_id")
 
 
@@ -174,13 +164,6 @@ class HoneypotProbeHoneypotBindListBindPortList(dict):
                  fixed: Optional[bool] = None,
                  start_port: Optional[int] = None,
                  target_port: Optional[int] = None):
-        """
-        :param bool bind_port: Whether to bind the port.
-        :param int end_port: End port.
-        :param bool fixed: Whether the port is fixed.
-        :param int start_port: Start port.
-        :param int target_port: Destination port.
-        """
         if bind_port is not None:
             pulumi.set(__self__, "bind_port", bind_port)
         if end_port is not None:
@@ -195,41 +178,26 @@ class HoneypotProbeHoneypotBindListBindPortList(dict):
     @property
     @pulumi.getter(name="bindPort")
     def bind_port(self) -> Optional[bool]:
-        """
-        Whether to bind the port.
-        """
         return pulumi.get(self, "bind_port")
 
     @property
     @pulumi.getter(name="endPort")
     def end_port(self) -> Optional[int]:
-        """
-        End port.
-        """
         return pulumi.get(self, "end_port")
 
     @property
     @pulumi.getter
     def fixed(self) -> Optional[bool]:
-        """
-        Whether the port is fixed.
-        """
         return pulumi.get(self, "fixed")
 
     @property
     @pulumi.getter(name="startPort")
     def start_port(self) -> Optional[int]:
-        """
-        Start port.
-        """
         return pulumi.get(self, "start_port")
 
     @property
     @pulumi.getter(name="targetPort")
     def target_port(self) -> Optional[int]:
-        """
-        Destination port.
-        """
         return pulumi.get(self, "target_port")