pulumi-ise 0.1.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_ise/__init__.py +362 -0
- pulumi_ise/_utilities.py +291 -0
- pulumi_ise/config/__init__.py +8 -0
- pulumi_ise/config/__init__.pyi +36 -0
- pulumi_ise/config/vars.py +52 -0
- pulumi_ise/deviceadmin/__init__.py +29 -0
- pulumi_ise/deviceadmin/_inputs.py +1952 -0
- pulumi_ise/deviceadmin/allowed_protocols_tacacs.py +376 -0
- pulumi_ise/deviceadmin/authentication_rule.py +1045 -0
- pulumi_ise/deviceadmin/authorization_exception_rule.py +937 -0
- pulumi_ise/deviceadmin/authorization_global_exception_rule.py +887 -0
- pulumi_ise/deviceadmin/authorization_rule.py +937 -0
- pulumi_ise/deviceadmin/condition.py +645 -0
- pulumi_ise/deviceadmin/get_allowed_protocols_tacacs.py +161 -0
- pulumi_ise/deviceadmin/get_authentication_rule.py +338 -0
- pulumi_ise/deviceadmin/get_authorization_exception_rule.py +312 -0
- pulumi_ise/deviceadmin/get_authorization_global_exception_rule.py +292 -0
- pulumi_ise/deviceadmin/get_authorization_rule.py +312 -0
- pulumi_ise/deviceadmin/get_condition.py +227 -0
- pulumi_ise/deviceadmin/get_policy_set.py +305 -0
- pulumi_ise/deviceadmin/get_tacacs_command_set.py +146 -0
- pulumi_ise/deviceadmin/get_tacacs_profile.py +133 -0
- pulumi_ise/deviceadmin/get_time_and_date_condition.py +265 -0
- pulumi_ise/deviceadmin/outputs.py +3173 -0
- pulumi_ise/deviceadmin/policy_set.py +942 -0
- pulumi_ise/deviceadmin/tacacs_command_set.py +321 -0
- pulumi_ise/deviceadmin/tacacs_profile.py +272 -0
- pulumi_ise/deviceadmin/time_and_date_condition.py +765 -0
- pulumi_ise/identitymanagement/__init__.py +26 -0
- pulumi_ise/identitymanagement/_inputs.py +313 -0
- pulumi_ise/identitymanagement/active_directory_add_groups.py +478 -0
- pulumi_ise/identitymanagement/active_directory_join_domain_with_all_nodes.py +211 -0
- pulumi_ise/identitymanagement/active_directory_join_point.py +1671 -0
- pulumi_ise/identitymanagement/certificate_authentication_profile.py +520 -0
- pulumi_ise/identitymanagement/endpoint.py +1371 -0
- pulumi_ise/identitymanagement/endpoint_identity_group.py +322 -0
- pulumi_ise/identitymanagement/get_active_directory_groups_by_domain.py +198 -0
- pulumi_ise/identitymanagement/get_active_directory_join_point.py +518 -0
- pulumi_ise/identitymanagement/get_certificate_authentication_profile.py +187 -0
- pulumi_ise/identitymanagement/get_endpoint.py +434 -0
- pulumi_ise/identitymanagement/get_endpoint_identity_group.py +148 -0
- pulumi_ise/identitymanagement/get_identity_source_sequence.py +159 -0
- pulumi_ise/identitymanagement/get_internal_user.py +278 -0
- pulumi_ise/identitymanagement/get_user_identity_group.py +135 -0
- pulumi_ise/identitymanagement/identity_source_sequence.py +371 -0
- pulumi_ise/identitymanagement/internal_user.py +825 -0
- pulumi_ise/identitymanagement/outputs.py +486 -0
- pulumi_ise/identitymanagement/user_identity_group.py +275 -0
- pulumi_ise/network/__init__.py +13 -0
- pulumi_ise/network/_inputs.py +69 -0
- pulumi_ise/network/device.py +2189 -0
- pulumi_ise/network/device_group.py +276 -0
- pulumi_ise/network/get_device.py +643 -0
- pulumi_ise/network/get_device_group.py +135 -0
- pulumi_ise/network/outputs.py +115 -0
- pulumi_ise/networkaccess/__init__.py +31 -0
- pulumi_ise/networkaccess/_inputs.py +1948 -0
- pulumi_ise/networkaccess/allowed_protocols.py +3962 -0
- pulumi_ise/networkaccess/authentication_rule.py +1045 -0
- pulumi_ise/networkaccess/authorization_exception_rule.py +937 -0
- pulumi_ise/networkaccess/authorization_global_exception_rule.py +887 -0
- pulumi_ise/networkaccess/authorization_profile.py +1677 -0
- pulumi_ise/networkaccess/authorization_rule.py +937 -0
- pulumi_ise/networkaccess/condition.py +645 -0
- pulumi_ise/networkaccess/dictionary.py +326 -0
- pulumi_ise/networkaccess/downloadable_acl.py +325 -0
- pulumi_ise/networkaccess/get_allowed_protocols.py +1097 -0
- pulumi_ise/networkaccess/get_authentication_rule.py +338 -0
- pulumi_ise/networkaccess/get_authorization_exception_rule.py +312 -0
- pulumi_ise/networkaccess/get_authorization_global_exception_rule.py +292 -0
- pulumi_ise/networkaccess/get_authorization_profile.py +526 -0
- pulumi_ise/networkaccess/get_authorization_rule.py +312 -0
- pulumi_ise/networkaccess/get_condition.py +227 -0
- pulumi_ise/networkaccess/get_dictionary.py +148 -0
- pulumi_ise/networkaccess/get_downloadable_acl.py +148 -0
- pulumi_ise/networkaccess/get_policy_set.py +305 -0
- pulumi_ise/networkaccess/get_time_and_date_condition.py +265 -0
- pulumi_ise/networkaccess/outputs.py +3188 -0
- pulumi_ise/networkaccess/policy_set.py +942 -0
- pulumi_ise/networkaccess/time_and_date_condition.py +765 -0
- pulumi_ise/provider.py +204 -0
- pulumi_ise/pulumi-plugin.json +4 -0
- pulumi_ise/py.typed +0 -0
- pulumi_ise/system/__init__.py +13 -0
- pulumi_ise/system/_inputs.py +56 -0
- pulumi_ise/system/get_license_tier_state.py +105 -0
- pulumi_ise/system/get_repository.py +187 -0
- pulumi_ise/system/license_tier_state.py +184 -0
- pulumi_ise/system/outputs.py +78 -0
- pulumi_ise/system/repository.py +473 -0
- pulumi_ise/trustsec/__init__.py +17 -0
- pulumi_ise/trustsec/egress_matrix_cell.py +424 -0
- pulumi_ise/trustsec/get_egress_matrix_cell.py +169 -0
- pulumi_ise/trustsec/get_ip_to_sgt_mapping.py +200 -0
- pulumi_ise/trustsec/get_ip_to_sgt_mapping_group.py +161 -0
- pulumi_ise/trustsec/get_security_group.py +161 -0
- pulumi_ise/trustsec/get_security_group_acl.py +161 -0
- pulumi_ise/trustsec/ip_to_sgt_mapping.py +512 -0
- pulumi_ise/trustsec/ip_to_sgt_mapping_group.py +371 -0
- pulumi_ise/trustsec/security_group.py +374 -0
- pulumi_ise/trustsec/security_group_acl.py +374 -0
- pulumi_ise-0.1.0.dist-info/METADATA +63 -0
- pulumi_ise-0.1.0.dist-info/RECORD +105 -0
- pulumi_ise-0.1.0.dist-info/WHEEL +5 -0
- pulumi_ise-0.1.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,1948 @@
|
|
|
1
|
+
# coding=utf-8
|
|
2
|
+
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
|
|
3
|
+
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
|
+
|
|
5
|
+
import copy
|
|
6
|
+
import warnings
|
|
7
|
+
import pulumi
|
|
8
|
+
import pulumi.runtime
|
|
9
|
+
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
10
|
+
from .. import _utilities
|
|
11
|
+
|
|
12
|
+
__all__ = [
|
|
13
|
+
'AuthenticationRuleChildrenArgs',
|
|
14
|
+
'AuthenticationRuleChildrenChildrenArgs',
|
|
15
|
+
'AuthorizationExceptionRuleChildrenArgs',
|
|
16
|
+
'AuthorizationExceptionRuleChildrenChildrenArgs',
|
|
17
|
+
'AuthorizationGlobalExceptionRuleChildrenArgs',
|
|
18
|
+
'AuthorizationGlobalExceptionRuleChildrenChildrenArgs',
|
|
19
|
+
'AuthorizationProfileAdvancedAttributeArgs',
|
|
20
|
+
'AuthorizationRuleChildrenArgs',
|
|
21
|
+
'AuthorizationRuleChildrenChildrenArgs',
|
|
22
|
+
'ConditionChildrenArgs',
|
|
23
|
+
'ConditionChildrenChildrenArgs',
|
|
24
|
+
'PolicySetChildrenArgs',
|
|
25
|
+
'PolicySetChildrenChildrenArgs',
|
|
26
|
+
]
|
|
27
|
+
|
|
28
|
+
@pulumi.input_type
|
|
29
|
+
class AuthenticationRuleChildrenArgs:
|
|
30
|
+
def __init__(__self__, *,
|
|
31
|
+
condition_type: pulumi.Input[str],
|
|
32
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
33
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
34
|
+
childrens: Optional[pulumi.Input[Sequence[pulumi.Input['AuthenticationRuleChildrenChildrenArgs']]]] = None,
|
|
35
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
36
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
37
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
38
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
39
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
40
|
+
"""
|
|
41
|
+
:param pulumi.Input[str] condition_type: Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
42
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
43
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
44
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
45
|
+
:param pulumi.Input[Sequence[pulumi.Input['AuthenticationRuleChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
46
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
47
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
48
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
49
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
50
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
51
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
52
|
+
"""
|
|
53
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
54
|
+
if attribute_name is not None:
|
|
55
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
56
|
+
if attribute_value is not None:
|
|
57
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
58
|
+
if childrens is not None:
|
|
59
|
+
pulumi.set(__self__, "childrens", childrens)
|
|
60
|
+
if dictionary_name is not None:
|
|
61
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
62
|
+
if dictionary_value is not None:
|
|
63
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
64
|
+
if id is not None:
|
|
65
|
+
pulumi.set(__self__, "id", id)
|
|
66
|
+
if is_negate is not None:
|
|
67
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
68
|
+
if operator is not None:
|
|
69
|
+
pulumi.set(__self__, "operator", operator)
|
|
70
|
+
|
|
71
|
+
@property
|
|
72
|
+
@pulumi.getter(name="conditionType")
|
|
73
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
74
|
+
"""
|
|
75
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
76
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
77
|
+
"""
|
|
78
|
+
return pulumi.get(self, "condition_type")
|
|
79
|
+
|
|
80
|
+
@condition_type.setter
|
|
81
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
82
|
+
pulumi.set(self, "condition_type", value)
|
|
83
|
+
|
|
84
|
+
@property
|
|
85
|
+
@pulumi.getter(name="attributeName")
|
|
86
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
87
|
+
"""
|
|
88
|
+
Dictionary attribute name
|
|
89
|
+
"""
|
|
90
|
+
return pulumi.get(self, "attribute_name")
|
|
91
|
+
|
|
92
|
+
@attribute_name.setter
|
|
93
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
94
|
+
pulumi.set(self, "attribute_name", value)
|
|
95
|
+
|
|
96
|
+
@property
|
|
97
|
+
@pulumi.getter(name="attributeValue")
|
|
98
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
99
|
+
"""
|
|
100
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
101
|
+
"""
|
|
102
|
+
return pulumi.get(self, "attribute_value")
|
|
103
|
+
|
|
104
|
+
@attribute_value.setter
|
|
105
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
106
|
+
pulumi.set(self, "attribute_value", value)
|
|
107
|
+
|
|
108
|
+
@property
|
|
109
|
+
@pulumi.getter
|
|
110
|
+
def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AuthenticationRuleChildrenChildrenArgs']]]]:
|
|
111
|
+
"""
|
|
112
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
113
|
+
"""
|
|
114
|
+
return pulumi.get(self, "childrens")
|
|
115
|
+
|
|
116
|
+
@childrens.setter
|
|
117
|
+
def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AuthenticationRuleChildrenChildrenArgs']]]]):
|
|
118
|
+
pulumi.set(self, "childrens", value)
|
|
119
|
+
|
|
120
|
+
@property
|
|
121
|
+
@pulumi.getter(name="dictionaryName")
|
|
122
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
123
|
+
"""
|
|
124
|
+
Dictionary name
|
|
125
|
+
"""
|
|
126
|
+
return pulumi.get(self, "dictionary_name")
|
|
127
|
+
|
|
128
|
+
@dictionary_name.setter
|
|
129
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
130
|
+
pulumi.set(self, "dictionary_name", value)
|
|
131
|
+
|
|
132
|
+
@property
|
|
133
|
+
@pulumi.getter(name="dictionaryValue")
|
|
134
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
135
|
+
"""
|
|
136
|
+
Dictionary value
|
|
137
|
+
"""
|
|
138
|
+
return pulumi.get(self, "dictionary_value")
|
|
139
|
+
|
|
140
|
+
@dictionary_value.setter
|
|
141
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
142
|
+
pulumi.set(self, "dictionary_value", value)
|
|
143
|
+
|
|
144
|
+
@property
|
|
145
|
+
@pulumi.getter
|
|
146
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
147
|
+
"""
|
|
148
|
+
UUID for condition
|
|
149
|
+
"""
|
|
150
|
+
return pulumi.get(self, "id")
|
|
151
|
+
|
|
152
|
+
@id.setter
|
|
153
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
154
|
+
pulumi.set(self, "id", value)
|
|
155
|
+
|
|
156
|
+
@property
|
|
157
|
+
@pulumi.getter(name="isNegate")
|
|
158
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
159
|
+
"""
|
|
160
|
+
Indicates whereas this condition is in negate mode
|
|
161
|
+
"""
|
|
162
|
+
return pulumi.get(self, "is_negate")
|
|
163
|
+
|
|
164
|
+
@is_negate.setter
|
|
165
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
166
|
+
pulumi.set(self, "is_negate", value)
|
|
167
|
+
|
|
168
|
+
@property
|
|
169
|
+
@pulumi.getter
|
|
170
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
171
|
+
"""
|
|
172
|
+
Equality operator
|
|
173
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
174
|
+
"""
|
|
175
|
+
return pulumi.get(self, "operator")
|
|
176
|
+
|
|
177
|
+
@operator.setter
|
|
178
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
179
|
+
pulumi.set(self, "operator", value)
|
|
180
|
+
|
|
181
|
+
|
|
182
|
+
@pulumi.input_type
|
|
183
|
+
class AuthenticationRuleChildrenChildrenArgs:
|
|
184
|
+
def __init__(__self__, *,
|
|
185
|
+
condition_type: pulumi.Input[str],
|
|
186
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
187
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
188
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
189
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
190
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
191
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
192
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
193
|
+
"""
|
|
194
|
+
:param pulumi.Input[str] condition_type: Condition type.
|
|
195
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
196
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
197
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
198
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
199
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
200
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
201
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
202
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
203
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
204
|
+
"""
|
|
205
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
206
|
+
if attribute_name is not None:
|
|
207
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
208
|
+
if attribute_value is not None:
|
|
209
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
210
|
+
if dictionary_name is not None:
|
|
211
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
212
|
+
if dictionary_value is not None:
|
|
213
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
214
|
+
if id is not None:
|
|
215
|
+
pulumi.set(__self__, "id", id)
|
|
216
|
+
if is_negate is not None:
|
|
217
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
218
|
+
if operator is not None:
|
|
219
|
+
pulumi.set(__self__, "operator", operator)
|
|
220
|
+
|
|
221
|
+
@property
|
|
222
|
+
@pulumi.getter(name="conditionType")
|
|
223
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
224
|
+
"""
|
|
225
|
+
Condition type.
|
|
226
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
227
|
+
"""
|
|
228
|
+
return pulumi.get(self, "condition_type")
|
|
229
|
+
|
|
230
|
+
@condition_type.setter
|
|
231
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
232
|
+
pulumi.set(self, "condition_type", value)
|
|
233
|
+
|
|
234
|
+
@property
|
|
235
|
+
@pulumi.getter(name="attributeName")
|
|
236
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
237
|
+
"""
|
|
238
|
+
Dictionary attribute name
|
|
239
|
+
"""
|
|
240
|
+
return pulumi.get(self, "attribute_name")
|
|
241
|
+
|
|
242
|
+
@attribute_name.setter
|
|
243
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
244
|
+
pulumi.set(self, "attribute_name", value)
|
|
245
|
+
|
|
246
|
+
@property
|
|
247
|
+
@pulumi.getter(name="attributeValue")
|
|
248
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
249
|
+
"""
|
|
250
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
251
|
+
"""
|
|
252
|
+
return pulumi.get(self, "attribute_value")
|
|
253
|
+
|
|
254
|
+
@attribute_value.setter
|
|
255
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
256
|
+
pulumi.set(self, "attribute_value", value)
|
|
257
|
+
|
|
258
|
+
@property
|
|
259
|
+
@pulumi.getter(name="dictionaryName")
|
|
260
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
261
|
+
"""
|
|
262
|
+
Dictionary name
|
|
263
|
+
"""
|
|
264
|
+
return pulumi.get(self, "dictionary_name")
|
|
265
|
+
|
|
266
|
+
@dictionary_name.setter
|
|
267
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
268
|
+
pulumi.set(self, "dictionary_name", value)
|
|
269
|
+
|
|
270
|
+
@property
|
|
271
|
+
@pulumi.getter(name="dictionaryValue")
|
|
272
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
273
|
+
"""
|
|
274
|
+
Dictionary value
|
|
275
|
+
"""
|
|
276
|
+
return pulumi.get(self, "dictionary_value")
|
|
277
|
+
|
|
278
|
+
@dictionary_value.setter
|
|
279
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
280
|
+
pulumi.set(self, "dictionary_value", value)
|
|
281
|
+
|
|
282
|
+
@property
|
|
283
|
+
@pulumi.getter
|
|
284
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
285
|
+
"""
|
|
286
|
+
UUID for condition
|
|
287
|
+
"""
|
|
288
|
+
return pulumi.get(self, "id")
|
|
289
|
+
|
|
290
|
+
@id.setter
|
|
291
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
292
|
+
pulumi.set(self, "id", value)
|
|
293
|
+
|
|
294
|
+
@property
|
|
295
|
+
@pulumi.getter(name="isNegate")
|
|
296
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
297
|
+
"""
|
|
298
|
+
Indicates whereas this condition is in negate mode
|
|
299
|
+
"""
|
|
300
|
+
return pulumi.get(self, "is_negate")
|
|
301
|
+
|
|
302
|
+
@is_negate.setter
|
|
303
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
304
|
+
pulumi.set(self, "is_negate", value)
|
|
305
|
+
|
|
306
|
+
@property
|
|
307
|
+
@pulumi.getter
|
|
308
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
309
|
+
"""
|
|
310
|
+
Equality operator
|
|
311
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
312
|
+
"""
|
|
313
|
+
return pulumi.get(self, "operator")
|
|
314
|
+
|
|
315
|
+
@operator.setter
|
|
316
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
317
|
+
pulumi.set(self, "operator", value)
|
|
318
|
+
|
|
319
|
+
|
|
320
|
+
@pulumi.input_type
|
|
321
|
+
class AuthorizationExceptionRuleChildrenArgs:
|
|
322
|
+
def __init__(__self__, *,
|
|
323
|
+
condition_type: pulumi.Input[str],
|
|
324
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
325
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
326
|
+
childrens: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationExceptionRuleChildrenChildrenArgs']]]] = None,
|
|
327
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
328
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
329
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
330
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
331
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
332
|
+
"""
|
|
333
|
+
:param pulumi.Input[str] condition_type: Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
334
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
335
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
336
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
337
|
+
:param pulumi.Input[Sequence[pulumi.Input['AuthorizationExceptionRuleChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
338
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
339
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
340
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
341
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
342
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
343
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
344
|
+
"""
|
|
345
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
346
|
+
if attribute_name is not None:
|
|
347
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
348
|
+
if attribute_value is not None:
|
|
349
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
350
|
+
if childrens is not None:
|
|
351
|
+
pulumi.set(__self__, "childrens", childrens)
|
|
352
|
+
if dictionary_name is not None:
|
|
353
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
354
|
+
if dictionary_value is not None:
|
|
355
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
356
|
+
if id is not None:
|
|
357
|
+
pulumi.set(__self__, "id", id)
|
|
358
|
+
if is_negate is not None:
|
|
359
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
360
|
+
if operator is not None:
|
|
361
|
+
pulumi.set(__self__, "operator", operator)
|
|
362
|
+
|
|
363
|
+
@property
|
|
364
|
+
@pulumi.getter(name="conditionType")
|
|
365
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
366
|
+
"""
|
|
367
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
368
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
369
|
+
"""
|
|
370
|
+
return pulumi.get(self, "condition_type")
|
|
371
|
+
|
|
372
|
+
@condition_type.setter
|
|
373
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
374
|
+
pulumi.set(self, "condition_type", value)
|
|
375
|
+
|
|
376
|
+
@property
|
|
377
|
+
@pulumi.getter(name="attributeName")
|
|
378
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
379
|
+
"""
|
|
380
|
+
Dictionary attribute name
|
|
381
|
+
"""
|
|
382
|
+
return pulumi.get(self, "attribute_name")
|
|
383
|
+
|
|
384
|
+
@attribute_name.setter
|
|
385
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
386
|
+
pulumi.set(self, "attribute_name", value)
|
|
387
|
+
|
|
388
|
+
@property
|
|
389
|
+
@pulumi.getter(name="attributeValue")
|
|
390
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
391
|
+
"""
|
|
392
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
393
|
+
"""
|
|
394
|
+
return pulumi.get(self, "attribute_value")
|
|
395
|
+
|
|
396
|
+
@attribute_value.setter
|
|
397
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
398
|
+
pulumi.set(self, "attribute_value", value)
|
|
399
|
+
|
|
400
|
+
@property
|
|
401
|
+
@pulumi.getter
|
|
402
|
+
def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationExceptionRuleChildrenChildrenArgs']]]]:
|
|
403
|
+
"""
|
|
404
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
405
|
+
"""
|
|
406
|
+
return pulumi.get(self, "childrens")
|
|
407
|
+
|
|
408
|
+
@childrens.setter
|
|
409
|
+
def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationExceptionRuleChildrenChildrenArgs']]]]):
|
|
410
|
+
pulumi.set(self, "childrens", value)
|
|
411
|
+
|
|
412
|
+
@property
|
|
413
|
+
@pulumi.getter(name="dictionaryName")
|
|
414
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
415
|
+
"""
|
|
416
|
+
Dictionary name
|
|
417
|
+
"""
|
|
418
|
+
return pulumi.get(self, "dictionary_name")
|
|
419
|
+
|
|
420
|
+
@dictionary_name.setter
|
|
421
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
422
|
+
pulumi.set(self, "dictionary_name", value)
|
|
423
|
+
|
|
424
|
+
@property
|
|
425
|
+
@pulumi.getter(name="dictionaryValue")
|
|
426
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
427
|
+
"""
|
|
428
|
+
Dictionary value
|
|
429
|
+
"""
|
|
430
|
+
return pulumi.get(self, "dictionary_value")
|
|
431
|
+
|
|
432
|
+
@dictionary_value.setter
|
|
433
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
434
|
+
pulumi.set(self, "dictionary_value", value)
|
|
435
|
+
|
|
436
|
+
@property
|
|
437
|
+
@pulumi.getter
|
|
438
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
439
|
+
"""
|
|
440
|
+
UUID for condition
|
|
441
|
+
"""
|
|
442
|
+
return pulumi.get(self, "id")
|
|
443
|
+
|
|
444
|
+
@id.setter
|
|
445
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
446
|
+
pulumi.set(self, "id", value)
|
|
447
|
+
|
|
448
|
+
@property
|
|
449
|
+
@pulumi.getter(name="isNegate")
|
|
450
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
451
|
+
"""
|
|
452
|
+
Indicates whereas this condition is in negate mode
|
|
453
|
+
"""
|
|
454
|
+
return pulumi.get(self, "is_negate")
|
|
455
|
+
|
|
456
|
+
@is_negate.setter
|
|
457
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
458
|
+
pulumi.set(self, "is_negate", value)
|
|
459
|
+
|
|
460
|
+
@property
|
|
461
|
+
@pulumi.getter
|
|
462
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
463
|
+
"""
|
|
464
|
+
Equality operator
|
|
465
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
466
|
+
"""
|
|
467
|
+
return pulumi.get(self, "operator")
|
|
468
|
+
|
|
469
|
+
@operator.setter
|
|
470
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
471
|
+
pulumi.set(self, "operator", value)
|
|
472
|
+
|
|
473
|
+
|
|
474
|
+
@pulumi.input_type
|
|
475
|
+
class AuthorizationExceptionRuleChildrenChildrenArgs:
|
|
476
|
+
def __init__(__self__, *,
|
|
477
|
+
condition_type: pulumi.Input[str],
|
|
478
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
479
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
480
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
481
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
482
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
483
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
484
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
485
|
+
"""
|
|
486
|
+
:param pulumi.Input[str] condition_type: Condition type.
|
|
487
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
488
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
489
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
490
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
491
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
492
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
493
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
494
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
495
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
496
|
+
"""
|
|
497
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
498
|
+
if attribute_name is not None:
|
|
499
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
500
|
+
if attribute_value is not None:
|
|
501
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
502
|
+
if dictionary_name is not None:
|
|
503
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
504
|
+
if dictionary_value is not None:
|
|
505
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
506
|
+
if id is not None:
|
|
507
|
+
pulumi.set(__self__, "id", id)
|
|
508
|
+
if is_negate is not None:
|
|
509
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
510
|
+
if operator is not None:
|
|
511
|
+
pulumi.set(__self__, "operator", operator)
|
|
512
|
+
|
|
513
|
+
@property
|
|
514
|
+
@pulumi.getter(name="conditionType")
|
|
515
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
516
|
+
"""
|
|
517
|
+
Condition type.
|
|
518
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
519
|
+
"""
|
|
520
|
+
return pulumi.get(self, "condition_type")
|
|
521
|
+
|
|
522
|
+
@condition_type.setter
|
|
523
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
524
|
+
pulumi.set(self, "condition_type", value)
|
|
525
|
+
|
|
526
|
+
@property
|
|
527
|
+
@pulumi.getter(name="attributeName")
|
|
528
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
529
|
+
"""
|
|
530
|
+
Dictionary attribute name
|
|
531
|
+
"""
|
|
532
|
+
return pulumi.get(self, "attribute_name")
|
|
533
|
+
|
|
534
|
+
@attribute_name.setter
|
|
535
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
536
|
+
pulumi.set(self, "attribute_name", value)
|
|
537
|
+
|
|
538
|
+
@property
|
|
539
|
+
@pulumi.getter(name="attributeValue")
|
|
540
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
541
|
+
"""
|
|
542
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
543
|
+
"""
|
|
544
|
+
return pulumi.get(self, "attribute_value")
|
|
545
|
+
|
|
546
|
+
@attribute_value.setter
|
|
547
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
548
|
+
pulumi.set(self, "attribute_value", value)
|
|
549
|
+
|
|
550
|
+
@property
|
|
551
|
+
@pulumi.getter(name="dictionaryName")
|
|
552
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
553
|
+
"""
|
|
554
|
+
Dictionary name
|
|
555
|
+
"""
|
|
556
|
+
return pulumi.get(self, "dictionary_name")
|
|
557
|
+
|
|
558
|
+
@dictionary_name.setter
|
|
559
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
560
|
+
pulumi.set(self, "dictionary_name", value)
|
|
561
|
+
|
|
562
|
+
@property
|
|
563
|
+
@pulumi.getter(name="dictionaryValue")
|
|
564
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
565
|
+
"""
|
|
566
|
+
Dictionary value
|
|
567
|
+
"""
|
|
568
|
+
return pulumi.get(self, "dictionary_value")
|
|
569
|
+
|
|
570
|
+
@dictionary_value.setter
|
|
571
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
572
|
+
pulumi.set(self, "dictionary_value", value)
|
|
573
|
+
|
|
574
|
+
@property
|
|
575
|
+
@pulumi.getter
|
|
576
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
577
|
+
"""
|
|
578
|
+
UUID for condition
|
|
579
|
+
"""
|
|
580
|
+
return pulumi.get(self, "id")
|
|
581
|
+
|
|
582
|
+
@id.setter
|
|
583
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
584
|
+
pulumi.set(self, "id", value)
|
|
585
|
+
|
|
586
|
+
@property
|
|
587
|
+
@pulumi.getter(name="isNegate")
|
|
588
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
589
|
+
"""
|
|
590
|
+
Indicates whereas this condition is in negate mode
|
|
591
|
+
"""
|
|
592
|
+
return pulumi.get(self, "is_negate")
|
|
593
|
+
|
|
594
|
+
@is_negate.setter
|
|
595
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
596
|
+
pulumi.set(self, "is_negate", value)
|
|
597
|
+
|
|
598
|
+
@property
|
|
599
|
+
@pulumi.getter
|
|
600
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
601
|
+
"""
|
|
602
|
+
Equality operator
|
|
603
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
604
|
+
"""
|
|
605
|
+
return pulumi.get(self, "operator")
|
|
606
|
+
|
|
607
|
+
@operator.setter
|
|
608
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
609
|
+
pulumi.set(self, "operator", value)
|
|
610
|
+
|
|
611
|
+
|
|
612
|
+
@pulumi.input_type
|
|
613
|
+
class AuthorizationGlobalExceptionRuleChildrenArgs:
|
|
614
|
+
def __init__(__self__, *,
|
|
615
|
+
condition_type: pulumi.Input[str],
|
|
616
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
617
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
618
|
+
childrens: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationGlobalExceptionRuleChildrenChildrenArgs']]]] = None,
|
|
619
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
620
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
621
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
622
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
623
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
624
|
+
"""
|
|
625
|
+
:param pulumi.Input[str] condition_type: Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
626
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
627
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
628
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
629
|
+
:param pulumi.Input[Sequence[pulumi.Input['AuthorizationGlobalExceptionRuleChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
630
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
631
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
632
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
633
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
634
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
635
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
636
|
+
"""
|
|
637
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
638
|
+
if attribute_name is not None:
|
|
639
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
640
|
+
if attribute_value is not None:
|
|
641
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
642
|
+
if childrens is not None:
|
|
643
|
+
pulumi.set(__self__, "childrens", childrens)
|
|
644
|
+
if dictionary_name is not None:
|
|
645
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
646
|
+
if dictionary_value is not None:
|
|
647
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
648
|
+
if id is not None:
|
|
649
|
+
pulumi.set(__self__, "id", id)
|
|
650
|
+
if is_negate is not None:
|
|
651
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
652
|
+
if operator is not None:
|
|
653
|
+
pulumi.set(__self__, "operator", operator)
|
|
654
|
+
|
|
655
|
+
@property
|
|
656
|
+
@pulumi.getter(name="conditionType")
|
|
657
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
658
|
+
"""
|
|
659
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
660
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
661
|
+
"""
|
|
662
|
+
return pulumi.get(self, "condition_type")
|
|
663
|
+
|
|
664
|
+
@condition_type.setter
|
|
665
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
666
|
+
pulumi.set(self, "condition_type", value)
|
|
667
|
+
|
|
668
|
+
@property
|
|
669
|
+
@pulumi.getter(name="attributeName")
|
|
670
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
671
|
+
"""
|
|
672
|
+
Dictionary attribute name
|
|
673
|
+
"""
|
|
674
|
+
return pulumi.get(self, "attribute_name")
|
|
675
|
+
|
|
676
|
+
@attribute_name.setter
|
|
677
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
678
|
+
pulumi.set(self, "attribute_name", value)
|
|
679
|
+
|
|
680
|
+
@property
|
|
681
|
+
@pulumi.getter(name="attributeValue")
|
|
682
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
683
|
+
"""
|
|
684
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
685
|
+
"""
|
|
686
|
+
return pulumi.get(self, "attribute_value")
|
|
687
|
+
|
|
688
|
+
@attribute_value.setter
|
|
689
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
690
|
+
pulumi.set(self, "attribute_value", value)
|
|
691
|
+
|
|
692
|
+
@property
|
|
693
|
+
@pulumi.getter
|
|
694
|
+
def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationGlobalExceptionRuleChildrenChildrenArgs']]]]:
|
|
695
|
+
"""
|
|
696
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
697
|
+
"""
|
|
698
|
+
return pulumi.get(self, "childrens")
|
|
699
|
+
|
|
700
|
+
@childrens.setter
|
|
701
|
+
def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationGlobalExceptionRuleChildrenChildrenArgs']]]]):
|
|
702
|
+
pulumi.set(self, "childrens", value)
|
|
703
|
+
|
|
704
|
+
@property
|
|
705
|
+
@pulumi.getter(name="dictionaryName")
|
|
706
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
707
|
+
"""
|
|
708
|
+
Dictionary name
|
|
709
|
+
"""
|
|
710
|
+
return pulumi.get(self, "dictionary_name")
|
|
711
|
+
|
|
712
|
+
@dictionary_name.setter
|
|
713
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
714
|
+
pulumi.set(self, "dictionary_name", value)
|
|
715
|
+
|
|
716
|
+
@property
|
|
717
|
+
@pulumi.getter(name="dictionaryValue")
|
|
718
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
719
|
+
"""
|
|
720
|
+
Dictionary value
|
|
721
|
+
"""
|
|
722
|
+
return pulumi.get(self, "dictionary_value")
|
|
723
|
+
|
|
724
|
+
@dictionary_value.setter
|
|
725
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
726
|
+
pulumi.set(self, "dictionary_value", value)
|
|
727
|
+
|
|
728
|
+
@property
|
|
729
|
+
@pulumi.getter
|
|
730
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
731
|
+
"""
|
|
732
|
+
UUID for condition
|
|
733
|
+
"""
|
|
734
|
+
return pulumi.get(self, "id")
|
|
735
|
+
|
|
736
|
+
@id.setter
|
|
737
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
738
|
+
pulumi.set(self, "id", value)
|
|
739
|
+
|
|
740
|
+
@property
|
|
741
|
+
@pulumi.getter(name="isNegate")
|
|
742
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
743
|
+
"""
|
|
744
|
+
Indicates whereas this condition is in negate mode
|
|
745
|
+
"""
|
|
746
|
+
return pulumi.get(self, "is_negate")
|
|
747
|
+
|
|
748
|
+
@is_negate.setter
|
|
749
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
750
|
+
pulumi.set(self, "is_negate", value)
|
|
751
|
+
|
|
752
|
+
@property
|
|
753
|
+
@pulumi.getter
|
|
754
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
755
|
+
"""
|
|
756
|
+
Equality operator
|
|
757
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
758
|
+
"""
|
|
759
|
+
return pulumi.get(self, "operator")
|
|
760
|
+
|
|
761
|
+
@operator.setter
|
|
762
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
763
|
+
pulumi.set(self, "operator", value)
|
|
764
|
+
|
|
765
|
+
|
|
766
|
+
@pulumi.input_type
|
|
767
|
+
class AuthorizationGlobalExceptionRuleChildrenChildrenArgs:
|
|
768
|
+
def __init__(__self__, *,
|
|
769
|
+
condition_type: pulumi.Input[str],
|
|
770
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
771
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
772
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
773
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
774
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
775
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
776
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
777
|
+
"""
|
|
778
|
+
:param pulumi.Input[str] condition_type: Condition type.
|
|
779
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
780
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
781
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
782
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
783
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
784
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
785
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
786
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
787
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
788
|
+
"""
|
|
789
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
790
|
+
if attribute_name is not None:
|
|
791
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
792
|
+
if attribute_value is not None:
|
|
793
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
794
|
+
if dictionary_name is not None:
|
|
795
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
796
|
+
if dictionary_value is not None:
|
|
797
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
798
|
+
if id is not None:
|
|
799
|
+
pulumi.set(__self__, "id", id)
|
|
800
|
+
if is_negate is not None:
|
|
801
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
802
|
+
if operator is not None:
|
|
803
|
+
pulumi.set(__self__, "operator", operator)
|
|
804
|
+
|
|
805
|
+
@property
|
|
806
|
+
@pulumi.getter(name="conditionType")
|
|
807
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
808
|
+
"""
|
|
809
|
+
Condition type.
|
|
810
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
811
|
+
"""
|
|
812
|
+
return pulumi.get(self, "condition_type")
|
|
813
|
+
|
|
814
|
+
@condition_type.setter
|
|
815
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
816
|
+
pulumi.set(self, "condition_type", value)
|
|
817
|
+
|
|
818
|
+
@property
|
|
819
|
+
@pulumi.getter(name="attributeName")
|
|
820
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
821
|
+
"""
|
|
822
|
+
Dictionary attribute name
|
|
823
|
+
"""
|
|
824
|
+
return pulumi.get(self, "attribute_name")
|
|
825
|
+
|
|
826
|
+
@attribute_name.setter
|
|
827
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
828
|
+
pulumi.set(self, "attribute_name", value)
|
|
829
|
+
|
|
830
|
+
@property
|
|
831
|
+
@pulumi.getter(name="attributeValue")
|
|
832
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
833
|
+
"""
|
|
834
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
835
|
+
"""
|
|
836
|
+
return pulumi.get(self, "attribute_value")
|
|
837
|
+
|
|
838
|
+
@attribute_value.setter
|
|
839
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
840
|
+
pulumi.set(self, "attribute_value", value)
|
|
841
|
+
|
|
842
|
+
@property
|
|
843
|
+
@pulumi.getter(name="dictionaryName")
|
|
844
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
845
|
+
"""
|
|
846
|
+
Dictionary name
|
|
847
|
+
"""
|
|
848
|
+
return pulumi.get(self, "dictionary_name")
|
|
849
|
+
|
|
850
|
+
@dictionary_name.setter
|
|
851
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
852
|
+
pulumi.set(self, "dictionary_name", value)
|
|
853
|
+
|
|
854
|
+
@property
|
|
855
|
+
@pulumi.getter(name="dictionaryValue")
|
|
856
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
857
|
+
"""
|
|
858
|
+
Dictionary value
|
|
859
|
+
"""
|
|
860
|
+
return pulumi.get(self, "dictionary_value")
|
|
861
|
+
|
|
862
|
+
@dictionary_value.setter
|
|
863
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
864
|
+
pulumi.set(self, "dictionary_value", value)
|
|
865
|
+
|
|
866
|
+
@property
|
|
867
|
+
@pulumi.getter
|
|
868
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
869
|
+
"""
|
|
870
|
+
UUID for condition
|
|
871
|
+
"""
|
|
872
|
+
return pulumi.get(self, "id")
|
|
873
|
+
|
|
874
|
+
@id.setter
|
|
875
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
876
|
+
pulumi.set(self, "id", value)
|
|
877
|
+
|
|
878
|
+
@property
|
|
879
|
+
@pulumi.getter(name="isNegate")
|
|
880
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
881
|
+
"""
|
|
882
|
+
Indicates whereas this condition is in negate mode
|
|
883
|
+
"""
|
|
884
|
+
return pulumi.get(self, "is_negate")
|
|
885
|
+
|
|
886
|
+
@is_negate.setter
|
|
887
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
888
|
+
pulumi.set(self, "is_negate", value)
|
|
889
|
+
|
|
890
|
+
@property
|
|
891
|
+
@pulumi.getter
|
|
892
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
893
|
+
"""
|
|
894
|
+
Equality operator
|
|
895
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
896
|
+
"""
|
|
897
|
+
return pulumi.get(self, "operator")
|
|
898
|
+
|
|
899
|
+
@operator.setter
|
|
900
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
901
|
+
pulumi.set(self, "operator", value)
|
|
902
|
+
|
|
903
|
+
|
|
904
|
+
@pulumi.input_type
|
|
905
|
+
class AuthorizationProfileAdvancedAttributeArgs:
|
|
906
|
+
def __init__(__self__, *,
|
|
907
|
+
attribute_left_dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
908
|
+
attribute_left_name: Optional[pulumi.Input[str]] = None,
|
|
909
|
+
attribute_right_dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
910
|
+
attribute_right_name: Optional[pulumi.Input[str]] = None,
|
|
911
|
+
attribute_right_value: Optional[pulumi.Input[str]] = None,
|
|
912
|
+
attribute_right_value_type: Optional[pulumi.Input[str]] = None):
|
|
913
|
+
"""
|
|
914
|
+
:param pulumi.Input[str] attribute_left_dictionary_name: Dictionary name
|
|
915
|
+
:param pulumi.Input[str] attribute_left_name: Attribute name
|
|
916
|
+
:param pulumi.Input[str] attribute_right_dictionary_name: Dictionary name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
|
|
917
|
+
:param pulumi.Input[str] attribute_right_name: Attribute name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
|
|
918
|
+
:param pulumi.Input[str] attribute_right_value: Attribute value, only required when `attribute_right_value_type` is `AttributeValue`
|
|
919
|
+
:param pulumi.Input[str] attribute_right_value_type: Advanced attribute value type
|
|
920
|
+
- Choices: `AdvancedDictionaryAttribute`, `AttributeValue`
|
|
921
|
+
"""
|
|
922
|
+
if attribute_left_dictionary_name is not None:
|
|
923
|
+
pulumi.set(__self__, "attribute_left_dictionary_name", attribute_left_dictionary_name)
|
|
924
|
+
if attribute_left_name is not None:
|
|
925
|
+
pulumi.set(__self__, "attribute_left_name", attribute_left_name)
|
|
926
|
+
if attribute_right_dictionary_name is not None:
|
|
927
|
+
pulumi.set(__self__, "attribute_right_dictionary_name", attribute_right_dictionary_name)
|
|
928
|
+
if attribute_right_name is not None:
|
|
929
|
+
pulumi.set(__self__, "attribute_right_name", attribute_right_name)
|
|
930
|
+
if attribute_right_value is not None:
|
|
931
|
+
pulumi.set(__self__, "attribute_right_value", attribute_right_value)
|
|
932
|
+
if attribute_right_value_type is not None:
|
|
933
|
+
pulumi.set(__self__, "attribute_right_value_type", attribute_right_value_type)
|
|
934
|
+
|
|
935
|
+
@property
|
|
936
|
+
@pulumi.getter(name="attributeLeftDictionaryName")
|
|
937
|
+
def attribute_left_dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
938
|
+
"""
|
|
939
|
+
Dictionary name
|
|
940
|
+
"""
|
|
941
|
+
return pulumi.get(self, "attribute_left_dictionary_name")
|
|
942
|
+
|
|
943
|
+
@attribute_left_dictionary_name.setter
|
|
944
|
+
def attribute_left_dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
945
|
+
pulumi.set(self, "attribute_left_dictionary_name", value)
|
|
946
|
+
|
|
947
|
+
@property
|
|
948
|
+
@pulumi.getter(name="attributeLeftName")
|
|
949
|
+
def attribute_left_name(self) -> Optional[pulumi.Input[str]]:
|
|
950
|
+
"""
|
|
951
|
+
Attribute name
|
|
952
|
+
"""
|
|
953
|
+
return pulumi.get(self, "attribute_left_name")
|
|
954
|
+
|
|
955
|
+
@attribute_left_name.setter
|
|
956
|
+
def attribute_left_name(self, value: Optional[pulumi.Input[str]]):
|
|
957
|
+
pulumi.set(self, "attribute_left_name", value)
|
|
958
|
+
|
|
959
|
+
@property
|
|
960
|
+
@pulumi.getter(name="attributeRightDictionaryName")
|
|
961
|
+
def attribute_right_dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
962
|
+
"""
|
|
963
|
+
Dictionary name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
|
|
964
|
+
"""
|
|
965
|
+
return pulumi.get(self, "attribute_right_dictionary_name")
|
|
966
|
+
|
|
967
|
+
@attribute_right_dictionary_name.setter
|
|
968
|
+
def attribute_right_dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
969
|
+
pulumi.set(self, "attribute_right_dictionary_name", value)
|
|
970
|
+
|
|
971
|
+
@property
|
|
972
|
+
@pulumi.getter(name="attributeRightName")
|
|
973
|
+
def attribute_right_name(self) -> Optional[pulumi.Input[str]]:
|
|
974
|
+
"""
|
|
975
|
+
Attribute name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
|
|
976
|
+
"""
|
|
977
|
+
return pulumi.get(self, "attribute_right_name")
|
|
978
|
+
|
|
979
|
+
@attribute_right_name.setter
|
|
980
|
+
def attribute_right_name(self, value: Optional[pulumi.Input[str]]):
|
|
981
|
+
pulumi.set(self, "attribute_right_name", value)
|
|
982
|
+
|
|
983
|
+
@property
|
|
984
|
+
@pulumi.getter(name="attributeRightValue")
|
|
985
|
+
def attribute_right_value(self) -> Optional[pulumi.Input[str]]:
|
|
986
|
+
"""
|
|
987
|
+
Attribute value, only required when `attribute_right_value_type` is `AttributeValue`
|
|
988
|
+
"""
|
|
989
|
+
return pulumi.get(self, "attribute_right_value")
|
|
990
|
+
|
|
991
|
+
@attribute_right_value.setter
|
|
992
|
+
def attribute_right_value(self, value: Optional[pulumi.Input[str]]):
|
|
993
|
+
pulumi.set(self, "attribute_right_value", value)
|
|
994
|
+
|
|
995
|
+
@property
|
|
996
|
+
@pulumi.getter(name="attributeRightValueType")
|
|
997
|
+
def attribute_right_value_type(self) -> Optional[pulumi.Input[str]]:
|
|
998
|
+
"""
|
|
999
|
+
Advanced attribute value type
|
|
1000
|
+
- Choices: `AdvancedDictionaryAttribute`, `AttributeValue`
|
|
1001
|
+
"""
|
|
1002
|
+
return pulumi.get(self, "attribute_right_value_type")
|
|
1003
|
+
|
|
1004
|
+
@attribute_right_value_type.setter
|
|
1005
|
+
def attribute_right_value_type(self, value: Optional[pulumi.Input[str]]):
|
|
1006
|
+
pulumi.set(self, "attribute_right_value_type", value)
|
|
1007
|
+
|
|
1008
|
+
|
|
1009
|
+
@pulumi.input_type
|
|
1010
|
+
class AuthorizationRuleChildrenArgs:
|
|
1011
|
+
def __init__(__self__, *,
|
|
1012
|
+
condition_type: pulumi.Input[str],
|
|
1013
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
1014
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
1015
|
+
childrens: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationRuleChildrenChildrenArgs']]]] = None,
|
|
1016
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
1017
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
1018
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
1019
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
1020
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
1021
|
+
"""
|
|
1022
|
+
:param pulumi.Input[str] condition_type: Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
1023
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
1024
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
1025
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
1026
|
+
:param pulumi.Input[Sequence[pulumi.Input['AuthorizationRuleChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
1027
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
1028
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
1029
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
1030
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
1031
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
1032
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1033
|
+
"""
|
|
1034
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
1035
|
+
if attribute_name is not None:
|
|
1036
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
1037
|
+
if attribute_value is not None:
|
|
1038
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
1039
|
+
if childrens is not None:
|
|
1040
|
+
pulumi.set(__self__, "childrens", childrens)
|
|
1041
|
+
if dictionary_name is not None:
|
|
1042
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
1043
|
+
if dictionary_value is not None:
|
|
1044
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
1045
|
+
if id is not None:
|
|
1046
|
+
pulumi.set(__self__, "id", id)
|
|
1047
|
+
if is_negate is not None:
|
|
1048
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
1049
|
+
if operator is not None:
|
|
1050
|
+
pulumi.set(__self__, "operator", operator)
|
|
1051
|
+
|
|
1052
|
+
@property
|
|
1053
|
+
@pulumi.getter(name="conditionType")
|
|
1054
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
1055
|
+
"""
|
|
1056
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
1057
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
1058
|
+
"""
|
|
1059
|
+
return pulumi.get(self, "condition_type")
|
|
1060
|
+
|
|
1061
|
+
@condition_type.setter
|
|
1062
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
1063
|
+
pulumi.set(self, "condition_type", value)
|
|
1064
|
+
|
|
1065
|
+
@property
|
|
1066
|
+
@pulumi.getter(name="attributeName")
|
|
1067
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
1068
|
+
"""
|
|
1069
|
+
Dictionary attribute name
|
|
1070
|
+
"""
|
|
1071
|
+
return pulumi.get(self, "attribute_name")
|
|
1072
|
+
|
|
1073
|
+
@attribute_name.setter
|
|
1074
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
1075
|
+
pulumi.set(self, "attribute_name", value)
|
|
1076
|
+
|
|
1077
|
+
@property
|
|
1078
|
+
@pulumi.getter(name="attributeValue")
|
|
1079
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
1080
|
+
"""
|
|
1081
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
1082
|
+
"""
|
|
1083
|
+
return pulumi.get(self, "attribute_value")
|
|
1084
|
+
|
|
1085
|
+
@attribute_value.setter
|
|
1086
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
1087
|
+
pulumi.set(self, "attribute_value", value)
|
|
1088
|
+
|
|
1089
|
+
@property
|
|
1090
|
+
@pulumi.getter
|
|
1091
|
+
def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationRuleChildrenChildrenArgs']]]]:
|
|
1092
|
+
"""
|
|
1093
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
1094
|
+
"""
|
|
1095
|
+
return pulumi.get(self, "childrens")
|
|
1096
|
+
|
|
1097
|
+
@childrens.setter
|
|
1098
|
+
def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationRuleChildrenChildrenArgs']]]]):
|
|
1099
|
+
pulumi.set(self, "childrens", value)
|
|
1100
|
+
|
|
1101
|
+
@property
|
|
1102
|
+
@pulumi.getter(name="dictionaryName")
|
|
1103
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
1104
|
+
"""
|
|
1105
|
+
Dictionary name
|
|
1106
|
+
"""
|
|
1107
|
+
return pulumi.get(self, "dictionary_name")
|
|
1108
|
+
|
|
1109
|
+
@dictionary_name.setter
|
|
1110
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
1111
|
+
pulumi.set(self, "dictionary_name", value)
|
|
1112
|
+
|
|
1113
|
+
@property
|
|
1114
|
+
@pulumi.getter(name="dictionaryValue")
|
|
1115
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
1116
|
+
"""
|
|
1117
|
+
Dictionary value
|
|
1118
|
+
"""
|
|
1119
|
+
return pulumi.get(self, "dictionary_value")
|
|
1120
|
+
|
|
1121
|
+
@dictionary_value.setter
|
|
1122
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
1123
|
+
pulumi.set(self, "dictionary_value", value)
|
|
1124
|
+
|
|
1125
|
+
@property
|
|
1126
|
+
@pulumi.getter
|
|
1127
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
1128
|
+
"""
|
|
1129
|
+
UUID for condition
|
|
1130
|
+
"""
|
|
1131
|
+
return pulumi.get(self, "id")
|
|
1132
|
+
|
|
1133
|
+
@id.setter
|
|
1134
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
1135
|
+
pulumi.set(self, "id", value)
|
|
1136
|
+
|
|
1137
|
+
@property
|
|
1138
|
+
@pulumi.getter(name="isNegate")
|
|
1139
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
1140
|
+
"""
|
|
1141
|
+
Indicates whereas this condition is in negate mode
|
|
1142
|
+
"""
|
|
1143
|
+
return pulumi.get(self, "is_negate")
|
|
1144
|
+
|
|
1145
|
+
@is_negate.setter
|
|
1146
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
1147
|
+
pulumi.set(self, "is_negate", value)
|
|
1148
|
+
|
|
1149
|
+
@property
|
|
1150
|
+
@pulumi.getter
|
|
1151
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1152
|
+
"""
|
|
1153
|
+
Equality operator
|
|
1154
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1155
|
+
"""
|
|
1156
|
+
return pulumi.get(self, "operator")
|
|
1157
|
+
|
|
1158
|
+
@operator.setter
|
|
1159
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1160
|
+
pulumi.set(self, "operator", value)
|
|
1161
|
+
|
|
1162
|
+
|
|
1163
|
+
@pulumi.input_type
|
|
1164
|
+
class AuthorizationRuleChildrenChildrenArgs:
|
|
1165
|
+
def __init__(__self__, *,
|
|
1166
|
+
condition_type: pulumi.Input[str],
|
|
1167
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
1168
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
1169
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
1170
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
1171
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
1172
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
1173
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
1174
|
+
"""
|
|
1175
|
+
:param pulumi.Input[str] condition_type: Condition type.
|
|
1176
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
1177
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
1178
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
1179
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
1180
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
1181
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
1182
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
1183
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
1184
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1185
|
+
"""
|
|
1186
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
1187
|
+
if attribute_name is not None:
|
|
1188
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
1189
|
+
if attribute_value is not None:
|
|
1190
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
1191
|
+
if dictionary_name is not None:
|
|
1192
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
1193
|
+
if dictionary_value is not None:
|
|
1194
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
1195
|
+
if id is not None:
|
|
1196
|
+
pulumi.set(__self__, "id", id)
|
|
1197
|
+
if is_negate is not None:
|
|
1198
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
1199
|
+
if operator is not None:
|
|
1200
|
+
pulumi.set(__self__, "operator", operator)
|
|
1201
|
+
|
|
1202
|
+
@property
|
|
1203
|
+
@pulumi.getter(name="conditionType")
|
|
1204
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
1205
|
+
"""
|
|
1206
|
+
Condition type.
|
|
1207
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
1208
|
+
"""
|
|
1209
|
+
return pulumi.get(self, "condition_type")
|
|
1210
|
+
|
|
1211
|
+
@condition_type.setter
|
|
1212
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
1213
|
+
pulumi.set(self, "condition_type", value)
|
|
1214
|
+
|
|
1215
|
+
@property
|
|
1216
|
+
@pulumi.getter(name="attributeName")
|
|
1217
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
1218
|
+
"""
|
|
1219
|
+
Dictionary attribute name
|
|
1220
|
+
"""
|
|
1221
|
+
return pulumi.get(self, "attribute_name")
|
|
1222
|
+
|
|
1223
|
+
@attribute_name.setter
|
|
1224
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
1225
|
+
pulumi.set(self, "attribute_name", value)
|
|
1226
|
+
|
|
1227
|
+
@property
|
|
1228
|
+
@pulumi.getter(name="attributeValue")
|
|
1229
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
1230
|
+
"""
|
|
1231
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
1232
|
+
"""
|
|
1233
|
+
return pulumi.get(self, "attribute_value")
|
|
1234
|
+
|
|
1235
|
+
@attribute_value.setter
|
|
1236
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
1237
|
+
pulumi.set(self, "attribute_value", value)
|
|
1238
|
+
|
|
1239
|
+
@property
|
|
1240
|
+
@pulumi.getter(name="dictionaryName")
|
|
1241
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
1242
|
+
"""
|
|
1243
|
+
Dictionary name
|
|
1244
|
+
"""
|
|
1245
|
+
return pulumi.get(self, "dictionary_name")
|
|
1246
|
+
|
|
1247
|
+
@dictionary_name.setter
|
|
1248
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
1249
|
+
pulumi.set(self, "dictionary_name", value)
|
|
1250
|
+
|
|
1251
|
+
@property
|
|
1252
|
+
@pulumi.getter(name="dictionaryValue")
|
|
1253
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
1254
|
+
"""
|
|
1255
|
+
Dictionary value
|
|
1256
|
+
"""
|
|
1257
|
+
return pulumi.get(self, "dictionary_value")
|
|
1258
|
+
|
|
1259
|
+
@dictionary_value.setter
|
|
1260
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
1261
|
+
pulumi.set(self, "dictionary_value", value)
|
|
1262
|
+
|
|
1263
|
+
@property
|
|
1264
|
+
@pulumi.getter
|
|
1265
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
1266
|
+
"""
|
|
1267
|
+
UUID for condition
|
|
1268
|
+
"""
|
|
1269
|
+
return pulumi.get(self, "id")
|
|
1270
|
+
|
|
1271
|
+
@id.setter
|
|
1272
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
1273
|
+
pulumi.set(self, "id", value)
|
|
1274
|
+
|
|
1275
|
+
@property
|
|
1276
|
+
@pulumi.getter(name="isNegate")
|
|
1277
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
1278
|
+
"""
|
|
1279
|
+
Indicates whereas this condition is in negate mode
|
|
1280
|
+
"""
|
|
1281
|
+
return pulumi.get(self, "is_negate")
|
|
1282
|
+
|
|
1283
|
+
@is_negate.setter
|
|
1284
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
1285
|
+
pulumi.set(self, "is_negate", value)
|
|
1286
|
+
|
|
1287
|
+
@property
|
|
1288
|
+
@pulumi.getter
|
|
1289
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1290
|
+
"""
|
|
1291
|
+
Equality operator
|
|
1292
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1293
|
+
"""
|
|
1294
|
+
return pulumi.get(self, "operator")
|
|
1295
|
+
|
|
1296
|
+
@operator.setter
|
|
1297
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1298
|
+
pulumi.set(self, "operator", value)
|
|
1299
|
+
|
|
1300
|
+
|
|
1301
|
+
@pulumi.input_type
|
|
1302
|
+
class ConditionChildrenArgs:
|
|
1303
|
+
def __init__(__self__, *,
|
|
1304
|
+
condition_type: pulumi.Input[str],
|
|
1305
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
1306
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
1307
|
+
childrens: Optional[pulumi.Input[Sequence[pulumi.Input['ConditionChildrenChildrenArgs']]]] = None,
|
|
1308
|
+
description: Optional[pulumi.Input[str]] = None,
|
|
1309
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
1310
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
1311
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
1312
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
1313
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
1314
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
1315
|
+
"""
|
|
1316
|
+
:param pulumi.Input[str] condition_type: Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
1317
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
1318
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
1319
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
1320
|
+
:param pulumi.Input[Sequence[pulumi.Input['ConditionChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
1321
|
+
:param pulumi.Input[str] description: Condition description
|
|
1322
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
1323
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
1324
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
1325
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
1326
|
+
:param pulumi.Input[str] name: Condition name
|
|
1327
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
1328
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1329
|
+
"""
|
|
1330
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
1331
|
+
if attribute_name is not None:
|
|
1332
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
1333
|
+
if attribute_value is not None:
|
|
1334
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
1335
|
+
if childrens is not None:
|
|
1336
|
+
pulumi.set(__self__, "childrens", childrens)
|
|
1337
|
+
if description is not None:
|
|
1338
|
+
pulumi.set(__self__, "description", description)
|
|
1339
|
+
if dictionary_name is not None:
|
|
1340
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
1341
|
+
if dictionary_value is not None:
|
|
1342
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
1343
|
+
if id is not None:
|
|
1344
|
+
pulumi.set(__self__, "id", id)
|
|
1345
|
+
if is_negate is not None:
|
|
1346
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
1347
|
+
if name is not None:
|
|
1348
|
+
pulumi.set(__self__, "name", name)
|
|
1349
|
+
if operator is not None:
|
|
1350
|
+
pulumi.set(__self__, "operator", operator)
|
|
1351
|
+
|
|
1352
|
+
@property
|
|
1353
|
+
@pulumi.getter(name="conditionType")
|
|
1354
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
1355
|
+
"""
|
|
1356
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
1357
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
1358
|
+
"""
|
|
1359
|
+
return pulumi.get(self, "condition_type")
|
|
1360
|
+
|
|
1361
|
+
@condition_type.setter
|
|
1362
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
1363
|
+
pulumi.set(self, "condition_type", value)
|
|
1364
|
+
|
|
1365
|
+
@property
|
|
1366
|
+
@pulumi.getter(name="attributeName")
|
|
1367
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
1368
|
+
"""
|
|
1369
|
+
Dictionary attribute name
|
|
1370
|
+
"""
|
|
1371
|
+
return pulumi.get(self, "attribute_name")
|
|
1372
|
+
|
|
1373
|
+
@attribute_name.setter
|
|
1374
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
1375
|
+
pulumi.set(self, "attribute_name", value)
|
|
1376
|
+
|
|
1377
|
+
@property
|
|
1378
|
+
@pulumi.getter(name="attributeValue")
|
|
1379
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
1380
|
+
"""
|
|
1381
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
1382
|
+
"""
|
|
1383
|
+
return pulumi.get(self, "attribute_value")
|
|
1384
|
+
|
|
1385
|
+
@attribute_value.setter
|
|
1386
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
1387
|
+
pulumi.set(self, "attribute_value", value)
|
|
1388
|
+
|
|
1389
|
+
@property
|
|
1390
|
+
@pulumi.getter
|
|
1391
|
+
def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ConditionChildrenChildrenArgs']]]]:
|
|
1392
|
+
"""
|
|
1393
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
1394
|
+
"""
|
|
1395
|
+
return pulumi.get(self, "childrens")
|
|
1396
|
+
|
|
1397
|
+
@childrens.setter
|
|
1398
|
+
def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ConditionChildrenChildrenArgs']]]]):
|
|
1399
|
+
pulumi.set(self, "childrens", value)
|
|
1400
|
+
|
|
1401
|
+
@property
|
|
1402
|
+
@pulumi.getter
|
|
1403
|
+
def description(self) -> Optional[pulumi.Input[str]]:
|
|
1404
|
+
"""
|
|
1405
|
+
Condition description
|
|
1406
|
+
"""
|
|
1407
|
+
return pulumi.get(self, "description")
|
|
1408
|
+
|
|
1409
|
+
@description.setter
|
|
1410
|
+
def description(self, value: Optional[pulumi.Input[str]]):
|
|
1411
|
+
pulumi.set(self, "description", value)
|
|
1412
|
+
|
|
1413
|
+
@property
|
|
1414
|
+
@pulumi.getter(name="dictionaryName")
|
|
1415
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
1416
|
+
"""
|
|
1417
|
+
Dictionary name
|
|
1418
|
+
"""
|
|
1419
|
+
return pulumi.get(self, "dictionary_name")
|
|
1420
|
+
|
|
1421
|
+
@dictionary_name.setter
|
|
1422
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
1423
|
+
pulumi.set(self, "dictionary_name", value)
|
|
1424
|
+
|
|
1425
|
+
@property
|
|
1426
|
+
@pulumi.getter(name="dictionaryValue")
|
|
1427
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
1428
|
+
"""
|
|
1429
|
+
Dictionary value
|
|
1430
|
+
"""
|
|
1431
|
+
return pulumi.get(self, "dictionary_value")
|
|
1432
|
+
|
|
1433
|
+
@dictionary_value.setter
|
|
1434
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
1435
|
+
pulumi.set(self, "dictionary_value", value)
|
|
1436
|
+
|
|
1437
|
+
@property
|
|
1438
|
+
@pulumi.getter
|
|
1439
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
1440
|
+
"""
|
|
1441
|
+
UUID for condition
|
|
1442
|
+
"""
|
|
1443
|
+
return pulumi.get(self, "id")
|
|
1444
|
+
|
|
1445
|
+
@id.setter
|
|
1446
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
1447
|
+
pulumi.set(self, "id", value)
|
|
1448
|
+
|
|
1449
|
+
@property
|
|
1450
|
+
@pulumi.getter(name="isNegate")
|
|
1451
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
1452
|
+
"""
|
|
1453
|
+
Indicates whereas this condition is in negate mode
|
|
1454
|
+
"""
|
|
1455
|
+
return pulumi.get(self, "is_negate")
|
|
1456
|
+
|
|
1457
|
+
@is_negate.setter
|
|
1458
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
1459
|
+
pulumi.set(self, "is_negate", value)
|
|
1460
|
+
|
|
1461
|
+
@property
|
|
1462
|
+
@pulumi.getter
|
|
1463
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
1464
|
+
"""
|
|
1465
|
+
Condition name
|
|
1466
|
+
"""
|
|
1467
|
+
return pulumi.get(self, "name")
|
|
1468
|
+
|
|
1469
|
+
@name.setter
|
|
1470
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
1471
|
+
pulumi.set(self, "name", value)
|
|
1472
|
+
|
|
1473
|
+
@property
|
|
1474
|
+
@pulumi.getter
|
|
1475
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1476
|
+
"""
|
|
1477
|
+
Equality operator
|
|
1478
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1479
|
+
"""
|
|
1480
|
+
return pulumi.get(self, "operator")
|
|
1481
|
+
|
|
1482
|
+
@operator.setter
|
|
1483
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1484
|
+
pulumi.set(self, "operator", value)
|
|
1485
|
+
|
|
1486
|
+
|
|
1487
|
+
@pulumi.input_type
|
|
1488
|
+
class ConditionChildrenChildrenArgs:
|
|
1489
|
+
def __init__(__self__, *,
|
|
1490
|
+
condition_type: pulumi.Input[str],
|
|
1491
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
1492
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
1493
|
+
description: Optional[pulumi.Input[str]] = None,
|
|
1494
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
1495
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
1496
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
1497
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
1498
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
1499
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
1500
|
+
"""
|
|
1501
|
+
:param pulumi.Input[str] condition_type: Condition type.
|
|
1502
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
1503
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
1504
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
1505
|
+
:param pulumi.Input[str] description: Condition description
|
|
1506
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
1507
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
1508
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
1509
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
1510
|
+
:param pulumi.Input[str] name: Condition name
|
|
1511
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
1512
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1513
|
+
"""
|
|
1514
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
1515
|
+
if attribute_name is not None:
|
|
1516
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
1517
|
+
if attribute_value is not None:
|
|
1518
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
1519
|
+
if description is not None:
|
|
1520
|
+
pulumi.set(__self__, "description", description)
|
|
1521
|
+
if dictionary_name is not None:
|
|
1522
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
1523
|
+
if dictionary_value is not None:
|
|
1524
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
1525
|
+
if id is not None:
|
|
1526
|
+
pulumi.set(__self__, "id", id)
|
|
1527
|
+
if is_negate is not None:
|
|
1528
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
1529
|
+
if name is not None:
|
|
1530
|
+
pulumi.set(__self__, "name", name)
|
|
1531
|
+
if operator is not None:
|
|
1532
|
+
pulumi.set(__self__, "operator", operator)
|
|
1533
|
+
|
|
1534
|
+
@property
|
|
1535
|
+
@pulumi.getter(name="conditionType")
|
|
1536
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
1537
|
+
"""
|
|
1538
|
+
Condition type.
|
|
1539
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
1540
|
+
"""
|
|
1541
|
+
return pulumi.get(self, "condition_type")
|
|
1542
|
+
|
|
1543
|
+
@condition_type.setter
|
|
1544
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
1545
|
+
pulumi.set(self, "condition_type", value)
|
|
1546
|
+
|
|
1547
|
+
@property
|
|
1548
|
+
@pulumi.getter(name="attributeName")
|
|
1549
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
1550
|
+
"""
|
|
1551
|
+
Dictionary attribute name
|
|
1552
|
+
"""
|
|
1553
|
+
return pulumi.get(self, "attribute_name")
|
|
1554
|
+
|
|
1555
|
+
@attribute_name.setter
|
|
1556
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
1557
|
+
pulumi.set(self, "attribute_name", value)
|
|
1558
|
+
|
|
1559
|
+
@property
|
|
1560
|
+
@pulumi.getter(name="attributeValue")
|
|
1561
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
1562
|
+
"""
|
|
1563
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
1564
|
+
"""
|
|
1565
|
+
return pulumi.get(self, "attribute_value")
|
|
1566
|
+
|
|
1567
|
+
@attribute_value.setter
|
|
1568
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
1569
|
+
pulumi.set(self, "attribute_value", value)
|
|
1570
|
+
|
|
1571
|
+
@property
|
|
1572
|
+
@pulumi.getter
|
|
1573
|
+
def description(self) -> Optional[pulumi.Input[str]]:
|
|
1574
|
+
"""
|
|
1575
|
+
Condition description
|
|
1576
|
+
"""
|
|
1577
|
+
return pulumi.get(self, "description")
|
|
1578
|
+
|
|
1579
|
+
@description.setter
|
|
1580
|
+
def description(self, value: Optional[pulumi.Input[str]]):
|
|
1581
|
+
pulumi.set(self, "description", value)
|
|
1582
|
+
|
|
1583
|
+
@property
|
|
1584
|
+
@pulumi.getter(name="dictionaryName")
|
|
1585
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
1586
|
+
"""
|
|
1587
|
+
Dictionary name
|
|
1588
|
+
"""
|
|
1589
|
+
return pulumi.get(self, "dictionary_name")
|
|
1590
|
+
|
|
1591
|
+
@dictionary_name.setter
|
|
1592
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
1593
|
+
pulumi.set(self, "dictionary_name", value)
|
|
1594
|
+
|
|
1595
|
+
@property
|
|
1596
|
+
@pulumi.getter(name="dictionaryValue")
|
|
1597
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
1598
|
+
"""
|
|
1599
|
+
Dictionary value
|
|
1600
|
+
"""
|
|
1601
|
+
return pulumi.get(self, "dictionary_value")
|
|
1602
|
+
|
|
1603
|
+
@dictionary_value.setter
|
|
1604
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
1605
|
+
pulumi.set(self, "dictionary_value", value)
|
|
1606
|
+
|
|
1607
|
+
@property
|
|
1608
|
+
@pulumi.getter
|
|
1609
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
1610
|
+
"""
|
|
1611
|
+
UUID for condition
|
|
1612
|
+
"""
|
|
1613
|
+
return pulumi.get(self, "id")
|
|
1614
|
+
|
|
1615
|
+
@id.setter
|
|
1616
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
1617
|
+
pulumi.set(self, "id", value)
|
|
1618
|
+
|
|
1619
|
+
@property
|
|
1620
|
+
@pulumi.getter(name="isNegate")
|
|
1621
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
1622
|
+
"""
|
|
1623
|
+
Indicates whereas this condition is in negate mode
|
|
1624
|
+
"""
|
|
1625
|
+
return pulumi.get(self, "is_negate")
|
|
1626
|
+
|
|
1627
|
+
@is_negate.setter
|
|
1628
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
1629
|
+
pulumi.set(self, "is_negate", value)
|
|
1630
|
+
|
|
1631
|
+
@property
|
|
1632
|
+
@pulumi.getter
|
|
1633
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
1634
|
+
"""
|
|
1635
|
+
Condition name
|
|
1636
|
+
"""
|
|
1637
|
+
return pulumi.get(self, "name")
|
|
1638
|
+
|
|
1639
|
+
@name.setter
|
|
1640
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
1641
|
+
pulumi.set(self, "name", value)
|
|
1642
|
+
|
|
1643
|
+
@property
|
|
1644
|
+
@pulumi.getter
|
|
1645
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1646
|
+
"""
|
|
1647
|
+
Equality operator
|
|
1648
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1649
|
+
"""
|
|
1650
|
+
return pulumi.get(self, "operator")
|
|
1651
|
+
|
|
1652
|
+
@operator.setter
|
|
1653
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1654
|
+
pulumi.set(self, "operator", value)
|
|
1655
|
+
|
|
1656
|
+
|
|
1657
|
+
@pulumi.input_type
|
|
1658
|
+
class PolicySetChildrenArgs:
|
|
1659
|
+
def __init__(__self__, *,
|
|
1660
|
+
condition_type: pulumi.Input[str],
|
|
1661
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
1662
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
1663
|
+
childrens: Optional[pulumi.Input[Sequence[pulumi.Input['PolicySetChildrenChildrenArgs']]]] = None,
|
|
1664
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
1665
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
1666
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
1667
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
1668
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
1669
|
+
"""
|
|
1670
|
+
:param pulumi.Input[str] condition_type: Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
1671
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
1672
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
1673
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
1674
|
+
:param pulumi.Input[Sequence[pulumi.Input['PolicySetChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
1675
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
1676
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
1677
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
1678
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
1679
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
1680
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1681
|
+
"""
|
|
1682
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
1683
|
+
if attribute_name is not None:
|
|
1684
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
1685
|
+
if attribute_value is not None:
|
|
1686
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
1687
|
+
if childrens is not None:
|
|
1688
|
+
pulumi.set(__self__, "childrens", childrens)
|
|
1689
|
+
if dictionary_name is not None:
|
|
1690
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
1691
|
+
if dictionary_value is not None:
|
|
1692
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
1693
|
+
if id is not None:
|
|
1694
|
+
pulumi.set(__self__, "id", id)
|
|
1695
|
+
if is_negate is not None:
|
|
1696
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
1697
|
+
if operator is not None:
|
|
1698
|
+
pulumi.set(__self__, "operator", operator)
|
|
1699
|
+
|
|
1700
|
+
@property
|
|
1701
|
+
@pulumi.getter(name="conditionType")
|
|
1702
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
1703
|
+
"""
|
|
1704
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
1705
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
1706
|
+
"""
|
|
1707
|
+
return pulumi.get(self, "condition_type")
|
|
1708
|
+
|
|
1709
|
+
@condition_type.setter
|
|
1710
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
1711
|
+
pulumi.set(self, "condition_type", value)
|
|
1712
|
+
|
|
1713
|
+
@property
|
|
1714
|
+
@pulumi.getter(name="attributeName")
|
|
1715
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
1716
|
+
"""
|
|
1717
|
+
Dictionary attribute name
|
|
1718
|
+
"""
|
|
1719
|
+
return pulumi.get(self, "attribute_name")
|
|
1720
|
+
|
|
1721
|
+
@attribute_name.setter
|
|
1722
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
1723
|
+
pulumi.set(self, "attribute_name", value)
|
|
1724
|
+
|
|
1725
|
+
@property
|
|
1726
|
+
@pulumi.getter(name="attributeValue")
|
|
1727
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
1728
|
+
"""
|
|
1729
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
1730
|
+
"""
|
|
1731
|
+
return pulumi.get(self, "attribute_value")
|
|
1732
|
+
|
|
1733
|
+
@attribute_value.setter
|
|
1734
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
1735
|
+
pulumi.set(self, "attribute_value", value)
|
|
1736
|
+
|
|
1737
|
+
@property
|
|
1738
|
+
@pulumi.getter
|
|
1739
|
+
def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PolicySetChildrenChildrenArgs']]]]:
|
|
1740
|
+
"""
|
|
1741
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
1742
|
+
"""
|
|
1743
|
+
return pulumi.get(self, "childrens")
|
|
1744
|
+
|
|
1745
|
+
@childrens.setter
|
|
1746
|
+
def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PolicySetChildrenChildrenArgs']]]]):
|
|
1747
|
+
pulumi.set(self, "childrens", value)
|
|
1748
|
+
|
|
1749
|
+
@property
|
|
1750
|
+
@pulumi.getter(name="dictionaryName")
|
|
1751
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
1752
|
+
"""
|
|
1753
|
+
Dictionary name
|
|
1754
|
+
"""
|
|
1755
|
+
return pulumi.get(self, "dictionary_name")
|
|
1756
|
+
|
|
1757
|
+
@dictionary_name.setter
|
|
1758
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
1759
|
+
pulumi.set(self, "dictionary_name", value)
|
|
1760
|
+
|
|
1761
|
+
@property
|
|
1762
|
+
@pulumi.getter(name="dictionaryValue")
|
|
1763
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
1764
|
+
"""
|
|
1765
|
+
Dictionary value
|
|
1766
|
+
"""
|
|
1767
|
+
return pulumi.get(self, "dictionary_value")
|
|
1768
|
+
|
|
1769
|
+
@dictionary_value.setter
|
|
1770
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
1771
|
+
pulumi.set(self, "dictionary_value", value)
|
|
1772
|
+
|
|
1773
|
+
@property
|
|
1774
|
+
@pulumi.getter
|
|
1775
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
1776
|
+
"""
|
|
1777
|
+
UUID for condition
|
|
1778
|
+
"""
|
|
1779
|
+
return pulumi.get(self, "id")
|
|
1780
|
+
|
|
1781
|
+
@id.setter
|
|
1782
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
1783
|
+
pulumi.set(self, "id", value)
|
|
1784
|
+
|
|
1785
|
+
@property
|
|
1786
|
+
@pulumi.getter(name="isNegate")
|
|
1787
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
1788
|
+
"""
|
|
1789
|
+
Indicates whereas this condition is in negate mode
|
|
1790
|
+
"""
|
|
1791
|
+
return pulumi.get(self, "is_negate")
|
|
1792
|
+
|
|
1793
|
+
@is_negate.setter
|
|
1794
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
1795
|
+
pulumi.set(self, "is_negate", value)
|
|
1796
|
+
|
|
1797
|
+
@property
|
|
1798
|
+
@pulumi.getter
|
|
1799
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1800
|
+
"""
|
|
1801
|
+
Equality operator
|
|
1802
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1803
|
+
"""
|
|
1804
|
+
return pulumi.get(self, "operator")
|
|
1805
|
+
|
|
1806
|
+
@operator.setter
|
|
1807
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1808
|
+
pulumi.set(self, "operator", value)
|
|
1809
|
+
|
|
1810
|
+
|
|
1811
|
+
@pulumi.input_type
|
|
1812
|
+
class PolicySetChildrenChildrenArgs:
|
|
1813
|
+
def __init__(__self__, *,
|
|
1814
|
+
condition_type: pulumi.Input[str],
|
|
1815
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
1816
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
1817
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
1818
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
1819
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
1820
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
1821
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
1822
|
+
"""
|
|
1823
|
+
:param pulumi.Input[str] condition_type: Condition type.
|
|
1824
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
1825
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
1826
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
1827
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
1828
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
1829
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
1830
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
1831
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
1832
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1833
|
+
"""
|
|
1834
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
1835
|
+
if attribute_name is not None:
|
|
1836
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
1837
|
+
if attribute_value is not None:
|
|
1838
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
1839
|
+
if dictionary_name is not None:
|
|
1840
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
1841
|
+
if dictionary_value is not None:
|
|
1842
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
1843
|
+
if id is not None:
|
|
1844
|
+
pulumi.set(__self__, "id", id)
|
|
1845
|
+
if is_negate is not None:
|
|
1846
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
1847
|
+
if operator is not None:
|
|
1848
|
+
pulumi.set(__self__, "operator", operator)
|
|
1849
|
+
|
|
1850
|
+
@property
|
|
1851
|
+
@pulumi.getter(name="conditionType")
|
|
1852
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
1853
|
+
"""
|
|
1854
|
+
Condition type.
|
|
1855
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
1856
|
+
"""
|
|
1857
|
+
return pulumi.get(self, "condition_type")
|
|
1858
|
+
|
|
1859
|
+
@condition_type.setter
|
|
1860
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
1861
|
+
pulumi.set(self, "condition_type", value)
|
|
1862
|
+
|
|
1863
|
+
@property
|
|
1864
|
+
@pulumi.getter(name="attributeName")
|
|
1865
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
1866
|
+
"""
|
|
1867
|
+
Dictionary attribute name
|
|
1868
|
+
"""
|
|
1869
|
+
return pulumi.get(self, "attribute_name")
|
|
1870
|
+
|
|
1871
|
+
@attribute_name.setter
|
|
1872
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
1873
|
+
pulumi.set(self, "attribute_name", value)
|
|
1874
|
+
|
|
1875
|
+
@property
|
|
1876
|
+
@pulumi.getter(name="attributeValue")
|
|
1877
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
1878
|
+
"""
|
|
1879
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
1880
|
+
"""
|
|
1881
|
+
return pulumi.get(self, "attribute_value")
|
|
1882
|
+
|
|
1883
|
+
@attribute_value.setter
|
|
1884
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
1885
|
+
pulumi.set(self, "attribute_value", value)
|
|
1886
|
+
|
|
1887
|
+
@property
|
|
1888
|
+
@pulumi.getter(name="dictionaryName")
|
|
1889
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
1890
|
+
"""
|
|
1891
|
+
Dictionary name
|
|
1892
|
+
"""
|
|
1893
|
+
return pulumi.get(self, "dictionary_name")
|
|
1894
|
+
|
|
1895
|
+
@dictionary_name.setter
|
|
1896
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
1897
|
+
pulumi.set(self, "dictionary_name", value)
|
|
1898
|
+
|
|
1899
|
+
@property
|
|
1900
|
+
@pulumi.getter(name="dictionaryValue")
|
|
1901
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
1902
|
+
"""
|
|
1903
|
+
Dictionary value
|
|
1904
|
+
"""
|
|
1905
|
+
return pulumi.get(self, "dictionary_value")
|
|
1906
|
+
|
|
1907
|
+
@dictionary_value.setter
|
|
1908
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
1909
|
+
pulumi.set(self, "dictionary_value", value)
|
|
1910
|
+
|
|
1911
|
+
@property
|
|
1912
|
+
@pulumi.getter
|
|
1913
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
1914
|
+
"""
|
|
1915
|
+
UUID for condition
|
|
1916
|
+
"""
|
|
1917
|
+
return pulumi.get(self, "id")
|
|
1918
|
+
|
|
1919
|
+
@id.setter
|
|
1920
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
1921
|
+
pulumi.set(self, "id", value)
|
|
1922
|
+
|
|
1923
|
+
@property
|
|
1924
|
+
@pulumi.getter(name="isNegate")
|
|
1925
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
1926
|
+
"""
|
|
1927
|
+
Indicates whereas this condition is in negate mode
|
|
1928
|
+
"""
|
|
1929
|
+
return pulumi.get(self, "is_negate")
|
|
1930
|
+
|
|
1931
|
+
@is_negate.setter
|
|
1932
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
1933
|
+
pulumi.set(self, "is_negate", value)
|
|
1934
|
+
|
|
1935
|
+
@property
|
|
1936
|
+
@pulumi.getter
|
|
1937
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1938
|
+
"""
|
|
1939
|
+
Equality operator
|
|
1940
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1941
|
+
"""
|
|
1942
|
+
return pulumi.get(self, "operator")
|
|
1943
|
+
|
|
1944
|
+
@operator.setter
|
|
1945
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1946
|
+
pulumi.set(self, "operator", value)
|
|
1947
|
+
|
|
1948
|
+
|