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