pulumi-oci 3.5.0a1756440723__py3-none-any.whl → 3.6.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pulumi_oci/__init__.py +48 -0
- pulumi_oci/aivision/__init__.py +12 -0
- pulumi_oci/aivision/_inputs.py +787 -51
- pulumi_oci/aivision/get_model.py +4 -4
- pulumi_oci/aivision/get_models.py +11 -11
- pulumi_oci/aivision/get_project.py +15 -15
- pulumi_oci/aivision/get_projects.py +10 -10
- pulumi_oci/aivision/get_stream_group.py +268 -0
- pulumi_oci/aivision/get_stream_groups.py +177 -0
- pulumi_oci/aivision/get_stream_job.py +296 -0
- pulumi_oci/aivision/get_stream_jobs.py +199 -0
- pulumi_oci/aivision/get_stream_source.py +240 -0
- pulumi_oci/aivision/get_stream_sources.py +199 -0
- pulumi_oci/aivision/get_vision_private_endpoint.py +267 -0
- pulumi_oci/aivision/get_vision_private_endpoints.py +199 -0
- pulumi_oci/aivision/model.py +149 -157
- pulumi_oci/aivision/outputs.py +1920 -116
- pulumi_oci/aivision/project.py +61 -69
- pulumi_oci/aivision/stream_group.py +632 -0
- pulumi_oci/aivision/stream_job.py +744 -0
- pulumi_oci/aivision/stream_source.py +519 -0
- pulumi_oci/aivision/vision_private_endpoint.py +606 -0
- pulumi_oci/cloudguard/_inputs.py +1198 -72
- pulumi_oci/cloudguard/get_managed_list.py +15 -1
- pulumi_oci/cloudguard/managed_list.py +47 -0
- pulumi_oci/cloudguard/outputs.py +2104 -67
- pulumi_oci/config/__init__.pyi +12 -17
- pulumi_oci/config/vars.py +12 -17
- pulumi_oci/database/_inputs.py +41 -1
- pulumi_oci/database/exascale_db_storage_vault.py +98 -0
- pulumi_oci/database/get_exascale_db_storage_vault.py +29 -1
- pulumi_oci/database/outputs.py +121 -5
- pulumi_oci/mysql/_inputs.py +221 -0
- pulumi_oci/mysql/get_mysql_backup.py +40 -4
- pulumi_oci/mysql/get_mysql_backups.py +2 -2
- pulumi_oci/mysql/mysql_backup.py +119 -3
- pulumi_oci/mysql/outputs.py +343 -957
- pulumi_oci/oci/__init__.py +8 -0
- pulumi_oci/oci/_inputs.py +256 -15
- pulumi_oci/oci/dbmulticloud_multi_cloud_resource_discovery.py +103 -54
- pulumi_oci/oci/dbmulticloud_oracle_db_azure_blob_container.py +45 -45
- pulumi_oci/oci/dbmulticloud_oracle_db_azure_blob_mount.py +42 -44
- pulumi_oci/oci/dbmulticloud_oracle_db_azure_connector.py +100 -72
- pulumi_oci/oci/dbmulticloud_oracle_db_azure_vault.py +74 -74
- pulumi_oci/oci/dbmulticloud_oracle_db_azure_vault_association.py +50 -50
- pulumi_oci/oci/dbmulticloud_oracle_db_gcp_identity_connector.py +924 -0
- pulumi_oci/oci/dbmulticloud_oracle_db_gcp_key_ring.py +762 -0
- pulumi_oci/oci/get_dbmulticloud_multi_cloud_resource_discoveries.py +37 -15
- pulumi_oci/oci/get_dbmulticloud_multi_cloud_resource_discovery.py +26 -12
- pulumi_oci/oci/get_dbmulticloud_oracle_db_azure_blob_container.py +12 -12
- pulumi_oci/oci/get_dbmulticloud_oracle_db_azure_blob_containers.py +15 -15
- pulumi_oci/oci/get_dbmulticloud_oracle_db_azure_blob_mount.py +12 -12
- pulumi_oci/oci/get_dbmulticloud_oracle_db_azure_blob_mounts.py +15 -15
- pulumi_oci/oci/get_dbmulticloud_oracle_db_azure_connector.py +30 -16
- pulumi_oci/oci/get_dbmulticloud_oracle_db_azure_connectors.py +11 -11
- pulumi_oci/oci/get_dbmulticloud_oracle_db_azure_key.py +41 -13
- pulumi_oci/oci/get_dbmulticloud_oracle_db_azure_keys.py +12 -12
- pulumi_oci/oci/get_dbmulticloud_oracle_db_azure_vault.py +17 -17
- pulumi_oci/oci/get_dbmulticloud_oracle_db_azure_vault_association.py +14 -14
- pulumi_oci/oci/get_dbmulticloud_oracle_db_azure_vault_associations.py +15 -15
- pulumi_oci/oci/get_dbmulticloud_oracle_db_azure_vaults.py +14 -14
- pulumi_oci/oci/get_dbmulticloud_oracle_db_gcp_identity_connector.py +366 -0
- pulumi_oci/oci/get_dbmulticloud_oracle_db_gcp_identity_connectors.py +213 -0
- pulumi_oci/oci/get_dbmulticloud_oracle_db_gcp_key.py +295 -0
- pulumi_oci/oci/get_dbmulticloud_oracle_db_gcp_key_ring.py +309 -0
- pulumi_oci/oci/get_dbmulticloud_oracle_db_gcp_key_rings.py +229 -0
- pulumi_oci/oci/get_dbmulticloud_oracle_db_gcp_keys.py +232 -0
- pulumi_oci/oci/outputs.py +1042 -142
- pulumi_oci/provider.py +44 -63
- pulumi_oci/pulumi-plugin.json +1 -1
- {pulumi_oci-3.5.0a1756440723.dist-info → pulumi_oci-3.6.0.dist-info}/METADATA +1 -1
- {pulumi_oci-3.5.0a1756440723.dist-info → pulumi_oci-3.6.0.dist-info}/RECORD +74 -54
- {pulumi_oci-3.5.0a1756440723.dist-info → pulumi_oci-3.6.0.dist-info}/WHEEL +0 -0
- {pulumi_oci-3.5.0a1756440723.dist-info → pulumi_oci-3.6.0.dist-info}/top_level.txt +0 -0
pulumi_oci/cloudguard/_inputs.py
CHANGED
|
@@ -43,12 +43,18 @@ __all__ = [
|
|
|
43
43
|
'DetectorRecipeDetectorRuleDetailsArgsDict',
|
|
44
44
|
'DetectorRecipeDetectorRuleDetailsConfigurationArgs',
|
|
45
45
|
'DetectorRecipeDetectorRuleDetailsConfigurationArgsDict',
|
|
46
|
+
'DetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgs',
|
|
47
|
+
'DetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgsDict',
|
|
48
|
+
'DetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgs',
|
|
49
|
+
'DetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgsDict',
|
|
46
50
|
'DetectorRecipeDetectorRuleDetailsConfigurationValueArgs',
|
|
47
51
|
'DetectorRecipeDetectorRuleDetailsConfigurationValueArgsDict',
|
|
48
52
|
'DetectorRecipeDetectorRuleDetailsEntitiesMappingArgs',
|
|
49
53
|
'DetectorRecipeDetectorRuleDetailsEntitiesMappingArgsDict',
|
|
50
54
|
'DetectorRecipeDetectorRuleEntitiesMappingArgs',
|
|
51
55
|
'DetectorRecipeDetectorRuleEntitiesMappingArgsDict',
|
|
56
|
+
'DetectorRecipeDetectorRuleRuleTypeArgs',
|
|
57
|
+
'DetectorRecipeDetectorRuleRuleTypeArgsDict',
|
|
52
58
|
'DetectorRecipeEffectiveDetectorRuleArgs',
|
|
53
59
|
'DetectorRecipeEffectiveDetectorRuleArgsDict',
|
|
54
60
|
'DetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgs',
|
|
@@ -57,12 +63,18 @@ __all__ = [
|
|
|
57
63
|
'DetectorRecipeEffectiveDetectorRuleDetailArgsDict',
|
|
58
64
|
'DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs',
|
|
59
65
|
'DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgsDict',
|
|
66
|
+
'DetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgs',
|
|
67
|
+
'DetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgsDict',
|
|
68
|
+
'DetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgs',
|
|
69
|
+
'DetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgsDict',
|
|
60
70
|
'DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs',
|
|
61
71
|
'DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgsDict',
|
|
62
72
|
'DetectorRecipeEffectiveDetectorRuleDetailEntitiesMappingArgs',
|
|
63
73
|
'DetectorRecipeEffectiveDetectorRuleDetailEntitiesMappingArgsDict',
|
|
64
74
|
'DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs',
|
|
65
75
|
'DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgsDict',
|
|
76
|
+
'DetectorRecipeEffectiveDetectorRuleRuleTypeArgs',
|
|
77
|
+
'DetectorRecipeEffectiveDetectorRuleRuleTypeArgsDict',
|
|
66
78
|
'ResponderRecipeEffectiveResponderRuleArgs',
|
|
67
79
|
'ResponderRecipeEffectiveResponderRuleArgsDict',
|
|
68
80
|
'ResponderRecipeEffectiveResponderRuleDetailArgs',
|
|
@@ -89,10 +101,16 @@ __all__ = [
|
|
|
89
101
|
'TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgsDict',
|
|
90
102
|
'TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgs',
|
|
91
103
|
'TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgsDict',
|
|
104
|
+
'TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgs',
|
|
105
|
+
'TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgsDict',
|
|
106
|
+
'TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgs',
|
|
107
|
+
'TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgsDict',
|
|
92
108
|
'TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgs',
|
|
93
109
|
'TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgsDict',
|
|
94
110
|
'TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgs',
|
|
95
111
|
'TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgsDict',
|
|
112
|
+
'TargetTargetDetectorRecipeDetectorRuleRuleTypeArgs',
|
|
113
|
+
'TargetTargetDetectorRecipeDetectorRuleRuleTypeArgsDict',
|
|
96
114
|
'TargetTargetDetectorRecipeEffectiveDetectorRuleArgs',
|
|
97
115
|
'TargetTargetDetectorRecipeEffectiveDetectorRuleArgsDict',
|
|
98
116
|
'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailArgs',
|
|
@@ -101,10 +119,16 @@ __all__ = [
|
|
|
101
119
|
'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConditionGroupArgsDict',
|
|
102
120
|
'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs',
|
|
103
121
|
'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgsDict',
|
|
122
|
+
'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgs',
|
|
123
|
+
'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgsDict',
|
|
124
|
+
'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgs',
|
|
125
|
+
'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgsDict',
|
|
104
126
|
'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs',
|
|
105
127
|
'TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgsDict',
|
|
106
128
|
'TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs',
|
|
107
129
|
'TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgsDict',
|
|
130
|
+
'TargetTargetDetectorRecipeEffectiveDetectorRuleRuleTypeArgs',
|
|
131
|
+
'TargetTargetDetectorRecipeEffectiveDetectorRuleRuleTypeArgsDict',
|
|
108
132
|
'TargetTargetResponderRecipeArgs',
|
|
109
133
|
'TargetTargetResponderRecipeArgsDict',
|
|
110
134
|
'TargetTargetResponderRecipeEffectiveResponderRuleArgs',
|
|
@@ -1087,6 +1111,10 @@ if not MYPY:
|
|
|
1087
1111
|
"""
|
|
1088
1112
|
Data source entities mapping for the detector rule
|
|
1089
1113
|
"""
|
|
1114
|
+
is_cloneable: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1115
|
+
"""
|
|
1116
|
+
Is the rule cloneable?
|
|
1117
|
+
"""
|
|
1090
1118
|
lifecycle_details: NotRequired[pulumi.Input[_builtins.str]]
|
|
1091
1119
|
"""
|
|
1092
1120
|
A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
|
|
@@ -1103,6 +1131,10 @@ if not MYPY:
|
|
|
1103
1131
|
"""
|
|
1104
1132
|
Resource type of the configuration to which the rule is applied
|
|
1105
1133
|
"""
|
|
1134
|
+
rule_types: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleRuleTypeArgsDict']]]]
|
|
1135
|
+
"""
|
|
1136
|
+
Detector rule type
|
|
1137
|
+
"""
|
|
1106
1138
|
service_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
1107
1139
|
"""
|
|
1108
1140
|
Service type of the configuration to which the rule is applied
|
|
@@ -1133,10 +1165,12 @@ class DetectorRecipeDetectorRuleArgs:
|
|
|
1133
1165
|
detector: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1134
1166
|
display_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1135
1167
|
entities_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleEntitiesMappingArgs']]]] = None,
|
|
1168
|
+
is_cloneable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1136
1169
|
lifecycle_details: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1137
1170
|
managed_list_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1138
1171
|
recommendation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1139
1172
|
resource_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1173
|
+
rule_types: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleRuleTypeArgs']]]] = None,
|
|
1140
1174
|
service_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1141
1175
|
state: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1142
1176
|
time_created: Optional[pulumi.Input[_builtins.str]] = None,
|
|
@@ -1154,10 +1188,12 @@ class DetectorRecipeDetectorRuleArgs:
|
|
|
1154
1188
|
|
|
1155
1189
|
Avoid entering confidential information.
|
|
1156
1190
|
:param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleEntitiesMappingArgs']]] entities_mappings: Data source entities mapping for the detector rule
|
|
1191
|
+
:param pulumi.Input[_builtins.bool] is_cloneable: Is the rule cloneable?
|
|
1157
1192
|
:param pulumi.Input[_builtins.str] lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
|
|
1158
1193
|
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] managed_list_types: List of managed list types related to this rule
|
|
1159
1194
|
:param pulumi.Input[_builtins.str] recommendation: Recommendation for DetectorRecipeDetectorRule resource
|
|
1160
1195
|
:param pulumi.Input[_builtins.str] resource_type: Resource type of the configuration to which the rule is applied
|
|
1196
|
+
:param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleRuleTypeArgs']]] rule_types: Detector rule type
|
|
1161
1197
|
:param pulumi.Input[_builtins.str] service_type: Service type of the configuration to which the rule is applied
|
|
1162
1198
|
:param pulumi.Input[_builtins.str] state: The current lifecycle state of the resource
|
|
1163
1199
|
:param pulumi.Input[_builtins.str] time_created: The date and time the detector recipe was created Format defined by RFC3339.
|
|
@@ -1177,6 +1213,8 @@ class DetectorRecipeDetectorRuleArgs:
|
|
|
1177
1213
|
pulumi.set(__self__, "display_name", display_name)
|
|
1178
1214
|
if entities_mappings is not None:
|
|
1179
1215
|
pulumi.set(__self__, "entities_mappings", entities_mappings)
|
|
1216
|
+
if is_cloneable is not None:
|
|
1217
|
+
pulumi.set(__self__, "is_cloneable", is_cloneable)
|
|
1180
1218
|
if lifecycle_details is not None:
|
|
1181
1219
|
pulumi.set(__self__, "lifecycle_details", lifecycle_details)
|
|
1182
1220
|
if managed_list_types is not None:
|
|
@@ -1185,6 +1223,8 @@ class DetectorRecipeDetectorRuleArgs:
|
|
|
1185
1223
|
pulumi.set(__self__, "recommendation", recommendation)
|
|
1186
1224
|
if resource_type is not None:
|
|
1187
1225
|
pulumi.set(__self__, "resource_type", resource_type)
|
|
1226
|
+
if rule_types is not None:
|
|
1227
|
+
pulumi.set(__self__, "rule_types", rule_types)
|
|
1188
1228
|
if service_type is not None:
|
|
1189
1229
|
pulumi.set(__self__, "service_type", service_type)
|
|
1190
1230
|
if state is not None:
|
|
@@ -1294,6 +1334,18 @@ class DetectorRecipeDetectorRuleArgs:
|
|
|
1294
1334
|
def entities_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleEntitiesMappingArgs']]]]):
|
|
1295
1335
|
pulumi.set(self, "entities_mappings", value)
|
|
1296
1336
|
|
|
1337
|
+
@_builtins.property
|
|
1338
|
+
@pulumi.getter(name="isCloneable")
|
|
1339
|
+
def is_cloneable(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1340
|
+
"""
|
|
1341
|
+
Is the rule cloneable?
|
|
1342
|
+
"""
|
|
1343
|
+
return pulumi.get(self, "is_cloneable")
|
|
1344
|
+
|
|
1345
|
+
@is_cloneable.setter
|
|
1346
|
+
def is_cloneable(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1347
|
+
pulumi.set(self, "is_cloneable", value)
|
|
1348
|
+
|
|
1297
1349
|
@_builtins.property
|
|
1298
1350
|
@pulumi.getter(name="lifecycleDetails")
|
|
1299
1351
|
def lifecycle_details(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -1342,6 +1394,18 @@ class DetectorRecipeDetectorRuleArgs:
|
|
|
1342
1394
|
def resource_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1343
1395
|
pulumi.set(self, "resource_type", value)
|
|
1344
1396
|
|
|
1397
|
+
@_builtins.property
|
|
1398
|
+
@pulumi.getter(name="ruleTypes")
|
|
1399
|
+
def rule_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleRuleTypeArgs']]]]:
|
|
1400
|
+
"""
|
|
1401
|
+
Detector rule type
|
|
1402
|
+
"""
|
|
1403
|
+
return pulumi.get(self, "rule_types")
|
|
1404
|
+
|
|
1405
|
+
@rule_types.setter
|
|
1406
|
+
def rule_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleRuleTypeArgs']]]]):
|
|
1407
|
+
pulumi.set(self, "rule_types", value)
|
|
1408
|
+
|
|
1345
1409
|
@_builtins.property
|
|
1346
1410
|
@pulumi.getter(name="serviceType")
|
|
1347
1411
|
def service_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -1689,6 +1753,18 @@ if not MYPY:
|
|
|
1689
1753
|
"""
|
|
1690
1754
|
(Updatable) Configuration name
|
|
1691
1755
|
"""
|
|
1756
|
+
additional_properties: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgsDict']]]]
|
|
1757
|
+
"""
|
|
1758
|
+
(Updatable) Map of additional property values for configuration
|
|
1759
|
+
"""
|
|
1760
|
+
allowed_values: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgsDict']]]]
|
|
1761
|
+
"""
|
|
1762
|
+
(Updatable) Map of possible values for configuration
|
|
1763
|
+
"""
|
|
1764
|
+
allowed_values_data_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
1765
|
+
"""
|
|
1766
|
+
(Updatable) Map property Value data type
|
|
1767
|
+
"""
|
|
1692
1768
|
data_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
1693
1769
|
"""
|
|
1694
1770
|
(Updatable) Configuration data type
|
|
@@ -1709,18 +1785,30 @@ class DetectorRecipeDetectorRuleDetailsConfigurationArgs:
|
|
|
1709
1785
|
def __init__(__self__, *,
|
|
1710
1786
|
config_key: pulumi.Input[_builtins.str],
|
|
1711
1787
|
name: pulumi.Input[_builtins.str],
|
|
1788
|
+
additional_properties: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgs']]]] = None,
|
|
1789
|
+
allowed_values: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgs']]]] = None,
|
|
1790
|
+
allowed_values_data_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1712
1791
|
data_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1713
1792
|
value: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1714
1793
|
values: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationValueArgs']]]] = None):
|
|
1715
1794
|
"""
|
|
1716
1795
|
:param pulumi.Input[_builtins.str] config_key: (Updatable) Unique identifier of the configuration
|
|
1717
1796
|
:param pulumi.Input[_builtins.str] name: (Updatable) Configuration name
|
|
1797
|
+
:param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgs']]] additional_properties: (Updatable) Map of additional property values for configuration
|
|
1798
|
+
:param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgs']]] allowed_values: (Updatable) Map of possible values for configuration
|
|
1799
|
+
:param pulumi.Input[_builtins.str] allowed_values_data_type: (Updatable) Map property Value data type
|
|
1718
1800
|
:param pulumi.Input[_builtins.str] data_type: (Updatable) Configuration data type
|
|
1719
1801
|
:param pulumi.Input[_builtins.str] value: (Updatable) Configuration value
|
|
1720
1802
|
:param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationValueArgs']]] values: (Updatable) List of configuration values
|
|
1721
1803
|
"""
|
|
1722
1804
|
pulumi.set(__self__, "config_key", config_key)
|
|
1723
1805
|
pulumi.set(__self__, "name", name)
|
|
1806
|
+
if additional_properties is not None:
|
|
1807
|
+
pulumi.set(__self__, "additional_properties", additional_properties)
|
|
1808
|
+
if allowed_values is not None:
|
|
1809
|
+
pulumi.set(__self__, "allowed_values", allowed_values)
|
|
1810
|
+
if allowed_values_data_type is not None:
|
|
1811
|
+
pulumi.set(__self__, "allowed_values_data_type", allowed_values_data_type)
|
|
1724
1812
|
if data_type is not None:
|
|
1725
1813
|
pulumi.set(__self__, "data_type", data_type)
|
|
1726
1814
|
if value is not None:
|
|
@@ -1752,6 +1840,42 @@ class DetectorRecipeDetectorRuleDetailsConfigurationArgs:
|
|
|
1752
1840
|
def name(self, value: pulumi.Input[_builtins.str]):
|
|
1753
1841
|
pulumi.set(self, "name", value)
|
|
1754
1842
|
|
|
1843
|
+
@_builtins.property
|
|
1844
|
+
@pulumi.getter(name="additionalProperties")
|
|
1845
|
+
def additional_properties(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgs']]]]:
|
|
1846
|
+
"""
|
|
1847
|
+
(Updatable) Map of additional property values for configuration
|
|
1848
|
+
"""
|
|
1849
|
+
return pulumi.get(self, "additional_properties")
|
|
1850
|
+
|
|
1851
|
+
@additional_properties.setter
|
|
1852
|
+
def additional_properties(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgs']]]]):
|
|
1853
|
+
pulumi.set(self, "additional_properties", value)
|
|
1854
|
+
|
|
1855
|
+
@_builtins.property
|
|
1856
|
+
@pulumi.getter(name="allowedValues")
|
|
1857
|
+
def allowed_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgs']]]]:
|
|
1858
|
+
"""
|
|
1859
|
+
(Updatable) Map of possible values for configuration
|
|
1860
|
+
"""
|
|
1861
|
+
return pulumi.get(self, "allowed_values")
|
|
1862
|
+
|
|
1863
|
+
@allowed_values.setter
|
|
1864
|
+
def allowed_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgs']]]]):
|
|
1865
|
+
pulumi.set(self, "allowed_values", value)
|
|
1866
|
+
|
|
1867
|
+
@_builtins.property
|
|
1868
|
+
@pulumi.getter(name="allowedValuesDataType")
|
|
1869
|
+
def allowed_values_data_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1870
|
+
"""
|
|
1871
|
+
(Updatable) Map property Value data type
|
|
1872
|
+
"""
|
|
1873
|
+
return pulumi.get(self, "allowed_values_data_type")
|
|
1874
|
+
|
|
1875
|
+
@allowed_values_data_type.setter
|
|
1876
|
+
def allowed_values_data_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1877
|
+
pulumi.set(self, "allowed_values_data_type", value)
|
|
1878
|
+
|
|
1755
1879
|
@_builtins.property
|
|
1756
1880
|
@pulumi.getter(name="dataType")
|
|
1757
1881
|
def data_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -1789,6 +1913,128 @@ class DetectorRecipeDetectorRuleDetailsConfigurationArgs:
|
|
|
1789
1913
|
pulumi.set(self, "values", value)
|
|
1790
1914
|
|
|
1791
1915
|
|
|
1916
|
+
if not MYPY:
|
|
1917
|
+
class DetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgsDict(TypedDict):
|
|
1918
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
1919
|
+
"""
|
|
1920
|
+
(Updatable) Name for Additional Property, for example, "interpreter", "router"
|
|
1921
|
+
"""
|
|
1922
|
+
property_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
1923
|
+
"""
|
|
1924
|
+
(Updatable) Property Type
|
|
1925
|
+
"""
|
|
1926
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
1927
|
+
"""
|
|
1928
|
+
(Updatable) Value for Property Name, for example, "generic", "cloudguard"
|
|
1929
|
+
"""
|
|
1930
|
+
elif False:
|
|
1931
|
+
DetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1932
|
+
|
|
1933
|
+
@pulumi.input_type
|
|
1934
|
+
class DetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgs:
|
|
1935
|
+
def __init__(__self__, *,
|
|
1936
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1937
|
+
property_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1938
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1939
|
+
"""
|
|
1940
|
+
:param pulumi.Input[_builtins.str] key: (Updatable) Name for Additional Property, for example, "interpreter", "router"
|
|
1941
|
+
:param pulumi.Input[_builtins.str] property_type: (Updatable) Property Type
|
|
1942
|
+
:param pulumi.Input[_builtins.str] value: (Updatable) Value for Property Name, for example, "generic", "cloudguard"
|
|
1943
|
+
"""
|
|
1944
|
+
if key is not None:
|
|
1945
|
+
pulumi.set(__self__, "key", key)
|
|
1946
|
+
if property_type is not None:
|
|
1947
|
+
pulumi.set(__self__, "property_type", property_type)
|
|
1948
|
+
if value is not None:
|
|
1949
|
+
pulumi.set(__self__, "value", value)
|
|
1950
|
+
|
|
1951
|
+
@_builtins.property
|
|
1952
|
+
@pulumi.getter
|
|
1953
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1954
|
+
"""
|
|
1955
|
+
(Updatable) Name for Additional Property, for example, "interpreter", "router"
|
|
1956
|
+
"""
|
|
1957
|
+
return pulumi.get(self, "key")
|
|
1958
|
+
|
|
1959
|
+
@key.setter
|
|
1960
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1961
|
+
pulumi.set(self, "key", value)
|
|
1962
|
+
|
|
1963
|
+
@_builtins.property
|
|
1964
|
+
@pulumi.getter(name="propertyType")
|
|
1965
|
+
def property_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1966
|
+
"""
|
|
1967
|
+
(Updatable) Property Type
|
|
1968
|
+
"""
|
|
1969
|
+
return pulumi.get(self, "property_type")
|
|
1970
|
+
|
|
1971
|
+
@property_type.setter
|
|
1972
|
+
def property_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1973
|
+
pulumi.set(self, "property_type", value)
|
|
1974
|
+
|
|
1975
|
+
@_builtins.property
|
|
1976
|
+
@pulumi.getter
|
|
1977
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1978
|
+
"""
|
|
1979
|
+
(Updatable) Value for Property Name, for example, "generic", "cloudguard"
|
|
1980
|
+
"""
|
|
1981
|
+
return pulumi.get(self, "value")
|
|
1982
|
+
|
|
1983
|
+
@value.setter
|
|
1984
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1985
|
+
pulumi.set(self, "value", value)
|
|
1986
|
+
|
|
1987
|
+
|
|
1988
|
+
if not MYPY:
|
|
1989
|
+
class DetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgsDict(TypedDict):
|
|
1990
|
+
key: pulumi.Input[_builtins.str]
|
|
1991
|
+
"""
|
|
1992
|
+
(Updatable) key
|
|
1993
|
+
"""
|
|
1994
|
+
value: pulumi.Input[_builtins.str]
|
|
1995
|
+
"""
|
|
1996
|
+
(Updatable) value
|
|
1997
|
+
"""
|
|
1998
|
+
elif False:
|
|
1999
|
+
DetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgsDict: TypeAlias = Mapping[str, Any]
|
|
2000
|
+
|
|
2001
|
+
@pulumi.input_type
|
|
2002
|
+
class DetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgs:
|
|
2003
|
+
def __init__(__self__, *,
|
|
2004
|
+
key: pulumi.Input[_builtins.str],
|
|
2005
|
+
value: pulumi.Input[_builtins.str]):
|
|
2006
|
+
"""
|
|
2007
|
+
:param pulumi.Input[_builtins.str] key: (Updatable) key
|
|
2008
|
+
:param pulumi.Input[_builtins.str] value: (Updatable) value
|
|
2009
|
+
"""
|
|
2010
|
+
pulumi.set(__self__, "key", key)
|
|
2011
|
+
pulumi.set(__self__, "value", value)
|
|
2012
|
+
|
|
2013
|
+
@_builtins.property
|
|
2014
|
+
@pulumi.getter
|
|
2015
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
2016
|
+
"""
|
|
2017
|
+
(Updatable) key
|
|
2018
|
+
"""
|
|
2019
|
+
return pulumi.get(self, "key")
|
|
2020
|
+
|
|
2021
|
+
@key.setter
|
|
2022
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
2023
|
+
pulumi.set(self, "key", value)
|
|
2024
|
+
|
|
2025
|
+
@_builtins.property
|
|
2026
|
+
@pulumi.getter
|
|
2027
|
+
def value(self) -> pulumi.Input[_builtins.str]:
|
|
2028
|
+
"""
|
|
2029
|
+
(Updatable) value
|
|
2030
|
+
"""
|
|
2031
|
+
return pulumi.get(self, "value")
|
|
2032
|
+
|
|
2033
|
+
@value.setter
|
|
2034
|
+
def value(self, value: pulumi.Input[_builtins.str]):
|
|
2035
|
+
pulumi.set(self, "value", value)
|
|
2036
|
+
|
|
2037
|
+
|
|
1792
2038
|
if not MYPY:
|
|
1793
2039
|
class DetectorRecipeDetectorRuleDetailsConfigurationValueArgsDict(TypedDict):
|
|
1794
2040
|
list_type: pulumi.Input[_builtins.str]
|
|
@@ -2007,6 +2253,58 @@ class DetectorRecipeDetectorRuleEntitiesMappingArgs:
|
|
|
2007
2253
|
pulumi.set(self, "query_field", value)
|
|
2008
2254
|
|
|
2009
2255
|
|
|
2256
|
+
if not MYPY:
|
|
2257
|
+
class DetectorRecipeDetectorRuleRuleTypeArgsDict(TypedDict):
|
|
2258
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2259
|
+
"""
|
|
2260
|
+
The unique identifier of the detector rule type
|
|
2261
|
+
"""
|
|
2262
|
+
values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2263
|
+
"""
|
|
2264
|
+
Detector rule type value
|
|
2265
|
+
"""
|
|
2266
|
+
elif False:
|
|
2267
|
+
DetectorRecipeDetectorRuleRuleTypeArgsDict: TypeAlias = Mapping[str, Any]
|
|
2268
|
+
|
|
2269
|
+
@pulumi.input_type
|
|
2270
|
+
class DetectorRecipeDetectorRuleRuleTypeArgs:
|
|
2271
|
+
def __init__(__self__, *,
|
|
2272
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2273
|
+
values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
2274
|
+
"""
|
|
2275
|
+
:param pulumi.Input[_builtins.str] key: The unique identifier of the detector rule type
|
|
2276
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: Detector rule type value
|
|
2277
|
+
"""
|
|
2278
|
+
if key is not None:
|
|
2279
|
+
pulumi.set(__self__, "key", key)
|
|
2280
|
+
if values is not None:
|
|
2281
|
+
pulumi.set(__self__, "values", values)
|
|
2282
|
+
|
|
2283
|
+
@_builtins.property
|
|
2284
|
+
@pulumi.getter
|
|
2285
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2286
|
+
"""
|
|
2287
|
+
The unique identifier of the detector rule type
|
|
2288
|
+
"""
|
|
2289
|
+
return pulumi.get(self, "key")
|
|
2290
|
+
|
|
2291
|
+
@key.setter
|
|
2292
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2293
|
+
pulumi.set(self, "key", value)
|
|
2294
|
+
|
|
2295
|
+
@_builtins.property
|
|
2296
|
+
@pulumi.getter
|
|
2297
|
+
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2298
|
+
"""
|
|
2299
|
+
Detector rule type value
|
|
2300
|
+
"""
|
|
2301
|
+
return pulumi.get(self, "values")
|
|
2302
|
+
|
|
2303
|
+
@values.setter
|
|
2304
|
+
def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2305
|
+
pulumi.set(self, "values", value)
|
|
2306
|
+
|
|
2307
|
+
|
|
2010
2308
|
if not MYPY:
|
|
2011
2309
|
class DetectorRecipeEffectiveDetectorRuleArgsDict(TypedDict):
|
|
2012
2310
|
candidate_responder_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleCandidateResponderRuleArgsDict']]]]
|
|
@@ -2045,6 +2343,10 @@ if not MYPY:
|
|
|
2045
2343
|
"""
|
|
2046
2344
|
Data source entities mapping for the detector rule
|
|
2047
2345
|
"""
|
|
2346
|
+
is_cloneable: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2347
|
+
"""
|
|
2348
|
+
Is the rule cloneable?
|
|
2349
|
+
"""
|
|
2048
2350
|
lifecycle_details: NotRequired[pulumi.Input[_builtins.str]]
|
|
2049
2351
|
"""
|
|
2050
2352
|
A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
|
|
@@ -2061,6 +2363,10 @@ if not MYPY:
|
|
|
2061
2363
|
"""
|
|
2062
2364
|
Resource type of the configuration to which the rule is applied
|
|
2063
2365
|
"""
|
|
2366
|
+
rule_types: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleRuleTypeArgsDict']]]]
|
|
2367
|
+
"""
|
|
2368
|
+
Detector rule type
|
|
2369
|
+
"""
|
|
2064
2370
|
service_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
2065
2371
|
"""
|
|
2066
2372
|
Service type of the configuration to which the rule is applied
|
|
@@ -2091,10 +2397,12 @@ class DetectorRecipeEffectiveDetectorRuleArgs:
|
|
|
2091
2397
|
detector_rule_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2092
2398
|
display_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2093
2399
|
entities_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs']]]] = None,
|
|
2400
|
+
is_cloneable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2094
2401
|
lifecycle_details: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2095
2402
|
managed_list_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2096
2403
|
recommendation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2097
2404
|
resource_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2405
|
+
rule_types: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleRuleTypeArgs']]]] = None,
|
|
2098
2406
|
service_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2099
2407
|
state: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2100
2408
|
time_created: Optional[pulumi.Input[_builtins.str]] = None,
|
|
@@ -2112,10 +2420,12 @@ class DetectorRecipeEffectiveDetectorRuleArgs:
|
|
|
2112
2420
|
|
|
2113
2421
|
Avoid entering confidential information.
|
|
2114
2422
|
:param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs']]] entities_mappings: Data source entities mapping for the detector rule
|
|
2423
|
+
:param pulumi.Input[_builtins.bool] is_cloneable: Is the rule cloneable?
|
|
2115
2424
|
:param pulumi.Input[_builtins.str] lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
|
|
2116
2425
|
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] managed_list_types: List of managed list types related to this rule
|
|
2117
2426
|
:param pulumi.Input[_builtins.str] recommendation: Recommendation for DetectorRecipeDetectorRule resource
|
|
2118
2427
|
:param pulumi.Input[_builtins.str] resource_type: Resource type of the configuration to which the rule is applied
|
|
2428
|
+
:param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleRuleTypeArgs']]] rule_types: Detector rule type
|
|
2119
2429
|
:param pulumi.Input[_builtins.str] service_type: Service type of the configuration to which the rule is applied
|
|
2120
2430
|
:param pulumi.Input[_builtins.str] state: The current lifecycle state of the resource
|
|
2121
2431
|
:param pulumi.Input[_builtins.str] time_created: The date and time the detector recipe was created Format defined by RFC3339.
|
|
@@ -2137,6 +2447,8 @@ class DetectorRecipeEffectiveDetectorRuleArgs:
|
|
|
2137
2447
|
pulumi.set(__self__, "display_name", display_name)
|
|
2138
2448
|
if entities_mappings is not None:
|
|
2139
2449
|
pulumi.set(__self__, "entities_mappings", entities_mappings)
|
|
2450
|
+
if is_cloneable is not None:
|
|
2451
|
+
pulumi.set(__self__, "is_cloneable", is_cloneable)
|
|
2140
2452
|
if lifecycle_details is not None:
|
|
2141
2453
|
pulumi.set(__self__, "lifecycle_details", lifecycle_details)
|
|
2142
2454
|
if managed_list_types is not None:
|
|
@@ -2145,6 +2457,8 @@ class DetectorRecipeEffectiveDetectorRuleArgs:
|
|
|
2145
2457
|
pulumi.set(__self__, "recommendation", recommendation)
|
|
2146
2458
|
if resource_type is not None:
|
|
2147
2459
|
pulumi.set(__self__, "resource_type", resource_type)
|
|
2460
|
+
if rule_types is not None:
|
|
2461
|
+
pulumi.set(__self__, "rule_types", rule_types)
|
|
2148
2462
|
if service_type is not None:
|
|
2149
2463
|
pulumi.set(__self__, "service_type", service_type)
|
|
2150
2464
|
if state is not None:
|
|
@@ -2254,6 +2568,18 @@ class DetectorRecipeEffectiveDetectorRuleArgs:
|
|
|
2254
2568
|
def entities_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs']]]]):
|
|
2255
2569
|
pulumi.set(self, "entities_mappings", value)
|
|
2256
2570
|
|
|
2571
|
+
@_builtins.property
|
|
2572
|
+
@pulumi.getter(name="isCloneable")
|
|
2573
|
+
def is_cloneable(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2574
|
+
"""
|
|
2575
|
+
Is the rule cloneable?
|
|
2576
|
+
"""
|
|
2577
|
+
return pulumi.get(self, "is_cloneable")
|
|
2578
|
+
|
|
2579
|
+
@is_cloneable.setter
|
|
2580
|
+
def is_cloneable(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2581
|
+
pulumi.set(self, "is_cloneable", value)
|
|
2582
|
+
|
|
2257
2583
|
@_builtins.property
|
|
2258
2584
|
@pulumi.getter(name="lifecycleDetails")
|
|
2259
2585
|
def lifecycle_details(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -2302,6 +2628,18 @@ class DetectorRecipeEffectiveDetectorRuleArgs:
|
|
|
2302
2628
|
def resource_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2303
2629
|
pulumi.set(self, "resource_type", value)
|
|
2304
2630
|
|
|
2631
|
+
@_builtins.property
|
|
2632
|
+
@pulumi.getter(name="ruleTypes")
|
|
2633
|
+
def rule_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleRuleTypeArgs']]]]:
|
|
2634
|
+
"""
|
|
2635
|
+
Detector rule type
|
|
2636
|
+
"""
|
|
2637
|
+
return pulumi.get(self, "rule_types")
|
|
2638
|
+
|
|
2639
|
+
@rule_types.setter
|
|
2640
|
+
def rule_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleRuleTypeArgs']]]]):
|
|
2641
|
+
pulumi.set(self, "rule_types", value)
|
|
2642
|
+
|
|
2305
2643
|
@_builtins.property
|
|
2306
2644
|
@pulumi.getter(name="serviceType")
|
|
2307
2645
|
def service_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -2649,6 +2987,18 @@ class DetectorRecipeEffectiveDetectorRuleDetailArgs:
|
|
|
2649
2987
|
|
|
2650
2988
|
if not MYPY:
|
|
2651
2989
|
class DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgsDict(TypedDict):
|
|
2990
|
+
additional_properties: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgsDict']]]]
|
|
2991
|
+
"""
|
|
2992
|
+
Map of additional property values for configuration
|
|
2993
|
+
"""
|
|
2994
|
+
allowed_values: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgsDict']]]]
|
|
2995
|
+
"""
|
|
2996
|
+
Map of possible values for configuration
|
|
2997
|
+
"""
|
|
2998
|
+
allowed_values_data_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
2999
|
+
"""
|
|
3000
|
+
Map property Value data type
|
|
3001
|
+
"""
|
|
2652
3002
|
config_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2653
3003
|
"""
|
|
2654
3004
|
Unique identifier of the configuration
|
|
@@ -2663,7 +3013,7 @@ if not MYPY:
|
|
|
2663
3013
|
"""
|
|
2664
3014
|
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
2665
3015
|
"""
|
|
2666
|
-
|
|
3016
|
+
Detector rule type value
|
|
2667
3017
|
"""
|
|
2668
3018
|
values: NotRequired[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgsDict']]]]
|
|
2669
3019
|
"""
|
|
@@ -2675,18 +3025,30 @@ elif False:
|
|
|
2675
3025
|
@pulumi.input_type
|
|
2676
3026
|
class DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs:
|
|
2677
3027
|
def __init__(__self__, *,
|
|
3028
|
+
additional_properties: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgs']]]] = None,
|
|
3029
|
+
allowed_values: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgs']]]] = None,
|
|
3030
|
+
allowed_values_data_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2678
3031
|
config_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2679
3032
|
data_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2680
3033
|
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2681
3034
|
value: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2682
3035
|
values: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs']]]] = None):
|
|
2683
3036
|
"""
|
|
3037
|
+
:param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgs']]] additional_properties: Map of additional property values for configuration
|
|
3038
|
+
:param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgs']]] allowed_values: Map of possible values for configuration
|
|
3039
|
+
:param pulumi.Input[_builtins.str] allowed_values_data_type: Map property Value data type
|
|
2684
3040
|
:param pulumi.Input[_builtins.str] config_key: Unique identifier of the configuration
|
|
2685
3041
|
:param pulumi.Input[_builtins.str] data_type: Configuration data type
|
|
2686
3042
|
:param pulumi.Input[_builtins.str] name: Configuration name
|
|
2687
|
-
:param pulumi.Input[_builtins.str] value:
|
|
3043
|
+
:param pulumi.Input[_builtins.str] value: Detector rule type value
|
|
2688
3044
|
:param pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs']]] values: List of configuration values
|
|
2689
3045
|
"""
|
|
3046
|
+
if additional_properties is not None:
|
|
3047
|
+
pulumi.set(__self__, "additional_properties", additional_properties)
|
|
3048
|
+
if allowed_values is not None:
|
|
3049
|
+
pulumi.set(__self__, "allowed_values", allowed_values)
|
|
3050
|
+
if allowed_values_data_type is not None:
|
|
3051
|
+
pulumi.set(__self__, "allowed_values_data_type", allowed_values_data_type)
|
|
2690
3052
|
if config_key is not None:
|
|
2691
3053
|
pulumi.set(__self__, "config_key", config_key)
|
|
2692
3054
|
if data_type is not None:
|
|
@@ -2698,6 +3060,42 @@ class DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs:
|
|
|
2698
3060
|
if values is not None:
|
|
2699
3061
|
pulumi.set(__self__, "values", values)
|
|
2700
3062
|
|
|
3063
|
+
@_builtins.property
|
|
3064
|
+
@pulumi.getter(name="additionalProperties")
|
|
3065
|
+
def additional_properties(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgs']]]]:
|
|
3066
|
+
"""
|
|
3067
|
+
Map of additional property values for configuration
|
|
3068
|
+
"""
|
|
3069
|
+
return pulumi.get(self, "additional_properties")
|
|
3070
|
+
|
|
3071
|
+
@additional_properties.setter
|
|
3072
|
+
def additional_properties(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgs']]]]):
|
|
3073
|
+
pulumi.set(self, "additional_properties", value)
|
|
3074
|
+
|
|
3075
|
+
@_builtins.property
|
|
3076
|
+
@pulumi.getter(name="allowedValues")
|
|
3077
|
+
def allowed_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgs']]]]:
|
|
3078
|
+
"""
|
|
3079
|
+
Map of possible values for configuration
|
|
3080
|
+
"""
|
|
3081
|
+
return pulumi.get(self, "allowed_values")
|
|
3082
|
+
|
|
3083
|
+
@allowed_values.setter
|
|
3084
|
+
def allowed_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgs']]]]):
|
|
3085
|
+
pulumi.set(self, "allowed_values", value)
|
|
3086
|
+
|
|
3087
|
+
@_builtins.property
|
|
3088
|
+
@pulumi.getter(name="allowedValuesDataType")
|
|
3089
|
+
def allowed_values_data_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3090
|
+
"""
|
|
3091
|
+
Map property Value data type
|
|
3092
|
+
"""
|
|
3093
|
+
return pulumi.get(self, "allowed_values_data_type")
|
|
3094
|
+
|
|
3095
|
+
@allowed_values_data_type.setter
|
|
3096
|
+
def allowed_values_data_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3097
|
+
pulumi.set(self, "allowed_values_data_type", value)
|
|
3098
|
+
|
|
2701
3099
|
@_builtins.property
|
|
2702
3100
|
@pulumi.getter(name="configKey")
|
|
2703
3101
|
def config_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -2738,7 +3136,7 @@ class DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs:
|
|
|
2738
3136
|
@pulumi.getter
|
|
2739
3137
|
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2740
3138
|
"""
|
|
2741
|
-
|
|
3139
|
+
Detector rule type value
|
|
2742
3140
|
"""
|
|
2743
3141
|
return pulumi.get(self, "value")
|
|
2744
3142
|
|
|
@@ -2760,69 +3158,69 @@ class DetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs:
|
|
|
2760
3158
|
|
|
2761
3159
|
|
|
2762
3160
|
if not MYPY:
|
|
2763
|
-
class
|
|
2764
|
-
|
|
3161
|
+
class DetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgsDict(TypedDict):
|
|
3162
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2765
3163
|
"""
|
|
2766
|
-
|
|
3164
|
+
The unique identifier of the detector rule type
|
|
2767
3165
|
"""
|
|
2768
|
-
|
|
3166
|
+
property_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
2769
3167
|
"""
|
|
2770
|
-
Type
|
|
3168
|
+
Property Type
|
|
2771
3169
|
"""
|
|
2772
3170
|
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
2773
3171
|
"""
|
|
2774
|
-
|
|
3172
|
+
Detector rule type value
|
|
2775
3173
|
"""
|
|
2776
3174
|
elif False:
|
|
2777
|
-
|
|
3175
|
+
DetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgsDict: TypeAlias = Mapping[str, Any]
|
|
2778
3176
|
|
|
2779
3177
|
@pulumi.input_type
|
|
2780
|
-
class
|
|
3178
|
+
class DetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgs:
|
|
2781
3179
|
def __init__(__self__, *,
|
|
2782
|
-
|
|
2783
|
-
|
|
3180
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3181
|
+
property_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2784
3182
|
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2785
3183
|
"""
|
|
2786
|
-
:param pulumi.Input[_builtins.str]
|
|
2787
|
-
:param pulumi.Input[_builtins.str]
|
|
2788
|
-
:param pulumi.Input[_builtins.str] value:
|
|
3184
|
+
:param pulumi.Input[_builtins.str] key: The unique identifier of the detector rule type
|
|
3185
|
+
:param pulumi.Input[_builtins.str] property_type: Property Type
|
|
3186
|
+
:param pulumi.Input[_builtins.str] value: Detector rule type value
|
|
2789
3187
|
"""
|
|
2790
|
-
if
|
|
2791
|
-
pulumi.set(__self__, "
|
|
2792
|
-
if
|
|
2793
|
-
pulumi.set(__self__, "
|
|
3188
|
+
if key is not None:
|
|
3189
|
+
pulumi.set(__self__, "key", key)
|
|
3190
|
+
if property_type is not None:
|
|
3191
|
+
pulumi.set(__self__, "property_type", property_type)
|
|
2794
3192
|
if value is not None:
|
|
2795
3193
|
pulumi.set(__self__, "value", value)
|
|
2796
3194
|
|
|
2797
3195
|
@_builtins.property
|
|
2798
|
-
@pulumi.getter
|
|
2799
|
-
def
|
|
3196
|
+
@pulumi.getter
|
|
3197
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2800
3198
|
"""
|
|
2801
|
-
|
|
3199
|
+
The unique identifier of the detector rule type
|
|
2802
3200
|
"""
|
|
2803
|
-
return pulumi.get(self, "
|
|
3201
|
+
return pulumi.get(self, "key")
|
|
2804
3202
|
|
|
2805
|
-
@
|
|
2806
|
-
def
|
|
2807
|
-
pulumi.set(self, "
|
|
3203
|
+
@key.setter
|
|
3204
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3205
|
+
pulumi.set(self, "key", value)
|
|
2808
3206
|
|
|
2809
3207
|
@_builtins.property
|
|
2810
|
-
@pulumi.getter(name="
|
|
2811
|
-
def
|
|
3208
|
+
@pulumi.getter(name="propertyType")
|
|
3209
|
+
def property_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2812
3210
|
"""
|
|
2813
|
-
Type
|
|
3211
|
+
Property Type
|
|
2814
3212
|
"""
|
|
2815
|
-
return pulumi.get(self, "
|
|
3213
|
+
return pulumi.get(self, "property_type")
|
|
2816
3214
|
|
|
2817
|
-
@
|
|
2818
|
-
def
|
|
2819
|
-
pulumi.set(self, "
|
|
3215
|
+
@property_type.setter
|
|
3216
|
+
def property_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3217
|
+
pulumi.set(self, "property_type", value)
|
|
2820
3218
|
|
|
2821
3219
|
@_builtins.property
|
|
2822
3220
|
@pulumi.getter
|
|
2823
3221
|
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2824
3222
|
"""
|
|
2825
|
-
|
|
3223
|
+
Detector rule type value
|
|
2826
3224
|
"""
|
|
2827
3225
|
return pulumi.get(self, "value")
|
|
2828
3226
|
|
|
@@ -2832,60 +3230,184 @@ class DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs:
|
|
|
2832
3230
|
|
|
2833
3231
|
|
|
2834
3232
|
if not MYPY:
|
|
2835
|
-
class
|
|
2836
|
-
|
|
3233
|
+
class DetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgsDict(TypedDict):
|
|
3234
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2837
3235
|
"""
|
|
2838
|
-
|
|
2839
|
-
|
|
2840
|
-
Avoid entering confidential information.
|
|
2841
|
-
"""
|
|
2842
|
-
entity_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
2843
|
-
"""
|
|
2844
|
-
Type of entity
|
|
3236
|
+
The unique identifier of the detector rule type
|
|
2845
3237
|
"""
|
|
2846
|
-
|
|
3238
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
2847
3239
|
"""
|
|
2848
|
-
|
|
3240
|
+
Detector rule type value
|
|
2849
3241
|
"""
|
|
2850
3242
|
elif False:
|
|
2851
|
-
|
|
3243
|
+
DetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgsDict: TypeAlias = Mapping[str, Any]
|
|
2852
3244
|
|
|
2853
3245
|
@pulumi.input_type
|
|
2854
|
-
class
|
|
3246
|
+
class DetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgs:
|
|
2855
3247
|
def __init__(__self__, *,
|
|
2856
|
-
|
|
2857
|
-
|
|
2858
|
-
query_field: Optional[pulumi.Input[_builtins.str]] = None):
|
|
3248
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3249
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2859
3250
|
"""
|
|
2860
|
-
:param pulumi.Input[_builtins.str]
|
|
2861
|
-
|
|
2862
|
-
Avoid entering confidential information.
|
|
2863
|
-
:param pulumi.Input[_builtins.str] entity_type: Type of entity
|
|
2864
|
-
:param pulumi.Input[_builtins.str] query_field: The entity value mapped to a data source query
|
|
3251
|
+
:param pulumi.Input[_builtins.str] key: The unique identifier of the detector rule type
|
|
3252
|
+
:param pulumi.Input[_builtins.str] value: Detector rule type value
|
|
2865
3253
|
"""
|
|
2866
|
-
if
|
|
2867
|
-
pulumi.set(__self__, "
|
|
2868
|
-
if
|
|
2869
|
-
pulumi.set(__self__, "
|
|
2870
|
-
if query_field is not None:
|
|
2871
|
-
pulumi.set(__self__, "query_field", query_field)
|
|
3254
|
+
if key is not None:
|
|
3255
|
+
pulumi.set(__self__, "key", key)
|
|
3256
|
+
if value is not None:
|
|
3257
|
+
pulumi.set(__self__, "value", value)
|
|
2872
3258
|
|
|
2873
3259
|
@_builtins.property
|
|
2874
|
-
@pulumi.getter
|
|
2875
|
-
def
|
|
3260
|
+
@pulumi.getter
|
|
3261
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2876
3262
|
"""
|
|
2877
|
-
|
|
2878
|
-
|
|
2879
|
-
Avoid entering confidential information.
|
|
3263
|
+
The unique identifier of the detector rule type
|
|
2880
3264
|
"""
|
|
2881
|
-
return pulumi.get(self, "
|
|
3265
|
+
return pulumi.get(self, "key")
|
|
2882
3266
|
|
|
2883
|
-
@
|
|
2884
|
-
def
|
|
2885
|
-
pulumi.set(self, "
|
|
3267
|
+
@key.setter
|
|
3268
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3269
|
+
pulumi.set(self, "key", value)
|
|
2886
3270
|
|
|
2887
3271
|
@_builtins.property
|
|
2888
|
-
@pulumi.getter
|
|
3272
|
+
@pulumi.getter
|
|
3273
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3274
|
+
"""
|
|
3275
|
+
Detector rule type value
|
|
3276
|
+
"""
|
|
3277
|
+
return pulumi.get(self, "value")
|
|
3278
|
+
|
|
3279
|
+
@value.setter
|
|
3280
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3281
|
+
pulumi.set(self, "value", value)
|
|
3282
|
+
|
|
3283
|
+
|
|
3284
|
+
if not MYPY:
|
|
3285
|
+
class DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgsDict(TypedDict):
|
|
3286
|
+
list_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
3287
|
+
"""
|
|
3288
|
+
Configuration list item type (CUSTOM or MANAGED)
|
|
3289
|
+
"""
|
|
3290
|
+
managed_list_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
3291
|
+
"""
|
|
3292
|
+
Type of content in the managed list
|
|
3293
|
+
"""
|
|
3294
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
3295
|
+
"""
|
|
3296
|
+
Detector rule type value
|
|
3297
|
+
"""
|
|
3298
|
+
elif False:
|
|
3299
|
+
DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgsDict: TypeAlias = Mapping[str, Any]
|
|
3300
|
+
|
|
3301
|
+
@pulumi.input_type
|
|
3302
|
+
class DetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs:
|
|
3303
|
+
def __init__(__self__, *,
|
|
3304
|
+
list_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3305
|
+
managed_list_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3306
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
3307
|
+
"""
|
|
3308
|
+
:param pulumi.Input[_builtins.str] list_type: Configuration list item type (CUSTOM or MANAGED)
|
|
3309
|
+
:param pulumi.Input[_builtins.str] managed_list_type: Type of content in the managed list
|
|
3310
|
+
:param pulumi.Input[_builtins.str] value: Detector rule type value
|
|
3311
|
+
"""
|
|
3312
|
+
if list_type is not None:
|
|
3313
|
+
pulumi.set(__self__, "list_type", list_type)
|
|
3314
|
+
if managed_list_type is not None:
|
|
3315
|
+
pulumi.set(__self__, "managed_list_type", managed_list_type)
|
|
3316
|
+
if value is not None:
|
|
3317
|
+
pulumi.set(__self__, "value", value)
|
|
3318
|
+
|
|
3319
|
+
@_builtins.property
|
|
3320
|
+
@pulumi.getter(name="listType")
|
|
3321
|
+
def list_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3322
|
+
"""
|
|
3323
|
+
Configuration list item type (CUSTOM or MANAGED)
|
|
3324
|
+
"""
|
|
3325
|
+
return pulumi.get(self, "list_type")
|
|
3326
|
+
|
|
3327
|
+
@list_type.setter
|
|
3328
|
+
def list_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3329
|
+
pulumi.set(self, "list_type", value)
|
|
3330
|
+
|
|
3331
|
+
@_builtins.property
|
|
3332
|
+
@pulumi.getter(name="managedListType")
|
|
3333
|
+
def managed_list_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3334
|
+
"""
|
|
3335
|
+
Type of content in the managed list
|
|
3336
|
+
"""
|
|
3337
|
+
return pulumi.get(self, "managed_list_type")
|
|
3338
|
+
|
|
3339
|
+
@managed_list_type.setter
|
|
3340
|
+
def managed_list_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3341
|
+
pulumi.set(self, "managed_list_type", value)
|
|
3342
|
+
|
|
3343
|
+
@_builtins.property
|
|
3344
|
+
@pulumi.getter
|
|
3345
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3346
|
+
"""
|
|
3347
|
+
Detector rule type value
|
|
3348
|
+
"""
|
|
3349
|
+
return pulumi.get(self, "value")
|
|
3350
|
+
|
|
3351
|
+
@value.setter
|
|
3352
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3353
|
+
pulumi.set(self, "value", value)
|
|
3354
|
+
|
|
3355
|
+
|
|
3356
|
+
if not MYPY:
|
|
3357
|
+
class DetectorRecipeEffectiveDetectorRuleDetailEntitiesMappingArgsDict(TypedDict):
|
|
3358
|
+
display_name: NotRequired[pulumi.Input[_builtins.str]]
|
|
3359
|
+
"""
|
|
3360
|
+
(Updatable) Detector recipe display name.
|
|
3361
|
+
|
|
3362
|
+
Avoid entering confidential information.
|
|
3363
|
+
"""
|
|
3364
|
+
entity_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
3365
|
+
"""
|
|
3366
|
+
Type of entity
|
|
3367
|
+
"""
|
|
3368
|
+
query_field: NotRequired[pulumi.Input[_builtins.str]]
|
|
3369
|
+
"""
|
|
3370
|
+
The entity value mapped to a data source query
|
|
3371
|
+
"""
|
|
3372
|
+
elif False:
|
|
3373
|
+
DetectorRecipeEffectiveDetectorRuleDetailEntitiesMappingArgsDict: TypeAlias = Mapping[str, Any]
|
|
3374
|
+
|
|
3375
|
+
@pulumi.input_type
|
|
3376
|
+
class DetectorRecipeEffectiveDetectorRuleDetailEntitiesMappingArgs:
|
|
3377
|
+
def __init__(__self__, *,
|
|
3378
|
+
display_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3379
|
+
entity_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3380
|
+
query_field: Optional[pulumi.Input[_builtins.str]] = None):
|
|
3381
|
+
"""
|
|
3382
|
+
:param pulumi.Input[_builtins.str] display_name: (Updatable) Detector recipe display name.
|
|
3383
|
+
|
|
3384
|
+
Avoid entering confidential information.
|
|
3385
|
+
:param pulumi.Input[_builtins.str] entity_type: Type of entity
|
|
3386
|
+
:param pulumi.Input[_builtins.str] query_field: The entity value mapped to a data source query
|
|
3387
|
+
"""
|
|
3388
|
+
if display_name is not None:
|
|
3389
|
+
pulumi.set(__self__, "display_name", display_name)
|
|
3390
|
+
if entity_type is not None:
|
|
3391
|
+
pulumi.set(__self__, "entity_type", entity_type)
|
|
3392
|
+
if query_field is not None:
|
|
3393
|
+
pulumi.set(__self__, "query_field", query_field)
|
|
3394
|
+
|
|
3395
|
+
@_builtins.property
|
|
3396
|
+
@pulumi.getter(name="displayName")
|
|
3397
|
+
def display_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3398
|
+
"""
|
|
3399
|
+
(Updatable) Detector recipe display name.
|
|
3400
|
+
|
|
3401
|
+
Avoid entering confidential information.
|
|
3402
|
+
"""
|
|
3403
|
+
return pulumi.get(self, "display_name")
|
|
3404
|
+
|
|
3405
|
+
@display_name.setter
|
|
3406
|
+
def display_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3407
|
+
pulumi.set(self, "display_name", value)
|
|
3408
|
+
|
|
3409
|
+
@_builtins.property
|
|
3410
|
+
@pulumi.getter(name="entityType")
|
|
2889
3411
|
def entity_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2890
3412
|
"""
|
|
2891
3413
|
Type of entity
|
|
@@ -2987,6 +3509,58 @@ class DetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs:
|
|
|
2987
3509
|
pulumi.set(self, "query_field", value)
|
|
2988
3510
|
|
|
2989
3511
|
|
|
3512
|
+
if not MYPY:
|
|
3513
|
+
class DetectorRecipeEffectiveDetectorRuleRuleTypeArgsDict(TypedDict):
|
|
3514
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
3515
|
+
"""
|
|
3516
|
+
The unique identifier of the detector rule type
|
|
3517
|
+
"""
|
|
3518
|
+
values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
3519
|
+
"""
|
|
3520
|
+
Detector rule type value
|
|
3521
|
+
"""
|
|
3522
|
+
elif False:
|
|
3523
|
+
DetectorRecipeEffectiveDetectorRuleRuleTypeArgsDict: TypeAlias = Mapping[str, Any]
|
|
3524
|
+
|
|
3525
|
+
@pulumi.input_type
|
|
3526
|
+
class DetectorRecipeEffectiveDetectorRuleRuleTypeArgs:
|
|
3527
|
+
def __init__(__self__, *,
|
|
3528
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3529
|
+
values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
3530
|
+
"""
|
|
3531
|
+
:param pulumi.Input[_builtins.str] key: The unique identifier of the detector rule type
|
|
3532
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: Detector rule type value
|
|
3533
|
+
"""
|
|
3534
|
+
if key is not None:
|
|
3535
|
+
pulumi.set(__self__, "key", key)
|
|
3536
|
+
if values is not None:
|
|
3537
|
+
pulumi.set(__self__, "values", values)
|
|
3538
|
+
|
|
3539
|
+
@_builtins.property
|
|
3540
|
+
@pulumi.getter
|
|
3541
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3542
|
+
"""
|
|
3543
|
+
The unique identifier of the detector rule type
|
|
3544
|
+
"""
|
|
3545
|
+
return pulumi.get(self, "key")
|
|
3546
|
+
|
|
3547
|
+
@key.setter
|
|
3548
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3549
|
+
pulumi.set(self, "key", value)
|
|
3550
|
+
|
|
3551
|
+
@_builtins.property
|
|
3552
|
+
@pulumi.getter
|
|
3553
|
+
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
3554
|
+
"""
|
|
3555
|
+
Detector rule type value
|
|
3556
|
+
"""
|
|
3557
|
+
return pulumi.get(self, "values")
|
|
3558
|
+
|
|
3559
|
+
@values.setter
|
|
3560
|
+
def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
3561
|
+
pulumi.set(self, "values", value)
|
|
3562
|
+
|
|
3563
|
+
|
|
2990
3564
|
if not MYPY:
|
|
2991
3565
|
class ResponderRecipeEffectiveResponderRuleArgsDict(TypedDict):
|
|
2992
3566
|
compartment_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
@@ -4539,6 +5113,10 @@ if not MYPY:
|
|
|
4539
5113
|
"""
|
|
4540
5114
|
Data source entities mapping for a detector rule
|
|
4541
5115
|
"""
|
|
5116
|
+
is_cloneable: NotRequired[pulumi.Input[_builtins.bool]]
|
|
5117
|
+
"""
|
|
5118
|
+
Is the rule cloneable?
|
|
5119
|
+
"""
|
|
4542
5120
|
lifecycle_details: NotRequired[pulumi.Input[_builtins.str]]
|
|
4543
5121
|
"""
|
|
4544
5122
|
A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
|
|
@@ -4555,6 +5133,10 @@ if not MYPY:
|
|
|
4555
5133
|
"""
|
|
4556
5134
|
The type of resource which is monitored by the detector rule. For example, Instance, Database, VCN, Policy. To find the resource type for a particular rule, see [Detector Recipe Reference] (/iaas/cloud-guard/using/detect-recipes.htm#detect-recipes-reference).
|
|
4557
5135
|
"""
|
|
5136
|
+
rule_types: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleRuleTypeArgsDict']]]]
|
|
5137
|
+
"""
|
|
5138
|
+
Rule category type
|
|
5139
|
+
"""
|
|
4558
5140
|
service_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
4559
5141
|
"""
|
|
4560
5142
|
Service type of the configuration to which the rule is applied
|
|
@@ -4584,10 +5166,12 @@ class TargetTargetDetectorRecipeDetectorRuleArgs:
|
|
|
4584
5166
|
detector: Optional[pulumi.Input[_builtins.str]] = None,
|
|
4585
5167
|
display_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
4586
5168
|
entities_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgs']]]] = None,
|
|
5169
|
+
is_cloneable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
4587
5170
|
lifecycle_details: Optional[pulumi.Input[_builtins.str]] = None,
|
|
4588
5171
|
managed_list_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
4589
5172
|
recommendation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
4590
5173
|
resource_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5174
|
+
rule_types: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleRuleTypeArgs']]]] = None,
|
|
4591
5175
|
service_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
4592
5176
|
state: Optional[pulumi.Input[_builtins.str]] = None,
|
|
4593
5177
|
time_created: Optional[pulumi.Input[_builtins.str]] = None,
|
|
@@ -4604,10 +5188,12 @@ class TargetTargetDetectorRecipeDetectorRuleArgs:
|
|
|
4604
5188
|
|
|
4605
5189
|
Avoid entering confidential information.
|
|
4606
5190
|
:param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgs']]] entities_mappings: Data source entities mapping for a detector rule
|
|
5191
|
+
:param pulumi.Input[_builtins.bool] is_cloneable: Is the rule cloneable?
|
|
4607
5192
|
:param pulumi.Input[_builtins.str] lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
|
|
4608
5193
|
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] managed_list_types: List of managed list types related to this rule
|
|
4609
5194
|
:param pulumi.Input[_builtins.str] recommendation: Recommendation for TargetDetectorRecipeDetectorRule resource
|
|
4610
5195
|
:param pulumi.Input[_builtins.str] resource_type: The type of resource which is monitored by the detector rule. For example, Instance, Database, VCN, Policy. To find the resource type for a particular rule, see [Detector Recipe Reference] (/iaas/cloud-guard/using/detect-recipes.htm#detect-recipes-reference).
|
|
5196
|
+
:param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleRuleTypeArgs']]] rule_types: Rule category type
|
|
4611
5197
|
:param pulumi.Input[_builtins.str] service_type: Service type of the configuration to which the rule is applied
|
|
4612
5198
|
:param pulumi.Input[_builtins.str] state: (Updatable) The enablement state of the detector rule
|
|
4613
5199
|
:param pulumi.Input[_builtins.str] time_created: The date and time the target was created. Format defined by RFC3339.
|
|
@@ -4625,6 +5211,8 @@ class TargetTargetDetectorRecipeDetectorRuleArgs:
|
|
|
4625
5211
|
pulumi.set(__self__, "display_name", display_name)
|
|
4626
5212
|
if entities_mappings is not None:
|
|
4627
5213
|
pulumi.set(__self__, "entities_mappings", entities_mappings)
|
|
5214
|
+
if is_cloneable is not None:
|
|
5215
|
+
pulumi.set(__self__, "is_cloneable", is_cloneable)
|
|
4628
5216
|
if lifecycle_details is not None:
|
|
4629
5217
|
pulumi.set(__self__, "lifecycle_details", lifecycle_details)
|
|
4630
5218
|
if managed_list_types is not None:
|
|
@@ -4633,6 +5221,8 @@ class TargetTargetDetectorRecipeDetectorRuleArgs:
|
|
|
4633
5221
|
pulumi.set(__self__, "recommendation", recommendation)
|
|
4634
5222
|
if resource_type is not None:
|
|
4635
5223
|
pulumi.set(__self__, "resource_type", resource_type)
|
|
5224
|
+
if rule_types is not None:
|
|
5225
|
+
pulumi.set(__self__, "rule_types", rule_types)
|
|
4636
5226
|
if service_type is not None:
|
|
4637
5227
|
pulumi.set(__self__, "service_type", service_type)
|
|
4638
5228
|
if state is not None:
|
|
@@ -4730,6 +5320,18 @@ class TargetTargetDetectorRecipeDetectorRuleArgs:
|
|
|
4730
5320
|
def entities_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgs']]]]):
|
|
4731
5321
|
pulumi.set(self, "entities_mappings", value)
|
|
4732
5322
|
|
|
5323
|
+
@_builtins.property
|
|
5324
|
+
@pulumi.getter(name="isCloneable")
|
|
5325
|
+
def is_cloneable(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
5326
|
+
"""
|
|
5327
|
+
Is the rule cloneable?
|
|
5328
|
+
"""
|
|
5329
|
+
return pulumi.get(self, "is_cloneable")
|
|
5330
|
+
|
|
5331
|
+
@is_cloneable.setter
|
|
5332
|
+
def is_cloneable(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
5333
|
+
pulumi.set(self, "is_cloneable", value)
|
|
5334
|
+
|
|
4733
5335
|
@_builtins.property
|
|
4734
5336
|
@pulumi.getter(name="lifecycleDetails")
|
|
4735
5337
|
def lifecycle_details(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -4778,6 +5380,18 @@ class TargetTargetDetectorRecipeDetectorRuleArgs:
|
|
|
4778
5380
|
def resource_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
4779
5381
|
pulumi.set(self, "resource_type", value)
|
|
4780
5382
|
|
|
5383
|
+
@_builtins.property
|
|
5384
|
+
@pulumi.getter(name="ruleTypes")
|
|
5385
|
+
def rule_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleRuleTypeArgs']]]]:
|
|
5386
|
+
"""
|
|
5387
|
+
Rule category type
|
|
5388
|
+
"""
|
|
5389
|
+
return pulumi.get(self, "rule_types")
|
|
5390
|
+
|
|
5391
|
+
@rule_types.setter
|
|
5392
|
+
def rule_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleRuleTypeArgs']]]]):
|
|
5393
|
+
pulumi.set(self, "rule_types", value)
|
|
5394
|
+
|
|
4781
5395
|
@_builtins.property
|
|
4782
5396
|
@pulumi.getter(name="serviceType")
|
|
4783
5397
|
def service_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -5011,6 +5625,18 @@ class TargetTargetDetectorRecipeDetectorRuleDetailsConditionGroupArgs:
|
|
|
5011
5625
|
|
|
5012
5626
|
if not MYPY:
|
|
5013
5627
|
class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgsDict(TypedDict):
|
|
5628
|
+
additional_properties: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgsDict']]]]
|
|
5629
|
+
"""
|
|
5630
|
+
Map of additional property values for configuration
|
|
5631
|
+
"""
|
|
5632
|
+
allowed_values: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgsDict']]]]
|
|
5633
|
+
"""
|
|
5634
|
+
Map of possible values for configuration
|
|
5635
|
+
"""
|
|
5636
|
+
allowed_values_data_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
5637
|
+
"""
|
|
5638
|
+
Map property Value data type
|
|
5639
|
+
"""
|
|
5014
5640
|
config_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
5015
5641
|
"""
|
|
5016
5642
|
Unique identifier of the configuration
|
|
@@ -5037,18 +5663,30 @@ elif False:
|
|
|
5037
5663
|
@pulumi.input_type
|
|
5038
5664
|
class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgs:
|
|
5039
5665
|
def __init__(__self__, *,
|
|
5666
|
+
additional_properties: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgs']]]] = None,
|
|
5667
|
+
allowed_values: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgs']]]] = None,
|
|
5668
|
+
allowed_values_data_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5040
5669
|
config_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5041
5670
|
data_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5042
5671
|
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5043
5672
|
value: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5044
5673
|
values: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgs']]]] = None):
|
|
5045
5674
|
"""
|
|
5675
|
+
:param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgs']]] additional_properties: Map of additional property values for configuration
|
|
5676
|
+
:param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgs']]] allowed_values: Map of possible values for configuration
|
|
5677
|
+
:param pulumi.Input[_builtins.str] allowed_values_data_type: Map property Value data type
|
|
5046
5678
|
:param pulumi.Input[_builtins.str] config_key: Unique identifier of the configuration
|
|
5047
5679
|
:param pulumi.Input[_builtins.str] data_type: Configuration data type
|
|
5048
5680
|
:param pulumi.Input[_builtins.str] name: Configuration name
|
|
5049
5681
|
:param pulumi.Input[_builtins.str] value: Configuration value
|
|
5050
5682
|
:param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgs']]] values: List of configuration values
|
|
5051
5683
|
"""
|
|
5684
|
+
if additional_properties is not None:
|
|
5685
|
+
pulumi.set(__self__, "additional_properties", additional_properties)
|
|
5686
|
+
if allowed_values is not None:
|
|
5687
|
+
pulumi.set(__self__, "allowed_values", allowed_values)
|
|
5688
|
+
if allowed_values_data_type is not None:
|
|
5689
|
+
pulumi.set(__self__, "allowed_values_data_type", allowed_values_data_type)
|
|
5052
5690
|
if config_key is not None:
|
|
5053
5691
|
pulumi.set(__self__, "config_key", config_key)
|
|
5054
5692
|
if data_type is not None:
|
|
@@ -5060,6 +5698,42 @@ class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgs:
|
|
|
5060
5698
|
if values is not None:
|
|
5061
5699
|
pulumi.set(__self__, "values", values)
|
|
5062
5700
|
|
|
5701
|
+
@_builtins.property
|
|
5702
|
+
@pulumi.getter(name="additionalProperties")
|
|
5703
|
+
def additional_properties(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgs']]]]:
|
|
5704
|
+
"""
|
|
5705
|
+
Map of additional property values for configuration
|
|
5706
|
+
"""
|
|
5707
|
+
return pulumi.get(self, "additional_properties")
|
|
5708
|
+
|
|
5709
|
+
@additional_properties.setter
|
|
5710
|
+
def additional_properties(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgs']]]]):
|
|
5711
|
+
pulumi.set(self, "additional_properties", value)
|
|
5712
|
+
|
|
5713
|
+
@_builtins.property
|
|
5714
|
+
@pulumi.getter(name="allowedValues")
|
|
5715
|
+
def allowed_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgs']]]]:
|
|
5716
|
+
"""
|
|
5717
|
+
Map of possible values for configuration
|
|
5718
|
+
"""
|
|
5719
|
+
return pulumi.get(self, "allowed_values")
|
|
5720
|
+
|
|
5721
|
+
@allowed_values.setter
|
|
5722
|
+
def allowed_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgs']]]]):
|
|
5723
|
+
pulumi.set(self, "allowed_values", value)
|
|
5724
|
+
|
|
5725
|
+
@_builtins.property
|
|
5726
|
+
@pulumi.getter(name="allowedValuesDataType")
|
|
5727
|
+
def allowed_values_data_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
5728
|
+
"""
|
|
5729
|
+
Map property Value data type
|
|
5730
|
+
"""
|
|
5731
|
+
return pulumi.get(self, "allowed_values_data_type")
|
|
5732
|
+
|
|
5733
|
+
@allowed_values_data_type.setter
|
|
5734
|
+
def allowed_values_data_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
5735
|
+
pulumi.set(self, "allowed_values_data_type", value)
|
|
5736
|
+
|
|
5063
5737
|
@_builtins.property
|
|
5064
5738
|
@pulumi.getter(name="configKey")
|
|
5065
5739
|
def config_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -5121,6 +5795,130 @@ class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationArgs:
|
|
|
5121
5795
|
pulumi.set(self, "values", value)
|
|
5122
5796
|
|
|
5123
5797
|
|
|
5798
|
+
if not MYPY:
|
|
5799
|
+
class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgsDict(TypedDict):
|
|
5800
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
5801
|
+
"""
|
|
5802
|
+
The unique identifier of the detector rule type
|
|
5803
|
+
"""
|
|
5804
|
+
property_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
5805
|
+
"""
|
|
5806
|
+
Property Type
|
|
5807
|
+
"""
|
|
5808
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
5809
|
+
"""
|
|
5810
|
+
Configuration value
|
|
5811
|
+
"""
|
|
5812
|
+
elif False:
|
|
5813
|
+
TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgsDict: TypeAlias = Mapping[str, Any]
|
|
5814
|
+
|
|
5815
|
+
@pulumi.input_type
|
|
5816
|
+
class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAdditionalPropertyArgs:
|
|
5817
|
+
def __init__(__self__, *,
|
|
5818
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5819
|
+
property_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5820
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
5821
|
+
"""
|
|
5822
|
+
:param pulumi.Input[_builtins.str] key: The unique identifier of the detector rule type
|
|
5823
|
+
:param pulumi.Input[_builtins.str] property_type: Property Type
|
|
5824
|
+
:param pulumi.Input[_builtins.str] value: Configuration value
|
|
5825
|
+
"""
|
|
5826
|
+
if key is not None:
|
|
5827
|
+
pulumi.set(__self__, "key", key)
|
|
5828
|
+
if property_type is not None:
|
|
5829
|
+
pulumi.set(__self__, "property_type", property_type)
|
|
5830
|
+
if value is not None:
|
|
5831
|
+
pulumi.set(__self__, "value", value)
|
|
5832
|
+
|
|
5833
|
+
@_builtins.property
|
|
5834
|
+
@pulumi.getter
|
|
5835
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
5836
|
+
"""
|
|
5837
|
+
The unique identifier of the detector rule type
|
|
5838
|
+
"""
|
|
5839
|
+
return pulumi.get(self, "key")
|
|
5840
|
+
|
|
5841
|
+
@key.setter
|
|
5842
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
5843
|
+
pulumi.set(self, "key", value)
|
|
5844
|
+
|
|
5845
|
+
@_builtins.property
|
|
5846
|
+
@pulumi.getter(name="propertyType")
|
|
5847
|
+
def property_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
5848
|
+
"""
|
|
5849
|
+
Property Type
|
|
5850
|
+
"""
|
|
5851
|
+
return pulumi.get(self, "property_type")
|
|
5852
|
+
|
|
5853
|
+
@property_type.setter
|
|
5854
|
+
def property_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
5855
|
+
pulumi.set(self, "property_type", value)
|
|
5856
|
+
|
|
5857
|
+
@_builtins.property
|
|
5858
|
+
@pulumi.getter
|
|
5859
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
5860
|
+
"""
|
|
5861
|
+
Configuration value
|
|
5862
|
+
"""
|
|
5863
|
+
return pulumi.get(self, "value")
|
|
5864
|
+
|
|
5865
|
+
@value.setter
|
|
5866
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
5867
|
+
pulumi.set(self, "value", value)
|
|
5868
|
+
|
|
5869
|
+
|
|
5870
|
+
if not MYPY:
|
|
5871
|
+
class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgsDict(TypedDict):
|
|
5872
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
5873
|
+
"""
|
|
5874
|
+
The unique identifier of the detector rule type
|
|
5875
|
+
"""
|
|
5876
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
5877
|
+
"""
|
|
5878
|
+
Configuration value
|
|
5879
|
+
"""
|
|
5880
|
+
elif False:
|
|
5881
|
+
TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgsDict: TypeAlias = Mapping[str, Any]
|
|
5882
|
+
|
|
5883
|
+
@pulumi.input_type
|
|
5884
|
+
class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationAllowedValueArgs:
|
|
5885
|
+
def __init__(__self__, *,
|
|
5886
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5887
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
5888
|
+
"""
|
|
5889
|
+
:param pulumi.Input[_builtins.str] key: The unique identifier of the detector rule type
|
|
5890
|
+
:param pulumi.Input[_builtins.str] value: Configuration value
|
|
5891
|
+
"""
|
|
5892
|
+
if key is not None:
|
|
5893
|
+
pulumi.set(__self__, "key", key)
|
|
5894
|
+
if value is not None:
|
|
5895
|
+
pulumi.set(__self__, "value", value)
|
|
5896
|
+
|
|
5897
|
+
@_builtins.property
|
|
5898
|
+
@pulumi.getter
|
|
5899
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
5900
|
+
"""
|
|
5901
|
+
The unique identifier of the detector rule type
|
|
5902
|
+
"""
|
|
5903
|
+
return pulumi.get(self, "key")
|
|
5904
|
+
|
|
5905
|
+
@key.setter
|
|
5906
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
5907
|
+
pulumi.set(self, "key", value)
|
|
5908
|
+
|
|
5909
|
+
@_builtins.property
|
|
5910
|
+
@pulumi.getter
|
|
5911
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
5912
|
+
"""
|
|
5913
|
+
Configuration value
|
|
5914
|
+
"""
|
|
5915
|
+
return pulumi.get(self, "value")
|
|
5916
|
+
|
|
5917
|
+
@value.setter
|
|
5918
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
5919
|
+
pulumi.set(self, "value", value)
|
|
5920
|
+
|
|
5921
|
+
|
|
5124
5922
|
if not MYPY:
|
|
5125
5923
|
class TargetTargetDetectorRecipeDetectorRuleDetailsConfigurationValueArgsDict(TypedDict):
|
|
5126
5924
|
list_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
@@ -5271,6 +6069,58 @@ class TargetTargetDetectorRecipeDetectorRuleEntitiesMappingArgs:
|
|
|
5271
6069
|
pulumi.set(self, "query_field", value)
|
|
5272
6070
|
|
|
5273
6071
|
|
|
6072
|
+
if not MYPY:
|
|
6073
|
+
class TargetTargetDetectorRecipeDetectorRuleRuleTypeArgsDict(TypedDict):
|
|
6074
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
6075
|
+
"""
|
|
6076
|
+
The unique identifier of the detector rule type
|
|
6077
|
+
"""
|
|
6078
|
+
values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
6079
|
+
"""
|
|
6080
|
+
Configuration value
|
|
6081
|
+
"""
|
|
6082
|
+
elif False:
|
|
6083
|
+
TargetTargetDetectorRecipeDetectorRuleRuleTypeArgsDict: TypeAlias = Mapping[str, Any]
|
|
6084
|
+
|
|
6085
|
+
@pulumi.input_type
|
|
6086
|
+
class TargetTargetDetectorRecipeDetectorRuleRuleTypeArgs:
|
|
6087
|
+
def __init__(__self__, *,
|
|
6088
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
6089
|
+
values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
6090
|
+
"""
|
|
6091
|
+
:param pulumi.Input[_builtins.str] key: The unique identifier of the detector rule type
|
|
6092
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: Configuration value
|
|
6093
|
+
"""
|
|
6094
|
+
if key is not None:
|
|
6095
|
+
pulumi.set(__self__, "key", key)
|
|
6096
|
+
if values is not None:
|
|
6097
|
+
pulumi.set(__self__, "values", values)
|
|
6098
|
+
|
|
6099
|
+
@_builtins.property
|
|
6100
|
+
@pulumi.getter
|
|
6101
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
6102
|
+
"""
|
|
6103
|
+
The unique identifier of the detector rule type
|
|
6104
|
+
"""
|
|
6105
|
+
return pulumi.get(self, "key")
|
|
6106
|
+
|
|
6107
|
+
@key.setter
|
|
6108
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
6109
|
+
pulumi.set(self, "key", value)
|
|
6110
|
+
|
|
6111
|
+
@_builtins.property
|
|
6112
|
+
@pulumi.getter
|
|
6113
|
+
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
6114
|
+
"""
|
|
6115
|
+
Configuration value
|
|
6116
|
+
"""
|
|
6117
|
+
return pulumi.get(self, "values")
|
|
6118
|
+
|
|
6119
|
+
@values.setter
|
|
6120
|
+
def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
6121
|
+
pulumi.set(self, "values", value)
|
|
6122
|
+
|
|
6123
|
+
|
|
5274
6124
|
if not MYPY:
|
|
5275
6125
|
class TargetTargetDetectorRecipeEffectiveDetectorRuleArgsDict(TypedDict):
|
|
5276
6126
|
data_source_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
@@ -5305,6 +6155,10 @@ if not MYPY:
|
|
|
5305
6155
|
"""
|
|
5306
6156
|
Data source entities mapping for a detector rule
|
|
5307
6157
|
"""
|
|
6158
|
+
is_cloneable: NotRequired[pulumi.Input[_builtins.bool]]
|
|
6159
|
+
"""
|
|
6160
|
+
Is the rule cloneable?
|
|
6161
|
+
"""
|
|
5308
6162
|
lifecycle_details: NotRequired[pulumi.Input[_builtins.str]]
|
|
5309
6163
|
"""
|
|
5310
6164
|
A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
|
|
@@ -5321,6 +6175,10 @@ if not MYPY:
|
|
|
5321
6175
|
"""
|
|
5322
6176
|
The type of resource which is monitored by the detector rule. For example, Instance, Database, VCN, Policy. To find the resource type for a particular rule, see [Detector Recipe Reference] (/iaas/cloud-guard/using/detect-recipes.htm#detect-recipes-reference).
|
|
5323
6177
|
"""
|
|
6178
|
+
rule_types: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleRuleTypeArgsDict']]]]
|
|
6179
|
+
"""
|
|
6180
|
+
Rule category type
|
|
6181
|
+
"""
|
|
5324
6182
|
service_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
5325
6183
|
"""
|
|
5326
6184
|
Service type of the configuration to which the rule is applied
|
|
@@ -5350,10 +6208,12 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleArgs:
|
|
|
5350
6208
|
detector_rule_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5351
6209
|
display_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5352
6210
|
entities_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs']]]] = None,
|
|
6211
|
+
is_cloneable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
5353
6212
|
lifecycle_details: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5354
6213
|
managed_list_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
5355
6214
|
recommendation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5356
6215
|
resource_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
6216
|
+
rule_types: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleRuleTypeArgs']]]] = None,
|
|
5357
6217
|
service_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5358
6218
|
state: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5359
6219
|
time_created: Optional[pulumi.Input[_builtins.str]] = None,
|
|
@@ -5370,10 +6230,12 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleArgs:
|
|
|
5370
6230
|
|
|
5371
6231
|
Avoid entering confidential information.
|
|
5372
6232
|
:param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs']]] entities_mappings: Data source entities mapping for a detector rule
|
|
6233
|
+
:param pulumi.Input[_builtins.bool] is_cloneable: Is the rule cloneable?
|
|
5373
6234
|
:param pulumi.Input[_builtins.str] lifecycle_details: A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in Failed state.
|
|
5374
6235
|
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] managed_list_types: List of managed list types related to this rule
|
|
5375
6236
|
:param pulumi.Input[_builtins.str] recommendation: Recommendation for TargetDetectorRecipeDetectorRule resource
|
|
5376
6237
|
:param pulumi.Input[_builtins.str] resource_type: The type of resource which is monitored by the detector rule. For example, Instance, Database, VCN, Policy. To find the resource type for a particular rule, see [Detector Recipe Reference] (/iaas/cloud-guard/using/detect-recipes.htm#detect-recipes-reference).
|
|
6238
|
+
:param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleRuleTypeArgs']]] rule_types: Rule category type
|
|
5377
6239
|
:param pulumi.Input[_builtins.str] service_type: Service type of the configuration to which the rule is applied
|
|
5378
6240
|
:param pulumi.Input[_builtins.str] state: (Updatable) The enablement state of the detector rule
|
|
5379
6241
|
:param pulumi.Input[_builtins.str] time_created: The date and time the target was created. Format defined by RFC3339.
|
|
@@ -5393,6 +6255,8 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleArgs:
|
|
|
5393
6255
|
pulumi.set(__self__, "display_name", display_name)
|
|
5394
6256
|
if entities_mappings is not None:
|
|
5395
6257
|
pulumi.set(__self__, "entities_mappings", entities_mappings)
|
|
6258
|
+
if is_cloneable is not None:
|
|
6259
|
+
pulumi.set(__self__, "is_cloneable", is_cloneable)
|
|
5396
6260
|
if lifecycle_details is not None:
|
|
5397
6261
|
pulumi.set(__self__, "lifecycle_details", lifecycle_details)
|
|
5398
6262
|
if managed_list_types is not None:
|
|
@@ -5401,6 +6265,8 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleArgs:
|
|
|
5401
6265
|
pulumi.set(__self__, "recommendation", recommendation)
|
|
5402
6266
|
if resource_type is not None:
|
|
5403
6267
|
pulumi.set(__self__, "resource_type", resource_type)
|
|
6268
|
+
if rule_types is not None:
|
|
6269
|
+
pulumi.set(__self__, "rule_types", rule_types)
|
|
5404
6270
|
if service_type is not None:
|
|
5405
6271
|
pulumi.set(__self__, "service_type", service_type)
|
|
5406
6272
|
if state is not None:
|
|
@@ -5498,6 +6364,18 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleArgs:
|
|
|
5498
6364
|
def entities_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs']]]]):
|
|
5499
6365
|
pulumi.set(self, "entities_mappings", value)
|
|
5500
6366
|
|
|
6367
|
+
@_builtins.property
|
|
6368
|
+
@pulumi.getter(name="isCloneable")
|
|
6369
|
+
def is_cloneable(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
6370
|
+
"""
|
|
6371
|
+
Is the rule cloneable?
|
|
6372
|
+
"""
|
|
6373
|
+
return pulumi.get(self, "is_cloneable")
|
|
6374
|
+
|
|
6375
|
+
@is_cloneable.setter
|
|
6376
|
+
def is_cloneable(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
6377
|
+
pulumi.set(self, "is_cloneable", value)
|
|
6378
|
+
|
|
5501
6379
|
@_builtins.property
|
|
5502
6380
|
@pulumi.getter(name="lifecycleDetails")
|
|
5503
6381
|
def lifecycle_details(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -5546,6 +6424,18 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleArgs:
|
|
|
5546
6424
|
def resource_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
5547
6425
|
pulumi.set(self, "resource_type", value)
|
|
5548
6426
|
|
|
6427
|
+
@_builtins.property
|
|
6428
|
+
@pulumi.getter(name="ruleTypes")
|
|
6429
|
+
def rule_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleRuleTypeArgs']]]]:
|
|
6430
|
+
"""
|
|
6431
|
+
Rule category type
|
|
6432
|
+
"""
|
|
6433
|
+
return pulumi.get(self, "rule_types")
|
|
6434
|
+
|
|
6435
|
+
@rule_types.setter
|
|
6436
|
+
def rule_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleRuleTypeArgs']]]]):
|
|
6437
|
+
pulumi.set(self, "rule_types", value)
|
|
6438
|
+
|
|
5549
6439
|
@_builtins.property
|
|
5550
6440
|
@pulumi.getter(name="serviceType")
|
|
5551
6441
|
def service_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -5781,6 +6671,18 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConditionGroupArgs:
|
|
|
5781
6671
|
|
|
5782
6672
|
if not MYPY:
|
|
5783
6673
|
class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgsDict(TypedDict):
|
|
6674
|
+
additional_properties: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgsDict']]]]
|
|
6675
|
+
"""
|
|
6676
|
+
Map of additional property values for configuration
|
|
6677
|
+
"""
|
|
6678
|
+
allowed_values: NotRequired[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgsDict']]]]
|
|
6679
|
+
"""
|
|
6680
|
+
Map of possible values for configuration
|
|
6681
|
+
"""
|
|
6682
|
+
allowed_values_data_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
6683
|
+
"""
|
|
6684
|
+
Map property Value data type
|
|
6685
|
+
"""
|
|
5784
6686
|
config_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
5785
6687
|
"""
|
|
5786
6688
|
Unique identifier of the configuration
|
|
@@ -5807,18 +6709,30 @@ elif False:
|
|
|
5807
6709
|
@pulumi.input_type
|
|
5808
6710
|
class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs:
|
|
5809
6711
|
def __init__(__self__, *,
|
|
6712
|
+
additional_properties: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgs']]]] = None,
|
|
6713
|
+
allowed_values: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgs']]]] = None,
|
|
6714
|
+
allowed_values_data_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5810
6715
|
config_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5811
6716
|
data_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5812
6717
|
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5813
6718
|
value: Optional[pulumi.Input[_builtins.str]] = None,
|
|
5814
6719
|
values: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs']]]] = None):
|
|
5815
6720
|
"""
|
|
6721
|
+
:param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgs']]] additional_properties: Map of additional property values for configuration
|
|
6722
|
+
:param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgs']]] allowed_values: Map of possible values for configuration
|
|
6723
|
+
:param pulumi.Input[_builtins.str] allowed_values_data_type: Map property Value data type
|
|
5816
6724
|
:param pulumi.Input[_builtins.str] config_key: Unique identifier of the configuration
|
|
5817
6725
|
:param pulumi.Input[_builtins.str] data_type: Configuration data type
|
|
5818
6726
|
:param pulumi.Input[_builtins.str] name: Configuration name
|
|
5819
6727
|
:param pulumi.Input[_builtins.str] value: Configuration value
|
|
5820
6728
|
:param pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgs']]] values: List of configuration values
|
|
5821
6729
|
"""
|
|
6730
|
+
if additional_properties is not None:
|
|
6731
|
+
pulumi.set(__self__, "additional_properties", additional_properties)
|
|
6732
|
+
if allowed_values is not None:
|
|
6733
|
+
pulumi.set(__self__, "allowed_values", allowed_values)
|
|
6734
|
+
if allowed_values_data_type is not None:
|
|
6735
|
+
pulumi.set(__self__, "allowed_values_data_type", allowed_values_data_type)
|
|
5822
6736
|
if config_key is not None:
|
|
5823
6737
|
pulumi.set(__self__, "config_key", config_key)
|
|
5824
6738
|
if data_type is not None:
|
|
@@ -5830,6 +6744,42 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs:
|
|
|
5830
6744
|
if values is not None:
|
|
5831
6745
|
pulumi.set(__self__, "values", values)
|
|
5832
6746
|
|
|
6747
|
+
@_builtins.property
|
|
6748
|
+
@pulumi.getter(name="additionalProperties")
|
|
6749
|
+
def additional_properties(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgs']]]]:
|
|
6750
|
+
"""
|
|
6751
|
+
Map of additional property values for configuration
|
|
6752
|
+
"""
|
|
6753
|
+
return pulumi.get(self, "additional_properties")
|
|
6754
|
+
|
|
6755
|
+
@additional_properties.setter
|
|
6756
|
+
def additional_properties(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgs']]]]):
|
|
6757
|
+
pulumi.set(self, "additional_properties", value)
|
|
6758
|
+
|
|
6759
|
+
@_builtins.property
|
|
6760
|
+
@pulumi.getter(name="allowedValues")
|
|
6761
|
+
def allowed_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgs']]]]:
|
|
6762
|
+
"""
|
|
6763
|
+
Map of possible values for configuration
|
|
6764
|
+
"""
|
|
6765
|
+
return pulumi.get(self, "allowed_values")
|
|
6766
|
+
|
|
6767
|
+
@allowed_values.setter
|
|
6768
|
+
def allowed_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgs']]]]):
|
|
6769
|
+
pulumi.set(self, "allowed_values", value)
|
|
6770
|
+
|
|
6771
|
+
@_builtins.property
|
|
6772
|
+
@pulumi.getter(name="allowedValuesDataType")
|
|
6773
|
+
def allowed_values_data_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
6774
|
+
"""
|
|
6775
|
+
Map property Value data type
|
|
6776
|
+
"""
|
|
6777
|
+
return pulumi.get(self, "allowed_values_data_type")
|
|
6778
|
+
|
|
6779
|
+
@allowed_values_data_type.setter
|
|
6780
|
+
def allowed_values_data_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
6781
|
+
pulumi.set(self, "allowed_values_data_type", value)
|
|
6782
|
+
|
|
5833
6783
|
@_builtins.property
|
|
5834
6784
|
@pulumi.getter(name="configKey")
|
|
5835
6785
|
def config_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -5891,6 +6841,130 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationArgs:
|
|
|
5891
6841
|
pulumi.set(self, "values", value)
|
|
5892
6842
|
|
|
5893
6843
|
|
|
6844
|
+
if not MYPY:
|
|
6845
|
+
class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgsDict(TypedDict):
|
|
6846
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
6847
|
+
"""
|
|
6848
|
+
The unique identifier of the detector rule type
|
|
6849
|
+
"""
|
|
6850
|
+
property_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
6851
|
+
"""
|
|
6852
|
+
Property Type
|
|
6853
|
+
"""
|
|
6854
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
6855
|
+
"""
|
|
6856
|
+
Configuration value
|
|
6857
|
+
"""
|
|
6858
|
+
elif False:
|
|
6859
|
+
TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgsDict: TypeAlias = Mapping[str, Any]
|
|
6860
|
+
|
|
6861
|
+
@pulumi.input_type
|
|
6862
|
+
class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAdditionalPropertyArgs:
|
|
6863
|
+
def __init__(__self__, *,
|
|
6864
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
6865
|
+
property_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
6866
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
6867
|
+
"""
|
|
6868
|
+
:param pulumi.Input[_builtins.str] key: The unique identifier of the detector rule type
|
|
6869
|
+
:param pulumi.Input[_builtins.str] property_type: Property Type
|
|
6870
|
+
:param pulumi.Input[_builtins.str] value: Configuration value
|
|
6871
|
+
"""
|
|
6872
|
+
if key is not None:
|
|
6873
|
+
pulumi.set(__self__, "key", key)
|
|
6874
|
+
if property_type is not None:
|
|
6875
|
+
pulumi.set(__self__, "property_type", property_type)
|
|
6876
|
+
if value is not None:
|
|
6877
|
+
pulumi.set(__self__, "value", value)
|
|
6878
|
+
|
|
6879
|
+
@_builtins.property
|
|
6880
|
+
@pulumi.getter
|
|
6881
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
6882
|
+
"""
|
|
6883
|
+
The unique identifier of the detector rule type
|
|
6884
|
+
"""
|
|
6885
|
+
return pulumi.get(self, "key")
|
|
6886
|
+
|
|
6887
|
+
@key.setter
|
|
6888
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
6889
|
+
pulumi.set(self, "key", value)
|
|
6890
|
+
|
|
6891
|
+
@_builtins.property
|
|
6892
|
+
@pulumi.getter(name="propertyType")
|
|
6893
|
+
def property_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
6894
|
+
"""
|
|
6895
|
+
Property Type
|
|
6896
|
+
"""
|
|
6897
|
+
return pulumi.get(self, "property_type")
|
|
6898
|
+
|
|
6899
|
+
@property_type.setter
|
|
6900
|
+
def property_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
6901
|
+
pulumi.set(self, "property_type", value)
|
|
6902
|
+
|
|
6903
|
+
@_builtins.property
|
|
6904
|
+
@pulumi.getter
|
|
6905
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
6906
|
+
"""
|
|
6907
|
+
Configuration value
|
|
6908
|
+
"""
|
|
6909
|
+
return pulumi.get(self, "value")
|
|
6910
|
+
|
|
6911
|
+
@value.setter
|
|
6912
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
6913
|
+
pulumi.set(self, "value", value)
|
|
6914
|
+
|
|
6915
|
+
|
|
6916
|
+
if not MYPY:
|
|
6917
|
+
class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgsDict(TypedDict):
|
|
6918
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
6919
|
+
"""
|
|
6920
|
+
The unique identifier of the detector rule type
|
|
6921
|
+
"""
|
|
6922
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
6923
|
+
"""
|
|
6924
|
+
Configuration value
|
|
6925
|
+
"""
|
|
6926
|
+
elif False:
|
|
6927
|
+
TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgsDict: TypeAlias = Mapping[str, Any]
|
|
6928
|
+
|
|
6929
|
+
@pulumi.input_type
|
|
6930
|
+
class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationAllowedValueArgs:
|
|
6931
|
+
def __init__(__self__, *,
|
|
6932
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
6933
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
6934
|
+
"""
|
|
6935
|
+
:param pulumi.Input[_builtins.str] key: The unique identifier of the detector rule type
|
|
6936
|
+
:param pulumi.Input[_builtins.str] value: Configuration value
|
|
6937
|
+
"""
|
|
6938
|
+
if key is not None:
|
|
6939
|
+
pulumi.set(__self__, "key", key)
|
|
6940
|
+
if value is not None:
|
|
6941
|
+
pulumi.set(__self__, "value", value)
|
|
6942
|
+
|
|
6943
|
+
@_builtins.property
|
|
6944
|
+
@pulumi.getter
|
|
6945
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
6946
|
+
"""
|
|
6947
|
+
The unique identifier of the detector rule type
|
|
6948
|
+
"""
|
|
6949
|
+
return pulumi.get(self, "key")
|
|
6950
|
+
|
|
6951
|
+
@key.setter
|
|
6952
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
6953
|
+
pulumi.set(self, "key", value)
|
|
6954
|
+
|
|
6955
|
+
@_builtins.property
|
|
6956
|
+
@pulumi.getter
|
|
6957
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
6958
|
+
"""
|
|
6959
|
+
Configuration value
|
|
6960
|
+
"""
|
|
6961
|
+
return pulumi.get(self, "value")
|
|
6962
|
+
|
|
6963
|
+
@value.setter
|
|
6964
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
6965
|
+
pulumi.set(self, "value", value)
|
|
6966
|
+
|
|
6967
|
+
|
|
5894
6968
|
if not MYPY:
|
|
5895
6969
|
class TargetTargetDetectorRecipeEffectiveDetectorRuleDetailConfigurationValueArgsDict(TypedDict):
|
|
5896
6970
|
list_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
@@ -6041,6 +7115,58 @@ class TargetTargetDetectorRecipeEffectiveDetectorRuleEntitiesMappingArgs:
|
|
|
6041
7115
|
pulumi.set(self, "query_field", value)
|
|
6042
7116
|
|
|
6043
7117
|
|
|
7118
|
+
if not MYPY:
|
|
7119
|
+
class TargetTargetDetectorRecipeEffectiveDetectorRuleRuleTypeArgsDict(TypedDict):
|
|
7120
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
7121
|
+
"""
|
|
7122
|
+
The unique identifier of the detector rule type
|
|
7123
|
+
"""
|
|
7124
|
+
values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
7125
|
+
"""
|
|
7126
|
+
Configuration value
|
|
7127
|
+
"""
|
|
7128
|
+
elif False:
|
|
7129
|
+
TargetTargetDetectorRecipeEffectiveDetectorRuleRuleTypeArgsDict: TypeAlias = Mapping[str, Any]
|
|
7130
|
+
|
|
7131
|
+
@pulumi.input_type
|
|
7132
|
+
class TargetTargetDetectorRecipeEffectiveDetectorRuleRuleTypeArgs:
|
|
7133
|
+
def __init__(__self__, *,
|
|
7134
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
7135
|
+
values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
7136
|
+
"""
|
|
7137
|
+
:param pulumi.Input[_builtins.str] key: The unique identifier of the detector rule type
|
|
7138
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: Configuration value
|
|
7139
|
+
"""
|
|
7140
|
+
if key is not None:
|
|
7141
|
+
pulumi.set(__self__, "key", key)
|
|
7142
|
+
if values is not None:
|
|
7143
|
+
pulumi.set(__self__, "values", values)
|
|
7144
|
+
|
|
7145
|
+
@_builtins.property
|
|
7146
|
+
@pulumi.getter
|
|
7147
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
7148
|
+
"""
|
|
7149
|
+
The unique identifier of the detector rule type
|
|
7150
|
+
"""
|
|
7151
|
+
return pulumi.get(self, "key")
|
|
7152
|
+
|
|
7153
|
+
@key.setter
|
|
7154
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
7155
|
+
pulumi.set(self, "key", value)
|
|
7156
|
+
|
|
7157
|
+
@_builtins.property
|
|
7158
|
+
@pulumi.getter
|
|
7159
|
+
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
7160
|
+
"""
|
|
7161
|
+
Configuration value
|
|
7162
|
+
"""
|
|
7163
|
+
return pulumi.get(self, "values")
|
|
7164
|
+
|
|
7165
|
+
@values.setter
|
|
7166
|
+
def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
7167
|
+
pulumi.set(self, "values", value)
|
|
7168
|
+
|
|
7169
|
+
|
|
6044
7170
|
if not MYPY:
|
|
6045
7171
|
class TargetTargetResponderRecipeArgsDict(TypedDict):
|
|
6046
7172
|
responder_recipe_id: pulumi.Input[_builtins.str]
|