pulumi-azure-native 2.78.0__py3-none-any.whl → 2.78.0a1734029897__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 +16 -0
- pulumi_azure_native/alertsmanagement/__init__.py +6 -0
- pulumi_azure_native/alertsmanagement/action_rule_by_name.py +1 -1
- pulumi_azure_native/alertsmanagement/alert_processing_rule_by_name.py +5 -1
- pulumi_azure_native/alertsmanagement/get_alert_processing_rule_by_name.py +4 -0
- pulumi_azure_native/alertsmanagement/v20190505preview/action_rule_by_name.py +1 -1
- pulumi_azure_native/alertsmanagement/v20210808/alert_processing_rule_by_name.py +1 -1
- pulumi_azure_native/alertsmanagement/v20230501preview/__init__.py +12 -0
- pulumi_azure_native/alertsmanagement/v20230501preview/_enums.py +80 -0
- pulumi_azure_native/alertsmanagement/v20230501preview/_inputs.py +868 -0
- pulumi_azure_native/alertsmanagement/v20230501preview/alert_processing_rule_by_name.py +258 -0
- pulumi_azure_native/alertsmanagement/v20230501preview/get_alert_processing_rule_by_name.py +171 -0
- pulumi_azure_native/alertsmanagement/v20230501preview/outputs.py +795 -0
- pulumi_azure_native/alertsmanagement/v20240301preview/__init__.py +12 -0
- pulumi_azure_native/alertsmanagement/v20240301preview/_enums.py +88 -0
- pulumi_azure_native/alertsmanagement/v20240301preview/_inputs.py +965 -0
- pulumi_azure_native/alertsmanagement/v20240301preview/alert_processing_rule_by_name.py +258 -0
- pulumi_azure_native/alertsmanagement/v20240301preview/get_alert_processing_rule_by_name.py +171 -0
- pulumi_azure_native/alertsmanagement/v20240301preview/outputs.py +877 -0
- pulumi_azure_native/pulumi-plugin.json +1 -1
- {pulumi_azure_native-2.78.0.dist-info → pulumi_azure_native-2.78.0a1734029897.dist-info}/METADATA +3 -3
- {pulumi_azure_native-2.78.0.dist-info → pulumi_azure_native-2.78.0a1734029897.dist-info}/RECORD +24 -12
- {pulumi_azure_native-2.78.0.dist-info → pulumi_azure_native-2.78.0a1734029897.dist-info}/WHEEL +0 -0
- {pulumi_azure_native-2.78.0.dist-info → pulumi_azure_native-2.78.0a1734029897.dist-info}/top_level.txt +0 -0
|
@@ -0,0 +1,965 @@
|
|
|
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
|
+
'AddActionGroupsArgs',
|
|
20
|
+
'AddActionGroupsArgsDict',
|
|
21
|
+
'AlertProcessingRulePropertiesArgs',
|
|
22
|
+
'AlertProcessingRulePropertiesArgsDict',
|
|
23
|
+
'ConditionArgs',
|
|
24
|
+
'ConditionArgsDict',
|
|
25
|
+
'CorrelateAlertsArgs',
|
|
26
|
+
'CorrelateAlertsArgsDict',
|
|
27
|
+
'CorrelateByArgs',
|
|
28
|
+
'CorrelateByArgsDict',
|
|
29
|
+
'CorrelationUpdatesArgs',
|
|
30
|
+
'CorrelationUpdatesArgsDict',
|
|
31
|
+
'DailyRecurrenceArgs',
|
|
32
|
+
'DailyRecurrenceArgsDict',
|
|
33
|
+
'MonthlyRecurrenceArgs',
|
|
34
|
+
'MonthlyRecurrenceArgsDict',
|
|
35
|
+
'RemoveAllActionGroupsArgs',
|
|
36
|
+
'RemoveAllActionGroupsArgsDict',
|
|
37
|
+
'ScheduleArgs',
|
|
38
|
+
'ScheduleArgsDict',
|
|
39
|
+
'WeeklyRecurrenceArgs',
|
|
40
|
+
'WeeklyRecurrenceArgsDict',
|
|
41
|
+
]
|
|
42
|
+
|
|
43
|
+
MYPY = False
|
|
44
|
+
|
|
45
|
+
if not MYPY:
|
|
46
|
+
class AddActionGroupsArgsDict(TypedDict):
|
|
47
|
+
"""
|
|
48
|
+
Add action groups to alert processing rule.
|
|
49
|
+
"""
|
|
50
|
+
action_group_ids: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
51
|
+
"""
|
|
52
|
+
List of action group Ids to add to alert processing rule.
|
|
53
|
+
"""
|
|
54
|
+
action_type: pulumi.Input[str]
|
|
55
|
+
"""
|
|
56
|
+
Action that should be applied.
|
|
57
|
+
Expected value is 'AddActionGroups'.
|
|
58
|
+
"""
|
|
59
|
+
elif False:
|
|
60
|
+
AddActionGroupsArgsDict: TypeAlias = Mapping[str, Any]
|
|
61
|
+
|
|
62
|
+
@pulumi.input_type
|
|
63
|
+
class AddActionGroupsArgs:
|
|
64
|
+
def __init__(__self__, *,
|
|
65
|
+
action_group_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
66
|
+
action_type: pulumi.Input[str]):
|
|
67
|
+
"""
|
|
68
|
+
Add action groups to alert processing rule.
|
|
69
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] action_group_ids: List of action group Ids to add to alert processing rule.
|
|
70
|
+
:param pulumi.Input[str] action_type: Action that should be applied.
|
|
71
|
+
Expected value is 'AddActionGroups'.
|
|
72
|
+
"""
|
|
73
|
+
pulumi.set(__self__, "action_group_ids", action_group_ids)
|
|
74
|
+
pulumi.set(__self__, "action_type", 'AddActionGroups')
|
|
75
|
+
|
|
76
|
+
@property
|
|
77
|
+
@pulumi.getter(name="actionGroupIds")
|
|
78
|
+
def action_group_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
79
|
+
"""
|
|
80
|
+
List of action group Ids to add to alert processing rule.
|
|
81
|
+
"""
|
|
82
|
+
return pulumi.get(self, "action_group_ids")
|
|
83
|
+
|
|
84
|
+
@action_group_ids.setter
|
|
85
|
+
def action_group_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
86
|
+
pulumi.set(self, "action_group_ids", value)
|
|
87
|
+
|
|
88
|
+
@property
|
|
89
|
+
@pulumi.getter(name="actionType")
|
|
90
|
+
def action_type(self) -> pulumi.Input[str]:
|
|
91
|
+
"""
|
|
92
|
+
Action that should be applied.
|
|
93
|
+
Expected value is 'AddActionGroups'.
|
|
94
|
+
"""
|
|
95
|
+
return pulumi.get(self, "action_type")
|
|
96
|
+
|
|
97
|
+
@action_type.setter
|
|
98
|
+
def action_type(self, value: pulumi.Input[str]):
|
|
99
|
+
pulumi.set(self, "action_type", value)
|
|
100
|
+
|
|
101
|
+
|
|
102
|
+
if not MYPY:
|
|
103
|
+
class AlertProcessingRulePropertiesArgsDict(TypedDict):
|
|
104
|
+
"""
|
|
105
|
+
Alert processing rule properties defining scopes, conditions and scheduling logic for alert processing rule.
|
|
106
|
+
"""
|
|
107
|
+
actions: pulumi.Input[Sequence[pulumi.Input[Union['AddActionGroupsArgsDict', 'CorrelateAlertsArgsDict', 'RemoveAllActionGroupsArgsDict']]]]
|
|
108
|
+
"""
|
|
109
|
+
Actions to be applied.
|
|
110
|
+
"""
|
|
111
|
+
scopes: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
112
|
+
"""
|
|
113
|
+
Scopes on which alert processing rule will apply.
|
|
114
|
+
"""
|
|
115
|
+
conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConditionArgsDict']]]]
|
|
116
|
+
"""
|
|
117
|
+
Conditions on which alerts will be filtered.
|
|
118
|
+
"""
|
|
119
|
+
description: NotRequired[pulumi.Input[str]]
|
|
120
|
+
"""
|
|
121
|
+
Description of alert processing rule.
|
|
122
|
+
"""
|
|
123
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
124
|
+
"""
|
|
125
|
+
Indicates if the given alert processing rule is enabled or disabled.
|
|
126
|
+
"""
|
|
127
|
+
schedule: NotRequired[pulumi.Input['ScheduleArgsDict']]
|
|
128
|
+
"""
|
|
129
|
+
Scheduling for alert processing rule.
|
|
130
|
+
"""
|
|
131
|
+
elif False:
|
|
132
|
+
AlertProcessingRulePropertiesArgsDict: TypeAlias = Mapping[str, Any]
|
|
133
|
+
|
|
134
|
+
@pulumi.input_type
|
|
135
|
+
class AlertProcessingRulePropertiesArgs:
|
|
136
|
+
def __init__(__self__, *,
|
|
137
|
+
actions: pulumi.Input[Sequence[pulumi.Input[Union['AddActionGroupsArgs', 'CorrelateAlertsArgs', 'RemoveAllActionGroupsArgs']]]],
|
|
138
|
+
scopes: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
139
|
+
conditions: Optional[pulumi.Input[Sequence[pulumi.Input['ConditionArgs']]]] = None,
|
|
140
|
+
description: Optional[pulumi.Input[str]] = None,
|
|
141
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
142
|
+
schedule: Optional[pulumi.Input['ScheduleArgs']] = None):
|
|
143
|
+
"""
|
|
144
|
+
Alert processing rule properties defining scopes, conditions and scheduling logic for alert processing rule.
|
|
145
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['AddActionGroupsArgs', 'CorrelateAlertsArgs', 'RemoveAllActionGroupsArgs']]]] actions: Actions to be applied.
|
|
146
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] scopes: Scopes on which alert processing rule will apply.
|
|
147
|
+
:param pulumi.Input[Sequence[pulumi.Input['ConditionArgs']]] conditions: Conditions on which alerts will be filtered.
|
|
148
|
+
:param pulumi.Input[str] description: Description of alert processing rule.
|
|
149
|
+
:param pulumi.Input[bool] enabled: Indicates if the given alert processing rule is enabled or disabled.
|
|
150
|
+
:param pulumi.Input['ScheduleArgs'] schedule: Scheduling for alert processing rule.
|
|
151
|
+
"""
|
|
152
|
+
pulumi.set(__self__, "actions", actions)
|
|
153
|
+
pulumi.set(__self__, "scopes", scopes)
|
|
154
|
+
if conditions is not None:
|
|
155
|
+
pulumi.set(__self__, "conditions", conditions)
|
|
156
|
+
if description is not None:
|
|
157
|
+
pulumi.set(__self__, "description", description)
|
|
158
|
+
if enabled is None:
|
|
159
|
+
enabled = True
|
|
160
|
+
if enabled is not None:
|
|
161
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
162
|
+
if schedule is not None:
|
|
163
|
+
pulumi.set(__self__, "schedule", schedule)
|
|
164
|
+
|
|
165
|
+
@property
|
|
166
|
+
@pulumi.getter
|
|
167
|
+
def actions(self) -> pulumi.Input[Sequence[pulumi.Input[Union['AddActionGroupsArgs', 'CorrelateAlertsArgs', 'RemoveAllActionGroupsArgs']]]]:
|
|
168
|
+
"""
|
|
169
|
+
Actions to be applied.
|
|
170
|
+
"""
|
|
171
|
+
return pulumi.get(self, "actions")
|
|
172
|
+
|
|
173
|
+
@actions.setter
|
|
174
|
+
def actions(self, value: pulumi.Input[Sequence[pulumi.Input[Union['AddActionGroupsArgs', 'CorrelateAlertsArgs', 'RemoveAllActionGroupsArgs']]]]):
|
|
175
|
+
pulumi.set(self, "actions", value)
|
|
176
|
+
|
|
177
|
+
@property
|
|
178
|
+
@pulumi.getter
|
|
179
|
+
def scopes(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
180
|
+
"""
|
|
181
|
+
Scopes on which alert processing rule will apply.
|
|
182
|
+
"""
|
|
183
|
+
return pulumi.get(self, "scopes")
|
|
184
|
+
|
|
185
|
+
@scopes.setter
|
|
186
|
+
def scopes(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
187
|
+
pulumi.set(self, "scopes", value)
|
|
188
|
+
|
|
189
|
+
@property
|
|
190
|
+
@pulumi.getter
|
|
191
|
+
def conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ConditionArgs']]]]:
|
|
192
|
+
"""
|
|
193
|
+
Conditions on which alerts will be filtered.
|
|
194
|
+
"""
|
|
195
|
+
return pulumi.get(self, "conditions")
|
|
196
|
+
|
|
197
|
+
@conditions.setter
|
|
198
|
+
def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ConditionArgs']]]]):
|
|
199
|
+
pulumi.set(self, "conditions", value)
|
|
200
|
+
|
|
201
|
+
@property
|
|
202
|
+
@pulumi.getter
|
|
203
|
+
def description(self) -> Optional[pulumi.Input[str]]:
|
|
204
|
+
"""
|
|
205
|
+
Description of alert processing rule.
|
|
206
|
+
"""
|
|
207
|
+
return pulumi.get(self, "description")
|
|
208
|
+
|
|
209
|
+
@description.setter
|
|
210
|
+
def description(self, value: Optional[pulumi.Input[str]]):
|
|
211
|
+
pulumi.set(self, "description", value)
|
|
212
|
+
|
|
213
|
+
@property
|
|
214
|
+
@pulumi.getter
|
|
215
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
216
|
+
"""
|
|
217
|
+
Indicates if the given alert processing rule is enabled or disabled.
|
|
218
|
+
"""
|
|
219
|
+
return pulumi.get(self, "enabled")
|
|
220
|
+
|
|
221
|
+
@enabled.setter
|
|
222
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
223
|
+
pulumi.set(self, "enabled", value)
|
|
224
|
+
|
|
225
|
+
@property
|
|
226
|
+
@pulumi.getter
|
|
227
|
+
def schedule(self) -> Optional[pulumi.Input['ScheduleArgs']]:
|
|
228
|
+
"""
|
|
229
|
+
Scheduling for alert processing rule.
|
|
230
|
+
"""
|
|
231
|
+
return pulumi.get(self, "schedule")
|
|
232
|
+
|
|
233
|
+
@schedule.setter
|
|
234
|
+
def schedule(self, value: Optional[pulumi.Input['ScheduleArgs']]):
|
|
235
|
+
pulumi.set(self, "schedule", value)
|
|
236
|
+
|
|
237
|
+
|
|
238
|
+
if not MYPY:
|
|
239
|
+
class ConditionArgsDict(TypedDict):
|
|
240
|
+
"""
|
|
241
|
+
Condition to trigger an alert processing rule.
|
|
242
|
+
"""
|
|
243
|
+
field: NotRequired[pulumi.Input[Union[str, 'Field']]]
|
|
244
|
+
"""
|
|
245
|
+
Field for a given condition.
|
|
246
|
+
"""
|
|
247
|
+
operator: NotRequired[pulumi.Input[Union[str, 'Operator']]]
|
|
248
|
+
"""
|
|
249
|
+
Operator for a given condition.
|
|
250
|
+
"""
|
|
251
|
+
values: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
252
|
+
"""
|
|
253
|
+
List of values to match for a given condition.
|
|
254
|
+
"""
|
|
255
|
+
elif False:
|
|
256
|
+
ConditionArgsDict: TypeAlias = Mapping[str, Any]
|
|
257
|
+
|
|
258
|
+
@pulumi.input_type
|
|
259
|
+
class ConditionArgs:
|
|
260
|
+
def __init__(__self__, *,
|
|
261
|
+
field: Optional[pulumi.Input[Union[str, 'Field']]] = None,
|
|
262
|
+
operator: Optional[pulumi.Input[Union[str, 'Operator']]] = None,
|
|
263
|
+
values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
264
|
+
"""
|
|
265
|
+
Condition to trigger an alert processing rule.
|
|
266
|
+
:param pulumi.Input[Union[str, 'Field']] field: Field for a given condition.
|
|
267
|
+
:param pulumi.Input[Union[str, 'Operator']] operator: Operator for a given condition.
|
|
268
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: List of values to match for a given condition.
|
|
269
|
+
"""
|
|
270
|
+
if field is not None:
|
|
271
|
+
pulumi.set(__self__, "field", field)
|
|
272
|
+
if operator is not None:
|
|
273
|
+
pulumi.set(__self__, "operator", operator)
|
|
274
|
+
if values is not None:
|
|
275
|
+
pulumi.set(__self__, "values", values)
|
|
276
|
+
|
|
277
|
+
@property
|
|
278
|
+
@pulumi.getter
|
|
279
|
+
def field(self) -> Optional[pulumi.Input[Union[str, 'Field']]]:
|
|
280
|
+
"""
|
|
281
|
+
Field for a given condition.
|
|
282
|
+
"""
|
|
283
|
+
return pulumi.get(self, "field")
|
|
284
|
+
|
|
285
|
+
@field.setter
|
|
286
|
+
def field(self, value: Optional[pulumi.Input[Union[str, 'Field']]]):
|
|
287
|
+
pulumi.set(self, "field", value)
|
|
288
|
+
|
|
289
|
+
@property
|
|
290
|
+
@pulumi.getter
|
|
291
|
+
def operator(self) -> Optional[pulumi.Input[Union[str, 'Operator']]]:
|
|
292
|
+
"""
|
|
293
|
+
Operator for a given condition.
|
|
294
|
+
"""
|
|
295
|
+
return pulumi.get(self, "operator")
|
|
296
|
+
|
|
297
|
+
@operator.setter
|
|
298
|
+
def operator(self, value: Optional[pulumi.Input[Union[str, 'Operator']]]):
|
|
299
|
+
pulumi.set(self, "operator", value)
|
|
300
|
+
|
|
301
|
+
@property
|
|
302
|
+
@pulumi.getter
|
|
303
|
+
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
304
|
+
"""
|
|
305
|
+
List of values to match for a given condition.
|
|
306
|
+
"""
|
|
307
|
+
return pulumi.get(self, "values")
|
|
308
|
+
|
|
309
|
+
@values.setter
|
|
310
|
+
def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
311
|
+
pulumi.set(self, "values", value)
|
|
312
|
+
|
|
313
|
+
|
|
314
|
+
if not MYPY:
|
|
315
|
+
class CorrelateAlertsArgsDict(TypedDict):
|
|
316
|
+
"""
|
|
317
|
+
Add logic for alerts correlation.
|
|
318
|
+
"""
|
|
319
|
+
action_type: pulumi.Input[str]
|
|
320
|
+
"""
|
|
321
|
+
Action that should be applied.
|
|
322
|
+
Expected value is 'CorrelateAlerts'.
|
|
323
|
+
"""
|
|
324
|
+
correlate_by: pulumi.Input[Sequence[pulumi.Input['CorrelateByArgsDict']]]
|
|
325
|
+
"""
|
|
326
|
+
The list of conditions for the alerts correlations.
|
|
327
|
+
"""
|
|
328
|
+
correlation_interval: pulumi.Input[str]
|
|
329
|
+
"""
|
|
330
|
+
The required duration (in ISO8601 format) for the alerts correlation.
|
|
331
|
+
"""
|
|
332
|
+
priority: pulumi.Input[int]
|
|
333
|
+
"""
|
|
334
|
+
The priority of this correlation.
|
|
335
|
+
"""
|
|
336
|
+
correlation_updates: NotRequired[pulumi.Input['CorrelationUpdatesArgsDict']]
|
|
337
|
+
"""
|
|
338
|
+
Defines the updates to be applied for correlation.
|
|
339
|
+
"""
|
|
340
|
+
notifications_for_correlated_alerts: NotRequired[pulumi.Input[Union[str, 'NotificationsForCorrelatedAlerts']]]
|
|
341
|
+
"""
|
|
342
|
+
Indicates how to handle child alerts notifications.
|
|
343
|
+
"""
|
|
344
|
+
elif False:
|
|
345
|
+
CorrelateAlertsArgsDict: TypeAlias = Mapping[str, Any]
|
|
346
|
+
|
|
347
|
+
@pulumi.input_type
|
|
348
|
+
class CorrelateAlertsArgs:
|
|
349
|
+
def __init__(__self__, *,
|
|
350
|
+
action_type: pulumi.Input[str],
|
|
351
|
+
correlate_by: pulumi.Input[Sequence[pulumi.Input['CorrelateByArgs']]],
|
|
352
|
+
correlation_interval: pulumi.Input[str],
|
|
353
|
+
priority: pulumi.Input[int],
|
|
354
|
+
correlation_updates: Optional[pulumi.Input['CorrelationUpdatesArgs']] = None,
|
|
355
|
+
notifications_for_correlated_alerts: Optional[pulumi.Input[Union[str, 'NotificationsForCorrelatedAlerts']]] = None):
|
|
356
|
+
"""
|
|
357
|
+
Add logic for alerts correlation.
|
|
358
|
+
:param pulumi.Input[str] action_type: Action that should be applied.
|
|
359
|
+
Expected value is 'CorrelateAlerts'.
|
|
360
|
+
:param pulumi.Input[Sequence[pulumi.Input['CorrelateByArgs']]] correlate_by: The list of conditions for the alerts correlations.
|
|
361
|
+
:param pulumi.Input[str] correlation_interval: The required duration (in ISO8601 format) for the alerts correlation.
|
|
362
|
+
:param pulumi.Input[int] priority: The priority of this correlation.
|
|
363
|
+
:param pulumi.Input['CorrelationUpdatesArgs'] correlation_updates: Defines the updates to be applied for correlation.
|
|
364
|
+
:param pulumi.Input[Union[str, 'NotificationsForCorrelatedAlerts']] notifications_for_correlated_alerts: Indicates how to handle child alerts notifications.
|
|
365
|
+
"""
|
|
366
|
+
pulumi.set(__self__, "action_type", 'CorrelateAlerts')
|
|
367
|
+
pulumi.set(__self__, "correlate_by", correlate_by)
|
|
368
|
+
pulumi.set(__self__, "correlation_interval", correlation_interval)
|
|
369
|
+
pulumi.set(__self__, "priority", priority)
|
|
370
|
+
if correlation_updates is not None:
|
|
371
|
+
pulumi.set(__self__, "correlation_updates", correlation_updates)
|
|
372
|
+
if notifications_for_correlated_alerts is None:
|
|
373
|
+
notifications_for_correlated_alerts = 'SuppressAlways'
|
|
374
|
+
if notifications_for_correlated_alerts is not None:
|
|
375
|
+
pulumi.set(__self__, "notifications_for_correlated_alerts", notifications_for_correlated_alerts)
|
|
376
|
+
|
|
377
|
+
@property
|
|
378
|
+
@pulumi.getter(name="actionType")
|
|
379
|
+
def action_type(self) -> pulumi.Input[str]:
|
|
380
|
+
"""
|
|
381
|
+
Action that should be applied.
|
|
382
|
+
Expected value is 'CorrelateAlerts'.
|
|
383
|
+
"""
|
|
384
|
+
return pulumi.get(self, "action_type")
|
|
385
|
+
|
|
386
|
+
@action_type.setter
|
|
387
|
+
def action_type(self, value: pulumi.Input[str]):
|
|
388
|
+
pulumi.set(self, "action_type", value)
|
|
389
|
+
|
|
390
|
+
@property
|
|
391
|
+
@pulumi.getter(name="correlateBy")
|
|
392
|
+
def correlate_by(self) -> pulumi.Input[Sequence[pulumi.Input['CorrelateByArgs']]]:
|
|
393
|
+
"""
|
|
394
|
+
The list of conditions for the alerts correlations.
|
|
395
|
+
"""
|
|
396
|
+
return pulumi.get(self, "correlate_by")
|
|
397
|
+
|
|
398
|
+
@correlate_by.setter
|
|
399
|
+
def correlate_by(self, value: pulumi.Input[Sequence[pulumi.Input['CorrelateByArgs']]]):
|
|
400
|
+
pulumi.set(self, "correlate_by", value)
|
|
401
|
+
|
|
402
|
+
@property
|
|
403
|
+
@pulumi.getter(name="correlationInterval")
|
|
404
|
+
def correlation_interval(self) -> pulumi.Input[str]:
|
|
405
|
+
"""
|
|
406
|
+
The required duration (in ISO8601 format) for the alerts correlation.
|
|
407
|
+
"""
|
|
408
|
+
return pulumi.get(self, "correlation_interval")
|
|
409
|
+
|
|
410
|
+
@correlation_interval.setter
|
|
411
|
+
def correlation_interval(self, value: pulumi.Input[str]):
|
|
412
|
+
pulumi.set(self, "correlation_interval", value)
|
|
413
|
+
|
|
414
|
+
@property
|
|
415
|
+
@pulumi.getter
|
|
416
|
+
def priority(self) -> pulumi.Input[int]:
|
|
417
|
+
"""
|
|
418
|
+
The priority of this correlation.
|
|
419
|
+
"""
|
|
420
|
+
return pulumi.get(self, "priority")
|
|
421
|
+
|
|
422
|
+
@priority.setter
|
|
423
|
+
def priority(self, value: pulumi.Input[int]):
|
|
424
|
+
pulumi.set(self, "priority", value)
|
|
425
|
+
|
|
426
|
+
@property
|
|
427
|
+
@pulumi.getter(name="correlationUpdates")
|
|
428
|
+
def correlation_updates(self) -> Optional[pulumi.Input['CorrelationUpdatesArgs']]:
|
|
429
|
+
"""
|
|
430
|
+
Defines the updates to be applied for correlation.
|
|
431
|
+
"""
|
|
432
|
+
return pulumi.get(self, "correlation_updates")
|
|
433
|
+
|
|
434
|
+
@correlation_updates.setter
|
|
435
|
+
def correlation_updates(self, value: Optional[pulumi.Input['CorrelationUpdatesArgs']]):
|
|
436
|
+
pulumi.set(self, "correlation_updates", value)
|
|
437
|
+
|
|
438
|
+
@property
|
|
439
|
+
@pulumi.getter(name="notificationsForCorrelatedAlerts")
|
|
440
|
+
def notifications_for_correlated_alerts(self) -> Optional[pulumi.Input[Union[str, 'NotificationsForCorrelatedAlerts']]]:
|
|
441
|
+
"""
|
|
442
|
+
Indicates how to handle child alerts notifications.
|
|
443
|
+
"""
|
|
444
|
+
return pulumi.get(self, "notifications_for_correlated_alerts")
|
|
445
|
+
|
|
446
|
+
@notifications_for_correlated_alerts.setter
|
|
447
|
+
def notifications_for_correlated_alerts(self, value: Optional[pulumi.Input[Union[str, 'NotificationsForCorrelatedAlerts']]]):
|
|
448
|
+
pulumi.set(self, "notifications_for_correlated_alerts", value)
|
|
449
|
+
|
|
450
|
+
|
|
451
|
+
if not MYPY:
|
|
452
|
+
class CorrelateByArgsDict(TypedDict):
|
|
453
|
+
"""
|
|
454
|
+
The logic for the correlation.
|
|
455
|
+
"""
|
|
456
|
+
field: NotRequired[pulumi.Input[str]]
|
|
457
|
+
"""
|
|
458
|
+
The JPath of the property that the alerts should be correlated by.
|
|
459
|
+
"""
|
|
460
|
+
elif False:
|
|
461
|
+
CorrelateByArgsDict: TypeAlias = Mapping[str, Any]
|
|
462
|
+
|
|
463
|
+
@pulumi.input_type
|
|
464
|
+
class CorrelateByArgs:
|
|
465
|
+
def __init__(__self__, *,
|
|
466
|
+
field: Optional[pulumi.Input[str]] = None):
|
|
467
|
+
"""
|
|
468
|
+
The logic for the correlation.
|
|
469
|
+
:param pulumi.Input[str] field: The JPath of the property that the alerts should be correlated by.
|
|
470
|
+
"""
|
|
471
|
+
if field is not None:
|
|
472
|
+
pulumi.set(__self__, "field", field)
|
|
473
|
+
|
|
474
|
+
@property
|
|
475
|
+
@pulumi.getter
|
|
476
|
+
def field(self) -> Optional[pulumi.Input[str]]:
|
|
477
|
+
"""
|
|
478
|
+
The JPath of the property that the alerts should be correlated by.
|
|
479
|
+
"""
|
|
480
|
+
return pulumi.get(self, "field")
|
|
481
|
+
|
|
482
|
+
@field.setter
|
|
483
|
+
def field(self, value: Optional[pulumi.Input[str]]):
|
|
484
|
+
pulumi.set(self, "field", value)
|
|
485
|
+
|
|
486
|
+
|
|
487
|
+
if not MYPY:
|
|
488
|
+
class CorrelationUpdatesArgsDict(TypedDict):
|
|
489
|
+
"""
|
|
490
|
+
Defines the updates to be applied for correlation.
|
|
491
|
+
"""
|
|
492
|
+
action_groups: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
493
|
+
"""
|
|
494
|
+
The action group ids.
|
|
495
|
+
"""
|
|
496
|
+
update_interval: pulumi.Input[str]
|
|
497
|
+
"""
|
|
498
|
+
The update interval for notification updates in ISO8601 format.
|
|
499
|
+
"""
|
|
500
|
+
update_type: pulumi.Input[Union[str, 'UpdateType']]
|
|
501
|
+
"""
|
|
502
|
+
The type of update that needs to be performed.
|
|
503
|
+
"""
|
|
504
|
+
elif False:
|
|
505
|
+
CorrelationUpdatesArgsDict: TypeAlias = Mapping[str, Any]
|
|
506
|
+
|
|
507
|
+
@pulumi.input_type
|
|
508
|
+
class CorrelationUpdatesArgs:
|
|
509
|
+
def __init__(__self__, *,
|
|
510
|
+
action_groups: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
511
|
+
update_interval: pulumi.Input[str],
|
|
512
|
+
update_type: Optional[pulumi.Input[Union[str, 'UpdateType']]] = None):
|
|
513
|
+
"""
|
|
514
|
+
Defines the updates to be applied for correlation.
|
|
515
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] action_groups: The action group ids.
|
|
516
|
+
:param pulumi.Input[str] update_interval: The update interval for notification updates in ISO8601 format.
|
|
517
|
+
:param pulumi.Input[Union[str, 'UpdateType']] update_type: The type of update that needs to be performed.
|
|
518
|
+
"""
|
|
519
|
+
pulumi.set(__self__, "action_groups", action_groups)
|
|
520
|
+
pulumi.set(__self__, "update_interval", update_interval)
|
|
521
|
+
if update_type is None:
|
|
522
|
+
update_type = 'timeBased'
|
|
523
|
+
pulumi.set(__self__, "update_type", update_type)
|
|
524
|
+
|
|
525
|
+
@property
|
|
526
|
+
@pulumi.getter(name="actionGroups")
|
|
527
|
+
def action_groups(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
528
|
+
"""
|
|
529
|
+
The action group ids.
|
|
530
|
+
"""
|
|
531
|
+
return pulumi.get(self, "action_groups")
|
|
532
|
+
|
|
533
|
+
@action_groups.setter
|
|
534
|
+
def action_groups(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
535
|
+
pulumi.set(self, "action_groups", value)
|
|
536
|
+
|
|
537
|
+
@property
|
|
538
|
+
@pulumi.getter(name="updateInterval")
|
|
539
|
+
def update_interval(self) -> pulumi.Input[str]:
|
|
540
|
+
"""
|
|
541
|
+
The update interval for notification updates in ISO8601 format.
|
|
542
|
+
"""
|
|
543
|
+
return pulumi.get(self, "update_interval")
|
|
544
|
+
|
|
545
|
+
@update_interval.setter
|
|
546
|
+
def update_interval(self, value: pulumi.Input[str]):
|
|
547
|
+
pulumi.set(self, "update_interval", value)
|
|
548
|
+
|
|
549
|
+
@property
|
|
550
|
+
@pulumi.getter(name="updateType")
|
|
551
|
+
def update_type(self) -> pulumi.Input[Union[str, 'UpdateType']]:
|
|
552
|
+
"""
|
|
553
|
+
The type of update that needs to be performed.
|
|
554
|
+
"""
|
|
555
|
+
return pulumi.get(self, "update_type")
|
|
556
|
+
|
|
557
|
+
@update_type.setter
|
|
558
|
+
def update_type(self, value: pulumi.Input[Union[str, 'UpdateType']]):
|
|
559
|
+
pulumi.set(self, "update_type", value)
|
|
560
|
+
|
|
561
|
+
|
|
562
|
+
if not MYPY:
|
|
563
|
+
class DailyRecurrenceArgsDict(TypedDict):
|
|
564
|
+
"""
|
|
565
|
+
Daily recurrence object.
|
|
566
|
+
"""
|
|
567
|
+
end_time: pulumi.Input[str]
|
|
568
|
+
"""
|
|
569
|
+
End time for recurrence.
|
|
570
|
+
"""
|
|
571
|
+
recurrence_type: pulumi.Input[str]
|
|
572
|
+
"""
|
|
573
|
+
Specifies when the recurrence should be applied.
|
|
574
|
+
Expected value is 'Daily'.
|
|
575
|
+
"""
|
|
576
|
+
start_time: pulumi.Input[str]
|
|
577
|
+
"""
|
|
578
|
+
Start time for recurrence.
|
|
579
|
+
"""
|
|
580
|
+
elif False:
|
|
581
|
+
DailyRecurrenceArgsDict: TypeAlias = Mapping[str, Any]
|
|
582
|
+
|
|
583
|
+
@pulumi.input_type
|
|
584
|
+
class DailyRecurrenceArgs:
|
|
585
|
+
def __init__(__self__, *,
|
|
586
|
+
end_time: pulumi.Input[str],
|
|
587
|
+
recurrence_type: pulumi.Input[str],
|
|
588
|
+
start_time: pulumi.Input[str]):
|
|
589
|
+
"""
|
|
590
|
+
Daily recurrence object.
|
|
591
|
+
:param pulumi.Input[str] end_time: End time for recurrence.
|
|
592
|
+
:param pulumi.Input[str] recurrence_type: Specifies when the recurrence should be applied.
|
|
593
|
+
Expected value is 'Daily'.
|
|
594
|
+
:param pulumi.Input[str] start_time: Start time for recurrence.
|
|
595
|
+
"""
|
|
596
|
+
pulumi.set(__self__, "end_time", end_time)
|
|
597
|
+
pulumi.set(__self__, "recurrence_type", 'Daily')
|
|
598
|
+
pulumi.set(__self__, "start_time", start_time)
|
|
599
|
+
|
|
600
|
+
@property
|
|
601
|
+
@pulumi.getter(name="endTime")
|
|
602
|
+
def end_time(self) -> pulumi.Input[str]:
|
|
603
|
+
"""
|
|
604
|
+
End time for recurrence.
|
|
605
|
+
"""
|
|
606
|
+
return pulumi.get(self, "end_time")
|
|
607
|
+
|
|
608
|
+
@end_time.setter
|
|
609
|
+
def end_time(self, value: pulumi.Input[str]):
|
|
610
|
+
pulumi.set(self, "end_time", value)
|
|
611
|
+
|
|
612
|
+
@property
|
|
613
|
+
@pulumi.getter(name="recurrenceType")
|
|
614
|
+
def recurrence_type(self) -> pulumi.Input[str]:
|
|
615
|
+
"""
|
|
616
|
+
Specifies when the recurrence should be applied.
|
|
617
|
+
Expected value is 'Daily'.
|
|
618
|
+
"""
|
|
619
|
+
return pulumi.get(self, "recurrence_type")
|
|
620
|
+
|
|
621
|
+
@recurrence_type.setter
|
|
622
|
+
def recurrence_type(self, value: pulumi.Input[str]):
|
|
623
|
+
pulumi.set(self, "recurrence_type", value)
|
|
624
|
+
|
|
625
|
+
@property
|
|
626
|
+
@pulumi.getter(name="startTime")
|
|
627
|
+
def start_time(self) -> pulumi.Input[str]:
|
|
628
|
+
"""
|
|
629
|
+
Start time for recurrence.
|
|
630
|
+
"""
|
|
631
|
+
return pulumi.get(self, "start_time")
|
|
632
|
+
|
|
633
|
+
@start_time.setter
|
|
634
|
+
def start_time(self, value: pulumi.Input[str]):
|
|
635
|
+
pulumi.set(self, "start_time", value)
|
|
636
|
+
|
|
637
|
+
|
|
638
|
+
if not MYPY:
|
|
639
|
+
class MonthlyRecurrenceArgsDict(TypedDict):
|
|
640
|
+
"""
|
|
641
|
+
Monthly recurrence object.
|
|
642
|
+
"""
|
|
643
|
+
days_of_month: pulumi.Input[Sequence[pulumi.Input[int]]]
|
|
644
|
+
"""
|
|
645
|
+
Specifies the values for monthly recurrence pattern.
|
|
646
|
+
"""
|
|
647
|
+
recurrence_type: pulumi.Input[str]
|
|
648
|
+
"""
|
|
649
|
+
Specifies when the recurrence should be applied.
|
|
650
|
+
Expected value is 'Monthly'.
|
|
651
|
+
"""
|
|
652
|
+
end_time: NotRequired[pulumi.Input[str]]
|
|
653
|
+
"""
|
|
654
|
+
End time for recurrence.
|
|
655
|
+
"""
|
|
656
|
+
start_time: NotRequired[pulumi.Input[str]]
|
|
657
|
+
"""
|
|
658
|
+
Start time for recurrence.
|
|
659
|
+
"""
|
|
660
|
+
elif False:
|
|
661
|
+
MonthlyRecurrenceArgsDict: TypeAlias = Mapping[str, Any]
|
|
662
|
+
|
|
663
|
+
@pulumi.input_type
|
|
664
|
+
class MonthlyRecurrenceArgs:
|
|
665
|
+
def __init__(__self__, *,
|
|
666
|
+
days_of_month: pulumi.Input[Sequence[pulumi.Input[int]]],
|
|
667
|
+
recurrence_type: pulumi.Input[str],
|
|
668
|
+
end_time: Optional[pulumi.Input[str]] = None,
|
|
669
|
+
start_time: Optional[pulumi.Input[str]] = None):
|
|
670
|
+
"""
|
|
671
|
+
Monthly recurrence object.
|
|
672
|
+
:param pulumi.Input[Sequence[pulumi.Input[int]]] days_of_month: Specifies the values for monthly recurrence pattern.
|
|
673
|
+
:param pulumi.Input[str] recurrence_type: Specifies when the recurrence should be applied.
|
|
674
|
+
Expected value is 'Monthly'.
|
|
675
|
+
:param pulumi.Input[str] end_time: End time for recurrence.
|
|
676
|
+
:param pulumi.Input[str] start_time: Start time for recurrence.
|
|
677
|
+
"""
|
|
678
|
+
pulumi.set(__self__, "days_of_month", days_of_month)
|
|
679
|
+
pulumi.set(__self__, "recurrence_type", 'Monthly')
|
|
680
|
+
if end_time is not None:
|
|
681
|
+
pulumi.set(__self__, "end_time", end_time)
|
|
682
|
+
if start_time is not None:
|
|
683
|
+
pulumi.set(__self__, "start_time", start_time)
|
|
684
|
+
|
|
685
|
+
@property
|
|
686
|
+
@pulumi.getter(name="daysOfMonth")
|
|
687
|
+
def days_of_month(self) -> pulumi.Input[Sequence[pulumi.Input[int]]]:
|
|
688
|
+
"""
|
|
689
|
+
Specifies the values for monthly recurrence pattern.
|
|
690
|
+
"""
|
|
691
|
+
return pulumi.get(self, "days_of_month")
|
|
692
|
+
|
|
693
|
+
@days_of_month.setter
|
|
694
|
+
def days_of_month(self, value: pulumi.Input[Sequence[pulumi.Input[int]]]):
|
|
695
|
+
pulumi.set(self, "days_of_month", value)
|
|
696
|
+
|
|
697
|
+
@property
|
|
698
|
+
@pulumi.getter(name="recurrenceType")
|
|
699
|
+
def recurrence_type(self) -> pulumi.Input[str]:
|
|
700
|
+
"""
|
|
701
|
+
Specifies when the recurrence should be applied.
|
|
702
|
+
Expected value is 'Monthly'.
|
|
703
|
+
"""
|
|
704
|
+
return pulumi.get(self, "recurrence_type")
|
|
705
|
+
|
|
706
|
+
@recurrence_type.setter
|
|
707
|
+
def recurrence_type(self, value: pulumi.Input[str]):
|
|
708
|
+
pulumi.set(self, "recurrence_type", value)
|
|
709
|
+
|
|
710
|
+
@property
|
|
711
|
+
@pulumi.getter(name="endTime")
|
|
712
|
+
def end_time(self) -> Optional[pulumi.Input[str]]:
|
|
713
|
+
"""
|
|
714
|
+
End time for recurrence.
|
|
715
|
+
"""
|
|
716
|
+
return pulumi.get(self, "end_time")
|
|
717
|
+
|
|
718
|
+
@end_time.setter
|
|
719
|
+
def end_time(self, value: Optional[pulumi.Input[str]]):
|
|
720
|
+
pulumi.set(self, "end_time", value)
|
|
721
|
+
|
|
722
|
+
@property
|
|
723
|
+
@pulumi.getter(name="startTime")
|
|
724
|
+
def start_time(self) -> Optional[pulumi.Input[str]]:
|
|
725
|
+
"""
|
|
726
|
+
Start time for recurrence.
|
|
727
|
+
"""
|
|
728
|
+
return pulumi.get(self, "start_time")
|
|
729
|
+
|
|
730
|
+
@start_time.setter
|
|
731
|
+
def start_time(self, value: Optional[pulumi.Input[str]]):
|
|
732
|
+
pulumi.set(self, "start_time", value)
|
|
733
|
+
|
|
734
|
+
|
|
735
|
+
if not MYPY:
|
|
736
|
+
class RemoveAllActionGroupsArgsDict(TypedDict):
|
|
737
|
+
"""
|
|
738
|
+
Indicates if all action groups should be removed.
|
|
739
|
+
"""
|
|
740
|
+
action_type: pulumi.Input[str]
|
|
741
|
+
"""
|
|
742
|
+
Action that should be applied.
|
|
743
|
+
Expected value is 'RemoveAllActionGroups'.
|
|
744
|
+
"""
|
|
745
|
+
elif False:
|
|
746
|
+
RemoveAllActionGroupsArgsDict: TypeAlias = Mapping[str, Any]
|
|
747
|
+
|
|
748
|
+
@pulumi.input_type
|
|
749
|
+
class RemoveAllActionGroupsArgs:
|
|
750
|
+
def __init__(__self__, *,
|
|
751
|
+
action_type: pulumi.Input[str]):
|
|
752
|
+
"""
|
|
753
|
+
Indicates if all action groups should be removed.
|
|
754
|
+
:param pulumi.Input[str] action_type: Action that should be applied.
|
|
755
|
+
Expected value is 'RemoveAllActionGroups'.
|
|
756
|
+
"""
|
|
757
|
+
pulumi.set(__self__, "action_type", 'RemoveAllActionGroups')
|
|
758
|
+
|
|
759
|
+
@property
|
|
760
|
+
@pulumi.getter(name="actionType")
|
|
761
|
+
def action_type(self) -> pulumi.Input[str]:
|
|
762
|
+
"""
|
|
763
|
+
Action that should be applied.
|
|
764
|
+
Expected value is 'RemoveAllActionGroups'.
|
|
765
|
+
"""
|
|
766
|
+
return pulumi.get(self, "action_type")
|
|
767
|
+
|
|
768
|
+
@action_type.setter
|
|
769
|
+
def action_type(self, value: pulumi.Input[str]):
|
|
770
|
+
pulumi.set(self, "action_type", value)
|
|
771
|
+
|
|
772
|
+
|
|
773
|
+
if not MYPY:
|
|
774
|
+
class ScheduleArgsDict(TypedDict):
|
|
775
|
+
"""
|
|
776
|
+
Scheduling configuration for a given alert processing rule.
|
|
777
|
+
"""
|
|
778
|
+
effective_from: NotRequired[pulumi.Input[str]]
|
|
779
|
+
"""
|
|
780
|
+
Scheduling effective from time. Date-Time in ISO-8601 format without timezone suffix.
|
|
781
|
+
"""
|
|
782
|
+
effective_until: NotRequired[pulumi.Input[str]]
|
|
783
|
+
"""
|
|
784
|
+
Scheduling effective until time. Date-Time in ISO-8601 format without timezone suffix.
|
|
785
|
+
"""
|
|
786
|
+
recurrences: NotRequired[pulumi.Input[Sequence[pulumi.Input[Union['DailyRecurrenceArgsDict', 'MonthlyRecurrenceArgsDict', 'WeeklyRecurrenceArgsDict']]]]]
|
|
787
|
+
"""
|
|
788
|
+
List of recurrences.
|
|
789
|
+
"""
|
|
790
|
+
time_zone: NotRequired[pulumi.Input[str]]
|
|
791
|
+
"""
|
|
792
|
+
Scheduling time zone.
|
|
793
|
+
"""
|
|
794
|
+
elif False:
|
|
795
|
+
ScheduleArgsDict: TypeAlias = Mapping[str, Any]
|
|
796
|
+
|
|
797
|
+
@pulumi.input_type
|
|
798
|
+
class ScheduleArgs:
|
|
799
|
+
def __init__(__self__, *,
|
|
800
|
+
effective_from: Optional[pulumi.Input[str]] = None,
|
|
801
|
+
effective_until: Optional[pulumi.Input[str]] = None,
|
|
802
|
+
recurrences: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DailyRecurrenceArgs', 'MonthlyRecurrenceArgs', 'WeeklyRecurrenceArgs']]]]] = None,
|
|
803
|
+
time_zone: Optional[pulumi.Input[str]] = None):
|
|
804
|
+
"""
|
|
805
|
+
Scheduling configuration for a given alert processing rule.
|
|
806
|
+
:param pulumi.Input[str] effective_from: Scheduling effective from time. Date-Time in ISO-8601 format without timezone suffix.
|
|
807
|
+
:param pulumi.Input[str] effective_until: Scheduling effective until time. Date-Time in ISO-8601 format without timezone suffix.
|
|
808
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['DailyRecurrenceArgs', 'MonthlyRecurrenceArgs', 'WeeklyRecurrenceArgs']]]] recurrences: List of recurrences.
|
|
809
|
+
:param pulumi.Input[str] time_zone: Scheduling time zone.
|
|
810
|
+
"""
|
|
811
|
+
if effective_from is not None:
|
|
812
|
+
pulumi.set(__self__, "effective_from", effective_from)
|
|
813
|
+
if effective_until is not None:
|
|
814
|
+
pulumi.set(__self__, "effective_until", effective_until)
|
|
815
|
+
if recurrences is not None:
|
|
816
|
+
pulumi.set(__self__, "recurrences", recurrences)
|
|
817
|
+
if time_zone is not None:
|
|
818
|
+
pulumi.set(__self__, "time_zone", time_zone)
|
|
819
|
+
|
|
820
|
+
@property
|
|
821
|
+
@pulumi.getter(name="effectiveFrom")
|
|
822
|
+
def effective_from(self) -> Optional[pulumi.Input[str]]:
|
|
823
|
+
"""
|
|
824
|
+
Scheduling effective from time. Date-Time in ISO-8601 format without timezone suffix.
|
|
825
|
+
"""
|
|
826
|
+
return pulumi.get(self, "effective_from")
|
|
827
|
+
|
|
828
|
+
@effective_from.setter
|
|
829
|
+
def effective_from(self, value: Optional[pulumi.Input[str]]):
|
|
830
|
+
pulumi.set(self, "effective_from", value)
|
|
831
|
+
|
|
832
|
+
@property
|
|
833
|
+
@pulumi.getter(name="effectiveUntil")
|
|
834
|
+
def effective_until(self) -> Optional[pulumi.Input[str]]:
|
|
835
|
+
"""
|
|
836
|
+
Scheduling effective until time. Date-Time in ISO-8601 format without timezone suffix.
|
|
837
|
+
"""
|
|
838
|
+
return pulumi.get(self, "effective_until")
|
|
839
|
+
|
|
840
|
+
@effective_until.setter
|
|
841
|
+
def effective_until(self, value: Optional[pulumi.Input[str]]):
|
|
842
|
+
pulumi.set(self, "effective_until", value)
|
|
843
|
+
|
|
844
|
+
@property
|
|
845
|
+
@pulumi.getter
|
|
846
|
+
def recurrences(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union['DailyRecurrenceArgs', 'MonthlyRecurrenceArgs', 'WeeklyRecurrenceArgs']]]]]:
|
|
847
|
+
"""
|
|
848
|
+
List of recurrences.
|
|
849
|
+
"""
|
|
850
|
+
return pulumi.get(self, "recurrences")
|
|
851
|
+
|
|
852
|
+
@recurrences.setter
|
|
853
|
+
def recurrences(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DailyRecurrenceArgs', 'MonthlyRecurrenceArgs', 'WeeklyRecurrenceArgs']]]]]):
|
|
854
|
+
pulumi.set(self, "recurrences", value)
|
|
855
|
+
|
|
856
|
+
@property
|
|
857
|
+
@pulumi.getter(name="timeZone")
|
|
858
|
+
def time_zone(self) -> Optional[pulumi.Input[str]]:
|
|
859
|
+
"""
|
|
860
|
+
Scheduling time zone.
|
|
861
|
+
"""
|
|
862
|
+
return pulumi.get(self, "time_zone")
|
|
863
|
+
|
|
864
|
+
@time_zone.setter
|
|
865
|
+
def time_zone(self, value: Optional[pulumi.Input[str]]):
|
|
866
|
+
pulumi.set(self, "time_zone", value)
|
|
867
|
+
|
|
868
|
+
|
|
869
|
+
if not MYPY:
|
|
870
|
+
class WeeklyRecurrenceArgsDict(TypedDict):
|
|
871
|
+
"""
|
|
872
|
+
Weekly recurrence object.
|
|
873
|
+
"""
|
|
874
|
+
days_of_week: pulumi.Input[Sequence[pulumi.Input[Union[str, 'DaysOfWeek']]]]
|
|
875
|
+
"""
|
|
876
|
+
Specifies the values for weekly recurrence pattern.
|
|
877
|
+
"""
|
|
878
|
+
recurrence_type: pulumi.Input[str]
|
|
879
|
+
"""
|
|
880
|
+
Specifies when the recurrence should be applied.
|
|
881
|
+
Expected value is 'Weekly'.
|
|
882
|
+
"""
|
|
883
|
+
end_time: NotRequired[pulumi.Input[str]]
|
|
884
|
+
"""
|
|
885
|
+
End time for recurrence.
|
|
886
|
+
"""
|
|
887
|
+
start_time: NotRequired[pulumi.Input[str]]
|
|
888
|
+
"""
|
|
889
|
+
Start time for recurrence.
|
|
890
|
+
"""
|
|
891
|
+
elif False:
|
|
892
|
+
WeeklyRecurrenceArgsDict: TypeAlias = Mapping[str, Any]
|
|
893
|
+
|
|
894
|
+
@pulumi.input_type
|
|
895
|
+
class WeeklyRecurrenceArgs:
|
|
896
|
+
def __init__(__self__, *,
|
|
897
|
+
days_of_week: pulumi.Input[Sequence[pulumi.Input[Union[str, 'DaysOfWeek']]]],
|
|
898
|
+
recurrence_type: pulumi.Input[str],
|
|
899
|
+
end_time: Optional[pulumi.Input[str]] = None,
|
|
900
|
+
start_time: Optional[pulumi.Input[str]] = None):
|
|
901
|
+
"""
|
|
902
|
+
Weekly recurrence object.
|
|
903
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union[str, 'DaysOfWeek']]]] days_of_week: Specifies the values for weekly recurrence pattern.
|
|
904
|
+
:param pulumi.Input[str] recurrence_type: Specifies when the recurrence should be applied.
|
|
905
|
+
Expected value is 'Weekly'.
|
|
906
|
+
:param pulumi.Input[str] end_time: End time for recurrence.
|
|
907
|
+
:param pulumi.Input[str] start_time: Start time for recurrence.
|
|
908
|
+
"""
|
|
909
|
+
pulumi.set(__self__, "days_of_week", days_of_week)
|
|
910
|
+
pulumi.set(__self__, "recurrence_type", 'Weekly')
|
|
911
|
+
if end_time is not None:
|
|
912
|
+
pulumi.set(__self__, "end_time", end_time)
|
|
913
|
+
if start_time is not None:
|
|
914
|
+
pulumi.set(__self__, "start_time", start_time)
|
|
915
|
+
|
|
916
|
+
@property
|
|
917
|
+
@pulumi.getter(name="daysOfWeek")
|
|
918
|
+
def days_of_week(self) -> pulumi.Input[Sequence[pulumi.Input[Union[str, 'DaysOfWeek']]]]:
|
|
919
|
+
"""
|
|
920
|
+
Specifies the values for weekly recurrence pattern.
|
|
921
|
+
"""
|
|
922
|
+
return pulumi.get(self, "days_of_week")
|
|
923
|
+
|
|
924
|
+
@days_of_week.setter
|
|
925
|
+
def days_of_week(self, value: pulumi.Input[Sequence[pulumi.Input[Union[str, 'DaysOfWeek']]]]):
|
|
926
|
+
pulumi.set(self, "days_of_week", value)
|
|
927
|
+
|
|
928
|
+
@property
|
|
929
|
+
@pulumi.getter(name="recurrenceType")
|
|
930
|
+
def recurrence_type(self) -> pulumi.Input[str]:
|
|
931
|
+
"""
|
|
932
|
+
Specifies when the recurrence should be applied.
|
|
933
|
+
Expected value is 'Weekly'.
|
|
934
|
+
"""
|
|
935
|
+
return pulumi.get(self, "recurrence_type")
|
|
936
|
+
|
|
937
|
+
@recurrence_type.setter
|
|
938
|
+
def recurrence_type(self, value: pulumi.Input[str]):
|
|
939
|
+
pulumi.set(self, "recurrence_type", value)
|
|
940
|
+
|
|
941
|
+
@property
|
|
942
|
+
@pulumi.getter(name="endTime")
|
|
943
|
+
def end_time(self) -> Optional[pulumi.Input[str]]:
|
|
944
|
+
"""
|
|
945
|
+
End time for recurrence.
|
|
946
|
+
"""
|
|
947
|
+
return pulumi.get(self, "end_time")
|
|
948
|
+
|
|
949
|
+
@end_time.setter
|
|
950
|
+
def end_time(self, value: Optional[pulumi.Input[str]]):
|
|
951
|
+
pulumi.set(self, "end_time", value)
|
|
952
|
+
|
|
953
|
+
@property
|
|
954
|
+
@pulumi.getter(name="startTime")
|
|
955
|
+
def start_time(self) -> Optional[pulumi.Input[str]]:
|
|
956
|
+
"""
|
|
957
|
+
Start time for recurrence.
|
|
958
|
+
"""
|
|
959
|
+
return pulumi.get(self, "start_time")
|
|
960
|
+
|
|
961
|
+
@start_time.setter
|
|
962
|
+
def start_time(self, value: Optional[pulumi.Input[str]]):
|
|
963
|
+
pulumi.set(self, "start_time", value)
|
|
964
|
+
|
|
965
|
+
|