pulumi-azure-native 2.87.0a1739193742__py3-none-any.whl → 2.88.0a1739348902__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.
Potentially problematic release.
This version of pulumi-azure-native might be problematic. Click here for more details.
- pulumi_azure_native/__init__.py +5 -0
- pulumi_azure_native/authorization/__init__.py +2 -0
- pulumi_azure_native/authorization/_enums.py +88 -0
- pulumi_azure_native/authorization/_inputs.py +1431 -43
- pulumi_azure_native/authorization/get_role_management_policy.py +247 -0
- pulumi_azure_native/authorization/outputs.py +312 -0
- pulumi_azure_native/authorization/role_management_policy.py +332 -0
- pulumi_azure_native/authorization/v20201001/__init__.py +4 -0
- pulumi_azure_native/authorization/v20201001/_enums.py +78 -0
- pulumi_azure_native/authorization/v20201001/_inputs.py +1134 -0
- pulumi_azure_native/authorization/v20201001/get_role_management_policy.py +241 -0
- pulumi_azure_native/authorization/v20201001/outputs.py +89 -0
- pulumi_azure_native/authorization/v20201001/role_management_policy.py +326 -0
- pulumi_azure_native/authorization/v20201001preview/__init__.py +4 -0
- pulumi_azure_native/authorization/v20201001preview/_enums.py +78 -0
- pulumi_azure_native/authorization/v20201001preview/_inputs.py +1134 -0
- pulumi_azure_native/authorization/v20201001preview/get_role_management_policy.py +241 -0
- pulumi_azure_native/authorization/v20201001preview/outputs.py +959 -0
- pulumi_azure_native/authorization/v20201001preview/role_management_policy.py +326 -0
- pulumi_azure_native/authorization/v20240201preview/__init__.py +4 -0
- pulumi_azure_native/authorization/v20240201preview/_enums.py +96 -0
- pulumi_azure_native/authorization/v20240201preview/_inputs.py +1390 -0
- pulumi_azure_native/authorization/v20240201preview/get_role_management_policy.py +241 -0
- pulumi_azure_native/authorization/v20240201preview/outputs.py +89 -0
- pulumi_azure_native/authorization/v20240201preview/role_management_policy.py +326 -0
- pulumi_azure_native/authorization/v20240901preview/__init__.py +4 -0
- pulumi_azure_native/authorization/v20240901preview/_enums.py +96 -0
- pulumi_azure_native/authorization/v20240901preview/_inputs.py +1410 -0
- pulumi_azure_native/authorization/v20240901preview/get_role_management_policy.py +241 -0
- pulumi_azure_native/authorization/v20240901preview/outputs.py +89 -0
- pulumi_azure_native/authorization/v20240901preview/role_management_policy.py +326 -0
- pulumi_azure_native/pulumi-plugin.json +1 -1
- {pulumi_azure_native-2.87.0a1739193742.dist-info → pulumi_azure_native-2.88.0a1739348902.dist-info}/METADATA +1 -1
- {pulumi_azure_native-2.87.0a1739193742.dist-info → pulumi_azure_native-2.88.0a1739348902.dist-info}/RECORD +36 -18
- {pulumi_azure_native-2.87.0a1739193742.dist-info → pulumi_azure_native-2.88.0a1739348902.dist-info}/WHEEL +0 -0
- {pulumi_azure_native-2.87.0a1739193742.dist-info → pulumi_azure_native-2.88.0a1739348902.dist-info}/top_level.txt +0 -0
|
@@ -0,0 +1,1410 @@
|
|
|
1
|
+
# coding=utf-8
|
|
2
|
+
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
|
+
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
|
+
|
|
5
|
+
import copy
|
|
6
|
+
import warnings
|
|
7
|
+
import sys
|
|
8
|
+
import pulumi
|
|
9
|
+
import pulumi.runtime
|
|
10
|
+
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
15
|
+
from ... import _utilities
|
|
16
|
+
from ._enums import *
|
|
17
|
+
|
|
18
|
+
__all__ = [
|
|
19
|
+
'ApprovalSettingsArgs',
|
|
20
|
+
'ApprovalSettingsArgsDict',
|
|
21
|
+
'ApprovalStageArgs',
|
|
22
|
+
'ApprovalStageArgsDict',
|
|
23
|
+
'PIMOnlyModeSettingsArgs',
|
|
24
|
+
'PIMOnlyModeSettingsArgsDict',
|
|
25
|
+
'RoleManagementPolicyApprovalRuleArgs',
|
|
26
|
+
'RoleManagementPolicyApprovalRuleArgsDict',
|
|
27
|
+
'RoleManagementPolicyAuthenticationContextRuleArgs',
|
|
28
|
+
'RoleManagementPolicyAuthenticationContextRuleArgsDict',
|
|
29
|
+
'RoleManagementPolicyEnablementRuleArgs',
|
|
30
|
+
'RoleManagementPolicyEnablementRuleArgsDict',
|
|
31
|
+
'RoleManagementPolicyExpirationRuleArgs',
|
|
32
|
+
'RoleManagementPolicyExpirationRuleArgsDict',
|
|
33
|
+
'RoleManagementPolicyNotificationRuleArgs',
|
|
34
|
+
'RoleManagementPolicyNotificationRuleArgsDict',
|
|
35
|
+
'RoleManagementPolicyPimOnlyModeRuleArgs',
|
|
36
|
+
'RoleManagementPolicyPimOnlyModeRuleArgsDict',
|
|
37
|
+
'RoleManagementPolicyRuleTargetArgs',
|
|
38
|
+
'RoleManagementPolicyRuleTargetArgsDict',
|
|
39
|
+
'UserSetArgs',
|
|
40
|
+
'UserSetArgsDict',
|
|
41
|
+
'UsersOrServicePrincipalSetArgs',
|
|
42
|
+
'UsersOrServicePrincipalSetArgsDict',
|
|
43
|
+
]
|
|
44
|
+
|
|
45
|
+
MYPY = False
|
|
46
|
+
|
|
47
|
+
if not MYPY:
|
|
48
|
+
class ApprovalSettingsArgsDict(TypedDict):
|
|
49
|
+
"""
|
|
50
|
+
The approval settings.
|
|
51
|
+
"""
|
|
52
|
+
approval_mode: NotRequired[pulumi.Input[Union[str, 'ApprovalMode']]]
|
|
53
|
+
"""
|
|
54
|
+
The type of rule
|
|
55
|
+
"""
|
|
56
|
+
approval_stages: NotRequired[pulumi.Input[Sequence[pulumi.Input['ApprovalStageArgsDict']]]]
|
|
57
|
+
"""
|
|
58
|
+
The approval stages of the request.
|
|
59
|
+
"""
|
|
60
|
+
is_approval_required: NotRequired[pulumi.Input[bool]]
|
|
61
|
+
"""
|
|
62
|
+
Determines whether approval is required or not.
|
|
63
|
+
"""
|
|
64
|
+
is_approval_required_for_extension: NotRequired[pulumi.Input[bool]]
|
|
65
|
+
"""
|
|
66
|
+
Determines whether approval is required for assignment extension.
|
|
67
|
+
"""
|
|
68
|
+
is_requestor_justification_required: NotRequired[pulumi.Input[bool]]
|
|
69
|
+
"""
|
|
70
|
+
Determine whether requestor justification is required.
|
|
71
|
+
"""
|
|
72
|
+
elif False:
|
|
73
|
+
ApprovalSettingsArgsDict: TypeAlias = Mapping[str, Any]
|
|
74
|
+
|
|
75
|
+
@pulumi.input_type
|
|
76
|
+
class ApprovalSettingsArgs:
|
|
77
|
+
def __init__(__self__, *,
|
|
78
|
+
approval_mode: Optional[pulumi.Input[Union[str, 'ApprovalMode']]] = None,
|
|
79
|
+
approval_stages: Optional[pulumi.Input[Sequence[pulumi.Input['ApprovalStageArgs']]]] = None,
|
|
80
|
+
is_approval_required: Optional[pulumi.Input[bool]] = None,
|
|
81
|
+
is_approval_required_for_extension: Optional[pulumi.Input[bool]] = None,
|
|
82
|
+
is_requestor_justification_required: Optional[pulumi.Input[bool]] = None):
|
|
83
|
+
"""
|
|
84
|
+
The approval settings.
|
|
85
|
+
:param pulumi.Input[Union[str, 'ApprovalMode']] approval_mode: The type of rule
|
|
86
|
+
:param pulumi.Input[Sequence[pulumi.Input['ApprovalStageArgs']]] approval_stages: The approval stages of the request.
|
|
87
|
+
:param pulumi.Input[bool] is_approval_required: Determines whether approval is required or not.
|
|
88
|
+
:param pulumi.Input[bool] is_approval_required_for_extension: Determines whether approval is required for assignment extension.
|
|
89
|
+
:param pulumi.Input[bool] is_requestor_justification_required: Determine whether requestor justification is required.
|
|
90
|
+
"""
|
|
91
|
+
if approval_mode is not None:
|
|
92
|
+
pulumi.set(__self__, "approval_mode", approval_mode)
|
|
93
|
+
if approval_stages is not None:
|
|
94
|
+
pulumi.set(__self__, "approval_stages", approval_stages)
|
|
95
|
+
if is_approval_required is not None:
|
|
96
|
+
pulumi.set(__self__, "is_approval_required", is_approval_required)
|
|
97
|
+
if is_approval_required_for_extension is not None:
|
|
98
|
+
pulumi.set(__self__, "is_approval_required_for_extension", is_approval_required_for_extension)
|
|
99
|
+
if is_requestor_justification_required is not None:
|
|
100
|
+
pulumi.set(__self__, "is_requestor_justification_required", is_requestor_justification_required)
|
|
101
|
+
|
|
102
|
+
@property
|
|
103
|
+
@pulumi.getter(name="approvalMode")
|
|
104
|
+
def approval_mode(self) -> Optional[pulumi.Input[Union[str, 'ApprovalMode']]]:
|
|
105
|
+
"""
|
|
106
|
+
The type of rule
|
|
107
|
+
"""
|
|
108
|
+
return pulumi.get(self, "approval_mode")
|
|
109
|
+
|
|
110
|
+
@approval_mode.setter
|
|
111
|
+
def approval_mode(self, value: Optional[pulumi.Input[Union[str, 'ApprovalMode']]]):
|
|
112
|
+
pulumi.set(self, "approval_mode", value)
|
|
113
|
+
|
|
114
|
+
@property
|
|
115
|
+
@pulumi.getter(name="approvalStages")
|
|
116
|
+
def approval_stages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApprovalStageArgs']]]]:
|
|
117
|
+
"""
|
|
118
|
+
The approval stages of the request.
|
|
119
|
+
"""
|
|
120
|
+
return pulumi.get(self, "approval_stages")
|
|
121
|
+
|
|
122
|
+
@approval_stages.setter
|
|
123
|
+
def approval_stages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApprovalStageArgs']]]]):
|
|
124
|
+
pulumi.set(self, "approval_stages", value)
|
|
125
|
+
|
|
126
|
+
@property
|
|
127
|
+
@pulumi.getter(name="isApprovalRequired")
|
|
128
|
+
def is_approval_required(self) -> Optional[pulumi.Input[bool]]:
|
|
129
|
+
"""
|
|
130
|
+
Determines whether approval is required or not.
|
|
131
|
+
"""
|
|
132
|
+
return pulumi.get(self, "is_approval_required")
|
|
133
|
+
|
|
134
|
+
@is_approval_required.setter
|
|
135
|
+
def is_approval_required(self, value: Optional[pulumi.Input[bool]]):
|
|
136
|
+
pulumi.set(self, "is_approval_required", value)
|
|
137
|
+
|
|
138
|
+
@property
|
|
139
|
+
@pulumi.getter(name="isApprovalRequiredForExtension")
|
|
140
|
+
def is_approval_required_for_extension(self) -> Optional[pulumi.Input[bool]]:
|
|
141
|
+
"""
|
|
142
|
+
Determines whether approval is required for assignment extension.
|
|
143
|
+
"""
|
|
144
|
+
return pulumi.get(self, "is_approval_required_for_extension")
|
|
145
|
+
|
|
146
|
+
@is_approval_required_for_extension.setter
|
|
147
|
+
def is_approval_required_for_extension(self, value: Optional[pulumi.Input[bool]]):
|
|
148
|
+
pulumi.set(self, "is_approval_required_for_extension", value)
|
|
149
|
+
|
|
150
|
+
@property
|
|
151
|
+
@pulumi.getter(name="isRequestorJustificationRequired")
|
|
152
|
+
def is_requestor_justification_required(self) -> Optional[pulumi.Input[bool]]:
|
|
153
|
+
"""
|
|
154
|
+
Determine whether requestor justification is required.
|
|
155
|
+
"""
|
|
156
|
+
return pulumi.get(self, "is_requestor_justification_required")
|
|
157
|
+
|
|
158
|
+
@is_requestor_justification_required.setter
|
|
159
|
+
def is_requestor_justification_required(self, value: Optional[pulumi.Input[bool]]):
|
|
160
|
+
pulumi.set(self, "is_requestor_justification_required", value)
|
|
161
|
+
|
|
162
|
+
|
|
163
|
+
if not MYPY:
|
|
164
|
+
class ApprovalStageArgsDict(TypedDict):
|
|
165
|
+
"""
|
|
166
|
+
The approval stage.
|
|
167
|
+
"""
|
|
168
|
+
approval_stage_time_out_in_days: NotRequired[pulumi.Input[int]]
|
|
169
|
+
"""
|
|
170
|
+
The time in days when approval request would be timed out
|
|
171
|
+
"""
|
|
172
|
+
escalation_approvers: NotRequired[pulumi.Input[Sequence[pulumi.Input['UserSetArgsDict']]]]
|
|
173
|
+
"""
|
|
174
|
+
The escalation approver of the request.
|
|
175
|
+
"""
|
|
176
|
+
escalation_time_in_minutes: NotRequired[pulumi.Input[int]]
|
|
177
|
+
"""
|
|
178
|
+
The time in minutes when the approval request would be escalated if the primary approver does not approve
|
|
179
|
+
"""
|
|
180
|
+
is_approver_justification_required: NotRequired[pulumi.Input[bool]]
|
|
181
|
+
"""
|
|
182
|
+
Determines whether approver need to provide justification for his decision.
|
|
183
|
+
"""
|
|
184
|
+
is_escalation_enabled: NotRequired[pulumi.Input[bool]]
|
|
185
|
+
"""
|
|
186
|
+
The value determine whether escalation feature is enabled.
|
|
187
|
+
"""
|
|
188
|
+
primary_approvers: NotRequired[pulumi.Input[Sequence[pulumi.Input['UserSetArgsDict']]]]
|
|
189
|
+
"""
|
|
190
|
+
The primary approver of the request.
|
|
191
|
+
"""
|
|
192
|
+
elif False:
|
|
193
|
+
ApprovalStageArgsDict: TypeAlias = Mapping[str, Any]
|
|
194
|
+
|
|
195
|
+
@pulumi.input_type
|
|
196
|
+
class ApprovalStageArgs:
|
|
197
|
+
def __init__(__self__, *,
|
|
198
|
+
approval_stage_time_out_in_days: Optional[pulumi.Input[int]] = None,
|
|
199
|
+
escalation_approvers: Optional[pulumi.Input[Sequence[pulumi.Input['UserSetArgs']]]] = None,
|
|
200
|
+
escalation_time_in_minutes: Optional[pulumi.Input[int]] = None,
|
|
201
|
+
is_approver_justification_required: Optional[pulumi.Input[bool]] = None,
|
|
202
|
+
is_escalation_enabled: Optional[pulumi.Input[bool]] = None,
|
|
203
|
+
primary_approvers: Optional[pulumi.Input[Sequence[pulumi.Input['UserSetArgs']]]] = None):
|
|
204
|
+
"""
|
|
205
|
+
The approval stage.
|
|
206
|
+
:param pulumi.Input[int] approval_stage_time_out_in_days: The time in days when approval request would be timed out
|
|
207
|
+
:param pulumi.Input[Sequence[pulumi.Input['UserSetArgs']]] escalation_approvers: The escalation approver of the request.
|
|
208
|
+
:param pulumi.Input[int] escalation_time_in_minutes: The time in minutes when the approval request would be escalated if the primary approver does not approve
|
|
209
|
+
:param pulumi.Input[bool] is_approver_justification_required: Determines whether approver need to provide justification for his decision.
|
|
210
|
+
:param pulumi.Input[bool] is_escalation_enabled: The value determine whether escalation feature is enabled.
|
|
211
|
+
:param pulumi.Input[Sequence[pulumi.Input['UserSetArgs']]] primary_approvers: The primary approver of the request.
|
|
212
|
+
"""
|
|
213
|
+
if approval_stage_time_out_in_days is not None:
|
|
214
|
+
pulumi.set(__self__, "approval_stage_time_out_in_days", approval_stage_time_out_in_days)
|
|
215
|
+
if escalation_approvers is not None:
|
|
216
|
+
pulumi.set(__self__, "escalation_approvers", escalation_approvers)
|
|
217
|
+
if escalation_time_in_minutes is not None:
|
|
218
|
+
pulumi.set(__self__, "escalation_time_in_minutes", escalation_time_in_minutes)
|
|
219
|
+
if is_approver_justification_required is not None:
|
|
220
|
+
pulumi.set(__self__, "is_approver_justification_required", is_approver_justification_required)
|
|
221
|
+
if is_escalation_enabled is not None:
|
|
222
|
+
pulumi.set(__self__, "is_escalation_enabled", is_escalation_enabled)
|
|
223
|
+
if primary_approvers is not None:
|
|
224
|
+
pulumi.set(__self__, "primary_approvers", primary_approvers)
|
|
225
|
+
|
|
226
|
+
@property
|
|
227
|
+
@pulumi.getter(name="approvalStageTimeOutInDays")
|
|
228
|
+
def approval_stage_time_out_in_days(self) -> Optional[pulumi.Input[int]]:
|
|
229
|
+
"""
|
|
230
|
+
The time in days when approval request would be timed out
|
|
231
|
+
"""
|
|
232
|
+
return pulumi.get(self, "approval_stage_time_out_in_days")
|
|
233
|
+
|
|
234
|
+
@approval_stage_time_out_in_days.setter
|
|
235
|
+
def approval_stage_time_out_in_days(self, value: Optional[pulumi.Input[int]]):
|
|
236
|
+
pulumi.set(self, "approval_stage_time_out_in_days", value)
|
|
237
|
+
|
|
238
|
+
@property
|
|
239
|
+
@pulumi.getter(name="escalationApprovers")
|
|
240
|
+
def escalation_approvers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['UserSetArgs']]]]:
|
|
241
|
+
"""
|
|
242
|
+
The escalation approver of the request.
|
|
243
|
+
"""
|
|
244
|
+
return pulumi.get(self, "escalation_approvers")
|
|
245
|
+
|
|
246
|
+
@escalation_approvers.setter
|
|
247
|
+
def escalation_approvers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['UserSetArgs']]]]):
|
|
248
|
+
pulumi.set(self, "escalation_approvers", value)
|
|
249
|
+
|
|
250
|
+
@property
|
|
251
|
+
@pulumi.getter(name="escalationTimeInMinutes")
|
|
252
|
+
def escalation_time_in_minutes(self) -> Optional[pulumi.Input[int]]:
|
|
253
|
+
"""
|
|
254
|
+
The time in minutes when the approval request would be escalated if the primary approver does not approve
|
|
255
|
+
"""
|
|
256
|
+
return pulumi.get(self, "escalation_time_in_minutes")
|
|
257
|
+
|
|
258
|
+
@escalation_time_in_minutes.setter
|
|
259
|
+
def escalation_time_in_minutes(self, value: Optional[pulumi.Input[int]]):
|
|
260
|
+
pulumi.set(self, "escalation_time_in_minutes", value)
|
|
261
|
+
|
|
262
|
+
@property
|
|
263
|
+
@pulumi.getter(name="isApproverJustificationRequired")
|
|
264
|
+
def is_approver_justification_required(self) -> Optional[pulumi.Input[bool]]:
|
|
265
|
+
"""
|
|
266
|
+
Determines whether approver need to provide justification for his decision.
|
|
267
|
+
"""
|
|
268
|
+
return pulumi.get(self, "is_approver_justification_required")
|
|
269
|
+
|
|
270
|
+
@is_approver_justification_required.setter
|
|
271
|
+
def is_approver_justification_required(self, value: Optional[pulumi.Input[bool]]):
|
|
272
|
+
pulumi.set(self, "is_approver_justification_required", value)
|
|
273
|
+
|
|
274
|
+
@property
|
|
275
|
+
@pulumi.getter(name="isEscalationEnabled")
|
|
276
|
+
def is_escalation_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
277
|
+
"""
|
|
278
|
+
The value determine whether escalation feature is enabled.
|
|
279
|
+
"""
|
|
280
|
+
return pulumi.get(self, "is_escalation_enabled")
|
|
281
|
+
|
|
282
|
+
@is_escalation_enabled.setter
|
|
283
|
+
def is_escalation_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
284
|
+
pulumi.set(self, "is_escalation_enabled", value)
|
|
285
|
+
|
|
286
|
+
@property
|
|
287
|
+
@pulumi.getter(name="primaryApprovers")
|
|
288
|
+
def primary_approvers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['UserSetArgs']]]]:
|
|
289
|
+
"""
|
|
290
|
+
The primary approver of the request.
|
|
291
|
+
"""
|
|
292
|
+
return pulumi.get(self, "primary_approvers")
|
|
293
|
+
|
|
294
|
+
@primary_approvers.setter
|
|
295
|
+
def primary_approvers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['UserSetArgs']]]]):
|
|
296
|
+
pulumi.set(self, "primary_approvers", value)
|
|
297
|
+
|
|
298
|
+
|
|
299
|
+
if not MYPY:
|
|
300
|
+
class PIMOnlyModeSettingsArgsDict(TypedDict):
|
|
301
|
+
"""
|
|
302
|
+
The PIM Only Mode settings.
|
|
303
|
+
"""
|
|
304
|
+
excluded_assignment_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ExcludedPrincipalTypes']]]]]
|
|
305
|
+
"""
|
|
306
|
+
The list of excluded assignment types allowed.
|
|
307
|
+
"""
|
|
308
|
+
excludes: NotRequired[pulumi.Input[Sequence[pulumi.Input['UsersOrServicePrincipalSetArgsDict']]]]
|
|
309
|
+
"""
|
|
310
|
+
The list of excluded entities that the rule does not apply to.
|
|
311
|
+
"""
|
|
312
|
+
mode: NotRequired[pulumi.Input[Union[str, 'PIMOnlyMode']]]
|
|
313
|
+
"""
|
|
314
|
+
Determines whether the setting is enabled, disabled or report only.
|
|
315
|
+
"""
|
|
316
|
+
elif False:
|
|
317
|
+
PIMOnlyModeSettingsArgsDict: TypeAlias = Mapping[str, Any]
|
|
318
|
+
|
|
319
|
+
@pulumi.input_type
|
|
320
|
+
class PIMOnlyModeSettingsArgs:
|
|
321
|
+
def __init__(__self__, *,
|
|
322
|
+
excluded_assignment_types: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ExcludedPrincipalTypes']]]]] = None,
|
|
323
|
+
excludes: Optional[pulumi.Input[Sequence[pulumi.Input['UsersOrServicePrincipalSetArgs']]]] = None,
|
|
324
|
+
mode: Optional[pulumi.Input[Union[str, 'PIMOnlyMode']]] = None):
|
|
325
|
+
"""
|
|
326
|
+
The PIM Only Mode settings.
|
|
327
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union[str, 'ExcludedPrincipalTypes']]]] excluded_assignment_types: The list of excluded assignment types allowed.
|
|
328
|
+
:param pulumi.Input[Sequence[pulumi.Input['UsersOrServicePrincipalSetArgs']]] excludes: The list of excluded entities that the rule does not apply to.
|
|
329
|
+
:param pulumi.Input[Union[str, 'PIMOnlyMode']] mode: Determines whether the setting is enabled, disabled or report only.
|
|
330
|
+
"""
|
|
331
|
+
if excluded_assignment_types is not None:
|
|
332
|
+
pulumi.set(__self__, "excluded_assignment_types", excluded_assignment_types)
|
|
333
|
+
if excludes is not None:
|
|
334
|
+
pulumi.set(__self__, "excludes", excludes)
|
|
335
|
+
if mode is not None:
|
|
336
|
+
pulumi.set(__self__, "mode", mode)
|
|
337
|
+
|
|
338
|
+
@property
|
|
339
|
+
@pulumi.getter(name="excludedAssignmentTypes")
|
|
340
|
+
def excluded_assignment_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ExcludedPrincipalTypes']]]]]:
|
|
341
|
+
"""
|
|
342
|
+
The list of excluded assignment types allowed.
|
|
343
|
+
"""
|
|
344
|
+
return pulumi.get(self, "excluded_assignment_types")
|
|
345
|
+
|
|
346
|
+
@excluded_assignment_types.setter
|
|
347
|
+
def excluded_assignment_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ExcludedPrincipalTypes']]]]]):
|
|
348
|
+
pulumi.set(self, "excluded_assignment_types", value)
|
|
349
|
+
|
|
350
|
+
@property
|
|
351
|
+
@pulumi.getter
|
|
352
|
+
def excludes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['UsersOrServicePrincipalSetArgs']]]]:
|
|
353
|
+
"""
|
|
354
|
+
The list of excluded entities that the rule does not apply to.
|
|
355
|
+
"""
|
|
356
|
+
return pulumi.get(self, "excludes")
|
|
357
|
+
|
|
358
|
+
@excludes.setter
|
|
359
|
+
def excludes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['UsersOrServicePrincipalSetArgs']]]]):
|
|
360
|
+
pulumi.set(self, "excludes", value)
|
|
361
|
+
|
|
362
|
+
@property
|
|
363
|
+
@pulumi.getter
|
|
364
|
+
def mode(self) -> Optional[pulumi.Input[Union[str, 'PIMOnlyMode']]]:
|
|
365
|
+
"""
|
|
366
|
+
Determines whether the setting is enabled, disabled or report only.
|
|
367
|
+
"""
|
|
368
|
+
return pulumi.get(self, "mode")
|
|
369
|
+
|
|
370
|
+
@mode.setter
|
|
371
|
+
def mode(self, value: Optional[pulumi.Input[Union[str, 'PIMOnlyMode']]]):
|
|
372
|
+
pulumi.set(self, "mode", value)
|
|
373
|
+
|
|
374
|
+
|
|
375
|
+
if not MYPY:
|
|
376
|
+
class RoleManagementPolicyApprovalRuleArgsDict(TypedDict):
|
|
377
|
+
"""
|
|
378
|
+
The role management policy approval rule.
|
|
379
|
+
"""
|
|
380
|
+
rule_type: pulumi.Input[str]
|
|
381
|
+
"""
|
|
382
|
+
The type of rule
|
|
383
|
+
Expected value is 'RoleManagementPolicyApprovalRule'.
|
|
384
|
+
"""
|
|
385
|
+
id: NotRequired[pulumi.Input[str]]
|
|
386
|
+
"""
|
|
387
|
+
The id of the rule.
|
|
388
|
+
"""
|
|
389
|
+
setting: NotRequired[pulumi.Input['ApprovalSettingsArgsDict']]
|
|
390
|
+
"""
|
|
391
|
+
The approval setting
|
|
392
|
+
"""
|
|
393
|
+
target: NotRequired[pulumi.Input['RoleManagementPolicyRuleTargetArgsDict']]
|
|
394
|
+
"""
|
|
395
|
+
The target of the current rule.
|
|
396
|
+
"""
|
|
397
|
+
elif False:
|
|
398
|
+
RoleManagementPolicyApprovalRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
399
|
+
|
|
400
|
+
@pulumi.input_type
|
|
401
|
+
class RoleManagementPolicyApprovalRuleArgs:
|
|
402
|
+
def __init__(__self__, *,
|
|
403
|
+
rule_type: pulumi.Input[str],
|
|
404
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
405
|
+
setting: Optional[pulumi.Input['ApprovalSettingsArgs']] = None,
|
|
406
|
+
target: Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']] = None):
|
|
407
|
+
"""
|
|
408
|
+
The role management policy approval rule.
|
|
409
|
+
:param pulumi.Input[str] rule_type: The type of rule
|
|
410
|
+
Expected value is 'RoleManagementPolicyApprovalRule'.
|
|
411
|
+
:param pulumi.Input[str] id: The id of the rule.
|
|
412
|
+
:param pulumi.Input['ApprovalSettingsArgs'] setting: The approval setting
|
|
413
|
+
:param pulumi.Input['RoleManagementPolicyRuleTargetArgs'] target: The target of the current rule.
|
|
414
|
+
"""
|
|
415
|
+
pulumi.set(__self__, "rule_type", 'RoleManagementPolicyApprovalRule')
|
|
416
|
+
if id is not None:
|
|
417
|
+
pulumi.set(__self__, "id", id)
|
|
418
|
+
if setting is not None:
|
|
419
|
+
pulumi.set(__self__, "setting", setting)
|
|
420
|
+
if target is not None:
|
|
421
|
+
pulumi.set(__self__, "target", target)
|
|
422
|
+
|
|
423
|
+
@property
|
|
424
|
+
@pulumi.getter(name="ruleType")
|
|
425
|
+
def rule_type(self) -> pulumi.Input[str]:
|
|
426
|
+
"""
|
|
427
|
+
The type of rule
|
|
428
|
+
Expected value is 'RoleManagementPolicyApprovalRule'.
|
|
429
|
+
"""
|
|
430
|
+
return pulumi.get(self, "rule_type")
|
|
431
|
+
|
|
432
|
+
@rule_type.setter
|
|
433
|
+
def rule_type(self, value: pulumi.Input[str]):
|
|
434
|
+
pulumi.set(self, "rule_type", value)
|
|
435
|
+
|
|
436
|
+
@property
|
|
437
|
+
@pulumi.getter
|
|
438
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
439
|
+
"""
|
|
440
|
+
The id of the rule.
|
|
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
|
|
450
|
+
def setting(self) -> Optional[pulumi.Input['ApprovalSettingsArgs']]:
|
|
451
|
+
"""
|
|
452
|
+
The approval setting
|
|
453
|
+
"""
|
|
454
|
+
return pulumi.get(self, "setting")
|
|
455
|
+
|
|
456
|
+
@setting.setter
|
|
457
|
+
def setting(self, value: Optional[pulumi.Input['ApprovalSettingsArgs']]):
|
|
458
|
+
pulumi.set(self, "setting", value)
|
|
459
|
+
|
|
460
|
+
@property
|
|
461
|
+
@pulumi.getter
|
|
462
|
+
def target(self) -> Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']]:
|
|
463
|
+
"""
|
|
464
|
+
The target of the current rule.
|
|
465
|
+
"""
|
|
466
|
+
return pulumi.get(self, "target")
|
|
467
|
+
|
|
468
|
+
@target.setter
|
|
469
|
+
def target(self, value: Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']]):
|
|
470
|
+
pulumi.set(self, "target", value)
|
|
471
|
+
|
|
472
|
+
|
|
473
|
+
if not MYPY:
|
|
474
|
+
class RoleManagementPolicyAuthenticationContextRuleArgsDict(TypedDict):
|
|
475
|
+
"""
|
|
476
|
+
The role management policy authentication context rule.
|
|
477
|
+
"""
|
|
478
|
+
rule_type: pulumi.Input[str]
|
|
479
|
+
"""
|
|
480
|
+
The type of rule
|
|
481
|
+
Expected value is 'RoleManagementPolicyAuthenticationContextRule'.
|
|
482
|
+
"""
|
|
483
|
+
claim_value: NotRequired[pulumi.Input[str]]
|
|
484
|
+
"""
|
|
485
|
+
The claim value.
|
|
486
|
+
"""
|
|
487
|
+
id: NotRequired[pulumi.Input[str]]
|
|
488
|
+
"""
|
|
489
|
+
The id of the rule.
|
|
490
|
+
"""
|
|
491
|
+
is_enabled: NotRequired[pulumi.Input[bool]]
|
|
492
|
+
"""
|
|
493
|
+
The value indicating if rule is enabled.
|
|
494
|
+
"""
|
|
495
|
+
target: NotRequired[pulumi.Input['RoleManagementPolicyRuleTargetArgsDict']]
|
|
496
|
+
"""
|
|
497
|
+
The target of the current rule.
|
|
498
|
+
"""
|
|
499
|
+
elif False:
|
|
500
|
+
RoleManagementPolicyAuthenticationContextRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
501
|
+
|
|
502
|
+
@pulumi.input_type
|
|
503
|
+
class RoleManagementPolicyAuthenticationContextRuleArgs:
|
|
504
|
+
def __init__(__self__, *,
|
|
505
|
+
rule_type: pulumi.Input[str],
|
|
506
|
+
claim_value: Optional[pulumi.Input[str]] = None,
|
|
507
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
508
|
+
is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
509
|
+
target: Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']] = None):
|
|
510
|
+
"""
|
|
511
|
+
The role management policy authentication context rule.
|
|
512
|
+
:param pulumi.Input[str] rule_type: The type of rule
|
|
513
|
+
Expected value is 'RoleManagementPolicyAuthenticationContextRule'.
|
|
514
|
+
:param pulumi.Input[str] claim_value: The claim value.
|
|
515
|
+
:param pulumi.Input[str] id: The id of the rule.
|
|
516
|
+
:param pulumi.Input[bool] is_enabled: The value indicating if rule is enabled.
|
|
517
|
+
:param pulumi.Input['RoleManagementPolicyRuleTargetArgs'] target: The target of the current rule.
|
|
518
|
+
"""
|
|
519
|
+
pulumi.set(__self__, "rule_type", 'RoleManagementPolicyAuthenticationContextRule')
|
|
520
|
+
if claim_value is not None:
|
|
521
|
+
pulumi.set(__self__, "claim_value", claim_value)
|
|
522
|
+
if id is not None:
|
|
523
|
+
pulumi.set(__self__, "id", id)
|
|
524
|
+
if is_enabled is not None:
|
|
525
|
+
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
526
|
+
if target is not None:
|
|
527
|
+
pulumi.set(__self__, "target", target)
|
|
528
|
+
|
|
529
|
+
@property
|
|
530
|
+
@pulumi.getter(name="ruleType")
|
|
531
|
+
def rule_type(self) -> pulumi.Input[str]:
|
|
532
|
+
"""
|
|
533
|
+
The type of rule
|
|
534
|
+
Expected value is 'RoleManagementPolicyAuthenticationContextRule'.
|
|
535
|
+
"""
|
|
536
|
+
return pulumi.get(self, "rule_type")
|
|
537
|
+
|
|
538
|
+
@rule_type.setter
|
|
539
|
+
def rule_type(self, value: pulumi.Input[str]):
|
|
540
|
+
pulumi.set(self, "rule_type", value)
|
|
541
|
+
|
|
542
|
+
@property
|
|
543
|
+
@pulumi.getter(name="claimValue")
|
|
544
|
+
def claim_value(self) -> Optional[pulumi.Input[str]]:
|
|
545
|
+
"""
|
|
546
|
+
The claim value.
|
|
547
|
+
"""
|
|
548
|
+
return pulumi.get(self, "claim_value")
|
|
549
|
+
|
|
550
|
+
@claim_value.setter
|
|
551
|
+
def claim_value(self, value: Optional[pulumi.Input[str]]):
|
|
552
|
+
pulumi.set(self, "claim_value", value)
|
|
553
|
+
|
|
554
|
+
@property
|
|
555
|
+
@pulumi.getter
|
|
556
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
557
|
+
"""
|
|
558
|
+
The id of the rule.
|
|
559
|
+
"""
|
|
560
|
+
return pulumi.get(self, "id")
|
|
561
|
+
|
|
562
|
+
@id.setter
|
|
563
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
564
|
+
pulumi.set(self, "id", value)
|
|
565
|
+
|
|
566
|
+
@property
|
|
567
|
+
@pulumi.getter(name="isEnabled")
|
|
568
|
+
def is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
569
|
+
"""
|
|
570
|
+
The value indicating if rule is enabled.
|
|
571
|
+
"""
|
|
572
|
+
return pulumi.get(self, "is_enabled")
|
|
573
|
+
|
|
574
|
+
@is_enabled.setter
|
|
575
|
+
def is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
576
|
+
pulumi.set(self, "is_enabled", value)
|
|
577
|
+
|
|
578
|
+
@property
|
|
579
|
+
@pulumi.getter
|
|
580
|
+
def target(self) -> Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']]:
|
|
581
|
+
"""
|
|
582
|
+
The target of the current rule.
|
|
583
|
+
"""
|
|
584
|
+
return pulumi.get(self, "target")
|
|
585
|
+
|
|
586
|
+
@target.setter
|
|
587
|
+
def target(self, value: Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']]):
|
|
588
|
+
pulumi.set(self, "target", value)
|
|
589
|
+
|
|
590
|
+
|
|
591
|
+
if not MYPY:
|
|
592
|
+
class RoleManagementPolicyEnablementRuleArgsDict(TypedDict):
|
|
593
|
+
"""
|
|
594
|
+
The role management policy enablement rule.
|
|
595
|
+
"""
|
|
596
|
+
rule_type: pulumi.Input[str]
|
|
597
|
+
"""
|
|
598
|
+
The type of rule
|
|
599
|
+
Expected value is 'RoleManagementPolicyEnablementRule'.
|
|
600
|
+
"""
|
|
601
|
+
enabled_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input[Union[str, 'EnablementRules']]]]]
|
|
602
|
+
"""
|
|
603
|
+
The list of enabled rules.
|
|
604
|
+
"""
|
|
605
|
+
id: NotRequired[pulumi.Input[str]]
|
|
606
|
+
"""
|
|
607
|
+
The id of the rule.
|
|
608
|
+
"""
|
|
609
|
+
target: NotRequired[pulumi.Input['RoleManagementPolicyRuleTargetArgsDict']]
|
|
610
|
+
"""
|
|
611
|
+
The target of the current rule.
|
|
612
|
+
"""
|
|
613
|
+
elif False:
|
|
614
|
+
RoleManagementPolicyEnablementRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
615
|
+
|
|
616
|
+
@pulumi.input_type
|
|
617
|
+
class RoleManagementPolicyEnablementRuleArgs:
|
|
618
|
+
def __init__(__self__, *,
|
|
619
|
+
rule_type: pulumi.Input[str],
|
|
620
|
+
enabled_rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'EnablementRules']]]]] = None,
|
|
621
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
622
|
+
target: Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']] = None):
|
|
623
|
+
"""
|
|
624
|
+
The role management policy enablement rule.
|
|
625
|
+
:param pulumi.Input[str] rule_type: The type of rule
|
|
626
|
+
Expected value is 'RoleManagementPolicyEnablementRule'.
|
|
627
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union[str, 'EnablementRules']]]] enabled_rules: The list of enabled rules.
|
|
628
|
+
:param pulumi.Input[str] id: The id of the rule.
|
|
629
|
+
:param pulumi.Input['RoleManagementPolicyRuleTargetArgs'] target: The target of the current rule.
|
|
630
|
+
"""
|
|
631
|
+
pulumi.set(__self__, "rule_type", 'RoleManagementPolicyEnablementRule')
|
|
632
|
+
if enabled_rules is not None:
|
|
633
|
+
pulumi.set(__self__, "enabled_rules", enabled_rules)
|
|
634
|
+
if id is not None:
|
|
635
|
+
pulumi.set(__self__, "id", id)
|
|
636
|
+
if target is not None:
|
|
637
|
+
pulumi.set(__self__, "target", target)
|
|
638
|
+
|
|
639
|
+
@property
|
|
640
|
+
@pulumi.getter(name="ruleType")
|
|
641
|
+
def rule_type(self) -> pulumi.Input[str]:
|
|
642
|
+
"""
|
|
643
|
+
The type of rule
|
|
644
|
+
Expected value is 'RoleManagementPolicyEnablementRule'.
|
|
645
|
+
"""
|
|
646
|
+
return pulumi.get(self, "rule_type")
|
|
647
|
+
|
|
648
|
+
@rule_type.setter
|
|
649
|
+
def rule_type(self, value: pulumi.Input[str]):
|
|
650
|
+
pulumi.set(self, "rule_type", value)
|
|
651
|
+
|
|
652
|
+
@property
|
|
653
|
+
@pulumi.getter(name="enabledRules")
|
|
654
|
+
def enabled_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'EnablementRules']]]]]:
|
|
655
|
+
"""
|
|
656
|
+
The list of enabled rules.
|
|
657
|
+
"""
|
|
658
|
+
return pulumi.get(self, "enabled_rules")
|
|
659
|
+
|
|
660
|
+
@enabled_rules.setter
|
|
661
|
+
def enabled_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'EnablementRules']]]]]):
|
|
662
|
+
pulumi.set(self, "enabled_rules", value)
|
|
663
|
+
|
|
664
|
+
@property
|
|
665
|
+
@pulumi.getter
|
|
666
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
667
|
+
"""
|
|
668
|
+
The id of the rule.
|
|
669
|
+
"""
|
|
670
|
+
return pulumi.get(self, "id")
|
|
671
|
+
|
|
672
|
+
@id.setter
|
|
673
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
674
|
+
pulumi.set(self, "id", value)
|
|
675
|
+
|
|
676
|
+
@property
|
|
677
|
+
@pulumi.getter
|
|
678
|
+
def target(self) -> Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']]:
|
|
679
|
+
"""
|
|
680
|
+
The target of the current rule.
|
|
681
|
+
"""
|
|
682
|
+
return pulumi.get(self, "target")
|
|
683
|
+
|
|
684
|
+
@target.setter
|
|
685
|
+
def target(self, value: Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']]):
|
|
686
|
+
pulumi.set(self, "target", value)
|
|
687
|
+
|
|
688
|
+
|
|
689
|
+
if not MYPY:
|
|
690
|
+
class RoleManagementPolicyExpirationRuleArgsDict(TypedDict):
|
|
691
|
+
"""
|
|
692
|
+
The role management policy expiration rule.
|
|
693
|
+
"""
|
|
694
|
+
rule_type: pulumi.Input[str]
|
|
695
|
+
"""
|
|
696
|
+
The type of rule
|
|
697
|
+
Expected value is 'RoleManagementPolicyExpirationRule'.
|
|
698
|
+
"""
|
|
699
|
+
exception_members: NotRequired[pulumi.Input[Sequence[pulumi.Input['UserSetArgsDict']]]]
|
|
700
|
+
"""
|
|
701
|
+
The members not restricted by expiration rule.
|
|
702
|
+
"""
|
|
703
|
+
id: NotRequired[pulumi.Input[str]]
|
|
704
|
+
"""
|
|
705
|
+
The id of the rule.
|
|
706
|
+
"""
|
|
707
|
+
is_expiration_required: NotRequired[pulumi.Input[bool]]
|
|
708
|
+
"""
|
|
709
|
+
The value indicating whether expiration is required.
|
|
710
|
+
"""
|
|
711
|
+
maximum_duration: NotRequired[pulumi.Input[str]]
|
|
712
|
+
"""
|
|
713
|
+
The maximum duration of expiration in timespan.
|
|
714
|
+
"""
|
|
715
|
+
target: NotRequired[pulumi.Input['RoleManagementPolicyRuleTargetArgsDict']]
|
|
716
|
+
"""
|
|
717
|
+
The target of the current rule.
|
|
718
|
+
"""
|
|
719
|
+
elif False:
|
|
720
|
+
RoleManagementPolicyExpirationRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
721
|
+
|
|
722
|
+
@pulumi.input_type
|
|
723
|
+
class RoleManagementPolicyExpirationRuleArgs:
|
|
724
|
+
def __init__(__self__, *,
|
|
725
|
+
rule_type: pulumi.Input[str],
|
|
726
|
+
exception_members: Optional[pulumi.Input[Sequence[pulumi.Input['UserSetArgs']]]] = None,
|
|
727
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
728
|
+
is_expiration_required: Optional[pulumi.Input[bool]] = None,
|
|
729
|
+
maximum_duration: Optional[pulumi.Input[str]] = None,
|
|
730
|
+
target: Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']] = None):
|
|
731
|
+
"""
|
|
732
|
+
The role management policy expiration rule.
|
|
733
|
+
:param pulumi.Input[str] rule_type: The type of rule
|
|
734
|
+
Expected value is 'RoleManagementPolicyExpirationRule'.
|
|
735
|
+
:param pulumi.Input[Sequence[pulumi.Input['UserSetArgs']]] exception_members: The members not restricted by expiration rule.
|
|
736
|
+
:param pulumi.Input[str] id: The id of the rule.
|
|
737
|
+
:param pulumi.Input[bool] is_expiration_required: The value indicating whether expiration is required.
|
|
738
|
+
:param pulumi.Input[str] maximum_duration: The maximum duration of expiration in timespan.
|
|
739
|
+
:param pulumi.Input['RoleManagementPolicyRuleTargetArgs'] target: The target of the current rule.
|
|
740
|
+
"""
|
|
741
|
+
pulumi.set(__self__, "rule_type", 'RoleManagementPolicyExpirationRule')
|
|
742
|
+
if exception_members is not None:
|
|
743
|
+
pulumi.set(__self__, "exception_members", exception_members)
|
|
744
|
+
if id is not None:
|
|
745
|
+
pulumi.set(__self__, "id", id)
|
|
746
|
+
if is_expiration_required is not None:
|
|
747
|
+
pulumi.set(__self__, "is_expiration_required", is_expiration_required)
|
|
748
|
+
if maximum_duration is not None:
|
|
749
|
+
pulumi.set(__self__, "maximum_duration", maximum_duration)
|
|
750
|
+
if target is not None:
|
|
751
|
+
pulumi.set(__self__, "target", target)
|
|
752
|
+
|
|
753
|
+
@property
|
|
754
|
+
@pulumi.getter(name="ruleType")
|
|
755
|
+
def rule_type(self) -> pulumi.Input[str]:
|
|
756
|
+
"""
|
|
757
|
+
The type of rule
|
|
758
|
+
Expected value is 'RoleManagementPolicyExpirationRule'.
|
|
759
|
+
"""
|
|
760
|
+
return pulumi.get(self, "rule_type")
|
|
761
|
+
|
|
762
|
+
@rule_type.setter
|
|
763
|
+
def rule_type(self, value: pulumi.Input[str]):
|
|
764
|
+
pulumi.set(self, "rule_type", value)
|
|
765
|
+
|
|
766
|
+
@property
|
|
767
|
+
@pulumi.getter(name="exceptionMembers")
|
|
768
|
+
def exception_members(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['UserSetArgs']]]]:
|
|
769
|
+
"""
|
|
770
|
+
The members not restricted by expiration rule.
|
|
771
|
+
"""
|
|
772
|
+
return pulumi.get(self, "exception_members")
|
|
773
|
+
|
|
774
|
+
@exception_members.setter
|
|
775
|
+
def exception_members(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['UserSetArgs']]]]):
|
|
776
|
+
pulumi.set(self, "exception_members", value)
|
|
777
|
+
|
|
778
|
+
@property
|
|
779
|
+
@pulumi.getter
|
|
780
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
781
|
+
"""
|
|
782
|
+
The id of the rule.
|
|
783
|
+
"""
|
|
784
|
+
return pulumi.get(self, "id")
|
|
785
|
+
|
|
786
|
+
@id.setter
|
|
787
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
788
|
+
pulumi.set(self, "id", value)
|
|
789
|
+
|
|
790
|
+
@property
|
|
791
|
+
@pulumi.getter(name="isExpirationRequired")
|
|
792
|
+
def is_expiration_required(self) -> Optional[pulumi.Input[bool]]:
|
|
793
|
+
"""
|
|
794
|
+
The value indicating whether expiration is required.
|
|
795
|
+
"""
|
|
796
|
+
return pulumi.get(self, "is_expiration_required")
|
|
797
|
+
|
|
798
|
+
@is_expiration_required.setter
|
|
799
|
+
def is_expiration_required(self, value: Optional[pulumi.Input[bool]]):
|
|
800
|
+
pulumi.set(self, "is_expiration_required", value)
|
|
801
|
+
|
|
802
|
+
@property
|
|
803
|
+
@pulumi.getter(name="maximumDuration")
|
|
804
|
+
def maximum_duration(self) -> Optional[pulumi.Input[str]]:
|
|
805
|
+
"""
|
|
806
|
+
The maximum duration of expiration in timespan.
|
|
807
|
+
"""
|
|
808
|
+
return pulumi.get(self, "maximum_duration")
|
|
809
|
+
|
|
810
|
+
@maximum_duration.setter
|
|
811
|
+
def maximum_duration(self, value: Optional[pulumi.Input[str]]):
|
|
812
|
+
pulumi.set(self, "maximum_duration", value)
|
|
813
|
+
|
|
814
|
+
@property
|
|
815
|
+
@pulumi.getter
|
|
816
|
+
def target(self) -> Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']]:
|
|
817
|
+
"""
|
|
818
|
+
The target of the current rule.
|
|
819
|
+
"""
|
|
820
|
+
return pulumi.get(self, "target")
|
|
821
|
+
|
|
822
|
+
@target.setter
|
|
823
|
+
def target(self, value: Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']]):
|
|
824
|
+
pulumi.set(self, "target", value)
|
|
825
|
+
|
|
826
|
+
|
|
827
|
+
if not MYPY:
|
|
828
|
+
class RoleManagementPolicyNotificationRuleArgsDict(TypedDict):
|
|
829
|
+
"""
|
|
830
|
+
The role management policy notification rule.
|
|
831
|
+
"""
|
|
832
|
+
rule_type: pulumi.Input[str]
|
|
833
|
+
"""
|
|
834
|
+
The type of rule
|
|
835
|
+
Expected value is 'RoleManagementPolicyNotificationRule'.
|
|
836
|
+
"""
|
|
837
|
+
id: NotRequired[pulumi.Input[str]]
|
|
838
|
+
"""
|
|
839
|
+
The id of the rule.
|
|
840
|
+
"""
|
|
841
|
+
is_default_recipients_enabled: NotRequired[pulumi.Input[bool]]
|
|
842
|
+
"""
|
|
843
|
+
Determines if the notification will be sent to the recipient type specified in the policy rule.
|
|
844
|
+
"""
|
|
845
|
+
notification_level: NotRequired[pulumi.Input[Union[str, 'NotificationLevel']]]
|
|
846
|
+
"""
|
|
847
|
+
The notification level.
|
|
848
|
+
"""
|
|
849
|
+
notification_recipients: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
850
|
+
"""
|
|
851
|
+
The list of notification recipients.
|
|
852
|
+
"""
|
|
853
|
+
notification_type: NotRequired[pulumi.Input[Union[str, 'NotificationDeliveryMechanism']]]
|
|
854
|
+
"""
|
|
855
|
+
The type of notification.
|
|
856
|
+
"""
|
|
857
|
+
recipient_type: NotRequired[pulumi.Input[Union[str, 'RecipientType']]]
|
|
858
|
+
"""
|
|
859
|
+
The recipient type.
|
|
860
|
+
"""
|
|
861
|
+
target: NotRequired[pulumi.Input['RoleManagementPolicyRuleTargetArgsDict']]
|
|
862
|
+
"""
|
|
863
|
+
The target of the current rule.
|
|
864
|
+
"""
|
|
865
|
+
elif False:
|
|
866
|
+
RoleManagementPolicyNotificationRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
867
|
+
|
|
868
|
+
@pulumi.input_type
|
|
869
|
+
class RoleManagementPolicyNotificationRuleArgs:
|
|
870
|
+
def __init__(__self__, *,
|
|
871
|
+
rule_type: pulumi.Input[str],
|
|
872
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
873
|
+
is_default_recipients_enabled: Optional[pulumi.Input[bool]] = None,
|
|
874
|
+
notification_level: Optional[pulumi.Input[Union[str, 'NotificationLevel']]] = None,
|
|
875
|
+
notification_recipients: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
876
|
+
notification_type: Optional[pulumi.Input[Union[str, 'NotificationDeliveryMechanism']]] = None,
|
|
877
|
+
recipient_type: Optional[pulumi.Input[Union[str, 'RecipientType']]] = None,
|
|
878
|
+
target: Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']] = None):
|
|
879
|
+
"""
|
|
880
|
+
The role management policy notification rule.
|
|
881
|
+
:param pulumi.Input[str] rule_type: The type of rule
|
|
882
|
+
Expected value is 'RoleManagementPolicyNotificationRule'.
|
|
883
|
+
:param pulumi.Input[str] id: The id of the rule.
|
|
884
|
+
:param pulumi.Input[bool] is_default_recipients_enabled: Determines if the notification will be sent to the recipient type specified in the policy rule.
|
|
885
|
+
:param pulumi.Input[Union[str, 'NotificationLevel']] notification_level: The notification level.
|
|
886
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] notification_recipients: The list of notification recipients.
|
|
887
|
+
:param pulumi.Input[Union[str, 'NotificationDeliveryMechanism']] notification_type: The type of notification.
|
|
888
|
+
:param pulumi.Input[Union[str, 'RecipientType']] recipient_type: The recipient type.
|
|
889
|
+
:param pulumi.Input['RoleManagementPolicyRuleTargetArgs'] target: The target of the current rule.
|
|
890
|
+
"""
|
|
891
|
+
pulumi.set(__self__, "rule_type", 'RoleManagementPolicyNotificationRule')
|
|
892
|
+
if id is not None:
|
|
893
|
+
pulumi.set(__self__, "id", id)
|
|
894
|
+
if is_default_recipients_enabled is not None:
|
|
895
|
+
pulumi.set(__self__, "is_default_recipients_enabled", is_default_recipients_enabled)
|
|
896
|
+
if notification_level is not None:
|
|
897
|
+
pulumi.set(__self__, "notification_level", notification_level)
|
|
898
|
+
if notification_recipients is not None:
|
|
899
|
+
pulumi.set(__self__, "notification_recipients", notification_recipients)
|
|
900
|
+
if notification_type is not None:
|
|
901
|
+
pulumi.set(__self__, "notification_type", notification_type)
|
|
902
|
+
if recipient_type is not None:
|
|
903
|
+
pulumi.set(__self__, "recipient_type", recipient_type)
|
|
904
|
+
if target is not None:
|
|
905
|
+
pulumi.set(__self__, "target", target)
|
|
906
|
+
|
|
907
|
+
@property
|
|
908
|
+
@pulumi.getter(name="ruleType")
|
|
909
|
+
def rule_type(self) -> pulumi.Input[str]:
|
|
910
|
+
"""
|
|
911
|
+
The type of rule
|
|
912
|
+
Expected value is 'RoleManagementPolicyNotificationRule'.
|
|
913
|
+
"""
|
|
914
|
+
return pulumi.get(self, "rule_type")
|
|
915
|
+
|
|
916
|
+
@rule_type.setter
|
|
917
|
+
def rule_type(self, value: pulumi.Input[str]):
|
|
918
|
+
pulumi.set(self, "rule_type", value)
|
|
919
|
+
|
|
920
|
+
@property
|
|
921
|
+
@pulumi.getter
|
|
922
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
923
|
+
"""
|
|
924
|
+
The id of the rule.
|
|
925
|
+
"""
|
|
926
|
+
return pulumi.get(self, "id")
|
|
927
|
+
|
|
928
|
+
@id.setter
|
|
929
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
930
|
+
pulumi.set(self, "id", value)
|
|
931
|
+
|
|
932
|
+
@property
|
|
933
|
+
@pulumi.getter(name="isDefaultRecipientsEnabled")
|
|
934
|
+
def is_default_recipients_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
935
|
+
"""
|
|
936
|
+
Determines if the notification will be sent to the recipient type specified in the policy rule.
|
|
937
|
+
"""
|
|
938
|
+
return pulumi.get(self, "is_default_recipients_enabled")
|
|
939
|
+
|
|
940
|
+
@is_default_recipients_enabled.setter
|
|
941
|
+
def is_default_recipients_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
942
|
+
pulumi.set(self, "is_default_recipients_enabled", value)
|
|
943
|
+
|
|
944
|
+
@property
|
|
945
|
+
@pulumi.getter(name="notificationLevel")
|
|
946
|
+
def notification_level(self) -> Optional[pulumi.Input[Union[str, 'NotificationLevel']]]:
|
|
947
|
+
"""
|
|
948
|
+
The notification level.
|
|
949
|
+
"""
|
|
950
|
+
return pulumi.get(self, "notification_level")
|
|
951
|
+
|
|
952
|
+
@notification_level.setter
|
|
953
|
+
def notification_level(self, value: Optional[pulumi.Input[Union[str, 'NotificationLevel']]]):
|
|
954
|
+
pulumi.set(self, "notification_level", value)
|
|
955
|
+
|
|
956
|
+
@property
|
|
957
|
+
@pulumi.getter(name="notificationRecipients")
|
|
958
|
+
def notification_recipients(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
959
|
+
"""
|
|
960
|
+
The list of notification recipients.
|
|
961
|
+
"""
|
|
962
|
+
return pulumi.get(self, "notification_recipients")
|
|
963
|
+
|
|
964
|
+
@notification_recipients.setter
|
|
965
|
+
def notification_recipients(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
966
|
+
pulumi.set(self, "notification_recipients", value)
|
|
967
|
+
|
|
968
|
+
@property
|
|
969
|
+
@pulumi.getter(name="notificationType")
|
|
970
|
+
def notification_type(self) -> Optional[pulumi.Input[Union[str, 'NotificationDeliveryMechanism']]]:
|
|
971
|
+
"""
|
|
972
|
+
The type of notification.
|
|
973
|
+
"""
|
|
974
|
+
return pulumi.get(self, "notification_type")
|
|
975
|
+
|
|
976
|
+
@notification_type.setter
|
|
977
|
+
def notification_type(self, value: Optional[pulumi.Input[Union[str, 'NotificationDeliveryMechanism']]]):
|
|
978
|
+
pulumi.set(self, "notification_type", value)
|
|
979
|
+
|
|
980
|
+
@property
|
|
981
|
+
@pulumi.getter(name="recipientType")
|
|
982
|
+
def recipient_type(self) -> Optional[pulumi.Input[Union[str, 'RecipientType']]]:
|
|
983
|
+
"""
|
|
984
|
+
The recipient type.
|
|
985
|
+
"""
|
|
986
|
+
return pulumi.get(self, "recipient_type")
|
|
987
|
+
|
|
988
|
+
@recipient_type.setter
|
|
989
|
+
def recipient_type(self, value: Optional[pulumi.Input[Union[str, 'RecipientType']]]):
|
|
990
|
+
pulumi.set(self, "recipient_type", value)
|
|
991
|
+
|
|
992
|
+
@property
|
|
993
|
+
@pulumi.getter
|
|
994
|
+
def target(self) -> Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']]:
|
|
995
|
+
"""
|
|
996
|
+
The target of the current rule.
|
|
997
|
+
"""
|
|
998
|
+
return pulumi.get(self, "target")
|
|
999
|
+
|
|
1000
|
+
@target.setter
|
|
1001
|
+
def target(self, value: Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']]):
|
|
1002
|
+
pulumi.set(self, "target", value)
|
|
1003
|
+
|
|
1004
|
+
|
|
1005
|
+
if not MYPY:
|
|
1006
|
+
class RoleManagementPolicyPimOnlyModeRuleArgsDict(TypedDict):
|
|
1007
|
+
"""
|
|
1008
|
+
The role management policy PIM only mode rule.
|
|
1009
|
+
"""
|
|
1010
|
+
rule_type: pulumi.Input[str]
|
|
1011
|
+
"""
|
|
1012
|
+
The type of rule
|
|
1013
|
+
Expected value is 'RoleManagementPolicyPimOnlyModeRule'.
|
|
1014
|
+
"""
|
|
1015
|
+
id: NotRequired[pulumi.Input[str]]
|
|
1016
|
+
"""
|
|
1017
|
+
The id of the rule.
|
|
1018
|
+
"""
|
|
1019
|
+
pim_only_mode_settings: NotRequired[pulumi.Input['PIMOnlyModeSettingsArgsDict']]
|
|
1020
|
+
"""
|
|
1021
|
+
The PIM Only Mode settings
|
|
1022
|
+
"""
|
|
1023
|
+
target: NotRequired[pulumi.Input['RoleManagementPolicyRuleTargetArgsDict']]
|
|
1024
|
+
"""
|
|
1025
|
+
The target of the current rule.
|
|
1026
|
+
"""
|
|
1027
|
+
elif False:
|
|
1028
|
+
RoleManagementPolicyPimOnlyModeRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
1029
|
+
|
|
1030
|
+
@pulumi.input_type
|
|
1031
|
+
class RoleManagementPolicyPimOnlyModeRuleArgs:
|
|
1032
|
+
def __init__(__self__, *,
|
|
1033
|
+
rule_type: pulumi.Input[str],
|
|
1034
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
1035
|
+
pim_only_mode_settings: Optional[pulumi.Input['PIMOnlyModeSettingsArgs']] = None,
|
|
1036
|
+
target: Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']] = None):
|
|
1037
|
+
"""
|
|
1038
|
+
The role management policy PIM only mode rule.
|
|
1039
|
+
:param pulumi.Input[str] rule_type: The type of rule
|
|
1040
|
+
Expected value is 'RoleManagementPolicyPimOnlyModeRule'.
|
|
1041
|
+
:param pulumi.Input[str] id: The id of the rule.
|
|
1042
|
+
:param pulumi.Input['PIMOnlyModeSettingsArgs'] pim_only_mode_settings: The PIM Only Mode settings
|
|
1043
|
+
:param pulumi.Input['RoleManagementPolicyRuleTargetArgs'] target: The target of the current rule.
|
|
1044
|
+
"""
|
|
1045
|
+
pulumi.set(__self__, "rule_type", 'RoleManagementPolicyPimOnlyModeRule')
|
|
1046
|
+
if id is not None:
|
|
1047
|
+
pulumi.set(__self__, "id", id)
|
|
1048
|
+
if pim_only_mode_settings is not None:
|
|
1049
|
+
pulumi.set(__self__, "pim_only_mode_settings", pim_only_mode_settings)
|
|
1050
|
+
if target is not None:
|
|
1051
|
+
pulumi.set(__self__, "target", target)
|
|
1052
|
+
|
|
1053
|
+
@property
|
|
1054
|
+
@pulumi.getter(name="ruleType")
|
|
1055
|
+
def rule_type(self) -> pulumi.Input[str]:
|
|
1056
|
+
"""
|
|
1057
|
+
The type of rule
|
|
1058
|
+
Expected value is 'RoleManagementPolicyPimOnlyModeRule'.
|
|
1059
|
+
"""
|
|
1060
|
+
return pulumi.get(self, "rule_type")
|
|
1061
|
+
|
|
1062
|
+
@rule_type.setter
|
|
1063
|
+
def rule_type(self, value: pulumi.Input[str]):
|
|
1064
|
+
pulumi.set(self, "rule_type", value)
|
|
1065
|
+
|
|
1066
|
+
@property
|
|
1067
|
+
@pulumi.getter
|
|
1068
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
1069
|
+
"""
|
|
1070
|
+
The id of the rule.
|
|
1071
|
+
"""
|
|
1072
|
+
return pulumi.get(self, "id")
|
|
1073
|
+
|
|
1074
|
+
@id.setter
|
|
1075
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
1076
|
+
pulumi.set(self, "id", value)
|
|
1077
|
+
|
|
1078
|
+
@property
|
|
1079
|
+
@pulumi.getter(name="pimOnlyModeSettings")
|
|
1080
|
+
def pim_only_mode_settings(self) -> Optional[pulumi.Input['PIMOnlyModeSettingsArgs']]:
|
|
1081
|
+
"""
|
|
1082
|
+
The PIM Only Mode settings
|
|
1083
|
+
"""
|
|
1084
|
+
return pulumi.get(self, "pim_only_mode_settings")
|
|
1085
|
+
|
|
1086
|
+
@pim_only_mode_settings.setter
|
|
1087
|
+
def pim_only_mode_settings(self, value: Optional[pulumi.Input['PIMOnlyModeSettingsArgs']]):
|
|
1088
|
+
pulumi.set(self, "pim_only_mode_settings", value)
|
|
1089
|
+
|
|
1090
|
+
@property
|
|
1091
|
+
@pulumi.getter
|
|
1092
|
+
def target(self) -> Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']]:
|
|
1093
|
+
"""
|
|
1094
|
+
The target of the current rule.
|
|
1095
|
+
"""
|
|
1096
|
+
return pulumi.get(self, "target")
|
|
1097
|
+
|
|
1098
|
+
@target.setter
|
|
1099
|
+
def target(self, value: Optional[pulumi.Input['RoleManagementPolicyRuleTargetArgs']]):
|
|
1100
|
+
pulumi.set(self, "target", value)
|
|
1101
|
+
|
|
1102
|
+
|
|
1103
|
+
if not MYPY:
|
|
1104
|
+
class RoleManagementPolicyRuleTargetArgsDict(TypedDict):
|
|
1105
|
+
"""
|
|
1106
|
+
The role management policy rule target.
|
|
1107
|
+
"""
|
|
1108
|
+
caller: NotRequired[pulumi.Input[str]]
|
|
1109
|
+
"""
|
|
1110
|
+
The caller of the setting.
|
|
1111
|
+
"""
|
|
1112
|
+
enforced_settings: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1113
|
+
"""
|
|
1114
|
+
The list of enforced settings.
|
|
1115
|
+
"""
|
|
1116
|
+
inheritable_settings: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1117
|
+
"""
|
|
1118
|
+
The list of inheritable settings.
|
|
1119
|
+
"""
|
|
1120
|
+
level: NotRequired[pulumi.Input[str]]
|
|
1121
|
+
"""
|
|
1122
|
+
The assignment level to which rule is applied.
|
|
1123
|
+
"""
|
|
1124
|
+
operations: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1125
|
+
"""
|
|
1126
|
+
The type of operation.
|
|
1127
|
+
"""
|
|
1128
|
+
target_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1129
|
+
"""
|
|
1130
|
+
The list of target objects.
|
|
1131
|
+
"""
|
|
1132
|
+
elif False:
|
|
1133
|
+
RoleManagementPolicyRuleTargetArgsDict: TypeAlias = Mapping[str, Any]
|
|
1134
|
+
|
|
1135
|
+
@pulumi.input_type
|
|
1136
|
+
class RoleManagementPolicyRuleTargetArgs:
|
|
1137
|
+
def __init__(__self__, *,
|
|
1138
|
+
caller: Optional[pulumi.Input[str]] = None,
|
|
1139
|
+
enforced_settings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1140
|
+
inheritable_settings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1141
|
+
level: Optional[pulumi.Input[str]] = None,
|
|
1142
|
+
operations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1143
|
+
target_objects: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
1144
|
+
"""
|
|
1145
|
+
The role management policy rule target.
|
|
1146
|
+
:param pulumi.Input[str] caller: The caller of the setting.
|
|
1147
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] enforced_settings: The list of enforced settings.
|
|
1148
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] inheritable_settings: The list of inheritable settings.
|
|
1149
|
+
:param pulumi.Input[str] level: The assignment level to which rule is applied.
|
|
1150
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] operations: The type of operation.
|
|
1151
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] target_objects: The list of target objects.
|
|
1152
|
+
"""
|
|
1153
|
+
if caller is not None:
|
|
1154
|
+
pulumi.set(__self__, "caller", caller)
|
|
1155
|
+
if enforced_settings is not None:
|
|
1156
|
+
pulumi.set(__self__, "enforced_settings", enforced_settings)
|
|
1157
|
+
if inheritable_settings is not None:
|
|
1158
|
+
pulumi.set(__self__, "inheritable_settings", inheritable_settings)
|
|
1159
|
+
if level is not None:
|
|
1160
|
+
pulumi.set(__self__, "level", level)
|
|
1161
|
+
if operations is not None:
|
|
1162
|
+
pulumi.set(__self__, "operations", operations)
|
|
1163
|
+
if target_objects is not None:
|
|
1164
|
+
pulumi.set(__self__, "target_objects", target_objects)
|
|
1165
|
+
|
|
1166
|
+
@property
|
|
1167
|
+
@pulumi.getter
|
|
1168
|
+
def caller(self) -> Optional[pulumi.Input[str]]:
|
|
1169
|
+
"""
|
|
1170
|
+
The caller of the setting.
|
|
1171
|
+
"""
|
|
1172
|
+
return pulumi.get(self, "caller")
|
|
1173
|
+
|
|
1174
|
+
@caller.setter
|
|
1175
|
+
def caller(self, value: Optional[pulumi.Input[str]]):
|
|
1176
|
+
pulumi.set(self, "caller", value)
|
|
1177
|
+
|
|
1178
|
+
@property
|
|
1179
|
+
@pulumi.getter(name="enforcedSettings")
|
|
1180
|
+
def enforced_settings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1181
|
+
"""
|
|
1182
|
+
The list of enforced settings.
|
|
1183
|
+
"""
|
|
1184
|
+
return pulumi.get(self, "enforced_settings")
|
|
1185
|
+
|
|
1186
|
+
@enforced_settings.setter
|
|
1187
|
+
def enforced_settings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1188
|
+
pulumi.set(self, "enforced_settings", value)
|
|
1189
|
+
|
|
1190
|
+
@property
|
|
1191
|
+
@pulumi.getter(name="inheritableSettings")
|
|
1192
|
+
def inheritable_settings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1193
|
+
"""
|
|
1194
|
+
The list of inheritable settings.
|
|
1195
|
+
"""
|
|
1196
|
+
return pulumi.get(self, "inheritable_settings")
|
|
1197
|
+
|
|
1198
|
+
@inheritable_settings.setter
|
|
1199
|
+
def inheritable_settings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1200
|
+
pulumi.set(self, "inheritable_settings", value)
|
|
1201
|
+
|
|
1202
|
+
@property
|
|
1203
|
+
@pulumi.getter
|
|
1204
|
+
def level(self) -> Optional[pulumi.Input[str]]:
|
|
1205
|
+
"""
|
|
1206
|
+
The assignment level to which rule is applied.
|
|
1207
|
+
"""
|
|
1208
|
+
return pulumi.get(self, "level")
|
|
1209
|
+
|
|
1210
|
+
@level.setter
|
|
1211
|
+
def level(self, value: Optional[pulumi.Input[str]]):
|
|
1212
|
+
pulumi.set(self, "level", value)
|
|
1213
|
+
|
|
1214
|
+
@property
|
|
1215
|
+
@pulumi.getter
|
|
1216
|
+
def operations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1217
|
+
"""
|
|
1218
|
+
The type of operation.
|
|
1219
|
+
"""
|
|
1220
|
+
return pulumi.get(self, "operations")
|
|
1221
|
+
|
|
1222
|
+
@operations.setter
|
|
1223
|
+
def operations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1224
|
+
pulumi.set(self, "operations", value)
|
|
1225
|
+
|
|
1226
|
+
@property
|
|
1227
|
+
@pulumi.getter(name="targetObjects")
|
|
1228
|
+
def target_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1229
|
+
"""
|
|
1230
|
+
The list of target objects.
|
|
1231
|
+
"""
|
|
1232
|
+
return pulumi.get(self, "target_objects")
|
|
1233
|
+
|
|
1234
|
+
@target_objects.setter
|
|
1235
|
+
def target_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1236
|
+
pulumi.set(self, "target_objects", value)
|
|
1237
|
+
|
|
1238
|
+
|
|
1239
|
+
if not MYPY:
|
|
1240
|
+
class UserSetArgsDict(TypedDict):
|
|
1241
|
+
"""
|
|
1242
|
+
The detail of a user.
|
|
1243
|
+
"""
|
|
1244
|
+
description: NotRequired[pulumi.Input[str]]
|
|
1245
|
+
"""
|
|
1246
|
+
The description of the user.
|
|
1247
|
+
"""
|
|
1248
|
+
id: NotRequired[pulumi.Input[str]]
|
|
1249
|
+
"""
|
|
1250
|
+
The object id of the user.
|
|
1251
|
+
"""
|
|
1252
|
+
is_backup: NotRequired[pulumi.Input[bool]]
|
|
1253
|
+
"""
|
|
1254
|
+
The value indicating whether the user is a backup fallback approver
|
|
1255
|
+
"""
|
|
1256
|
+
user_type: NotRequired[pulumi.Input[Union[str, 'UserType']]]
|
|
1257
|
+
"""
|
|
1258
|
+
The type of user.
|
|
1259
|
+
"""
|
|
1260
|
+
elif False:
|
|
1261
|
+
UserSetArgsDict: TypeAlias = Mapping[str, Any]
|
|
1262
|
+
|
|
1263
|
+
@pulumi.input_type
|
|
1264
|
+
class UserSetArgs:
|
|
1265
|
+
def __init__(__self__, *,
|
|
1266
|
+
description: Optional[pulumi.Input[str]] = None,
|
|
1267
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
1268
|
+
is_backup: Optional[pulumi.Input[bool]] = None,
|
|
1269
|
+
user_type: Optional[pulumi.Input[Union[str, 'UserType']]] = None):
|
|
1270
|
+
"""
|
|
1271
|
+
The detail of a user.
|
|
1272
|
+
:param pulumi.Input[str] description: The description of the user.
|
|
1273
|
+
:param pulumi.Input[str] id: The object id of the user.
|
|
1274
|
+
:param pulumi.Input[bool] is_backup: The value indicating whether the user is a backup fallback approver
|
|
1275
|
+
:param pulumi.Input[Union[str, 'UserType']] user_type: The type of user.
|
|
1276
|
+
"""
|
|
1277
|
+
if description is not None:
|
|
1278
|
+
pulumi.set(__self__, "description", description)
|
|
1279
|
+
if id is not None:
|
|
1280
|
+
pulumi.set(__self__, "id", id)
|
|
1281
|
+
if is_backup is not None:
|
|
1282
|
+
pulumi.set(__self__, "is_backup", is_backup)
|
|
1283
|
+
if user_type is not None:
|
|
1284
|
+
pulumi.set(__self__, "user_type", user_type)
|
|
1285
|
+
|
|
1286
|
+
@property
|
|
1287
|
+
@pulumi.getter
|
|
1288
|
+
def description(self) -> Optional[pulumi.Input[str]]:
|
|
1289
|
+
"""
|
|
1290
|
+
The description of the user.
|
|
1291
|
+
"""
|
|
1292
|
+
return pulumi.get(self, "description")
|
|
1293
|
+
|
|
1294
|
+
@description.setter
|
|
1295
|
+
def description(self, value: Optional[pulumi.Input[str]]):
|
|
1296
|
+
pulumi.set(self, "description", value)
|
|
1297
|
+
|
|
1298
|
+
@property
|
|
1299
|
+
@pulumi.getter
|
|
1300
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
1301
|
+
"""
|
|
1302
|
+
The object id of the user.
|
|
1303
|
+
"""
|
|
1304
|
+
return pulumi.get(self, "id")
|
|
1305
|
+
|
|
1306
|
+
@id.setter
|
|
1307
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
1308
|
+
pulumi.set(self, "id", value)
|
|
1309
|
+
|
|
1310
|
+
@property
|
|
1311
|
+
@pulumi.getter(name="isBackup")
|
|
1312
|
+
def is_backup(self) -> Optional[pulumi.Input[bool]]:
|
|
1313
|
+
"""
|
|
1314
|
+
The value indicating whether the user is a backup fallback approver
|
|
1315
|
+
"""
|
|
1316
|
+
return pulumi.get(self, "is_backup")
|
|
1317
|
+
|
|
1318
|
+
@is_backup.setter
|
|
1319
|
+
def is_backup(self, value: Optional[pulumi.Input[bool]]):
|
|
1320
|
+
pulumi.set(self, "is_backup", value)
|
|
1321
|
+
|
|
1322
|
+
@property
|
|
1323
|
+
@pulumi.getter(name="userType")
|
|
1324
|
+
def user_type(self) -> Optional[pulumi.Input[Union[str, 'UserType']]]:
|
|
1325
|
+
"""
|
|
1326
|
+
The type of user.
|
|
1327
|
+
"""
|
|
1328
|
+
return pulumi.get(self, "user_type")
|
|
1329
|
+
|
|
1330
|
+
@user_type.setter
|
|
1331
|
+
def user_type(self, value: Optional[pulumi.Input[Union[str, 'UserType']]]):
|
|
1332
|
+
pulumi.set(self, "user_type", value)
|
|
1333
|
+
|
|
1334
|
+
|
|
1335
|
+
if not MYPY:
|
|
1336
|
+
class UsersOrServicePrincipalSetArgsDict(TypedDict):
|
|
1337
|
+
"""
|
|
1338
|
+
The detail of a subject.
|
|
1339
|
+
"""
|
|
1340
|
+
display_name: NotRequired[pulumi.Input[str]]
|
|
1341
|
+
"""
|
|
1342
|
+
The display Name of the entity.
|
|
1343
|
+
"""
|
|
1344
|
+
id: NotRequired[pulumi.Input[str]]
|
|
1345
|
+
"""
|
|
1346
|
+
The object id of the entity.
|
|
1347
|
+
"""
|
|
1348
|
+
type: NotRequired[pulumi.Input[Union[str, 'UserType']]]
|
|
1349
|
+
"""
|
|
1350
|
+
The type of user.
|
|
1351
|
+
"""
|
|
1352
|
+
elif False:
|
|
1353
|
+
UsersOrServicePrincipalSetArgsDict: TypeAlias = Mapping[str, Any]
|
|
1354
|
+
|
|
1355
|
+
@pulumi.input_type
|
|
1356
|
+
class UsersOrServicePrincipalSetArgs:
|
|
1357
|
+
def __init__(__self__, *,
|
|
1358
|
+
display_name: Optional[pulumi.Input[str]] = None,
|
|
1359
|
+
id: Optional[pulumi.Input[str]] = None,
|
|
1360
|
+
type: Optional[pulumi.Input[Union[str, 'UserType']]] = None):
|
|
1361
|
+
"""
|
|
1362
|
+
The detail of a subject.
|
|
1363
|
+
:param pulumi.Input[str] display_name: The display Name of the entity.
|
|
1364
|
+
:param pulumi.Input[str] id: The object id of the entity.
|
|
1365
|
+
:param pulumi.Input[Union[str, 'UserType']] type: The type of user.
|
|
1366
|
+
"""
|
|
1367
|
+
if display_name is not None:
|
|
1368
|
+
pulumi.set(__self__, "display_name", display_name)
|
|
1369
|
+
if id is not None:
|
|
1370
|
+
pulumi.set(__self__, "id", id)
|
|
1371
|
+
if type is not None:
|
|
1372
|
+
pulumi.set(__self__, "type", type)
|
|
1373
|
+
|
|
1374
|
+
@property
|
|
1375
|
+
@pulumi.getter(name="displayName")
|
|
1376
|
+
def display_name(self) -> Optional[pulumi.Input[str]]:
|
|
1377
|
+
"""
|
|
1378
|
+
The display Name of the entity.
|
|
1379
|
+
"""
|
|
1380
|
+
return pulumi.get(self, "display_name")
|
|
1381
|
+
|
|
1382
|
+
@display_name.setter
|
|
1383
|
+
def display_name(self, value: Optional[pulumi.Input[str]]):
|
|
1384
|
+
pulumi.set(self, "display_name", value)
|
|
1385
|
+
|
|
1386
|
+
@property
|
|
1387
|
+
@pulumi.getter
|
|
1388
|
+
def id(self) -> Optional[pulumi.Input[str]]:
|
|
1389
|
+
"""
|
|
1390
|
+
The object id of the entity.
|
|
1391
|
+
"""
|
|
1392
|
+
return pulumi.get(self, "id")
|
|
1393
|
+
|
|
1394
|
+
@id.setter
|
|
1395
|
+
def id(self, value: Optional[pulumi.Input[str]]):
|
|
1396
|
+
pulumi.set(self, "id", value)
|
|
1397
|
+
|
|
1398
|
+
@property
|
|
1399
|
+
@pulumi.getter
|
|
1400
|
+
def type(self) -> Optional[pulumi.Input[Union[str, 'UserType']]]:
|
|
1401
|
+
"""
|
|
1402
|
+
The type of user.
|
|
1403
|
+
"""
|
|
1404
|
+
return pulumi.get(self, "type")
|
|
1405
|
+
|
|
1406
|
+
@type.setter
|
|
1407
|
+
def type(self, value: Optional[pulumi.Input[Union[str, 'UserType']]]):
|
|
1408
|
+
pulumi.set(self, "type", value)
|
|
1409
|
+
|
|
1410
|
+
|