pulumi-alicloud 3.84.0a1756507491__py3-none-any.whl → 3.85.0a1757389637__py3-none-any.whl

pulumi_alicloud/tag/policy.py

@@ -192,7 +192,7 @@ class Policy(pulumi.CustomResource):
             policy_name=name,
             policy_desc=name,
             user_type="USER",
-            policy_content="\\x09\\x09{\\"tags\\":{\\"CostCenter\\":{\\"tag_value\\":{\\"@@assign\\":[\\"Beijing\\",\\"Shanghai\\"]},\\"tag_key\\":{\\"@@assign\\":\\"CostCenter\\"}}}}\\n")
+            policy_content="\\\\t\\\\t{\\\\\\"tags\\\\\\":{\\\\\\"CostCenter\\\\\\":{\\\\\\"tag_value\\\\\\":{\\\\\\"@@assign\\\\\\":[\\\\\\"Beijing\\\\\\",\\\\\\"Shanghai\\\\\\"]},\\\\\\"tag_key\\\\\\":{\\\\\\"@@assign\\\\\\":\\\\\\"CostCenter\\\\\\"}}}}\\n")
         ```
 
         ## Import
@@ -239,7 +239,7 @@ class Policy(pulumi.CustomResource):
             policy_name=name,
             policy_desc=name,
             user_type="USER",
-            policy_content="\\x09\\x09{\\"tags\\":{\\"CostCenter\\":{\\"tag_value\\":{\\"@@assign\\":[\\"Beijing\\",\\"Shanghai\\"]},\\"tag_key\\":{\\"@@assign\\":\\"CostCenter\\"}}}}\\n")
+            policy_content="\\\\t\\\\t{\\\\\\"tags\\\\\\":{\\\\\\"CostCenter\\\\\\":{\\\\\\"tag_value\\\\\\":{\\\\\\"@@assign\\\\\\":[\\\\\\"Beijing\\\\\\",\\\\\\"Shanghai\\\\\\"]},\\\\\\"tag_key\\\\\\":{\\\\\\"@@assign\\\\\\":\\\\\\"CostCenter\\\\\\"}}}}\\n")
         ```
 
         ## Import

pulumi_alicloud/tag/policy_attachment.py

@@ -159,7 +159,7 @@ class PolicyAttachment(pulumi.CustomResource):
             policy_name=name,
             policy_desc=name,
             user_type="USER",
-            policy_content="\\x09\\x09{\\"tags\\":{\\"CostCenter\\":{\\"tag_value\\":{\\"@@assign\\":[\\"Beijing\\",\\"Shanghai\\"]},\\"tag_key\\":{\\"@@assign\\":\\"CostCenter\\"}}}}\\n")
+            policy_content="\\\\t\\\\t{\\\\\\"tags\\\\\\":{\\\\\\"CostCenter\\\\\\":{\\\\\\"tag_value\\\\\\":{\\\\\\"@@assign\\\\\\":[\\\\\\"Beijing\\\\\\",\\\\\\"Shanghai\\\\\\"]},\\\\\\"tag_key\\\\\\":{\\\\\\"@@assign\\\\\\":\\\\\\"CostCenter\\\\\\"}}}}\\n")
         example_policy_attachment = alicloud.tag.PolicyAttachment("example",
             policy_id=example.id,
             target_id=default.id,
@@ -210,7 +210,7 @@ class PolicyAttachment(pulumi.CustomResource):
             policy_name=name,
             policy_desc=name,
             user_type="USER",
-            policy_content="\\x09\\x09{\\"tags\\":{\\"CostCenter\\":{\\"tag_value\\":{\\"@@assign\\":[\\"Beijing\\",\\"Shanghai\\"]},\\"tag_key\\":{\\"@@assign\\":\\"CostCenter\\"}}}}\\n")
+            policy_content="\\\\t\\\\t{\\\\\\"tags\\\\\\":{\\\\\\"CostCenter\\\\\\":{\\\\\\"tag_value\\\\\\":{\\\\\\"@@assign\\\\\\":[\\\\\\"Beijing\\\\\\",\\\\\\"Shanghai\\\\\\"]},\\\\\\"tag_key\\\\\\":{\\\\\\"@@assign\\\\\\":\\\\\\"CostCenter\\\\\\"}}}}\\n")
         example_policy_attachment = alicloud.tag.PolicyAttachment("example",
             policy_id=example.id,
             target_id=default.id,

pulumi_alicloud/threatdetection/__init__.py

@@ -9,6 +9,7 @@ import typing
 from .anti_brute_force_rule import *
 from .asset_bind import *
 from .asset_selection_config import *
+from .attack_path_sensitive_asset_config import *
 from .backup_policy import *
 from .baseline_strategy import *
 from .client_file_protect import *

pulumi_alicloud/threatdetection/_inputs.py

@@ -15,6 +15,10 @@ else:
 from .. import _utilities
 
 __all__ = [
+    'AntiBruteForceRuleProtocolTypeArgs',
+    'AntiBruteForceRuleProtocolTypeArgsDict',
+    'AttackPathSensitiveAssetConfigAttackPathAssetListArgs',
+    'AttackPathSensitiveAssetConfigAttackPathAssetListArgsDict',
     'HoneypotPresetMetaArgs',
     'HoneypotPresetMetaArgsDict',
     'HoneypotProbeHoneypotBindListArgs',
@@ -27,6 +31,185 @@ __all__ = [
 
 MYPY = False
 
+if not MYPY:
+    class AntiBruteForceRuleProtocolTypeArgsDict(TypedDict):
+        rdp: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Whether to enable RDP interception. Default value: `on`. Valid values: `on`, `off`.
+        """
+        sql_server: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Whether to enable the SqlServer interception method. Default value: `off`. Valid values: `on`, `off`.
+        """
+        ssh: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Whether to enable SSH interception. Default value: `on`. Valid values: `on`, `off`.
+        """
+elif False:
+    AntiBruteForceRuleProtocolTypeArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AntiBruteForceRuleProtocolTypeArgs:
+    def __init__(__self__, *,
+                 rdp: Optional[pulumi.Input[_builtins.str]] = None,
+                 sql_server: Optional[pulumi.Input[_builtins.str]] = None,
+                 ssh: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] rdp: Whether to enable RDP interception. Default value: `on`. Valid values: `on`, `off`.
+        :param pulumi.Input[_builtins.str] sql_server: Whether to enable the SqlServer interception method. Default value: `off`. Valid values: `on`, `off`.
+        :param pulumi.Input[_builtins.str] ssh: Whether to enable SSH interception. Default value: `on`. Valid values: `on`, `off`.
+        """
+        if rdp is not None:
+            pulumi.set(__self__, "rdp", rdp)
+        if sql_server is not None:
+            pulumi.set(__self__, "sql_server", sql_server)
+        if ssh is not None:
+            pulumi.set(__self__, "ssh", ssh)
+
+    @_builtins.property
+    @pulumi.getter
+    def rdp(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Whether to enable RDP interception. Default value: `on`. Valid values: `on`, `off`.
+        """
+        return pulumi.get(self, "rdp")
+
+    @rdp.setter
+    def rdp(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "rdp", value)
+
+    @_builtins.property
+    @pulumi.getter(name="sqlServer")
+    def sql_server(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Whether to enable the SqlServer interception method. Default value: `off`. Valid values: `on`, `off`.
+        """
+        return pulumi.get(self, "sql_server")
+
+    @sql_server.setter
+    def sql_server(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "sql_server", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def ssh(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Whether to enable SSH interception. Default value: `on`. Valid values: `on`, `off`.
+        """
+        return pulumi.get(self, "ssh")
+
+    @ssh.setter
+    def ssh(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "ssh", value)
+
+
+if not MYPY:
+    class AttackPathSensitiveAssetConfigAttackPathAssetListArgsDict(TypedDict):
+        asset_sub_type: pulumi.Input[_builtins.int]
+        """
+        Cloud product asset subtype.
+        """
+        asset_type: pulumi.Input[_builtins.int]
+        """
+        The asset type of the cloud product asset.
+        """
+        instance_id: pulumi.Input[_builtins.str]
+        """
+        The ID of the cloud product instance.
+        """
+        region_id: pulumi.Input[_builtins.str]
+        """
+        The region ID of the cloud product.
+        """
+        vendor: pulumi.Input[_builtins.int]
+        """
+        Cloud product asset vendor. Valid values: `0`.
+        """
+elif False:
+    AttackPathSensitiveAssetConfigAttackPathAssetListArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AttackPathSensitiveAssetConfigAttackPathAssetListArgs:
+    def __init__(__self__, *,
+                 asset_sub_type: pulumi.Input[_builtins.int],
+                 asset_type: pulumi.Input[_builtins.int],
+                 instance_id: pulumi.Input[_builtins.str],
+                 region_id: pulumi.Input[_builtins.str],
+                 vendor: pulumi.Input[_builtins.int]):
+        """
+        :param pulumi.Input[_builtins.int] asset_sub_type: Cloud product asset subtype.
+        :param pulumi.Input[_builtins.int] asset_type: The asset type of the cloud product asset.
+        :param pulumi.Input[_builtins.str] instance_id: The ID of the cloud product instance.
+        :param pulumi.Input[_builtins.str] region_id: The region ID of the cloud product.
+        :param pulumi.Input[_builtins.int] vendor: Cloud product asset vendor. Valid values: `0`.
+        """
+        pulumi.set(__self__, "asset_sub_type", asset_sub_type)
+        pulumi.set(__self__, "asset_type", asset_type)
+        pulumi.set(__self__, "instance_id", instance_id)
+        pulumi.set(__self__, "region_id", region_id)
+        pulumi.set(__self__, "vendor", vendor)
+
+    @_builtins.property
+    @pulumi.getter(name="assetSubType")
+    def asset_sub_type(self) -> pulumi.Input[_builtins.int]:
+        """
+        Cloud product asset subtype.
+        """
+        return pulumi.get(self, "asset_sub_type")
+
+    @asset_sub_type.setter
+    def asset_sub_type(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "asset_sub_type", value)
+
+    @_builtins.property
+    @pulumi.getter(name="assetType")
+    def asset_type(self) -> pulumi.Input[_builtins.int]:
+        """
+        The asset type of the cloud product asset.
+        """
+        return pulumi.get(self, "asset_type")
+
+    @asset_type.setter
+    def asset_type(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "asset_type", value)
+
+    @_builtins.property
+    @pulumi.getter(name="instanceId")
+    def instance_id(self) -> pulumi.Input[_builtins.str]:
+        """
+        The ID of the cloud product instance.
+        """
+        return pulumi.get(self, "instance_id")
+
+    @instance_id.setter
+    def instance_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "instance_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="regionId")
+    def region_id(self) -> pulumi.Input[_builtins.str]:
+        """
+        The region ID of the cloud product.
+        """
+        return pulumi.get(self, "region_id")
+
+    @region_id.setter
+    def region_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "region_id", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def vendor(self) -> pulumi.Input[_builtins.int]:
+        """
+        Cloud product asset vendor. Valid values: `0`.
+        """
+        return pulumi.get(self, "vendor")
+
+    @vendor.setter
+    def vendor(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "vendor", value)
+
+
 if not MYPY:
     class HoneypotPresetMetaArgsDict(TypedDict):
         burp: pulumi.Input[_builtins.str]

pulumi_alicloud/threatdetection/anti_brute_force_rule.py

@@ -13,6 +13,8 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
+from . import outputs
+from ._inputs import *
 
 __all__ = ['AntiBruteForceRuleArgs', 'AntiBruteForceRule']
 
@@ -24,7 +26,8 @@ class AntiBruteForceRuleArgs:
                  forbidden_time: pulumi.Input[_builtins.int],
                  span: pulumi.Input[_builtins.int],
                  uuid_lists: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
-                 default_rule: Optional[pulumi.Input[_builtins.bool]] = None):
+                 default_rule: Optional[pulumi.Input[_builtins.bool]] = None,
+                 protocol_type: Optional[pulumi.Input['AntiBruteForceRuleProtocolTypeArgs']] = None):
         """
         The set of arguments for constructing a AntiBruteForceRule resource.
         :param pulumi.Input[_builtins.str] anti_brute_force_rule_name: The name of the defense rule.
@@ -33,6 +36,7 @@ class AntiBruteForceRuleArgs:
         :param pulumi.Input[_builtins.int] span: The maximum period of time during which failed logon attempts from an account can occur. Unit: minutes. Valid values:
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uuid_lists: The UUIDs of the servers to which you want to apply the defense rule.
         :param pulumi.Input[_builtins.bool] default_rule: Specifies whether to set the defense rule as the default rule. Valid values:
+        :param pulumi.Input['AntiBruteForceRuleProtocolTypeArgs'] protocol_type: The types of protocols supported for interception by the brute force attack rule creation. See `protocol_type` below.
         """
         pulumi.set(__self__, "anti_brute_force_rule_name", anti_brute_force_rule_name)
         pulumi.set(__self__, "fail_count", fail_count)
@@ -41,6 +45,8 @@ class AntiBruteForceRuleArgs:
         pulumi.set(__self__, "uuid_lists", uuid_lists)
         if default_rule is not None:
             pulumi.set(__self__, "default_rule", default_rule)
+        if protocol_type is not None:
+            pulumi.set(__self__, "protocol_type", protocol_type)
 
     @_builtins.property
     @pulumi.getter(name="antiBruteForceRuleName")
@@ -114,6 +120,18 @@ class AntiBruteForceRuleArgs:
     def default_rule(self, value: Optional[pulumi.Input[_builtins.bool]]):
         pulumi.set(self, "default_rule", value)
 
+    @_builtins.property
+    @pulumi.getter(name="protocolType")
+    def protocol_type(self) -> Optional[pulumi.Input['AntiBruteForceRuleProtocolTypeArgs']]:
+        """
+        The types of protocols supported for interception by the brute force attack rule creation. See `protocol_type` below.
+        """
+        return pulumi.get(self, "protocol_type")
+
+    @protocol_type.setter
+    def protocol_type(self, value: Optional[pulumi.Input['AntiBruteForceRuleProtocolTypeArgs']]):
+        pulumi.set(self, "protocol_type", value)
+
 
 @pulumi.input_type
 class _AntiBruteForceRuleState:
@@ -122,6 +140,7 @@ class _AntiBruteForceRuleState:
                  default_rule: Optional[pulumi.Input[_builtins.bool]] = None,
                  fail_count: Optional[pulumi.Input[_builtins.int]] = None,
                  forbidden_time: Optional[pulumi.Input[_builtins.int]] = None,
+                 protocol_type: Optional[pulumi.Input['AntiBruteForceRuleProtocolTypeArgs']] = None,
                  span: Optional[pulumi.Input[_builtins.int]] = None,
                  uuid_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
         """
@@ -130,6 +149,7 @@ class _AntiBruteForceRuleState:
         :param pulumi.Input[_builtins.bool] default_rule: Specifies whether to set the defense rule as the default rule. Valid values:
         :param pulumi.Input[_builtins.int] fail_count: FailCount
         :param pulumi.Input[_builtins.int] forbidden_time: The period of time during which logons from an account are not allowed. Unit: minutes. Valid values:
+        :param pulumi.Input['AntiBruteForceRuleProtocolTypeArgs'] protocol_type: The types of protocols supported for interception by the brute force attack rule creation. See `protocol_type` below.
         :param pulumi.Input[_builtins.int] span: The maximum period of time during which failed logon attempts from an account can occur. Unit: minutes. Valid values:
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uuid_lists: The UUIDs of the servers to which you want to apply the defense rule.
         """
@@ -141,6 +161,8 @@ class _AntiBruteForceRuleState:
             pulumi.set(__self__, "fail_count", fail_count)
         if forbidden_time is not None:
             pulumi.set(__self__, "forbidden_time", forbidden_time)
+        if protocol_type is not None:
+            pulumi.set(__self__, "protocol_type", protocol_type)
         if span is not None:
             pulumi.set(__self__, "span", span)
         if uuid_lists is not None:
@@ -194,6 +216,18 @@ class _AntiBruteForceRuleState:
     def forbidden_time(self, value: Optional[pulumi.Input[_builtins.int]]):
         pulumi.set(self, "forbidden_time", value)
 
+    @_builtins.property
+    @pulumi.getter(name="protocolType")
+    def protocol_type(self) -> Optional[pulumi.Input['AntiBruteForceRuleProtocolTypeArgs']]:
+        """
+        The types of protocols supported for interception by the brute force attack rule creation. See `protocol_type` below.
+        """
+        return pulumi.get(self, "protocol_type")
+
+    @protocol_type.setter
+    def protocol_type(self, value: Optional[pulumi.Input['AntiBruteForceRuleProtocolTypeArgs']]):
+        pulumi.set(self, "protocol_type", value)
+
     @_builtins.property
     @pulumi.getter
     def span(self) -> Optional[pulumi.Input[_builtins.int]]:
@@ -229,6 +263,7 @@ class AntiBruteForceRule(pulumi.CustomResource):
                  default_rule: Optional[pulumi.Input[_builtins.bool]] = None,
                  fail_count: Optional[pulumi.Input[_builtins.int]] = None,
                  forbidden_time: Optional[pulumi.Input[_builtins.int]] = None,
+                 protocol_type: Optional[pulumi.Input[Union['AntiBruteForceRuleProtocolTypeArgs', 'AntiBruteForceRuleProtocolTypeArgsDict']]] = None,
                  span: Optional[pulumi.Input[_builtins.int]] = None,
                  uuid_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                  __props__=None):
@@ -271,6 +306,7 @@ class AntiBruteForceRule(pulumi.CustomResource):
         :param pulumi.Input[_builtins.bool] default_rule: Specifies whether to set the defense rule as the default rule. Valid values:
         :param pulumi.Input[_builtins.int] fail_count: FailCount
         :param pulumi.Input[_builtins.int] forbidden_time: The period of time during which logons from an account are not allowed. Unit: minutes. Valid values:
+        :param pulumi.Input[Union['AntiBruteForceRuleProtocolTypeArgs', 'AntiBruteForceRuleProtocolTypeArgsDict']] protocol_type: The types of protocols supported for interception by the brute force attack rule creation. See `protocol_type` below.
         :param pulumi.Input[_builtins.int] span: The maximum period of time during which failed logon attempts from an account can occur. Unit: minutes. Valid values:
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uuid_lists: The UUIDs of the servers to which you want to apply the defense rule.
         """
@@ -332,6 +368,7 @@ class AntiBruteForceRule(pulumi.CustomResource):
                  default_rule: Optional[pulumi.Input[_builtins.bool]] = None,
                  fail_count: Optional[pulumi.Input[_builtins.int]] = None,
                  forbidden_time: Optional[pulumi.Input[_builtins.int]] = None,
+                 protocol_type: Optional[pulumi.Input[Union['AntiBruteForceRuleProtocolTypeArgs', 'AntiBruteForceRuleProtocolTypeArgsDict']]] = None,
                  span: Optional[pulumi.Input[_builtins.int]] = None,
                  uuid_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                  __props__=None):
@@ -353,6 +390,7 @@ class AntiBruteForceRule(pulumi.CustomResource):
             if forbidden_time is None and not opts.urn:
                 raise TypeError("Missing required property 'forbidden_time'")
             __props__.__dict__["forbidden_time"] = forbidden_time
+            __props__.__dict__["protocol_type"] = protocol_type
             if span is None and not opts.urn:
                 raise TypeError("Missing required property 'span'")
             __props__.__dict__["span"] = span
@@ -373,6 +411,7 @@ class AntiBruteForceRule(pulumi.CustomResource):
             default_rule: Optional[pulumi.Input[_builtins.bool]] = None,
             fail_count: Optional[pulumi.Input[_builtins.int]] = None,
             forbidden_time: Optional[pulumi.Input[_builtins.int]] = None,
+            protocol_type: Optional[pulumi.Input[Union['AntiBruteForceRuleProtocolTypeArgs', 'AntiBruteForceRuleProtocolTypeArgsDict']]] = None,
             span: Optional[pulumi.Input[_builtins.int]] = None,
             uuid_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None) -> 'AntiBruteForceRule':
         """
@@ -386,6 +425,7 @@ class AntiBruteForceRule(pulumi.CustomResource):
         :param pulumi.Input[_builtins.bool] default_rule: Specifies whether to set the defense rule as the default rule. Valid values:
         :param pulumi.Input[_builtins.int] fail_count: FailCount
         :param pulumi.Input[_builtins.int] forbidden_time: The period of time during which logons from an account are not allowed. Unit: minutes. Valid values:
+        :param pulumi.Input[Union['AntiBruteForceRuleProtocolTypeArgs', 'AntiBruteForceRuleProtocolTypeArgsDict']] protocol_type: The types of protocols supported for interception by the brute force attack rule creation. See `protocol_type` below.
         :param pulumi.Input[_builtins.int] span: The maximum period of time during which failed logon attempts from an account can occur. Unit: minutes. Valid values:
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uuid_lists: The UUIDs of the servers to which you want to apply the defense rule.
         """
@@ -397,6 +437,7 @@ class AntiBruteForceRule(pulumi.CustomResource):
         __props__.__dict__["default_rule"] = default_rule
         __props__.__dict__["fail_count"] = fail_count
         __props__.__dict__["forbidden_time"] = forbidden_time
+        __props__.__dict__["protocol_type"] = protocol_type
         __props__.__dict__["span"] = span
         __props__.__dict__["uuid_lists"] = uuid_lists
         return AntiBruteForceRule(resource_name, opts=opts, __props__=__props__)
@@ -433,6 +474,14 @@ class AntiBruteForceRule(pulumi.CustomResource):
         """
         return pulumi.get(self, "forbidden_time")
 
+    @_builtins.property
+    @pulumi.getter(name="protocolType")
+    def protocol_type(self) -> pulumi.Output['outputs.AntiBruteForceRuleProtocolType']:
+        """
+        The types of protocols supported for interception by the brute force attack rule creation. See `protocol_type` below.
+        """
+        return pulumi.get(self, "protocol_type")
+
     @_builtins.property
     @pulumi.getter
     def span(self) -> pulumi.Output[_builtins.int]:

pulumi_alicloud/threatdetection/attack_path_sensitive_asset_config.py

@@ -0,0 +1,218 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+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
+from ._inputs import *
+
+__all__ = ['AttackPathSensitiveAssetConfigArgs', 'AttackPathSensitiveAssetConfig']
+
+@pulumi.input_type
+class AttackPathSensitiveAssetConfigArgs:
+    def __init__(__self__, *,
+                 attack_path_asset_lists: pulumi.Input[Sequence[pulumi.Input['AttackPathSensitiveAssetConfigAttackPathAssetListArgs']]]):
+        """
+        The set of arguments for constructing a AttackPathSensitiveAssetConfig resource.
+        :param pulumi.Input[Sequence[pulumi.Input['AttackPathSensitiveAssetConfigAttackPathAssetListArgs']]] attack_path_asset_lists: The attack path sensitive asset configuration list. See `attack_path_asset_list` below.
+        """
+        pulumi.set(__self__, "attack_path_asset_lists", attack_path_asset_lists)
+
+    @_builtins.property
+    @pulumi.getter(name="attackPathAssetLists")
+    def attack_path_asset_lists(self) -> pulumi.Input[Sequence[pulumi.Input['AttackPathSensitiveAssetConfigAttackPathAssetListArgs']]]:
+        """
+        The attack path sensitive asset configuration list. See `attack_path_asset_list` below.
+        """
+        return pulumi.get(self, "attack_path_asset_lists")
+
+    @attack_path_asset_lists.setter
+    def attack_path_asset_lists(self, value: pulumi.Input[Sequence[pulumi.Input['AttackPathSensitiveAssetConfigAttackPathAssetListArgs']]]):
+        pulumi.set(self, "attack_path_asset_lists", value)
+
+
+@pulumi.input_type
+class _AttackPathSensitiveAssetConfigState:
+    def __init__(__self__, *,
+                 attack_path_asset_lists: Optional[pulumi.Input[Sequence[pulumi.Input['AttackPathSensitiveAssetConfigAttackPathAssetListArgs']]]] = None):
+        """
+        Input properties used for looking up and filtering AttackPathSensitiveAssetConfig resources.
+        :param pulumi.Input[Sequence[pulumi.Input['AttackPathSensitiveAssetConfigAttackPathAssetListArgs']]] attack_path_asset_lists: The attack path sensitive asset configuration list. See `attack_path_asset_list` below.
+        """
+        if attack_path_asset_lists is not None:
+            pulumi.set(__self__, "attack_path_asset_lists", attack_path_asset_lists)
+
+    @_builtins.property
+    @pulumi.getter(name="attackPathAssetLists")
+    def attack_path_asset_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AttackPathSensitiveAssetConfigAttackPathAssetListArgs']]]]:
+        """
+        The attack path sensitive asset configuration list. See `attack_path_asset_list` below.
+        """
+        return pulumi.get(self, "attack_path_asset_lists")
+
+    @attack_path_asset_lists.setter
+    def attack_path_asset_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AttackPathSensitiveAssetConfigAttackPathAssetListArgs']]]]):
+        pulumi.set(self, "attack_path_asset_lists", value)
+
+
+@pulumi.type_token("alicloud:threatdetection/attackPathSensitiveAssetConfig:AttackPathSensitiveAssetConfig")
+class AttackPathSensitiveAssetConfig(pulumi.CustomResource):
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 attack_path_asset_lists: Optional[pulumi.Input[Sequence[pulumi.Input[Union['AttackPathSensitiveAssetConfigAttackPathAssetListArgs', 'AttackPathSensitiveAssetConfigAttackPathAssetListArgsDict']]]]] = None,
+                 __props__=None):
+        """
+        Provides a Threat Detection Attack Path Sensitive Asset Config resource.
+
+        Attack Path Sensitive Asset Configuration.
+
+        For information about Threat Detection Attack Path Sensitive Asset Config and how to use it, see [What is Attack Path Sensitive Asset Config](https://www.alibabacloud.com/help/en/security-center/developer-reference/api-sas-2018-12-03-createattackpathsensitiveassetconfig).
+
+        > **NOTE:** Available since v1.257.0.
+
+        ## Example Usage
+
+        Basic Usage
+
+        ```python
+        import pulumi
+        import pulumi_alicloud as alicloud
+
+        default = alicloud.slb.get_application_load_balancers()
+        default_attack_path_sensitive_asset_config = alicloud.threatdetection.AttackPathSensitiveAssetConfig("default", attack_path_asset_lists=[{
+            "instance_id": default.balancers[0].id,
+            "vendor": 0,
+            "asset_type": 1,
+            "asset_sub_type": 0,
+            "region_id": "cn-hangzhou",
+        }])
+        ```
+
+        ## Import
+
+        Threat Detection Attack Path Sensitive Asset Config can be imported using the id, e.g.
+
+        ```sh
+        $ pulumi import alicloud:threatdetection/attackPathSensitiveAssetConfig:AttackPathSensitiveAssetConfig example <id>
+        ```
+
+        :param str resource_name: The name of the resource.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[Sequence[pulumi.Input[Union['AttackPathSensitiveAssetConfigAttackPathAssetListArgs', 'AttackPathSensitiveAssetConfigAttackPathAssetListArgsDict']]]] attack_path_asset_lists: The attack path sensitive asset configuration list. See `attack_path_asset_list` below.
+        """
+        ...
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 args: AttackPathSensitiveAssetConfigArgs,
+                 opts: Optional[pulumi.ResourceOptions] = None):
+        """
+        Provides a Threat Detection Attack Path Sensitive Asset Config resource.
+
+        Attack Path Sensitive Asset Configuration.
+
+        For information about Threat Detection Attack Path Sensitive Asset Config and how to use it, see [What is Attack Path Sensitive Asset Config](https://www.alibabacloud.com/help/en/security-center/developer-reference/api-sas-2018-12-03-createattackpathsensitiveassetconfig).
+
+        > **NOTE:** Available since v1.257.0.
+
+        ## Example Usage
+
+        Basic Usage
+
+        ```python
+        import pulumi
+        import pulumi_alicloud as alicloud
+
+        default = alicloud.slb.get_application_load_balancers()
+        default_attack_path_sensitive_asset_config = alicloud.threatdetection.AttackPathSensitiveAssetConfig("default", attack_path_asset_lists=[{
+            "instance_id": default.balancers[0].id,
+            "vendor": 0,
+            "asset_type": 1,
+            "asset_sub_type": 0,
+            "region_id": "cn-hangzhou",
+        }])
+        ```
+
+        ## Import
+
+        Threat Detection Attack Path Sensitive Asset Config can be imported using the id, e.g.
+
+        ```sh
+        $ pulumi import alicloud:threatdetection/attackPathSensitiveAssetConfig:AttackPathSensitiveAssetConfig example <id>
+        ```
+
+        :param str resource_name: The name of the resource.
+        :param AttackPathSensitiveAssetConfigArgs args: The arguments to use to populate this resource's properties.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        """
+        ...
+    def __init__(__self__, resource_name: str, *args, **kwargs):
+        resource_args, opts = _utilities.get_resource_args_opts(AttackPathSensitiveAssetConfigArgs, pulumi.ResourceOptions, *args, **kwargs)
+        if resource_args is not None:
+            __self__._internal_init(resource_name, opts, **resource_args.__dict__)
+        else:
+            __self__._internal_init(resource_name, *args, **kwargs)
+
+    def _internal_init(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 attack_path_asset_lists: Optional[pulumi.Input[Sequence[pulumi.Input[Union['AttackPathSensitiveAssetConfigAttackPathAssetListArgs', 'AttackPathSensitiveAssetConfigAttackPathAssetListArgsDict']]]]] = None,
+                 __props__=None):
+        opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
+        if not isinstance(opts, pulumi.ResourceOptions):
+            raise TypeError('Expected resource options to be a ResourceOptions instance')
+        if opts.id is None:
+            if __props__ is not None:
+                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
+            __props__ = AttackPathSensitiveAssetConfigArgs.__new__(AttackPathSensitiveAssetConfigArgs)
+
+            if attack_path_asset_lists is None and not opts.urn:
+                raise TypeError("Missing required property 'attack_path_asset_lists'")
+            __props__.__dict__["attack_path_asset_lists"] = attack_path_asset_lists
+        super(AttackPathSensitiveAssetConfig, __self__).__init__(
+            'alicloud:threatdetection/attackPathSensitiveAssetConfig:AttackPathSensitiveAssetConfig',
+            resource_name,
+            __props__,
+            opts)
+
+    @staticmethod
+    def get(resource_name: str,
+            id: pulumi.Input[str],
+            opts: Optional[pulumi.ResourceOptions] = None,
+            attack_path_asset_lists: Optional[pulumi.Input[Sequence[pulumi.Input[Union['AttackPathSensitiveAssetConfigAttackPathAssetListArgs', 'AttackPathSensitiveAssetConfigAttackPathAssetListArgsDict']]]]] = None) -> 'AttackPathSensitiveAssetConfig':
+        """
+        Get an existing AttackPathSensitiveAssetConfig resource's state with the given name, id, and optional extra
+        properties used to qualify the lookup.
+
+        :param str resource_name: The unique name of the resulting resource.
+        :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[Sequence[pulumi.Input[Union['AttackPathSensitiveAssetConfigAttackPathAssetListArgs', 'AttackPathSensitiveAssetConfigAttackPathAssetListArgsDict']]]] attack_path_asset_lists: The attack path sensitive asset configuration list. See `attack_path_asset_list` below.
+        """
+        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
+
+        __props__ = _AttackPathSensitiveAssetConfigState.__new__(_AttackPathSensitiveAssetConfigState)
+
+        __props__.__dict__["attack_path_asset_lists"] = attack_path_asset_lists
+        return AttackPathSensitiveAssetConfig(resource_name, opts=opts, __props__=__props__)
+
+    @_builtins.property
+    @pulumi.getter(name="attackPathAssetLists")
+    def attack_path_asset_lists(self) -> pulumi.Output[Sequence['outputs.AttackPathSensitiveAssetConfigAttackPathAssetList']]:
+        """
+        The attack path sensitive asset configuration list. See `attack_path_asset_list` below.
+        """
+        return pulumi.get(self, "attack_path_asset_lists")
+