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