pulumi-ise 0.2.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 +458 -0
- pulumi_ise/_utilities.py +327 -0
- pulumi_ise/config/__init__.py +8 -0
- pulumi_ise/config/__init__.pyi +41 -0
- pulumi_ise/config/vars.py +57 -0
- pulumi_ise/deviceadmin/__init__.py +34 -0
- pulumi_ise/deviceadmin/_inputs.py +2517 -0
- pulumi_ise/deviceadmin/allowed_protocols_tacacs.py +381 -0
- pulumi_ise/deviceadmin/authentication_rule.py +1050 -0
- pulumi_ise/deviceadmin/authentication_rule_update_rank.py +271 -0
- pulumi_ise/deviceadmin/authorization_exception_rule.py +942 -0
- pulumi_ise/deviceadmin/authorization_exception_rule_update_rank.py +271 -0
- pulumi_ise/deviceadmin/authorization_global_exception_rule.py +843 -0
- pulumi_ise/deviceadmin/authorization_global_exception_rule_update_rank.py +221 -0
- pulumi_ise/deviceadmin/authorization_rule.py +942 -0
- pulumi_ise/deviceadmin/authorization_rule_update_rank.py +271 -0
- pulumi_ise/deviceadmin/condition.py +650 -0
- pulumi_ise/deviceadmin/get_allowed_protocols_tacacs.py +174 -0
- pulumi_ise/deviceadmin/get_authentication_rule.py +365 -0
- pulumi_ise/deviceadmin/get_authorization_exception_rule.py +337 -0
- pulumi_ise/deviceadmin/get_authorization_global_exception_rule.py +301 -0
- pulumi_ise/deviceadmin/get_authorization_rule.py +337 -0
- pulumi_ise/deviceadmin/get_condition.py +245 -0
- pulumi_ise/deviceadmin/get_policy_set.py +329 -0
- pulumi_ise/deviceadmin/get_tacacs_command_set.py +158 -0
- pulumi_ise/deviceadmin/get_tacacs_profile.py +144 -0
- pulumi_ise/deviceadmin/get_time_and_date_condition.py +286 -0
- pulumi_ise/deviceadmin/outputs.py +3178 -0
- pulumi_ise/deviceadmin/policy_set.py +947 -0
- pulumi_ise/deviceadmin/policy_set_update_rank.py +221 -0
- pulumi_ise/deviceadmin/tacacs_command_set.py +326 -0
- pulumi_ise/deviceadmin/tacacs_profile.py +277 -0
- pulumi_ise/deviceadmin/time_and_date_condition.py +770 -0
- pulumi_ise/identitymanagement/__init__.py +26 -0
- pulumi_ise/identitymanagement/_inputs.py +419 -0
- pulumi_ise/identitymanagement/active_directory_add_groups.py +483 -0
- pulumi_ise/identitymanagement/active_directory_join_domain_with_all_nodes.py +216 -0
- pulumi_ise/identitymanagement/active_directory_join_point.py +1676 -0
- pulumi_ise/identitymanagement/certificate_authentication_profile.py +525 -0
- pulumi_ise/identitymanagement/endpoint.py +1376 -0
- pulumi_ise/identitymanagement/endpoint_identity_group.py +327 -0
- pulumi_ise/identitymanagement/get_active_directory_groups_by_domain.py +215 -0
- pulumi_ise/identitymanagement/get_active_directory_join_point.py +558 -0
- pulumi_ise/identitymanagement/get_certificate_authentication_profile.py +202 -0
- pulumi_ise/identitymanagement/get_endpoint.py +468 -0
- pulumi_ise/identitymanagement/get_endpoint_identity_group.py +160 -0
- pulumi_ise/identitymanagement/get_identity_source_sequence.py +172 -0
- pulumi_ise/identitymanagement/get_internal_user.py +300 -0
- pulumi_ise/identitymanagement/get_user_identity_group.py +146 -0
- pulumi_ise/identitymanagement/identity_source_sequence.py +376 -0
- pulumi_ise/identitymanagement/internal_user.py +830 -0
- pulumi_ise/identitymanagement/outputs.py +491 -0
- pulumi_ise/identitymanagement/user_identity_group.py +280 -0
- pulumi_ise/network/__init__.py +13 -0
- pulumi_ise/network/_inputs.py +94 -0
- pulumi_ise/network/device.py +2194 -0
- pulumi_ise/network/device_group.py +281 -0
- pulumi_ise/network/get_device.py +693 -0
- pulumi_ise/network/get_device_group.py +146 -0
- pulumi_ise/network/outputs.py +120 -0
- pulumi_ise/networkaccess/__init__.py +36 -0
- pulumi_ise/networkaccess/_inputs.py +2506 -0
- pulumi_ise/networkaccess/allowed_protocols.py +3967 -0
- pulumi_ise/networkaccess/authentication_rule.py +1050 -0
- pulumi_ise/networkaccess/authentication_rule_update_rank.py +271 -0
- pulumi_ise/networkaccess/authorization_exception_rule.py +942 -0
- pulumi_ise/networkaccess/authorization_exception_rule_update_rank.py +271 -0
- pulumi_ise/networkaccess/authorization_global_exception_rule.py +843 -0
- pulumi_ise/networkaccess/authorization_global_exception_rule_update_rank.py +221 -0
- pulumi_ise/networkaccess/authorization_profile.py +1682 -0
- pulumi_ise/networkaccess/authorization_rule.py +942 -0
- pulumi_ise/networkaccess/authorization_rule_update_rank.py +271 -0
- pulumi_ise/networkaccess/condition.py +650 -0
- pulumi_ise/networkaccess/dictionary.py +331 -0
- pulumi_ise/networkaccess/downloadable_acl.py +330 -0
- pulumi_ise/networkaccess/get_allowed_protocols.py +1182 -0
- pulumi_ise/networkaccess/get_authentication_rule.py +365 -0
- pulumi_ise/networkaccess/get_authorization_exception_rule.py +337 -0
- pulumi_ise/networkaccess/get_authorization_global_exception_rule.py +301 -0
- pulumi_ise/networkaccess/get_authorization_profile.py +567 -0
- pulumi_ise/networkaccess/get_authorization_rule.py +337 -0
- pulumi_ise/networkaccess/get_condition.py +245 -0
- pulumi_ise/networkaccess/get_dictionary.py +160 -0
- pulumi_ise/networkaccess/get_downloadable_acl.py +160 -0
- pulumi_ise/networkaccess/get_policy_set.py +329 -0
- pulumi_ise/networkaccess/get_time_and_date_condition.py +286 -0
- pulumi_ise/networkaccess/outputs.py +3193 -0
- pulumi_ise/networkaccess/policy_set.py +947 -0
- pulumi_ise/networkaccess/policy_set_update_rank.py +221 -0
- pulumi_ise/networkaccess/time_and_date_condition.py +770 -0
- pulumi_ise/provider.py +209 -0
- pulumi_ise/pulumi-plugin.json +5 -0
- pulumi_ise/py.typed +0 -0
- pulumi_ise/system/__init__.py +13 -0
- pulumi_ise/system/_inputs.py +79 -0
- pulumi_ise/system/get_license_tier_state.py +113 -0
- pulumi_ise/system/get_repository.py +202 -0
- pulumi_ise/system/license_tier_state.py +189 -0
- pulumi_ise/system/outputs.py +83 -0
- pulumi_ise/system/repository.py +478 -0
- pulumi_ise/trustsec/__init__.py +21 -0
- pulumi_ise/trustsec/egress_matrix_cell.py +429 -0
- pulumi_ise/trustsec/egress_matrix_cell_default.py +327 -0
- pulumi_ise/trustsec/get_egress_matrix_cell.py +182 -0
- pulumi_ise/trustsec/get_egress_matrix_cell_default.py +154 -0
- pulumi_ise/trustsec/get_ip_to_sgt_mapping.py +216 -0
- pulumi_ise/trustsec/get_ip_to_sgt_mapping_group.py +174 -0
- pulumi_ise/trustsec/get_security_group.py +174 -0
- pulumi_ise/trustsec/get_security_group_acl.py +174 -0
- pulumi_ise/trustsec/get_sxp_domain_filter.py +188 -0
- pulumi_ise/trustsec/ip_to_sgt_mapping.py +517 -0
- pulumi_ise/trustsec/ip_to_sgt_mapping_group.py +376 -0
- pulumi_ise/trustsec/security_group.py +379 -0
- pulumi_ise/trustsec/security_group_acl.py +379 -0
- pulumi_ise/trustsec/sxp_domain_filter.py +422 -0
- pulumi_ise-0.2.0.dist-info/METADATA +64 -0
- pulumi_ise-0.2.0.dist-info/RECORD +119 -0
- pulumi_ise-0.2.0.dist-info/WHEEL +5 -0
- pulumi_ise-0.2.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,2506 @@
|
|
|
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 sys
|
|
8
|
+
import pulumi
|
|
9
|
+
import pulumi.runtime
|
|
10
|
+
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
15
|
+
from .. import _utilities
|
|
16
|
+
|
|
17
|
+
__all__ = [
|
|
18
|
+
'AuthenticationRuleChildrenArgs',
|
|
19
|
+
'AuthenticationRuleChildrenArgsDict',
|
|
20
|
+
'AuthenticationRuleChildrenChildrenArgs',
|
|
21
|
+
'AuthenticationRuleChildrenChildrenArgsDict',
|
|
22
|
+
'AuthorizationExceptionRuleChildrenArgs',
|
|
23
|
+
'AuthorizationExceptionRuleChildrenArgsDict',
|
|
24
|
+
'AuthorizationExceptionRuleChildrenChildrenArgs',
|
|
25
|
+
'AuthorizationExceptionRuleChildrenChildrenArgsDict',
|
|
26
|
+
'AuthorizationGlobalExceptionRuleChildrenArgs',
|
|
27
|
+
'AuthorizationGlobalExceptionRuleChildrenArgsDict',
|
|
28
|
+
'AuthorizationGlobalExceptionRuleChildrenChildrenArgs',
|
|
29
|
+
'AuthorizationGlobalExceptionRuleChildrenChildrenArgsDict',
|
|
30
|
+
'AuthorizationProfileAdvancedAttributeArgs',
|
|
31
|
+
'AuthorizationProfileAdvancedAttributeArgsDict',
|
|
32
|
+
'AuthorizationRuleChildrenArgs',
|
|
33
|
+
'AuthorizationRuleChildrenArgsDict',
|
|
34
|
+
'AuthorizationRuleChildrenChildrenArgs',
|
|
35
|
+
'AuthorizationRuleChildrenChildrenArgsDict',
|
|
36
|
+
'ConditionChildrenArgs',
|
|
37
|
+
'ConditionChildrenArgsDict',
|
|
38
|
+
'ConditionChildrenChildrenArgs',
|
|
39
|
+
'ConditionChildrenChildrenArgsDict',
|
|
40
|
+
'PolicySetChildrenArgs',
|
|
41
|
+
'PolicySetChildrenArgsDict',
|
|
42
|
+
'PolicySetChildrenChildrenArgs',
|
|
43
|
+
'PolicySetChildrenChildrenArgsDict',
|
|
44
|
+
]
|
|
45
|
+
|
|
46
|
+
MYPY = False
|
|
47
|
+
|
|
48
|
+
if not MYPY:
|
|
49
|
+
class AuthenticationRuleChildrenArgsDict(TypedDict):
|
|
50
|
+
condition_type: pulumi.Input[str]
|
|
51
|
+
"""
|
|
52
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
53
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
54
|
+
"""
|
|
55
|
+
attribute_name: NotRequired[pulumi.Input[str]]
|
|
56
|
+
"""
|
|
57
|
+
Dictionary attribute name
|
|
58
|
+
"""
|
|
59
|
+
attribute_value: NotRequired[pulumi.Input[str]]
|
|
60
|
+
"""
|
|
61
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
62
|
+
"""
|
|
63
|
+
childrens: NotRequired[pulumi.Input[Sequence[pulumi.Input['AuthenticationRuleChildrenChildrenArgsDict']]]]
|
|
64
|
+
"""
|
|
65
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
66
|
+
"""
|
|
67
|
+
dictionary_name: NotRequired[pulumi.Input[str]]
|
|
68
|
+
"""
|
|
69
|
+
Dictionary name
|
|
70
|
+
"""
|
|
71
|
+
dictionary_value: NotRequired[pulumi.Input[str]]
|
|
72
|
+
"""
|
|
73
|
+
Dictionary value
|
|
74
|
+
"""
|
|
75
|
+
id: NotRequired[pulumi.Input[str]]
|
|
76
|
+
"""
|
|
77
|
+
UUID for condition
|
|
78
|
+
"""
|
|
79
|
+
is_negate: NotRequired[pulumi.Input[bool]]
|
|
80
|
+
"""
|
|
81
|
+
Indicates whereas this condition is in negate mode
|
|
82
|
+
"""
|
|
83
|
+
operator: NotRequired[pulumi.Input[str]]
|
|
84
|
+
"""
|
|
85
|
+
Equality operator
|
|
86
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
87
|
+
"""
|
|
88
|
+
elif False:
|
|
89
|
+
AuthenticationRuleChildrenArgsDict: TypeAlias = Mapping[str, Any]
|
|
90
|
+
|
|
91
|
+
@pulumi.input_type
|
|
92
|
+
class AuthenticationRuleChildrenArgs:
|
|
93
|
+
def __init__(__self__, *,
|
|
94
|
+
condition_type: pulumi.Input[str],
|
|
95
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
96
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
97
|
+
childrens: Optional[pulumi.Input[Sequence[pulumi.Input['AuthenticationRuleChildrenChildrenArgs']]]] = None,
|
|
98
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
99
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
100
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
101
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
102
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
103
|
+
"""
|
|
104
|
+
: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.
|
|
105
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
106
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
107
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
108
|
+
:param pulumi.Input[Sequence[pulumi.Input['AuthenticationRuleChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
109
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
110
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
111
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
112
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
113
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
114
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
115
|
+
"""
|
|
116
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
117
|
+
if attribute_name is not None:
|
|
118
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
119
|
+
if attribute_value is not None:
|
|
120
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
121
|
+
if childrens is not None:
|
|
122
|
+
pulumi.set(__self__, "childrens", childrens)
|
|
123
|
+
if dictionary_name is not None:
|
|
124
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
125
|
+
if dictionary_value is not None:
|
|
126
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
127
|
+
if id is not None:
|
|
128
|
+
pulumi.set(__self__, "id", id)
|
|
129
|
+
if is_negate is not None:
|
|
130
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
131
|
+
if operator is not None:
|
|
132
|
+
pulumi.set(__self__, "operator", operator)
|
|
133
|
+
|
|
134
|
+
@property
|
|
135
|
+
@pulumi.getter(name="conditionType")
|
|
136
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
137
|
+
"""
|
|
138
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
139
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
140
|
+
"""
|
|
141
|
+
return pulumi.get(self, "condition_type")
|
|
142
|
+
|
|
143
|
+
@condition_type.setter
|
|
144
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
145
|
+
pulumi.set(self, "condition_type", value)
|
|
146
|
+
|
|
147
|
+
@property
|
|
148
|
+
@pulumi.getter(name="attributeName")
|
|
149
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
150
|
+
"""
|
|
151
|
+
Dictionary attribute name
|
|
152
|
+
"""
|
|
153
|
+
return pulumi.get(self, "attribute_name")
|
|
154
|
+
|
|
155
|
+
@attribute_name.setter
|
|
156
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
157
|
+
pulumi.set(self, "attribute_name", value)
|
|
158
|
+
|
|
159
|
+
@property
|
|
160
|
+
@pulumi.getter(name="attributeValue")
|
|
161
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
162
|
+
"""
|
|
163
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
164
|
+
"""
|
|
165
|
+
return pulumi.get(self, "attribute_value")
|
|
166
|
+
|
|
167
|
+
@attribute_value.setter
|
|
168
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
169
|
+
pulumi.set(self, "attribute_value", value)
|
|
170
|
+
|
|
171
|
+
@property
|
|
172
|
+
@pulumi.getter
|
|
173
|
+
def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AuthenticationRuleChildrenChildrenArgs']]]]:
|
|
174
|
+
"""
|
|
175
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
176
|
+
"""
|
|
177
|
+
return pulumi.get(self, "childrens")
|
|
178
|
+
|
|
179
|
+
@childrens.setter
|
|
180
|
+
def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AuthenticationRuleChildrenChildrenArgs']]]]):
|
|
181
|
+
pulumi.set(self, "childrens", value)
|
|
182
|
+
|
|
183
|
+
@property
|
|
184
|
+
@pulumi.getter(name="dictionaryName")
|
|
185
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
186
|
+
"""
|
|
187
|
+
Dictionary name
|
|
188
|
+
"""
|
|
189
|
+
return pulumi.get(self, "dictionary_name")
|
|
190
|
+
|
|
191
|
+
@dictionary_name.setter
|
|
192
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
193
|
+
pulumi.set(self, "dictionary_name", value)
|
|
194
|
+
|
|
195
|
+
@property
|
|
196
|
+
@pulumi.getter(name="dictionaryValue")
|
|
197
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
198
|
+
"""
|
|
199
|
+
Dictionary value
|
|
200
|
+
"""
|
|
201
|
+
return pulumi.get(self, "dictionary_value")
|
|
202
|
+
|
|
203
|
+
@dictionary_value.setter
|
|
204
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
205
|
+
pulumi.set(self, "dictionary_value", value)
|
|
206
|
+
|
|
207
|
+
@property
|
|
208
|
+
@pulumi.getter
|
|
209
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
210
|
+
"""
|
|
211
|
+
UUID for condition
|
|
212
|
+
"""
|
|
213
|
+
return pulumi.get(self, "id")
|
|
214
|
+
|
|
215
|
+
@id.setter
|
|
216
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
217
|
+
pulumi.set(self, "id", value)
|
|
218
|
+
|
|
219
|
+
@property
|
|
220
|
+
@pulumi.getter(name="isNegate")
|
|
221
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
222
|
+
"""
|
|
223
|
+
Indicates whereas this condition is in negate mode
|
|
224
|
+
"""
|
|
225
|
+
return pulumi.get(self, "is_negate")
|
|
226
|
+
|
|
227
|
+
@is_negate.setter
|
|
228
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
229
|
+
pulumi.set(self, "is_negate", value)
|
|
230
|
+
|
|
231
|
+
@property
|
|
232
|
+
@pulumi.getter
|
|
233
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
234
|
+
"""
|
|
235
|
+
Equality operator
|
|
236
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
237
|
+
"""
|
|
238
|
+
return pulumi.get(self, "operator")
|
|
239
|
+
|
|
240
|
+
@operator.setter
|
|
241
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
242
|
+
pulumi.set(self, "operator", value)
|
|
243
|
+
|
|
244
|
+
|
|
245
|
+
if not MYPY:
|
|
246
|
+
class AuthenticationRuleChildrenChildrenArgsDict(TypedDict):
|
|
247
|
+
condition_type: pulumi.Input[str]
|
|
248
|
+
"""
|
|
249
|
+
Condition type.
|
|
250
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
251
|
+
"""
|
|
252
|
+
attribute_name: NotRequired[pulumi.Input[str]]
|
|
253
|
+
"""
|
|
254
|
+
Dictionary attribute name
|
|
255
|
+
"""
|
|
256
|
+
attribute_value: NotRequired[pulumi.Input[str]]
|
|
257
|
+
"""
|
|
258
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
259
|
+
"""
|
|
260
|
+
dictionary_name: NotRequired[pulumi.Input[str]]
|
|
261
|
+
"""
|
|
262
|
+
Dictionary name
|
|
263
|
+
"""
|
|
264
|
+
dictionary_value: NotRequired[pulumi.Input[str]]
|
|
265
|
+
"""
|
|
266
|
+
Dictionary value
|
|
267
|
+
"""
|
|
268
|
+
id: NotRequired[pulumi.Input[str]]
|
|
269
|
+
"""
|
|
270
|
+
UUID for condition
|
|
271
|
+
"""
|
|
272
|
+
is_negate: NotRequired[pulumi.Input[bool]]
|
|
273
|
+
"""
|
|
274
|
+
Indicates whereas this condition is in negate mode
|
|
275
|
+
"""
|
|
276
|
+
operator: NotRequired[pulumi.Input[str]]
|
|
277
|
+
"""
|
|
278
|
+
Equality operator
|
|
279
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
280
|
+
"""
|
|
281
|
+
elif False:
|
|
282
|
+
AuthenticationRuleChildrenChildrenArgsDict: TypeAlias = Mapping[str, Any]
|
|
283
|
+
|
|
284
|
+
@pulumi.input_type
|
|
285
|
+
class AuthenticationRuleChildrenChildrenArgs:
|
|
286
|
+
def __init__(__self__, *,
|
|
287
|
+
condition_type: pulumi.Input[str],
|
|
288
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
289
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
290
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
291
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
292
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
293
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
294
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
295
|
+
"""
|
|
296
|
+
:param pulumi.Input[str] condition_type: Condition type.
|
|
297
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
298
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
299
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
300
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
301
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
302
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
303
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
304
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
305
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
306
|
+
"""
|
|
307
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
308
|
+
if attribute_name is not None:
|
|
309
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
310
|
+
if attribute_value is not None:
|
|
311
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
312
|
+
if dictionary_name is not None:
|
|
313
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
314
|
+
if dictionary_value is not None:
|
|
315
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
316
|
+
if id is not None:
|
|
317
|
+
pulumi.set(__self__, "id", id)
|
|
318
|
+
if is_negate is not None:
|
|
319
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
320
|
+
if operator is not None:
|
|
321
|
+
pulumi.set(__self__, "operator", operator)
|
|
322
|
+
|
|
323
|
+
@property
|
|
324
|
+
@pulumi.getter(name="conditionType")
|
|
325
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
326
|
+
"""
|
|
327
|
+
Condition type.
|
|
328
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
329
|
+
"""
|
|
330
|
+
return pulumi.get(self, "condition_type")
|
|
331
|
+
|
|
332
|
+
@condition_type.setter
|
|
333
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
334
|
+
pulumi.set(self, "condition_type", value)
|
|
335
|
+
|
|
336
|
+
@property
|
|
337
|
+
@pulumi.getter(name="attributeName")
|
|
338
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
339
|
+
"""
|
|
340
|
+
Dictionary attribute name
|
|
341
|
+
"""
|
|
342
|
+
return pulumi.get(self, "attribute_name")
|
|
343
|
+
|
|
344
|
+
@attribute_name.setter
|
|
345
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
346
|
+
pulumi.set(self, "attribute_name", value)
|
|
347
|
+
|
|
348
|
+
@property
|
|
349
|
+
@pulumi.getter(name="attributeValue")
|
|
350
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
351
|
+
"""
|
|
352
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
353
|
+
"""
|
|
354
|
+
return pulumi.get(self, "attribute_value")
|
|
355
|
+
|
|
356
|
+
@attribute_value.setter
|
|
357
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
358
|
+
pulumi.set(self, "attribute_value", value)
|
|
359
|
+
|
|
360
|
+
@property
|
|
361
|
+
@pulumi.getter(name="dictionaryName")
|
|
362
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
363
|
+
"""
|
|
364
|
+
Dictionary name
|
|
365
|
+
"""
|
|
366
|
+
return pulumi.get(self, "dictionary_name")
|
|
367
|
+
|
|
368
|
+
@dictionary_name.setter
|
|
369
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
370
|
+
pulumi.set(self, "dictionary_name", value)
|
|
371
|
+
|
|
372
|
+
@property
|
|
373
|
+
@pulumi.getter(name="dictionaryValue")
|
|
374
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
375
|
+
"""
|
|
376
|
+
Dictionary value
|
|
377
|
+
"""
|
|
378
|
+
return pulumi.get(self, "dictionary_value")
|
|
379
|
+
|
|
380
|
+
@dictionary_value.setter
|
|
381
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
382
|
+
pulumi.set(self, "dictionary_value", value)
|
|
383
|
+
|
|
384
|
+
@property
|
|
385
|
+
@pulumi.getter
|
|
386
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
387
|
+
"""
|
|
388
|
+
UUID for condition
|
|
389
|
+
"""
|
|
390
|
+
return pulumi.get(self, "id")
|
|
391
|
+
|
|
392
|
+
@id.setter
|
|
393
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
394
|
+
pulumi.set(self, "id", value)
|
|
395
|
+
|
|
396
|
+
@property
|
|
397
|
+
@pulumi.getter(name="isNegate")
|
|
398
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
399
|
+
"""
|
|
400
|
+
Indicates whereas this condition is in negate mode
|
|
401
|
+
"""
|
|
402
|
+
return pulumi.get(self, "is_negate")
|
|
403
|
+
|
|
404
|
+
@is_negate.setter
|
|
405
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
406
|
+
pulumi.set(self, "is_negate", value)
|
|
407
|
+
|
|
408
|
+
@property
|
|
409
|
+
@pulumi.getter
|
|
410
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
411
|
+
"""
|
|
412
|
+
Equality operator
|
|
413
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
414
|
+
"""
|
|
415
|
+
return pulumi.get(self, "operator")
|
|
416
|
+
|
|
417
|
+
@operator.setter
|
|
418
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
419
|
+
pulumi.set(self, "operator", value)
|
|
420
|
+
|
|
421
|
+
|
|
422
|
+
if not MYPY:
|
|
423
|
+
class AuthorizationExceptionRuleChildrenArgsDict(TypedDict):
|
|
424
|
+
condition_type: pulumi.Input[str]
|
|
425
|
+
"""
|
|
426
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
427
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
428
|
+
"""
|
|
429
|
+
attribute_name: NotRequired[pulumi.Input[str]]
|
|
430
|
+
"""
|
|
431
|
+
Dictionary attribute name
|
|
432
|
+
"""
|
|
433
|
+
attribute_value: NotRequired[pulumi.Input[str]]
|
|
434
|
+
"""
|
|
435
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
436
|
+
"""
|
|
437
|
+
childrens: NotRequired[pulumi.Input[Sequence[pulumi.Input['AuthorizationExceptionRuleChildrenChildrenArgsDict']]]]
|
|
438
|
+
"""
|
|
439
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
440
|
+
"""
|
|
441
|
+
dictionary_name: NotRequired[pulumi.Input[str]]
|
|
442
|
+
"""
|
|
443
|
+
Dictionary name
|
|
444
|
+
"""
|
|
445
|
+
dictionary_value: NotRequired[pulumi.Input[str]]
|
|
446
|
+
"""
|
|
447
|
+
Dictionary value
|
|
448
|
+
"""
|
|
449
|
+
id: NotRequired[pulumi.Input[str]]
|
|
450
|
+
"""
|
|
451
|
+
UUID for condition
|
|
452
|
+
"""
|
|
453
|
+
is_negate: NotRequired[pulumi.Input[bool]]
|
|
454
|
+
"""
|
|
455
|
+
Indicates whereas this condition is in negate mode
|
|
456
|
+
"""
|
|
457
|
+
operator: NotRequired[pulumi.Input[str]]
|
|
458
|
+
"""
|
|
459
|
+
Equality operator
|
|
460
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
461
|
+
"""
|
|
462
|
+
elif False:
|
|
463
|
+
AuthorizationExceptionRuleChildrenArgsDict: TypeAlias = Mapping[str, Any]
|
|
464
|
+
|
|
465
|
+
@pulumi.input_type
|
|
466
|
+
class AuthorizationExceptionRuleChildrenArgs:
|
|
467
|
+
def __init__(__self__, *,
|
|
468
|
+
condition_type: pulumi.Input[str],
|
|
469
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
470
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
471
|
+
childrens: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationExceptionRuleChildrenChildrenArgs']]]] = None,
|
|
472
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
473
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
474
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
475
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
476
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
477
|
+
"""
|
|
478
|
+
: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.
|
|
479
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
480
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
481
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
482
|
+
:param pulumi.Input[Sequence[pulumi.Input['AuthorizationExceptionRuleChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
483
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
484
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
485
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
486
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
487
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
488
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
489
|
+
"""
|
|
490
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
491
|
+
if attribute_name is not None:
|
|
492
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
493
|
+
if attribute_value is not None:
|
|
494
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
495
|
+
if childrens is not None:
|
|
496
|
+
pulumi.set(__self__, "childrens", childrens)
|
|
497
|
+
if dictionary_name is not None:
|
|
498
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
499
|
+
if dictionary_value is not None:
|
|
500
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
501
|
+
if id is not None:
|
|
502
|
+
pulumi.set(__self__, "id", id)
|
|
503
|
+
if is_negate is not None:
|
|
504
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
505
|
+
if operator is not None:
|
|
506
|
+
pulumi.set(__self__, "operator", operator)
|
|
507
|
+
|
|
508
|
+
@property
|
|
509
|
+
@pulumi.getter(name="conditionType")
|
|
510
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
511
|
+
"""
|
|
512
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
513
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
514
|
+
"""
|
|
515
|
+
return pulumi.get(self, "condition_type")
|
|
516
|
+
|
|
517
|
+
@condition_type.setter
|
|
518
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
519
|
+
pulumi.set(self, "condition_type", value)
|
|
520
|
+
|
|
521
|
+
@property
|
|
522
|
+
@pulumi.getter(name="attributeName")
|
|
523
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
524
|
+
"""
|
|
525
|
+
Dictionary attribute name
|
|
526
|
+
"""
|
|
527
|
+
return pulumi.get(self, "attribute_name")
|
|
528
|
+
|
|
529
|
+
@attribute_name.setter
|
|
530
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
531
|
+
pulumi.set(self, "attribute_name", value)
|
|
532
|
+
|
|
533
|
+
@property
|
|
534
|
+
@pulumi.getter(name="attributeValue")
|
|
535
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
536
|
+
"""
|
|
537
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
538
|
+
"""
|
|
539
|
+
return pulumi.get(self, "attribute_value")
|
|
540
|
+
|
|
541
|
+
@attribute_value.setter
|
|
542
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
543
|
+
pulumi.set(self, "attribute_value", value)
|
|
544
|
+
|
|
545
|
+
@property
|
|
546
|
+
@pulumi.getter
|
|
547
|
+
def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationExceptionRuleChildrenChildrenArgs']]]]:
|
|
548
|
+
"""
|
|
549
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
550
|
+
"""
|
|
551
|
+
return pulumi.get(self, "childrens")
|
|
552
|
+
|
|
553
|
+
@childrens.setter
|
|
554
|
+
def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationExceptionRuleChildrenChildrenArgs']]]]):
|
|
555
|
+
pulumi.set(self, "childrens", value)
|
|
556
|
+
|
|
557
|
+
@property
|
|
558
|
+
@pulumi.getter(name="dictionaryName")
|
|
559
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
560
|
+
"""
|
|
561
|
+
Dictionary name
|
|
562
|
+
"""
|
|
563
|
+
return pulumi.get(self, "dictionary_name")
|
|
564
|
+
|
|
565
|
+
@dictionary_name.setter
|
|
566
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
567
|
+
pulumi.set(self, "dictionary_name", value)
|
|
568
|
+
|
|
569
|
+
@property
|
|
570
|
+
@pulumi.getter(name="dictionaryValue")
|
|
571
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
572
|
+
"""
|
|
573
|
+
Dictionary value
|
|
574
|
+
"""
|
|
575
|
+
return pulumi.get(self, "dictionary_value")
|
|
576
|
+
|
|
577
|
+
@dictionary_value.setter
|
|
578
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
579
|
+
pulumi.set(self, "dictionary_value", value)
|
|
580
|
+
|
|
581
|
+
@property
|
|
582
|
+
@pulumi.getter
|
|
583
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
584
|
+
"""
|
|
585
|
+
UUID for condition
|
|
586
|
+
"""
|
|
587
|
+
return pulumi.get(self, "id")
|
|
588
|
+
|
|
589
|
+
@id.setter
|
|
590
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
591
|
+
pulumi.set(self, "id", value)
|
|
592
|
+
|
|
593
|
+
@property
|
|
594
|
+
@pulumi.getter(name="isNegate")
|
|
595
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
596
|
+
"""
|
|
597
|
+
Indicates whereas this condition is in negate mode
|
|
598
|
+
"""
|
|
599
|
+
return pulumi.get(self, "is_negate")
|
|
600
|
+
|
|
601
|
+
@is_negate.setter
|
|
602
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
603
|
+
pulumi.set(self, "is_negate", value)
|
|
604
|
+
|
|
605
|
+
@property
|
|
606
|
+
@pulumi.getter
|
|
607
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
608
|
+
"""
|
|
609
|
+
Equality operator
|
|
610
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
611
|
+
"""
|
|
612
|
+
return pulumi.get(self, "operator")
|
|
613
|
+
|
|
614
|
+
@operator.setter
|
|
615
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
616
|
+
pulumi.set(self, "operator", value)
|
|
617
|
+
|
|
618
|
+
|
|
619
|
+
if not MYPY:
|
|
620
|
+
class AuthorizationExceptionRuleChildrenChildrenArgsDict(TypedDict):
|
|
621
|
+
condition_type: pulumi.Input[str]
|
|
622
|
+
"""
|
|
623
|
+
Condition type.
|
|
624
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
625
|
+
"""
|
|
626
|
+
attribute_name: NotRequired[pulumi.Input[str]]
|
|
627
|
+
"""
|
|
628
|
+
Dictionary attribute name
|
|
629
|
+
"""
|
|
630
|
+
attribute_value: NotRequired[pulumi.Input[str]]
|
|
631
|
+
"""
|
|
632
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
633
|
+
"""
|
|
634
|
+
dictionary_name: NotRequired[pulumi.Input[str]]
|
|
635
|
+
"""
|
|
636
|
+
Dictionary name
|
|
637
|
+
"""
|
|
638
|
+
dictionary_value: NotRequired[pulumi.Input[str]]
|
|
639
|
+
"""
|
|
640
|
+
Dictionary value
|
|
641
|
+
"""
|
|
642
|
+
id: NotRequired[pulumi.Input[str]]
|
|
643
|
+
"""
|
|
644
|
+
UUID for condition
|
|
645
|
+
"""
|
|
646
|
+
is_negate: NotRequired[pulumi.Input[bool]]
|
|
647
|
+
"""
|
|
648
|
+
Indicates whereas this condition is in negate mode
|
|
649
|
+
"""
|
|
650
|
+
operator: NotRequired[pulumi.Input[str]]
|
|
651
|
+
"""
|
|
652
|
+
Equality operator
|
|
653
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
654
|
+
"""
|
|
655
|
+
elif False:
|
|
656
|
+
AuthorizationExceptionRuleChildrenChildrenArgsDict: TypeAlias = Mapping[str, Any]
|
|
657
|
+
|
|
658
|
+
@pulumi.input_type
|
|
659
|
+
class AuthorizationExceptionRuleChildrenChildrenArgs:
|
|
660
|
+
def __init__(__self__, *,
|
|
661
|
+
condition_type: pulumi.Input[str],
|
|
662
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
663
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
664
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
665
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
666
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
667
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
668
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
669
|
+
"""
|
|
670
|
+
:param pulumi.Input[str] condition_type: Condition type.
|
|
671
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
672
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
673
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
674
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
675
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
676
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
677
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
678
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
679
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
680
|
+
"""
|
|
681
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
682
|
+
if attribute_name is not None:
|
|
683
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
684
|
+
if attribute_value is not None:
|
|
685
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
686
|
+
if dictionary_name is not None:
|
|
687
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
688
|
+
if dictionary_value is not None:
|
|
689
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
690
|
+
if id is not None:
|
|
691
|
+
pulumi.set(__self__, "id", id)
|
|
692
|
+
if is_negate is not None:
|
|
693
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
694
|
+
if operator is not None:
|
|
695
|
+
pulumi.set(__self__, "operator", operator)
|
|
696
|
+
|
|
697
|
+
@property
|
|
698
|
+
@pulumi.getter(name="conditionType")
|
|
699
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
700
|
+
"""
|
|
701
|
+
Condition type.
|
|
702
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
703
|
+
"""
|
|
704
|
+
return pulumi.get(self, "condition_type")
|
|
705
|
+
|
|
706
|
+
@condition_type.setter
|
|
707
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
708
|
+
pulumi.set(self, "condition_type", value)
|
|
709
|
+
|
|
710
|
+
@property
|
|
711
|
+
@pulumi.getter(name="attributeName")
|
|
712
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
713
|
+
"""
|
|
714
|
+
Dictionary attribute name
|
|
715
|
+
"""
|
|
716
|
+
return pulumi.get(self, "attribute_name")
|
|
717
|
+
|
|
718
|
+
@attribute_name.setter
|
|
719
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
720
|
+
pulumi.set(self, "attribute_name", value)
|
|
721
|
+
|
|
722
|
+
@property
|
|
723
|
+
@pulumi.getter(name="attributeValue")
|
|
724
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
725
|
+
"""
|
|
726
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
727
|
+
"""
|
|
728
|
+
return pulumi.get(self, "attribute_value")
|
|
729
|
+
|
|
730
|
+
@attribute_value.setter
|
|
731
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
732
|
+
pulumi.set(self, "attribute_value", value)
|
|
733
|
+
|
|
734
|
+
@property
|
|
735
|
+
@pulumi.getter(name="dictionaryName")
|
|
736
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
737
|
+
"""
|
|
738
|
+
Dictionary name
|
|
739
|
+
"""
|
|
740
|
+
return pulumi.get(self, "dictionary_name")
|
|
741
|
+
|
|
742
|
+
@dictionary_name.setter
|
|
743
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
744
|
+
pulumi.set(self, "dictionary_name", value)
|
|
745
|
+
|
|
746
|
+
@property
|
|
747
|
+
@pulumi.getter(name="dictionaryValue")
|
|
748
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
749
|
+
"""
|
|
750
|
+
Dictionary value
|
|
751
|
+
"""
|
|
752
|
+
return pulumi.get(self, "dictionary_value")
|
|
753
|
+
|
|
754
|
+
@dictionary_value.setter
|
|
755
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
756
|
+
pulumi.set(self, "dictionary_value", value)
|
|
757
|
+
|
|
758
|
+
@property
|
|
759
|
+
@pulumi.getter
|
|
760
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
761
|
+
"""
|
|
762
|
+
UUID for condition
|
|
763
|
+
"""
|
|
764
|
+
return pulumi.get(self, "id")
|
|
765
|
+
|
|
766
|
+
@id.setter
|
|
767
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
768
|
+
pulumi.set(self, "id", value)
|
|
769
|
+
|
|
770
|
+
@property
|
|
771
|
+
@pulumi.getter(name="isNegate")
|
|
772
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
773
|
+
"""
|
|
774
|
+
Indicates whereas this condition is in negate mode
|
|
775
|
+
"""
|
|
776
|
+
return pulumi.get(self, "is_negate")
|
|
777
|
+
|
|
778
|
+
@is_negate.setter
|
|
779
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
780
|
+
pulumi.set(self, "is_negate", value)
|
|
781
|
+
|
|
782
|
+
@property
|
|
783
|
+
@pulumi.getter
|
|
784
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
785
|
+
"""
|
|
786
|
+
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
|
+
return pulumi.get(self, "operator")
|
|
790
|
+
|
|
791
|
+
@operator.setter
|
|
792
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
793
|
+
pulumi.set(self, "operator", value)
|
|
794
|
+
|
|
795
|
+
|
|
796
|
+
if not MYPY:
|
|
797
|
+
class AuthorizationGlobalExceptionRuleChildrenArgsDict(TypedDict):
|
|
798
|
+
condition_type: pulumi.Input[str]
|
|
799
|
+
"""
|
|
800
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
801
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
802
|
+
"""
|
|
803
|
+
attribute_name: NotRequired[pulumi.Input[str]]
|
|
804
|
+
"""
|
|
805
|
+
Dictionary attribute name
|
|
806
|
+
"""
|
|
807
|
+
attribute_value: NotRequired[pulumi.Input[str]]
|
|
808
|
+
"""
|
|
809
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
810
|
+
"""
|
|
811
|
+
childrens: NotRequired[pulumi.Input[Sequence[pulumi.Input['AuthorizationGlobalExceptionRuleChildrenChildrenArgsDict']]]]
|
|
812
|
+
"""
|
|
813
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
814
|
+
"""
|
|
815
|
+
dictionary_name: NotRequired[pulumi.Input[str]]
|
|
816
|
+
"""
|
|
817
|
+
Dictionary name
|
|
818
|
+
"""
|
|
819
|
+
dictionary_value: NotRequired[pulumi.Input[str]]
|
|
820
|
+
"""
|
|
821
|
+
Dictionary value
|
|
822
|
+
"""
|
|
823
|
+
id: NotRequired[pulumi.Input[str]]
|
|
824
|
+
"""
|
|
825
|
+
UUID for condition
|
|
826
|
+
"""
|
|
827
|
+
is_negate: NotRequired[pulumi.Input[bool]]
|
|
828
|
+
"""
|
|
829
|
+
Indicates whereas this condition is in negate mode
|
|
830
|
+
"""
|
|
831
|
+
operator: NotRequired[pulumi.Input[str]]
|
|
832
|
+
"""
|
|
833
|
+
Equality operator
|
|
834
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
835
|
+
"""
|
|
836
|
+
elif False:
|
|
837
|
+
AuthorizationGlobalExceptionRuleChildrenArgsDict: TypeAlias = Mapping[str, Any]
|
|
838
|
+
|
|
839
|
+
@pulumi.input_type
|
|
840
|
+
class AuthorizationGlobalExceptionRuleChildrenArgs:
|
|
841
|
+
def __init__(__self__, *,
|
|
842
|
+
condition_type: pulumi.Input[str],
|
|
843
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
844
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
845
|
+
childrens: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationGlobalExceptionRuleChildrenChildrenArgs']]]] = None,
|
|
846
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
847
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
848
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
849
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
850
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
851
|
+
"""
|
|
852
|
+
: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.
|
|
853
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
854
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
855
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
856
|
+
:param pulumi.Input[Sequence[pulumi.Input['AuthorizationGlobalExceptionRuleChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
857
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
858
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
859
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
860
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
861
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
862
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
863
|
+
"""
|
|
864
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
865
|
+
if attribute_name is not None:
|
|
866
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
867
|
+
if attribute_value is not None:
|
|
868
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
869
|
+
if childrens is not None:
|
|
870
|
+
pulumi.set(__self__, "childrens", childrens)
|
|
871
|
+
if dictionary_name is not None:
|
|
872
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
873
|
+
if dictionary_value is not None:
|
|
874
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
875
|
+
if id is not None:
|
|
876
|
+
pulumi.set(__self__, "id", id)
|
|
877
|
+
if is_negate is not None:
|
|
878
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
879
|
+
if operator is not None:
|
|
880
|
+
pulumi.set(__self__, "operator", operator)
|
|
881
|
+
|
|
882
|
+
@property
|
|
883
|
+
@pulumi.getter(name="conditionType")
|
|
884
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
885
|
+
"""
|
|
886
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
887
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
888
|
+
"""
|
|
889
|
+
return pulumi.get(self, "condition_type")
|
|
890
|
+
|
|
891
|
+
@condition_type.setter
|
|
892
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
893
|
+
pulumi.set(self, "condition_type", value)
|
|
894
|
+
|
|
895
|
+
@property
|
|
896
|
+
@pulumi.getter(name="attributeName")
|
|
897
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
898
|
+
"""
|
|
899
|
+
Dictionary attribute name
|
|
900
|
+
"""
|
|
901
|
+
return pulumi.get(self, "attribute_name")
|
|
902
|
+
|
|
903
|
+
@attribute_name.setter
|
|
904
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
905
|
+
pulumi.set(self, "attribute_name", value)
|
|
906
|
+
|
|
907
|
+
@property
|
|
908
|
+
@pulumi.getter(name="attributeValue")
|
|
909
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
910
|
+
"""
|
|
911
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
912
|
+
"""
|
|
913
|
+
return pulumi.get(self, "attribute_value")
|
|
914
|
+
|
|
915
|
+
@attribute_value.setter
|
|
916
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
917
|
+
pulumi.set(self, "attribute_value", value)
|
|
918
|
+
|
|
919
|
+
@property
|
|
920
|
+
@pulumi.getter
|
|
921
|
+
def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationGlobalExceptionRuleChildrenChildrenArgs']]]]:
|
|
922
|
+
"""
|
|
923
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
924
|
+
"""
|
|
925
|
+
return pulumi.get(self, "childrens")
|
|
926
|
+
|
|
927
|
+
@childrens.setter
|
|
928
|
+
def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationGlobalExceptionRuleChildrenChildrenArgs']]]]):
|
|
929
|
+
pulumi.set(self, "childrens", value)
|
|
930
|
+
|
|
931
|
+
@property
|
|
932
|
+
@pulumi.getter(name="dictionaryName")
|
|
933
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
934
|
+
"""
|
|
935
|
+
Dictionary name
|
|
936
|
+
"""
|
|
937
|
+
return pulumi.get(self, "dictionary_name")
|
|
938
|
+
|
|
939
|
+
@dictionary_name.setter
|
|
940
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
941
|
+
pulumi.set(self, "dictionary_name", value)
|
|
942
|
+
|
|
943
|
+
@property
|
|
944
|
+
@pulumi.getter(name="dictionaryValue")
|
|
945
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
946
|
+
"""
|
|
947
|
+
Dictionary value
|
|
948
|
+
"""
|
|
949
|
+
return pulumi.get(self, "dictionary_value")
|
|
950
|
+
|
|
951
|
+
@dictionary_value.setter
|
|
952
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
953
|
+
pulumi.set(self, "dictionary_value", value)
|
|
954
|
+
|
|
955
|
+
@property
|
|
956
|
+
@pulumi.getter
|
|
957
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
958
|
+
"""
|
|
959
|
+
UUID for condition
|
|
960
|
+
"""
|
|
961
|
+
return pulumi.get(self, "id")
|
|
962
|
+
|
|
963
|
+
@id.setter
|
|
964
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
965
|
+
pulumi.set(self, "id", value)
|
|
966
|
+
|
|
967
|
+
@property
|
|
968
|
+
@pulumi.getter(name="isNegate")
|
|
969
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
970
|
+
"""
|
|
971
|
+
Indicates whereas this condition is in negate mode
|
|
972
|
+
"""
|
|
973
|
+
return pulumi.get(self, "is_negate")
|
|
974
|
+
|
|
975
|
+
@is_negate.setter
|
|
976
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
977
|
+
pulumi.set(self, "is_negate", value)
|
|
978
|
+
|
|
979
|
+
@property
|
|
980
|
+
@pulumi.getter
|
|
981
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
982
|
+
"""
|
|
983
|
+
Equality operator
|
|
984
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
985
|
+
"""
|
|
986
|
+
return pulumi.get(self, "operator")
|
|
987
|
+
|
|
988
|
+
@operator.setter
|
|
989
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
990
|
+
pulumi.set(self, "operator", value)
|
|
991
|
+
|
|
992
|
+
|
|
993
|
+
if not MYPY:
|
|
994
|
+
class AuthorizationGlobalExceptionRuleChildrenChildrenArgsDict(TypedDict):
|
|
995
|
+
condition_type: pulumi.Input[str]
|
|
996
|
+
"""
|
|
997
|
+
Condition type.
|
|
998
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
999
|
+
"""
|
|
1000
|
+
attribute_name: NotRequired[pulumi.Input[str]]
|
|
1001
|
+
"""
|
|
1002
|
+
Dictionary attribute name
|
|
1003
|
+
"""
|
|
1004
|
+
attribute_value: NotRequired[pulumi.Input[str]]
|
|
1005
|
+
"""
|
|
1006
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
1007
|
+
"""
|
|
1008
|
+
dictionary_name: NotRequired[pulumi.Input[str]]
|
|
1009
|
+
"""
|
|
1010
|
+
Dictionary name
|
|
1011
|
+
"""
|
|
1012
|
+
dictionary_value: NotRequired[pulumi.Input[str]]
|
|
1013
|
+
"""
|
|
1014
|
+
Dictionary value
|
|
1015
|
+
"""
|
|
1016
|
+
id: NotRequired[pulumi.Input[str]]
|
|
1017
|
+
"""
|
|
1018
|
+
UUID for condition
|
|
1019
|
+
"""
|
|
1020
|
+
is_negate: NotRequired[pulumi.Input[bool]]
|
|
1021
|
+
"""
|
|
1022
|
+
Indicates whereas this condition is in negate mode
|
|
1023
|
+
"""
|
|
1024
|
+
operator: NotRequired[pulumi.Input[str]]
|
|
1025
|
+
"""
|
|
1026
|
+
Equality operator
|
|
1027
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1028
|
+
"""
|
|
1029
|
+
elif False:
|
|
1030
|
+
AuthorizationGlobalExceptionRuleChildrenChildrenArgsDict: TypeAlias = Mapping[str, Any]
|
|
1031
|
+
|
|
1032
|
+
@pulumi.input_type
|
|
1033
|
+
class AuthorizationGlobalExceptionRuleChildrenChildrenArgs:
|
|
1034
|
+
def __init__(__self__, *,
|
|
1035
|
+
condition_type: pulumi.Input[str],
|
|
1036
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
1037
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
1038
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
1039
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
1040
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
1041
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
1042
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
1043
|
+
"""
|
|
1044
|
+
:param pulumi.Input[str] condition_type: Condition type.
|
|
1045
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
1046
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
1047
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
1048
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
1049
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
1050
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
1051
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
1052
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
1053
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1054
|
+
"""
|
|
1055
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
1056
|
+
if attribute_name is not None:
|
|
1057
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
1058
|
+
if attribute_value is not None:
|
|
1059
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
1060
|
+
if dictionary_name is not None:
|
|
1061
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
1062
|
+
if dictionary_value is not None:
|
|
1063
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
1064
|
+
if id is not None:
|
|
1065
|
+
pulumi.set(__self__, "id", id)
|
|
1066
|
+
if is_negate is not None:
|
|
1067
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
1068
|
+
if operator is not None:
|
|
1069
|
+
pulumi.set(__self__, "operator", operator)
|
|
1070
|
+
|
|
1071
|
+
@property
|
|
1072
|
+
@pulumi.getter(name="conditionType")
|
|
1073
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
1074
|
+
"""
|
|
1075
|
+
Condition type.
|
|
1076
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
1077
|
+
"""
|
|
1078
|
+
return pulumi.get(self, "condition_type")
|
|
1079
|
+
|
|
1080
|
+
@condition_type.setter
|
|
1081
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
1082
|
+
pulumi.set(self, "condition_type", value)
|
|
1083
|
+
|
|
1084
|
+
@property
|
|
1085
|
+
@pulumi.getter(name="attributeName")
|
|
1086
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
1087
|
+
"""
|
|
1088
|
+
Dictionary attribute name
|
|
1089
|
+
"""
|
|
1090
|
+
return pulumi.get(self, "attribute_name")
|
|
1091
|
+
|
|
1092
|
+
@attribute_name.setter
|
|
1093
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
1094
|
+
pulumi.set(self, "attribute_name", value)
|
|
1095
|
+
|
|
1096
|
+
@property
|
|
1097
|
+
@pulumi.getter(name="attributeValue")
|
|
1098
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
1099
|
+
"""
|
|
1100
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
1101
|
+
"""
|
|
1102
|
+
return pulumi.get(self, "attribute_value")
|
|
1103
|
+
|
|
1104
|
+
@attribute_value.setter
|
|
1105
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
1106
|
+
pulumi.set(self, "attribute_value", value)
|
|
1107
|
+
|
|
1108
|
+
@property
|
|
1109
|
+
@pulumi.getter(name="dictionaryName")
|
|
1110
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
1111
|
+
"""
|
|
1112
|
+
Dictionary name
|
|
1113
|
+
"""
|
|
1114
|
+
return pulumi.get(self, "dictionary_name")
|
|
1115
|
+
|
|
1116
|
+
@dictionary_name.setter
|
|
1117
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
1118
|
+
pulumi.set(self, "dictionary_name", value)
|
|
1119
|
+
|
|
1120
|
+
@property
|
|
1121
|
+
@pulumi.getter(name="dictionaryValue")
|
|
1122
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
1123
|
+
"""
|
|
1124
|
+
Dictionary value
|
|
1125
|
+
"""
|
|
1126
|
+
return pulumi.get(self, "dictionary_value")
|
|
1127
|
+
|
|
1128
|
+
@dictionary_value.setter
|
|
1129
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
1130
|
+
pulumi.set(self, "dictionary_value", value)
|
|
1131
|
+
|
|
1132
|
+
@property
|
|
1133
|
+
@pulumi.getter
|
|
1134
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
1135
|
+
"""
|
|
1136
|
+
UUID for condition
|
|
1137
|
+
"""
|
|
1138
|
+
return pulumi.get(self, "id")
|
|
1139
|
+
|
|
1140
|
+
@id.setter
|
|
1141
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
1142
|
+
pulumi.set(self, "id", value)
|
|
1143
|
+
|
|
1144
|
+
@property
|
|
1145
|
+
@pulumi.getter(name="isNegate")
|
|
1146
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
1147
|
+
"""
|
|
1148
|
+
Indicates whereas this condition is in negate mode
|
|
1149
|
+
"""
|
|
1150
|
+
return pulumi.get(self, "is_negate")
|
|
1151
|
+
|
|
1152
|
+
@is_negate.setter
|
|
1153
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
1154
|
+
pulumi.set(self, "is_negate", value)
|
|
1155
|
+
|
|
1156
|
+
@property
|
|
1157
|
+
@pulumi.getter
|
|
1158
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1159
|
+
"""
|
|
1160
|
+
Equality operator
|
|
1161
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1162
|
+
"""
|
|
1163
|
+
return pulumi.get(self, "operator")
|
|
1164
|
+
|
|
1165
|
+
@operator.setter
|
|
1166
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1167
|
+
pulumi.set(self, "operator", value)
|
|
1168
|
+
|
|
1169
|
+
|
|
1170
|
+
if not MYPY:
|
|
1171
|
+
class AuthorizationProfileAdvancedAttributeArgsDict(TypedDict):
|
|
1172
|
+
attribute_left_dictionary_name: NotRequired[pulumi.Input[str]]
|
|
1173
|
+
"""
|
|
1174
|
+
Dictionary name
|
|
1175
|
+
"""
|
|
1176
|
+
attribute_left_name: NotRequired[pulumi.Input[str]]
|
|
1177
|
+
"""
|
|
1178
|
+
Attribute name
|
|
1179
|
+
"""
|
|
1180
|
+
attribute_right_dictionary_name: NotRequired[pulumi.Input[str]]
|
|
1181
|
+
"""
|
|
1182
|
+
Dictionary name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
|
|
1183
|
+
"""
|
|
1184
|
+
attribute_right_name: NotRequired[pulumi.Input[str]]
|
|
1185
|
+
"""
|
|
1186
|
+
Attribute name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
|
|
1187
|
+
"""
|
|
1188
|
+
attribute_right_value: NotRequired[pulumi.Input[str]]
|
|
1189
|
+
"""
|
|
1190
|
+
Attribute value, only required when `attribute_right_value_type` is `AttributeValue`
|
|
1191
|
+
"""
|
|
1192
|
+
attribute_right_value_type: NotRequired[pulumi.Input[str]]
|
|
1193
|
+
"""
|
|
1194
|
+
Advanced attribute value type
|
|
1195
|
+
- Choices: `AdvancedDictionaryAttribute`, `AttributeValue`
|
|
1196
|
+
"""
|
|
1197
|
+
elif False:
|
|
1198
|
+
AuthorizationProfileAdvancedAttributeArgsDict: TypeAlias = Mapping[str, Any]
|
|
1199
|
+
|
|
1200
|
+
@pulumi.input_type
|
|
1201
|
+
class AuthorizationProfileAdvancedAttributeArgs:
|
|
1202
|
+
def __init__(__self__, *,
|
|
1203
|
+
attribute_left_dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
1204
|
+
attribute_left_name: Optional[pulumi.Input[str]] = None,
|
|
1205
|
+
attribute_right_dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
1206
|
+
attribute_right_name: Optional[pulumi.Input[str]] = None,
|
|
1207
|
+
attribute_right_value: Optional[pulumi.Input[str]] = None,
|
|
1208
|
+
attribute_right_value_type: Optional[pulumi.Input[str]] = None):
|
|
1209
|
+
"""
|
|
1210
|
+
:param pulumi.Input[str] attribute_left_dictionary_name: Dictionary name
|
|
1211
|
+
:param pulumi.Input[str] attribute_left_name: Attribute name
|
|
1212
|
+
:param pulumi.Input[str] attribute_right_dictionary_name: Dictionary name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
|
|
1213
|
+
:param pulumi.Input[str] attribute_right_name: Attribute name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
|
|
1214
|
+
:param pulumi.Input[str] attribute_right_value: Attribute value, only required when `attribute_right_value_type` is `AttributeValue`
|
|
1215
|
+
:param pulumi.Input[str] attribute_right_value_type: Advanced attribute value type
|
|
1216
|
+
- Choices: `AdvancedDictionaryAttribute`, `AttributeValue`
|
|
1217
|
+
"""
|
|
1218
|
+
if attribute_left_dictionary_name is not None:
|
|
1219
|
+
pulumi.set(__self__, "attribute_left_dictionary_name", attribute_left_dictionary_name)
|
|
1220
|
+
if attribute_left_name is not None:
|
|
1221
|
+
pulumi.set(__self__, "attribute_left_name", attribute_left_name)
|
|
1222
|
+
if attribute_right_dictionary_name is not None:
|
|
1223
|
+
pulumi.set(__self__, "attribute_right_dictionary_name", attribute_right_dictionary_name)
|
|
1224
|
+
if attribute_right_name is not None:
|
|
1225
|
+
pulumi.set(__self__, "attribute_right_name", attribute_right_name)
|
|
1226
|
+
if attribute_right_value is not None:
|
|
1227
|
+
pulumi.set(__self__, "attribute_right_value", attribute_right_value)
|
|
1228
|
+
if attribute_right_value_type is not None:
|
|
1229
|
+
pulumi.set(__self__, "attribute_right_value_type", attribute_right_value_type)
|
|
1230
|
+
|
|
1231
|
+
@property
|
|
1232
|
+
@pulumi.getter(name="attributeLeftDictionaryName")
|
|
1233
|
+
def attribute_left_dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
1234
|
+
"""
|
|
1235
|
+
Dictionary name
|
|
1236
|
+
"""
|
|
1237
|
+
return pulumi.get(self, "attribute_left_dictionary_name")
|
|
1238
|
+
|
|
1239
|
+
@attribute_left_dictionary_name.setter
|
|
1240
|
+
def attribute_left_dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
1241
|
+
pulumi.set(self, "attribute_left_dictionary_name", value)
|
|
1242
|
+
|
|
1243
|
+
@property
|
|
1244
|
+
@pulumi.getter(name="attributeLeftName")
|
|
1245
|
+
def attribute_left_name(self) -> Optional[pulumi.Input[str]]:
|
|
1246
|
+
"""
|
|
1247
|
+
Attribute name
|
|
1248
|
+
"""
|
|
1249
|
+
return pulumi.get(self, "attribute_left_name")
|
|
1250
|
+
|
|
1251
|
+
@attribute_left_name.setter
|
|
1252
|
+
def attribute_left_name(self, value: Optional[pulumi.Input[str]]):
|
|
1253
|
+
pulumi.set(self, "attribute_left_name", value)
|
|
1254
|
+
|
|
1255
|
+
@property
|
|
1256
|
+
@pulumi.getter(name="attributeRightDictionaryName")
|
|
1257
|
+
def attribute_right_dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
1258
|
+
"""
|
|
1259
|
+
Dictionary name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
|
|
1260
|
+
"""
|
|
1261
|
+
return pulumi.get(self, "attribute_right_dictionary_name")
|
|
1262
|
+
|
|
1263
|
+
@attribute_right_dictionary_name.setter
|
|
1264
|
+
def attribute_right_dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
1265
|
+
pulumi.set(self, "attribute_right_dictionary_name", value)
|
|
1266
|
+
|
|
1267
|
+
@property
|
|
1268
|
+
@pulumi.getter(name="attributeRightName")
|
|
1269
|
+
def attribute_right_name(self) -> Optional[pulumi.Input[str]]:
|
|
1270
|
+
"""
|
|
1271
|
+
Attribute name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
|
|
1272
|
+
"""
|
|
1273
|
+
return pulumi.get(self, "attribute_right_name")
|
|
1274
|
+
|
|
1275
|
+
@attribute_right_name.setter
|
|
1276
|
+
def attribute_right_name(self, value: Optional[pulumi.Input[str]]):
|
|
1277
|
+
pulumi.set(self, "attribute_right_name", value)
|
|
1278
|
+
|
|
1279
|
+
@property
|
|
1280
|
+
@pulumi.getter(name="attributeRightValue")
|
|
1281
|
+
def attribute_right_value(self) -> Optional[pulumi.Input[str]]:
|
|
1282
|
+
"""
|
|
1283
|
+
Attribute value, only required when `attribute_right_value_type` is `AttributeValue`
|
|
1284
|
+
"""
|
|
1285
|
+
return pulumi.get(self, "attribute_right_value")
|
|
1286
|
+
|
|
1287
|
+
@attribute_right_value.setter
|
|
1288
|
+
def attribute_right_value(self, value: Optional[pulumi.Input[str]]):
|
|
1289
|
+
pulumi.set(self, "attribute_right_value", value)
|
|
1290
|
+
|
|
1291
|
+
@property
|
|
1292
|
+
@pulumi.getter(name="attributeRightValueType")
|
|
1293
|
+
def attribute_right_value_type(self) -> Optional[pulumi.Input[str]]:
|
|
1294
|
+
"""
|
|
1295
|
+
Advanced attribute value type
|
|
1296
|
+
- Choices: `AdvancedDictionaryAttribute`, `AttributeValue`
|
|
1297
|
+
"""
|
|
1298
|
+
return pulumi.get(self, "attribute_right_value_type")
|
|
1299
|
+
|
|
1300
|
+
@attribute_right_value_type.setter
|
|
1301
|
+
def attribute_right_value_type(self, value: Optional[pulumi.Input[str]]):
|
|
1302
|
+
pulumi.set(self, "attribute_right_value_type", value)
|
|
1303
|
+
|
|
1304
|
+
|
|
1305
|
+
if not MYPY:
|
|
1306
|
+
class AuthorizationRuleChildrenArgsDict(TypedDict):
|
|
1307
|
+
condition_type: pulumi.Input[str]
|
|
1308
|
+
"""
|
|
1309
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
1310
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
1311
|
+
"""
|
|
1312
|
+
attribute_name: NotRequired[pulumi.Input[str]]
|
|
1313
|
+
"""
|
|
1314
|
+
Dictionary attribute name
|
|
1315
|
+
"""
|
|
1316
|
+
attribute_value: NotRequired[pulumi.Input[str]]
|
|
1317
|
+
"""
|
|
1318
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
1319
|
+
"""
|
|
1320
|
+
childrens: NotRequired[pulumi.Input[Sequence[pulumi.Input['AuthorizationRuleChildrenChildrenArgsDict']]]]
|
|
1321
|
+
"""
|
|
1322
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
1323
|
+
"""
|
|
1324
|
+
dictionary_name: NotRequired[pulumi.Input[str]]
|
|
1325
|
+
"""
|
|
1326
|
+
Dictionary name
|
|
1327
|
+
"""
|
|
1328
|
+
dictionary_value: NotRequired[pulumi.Input[str]]
|
|
1329
|
+
"""
|
|
1330
|
+
Dictionary value
|
|
1331
|
+
"""
|
|
1332
|
+
id: NotRequired[pulumi.Input[str]]
|
|
1333
|
+
"""
|
|
1334
|
+
UUID for condition
|
|
1335
|
+
"""
|
|
1336
|
+
is_negate: NotRequired[pulumi.Input[bool]]
|
|
1337
|
+
"""
|
|
1338
|
+
Indicates whereas this condition is in negate mode
|
|
1339
|
+
"""
|
|
1340
|
+
operator: NotRequired[pulumi.Input[str]]
|
|
1341
|
+
"""
|
|
1342
|
+
Equality operator
|
|
1343
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1344
|
+
"""
|
|
1345
|
+
elif False:
|
|
1346
|
+
AuthorizationRuleChildrenArgsDict: TypeAlias = Mapping[str, Any]
|
|
1347
|
+
|
|
1348
|
+
@pulumi.input_type
|
|
1349
|
+
class AuthorizationRuleChildrenArgs:
|
|
1350
|
+
def __init__(__self__, *,
|
|
1351
|
+
condition_type: pulumi.Input[str],
|
|
1352
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
1353
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
1354
|
+
childrens: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationRuleChildrenChildrenArgs']]]] = None,
|
|
1355
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
1356
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
1357
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
1358
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
1359
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
1360
|
+
"""
|
|
1361
|
+
: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.
|
|
1362
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
1363
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
1364
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
1365
|
+
:param pulumi.Input[Sequence[pulumi.Input['AuthorizationRuleChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
1366
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
1367
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
1368
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
1369
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
1370
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
1371
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1372
|
+
"""
|
|
1373
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
1374
|
+
if attribute_name is not None:
|
|
1375
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
1376
|
+
if attribute_value is not None:
|
|
1377
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
1378
|
+
if childrens is not None:
|
|
1379
|
+
pulumi.set(__self__, "childrens", childrens)
|
|
1380
|
+
if dictionary_name is not None:
|
|
1381
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
1382
|
+
if dictionary_value is not None:
|
|
1383
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
1384
|
+
if id is not None:
|
|
1385
|
+
pulumi.set(__self__, "id", id)
|
|
1386
|
+
if is_negate is not None:
|
|
1387
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
1388
|
+
if operator is not None:
|
|
1389
|
+
pulumi.set(__self__, "operator", operator)
|
|
1390
|
+
|
|
1391
|
+
@property
|
|
1392
|
+
@pulumi.getter(name="conditionType")
|
|
1393
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
1394
|
+
"""
|
|
1395
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
1396
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
1397
|
+
"""
|
|
1398
|
+
return pulumi.get(self, "condition_type")
|
|
1399
|
+
|
|
1400
|
+
@condition_type.setter
|
|
1401
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
1402
|
+
pulumi.set(self, "condition_type", value)
|
|
1403
|
+
|
|
1404
|
+
@property
|
|
1405
|
+
@pulumi.getter(name="attributeName")
|
|
1406
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
1407
|
+
"""
|
|
1408
|
+
Dictionary attribute name
|
|
1409
|
+
"""
|
|
1410
|
+
return pulumi.get(self, "attribute_name")
|
|
1411
|
+
|
|
1412
|
+
@attribute_name.setter
|
|
1413
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
1414
|
+
pulumi.set(self, "attribute_name", value)
|
|
1415
|
+
|
|
1416
|
+
@property
|
|
1417
|
+
@pulumi.getter(name="attributeValue")
|
|
1418
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
1419
|
+
"""
|
|
1420
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
1421
|
+
"""
|
|
1422
|
+
return pulumi.get(self, "attribute_value")
|
|
1423
|
+
|
|
1424
|
+
@attribute_value.setter
|
|
1425
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
1426
|
+
pulumi.set(self, "attribute_value", value)
|
|
1427
|
+
|
|
1428
|
+
@property
|
|
1429
|
+
@pulumi.getter
|
|
1430
|
+
def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationRuleChildrenChildrenArgs']]]]:
|
|
1431
|
+
"""
|
|
1432
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
1433
|
+
"""
|
|
1434
|
+
return pulumi.get(self, "childrens")
|
|
1435
|
+
|
|
1436
|
+
@childrens.setter
|
|
1437
|
+
def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationRuleChildrenChildrenArgs']]]]):
|
|
1438
|
+
pulumi.set(self, "childrens", value)
|
|
1439
|
+
|
|
1440
|
+
@property
|
|
1441
|
+
@pulumi.getter(name="dictionaryName")
|
|
1442
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
1443
|
+
"""
|
|
1444
|
+
Dictionary name
|
|
1445
|
+
"""
|
|
1446
|
+
return pulumi.get(self, "dictionary_name")
|
|
1447
|
+
|
|
1448
|
+
@dictionary_name.setter
|
|
1449
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
1450
|
+
pulumi.set(self, "dictionary_name", value)
|
|
1451
|
+
|
|
1452
|
+
@property
|
|
1453
|
+
@pulumi.getter(name="dictionaryValue")
|
|
1454
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
1455
|
+
"""
|
|
1456
|
+
Dictionary value
|
|
1457
|
+
"""
|
|
1458
|
+
return pulumi.get(self, "dictionary_value")
|
|
1459
|
+
|
|
1460
|
+
@dictionary_value.setter
|
|
1461
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
1462
|
+
pulumi.set(self, "dictionary_value", value)
|
|
1463
|
+
|
|
1464
|
+
@property
|
|
1465
|
+
@pulumi.getter
|
|
1466
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
1467
|
+
"""
|
|
1468
|
+
UUID for condition
|
|
1469
|
+
"""
|
|
1470
|
+
return pulumi.get(self, "id")
|
|
1471
|
+
|
|
1472
|
+
@id.setter
|
|
1473
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
1474
|
+
pulumi.set(self, "id", value)
|
|
1475
|
+
|
|
1476
|
+
@property
|
|
1477
|
+
@pulumi.getter(name="isNegate")
|
|
1478
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
1479
|
+
"""
|
|
1480
|
+
Indicates whereas this condition is in negate mode
|
|
1481
|
+
"""
|
|
1482
|
+
return pulumi.get(self, "is_negate")
|
|
1483
|
+
|
|
1484
|
+
@is_negate.setter
|
|
1485
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
1486
|
+
pulumi.set(self, "is_negate", value)
|
|
1487
|
+
|
|
1488
|
+
@property
|
|
1489
|
+
@pulumi.getter
|
|
1490
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1491
|
+
"""
|
|
1492
|
+
Equality operator
|
|
1493
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1494
|
+
"""
|
|
1495
|
+
return pulumi.get(self, "operator")
|
|
1496
|
+
|
|
1497
|
+
@operator.setter
|
|
1498
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1499
|
+
pulumi.set(self, "operator", value)
|
|
1500
|
+
|
|
1501
|
+
|
|
1502
|
+
if not MYPY:
|
|
1503
|
+
class AuthorizationRuleChildrenChildrenArgsDict(TypedDict):
|
|
1504
|
+
condition_type: pulumi.Input[str]
|
|
1505
|
+
"""
|
|
1506
|
+
Condition type.
|
|
1507
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
1508
|
+
"""
|
|
1509
|
+
attribute_name: NotRequired[pulumi.Input[str]]
|
|
1510
|
+
"""
|
|
1511
|
+
Dictionary attribute name
|
|
1512
|
+
"""
|
|
1513
|
+
attribute_value: NotRequired[pulumi.Input[str]]
|
|
1514
|
+
"""
|
|
1515
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
1516
|
+
"""
|
|
1517
|
+
dictionary_name: NotRequired[pulumi.Input[str]]
|
|
1518
|
+
"""
|
|
1519
|
+
Dictionary name
|
|
1520
|
+
"""
|
|
1521
|
+
dictionary_value: NotRequired[pulumi.Input[str]]
|
|
1522
|
+
"""
|
|
1523
|
+
Dictionary value
|
|
1524
|
+
"""
|
|
1525
|
+
id: NotRequired[pulumi.Input[str]]
|
|
1526
|
+
"""
|
|
1527
|
+
UUID for condition
|
|
1528
|
+
"""
|
|
1529
|
+
is_negate: NotRequired[pulumi.Input[bool]]
|
|
1530
|
+
"""
|
|
1531
|
+
Indicates whereas this condition is in negate mode
|
|
1532
|
+
"""
|
|
1533
|
+
operator: NotRequired[pulumi.Input[str]]
|
|
1534
|
+
"""
|
|
1535
|
+
Equality operator
|
|
1536
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1537
|
+
"""
|
|
1538
|
+
elif False:
|
|
1539
|
+
AuthorizationRuleChildrenChildrenArgsDict: TypeAlias = Mapping[str, Any]
|
|
1540
|
+
|
|
1541
|
+
@pulumi.input_type
|
|
1542
|
+
class AuthorizationRuleChildrenChildrenArgs:
|
|
1543
|
+
def __init__(__self__, *,
|
|
1544
|
+
condition_type: pulumi.Input[str],
|
|
1545
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
1546
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
1547
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
1548
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
1549
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
1550
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
1551
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
1552
|
+
"""
|
|
1553
|
+
:param pulumi.Input[str] condition_type: Condition type.
|
|
1554
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
1555
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
1556
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
1557
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
1558
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
1559
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
1560
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
1561
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
1562
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1563
|
+
"""
|
|
1564
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
1565
|
+
if attribute_name is not None:
|
|
1566
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
1567
|
+
if attribute_value is not None:
|
|
1568
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
1569
|
+
if dictionary_name is not None:
|
|
1570
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
1571
|
+
if dictionary_value is not None:
|
|
1572
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
1573
|
+
if id is not None:
|
|
1574
|
+
pulumi.set(__self__, "id", id)
|
|
1575
|
+
if is_negate is not None:
|
|
1576
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
1577
|
+
if operator is not None:
|
|
1578
|
+
pulumi.set(__self__, "operator", operator)
|
|
1579
|
+
|
|
1580
|
+
@property
|
|
1581
|
+
@pulumi.getter(name="conditionType")
|
|
1582
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
1583
|
+
"""
|
|
1584
|
+
Condition type.
|
|
1585
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
1586
|
+
"""
|
|
1587
|
+
return pulumi.get(self, "condition_type")
|
|
1588
|
+
|
|
1589
|
+
@condition_type.setter
|
|
1590
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
1591
|
+
pulumi.set(self, "condition_type", value)
|
|
1592
|
+
|
|
1593
|
+
@property
|
|
1594
|
+
@pulumi.getter(name="attributeName")
|
|
1595
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
1596
|
+
"""
|
|
1597
|
+
Dictionary attribute name
|
|
1598
|
+
"""
|
|
1599
|
+
return pulumi.get(self, "attribute_name")
|
|
1600
|
+
|
|
1601
|
+
@attribute_name.setter
|
|
1602
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
1603
|
+
pulumi.set(self, "attribute_name", value)
|
|
1604
|
+
|
|
1605
|
+
@property
|
|
1606
|
+
@pulumi.getter(name="attributeValue")
|
|
1607
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
1608
|
+
"""
|
|
1609
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
1610
|
+
"""
|
|
1611
|
+
return pulumi.get(self, "attribute_value")
|
|
1612
|
+
|
|
1613
|
+
@attribute_value.setter
|
|
1614
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
1615
|
+
pulumi.set(self, "attribute_value", value)
|
|
1616
|
+
|
|
1617
|
+
@property
|
|
1618
|
+
@pulumi.getter(name="dictionaryName")
|
|
1619
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
1620
|
+
"""
|
|
1621
|
+
Dictionary name
|
|
1622
|
+
"""
|
|
1623
|
+
return pulumi.get(self, "dictionary_name")
|
|
1624
|
+
|
|
1625
|
+
@dictionary_name.setter
|
|
1626
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
1627
|
+
pulumi.set(self, "dictionary_name", value)
|
|
1628
|
+
|
|
1629
|
+
@property
|
|
1630
|
+
@pulumi.getter(name="dictionaryValue")
|
|
1631
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
1632
|
+
"""
|
|
1633
|
+
Dictionary value
|
|
1634
|
+
"""
|
|
1635
|
+
return pulumi.get(self, "dictionary_value")
|
|
1636
|
+
|
|
1637
|
+
@dictionary_value.setter
|
|
1638
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
1639
|
+
pulumi.set(self, "dictionary_value", value)
|
|
1640
|
+
|
|
1641
|
+
@property
|
|
1642
|
+
@pulumi.getter
|
|
1643
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
1644
|
+
"""
|
|
1645
|
+
UUID for condition
|
|
1646
|
+
"""
|
|
1647
|
+
return pulumi.get(self, "id")
|
|
1648
|
+
|
|
1649
|
+
@id.setter
|
|
1650
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
1651
|
+
pulumi.set(self, "id", value)
|
|
1652
|
+
|
|
1653
|
+
@property
|
|
1654
|
+
@pulumi.getter(name="isNegate")
|
|
1655
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
1656
|
+
"""
|
|
1657
|
+
Indicates whereas this condition is in negate mode
|
|
1658
|
+
"""
|
|
1659
|
+
return pulumi.get(self, "is_negate")
|
|
1660
|
+
|
|
1661
|
+
@is_negate.setter
|
|
1662
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
1663
|
+
pulumi.set(self, "is_negate", value)
|
|
1664
|
+
|
|
1665
|
+
@property
|
|
1666
|
+
@pulumi.getter
|
|
1667
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1668
|
+
"""
|
|
1669
|
+
Equality operator
|
|
1670
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1671
|
+
"""
|
|
1672
|
+
return pulumi.get(self, "operator")
|
|
1673
|
+
|
|
1674
|
+
@operator.setter
|
|
1675
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1676
|
+
pulumi.set(self, "operator", value)
|
|
1677
|
+
|
|
1678
|
+
|
|
1679
|
+
if not MYPY:
|
|
1680
|
+
class ConditionChildrenArgsDict(TypedDict):
|
|
1681
|
+
condition_type: pulumi.Input[str]
|
|
1682
|
+
"""
|
|
1683
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
1684
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
1685
|
+
"""
|
|
1686
|
+
attribute_name: NotRequired[pulumi.Input[str]]
|
|
1687
|
+
"""
|
|
1688
|
+
Dictionary attribute name
|
|
1689
|
+
"""
|
|
1690
|
+
attribute_value: NotRequired[pulumi.Input[str]]
|
|
1691
|
+
"""
|
|
1692
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
1693
|
+
"""
|
|
1694
|
+
childrens: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConditionChildrenChildrenArgsDict']]]]
|
|
1695
|
+
"""
|
|
1696
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
1697
|
+
"""
|
|
1698
|
+
description: NotRequired[pulumi.Input[str]]
|
|
1699
|
+
"""
|
|
1700
|
+
Condition description
|
|
1701
|
+
"""
|
|
1702
|
+
dictionary_name: NotRequired[pulumi.Input[str]]
|
|
1703
|
+
"""
|
|
1704
|
+
Dictionary name
|
|
1705
|
+
"""
|
|
1706
|
+
dictionary_value: NotRequired[pulumi.Input[str]]
|
|
1707
|
+
"""
|
|
1708
|
+
Dictionary value
|
|
1709
|
+
"""
|
|
1710
|
+
id: NotRequired[pulumi.Input[str]]
|
|
1711
|
+
"""
|
|
1712
|
+
UUID for condition
|
|
1713
|
+
"""
|
|
1714
|
+
is_negate: NotRequired[pulumi.Input[bool]]
|
|
1715
|
+
"""
|
|
1716
|
+
Indicates whereas this condition is in negate mode
|
|
1717
|
+
"""
|
|
1718
|
+
name: NotRequired[pulumi.Input[str]]
|
|
1719
|
+
"""
|
|
1720
|
+
Condition name
|
|
1721
|
+
"""
|
|
1722
|
+
operator: NotRequired[pulumi.Input[str]]
|
|
1723
|
+
"""
|
|
1724
|
+
Equality operator
|
|
1725
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1726
|
+
"""
|
|
1727
|
+
elif False:
|
|
1728
|
+
ConditionChildrenArgsDict: TypeAlias = Mapping[str, Any]
|
|
1729
|
+
|
|
1730
|
+
@pulumi.input_type
|
|
1731
|
+
class ConditionChildrenArgs:
|
|
1732
|
+
def __init__(__self__, *,
|
|
1733
|
+
condition_type: pulumi.Input[str],
|
|
1734
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
1735
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
1736
|
+
childrens: Optional[pulumi.Input[Sequence[pulumi.Input['ConditionChildrenChildrenArgs']]]] = None,
|
|
1737
|
+
description: Optional[pulumi.Input[str]] = None,
|
|
1738
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
1739
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
1740
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
1741
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
1742
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
1743
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
1744
|
+
"""
|
|
1745
|
+
: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.
|
|
1746
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
1747
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
1748
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
1749
|
+
:param pulumi.Input[Sequence[pulumi.Input['ConditionChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
1750
|
+
:param pulumi.Input[str] description: Condition description
|
|
1751
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
1752
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
1753
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
1754
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
1755
|
+
:param pulumi.Input[str] name: Condition name
|
|
1756
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
1757
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1758
|
+
"""
|
|
1759
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
1760
|
+
if attribute_name is not None:
|
|
1761
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
1762
|
+
if attribute_value is not None:
|
|
1763
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
1764
|
+
if childrens is not None:
|
|
1765
|
+
pulumi.set(__self__, "childrens", childrens)
|
|
1766
|
+
if description is not None:
|
|
1767
|
+
pulumi.set(__self__, "description", description)
|
|
1768
|
+
if dictionary_name is not None:
|
|
1769
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
1770
|
+
if dictionary_value is not None:
|
|
1771
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
1772
|
+
if id is not None:
|
|
1773
|
+
pulumi.set(__self__, "id", id)
|
|
1774
|
+
if is_negate is not None:
|
|
1775
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
1776
|
+
if name is not None:
|
|
1777
|
+
pulumi.set(__self__, "name", name)
|
|
1778
|
+
if operator is not None:
|
|
1779
|
+
pulumi.set(__self__, "operator", operator)
|
|
1780
|
+
|
|
1781
|
+
@property
|
|
1782
|
+
@pulumi.getter(name="conditionType")
|
|
1783
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
1784
|
+
"""
|
|
1785
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
1786
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
1787
|
+
"""
|
|
1788
|
+
return pulumi.get(self, "condition_type")
|
|
1789
|
+
|
|
1790
|
+
@condition_type.setter
|
|
1791
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
1792
|
+
pulumi.set(self, "condition_type", value)
|
|
1793
|
+
|
|
1794
|
+
@property
|
|
1795
|
+
@pulumi.getter(name="attributeName")
|
|
1796
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
1797
|
+
"""
|
|
1798
|
+
Dictionary attribute name
|
|
1799
|
+
"""
|
|
1800
|
+
return pulumi.get(self, "attribute_name")
|
|
1801
|
+
|
|
1802
|
+
@attribute_name.setter
|
|
1803
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
1804
|
+
pulumi.set(self, "attribute_name", value)
|
|
1805
|
+
|
|
1806
|
+
@property
|
|
1807
|
+
@pulumi.getter(name="attributeValue")
|
|
1808
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
1809
|
+
"""
|
|
1810
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
1811
|
+
"""
|
|
1812
|
+
return pulumi.get(self, "attribute_value")
|
|
1813
|
+
|
|
1814
|
+
@attribute_value.setter
|
|
1815
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
1816
|
+
pulumi.set(self, "attribute_value", value)
|
|
1817
|
+
|
|
1818
|
+
@property
|
|
1819
|
+
@pulumi.getter
|
|
1820
|
+
def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ConditionChildrenChildrenArgs']]]]:
|
|
1821
|
+
"""
|
|
1822
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
1823
|
+
"""
|
|
1824
|
+
return pulumi.get(self, "childrens")
|
|
1825
|
+
|
|
1826
|
+
@childrens.setter
|
|
1827
|
+
def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ConditionChildrenChildrenArgs']]]]):
|
|
1828
|
+
pulumi.set(self, "childrens", value)
|
|
1829
|
+
|
|
1830
|
+
@property
|
|
1831
|
+
@pulumi.getter
|
|
1832
|
+
def description(self) -> Optional[pulumi.Input[str]]:
|
|
1833
|
+
"""
|
|
1834
|
+
Condition description
|
|
1835
|
+
"""
|
|
1836
|
+
return pulumi.get(self, "description")
|
|
1837
|
+
|
|
1838
|
+
@description.setter
|
|
1839
|
+
def description(self, value: Optional[pulumi.Input[str]]):
|
|
1840
|
+
pulumi.set(self, "description", value)
|
|
1841
|
+
|
|
1842
|
+
@property
|
|
1843
|
+
@pulumi.getter(name="dictionaryName")
|
|
1844
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
1845
|
+
"""
|
|
1846
|
+
Dictionary name
|
|
1847
|
+
"""
|
|
1848
|
+
return pulumi.get(self, "dictionary_name")
|
|
1849
|
+
|
|
1850
|
+
@dictionary_name.setter
|
|
1851
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
1852
|
+
pulumi.set(self, "dictionary_name", value)
|
|
1853
|
+
|
|
1854
|
+
@property
|
|
1855
|
+
@pulumi.getter(name="dictionaryValue")
|
|
1856
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
1857
|
+
"""
|
|
1858
|
+
Dictionary value
|
|
1859
|
+
"""
|
|
1860
|
+
return pulumi.get(self, "dictionary_value")
|
|
1861
|
+
|
|
1862
|
+
@dictionary_value.setter
|
|
1863
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
1864
|
+
pulumi.set(self, "dictionary_value", value)
|
|
1865
|
+
|
|
1866
|
+
@property
|
|
1867
|
+
@pulumi.getter
|
|
1868
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
1869
|
+
"""
|
|
1870
|
+
UUID for condition
|
|
1871
|
+
"""
|
|
1872
|
+
return pulumi.get(self, "id")
|
|
1873
|
+
|
|
1874
|
+
@id.setter
|
|
1875
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
1876
|
+
pulumi.set(self, "id", value)
|
|
1877
|
+
|
|
1878
|
+
@property
|
|
1879
|
+
@pulumi.getter(name="isNegate")
|
|
1880
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
1881
|
+
"""
|
|
1882
|
+
Indicates whereas this condition is in negate mode
|
|
1883
|
+
"""
|
|
1884
|
+
return pulumi.get(self, "is_negate")
|
|
1885
|
+
|
|
1886
|
+
@is_negate.setter
|
|
1887
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
1888
|
+
pulumi.set(self, "is_negate", value)
|
|
1889
|
+
|
|
1890
|
+
@property
|
|
1891
|
+
@pulumi.getter
|
|
1892
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
1893
|
+
"""
|
|
1894
|
+
Condition name
|
|
1895
|
+
"""
|
|
1896
|
+
return pulumi.get(self, "name")
|
|
1897
|
+
|
|
1898
|
+
@name.setter
|
|
1899
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
1900
|
+
pulumi.set(self, "name", value)
|
|
1901
|
+
|
|
1902
|
+
@property
|
|
1903
|
+
@pulumi.getter
|
|
1904
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1905
|
+
"""
|
|
1906
|
+
Equality operator
|
|
1907
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1908
|
+
"""
|
|
1909
|
+
return pulumi.get(self, "operator")
|
|
1910
|
+
|
|
1911
|
+
@operator.setter
|
|
1912
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1913
|
+
pulumi.set(self, "operator", value)
|
|
1914
|
+
|
|
1915
|
+
|
|
1916
|
+
if not MYPY:
|
|
1917
|
+
class ConditionChildrenChildrenArgsDict(TypedDict):
|
|
1918
|
+
condition_type: pulumi.Input[str]
|
|
1919
|
+
"""
|
|
1920
|
+
Condition type.
|
|
1921
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
1922
|
+
"""
|
|
1923
|
+
attribute_name: NotRequired[pulumi.Input[str]]
|
|
1924
|
+
"""
|
|
1925
|
+
Dictionary attribute name
|
|
1926
|
+
"""
|
|
1927
|
+
attribute_value: NotRequired[pulumi.Input[str]]
|
|
1928
|
+
"""
|
|
1929
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
1930
|
+
"""
|
|
1931
|
+
description: NotRequired[pulumi.Input[str]]
|
|
1932
|
+
"""
|
|
1933
|
+
Condition description
|
|
1934
|
+
"""
|
|
1935
|
+
dictionary_name: NotRequired[pulumi.Input[str]]
|
|
1936
|
+
"""
|
|
1937
|
+
Dictionary name
|
|
1938
|
+
"""
|
|
1939
|
+
dictionary_value: NotRequired[pulumi.Input[str]]
|
|
1940
|
+
"""
|
|
1941
|
+
Dictionary value
|
|
1942
|
+
"""
|
|
1943
|
+
id: NotRequired[pulumi.Input[str]]
|
|
1944
|
+
"""
|
|
1945
|
+
UUID for condition
|
|
1946
|
+
"""
|
|
1947
|
+
is_negate: NotRequired[pulumi.Input[bool]]
|
|
1948
|
+
"""
|
|
1949
|
+
Indicates whereas this condition is in negate mode
|
|
1950
|
+
"""
|
|
1951
|
+
name: NotRequired[pulumi.Input[str]]
|
|
1952
|
+
"""
|
|
1953
|
+
Condition name
|
|
1954
|
+
"""
|
|
1955
|
+
operator: NotRequired[pulumi.Input[str]]
|
|
1956
|
+
"""
|
|
1957
|
+
Equality operator
|
|
1958
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1959
|
+
"""
|
|
1960
|
+
elif False:
|
|
1961
|
+
ConditionChildrenChildrenArgsDict: TypeAlias = Mapping[str, Any]
|
|
1962
|
+
|
|
1963
|
+
@pulumi.input_type
|
|
1964
|
+
class ConditionChildrenChildrenArgs:
|
|
1965
|
+
def __init__(__self__, *,
|
|
1966
|
+
condition_type: pulumi.Input[str],
|
|
1967
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
1968
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
1969
|
+
description: Optional[pulumi.Input[str]] = None,
|
|
1970
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
1971
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
1972
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
1973
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
1974
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
1975
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
1976
|
+
"""
|
|
1977
|
+
:param pulumi.Input[str] condition_type: Condition type.
|
|
1978
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
1979
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
1980
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
1981
|
+
:param pulumi.Input[str] description: Condition description
|
|
1982
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
1983
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
1984
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
1985
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
1986
|
+
:param pulumi.Input[str] name: Condition name
|
|
1987
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
1988
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
1989
|
+
"""
|
|
1990
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
1991
|
+
if attribute_name is not None:
|
|
1992
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
1993
|
+
if attribute_value is not None:
|
|
1994
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
1995
|
+
if description is not None:
|
|
1996
|
+
pulumi.set(__self__, "description", description)
|
|
1997
|
+
if dictionary_name is not None:
|
|
1998
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
1999
|
+
if dictionary_value is not None:
|
|
2000
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
2001
|
+
if id is not None:
|
|
2002
|
+
pulumi.set(__self__, "id", id)
|
|
2003
|
+
if is_negate is not None:
|
|
2004
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
2005
|
+
if name is not None:
|
|
2006
|
+
pulumi.set(__self__, "name", name)
|
|
2007
|
+
if operator is not None:
|
|
2008
|
+
pulumi.set(__self__, "operator", operator)
|
|
2009
|
+
|
|
2010
|
+
@property
|
|
2011
|
+
@pulumi.getter(name="conditionType")
|
|
2012
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
2013
|
+
"""
|
|
2014
|
+
Condition type.
|
|
2015
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
2016
|
+
"""
|
|
2017
|
+
return pulumi.get(self, "condition_type")
|
|
2018
|
+
|
|
2019
|
+
@condition_type.setter
|
|
2020
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
2021
|
+
pulumi.set(self, "condition_type", value)
|
|
2022
|
+
|
|
2023
|
+
@property
|
|
2024
|
+
@pulumi.getter(name="attributeName")
|
|
2025
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
2026
|
+
"""
|
|
2027
|
+
Dictionary attribute name
|
|
2028
|
+
"""
|
|
2029
|
+
return pulumi.get(self, "attribute_name")
|
|
2030
|
+
|
|
2031
|
+
@attribute_name.setter
|
|
2032
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
2033
|
+
pulumi.set(self, "attribute_name", value)
|
|
2034
|
+
|
|
2035
|
+
@property
|
|
2036
|
+
@pulumi.getter(name="attributeValue")
|
|
2037
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
2038
|
+
"""
|
|
2039
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
2040
|
+
"""
|
|
2041
|
+
return pulumi.get(self, "attribute_value")
|
|
2042
|
+
|
|
2043
|
+
@attribute_value.setter
|
|
2044
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
2045
|
+
pulumi.set(self, "attribute_value", value)
|
|
2046
|
+
|
|
2047
|
+
@property
|
|
2048
|
+
@pulumi.getter
|
|
2049
|
+
def description(self) -> Optional[pulumi.Input[str]]:
|
|
2050
|
+
"""
|
|
2051
|
+
Condition description
|
|
2052
|
+
"""
|
|
2053
|
+
return pulumi.get(self, "description")
|
|
2054
|
+
|
|
2055
|
+
@description.setter
|
|
2056
|
+
def description(self, value: Optional[pulumi.Input[str]]):
|
|
2057
|
+
pulumi.set(self, "description", value)
|
|
2058
|
+
|
|
2059
|
+
@property
|
|
2060
|
+
@pulumi.getter(name="dictionaryName")
|
|
2061
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
2062
|
+
"""
|
|
2063
|
+
Dictionary name
|
|
2064
|
+
"""
|
|
2065
|
+
return pulumi.get(self, "dictionary_name")
|
|
2066
|
+
|
|
2067
|
+
@dictionary_name.setter
|
|
2068
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
2069
|
+
pulumi.set(self, "dictionary_name", value)
|
|
2070
|
+
|
|
2071
|
+
@property
|
|
2072
|
+
@pulumi.getter(name="dictionaryValue")
|
|
2073
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
2074
|
+
"""
|
|
2075
|
+
Dictionary value
|
|
2076
|
+
"""
|
|
2077
|
+
return pulumi.get(self, "dictionary_value")
|
|
2078
|
+
|
|
2079
|
+
@dictionary_value.setter
|
|
2080
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
2081
|
+
pulumi.set(self, "dictionary_value", value)
|
|
2082
|
+
|
|
2083
|
+
@property
|
|
2084
|
+
@pulumi.getter
|
|
2085
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
2086
|
+
"""
|
|
2087
|
+
UUID for condition
|
|
2088
|
+
"""
|
|
2089
|
+
return pulumi.get(self, "id")
|
|
2090
|
+
|
|
2091
|
+
@id.setter
|
|
2092
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
2093
|
+
pulumi.set(self, "id", value)
|
|
2094
|
+
|
|
2095
|
+
@property
|
|
2096
|
+
@pulumi.getter(name="isNegate")
|
|
2097
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
2098
|
+
"""
|
|
2099
|
+
Indicates whereas this condition is in negate mode
|
|
2100
|
+
"""
|
|
2101
|
+
return pulumi.get(self, "is_negate")
|
|
2102
|
+
|
|
2103
|
+
@is_negate.setter
|
|
2104
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
2105
|
+
pulumi.set(self, "is_negate", value)
|
|
2106
|
+
|
|
2107
|
+
@property
|
|
2108
|
+
@pulumi.getter
|
|
2109
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
2110
|
+
"""
|
|
2111
|
+
Condition name
|
|
2112
|
+
"""
|
|
2113
|
+
return pulumi.get(self, "name")
|
|
2114
|
+
|
|
2115
|
+
@name.setter
|
|
2116
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
2117
|
+
pulumi.set(self, "name", value)
|
|
2118
|
+
|
|
2119
|
+
@property
|
|
2120
|
+
@pulumi.getter
|
|
2121
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
2122
|
+
"""
|
|
2123
|
+
Equality operator
|
|
2124
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
2125
|
+
"""
|
|
2126
|
+
return pulumi.get(self, "operator")
|
|
2127
|
+
|
|
2128
|
+
@operator.setter
|
|
2129
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
2130
|
+
pulumi.set(self, "operator", value)
|
|
2131
|
+
|
|
2132
|
+
|
|
2133
|
+
if not MYPY:
|
|
2134
|
+
class PolicySetChildrenArgsDict(TypedDict):
|
|
2135
|
+
condition_type: pulumi.Input[str]
|
|
2136
|
+
"""
|
|
2137
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
2138
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
2139
|
+
"""
|
|
2140
|
+
attribute_name: NotRequired[pulumi.Input[str]]
|
|
2141
|
+
"""
|
|
2142
|
+
Dictionary attribute name
|
|
2143
|
+
"""
|
|
2144
|
+
attribute_value: NotRequired[pulumi.Input[str]]
|
|
2145
|
+
"""
|
|
2146
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
2147
|
+
"""
|
|
2148
|
+
childrens: NotRequired[pulumi.Input[Sequence[pulumi.Input['PolicySetChildrenChildrenArgsDict']]]]
|
|
2149
|
+
"""
|
|
2150
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
2151
|
+
"""
|
|
2152
|
+
dictionary_name: NotRequired[pulumi.Input[str]]
|
|
2153
|
+
"""
|
|
2154
|
+
Dictionary name
|
|
2155
|
+
"""
|
|
2156
|
+
dictionary_value: NotRequired[pulumi.Input[str]]
|
|
2157
|
+
"""
|
|
2158
|
+
Dictionary value
|
|
2159
|
+
"""
|
|
2160
|
+
id: NotRequired[pulumi.Input[str]]
|
|
2161
|
+
"""
|
|
2162
|
+
UUID for condition
|
|
2163
|
+
"""
|
|
2164
|
+
is_negate: NotRequired[pulumi.Input[bool]]
|
|
2165
|
+
"""
|
|
2166
|
+
Indicates whereas this condition is in negate mode
|
|
2167
|
+
"""
|
|
2168
|
+
operator: NotRequired[pulumi.Input[str]]
|
|
2169
|
+
"""
|
|
2170
|
+
Equality operator
|
|
2171
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
2172
|
+
"""
|
|
2173
|
+
elif False:
|
|
2174
|
+
PolicySetChildrenArgsDict: TypeAlias = Mapping[str, Any]
|
|
2175
|
+
|
|
2176
|
+
@pulumi.input_type
|
|
2177
|
+
class PolicySetChildrenArgs:
|
|
2178
|
+
def __init__(__self__, *,
|
|
2179
|
+
condition_type: pulumi.Input[str],
|
|
2180
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
2181
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
2182
|
+
childrens: Optional[pulumi.Input[Sequence[pulumi.Input['PolicySetChildrenChildrenArgs']]]] = None,
|
|
2183
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
2184
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
2185
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
2186
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
2187
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
2188
|
+
"""
|
|
2189
|
+
: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.
|
|
2190
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
2191
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
2192
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
2193
|
+
:param pulumi.Input[Sequence[pulumi.Input['PolicySetChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
2194
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
2195
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
2196
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
2197
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
2198
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
2199
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
2200
|
+
"""
|
|
2201
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
2202
|
+
if attribute_name is not None:
|
|
2203
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
2204
|
+
if attribute_value is not None:
|
|
2205
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
2206
|
+
if childrens is not None:
|
|
2207
|
+
pulumi.set(__self__, "childrens", childrens)
|
|
2208
|
+
if dictionary_name is not None:
|
|
2209
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
2210
|
+
if dictionary_value is not None:
|
|
2211
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
2212
|
+
if id is not None:
|
|
2213
|
+
pulumi.set(__self__, "id", id)
|
|
2214
|
+
if is_negate is not None:
|
|
2215
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
2216
|
+
if operator is not None:
|
|
2217
|
+
pulumi.set(__self__, "operator", operator)
|
|
2218
|
+
|
|
2219
|
+
@property
|
|
2220
|
+
@pulumi.getter(name="conditionType")
|
|
2221
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
2222
|
+
"""
|
|
2223
|
+
Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
|
|
2224
|
+
- Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
|
|
2225
|
+
"""
|
|
2226
|
+
return pulumi.get(self, "condition_type")
|
|
2227
|
+
|
|
2228
|
+
@condition_type.setter
|
|
2229
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
2230
|
+
pulumi.set(self, "condition_type", value)
|
|
2231
|
+
|
|
2232
|
+
@property
|
|
2233
|
+
@pulumi.getter(name="attributeName")
|
|
2234
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
2235
|
+
"""
|
|
2236
|
+
Dictionary attribute name
|
|
2237
|
+
"""
|
|
2238
|
+
return pulumi.get(self, "attribute_name")
|
|
2239
|
+
|
|
2240
|
+
@attribute_name.setter
|
|
2241
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
2242
|
+
pulumi.set(self, "attribute_name", value)
|
|
2243
|
+
|
|
2244
|
+
@property
|
|
2245
|
+
@pulumi.getter(name="attributeValue")
|
|
2246
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
2247
|
+
"""
|
|
2248
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
2249
|
+
"""
|
|
2250
|
+
return pulumi.get(self, "attribute_value")
|
|
2251
|
+
|
|
2252
|
+
@attribute_value.setter
|
|
2253
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
2254
|
+
pulumi.set(self, "attribute_value", value)
|
|
2255
|
+
|
|
2256
|
+
@property
|
|
2257
|
+
@pulumi.getter
|
|
2258
|
+
def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PolicySetChildrenChildrenArgs']]]]:
|
|
2259
|
+
"""
|
|
2260
|
+
List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
|
|
2261
|
+
"""
|
|
2262
|
+
return pulumi.get(self, "childrens")
|
|
2263
|
+
|
|
2264
|
+
@childrens.setter
|
|
2265
|
+
def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PolicySetChildrenChildrenArgs']]]]):
|
|
2266
|
+
pulumi.set(self, "childrens", value)
|
|
2267
|
+
|
|
2268
|
+
@property
|
|
2269
|
+
@pulumi.getter(name="dictionaryName")
|
|
2270
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
2271
|
+
"""
|
|
2272
|
+
Dictionary name
|
|
2273
|
+
"""
|
|
2274
|
+
return pulumi.get(self, "dictionary_name")
|
|
2275
|
+
|
|
2276
|
+
@dictionary_name.setter
|
|
2277
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
2278
|
+
pulumi.set(self, "dictionary_name", value)
|
|
2279
|
+
|
|
2280
|
+
@property
|
|
2281
|
+
@pulumi.getter(name="dictionaryValue")
|
|
2282
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
2283
|
+
"""
|
|
2284
|
+
Dictionary value
|
|
2285
|
+
"""
|
|
2286
|
+
return pulumi.get(self, "dictionary_value")
|
|
2287
|
+
|
|
2288
|
+
@dictionary_value.setter
|
|
2289
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
2290
|
+
pulumi.set(self, "dictionary_value", value)
|
|
2291
|
+
|
|
2292
|
+
@property
|
|
2293
|
+
@pulumi.getter
|
|
2294
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
2295
|
+
"""
|
|
2296
|
+
UUID for condition
|
|
2297
|
+
"""
|
|
2298
|
+
return pulumi.get(self, "id")
|
|
2299
|
+
|
|
2300
|
+
@id.setter
|
|
2301
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
2302
|
+
pulumi.set(self, "id", value)
|
|
2303
|
+
|
|
2304
|
+
@property
|
|
2305
|
+
@pulumi.getter(name="isNegate")
|
|
2306
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
2307
|
+
"""
|
|
2308
|
+
Indicates whereas this condition is in negate mode
|
|
2309
|
+
"""
|
|
2310
|
+
return pulumi.get(self, "is_negate")
|
|
2311
|
+
|
|
2312
|
+
@is_negate.setter
|
|
2313
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
2314
|
+
pulumi.set(self, "is_negate", value)
|
|
2315
|
+
|
|
2316
|
+
@property
|
|
2317
|
+
@pulumi.getter
|
|
2318
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
2319
|
+
"""
|
|
2320
|
+
Equality operator
|
|
2321
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
2322
|
+
"""
|
|
2323
|
+
return pulumi.get(self, "operator")
|
|
2324
|
+
|
|
2325
|
+
@operator.setter
|
|
2326
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
2327
|
+
pulumi.set(self, "operator", value)
|
|
2328
|
+
|
|
2329
|
+
|
|
2330
|
+
if not MYPY:
|
|
2331
|
+
class PolicySetChildrenChildrenArgsDict(TypedDict):
|
|
2332
|
+
condition_type: pulumi.Input[str]
|
|
2333
|
+
"""
|
|
2334
|
+
Condition type.
|
|
2335
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
2336
|
+
"""
|
|
2337
|
+
attribute_name: NotRequired[pulumi.Input[str]]
|
|
2338
|
+
"""
|
|
2339
|
+
Dictionary attribute name
|
|
2340
|
+
"""
|
|
2341
|
+
attribute_value: NotRequired[pulumi.Input[str]]
|
|
2342
|
+
"""
|
|
2343
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
2344
|
+
"""
|
|
2345
|
+
dictionary_name: NotRequired[pulumi.Input[str]]
|
|
2346
|
+
"""
|
|
2347
|
+
Dictionary name
|
|
2348
|
+
"""
|
|
2349
|
+
dictionary_value: NotRequired[pulumi.Input[str]]
|
|
2350
|
+
"""
|
|
2351
|
+
Dictionary value
|
|
2352
|
+
"""
|
|
2353
|
+
id: NotRequired[pulumi.Input[str]]
|
|
2354
|
+
"""
|
|
2355
|
+
UUID for condition
|
|
2356
|
+
"""
|
|
2357
|
+
is_negate: NotRequired[pulumi.Input[bool]]
|
|
2358
|
+
"""
|
|
2359
|
+
Indicates whereas this condition is in negate mode
|
|
2360
|
+
"""
|
|
2361
|
+
operator: NotRequired[pulumi.Input[str]]
|
|
2362
|
+
"""
|
|
2363
|
+
Equality operator
|
|
2364
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
2365
|
+
"""
|
|
2366
|
+
elif False:
|
|
2367
|
+
PolicySetChildrenChildrenArgsDict: TypeAlias = Mapping[str, Any]
|
|
2368
|
+
|
|
2369
|
+
@pulumi.input_type
|
|
2370
|
+
class PolicySetChildrenChildrenArgs:
|
|
2371
|
+
def __init__(__self__, *,
|
|
2372
|
+
condition_type: pulumi.Input[str],
|
|
2373
|
+
attribute_name: Optional[pulumi.Input[str]] = None,
|
|
2374
|
+
attribute_value: Optional[pulumi.Input[str]] = None,
|
|
2375
|
+
dictionary_name: Optional[pulumi.Input[str]] = None,
|
|
2376
|
+
dictionary_value: Optional[pulumi.Input[str]] = None,
|
|
2377
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
2378
|
+
is_negate: Optional[pulumi.Input[bool]] = None,
|
|
2379
|
+
operator: Optional[pulumi.Input[str]] = None):
|
|
2380
|
+
"""
|
|
2381
|
+
:param pulumi.Input[str] condition_type: Condition type.
|
|
2382
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
2383
|
+
:param pulumi.Input[str] attribute_name: Dictionary attribute name
|
|
2384
|
+
:param pulumi.Input[str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
|
|
2385
|
+
:param pulumi.Input[str] dictionary_name: Dictionary name
|
|
2386
|
+
:param pulumi.Input[str] dictionary_value: Dictionary value
|
|
2387
|
+
:param pulumi.Input[str] id: UUID for condition
|
|
2388
|
+
:param pulumi.Input[bool] is_negate: Indicates whereas this condition is in negate mode
|
|
2389
|
+
:param pulumi.Input[str] operator: Equality operator
|
|
2390
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
2391
|
+
"""
|
|
2392
|
+
pulumi.set(__self__, "condition_type", condition_type)
|
|
2393
|
+
if attribute_name is not None:
|
|
2394
|
+
pulumi.set(__self__, "attribute_name", attribute_name)
|
|
2395
|
+
if attribute_value is not None:
|
|
2396
|
+
pulumi.set(__self__, "attribute_value", attribute_value)
|
|
2397
|
+
if dictionary_name is not None:
|
|
2398
|
+
pulumi.set(__self__, "dictionary_name", dictionary_name)
|
|
2399
|
+
if dictionary_value is not None:
|
|
2400
|
+
pulumi.set(__self__, "dictionary_value", dictionary_value)
|
|
2401
|
+
if id is not None:
|
|
2402
|
+
pulumi.set(__self__, "id", id)
|
|
2403
|
+
if is_negate is not None:
|
|
2404
|
+
pulumi.set(__self__, "is_negate", is_negate)
|
|
2405
|
+
if operator is not None:
|
|
2406
|
+
pulumi.set(__self__, "operator", operator)
|
|
2407
|
+
|
|
2408
|
+
@property
|
|
2409
|
+
@pulumi.getter(name="conditionType")
|
|
2410
|
+
def condition_type(self) -> pulumi.Input[str]:
|
|
2411
|
+
"""
|
|
2412
|
+
Condition type.
|
|
2413
|
+
- Choices: `ConditionAttributes`, `ConditionReference`
|
|
2414
|
+
"""
|
|
2415
|
+
return pulumi.get(self, "condition_type")
|
|
2416
|
+
|
|
2417
|
+
@condition_type.setter
|
|
2418
|
+
def condition_type(self, value: pulumi.Input[str]):
|
|
2419
|
+
pulumi.set(self, "condition_type", value)
|
|
2420
|
+
|
|
2421
|
+
@property
|
|
2422
|
+
@pulumi.getter(name="attributeName")
|
|
2423
|
+
def attribute_name(self) -> Optional[pulumi.Input[str]]:
|
|
2424
|
+
"""
|
|
2425
|
+
Dictionary attribute name
|
|
2426
|
+
"""
|
|
2427
|
+
return pulumi.get(self, "attribute_name")
|
|
2428
|
+
|
|
2429
|
+
@attribute_name.setter
|
|
2430
|
+
def attribute_name(self, value: Optional[pulumi.Input[str]]):
|
|
2431
|
+
pulumi.set(self, "attribute_name", value)
|
|
2432
|
+
|
|
2433
|
+
@property
|
|
2434
|
+
@pulumi.getter(name="attributeValue")
|
|
2435
|
+
def attribute_value(self) -> Optional[pulumi.Input[str]]:
|
|
2436
|
+
"""
|
|
2437
|
+
Attribute value for condition. Value type is specified in dictionary object.
|
|
2438
|
+
"""
|
|
2439
|
+
return pulumi.get(self, "attribute_value")
|
|
2440
|
+
|
|
2441
|
+
@attribute_value.setter
|
|
2442
|
+
def attribute_value(self, value: Optional[pulumi.Input[str]]):
|
|
2443
|
+
pulumi.set(self, "attribute_value", value)
|
|
2444
|
+
|
|
2445
|
+
@property
|
|
2446
|
+
@pulumi.getter(name="dictionaryName")
|
|
2447
|
+
def dictionary_name(self) -> Optional[pulumi.Input[str]]:
|
|
2448
|
+
"""
|
|
2449
|
+
Dictionary name
|
|
2450
|
+
"""
|
|
2451
|
+
return pulumi.get(self, "dictionary_name")
|
|
2452
|
+
|
|
2453
|
+
@dictionary_name.setter
|
|
2454
|
+
def dictionary_name(self, value: Optional[pulumi.Input[str]]):
|
|
2455
|
+
pulumi.set(self, "dictionary_name", value)
|
|
2456
|
+
|
|
2457
|
+
@property
|
|
2458
|
+
@pulumi.getter(name="dictionaryValue")
|
|
2459
|
+
def dictionary_value(self) -> Optional[pulumi.Input[str]]:
|
|
2460
|
+
"""
|
|
2461
|
+
Dictionary value
|
|
2462
|
+
"""
|
|
2463
|
+
return pulumi.get(self, "dictionary_value")
|
|
2464
|
+
|
|
2465
|
+
@dictionary_value.setter
|
|
2466
|
+
def dictionary_value(self, value: Optional[pulumi.Input[str]]):
|
|
2467
|
+
pulumi.set(self, "dictionary_value", value)
|
|
2468
|
+
|
|
2469
|
+
@property
|
|
2470
|
+
@pulumi.getter
|
|
2471
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
2472
|
+
"""
|
|
2473
|
+
UUID for condition
|
|
2474
|
+
"""
|
|
2475
|
+
return pulumi.get(self, "id")
|
|
2476
|
+
|
|
2477
|
+
@id.setter
|
|
2478
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
2479
|
+
pulumi.set(self, "id", value)
|
|
2480
|
+
|
|
2481
|
+
@property
|
|
2482
|
+
@pulumi.getter(name="isNegate")
|
|
2483
|
+
def is_negate(self) -> Optional[pulumi.Input[bool]]:
|
|
2484
|
+
"""
|
|
2485
|
+
Indicates whereas this condition is in negate mode
|
|
2486
|
+
"""
|
|
2487
|
+
return pulumi.get(self, "is_negate")
|
|
2488
|
+
|
|
2489
|
+
@is_negate.setter
|
|
2490
|
+
def is_negate(self, value: Optional[pulumi.Input[bool]]):
|
|
2491
|
+
pulumi.set(self, "is_negate", value)
|
|
2492
|
+
|
|
2493
|
+
@property
|
|
2494
|
+
@pulumi.getter
|
|
2495
|
+
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
2496
|
+
"""
|
|
2497
|
+
Equality operator
|
|
2498
|
+
- Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
|
|
2499
|
+
"""
|
|
2500
|
+
return pulumi.get(self, "operator")
|
|
2501
|
+
|
|
2502
|
+
@operator.setter
|
|
2503
|
+
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
2504
|
+
pulumi.set(self, "operator", value)
|
|
2505
|
+
|
|
2506
|
+
|