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