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