pulumi-checkly 2.0.0a1738674781__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pulumi_checkly/__init__.py +143 -0
- pulumi_checkly/_inputs.py +3131 -0
- pulumi_checkly/_utilities.py +327 -0
- pulumi_checkly/alert_channel.py +742 -0
- pulumi_checkly/check.py +1579 -0
- pulumi_checkly/check_group.py +1073 -0
- pulumi_checkly/config/__init__.py +8 -0
- pulumi_checkly/config/__init__.pyi +22 -0
- pulumi_checkly/config/vars.py +34 -0
- pulumi_checkly/dashboard.py +920 -0
- pulumi_checkly/environment_variable.py +269 -0
- pulumi_checkly/get_static_ips.py +126 -0
- pulumi_checkly/heartbeat_check.py +480 -0
- pulumi_checkly/maintenance_window.py +462 -0
- pulumi_checkly/outputs.py +2413 -0
- pulumi_checkly/private_location.py +293 -0
- pulumi_checkly/provider.py +144 -0
- pulumi_checkly/pulumi-plugin.json +6 -0
- pulumi_checkly/py.typed +0 -0
- pulumi_checkly/snippet.py +228 -0
- pulumi_checkly/tcp_check.py +1171 -0
- pulumi_checkly/trigger_check.py +261 -0
- pulumi_checkly/trigger_check_group.py +261 -0
- pulumi_checkly-2.0.0a1738674781.dist-info/METADATA +69 -0
- pulumi_checkly-2.0.0a1738674781.dist-info/RECORD +27 -0
- pulumi_checkly-2.0.0a1738674781.dist-info/WHEEL +5 -0
- pulumi_checkly-2.0.0a1738674781.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,3131 @@
|
|
|
1
|
+
# coding=utf-8
|
|
2
|
+
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
|
|
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
|
+
|
|
17
|
+
__all__ = [
|
|
18
|
+
'AlertChannelCallArgs',
|
|
19
|
+
'AlertChannelCallArgsDict',
|
|
20
|
+
'AlertChannelEmailArgs',
|
|
21
|
+
'AlertChannelEmailArgsDict',
|
|
22
|
+
'AlertChannelOpsgenieArgs',
|
|
23
|
+
'AlertChannelOpsgenieArgsDict',
|
|
24
|
+
'AlertChannelPagerdutyArgs',
|
|
25
|
+
'AlertChannelPagerdutyArgsDict',
|
|
26
|
+
'AlertChannelSlackArgs',
|
|
27
|
+
'AlertChannelSlackArgsDict',
|
|
28
|
+
'AlertChannelSmsArgs',
|
|
29
|
+
'AlertChannelSmsArgsDict',
|
|
30
|
+
'AlertChannelWebhookArgs',
|
|
31
|
+
'AlertChannelWebhookArgsDict',
|
|
32
|
+
'CheckAlertChannelSubscriptionArgs',
|
|
33
|
+
'CheckAlertChannelSubscriptionArgsDict',
|
|
34
|
+
'CheckAlertSettingsArgs',
|
|
35
|
+
'CheckAlertSettingsArgsDict',
|
|
36
|
+
'CheckAlertSettingsParallelRunFailureThresholdArgs',
|
|
37
|
+
'CheckAlertSettingsParallelRunFailureThresholdArgsDict',
|
|
38
|
+
'CheckAlertSettingsReminderArgs',
|
|
39
|
+
'CheckAlertSettingsReminderArgsDict',
|
|
40
|
+
'CheckAlertSettingsRunBasedEscalationArgs',
|
|
41
|
+
'CheckAlertSettingsRunBasedEscalationArgsDict',
|
|
42
|
+
'CheckAlertSettingsSslCertificateArgs',
|
|
43
|
+
'CheckAlertSettingsSslCertificateArgsDict',
|
|
44
|
+
'CheckAlertSettingsTimeBasedEscalationArgs',
|
|
45
|
+
'CheckAlertSettingsTimeBasedEscalationArgsDict',
|
|
46
|
+
'CheckEnvironmentVariableArgs',
|
|
47
|
+
'CheckEnvironmentVariableArgsDict',
|
|
48
|
+
'CheckGroupAlertChannelSubscriptionArgs',
|
|
49
|
+
'CheckGroupAlertChannelSubscriptionArgsDict',
|
|
50
|
+
'CheckGroupAlertSettingsArgs',
|
|
51
|
+
'CheckGroupAlertSettingsArgsDict',
|
|
52
|
+
'CheckGroupAlertSettingsParallelRunFailureThresholdArgs',
|
|
53
|
+
'CheckGroupAlertSettingsParallelRunFailureThresholdArgsDict',
|
|
54
|
+
'CheckGroupAlertSettingsReminderArgs',
|
|
55
|
+
'CheckGroupAlertSettingsReminderArgsDict',
|
|
56
|
+
'CheckGroupAlertSettingsRunBasedEscalationArgs',
|
|
57
|
+
'CheckGroupAlertSettingsRunBasedEscalationArgsDict',
|
|
58
|
+
'CheckGroupAlertSettingsSslCertificateArgs',
|
|
59
|
+
'CheckGroupAlertSettingsSslCertificateArgsDict',
|
|
60
|
+
'CheckGroupAlertSettingsTimeBasedEscalationArgs',
|
|
61
|
+
'CheckGroupAlertSettingsTimeBasedEscalationArgsDict',
|
|
62
|
+
'CheckGroupApiCheckDefaultsArgs',
|
|
63
|
+
'CheckGroupApiCheckDefaultsArgsDict',
|
|
64
|
+
'CheckGroupApiCheckDefaultsAssertionArgs',
|
|
65
|
+
'CheckGroupApiCheckDefaultsAssertionArgsDict',
|
|
66
|
+
'CheckGroupApiCheckDefaultsBasicAuthArgs',
|
|
67
|
+
'CheckGroupApiCheckDefaultsBasicAuthArgsDict',
|
|
68
|
+
'CheckGroupEnvironmentVariableArgs',
|
|
69
|
+
'CheckGroupEnvironmentVariableArgsDict',
|
|
70
|
+
'CheckGroupRetryStrategyArgs',
|
|
71
|
+
'CheckGroupRetryStrategyArgsDict',
|
|
72
|
+
'CheckRequestArgs',
|
|
73
|
+
'CheckRequestArgsDict',
|
|
74
|
+
'CheckRequestAssertionArgs',
|
|
75
|
+
'CheckRequestAssertionArgsDict',
|
|
76
|
+
'CheckRequestBasicAuthArgs',
|
|
77
|
+
'CheckRequestBasicAuthArgsDict',
|
|
78
|
+
'CheckRetryStrategyArgs',
|
|
79
|
+
'CheckRetryStrategyArgsDict',
|
|
80
|
+
'HeartbeatCheckAlertChannelSubscriptionArgs',
|
|
81
|
+
'HeartbeatCheckAlertChannelSubscriptionArgsDict',
|
|
82
|
+
'HeartbeatCheckAlertSettingsArgs',
|
|
83
|
+
'HeartbeatCheckAlertSettingsArgsDict',
|
|
84
|
+
'HeartbeatCheckAlertSettingsParallelRunFailureThresholdArgs',
|
|
85
|
+
'HeartbeatCheckAlertSettingsParallelRunFailureThresholdArgsDict',
|
|
86
|
+
'HeartbeatCheckAlertSettingsReminderArgs',
|
|
87
|
+
'HeartbeatCheckAlertSettingsReminderArgsDict',
|
|
88
|
+
'HeartbeatCheckAlertSettingsRunBasedEscalationArgs',
|
|
89
|
+
'HeartbeatCheckAlertSettingsRunBasedEscalationArgsDict',
|
|
90
|
+
'HeartbeatCheckAlertSettingsSslCertificateArgs',
|
|
91
|
+
'HeartbeatCheckAlertSettingsSslCertificateArgsDict',
|
|
92
|
+
'HeartbeatCheckAlertSettingsTimeBasedEscalationArgs',
|
|
93
|
+
'HeartbeatCheckAlertSettingsTimeBasedEscalationArgsDict',
|
|
94
|
+
'HeartbeatCheckHeartbeatArgs',
|
|
95
|
+
'HeartbeatCheckHeartbeatArgsDict',
|
|
96
|
+
'TcpCheckAlertChannelSubscriptionArgs',
|
|
97
|
+
'TcpCheckAlertChannelSubscriptionArgsDict',
|
|
98
|
+
'TcpCheckAlertSettingsArgs',
|
|
99
|
+
'TcpCheckAlertSettingsArgsDict',
|
|
100
|
+
'TcpCheckAlertSettingsParallelRunFailureThresholdArgs',
|
|
101
|
+
'TcpCheckAlertSettingsParallelRunFailureThresholdArgsDict',
|
|
102
|
+
'TcpCheckAlertSettingsReminderArgs',
|
|
103
|
+
'TcpCheckAlertSettingsReminderArgsDict',
|
|
104
|
+
'TcpCheckAlertSettingsRunBasedEscalationArgs',
|
|
105
|
+
'TcpCheckAlertSettingsRunBasedEscalationArgsDict',
|
|
106
|
+
'TcpCheckAlertSettingsTimeBasedEscalationArgs',
|
|
107
|
+
'TcpCheckAlertSettingsTimeBasedEscalationArgsDict',
|
|
108
|
+
'TcpCheckRequestArgs',
|
|
109
|
+
'TcpCheckRequestArgsDict',
|
|
110
|
+
'TcpCheckRequestAssertionArgs',
|
|
111
|
+
'TcpCheckRequestAssertionArgsDict',
|
|
112
|
+
'TcpCheckRetryStrategyArgs',
|
|
113
|
+
'TcpCheckRetryStrategyArgsDict',
|
|
114
|
+
]
|
|
115
|
+
|
|
116
|
+
MYPY = False
|
|
117
|
+
|
|
118
|
+
if not MYPY:
|
|
119
|
+
class AlertChannelCallArgsDict(TypedDict):
|
|
120
|
+
name: pulumi.Input[str]
|
|
121
|
+
"""
|
|
122
|
+
The name of this alert channel
|
|
123
|
+
"""
|
|
124
|
+
number: pulumi.Input[str]
|
|
125
|
+
"""
|
|
126
|
+
The mobile number to receive the alerts
|
|
127
|
+
"""
|
|
128
|
+
elif False:
|
|
129
|
+
AlertChannelCallArgsDict: TypeAlias = Mapping[str, Any]
|
|
130
|
+
|
|
131
|
+
@pulumi.input_type
|
|
132
|
+
class AlertChannelCallArgs:
|
|
133
|
+
def __init__(__self__, *,
|
|
134
|
+
name: pulumi.Input[str],
|
|
135
|
+
number: pulumi.Input[str]):
|
|
136
|
+
"""
|
|
137
|
+
:param pulumi.Input[str] name: The name of this alert channel
|
|
138
|
+
:param pulumi.Input[str] number: The mobile number to receive the alerts
|
|
139
|
+
"""
|
|
140
|
+
pulumi.set(__self__, "name", name)
|
|
141
|
+
pulumi.set(__self__, "number", number)
|
|
142
|
+
|
|
143
|
+
@property
|
|
144
|
+
@pulumi.getter
|
|
145
|
+
def name(self) -> pulumi.Input[str]:
|
|
146
|
+
"""
|
|
147
|
+
The name of this alert channel
|
|
148
|
+
"""
|
|
149
|
+
return pulumi.get(self, "name")
|
|
150
|
+
|
|
151
|
+
@name.setter
|
|
152
|
+
def name(self, value: pulumi.Input[str]):
|
|
153
|
+
pulumi.set(self, "name", value)
|
|
154
|
+
|
|
155
|
+
@property
|
|
156
|
+
@pulumi.getter
|
|
157
|
+
def number(self) -> pulumi.Input[str]:
|
|
158
|
+
"""
|
|
159
|
+
The mobile number to receive the alerts
|
|
160
|
+
"""
|
|
161
|
+
return pulumi.get(self, "number")
|
|
162
|
+
|
|
163
|
+
@number.setter
|
|
164
|
+
def number(self, value: pulumi.Input[str]):
|
|
165
|
+
pulumi.set(self, "number", value)
|
|
166
|
+
|
|
167
|
+
|
|
168
|
+
if not MYPY:
|
|
169
|
+
class AlertChannelEmailArgsDict(TypedDict):
|
|
170
|
+
address: pulumi.Input[str]
|
|
171
|
+
"""
|
|
172
|
+
The email address of this email alert channel.
|
|
173
|
+
"""
|
|
174
|
+
elif False:
|
|
175
|
+
AlertChannelEmailArgsDict: TypeAlias = Mapping[str, Any]
|
|
176
|
+
|
|
177
|
+
@pulumi.input_type
|
|
178
|
+
class AlertChannelEmailArgs:
|
|
179
|
+
def __init__(__self__, *,
|
|
180
|
+
address: pulumi.Input[str]):
|
|
181
|
+
"""
|
|
182
|
+
:param pulumi.Input[str] address: The email address of this email alert channel.
|
|
183
|
+
"""
|
|
184
|
+
pulumi.set(__self__, "address", address)
|
|
185
|
+
|
|
186
|
+
@property
|
|
187
|
+
@pulumi.getter
|
|
188
|
+
def address(self) -> pulumi.Input[str]:
|
|
189
|
+
"""
|
|
190
|
+
The email address of this email alert channel.
|
|
191
|
+
"""
|
|
192
|
+
return pulumi.get(self, "address")
|
|
193
|
+
|
|
194
|
+
@address.setter
|
|
195
|
+
def address(self, value: pulumi.Input[str]):
|
|
196
|
+
pulumi.set(self, "address", value)
|
|
197
|
+
|
|
198
|
+
|
|
199
|
+
if not MYPY:
|
|
200
|
+
class AlertChannelOpsgenieArgsDict(TypedDict):
|
|
201
|
+
api_key: pulumi.Input[str]
|
|
202
|
+
name: pulumi.Input[str]
|
|
203
|
+
priority: pulumi.Input[str]
|
|
204
|
+
region: pulumi.Input[str]
|
|
205
|
+
elif False:
|
|
206
|
+
AlertChannelOpsgenieArgsDict: TypeAlias = Mapping[str, Any]
|
|
207
|
+
|
|
208
|
+
@pulumi.input_type
|
|
209
|
+
class AlertChannelOpsgenieArgs:
|
|
210
|
+
def __init__(__self__, *,
|
|
211
|
+
api_key: pulumi.Input[str],
|
|
212
|
+
name: pulumi.Input[str],
|
|
213
|
+
priority: pulumi.Input[str],
|
|
214
|
+
region: pulumi.Input[str]):
|
|
215
|
+
pulumi.set(__self__, "api_key", api_key)
|
|
216
|
+
pulumi.set(__self__, "name", name)
|
|
217
|
+
pulumi.set(__self__, "priority", priority)
|
|
218
|
+
pulumi.set(__self__, "region", region)
|
|
219
|
+
|
|
220
|
+
@property
|
|
221
|
+
@pulumi.getter(name="apiKey")
|
|
222
|
+
def api_key(self) -> pulumi.Input[str]:
|
|
223
|
+
return pulumi.get(self, "api_key")
|
|
224
|
+
|
|
225
|
+
@api_key.setter
|
|
226
|
+
def api_key(self, value: pulumi.Input[str]):
|
|
227
|
+
pulumi.set(self, "api_key", value)
|
|
228
|
+
|
|
229
|
+
@property
|
|
230
|
+
@pulumi.getter
|
|
231
|
+
def name(self) -> pulumi.Input[str]:
|
|
232
|
+
return pulumi.get(self, "name")
|
|
233
|
+
|
|
234
|
+
@name.setter
|
|
235
|
+
def name(self, value: pulumi.Input[str]):
|
|
236
|
+
pulumi.set(self, "name", value)
|
|
237
|
+
|
|
238
|
+
@property
|
|
239
|
+
@pulumi.getter
|
|
240
|
+
def priority(self) -> pulumi.Input[str]:
|
|
241
|
+
return pulumi.get(self, "priority")
|
|
242
|
+
|
|
243
|
+
@priority.setter
|
|
244
|
+
def priority(self, value: pulumi.Input[str]):
|
|
245
|
+
pulumi.set(self, "priority", value)
|
|
246
|
+
|
|
247
|
+
@property
|
|
248
|
+
@pulumi.getter
|
|
249
|
+
def region(self) -> pulumi.Input[str]:
|
|
250
|
+
return pulumi.get(self, "region")
|
|
251
|
+
|
|
252
|
+
@region.setter
|
|
253
|
+
def region(self, value: pulumi.Input[str]):
|
|
254
|
+
pulumi.set(self, "region", value)
|
|
255
|
+
|
|
256
|
+
|
|
257
|
+
if not MYPY:
|
|
258
|
+
class AlertChannelPagerdutyArgsDict(TypedDict):
|
|
259
|
+
service_key: pulumi.Input[str]
|
|
260
|
+
account: NotRequired[pulumi.Input[str]]
|
|
261
|
+
service_name: NotRequired[pulumi.Input[str]]
|
|
262
|
+
elif False:
|
|
263
|
+
AlertChannelPagerdutyArgsDict: TypeAlias = Mapping[str, Any]
|
|
264
|
+
|
|
265
|
+
@pulumi.input_type
|
|
266
|
+
class AlertChannelPagerdutyArgs:
|
|
267
|
+
def __init__(__self__, *,
|
|
268
|
+
service_key: pulumi.Input[str],
|
|
269
|
+
account: Optional[pulumi.Input[str]] = None,
|
|
270
|
+
service_name: Optional[pulumi.Input[str]] = None):
|
|
271
|
+
pulumi.set(__self__, "service_key", service_key)
|
|
272
|
+
if account is not None:
|
|
273
|
+
pulumi.set(__self__, "account", account)
|
|
274
|
+
if service_name is not None:
|
|
275
|
+
pulumi.set(__self__, "service_name", service_name)
|
|
276
|
+
|
|
277
|
+
@property
|
|
278
|
+
@pulumi.getter(name="serviceKey")
|
|
279
|
+
def service_key(self) -> pulumi.Input[str]:
|
|
280
|
+
return pulumi.get(self, "service_key")
|
|
281
|
+
|
|
282
|
+
@service_key.setter
|
|
283
|
+
def service_key(self, value: pulumi.Input[str]):
|
|
284
|
+
pulumi.set(self, "service_key", value)
|
|
285
|
+
|
|
286
|
+
@property
|
|
287
|
+
@pulumi.getter
|
|
288
|
+
def account(self) -> Optional[pulumi.Input[str]]:
|
|
289
|
+
return pulumi.get(self, "account")
|
|
290
|
+
|
|
291
|
+
@account.setter
|
|
292
|
+
def account(self, value: Optional[pulumi.Input[str]]):
|
|
293
|
+
pulumi.set(self, "account", value)
|
|
294
|
+
|
|
295
|
+
@property
|
|
296
|
+
@pulumi.getter(name="serviceName")
|
|
297
|
+
def service_name(self) -> Optional[pulumi.Input[str]]:
|
|
298
|
+
return pulumi.get(self, "service_name")
|
|
299
|
+
|
|
300
|
+
@service_name.setter
|
|
301
|
+
def service_name(self, value: Optional[pulumi.Input[str]]):
|
|
302
|
+
pulumi.set(self, "service_name", value)
|
|
303
|
+
|
|
304
|
+
|
|
305
|
+
if not MYPY:
|
|
306
|
+
class AlertChannelSlackArgsDict(TypedDict):
|
|
307
|
+
channel: pulumi.Input[str]
|
|
308
|
+
"""
|
|
309
|
+
The name of the alert's Slack channel
|
|
310
|
+
"""
|
|
311
|
+
url: pulumi.Input[str]
|
|
312
|
+
"""
|
|
313
|
+
The Slack webhook URL
|
|
314
|
+
"""
|
|
315
|
+
elif False:
|
|
316
|
+
AlertChannelSlackArgsDict: TypeAlias = Mapping[str, Any]
|
|
317
|
+
|
|
318
|
+
@pulumi.input_type
|
|
319
|
+
class AlertChannelSlackArgs:
|
|
320
|
+
def __init__(__self__, *,
|
|
321
|
+
channel: pulumi.Input[str],
|
|
322
|
+
url: pulumi.Input[str]):
|
|
323
|
+
"""
|
|
324
|
+
:param pulumi.Input[str] channel: The name of the alert's Slack channel
|
|
325
|
+
:param pulumi.Input[str] url: The Slack webhook URL
|
|
326
|
+
"""
|
|
327
|
+
pulumi.set(__self__, "channel", channel)
|
|
328
|
+
pulumi.set(__self__, "url", url)
|
|
329
|
+
|
|
330
|
+
@property
|
|
331
|
+
@pulumi.getter
|
|
332
|
+
def channel(self) -> pulumi.Input[str]:
|
|
333
|
+
"""
|
|
334
|
+
The name of the alert's Slack channel
|
|
335
|
+
"""
|
|
336
|
+
return pulumi.get(self, "channel")
|
|
337
|
+
|
|
338
|
+
@channel.setter
|
|
339
|
+
def channel(self, value: pulumi.Input[str]):
|
|
340
|
+
pulumi.set(self, "channel", value)
|
|
341
|
+
|
|
342
|
+
@property
|
|
343
|
+
@pulumi.getter
|
|
344
|
+
def url(self) -> pulumi.Input[str]:
|
|
345
|
+
"""
|
|
346
|
+
The Slack webhook URL
|
|
347
|
+
"""
|
|
348
|
+
return pulumi.get(self, "url")
|
|
349
|
+
|
|
350
|
+
@url.setter
|
|
351
|
+
def url(self, value: pulumi.Input[str]):
|
|
352
|
+
pulumi.set(self, "url", value)
|
|
353
|
+
|
|
354
|
+
|
|
355
|
+
if not MYPY:
|
|
356
|
+
class AlertChannelSmsArgsDict(TypedDict):
|
|
357
|
+
name: pulumi.Input[str]
|
|
358
|
+
"""
|
|
359
|
+
The name of this alert channel
|
|
360
|
+
"""
|
|
361
|
+
number: pulumi.Input[str]
|
|
362
|
+
"""
|
|
363
|
+
The mobile number to receive the alerts
|
|
364
|
+
"""
|
|
365
|
+
elif False:
|
|
366
|
+
AlertChannelSmsArgsDict: TypeAlias = Mapping[str, Any]
|
|
367
|
+
|
|
368
|
+
@pulumi.input_type
|
|
369
|
+
class AlertChannelSmsArgs:
|
|
370
|
+
def __init__(__self__, *,
|
|
371
|
+
name: pulumi.Input[str],
|
|
372
|
+
number: pulumi.Input[str]):
|
|
373
|
+
"""
|
|
374
|
+
:param pulumi.Input[str] name: The name of this alert channel
|
|
375
|
+
:param pulumi.Input[str] number: The mobile number to receive the alerts
|
|
376
|
+
"""
|
|
377
|
+
pulumi.set(__self__, "name", name)
|
|
378
|
+
pulumi.set(__self__, "number", number)
|
|
379
|
+
|
|
380
|
+
@property
|
|
381
|
+
@pulumi.getter
|
|
382
|
+
def name(self) -> pulumi.Input[str]:
|
|
383
|
+
"""
|
|
384
|
+
The name of this alert channel
|
|
385
|
+
"""
|
|
386
|
+
return pulumi.get(self, "name")
|
|
387
|
+
|
|
388
|
+
@name.setter
|
|
389
|
+
def name(self, value: pulumi.Input[str]):
|
|
390
|
+
pulumi.set(self, "name", value)
|
|
391
|
+
|
|
392
|
+
@property
|
|
393
|
+
@pulumi.getter
|
|
394
|
+
def number(self) -> pulumi.Input[str]:
|
|
395
|
+
"""
|
|
396
|
+
The mobile number to receive the alerts
|
|
397
|
+
"""
|
|
398
|
+
return pulumi.get(self, "number")
|
|
399
|
+
|
|
400
|
+
@number.setter
|
|
401
|
+
def number(self, value: pulumi.Input[str]):
|
|
402
|
+
pulumi.set(self, "number", value)
|
|
403
|
+
|
|
404
|
+
|
|
405
|
+
if not MYPY:
|
|
406
|
+
class AlertChannelWebhookArgsDict(TypedDict):
|
|
407
|
+
name: pulumi.Input[str]
|
|
408
|
+
url: pulumi.Input[str]
|
|
409
|
+
headers: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
410
|
+
method: NotRequired[pulumi.Input[str]]
|
|
411
|
+
"""
|
|
412
|
+
(Default `POST`)
|
|
413
|
+
"""
|
|
414
|
+
query_parameters: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
415
|
+
template: NotRequired[pulumi.Input[str]]
|
|
416
|
+
webhook_secret: NotRequired[pulumi.Input[str]]
|
|
417
|
+
webhook_type: NotRequired[pulumi.Input[str]]
|
|
418
|
+
"""
|
|
419
|
+
Type of the webhook. Possible values are 'WEBHOOK*DISCORD', 'WEBHOOK*FIREHYDRANT', 'WEBHOOK*GITLAB*ALERT', 'WEBHOOK*SPIKESH', 'WEBHOOK*SPLUNK', 'WEBHOOK*MSTEAMS' and 'WEBHOOK*TELEGRAM'.
|
|
420
|
+
"""
|
|
421
|
+
elif False:
|
|
422
|
+
AlertChannelWebhookArgsDict: TypeAlias = Mapping[str, Any]
|
|
423
|
+
|
|
424
|
+
@pulumi.input_type
|
|
425
|
+
class AlertChannelWebhookArgs:
|
|
426
|
+
def __init__(__self__, *,
|
|
427
|
+
name: pulumi.Input[str],
|
|
428
|
+
url: pulumi.Input[str],
|
|
429
|
+
headers: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
430
|
+
method: Optional[pulumi.Input[str]] = None,
|
|
431
|
+
query_parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
432
|
+
template: Optional[pulumi.Input[str]] = None,
|
|
433
|
+
webhook_secret: Optional[pulumi.Input[str]] = None,
|
|
434
|
+
webhook_type: Optional[pulumi.Input[str]] = None):
|
|
435
|
+
"""
|
|
436
|
+
:param pulumi.Input[str] method: (Default `POST`)
|
|
437
|
+
:param pulumi.Input[str] webhook_type: Type of the webhook. Possible values are 'WEBHOOK*DISCORD', 'WEBHOOK*FIREHYDRANT', 'WEBHOOK*GITLAB*ALERT', 'WEBHOOK*SPIKESH', 'WEBHOOK*SPLUNK', 'WEBHOOK*MSTEAMS' and 'WEBHOOK*TELEGRAM'.
|
|
438
|
+
"""
|
|
439
|
+
pulumi.set(__self__, "name", name)
|
|
440
|
+
pulumi.set(__self__, "url", url)
|
|
441
|
+
if headers is not None:
|
|
442
|
+
pulumi.set(__self__, "headers", headers)
|
|
443
|
+
if method is not None:
|
|
444
|
+
pulumi.set(__self__, "method", method)
|
|
445
|
+
if query_parameters is not None:
|
|
446
|
+
pulumi.set(__self__, "query_parameters", query_parameters)
|
|
447
|
+
if template is not None:
|
|
448
|
+
pulumi.set(__self__, "template", template)
|
|
449
|
+
if webhook_secret is not None:
|
|
450
|
+
pulumi.set(__self__, "webhook_secret", webhook_secret)
|
|
451
|
+
if webhook_type is not None:
|
|
452
|
+
pulumi.set(__self__, "webhook_type", webhook_type)
|
|
453
|
+
|
|
454
|
+
@property
|
|
455
|
+
@pulumi.getter
|
|
456
|
+
def name(self) -> pulumi.Input[str]:
|
|
457
|
+
return pulumi.get(self, "name")
|
|
458
|
+
|
|
459
|
+
@name.setter
|
|
460
|
+
def name(self, value: pulumi.Input[str]):
|
|
461
|
+
pulumi.set(self, "name", value)
|
|
462
|
+
|
|
463
|
+
@property
|
|
464
|
+
@pulumi.getter
|
|
465
|
+
def url(self) -> pulumi.Input[str]:
|
|
466
|
+
return pulumi.get(self, "url")
|
|
467
|
+
|
|
468
|
+
@url.setter
|
|
469
|
+
def url(self, value: pulumi.Input[str]):
|
|
470
|
+
pulumi.set(self, "url", value)
|
|
471
|
+
|
|
472
|
+
@property
|
|
473
|
+
@pulumi.getter
|
|
474
|
+
def headers(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
475
|
+
return pulumi.get(self, "headers")
|
|
476
|
+
|
|
477
|
+
@headers.setter
|
|
478
|
+
def headers(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
479
|
+
pulumi.set(self, "headers", value)
|
|
480
|
+
|
|
481
|
+
@property
|
|
482
|
+
@pulumi.getter
|
|
483
|
+
def method(self) -> Optional[pulumi.Input[str]]:
|
|
484
|
+
"""
|
|
485
|
+
(Default `POST`)
|
|
486
|
+
"""
|
|
487
|
+
return pulumi.get(self, "method")
|
|
488
|
+
|
|
489
|
+
@method.setter
|
|
490
|
+
def method(self, value: Optional[pulumi.Input[str]]):
|
|
491
|
+
pulumi.set(self, "method", value)
|
|
492
|
+
|
|
493
|
+
@property
|
|
494
|
+
@pulumi.getter(name="queryParameters")
|
|
495
|
+
def query_parameters(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
496
|
+
return pulumi.get(self, "query_parameters")
|
|
497
|
+
|
|
498
|
+
@query_parameters.setter
|
|
499
|
+
def query_parameters(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
500
|
+
pulumi.set(self, "query_parameters", value)
|
|
501
|
+
|
|
502
|
+
@property
|
|
503
|
+
@pulumi.getter
|
|
504
|
+
def template(self) -> Optional[pulumi.Input[str]]:
|
|
505
|
+
return pulumi.get(self, "template")
|
|
506
|
+
|
|
507
|
+
@template.setter
|
|
508
|
+
def template(self, value: Optional[pulumi.Input[str]]):
|
|
509
|
+
pulumi.set(self, "template", value)
|
|
510
|
+
|
|
511
|
+
@property
|
|
512
|
+
@pulumi.getter(name="webhookSecret")
|
|
513
|
+
def webhook_secret(self) -> Optional[pulumi.Input[str]]:
|
|
514
|
+
return pulumi.get(self, "webhook_secret")
|
|
515
|
+
|
|
516
|
+
@webhook_secret.setter
|
|
517
|
+
def webhook_secret(self, value: Optional[pulumi.Input[str]]):
|
|
518
|
+
pulumi.set(self, "webhook_secret", value)
|
|
519
|
+
|
|
520
|
+
@property
|
|
521
|
+
@pulumi.getter(name="webhookType")
|
|
522
|
+
def webhook_type(self) -> Optional[pulumi.Input[str]]:
|
|
523
|
+
"""
|
|
524
|
+
Type of the webhook. Possible values are 'WEBHOOK*DISCORD', 'WEBHOOK*FIREHYDRANT', 'WEBHOOK*GITLAB*ALERT', 'WEBHOOK*SPIKESH', 'WEBHOOK*SPLUNK', 'WEBHOOK*MSTEAMS' and 'WEBHOOK*TELEGRAM'.
|
|
525
|
+
"""
|
|
526
|
+
return pulumi.get(self, "webhook_type")
|
|
527
|
+
|
|
528
|
+
@webhook_type.setter
|
|
529
|
+
def webhook_type(self, value: Optional[pulumi.Input[str]]):
|
|
530
|
+
pulumi.set(self, "webhook_type", value)
|
|
531
|
+
|
|
532
|
+
|
|
533
|
+
if not MYPY:
|
|
534
|
+
class CheckAlertChannelSubscriptionArgsDict(TypedDict):
|
|
535
|
+
activated: pulumi.Input[bool]
|
|
536
|
+
channel_id: pulumi.Input[int]
|
|
537
|
+
elif False:
|
|
538
|
+
CheckAlertChannelSubscriptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
539
|
+
|
|
540
|
+
@pulumi.input_type
|
|
541
|
+
class CheckAlertChannelSubscriptionArgs:
|
|
542
|
+
def __init__(__self__, *,
|
|
543
|
+
activated: pulumi.Input[bool],
|
|
544
|
+
channel_id: pulumi.Input[int]):
|
|
545
|
+
pulumi.set(__self__, "activated", activated)
|
|
546
|
+
pulumi.set(__self__, "channel_id", channel_id)
|
|
547
|
+
|
|
548
|
+
@property
|
|
549
|
+
@pulumi.getter
|
|
550
|
+
def activated(self) -> pulumi.Input[bool]:
|
|
551
|
+
return pulumi.get(self, "activated")
|
|
552
|
+
|
|
553
|
+
@activated.setter
|
|
554
|
+
def activated(self, value: pulumi.Input[bool]):
|
|
555
|
+
pulumi.set(self, "activated", value)
|
|
556
|
+
|
|
557
|
+
@property
|
|
558
|
+
@pulumi.getter(name="channelId")
|
|
559
|
+
def channel_id(self) -> pulumi.Input[int]:
|
|
560
|
+
return pulumi.get(self, "channel_id")
|
|
561
|
+
|
|
562
|
+
@channel_id.setter
|
|
563
|
+
def channel_id(self, value: pulumi.Input[int]):
|
|
564
|
+
pulumi.set(self, "channel_id", value)
|
|
565
|
+
|
|
566
|
+
|
|
567
|
+
if not MYPY:
|
|
568
|
+
class CheckAlertSettingsArgsDict(TypedDict):
|
|
569
|
+
escalation_type: NotRequired[pulumi.Input[str]]
|
|
570
|
+
"""
|
|
571
|
+
Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
572
|
+
"""
|
|
573
|
+
parallel_run_failure_thresholds: NotRequired[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsParallelRunFailureThresholdArgsDict']]]]
|
|
574
|
+
reminders: NotRequired[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsReminderArgsDict']]]]
|
|
575
|
+
run_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsRunBasedEscalationArgsDict']]]]
|
|
576
|
+
ssl_certificates: NotRequired[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsSslCertificateArgsDict']]]]
|
|
577
|
+
time_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsTimeBasedEscalationArgsDict']]]]
|
|
578
|
+
elif False:
|
|
579
|
+
CheckAlertSettingsArgsDict: TypeAlias = Mapping[str, Any]
|
|
580
|
+
|
|
581
|
+
@pulumi.input_type
|
|
582
|
+
class CheckAlertSettingsArgs:
|
|
583
|
+
def __init__(__self__, *,
|
|
584
|
+
escalation_type: Optional[pulumi.Input[str]] = None,
|
|
585
|
+
parallel_run_failure_thresholds: Optional[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsParallelRunFailureThresholdArgs']]]] = None,
|
|
586
|
+
reminders: Optional[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsReminderArgs']]]] = None,
|
|
587
|
+
run_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsRunBasedEscalationArgs']]]] = None,
|
|
588
|
+
ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsSslCertificateArgs']]]] = None,
|
|
589
|
+
time_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsTimeBasedEscalationArgs']]]] = None):
|
|
590
|
+
"""
|
|
591
|
+
:param pulumi.Input[str] escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
592
|
+
"""
|
|
593
|
+
if escalation_type is not None:
|
|
594
|
+
pulumi.set(__self__, "escalation_type", escalation_type)
|
|
595
|
+
if parallel_run_failure_thresholds is not None:
|
|
596
|
+
pulumi.set(__self__, "parallel_run_failure_thresholds", parallel_run_failure_thresholds)
|
|
597
|
+
if reminders is not None:
|
|
598
|
+
pulumi.set(__self__, "reminders", reminders)
|
|
599
|
+
if run_based_escalations is not None:
|
|
600
|
+
pulumi.set(__self__, "run_based_escalations", run_based_escalations)
|
|
601
|
+
if ssl_certificates is not None:
|
|
602
|
+
warnings.warn("""This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""", DeprecationWarning)
|
|
603
|
+
pulumi.log.warn("""ssl_certificates is deprecated: This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""")
|
|
604
|
+
if ssl_certificates is not None:
|
|
605
|
+
pulumi.set(__self__, "ssl_certificates", ssl_certificates)
|
|
606
|
+
if time_based_escalations is not None:
|
|
607
|
+
pulumi.set(__self__, "time_based_escalations", time_based_escalations)
|
|
608
|
+
|
|
609
|
+
@property
|
|
610
|
+
@pulumi.getter(name="escalationType")
|
|
611
|
+
def escalation_type(self) -> Optional[pulumi.Input[str]]:
|
|
612
|
+
"""
|
|
613
|
+
Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
614
|
+
"""
|
|
615
|
+
return pulumi.get(self, "escalation_type")
|
|
616
|
+
|
|
617
|
+
@escalation_type.setter
|
|
618
|
+
def escalation_type(self, value: Optional[pulumi.Input[str]]):
|
|
619
|
+
pulumi.set(self, "escalation_type", value)
|
|
620
|
+
|
|
621
|
+
@property
|
|
622
|
+
@pulumi.getter(name="parallelRunFailureThresholds")
|
|
623
|
+
def parallel_run_failure_thresholds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsParallelRunFailureThresholdArgs']]]]:
|
|
624
|
+
return pulumi.get(self, "parallel_run_failure_thresholds")
|
|
625
|
+
|
|
626
|
+
@parallel_run_failure_thresholds.setter
|
|
627
|
+
def parallel_run_failure_thresholds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsParallelRunFailureThresholdArgs']]]]):
|
|
628
|
+
pulumi.set(self, "parallel_run_failure_thresholds", value)
|
|
629
|
+
|
|
630
|
+
@property
|
|
631
|
+
@pulumi.getter
|
|
632
|
+
def reminders(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsReminderArgs']]]]:
|
|
633
|
+
return pulumi.get(self, "reminders")
|
|
634
|
+
|
|
635
|
+
@reminders.setter
|
|
636
|
+
def reminders(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsReminderArgs']]]]):
|
|
637
|
+
pulumi.set(self, "reminders", value)
|
|
638
|
+
|
|
639
|
+
@property
|
|
640
|
+
@pulumi.getter(name="runBasedEscalations")
|
|
641
|
+
def run_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsRunBasedEscalationArgs']]]]:
|
|
642
|
+
return pulumi.get(self, "run_based_escalations")
|
|
643
|
+
|
|
644
|
+
@run_based_escalations.setter
|
|
645
|
+
def run_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsRunBasedEscalationArgs']]]]):
|
|
646
|
+
pulumi.set(self, "run_based_escalations", value)
|
|
647
|
+
|
|
648
|
+
@property
|
|
649
|
+
@pulumi.getter(name="sslCertificates")
|
|
650
|
+
@_utilities.deprecated("""This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""")
|
|
651
|
+
def ssl_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsSslCertificateArgs']]]]:
|
|
652
|
+
return pulumi.get(self, "ssl_certificates")
|
|
653
|
+
|
|
654
|
+
@ssl_certificates.setter
|
|
655
|
+
def ssl_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsSslCertificateArgs']]]]):
|
|
656
|
+
pulumi.set(self, "ssl_certificates", value)
|
|
657
|
+
|
|
658
|
+
@property
|
|
659
|
+
@pulumi.getter(name="timeBasedEscalations")
|
|
660
|
+
def time_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsTimeBasedEscalationArgs']]]]:
|
|
661
|
+
return pulumi.get(self, "time_based_escalations")
|
|
662
|
+
|
|
663
|
+
@time_based_escalations.setter
|
|
664
|
+
def time_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CheckAlertSettingsTimeBasedEscalationArgs']]]]):
|
|
665
|
+
pulumi.set(self, "time_based_escalations", value)
|
|
666
|
+
|
|
667
|
+
|
|
668
|
+
if not MYPY:
|
|
669
|
+
class CheckAlertSettingsParallelRunFailureThresholdArgsDict(TypedDict):
|
|
670
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
671
|
+
"""
|
|
672
|
+
Applicable only for checks scheduled in parallel in multiple locations.
|
|
673
|
+
"""
|
|
674
|
+
percentage: NotRequired[pulumi.Input[int]]
|
|
675
|
+
"""
|
|
676
|
+
Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
677
|
+
"""
|
|
678
|
+
elif False:
|
|
679
|
+
CheckAlertSettingsParallelRunFailureThresholdArgsDict: TypeAlias = Mapping[str, Any]
|
|
680
|
+
|
|
681
|
+
@pulumi.input_type
|
|
682
|
+
class CheckAlertSettingsParallelRunFailureThresholdArgs:
|
|
683
|
+
def __init__(__self__, *,
|
|
684
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
685
|
+
percentage: Optional[pulumi.Input[int]] = None):
|
|
686
|
+
"""
|
|
687
|
+
:param pulumi.Input[bool] enabled: Applicable only for checks scheduled in parallel in multiple locations.
|
|
688
|
+
:param pulumi.Input[int] percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
689
|
+
"""
|
|
690
|
+
if enabled is not None:
|
|
691
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
692
|
+
if percentage is not None:
|
|
693
|
+
pulumi.set(__self__, "percentage", percentage)
|
|
694
|
+
|
|
695
|
+
@property
|
|
696
|
+
@pulumi.getter
|
|
697
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
698
|
+
"""
|
|
699
|
+
Applicable only for checks scheduled in parallel in multiple locations.
|
|
700
|
+
"""
|
|
701
|
+
return pulumi.get(self, "enabled")
|
|
702
|
+
|
|
703
|
+
@enabled.setter
|
|
704
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
705
|
+
pulumi.set(self, "enabled", value)
|
|
706
|
+
|
|
707
|
+
@property
|
|
708
|
+
@pulumi.getter
|
|
709
|
+
def percentage(self) -> Optional[pulumi.Input[int]]:
|
|
710
|
+
"""
|
|
711
|
+
Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
712
|
+
"""
|
|
713
|
+
return pulumi.get(self, "percentage")
|
|
714
|
+
|
|
715
|
+
@percentage.setter
|
|
716
|
+
def percentage(self, value: Optional[pulumi.Input[int]]):
|
|
717
|
+
pulumi.set(self, "percentage", value)
|
|
718
|
+
|
|
719
|
+
|
|
720
|
+
if not MYPY:
|
|
721
|
+
class CheckAlertSettingsReminderArgsDict(TypedDict):
|
|
722
|
+
amount: NotRequired[pulumi.Input[int]]
|
|
723
|
+
"""
|
|
724
|
+
How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
725
|
+
"""
|
|
726
|
+
interval: NotRequired[pulumi.Input[int]]
|
|
727
|
+
"""
|
|
728
|
+
Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
729
|
+
"""
|
|
730
|
+
elif False:
|
|
731
|
+
CheckAlertSettingsReminderArgsDict: TypeAlias = Mapping[str, Any]
|
|
732
|
+
|
|
733
|
+
@pulumi.input_type
|
|
734
|
+
class CheckAlertSettingsReminderArgs:
|
|
735
|
+
def __init__(__self__, *,
|
|
736
|
+
amount: Optional[pulumi.Input[int]] = None,
|
|
737
|
+
interval: Optional[pulumi.Input[int]] = None):
|
|
738
|
+
"""
|
|
739
|
+
:param pulumi.Input[int] amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
740
|
+
:param pulumi.Input[int] interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
741
|
+
"""
|
|
742
|
+
if amount is not None:
|
|
743
|
+
pulumi.set(__self__, "amount", amount)
|
|
744
|
+
if interval is not None:
|
|
745
|
+
pulumi.set(__self__, "interval", interval)
|
|
746
|
+
|
|
747
|
+
@property
|
|
748
|
+
@pulumi.getter
|
|
749
|
+
def amount(self) -> Optional[pulumi.Input[int]]:
|
|
750
|
+
"""
|
|
751
|
+
How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
752
|
+
"""
|
|
753
|
+
return pulumi.get(self, "amount")
|
|
754
|
+
|
|
755
|
+
@amount.setter
|
|
756
|
+
def amount(self, value: Optional[pulumi.Input[int]]):
|
|
757
|
+
pulumi.set(self, "amount", value)
|
|
758
|
+
|
|
759
|
+
@property
|
|
760
|
+
@pulumi.getter
|
|
761
|
+
def interval(self) -> Optional[pulumi.Input[int]]:
|
|
762
|
+
"""
|
|
763
|
+
Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
764
|
+
"""
|
|
765
|
+
return pulumi.get(self, "interval")
|
|
766
|
+
|
|
767
|
+
@interval.setter
|
|
768
|
+
def interval(self, value: Optional[pulumi.Input[int]]):
|
|
769
|
+
pulumi.set(self, "interval", value)
|
|
770
|
+
|
|
771
|
+
|
|
772
|
+
if not MYPY:
|
|
773
|
+
class CheckAlertSettingsRunBasedEscalationArgsDict(TypedDict):
|
|
774
|
+
failed_run_threshold: NotRequired[pulumi.Input[int]]
|
|
775
|
+
"""
|
|
776
|
+
After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
777
|
+
"""
|
|
778
|
+
elif False:
|
|
779
|
+
CheckAlertSettingsRunBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
780
|
+
|
|
781
|
+
@pulumi.input_type
|
|
782
|
+
class CheckAlertSettingsRunBasedEscalationArgs:
|
|
783
|
+
def __init__(__self__, *,
|
|
784
|
+
failed_run_threshold: Optional[pulumi.Input[int]] = None):
|
|
785
|
+
"""
|
|
786
|
+
:param pulumi.Input[int] failed_run_threshold: After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
787
|
+
"""
|
|
788
|
+
if failed_run_threshold is not None:
|
|
789
|
+
pulumi.set(__self__, "failed_run_threshold", failed_run_threshold)
|
|
790
|
+
|
|
791
|
+
@property
|
|
792
|
+
@pulumi.getter(name="failedRunThreshold")
|
|
793
|
+
def failed_run_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
794
|
+
"""
|
|
795
|
+
After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
796
|
+
"""
|
|
797
|
+
return pulumi.get(self, "failed_run_threshold")
|
|
798
|
+
|
|
799
|
+
@failed_run_threshold.setter
|
|
800
|
+
def failed_run_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
801
|
+
pulumi.set(self, "failed_run_threshold", value)
|
|
802
|
+
|
|
803
|
+
|
|
804
|
+
if not MYPY:
|
|
805
|
+
class CheckAlertSettingsSslCertificateArgsDict(TypedDict):
|
|
806
|
+
alert_threshold: NotRequired[pulumi.Input[int]]
|
|
807
|
+
"""
|
|
808
|
+
How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
|
|
809
|
+
"""
|
|
810
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
811
|
+
"""
|
|
812
|
+
Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
|
|
813
|
+
"""
|
|
814
|
+
elif False:
|
|
815
|
+
CheckAlertSettingsSslCertificateArgsDict: TypeAlias = Mapping[str, Any]
|
|
816
|
+
|
|
817
|
+
@pulumi.input_type
|
|
818
|
+
class CheckAlertSettingsSslCertificateArgs:
|
|
819
|
+
def __init__(__self__, *,
|
|
820
|
+
alert_threshold: Optional[pulumi.Input[int]] = None,
|
|
821
|
+
enabled: Optional[pulumi.Input[bool]] = None):
|
|
822
|
+
"""
|
|
823
|
+
:param pulumi.Input[int] alert_threshold: How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
|
|
824
|
+
:param pulumi.Input[bool] enabled: Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
|
|
825
|
+
"""
|
|
826
|
+
if alert_threshold is not None:
|
|
827
|
+
pulumi.set(__self__, "alert_threshold", alert_threshold)
|
|
828
|
+
if enabled is not None:
|
|
829
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
830
|
+
|
|
831
|
+
@property
|
|
832
|
+
@pulumi.getter(name="alertThreshold")
|
|
833
|
+
def alert_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
834
|
+
"""
|
|
835
|
+
How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
|
|
836
|
+
"""
|
|
837
|
+
return pulumi.get(self, "alert_threshold")
|
|
838
|
+
|
|
839
|
+
@alert_threshold.setter
|
|
840
|
+
def alert_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
841
|
+
pulumi.set(self, "alert_threshold", value)
|
|
842
|
+
|
|
843
|
+
@property
|
|
844
|
+
@pulumi.getter
|
|
845
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
846
|
+
"""
|
|
847
|
+
Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
|
|
848
|
+
"""
|
|
849
|
+
return pulumi.get(self, "enabled")
|
|
850
|
+
|
|
851
|
+
@enabled.setter
|
|
852
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
853
|
+
pulumi.set(self, "enabled", value)
|
|
854
|
+
|
|
855
|
+
|
|
856
|
+
if not MYPY:
|
|
857
|
+
class CheckAlertSettingsTimeBasedEscalationArgsDict(TypedDict):
|
|
858
|
+
minutes_failing_threshold: NotRequired[pulumi.Input[int]]
|
|
859
|
+
"""
|
|
860
|
+
After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
861
|
+
"""
|
|
862
|
+
elif False:
|
|
863
|
+
CheckAlertSettingsTimeBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
864
|
+
|
|
865
|
+
@pulumi.input_type
|
|
866
|
+
class CheckAlertSettingsTimeBasedEscalationArgs:
|
|
867
|
+
def __init__(__self__, *,
|
|
868
|
+
minutes_failing_threshold: Optional[pulumi.Input[int]] = None):
|
|
869
|
+
"""
|
|
870
|
+
:param pulumi.Input[int] minutes_failing_threshold: After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
871
|
+
"""
|
|
872
|
+
if minutes_failing_threshold is not None:
|
|
873
|
+
pulumi.set(__self__, "minutes_failing_threshold", minutes_failing_threshold)
|
|
874
|
+
|
|
875
|
+
@property
|
|
876
|
+
@pulumi.getter(name="minutesFailingThreshold")
|
|
877
|
+
def minutes_failing_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
878
|
+
"""
|
|
879
|
+
After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
880
|
+
"""
|
|
881
|
+
return pulumi.get(self, "minutes_failing_threshold")
|
|
882
|
+
|
|
883
|
+
@minutes_failing_threshold.setter
|
|
884
|
+
def minutes_failing_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
885
|
+
pulumi.set(self, "minutes_failing_threshold", value)
|
|
886
|
+
|
|
887
|
+
|
|
888
|
+
if not MYPY:
|
|
889
|
+
class CheckEnvironmentVariableArgsDict(TypedDict):
|
|
890
|
+
key: pulumi.Input[str]
|
|
891
|
+
value: pulumi.Input[str]
|
|
892
|
+
locked: NotRequired[pulumi.Input[bool]]
|
|
893
|
+
secret: NotRequired[pulumi.Input[bool]]
|
|
894
|
+
elif False:
|
|
895
|
+
CheckEnvironmentVariableArgsDict: TypeAlias = Mapping[str, Any]
|
|
896
|
+
|
|
897
|
+
@pulumi.input_type
|
|
898
|
+
class CheckEnvironmentVariableArgs:
|
|
899
|
+
def __init__(__self__, *,
|
|
900
|
+
key: pulumi.Input[str],
|
|
901
|
+
value: pulumi.Input[str],
|
|
902
|
+
locked: Optional[pulumi.Input[bool]] = None,
|
|
903
|
+
secret: Optional[pulumi.Input[bool]] = None):
|
|
904
|
+
pulumi.set(__self__, "key", key)
|
|
905
|
+
pulumi.set(__self__, "value", value)
|
|
906
|
+
if locked is not None:
|
|
907
|
+
pulumi.set(__self__, "locked", locked)
|
|
908
|
+
if secret is not None:
|
|
909
|
+
pulumi.set(__self__, "secret", secret)
|
|
910
|
+
|
|
911
|
+
@property
|
|
912
|
+
@pulumi.getter
|
|
913
|
+
def key(self) -> pulumi.Input[str]:
|
|
914
|
+
return pulumi.get(self, "key")
|
|
915
|
+
|
|
916
|
+
@key.setter
|
|
917
|
+
def key(self, value: pulumi.Input[str]):
|
|
918
|
+
pulumi.set(self, "key", value)
|
|
919
|
+
|
|
920
|
+
@property
|
|
921
|
+
@pulumi.getter
|
|
922
|
+
def value(self) -> pulumi.Input[str]:
|
|
923
|
+
return pulumi.get(self, "value")
|
|
924
|
+
|
|
925
|
+
@value.setter
|
|
926
|
+
def value(self, value: pulumi.Input[str]):
|
|
927
|
+
pulumi.set(self, "value", value)
|
|
928
|
+
|
|
929
|
+
@property
|
|
930
|
+
@pulumi.getter
|
|
931
|
+
def locked(self) -> Optional[pulumi.Input[bool]]:
|
|
932
|
+
return pulumi.get(self, "locked")
|
|
933
|
+
|
|
934
|
+
@locked.setter
|
|
935
|
+
def locked(self, value: Optional[pulumi.Input[bool]]):
|
|
936
|
+
pulumi.set(self, "locked", value)
|
|
937
|
+
|
|
938
|
+
@property
|
|
939
|
+
@pulumi.getter
|
|
940
|
+
def secret(self) -> Optional[pulumi.Input[bool]]:
|
|
941
|
+
return pulumi.get(self, "secret")
|
|
942
|
+
|
|
943
|
+
@secret.setter
|
|
944
|
+
def secret(self, value: Optional[pulumi.Input[bool]]):
|
|
945
|
+
pulumi.set(self, "secret", value)
|
|
946
|
+
|
|
947
|
+
|
|
948
|
+
if not MYPY:
|
|
949
|
+
class CheckGroupAlertChannelSubscriptionArgsDict(TypedDict):
|
|
950
|
+
activated: pulumi.Input[bool]
|
|
951
|
+
channel_id: pulumi.Input[int]
|
|
952
|
+
elif False:
|
|
953
|
+
CheckGroupAlertChannelSubscriptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
954
|
+
|
|
955
|
+
@pulumi.input_type
|
|
956
|
+
class CheckGroupAlertChannelSubscriptionArgs:
|
|
957
|
+
def __init__(__self__, *,
|
|
958
|
+
activated: pulumi.Input[bool],
|
|
959
|
+
channel_id: pulumi.Input[int]):
|
|
960
|
+
pulumi.set(__self__, "activated", activated)
|
|
961
|
+
pulumi.set(__self__, "channel_id", channel_id)
|
|
962
|
+
|
|
963
|
+
@property
|
|
964
|
+
@pulumi.getter
|
|
965
|
+
def activated(self) -> pulumi.Input[bool]:
|
|
966
|
+
return pulumi.get(self, "activated")
|
|
967
|
+
|
|
968
|
+
@activated.setter
|
|
969
|
+
def activated(self, value: pulumi.Input[bool]):
|
|
970
|
+
pulumi.set(self, "activated", value)
|
|
971
|
+
|
|
972
|
+
@property
|
|
973
|
+
@pulumi.getter(name="channelId")
|
|
974
|
+
def channel_id(self) -> pulumi.Input[int]:
|
|
975
|
+
return pulumi.get(self, "channel_id")
|
|
976
|
+
|
|
977
|
+
@channel_id.setter
|
|
978
|
+
def channel_id(self, value: pulumi.Input[int]):
|
|
979
|
+
pulumi.set(self, "channel_id", value)
|
|
980
|
+
|
|
981
|
+
|
|
982
|
+
if not MYPY:
|
|
983
|
+
class CheckGroupAlertSettingsArgsDict(TypedDict):
|
|
984
|
+
escalation_type: NotRequired[pulumi.Input[str]]
|
|
985
|
+
"""
|
|
986
|
+
Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
987
|
+
"""
|
|
988
|
+
parallel_run_failure_thresholds: NotRequired[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsParallelRunFailureThresholdArgsDict']]]]
|
|
989
|
+
reminders: NotRequired[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsReminderArgsDict']]]]
|
|
990
|
+
run_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsRunBasedEscalationArgsDict']]]]
|
|
991
|
+
ssl_certificates: NotRequired[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsSslCertificateArgsDict']]]]
|
|
992
|
+
time_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsTimeBasedEscalationArgsDict']]]]
|
|
993
|
+
elif False:
|
|
994
|
+
CheckGroupAlertSettingsArgsDict: TypeAlias = Mapping[str, Any]
|
|
995
|
+
|
|
996
|
+
@pulumi.input_type
|
|
997
|
+
class CheckGroupAlertSettingsArgs:
|
|
998
|
+
def __init__(__self__, *,
|
|
999
|
+
escalation_type: Optional[pulumi.Input[str]] = None,
|
|
1000
|
+
parallel_run_failure_thresholds: Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsParallelRunFailureThresholdArgs']]]] = None,
|
|
1001
|
+
reminders: Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsReminderArgs']]]] = None,
|
|
1002
|
+
run_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsRunBasedEscalationArgs']]]] = None,
|
|
1003
|
+
ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsSslCertificateArgs']]]] = None,
|
|
1004
|
+
time_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsTimeBasedEscalationArgs']]]] = None):
|
|
1005
|
+
"""
|
|
1006
|
+
:param pulumi.Input[str] escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
1007
|
+
"""
|
|
1008
|
+
if escalation_type is not None:
|
|
1009
|
+
pulumi.set(__self__, "escalation_type", escalation_type)
|
|
1010
|
+
if parallel_run_failure_thresholds is not None:
|
|
1011
|
+
pulumi.set(__self__, "parallel_run_failure_thresholds", parallel_run_failure_thresholds)
|
|
1012
|
+
if reminders is not None:
|
|
1013
|
+
pulumi.set(__self__, "reminders", reminders)
|
|
1014
|
+
if run_based_escalations is not None:
|
|
1015
|
+
pulumi.set(__self__, "run_based_escalations", run_based_escalations)
|
|
1016
|
+
if ssl_certificates is not None:
|
|
1017
|
+
warnings.warn("""This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""", DeprecationWarning)
|
|
1018
|
+
pulumi.log.warn("""ssl_certificates is deprecated: This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""")
|
|
1019
|
+
if ssl_certificates is not None:
|
|
1020
|
+
pulumi.set(__self__, "ssl_certificates", ssl_certificates)
|
|
1021
|
+
if time_based_escalations is not None:
|
|
1022
|
+
pulumi.set(__self__, "time_based_escalations", time_based_escalations)
|
|
1023
|
+
|
|
1024
|
+
@property
|
|
1025
|
+
@pulumi.getter(name="escalationType")
|
|
1026
|
+
def escalation_type(self) -> Optional[pulumi.Input[str]]:
|
|
1027
|
+
"""
|
|
1028
|
+
Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
1029
|
+
"""
|
|
1030
|
+
return pulumi.get(self, "escalation_type")
|
|
1031
|
+
|
|
1032
|
+
@escalation_type.setter
|
|
1033
|
+
def escalation_type(self, value: Optional[pulumi.Input[str]]):
|
|
1034
|
+
pulumi.set(self, "escalation_type", value)
|
|
1035
|
+
|
|
1036
|
+
@property
|
|
1037
|
+
@pulumi.getter(name="parallelRunFailureThresholds")
|
|
1038
|
+
def parallel_run_failure_thresholds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsParallelRunFailureThresholdArgs']]]]:
|
|
1039
|
+
return pulumi.get(self, "parallel_run_failure_thresholds")
|
|
1040
|
+
|
|
1041
|
+
@parallel_run_failure_thresholds.setter
|
|
1042
|
+
def parallel_run_failure_thresholds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsParallelRunFailureThresholdArgs']]]]):
|
|
1043
|
+
pulumi.set(self, "parallel_run_failure_thresholds", value)
|
|
1044
|
+
|
|
1045
|
+
@property
|
|
1046
|
+
@pulumi.getter
|
|
1047
|
+
def reminders(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsReminderArgs']]]]:
|
|
1048
|
+
return pulumi.get(self, "reminders")
|
|
1049
|
+
|
|
1050
|
+
@reminders.setter
|
|
1051
|
+
def reminders(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsReminderArgs']]]]):
|
|
1052
|
+
pulumi.set(self, "reminders", value)
|
|
1053
|
+
|
|
1054
|
+
@property
|
|
1055
|
+
@pulumi.getter(name="runBasedEscalations")
|
|
1056
|
+
def run_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsRunBasedEscalationArgs']]]]:
|
|
1057
|
+
return pulumi.get(self, "run_based_escalations")
|
|
1058
|
+
|
|
1059
|
+
@run_based_escalations.setter
|
|
1060
|
+
def run_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsRunBasedEscalationArgs']]]]):
|
|
1061
|
+
pulumi.set(self, "run_based_escalations", value)
|
|
1062
|
+
|
|
1063
|
+
@property
|
|
1064
|
+
@pulumi.getter(name="sslCertificates")
|
|
1065
|
+
@_utilities.deprecated("""This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""")
|
|
1066
|
+
def ssl_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsSslCertificateArgs']]]]:
|
|
1067
|
+
return pulumi.get(self, "ssl_certificates")
|
|
1068
|
+
|
|
1069
|
+
@ssl_certificates.setter
|
|
1070
|
+
def ssl_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsSslCertificateArgs']]]]):
|
|
1071
|
+
pulumi.set(self, "ssl_certificates", value)
|
|
1072
|
+
|
|
1073
|
+
@property
|
|
1074
|
+
@pulumi.getter(name="timeBasedEscalations")
|
|
1075
|
+
def time_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsTimeBasedEscalationArgs']]]]:
|
|
1076
|
+
return pulumi.get(self, "time_based_escalations")
|
|
1077
|
+
|
|
1078
|
+
@time_based_escalations.setter
|
|
1079
|
+
def time_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupAlertSettingsTimeBasedEscalationArgs']]]]):
|
|
1080
|
+
pulumi.set(self, "time_based_escalations", value)
|
|
1081
|
+
|
|
1082
|
+
|
|
1083
|
+
if not MYPY:
|
|
1084
|
+
class CheckGroupAlertSettingsParallelRunFailureThresholdArgsDict(TypedDict):
|
|
1085
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
1086
|
+
"""
|
|
1087
|
+
Applicable only for checks scheduled in parallel in multiple locations.
|
|
1088
|
+
"""
|
|
1089
|
+
percentage: NotRequired[pulumi.Input[int]]
|
|
1090
|
+
"""
|
|
1091
|
+
Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
1092
|
+
"""
|
|
1093
|
+
elif False:
|
|
1094
|
+
CheckGroupAlertSettingsParallelRunFailureThresholdArgsDict: TypeAlias = Mapping[str, Any]
|
|
1095
|
+
|
|
1096
|
+
@pulumi.input_type
|
|
1097
|
+
class CheckGroupAlertSettingsParallelRunFailureThresholdArgs:
|
|
1098
|
+
def __init__(__self__, *,
|
|
1099
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
1100
|
+
percentage: Optional[pulumi.Input[int]] = None):
|
|
1101
|
+
"""
|
|
1102
|
+
:param pulumi.Input[bool] enabled: Applicable only for checks scheduled in parallel in multiple locations.
|
|
1103
|
+
:param pulumi.Input[int] percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
1104
|
+
"""
|
|
1105
|
+
if enabled is not None:
|
|
1106
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
1107
|
+
if percentage is not None:
|
|
1108
|
+
pulumi.set(__self__, "percentage", percentage)
|
|
1109
|
+
|
|
1110
|
+
@property
|
|
1111
|
+
@pulumi.getter
|
|
1112
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1113
|
+
"""
|
|
1114
|
+
Applicable only for checks scheduled in parallel in multiple locations.
|
|
1115
|
+
"""
|
|
1116
|
+
return pulumi.get(self, "enabled")
|
|
1117
|
+
|
|
1118
|
+
@enabled.setter
|
|
1119
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1120
|
+
pulumi.set(self, "enabled", value)
|
|
1121
|
+
|
|
1122
|
+
@property
|
|
1123
|
+
@pulumi.getter
|
|
1124
|
+
def percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1125
|
+
"""
|
|
1126
|
+
Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
1127
|
+
"""
|
|
1128
|
+
return pulumi.get(self, "percentage")
|
|
1129
|
+
|
|
1130
|
+
@percentage.setter
|
|
1131
|
+
def percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1132
|
+
pulumi.set(self, "percentage", value)
|
|
1133
|
+
|
|
1134
|
+
|
|
1135
|
+
if not MYPY:
|
|
1136
|
+
class CheckGroupAlertSettingsReminderArgsDict(TypedDict):
|
|
1137
|
+
amount: NotRequired[pulumi.Input[int]]
|
|
1138
|
+
"""
|
|
1139
|
+
How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
1140
|
+
"""
|
|
1141
|
+
interval: NotRequired[pulumi.Input[int]]
|
|
1142
|
+
"""
|
|
1143
|
+
Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
1144
|
+
"""
|
|
1145
|
+
elif False:
|
|
1146
|
+
CheckGroupAlertSettingsReminderArgsDict: TypeAlias = Mapping[str, Any]
|
|
1147
|
+
|
|
1148
|
+
@pulumi.input_type
|
|
1149
|
+
class CheckGroupAlertSettingsReminderArgs:
|
|
1150
|
+
def __init__(__self__, *,
|
|
1151
|
+
amount: Optional[pulumi.Input[int]] = None,
|
|
1152
|
+
interval: Optional[pulumi.Input[int]] = None):
|
|
1153
|
+
"""
|
|
1154
|
+
:param pulumi.Input[int] amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
1155
|
+
:param pulumi.Input[int] interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
1156
|
+
"""
|
|
1157
|
+
if amount is not None:
|
|
1158
|
+
pulumi.set(__self__, "amount", amount)
|
|
1159
|
+
if interval is not None:
|
|
1160
|
+
pulumi.set(__self__, "interval", interval)
|
|
1161
|
+
|
|
1162
|
+
@property
|
|
1163
|
+
@pulumi.getter
|
|
1164
|
+
def amount(self) -> Optional[pulumi.Input[int]]:
|
|
1165
|
+
"""
|
|
1166
|
+
How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
1167
|
+
"""
|
|
1168
|
+
return pulumi.get(self, "amount")
|
|
1169
|
+
|
|
1170
|
+
@amount.setter
|
|
1171
|
+
def amount(self, value: Optional[pulumi.Input[int]]):
|
|
1172
|
+
pulumi.set(self, "amount", value)
|
|
1173
|
+
|
|
1174
|
+
@property
|
|
1175
|
+
@pulumi.getter
|
|
1176
|
+
def interval(self) -> Optional[pulumi.Input[int]]:
|
|
1177
|
+
"""
|
|
1178
|
+
Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
1179
|
+
"""
|
|
1180
|
+
return pulumi.get(self, "interval")
|
|
1181
|
+
|
|
1182
|
+
@interval.setter
|
|
1183
|
+
def interval(self, value: Optional[pulumi.Input[int]]):
|
|
1184
|
+
pulumi.set(self, "interval", value)
|
|
1185
|
+
|
|
1186
|
+
|
|
1187
|
+
if not MYPY:
|
|
1188
|
+
class CheckGroupAlertSettingsRunBasedEscalationArgsDict(TypedDict):
|
|
1189
|
+
failed_run_threshold: NotRequired[pulumi.Input[int]]
|
|
1190
|
+
"""
|
|
1191
|
+
After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
1192
|
+
"""
|
|
1193
|
+
elif False:
|
|
1194
|
+
CheckGroupAlertSettingsRunBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
1195
|
+
|
|
1196
|
+
@pulumi.input_type
|
|
1197
|
+
class CheckGroupAlertSettingsRunBasedEscalationArgs:
|
|
1198
|
+
def __init__(__self__, *,
|
|
1199
|
+
failed_run_threshold: Optional[pulumi.Input[int]] = None):
|
|
1200
|
+
"""
|
|
1201
|
+
:param pulumi.Input[int] failed_run_threshold: After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
1202
|
+
"""
|
|
1203
|
+
if failed_run_threshold is not None:
|
|
1204
|
+
pulumi.set(__self__, "failed_run_threshold", failed_run_threshold)
|
|
1205
|
+
|
|
1206
|
+
@property
|
|
1207
|
+
@pulumi.getter(name="failedRunThreshold")
|
|
1208
|
+
def failed_run_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
1209
|
+
"""
|
|
1210
|
+
After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
1211
|
+
"""
|
|
1212
|
+
return pulumi.get(self, "failed_run_threshold")
|
|
1213
|
+
|
|
1214
|
+
@failed_run_threshold.setter
|
|
1215
|
+
def failed_run_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
1216
|
+
pulumi.set(self, "failed_run_threshold", value)
|
|
1217
|
+
|
|
1218
|
+
|
|
1219
|
+
if not MYPY:
|
|
1220
|
+
class CheckGroupAlertSettingsSslCertificateArgsDict(TypedDict):
|
|
1221
|
+
alert_threshold: NotRequired[pulumi.Input[int]]
|
|
1222
|
+
"""
|
|
1223
|
+
At what moment in time to start alerting on SSL certificates. Possible values `3`, `7`, `14`, `30`. (Default `3`).
|
|
1224
|
+
"""
|
|
1225
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
1226
|
+
"""
|
|
1227
|
+
Determines if alert notifications should be sent for expiring SSL certificates.
|
|
1228
|
+
"""
|
|
1229
|
+
elif False:
|
|
1230
|
+
CheckGroupAlertSettingsSslCertificateArgsDict: TypeAlias = Mapping[str, Any]
|
|
1231
|
+
|
|
1232
|
+
@pulumi.input_type
|
|
1233
|
+
class CheckGroupAlertSettingsSslCertificateArgs:
|
|
1234
|
+
def __init__(__self__, *,
|
|
1235
|
+
alert_threshold: Optional[pulumi.Input[int]] = None,
|
|
1236
|
+
enabled: Optional[pulumi.Input[bool]] = None):
|
|
1237
|
+
"""
|
|
1238
|
+
:param pulumi.Input[int] alert_threshold: At what moment in time to start alerting on SSL certificates. Possible values `3`, `7`, `14`, `30`. (Default `3`).
|
|
1239
|
+
:param pulumi.Input[bool] enabled: Determines if alert notifications should be sent for expiring SSL certificates.
|
|
1240
|
+
"""
|
|
1241
|
+
if alert_threshold is not None:
|
|
1242
|
+
pulumi.set(__self__, "alert_threshold", alert_threshold)
|
|
1243
|
+
if enabled is not None:
|
|
1244
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
1245
|
+
|
|
1246
|
+
@property
|
|
1247
|
+
@pulumi.getter(name="alertThreshold")
|
|
1248
|
+
def alert_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
1249
|
+
"""
|
|
1250
|
+
At what moment in time to start alerting on SSL certificates. Possible values `3`, `7`, `14`, `30`. (Default `3`).
|
|
1251
|
+
"""
|
|
1252
|
+
return pulumi.get(self, "alert_threshold")
|
|
1253
|
+
|
|
1254
|
+
@alert_threshold.setter
|
|
1255
|
+
def alert_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
1256
|
+
pulumi.set(self, "alert_threshold", value)
|
|
1257
|
+
|
|
1258
|
+
@property
|
|
1259
|
+
@pulumi.getter
|
|
1260
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1261
|
+
"""
|
|
1262
|
+
Determines if alert notifications should be sent for expiring SSL certificates.
|
|
1263
|
+
"""
|
|
1264
|
+
return pulumi.get(self, "enabled")
|
|
1265
|
+
|
|
1266
|
+
@enabled.setter
|
|
1267
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1268
|
+
pulumi.set(self, "enabled", value)
|
|
1269
|
+
|
|
1270
|
+
|
|
1271
|
+
if not MYPY:
|
|
1272
|
+
class CheckGroupAlertSettingsTimeBasedEscalationArgsDict(TypedDict):
|
|
1273
|
+
minutes_failing_threshold: NotRequired[pulumi.Input[int]]
|
|
1274
|
+
"""
|
|
1275
|
+
After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
1276
|
+
"""
|
|
1277
|
+
elif False:
|
|
1278
|
+
CheckGroupAlertSettingsTimeBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
1279
|
+
|
|
1280
|
+
@pulumi.input_type
|
|
1281
|
+
class CheckGroupAlertSettingsTimeBasedEscalationArgs:
|
|
1282
|
+
def __init__(__self__, *,
|
|
1283
|
+
minutes_failing_threshold: Optional[pulumi.Input[int]] = None):
|
|
1284
|
+
"""
|
|
1285
|
+
:param pulumi.Input[int] minutes_failing_threshold: After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
1286
|
+
"""
|
|
1287
|
+
if minutes_failing_threshold is not None:
|
|
1288
|
+
pulumi.set(__self__, "minutes_failing_threshold", minutes_failing_threshold)
|
|
1289
|
+
|
|
1290
|
+
@property
|
|
1291
|
+
@pulumi.getter(name="minutesFailingThreshold")
|
|
1292
|
+
def minutes_failing_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
1293
|
+
"""
|
|
1294
|
+
After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
1295
|
+
"""
|
|
1296
|
+
return pulumi.get(self, "minutes_failing_threshold")
|
|
1297
|
+
|
|
1298
|
+
@minutes_failing_threshold.setter
|
|
1299
|
+
def minutes_failing_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
1300
|
+
pulumi.set(self, "minutes_failing_threshold", value)
|
|
1301
|
+
|
|
1302
|
+
|
|
1303
|
+
if not MYPY:
|
|
1304
|
+
class CheckGroupApiCheckDefaultsArgsDict(TypedDict):
|
|
1305
|
+
assertions: NotRequired[pulumi.Input[Sequence[pulumi.Input['CheckGroupApiCheckDefaultsAssertionArgsDict']]]]
|
|
1306
|
+
basic_auth: NotRequired[pulumi.Input['CheckGroupApiCheckDefaultsBasicAuthArgsDict']]
|
|
1307
|
+
headers: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1308
|
+
query_parameters: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1309
|
+
url: NotRequired[pulumi.Input[str]]
|
|
1310
|
+
"""
|
|
1311
|
+
The base url for this group which you can reference with the `GROUP_BASE_URL` variable in all group checks.
|
|
1312
|
+
"""
|
|
1313
|
+
elif False:
|
|
1314
|
+
CheckGroupApiCheckDefaultsArgsDict: TypeAlias = Mapping[str, Any]
|
|
1315
|
+
|
|
1316
|
+
@pulumi.input_type
|
|
1317
|
+
class CheckGroupApiCheckDefaultsArgs:
|
|
1318
|
+
def __init__(__self__, *,
|
|
1319
|
+
assertions: Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupApiCheckDefaultsAssertionArgs']]]] = None,
|
|
1320
|
+
basic_auth: Optional[pulumi.Input['CheckGroupApiCheckDefaultsBasicAuthArgs']] = None,
|
|
1321
|
+
headers: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1322
|
+
query_parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1323
|
+
url: Optional[pulumi.Input[str]] = None):
|
|
1324
|
+
"""
|
|
1325
|
+
:param pulumi.Input[str] url: The base url for this group which you can reference with the `GROUP_BASE_URL` variable in all group checks.
|
|
1326
|
+
"""
|
|
1327
|
+
if assertions is not None:
|
|
1328
|
+
pulumi.set(__self__, "assertions", assertions)
|
|
1329
|
+
if basic_auth is not None:
|
|
1330
|
+
pulumi.set(__self__, "basic_auth", basic_auth)
|
|
1331
|
+
if headers is not None:
|
|
1332
|
+
pulumi.set(__self__, "headers", headers)
|
|
1333
|
+
if query_parameters is not None:
|
|
1334
|
+
pulumi.set(__self__, "query_parameters", query_parameters)
|
|
1335
|
+
if url is None:
|
|
1336
|
+
url = ''
|
|
1337
|
+
if url is not None:
|
|
1338
|
+
pulumi.set(__self__, "url", url)
|
|
1339
|
+
|
|
1340
|
+
@property
|
|
1341
|
+
@pulumi.getter
|
|
1342
|
+
def assertions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupApiCheckDefaultsAssertionArgs']]]]:
|
|
1343
|
+
return pulumi.get(self, "assertions")
|
|
1344
|
+
|
|
1345
|
+
@assertions.setter
|
|
1346
|
+
def assertions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CheckGroupApiCheckDefaultsAssertionArgs']]]]):
|
|
1347
|
+
pulumi.set(self, "assertions", value)
|
|
1348
|
+
|
|
1349
|
+
@property
|
|
1350
|
+
@pulumi.getter(name="basicAuth")
|
|
1351
|
+
def basic_auth(self) -> Optional[pulumi.Input['CheckGroupApiCheckDefaultsBasicAuthArgs']]:
|
|
1352
|
+
return pulumi.get(self, "basic_auth")
|
|
1353
|
+
|
|
1354
|
+
@basic_auth.setter
|
|
1355
|
+
def basic_auth(self, value: Optional[pulumi.Input['CheckGroupApiCheckDefaultsBasicAuthArgs']]):
|
|
1356
|
+
pulumi.set(self, "basic_auth", value)
|
|
1357
|
+
|
|
1358
|
+
@property
|
|
1359
|
+
@pulumi.getter
|
|
1360
|
+
def headers(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1361
|
+
return pulumi.get(self, "headers")
|
|
1362
|
+
|
|
1363
|
+
@headers.setter
|
|
1364
|
+
def headers(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1365
|
+
pulumi.set(self, "headers", value)
|
|
1366
|
+
|
|
1367
|
+
@property
|
|
1368
|
+
@pulumi.getter(name="queryParameters")
|
|
1369
|
+
def query_parameters(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1370
|
+
return pulumi.get(self, "query_parameters")
|
|
1371
|
+
|
|
1372
|
+
@query_parameters.setter
|
|
1373
|
+
def query_parameters(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1374
|
+
pulumi.set(self, "query_parameters", value)
|
|
1375
|
+
|
|
1376
|
+
@property
|
|
1377
|
+
@pulumi.getter
|
|
1378
|
+
def url(self) -> Optional[pulumi.Input[str]]:
|
|
1379
|
+
"""
|
|
1380
|
+
The base url for this group which you can reference with the `GROUP_BASE_URL` variable in all group checks.
|
|
1381
|
+
"""
|
|
1382
|
+
return pulumi.get(self, "url")
|
|
1383
|
+
|
|
1384
|
+
@url.setter
|
|
1385
|
+
def url(self, value: Optional[pulumi.Input[str]]):
|
|
1386
|
+
pulumi.set(self, "url", value)
|
|
1387
|
+
|
|
1388
|
+
|
|
1389
|
+
if not MYPY:
|
|
1390
|
+
class CheckGroupApiCheckDefaultsAssertionArgsDict(TypedDict):
|
|
1391
|
+
comparison: pulumi.Input[str]
|
|
1392
|
+
"""
|
|
1393
|
+
The type of comparison to be executed between expected and actual value of the assertion. Possible values `EQUALS`, `NOT_EQUALS`, `HAS_KEY`, `NOT_HAS_KEY`, `HAS_VALUE`, `NOT_HAS_VALUE`, `IS_EMPTY`, `NOT_EMPTY`, `GREATER_THAN`, `LESS_THAN`, `CONTAINS`, `NOT_CONTAINS`, `IS_NULL`, and `NOT_NULL`.
|
|
1394
|
+
"""
|
|
1395
|
+
source: pulumi.Input[str]
|
|
1396
|
+
"""
|
|
1397
|
+
The source of the asserted value. Possible values `STATUS_CODE`, `JSON_BODY`, `HEADERS`, `TEXT_BODY`, and `RESPONSE_TIME`.
|
|
1398
|
+
"""
|
|
1399
|
+
target: pulumi.Input[str]
|
|
1400
|
+
property: NotRequired[pulumi.Input[str]]
|
|
1401
|
+
elif False:
|
|
1402
|
+
CheckGroupApiCheckDefaultsAssertionArgsDict: TypeAlias = Mapping[str, Any]
|
|
1403
|
+
|
|
1404
|
+
@pulumi.input_type
|
|
1405
|
+
class CheckGroupApiCheckDefaultsAssertionArgs:
|
|
1406
|
+
def __init__(__self__, *,
|
|
1407
|
+
comparison: pulumi.Input[str],
|
|
1408
|
+
source: pulumi.Input[str],
|
|
1409
|
+
target: pulumi.Input[str],
|
|
1410
|
+
property: Optional[pulumi.Input[str]] = None):
|
|
1411
|
+
"""
|
|
1412
|
+
:param pulumi.Input[str] comparison: The type of comparison to be executed between expected and actual value of the assertion. Possible values `EQUALS`, `NOT_EQUALS`, `HAS_KEY`, `NOT_HAS_KEY`, `HAS_VALUE`, `NOT_HAS_VALUE`, `IS_EMPTY`, `NOT_EMPTY`, `GREATER_THAN`, `LESS_THAN`, `CONTAINS`, `NOT_CONTAINS`, `IS_NULL`, and `NOT_NULL`.
|
|
1413
|
+
:param pulumi.Input[str] source: The source of the asserted value. Possible values `STATUS_CODE`, `JSON_BODY`, `HEADERS`, `TEXT_BODY`, and `RESPONSE_TIME`.
|
|
1414
|
+
"""
|
|
1415
|
+
pulumi.set(__self__, "comparison", comparison)
|
|
1416
|
+
pulumi.set(__self__, "source", source)
|
|
1417
|
+
pulumi.set(__self__, "target", target)
|
|
1418
|
+
if property is not None:
|
|
1419
|
+
pulumi.set(__self__, "property", property)
|
|
1420
|
+
|
|
1421
|
+
@property
|
|
1422
|
+
@pulumi.getter
|
|
1423
|
+
def comparison(self) -> pulumi.Input[str]:
|
|
1424
|
+
"""
|
|
1425
|
+
The type of comparison to be executed between expected and actual value of the assertion. Possible values `EQUALS`, `NOT_EQUALS`, `HAS_KEY`, `NOT_HAS_KEY`, `HAS_VALUE`, `NOT_HAS_VALUE`, `IS_EMPTY`, `NOT_EMPTY`, `GREATER_THAN`, `LESS_THAN`, `CONTAINS`, `NOT_CONTAINS`, `IS_NULL`, and `NOT_NULL`.
|
|
1426
|
+
"""
|
|
1427
|
+
return pulumi.get(self, "comparison")
|
|
1428
|
+
|
|
1429
|
+
@comparison.setter
|
|
1430
|
+
def comparison(self, value: pulumi.Input[str]):
|
|
1431
|
+
pulumi.set(self, "comparison", value)
|
|
1432
|
+
|
|
1433
|
+
@property
|
|
1434
|
+
@pulumi.getter
|
|
1435
|
+
def source(self) -> pulumi.Input[str]:
|
|
1436
|
+
"""
|
|
1437
|
+
The source of the asserted value. Possible values `STATUS_CODE`, `JSON_BODY`, `HEADERS`, `TEXT_BODY`, and `RESPONSE_TIME`.
|
|
1438
|
+
"""
|
|
1439
|
+
return pulumi.get(self, "source")
|
|
1440
|
+
|
|
1441
|
+
@source.setter
|
|
1442
|
+
def source(self, value: pulumi.Input[str]):
|
|
1443
|
+
pulumi.set(self, "source", value)
|
|
1444
|
+
|
|
1445
|
+
@property
|
|
1446
|
+
@pulumi.getter
|
|
1447
|
+
def target(self) -> pulumi.Input[str]:
|
|
1448
|
+
return pulumi.get(self, "target")
|
|
1449
|
+
|
|
1450
|
+
@target.setter
|
|
1451
|
+
def target(self, value: pulumi.Input[str]):
|
|
1452
|
+
pulumi.set(self, "target", value)
|
|
1453
|
+
|
|
1454
|
+
@property
|
|
1455
|
+
@pulumi.getter
|
|
1456
|
+
def property(self) -> Optional[pulumi.Input[str]]:
|
|
1457
|
+
return pulumi.get(self, "property")
|
|
1458
|
+
|
|
1459
|
+
@property.setter
|
|
1460
|
+
def property(self, value: Optional[pulumi.Input[str]]):
|
|
1461
|
+
pulumi.set(self, "property", value)
|
|
1462
|
+
|
|
1463
|
+
|
|
1464
|
+
if not MYPY:
|
|
1465
|
+
class CheckGroupApiCheckDefaultsBasicAuthArgsDict(TypedDict):
|
|
1466
|
+
password: pulumi.Input[str]
|
|
1467
|
+
username: pulumi.Input[str]
|
|
1468
|
+
elif False:
|
|
1469
|
+
CheckGroupApiCheckDefaultsBasicAuthArgsDict: TypeAlias = Mapping[str, Any]
|
|
1470
|
+
|
|
1471
|
+
@pulumi.input_type
|
|
1472
|
+
class CheckGroupApiCheckDefaultsBasicAuthArgs:
|
|
1473
|
+
def __init__(__self__, *,
|
|
1474
|
+
password: pulumi.Input[str],
|
|
1475
|
+
username: pulumi.Input[str]):
|
|
1476
|
+
pulumi.set(__self__, "password", password)
|
|
1477
|
+
pulumi.set(__self__, "username", username)
|
|
1478
|
+
|
|
1479
|
+
@property
|
|
1480
|
+
@pulumi.getter
|
|
1481
|
+
def password(self) -> pulumi.Input[str]:
|
|
1482
|
+
return pulumi.get(self, "password")
|
|
1483
|
+
|
|
1484
|
+
@password.setter
|
|
1485
|
+
def password(self, value: pulumi.Input[str]):
|
|
1486
|
+
pulumi.set(self, "password", value)
|
|
1487
|
+
|
|
1488
|
+
@property
|
|
1489
|
+
@pulumi.getter
|
|
1490
|
+
def username(self) -> pulumi.Input[str]:
|
|
1491
|
+
return pulumi.get(self, "username")
|
|
1492
|
+
|
|
1493
|
+
@username.setter
|
|
1494
|
+
def username(self, value: pulumi.Input[str]):
|
|
1495
|
+
pulumi.set(self, "username", value)
|
|
1496
|
+
|
|
1497
|
+
|
|
1498
|
+
if not MYPY:
|
|
1499
|
+
class CheckGroupEnvironmentVariableArgsDict(TypedDict):
|
|
1500
|
+
key: pulumi.Input[str]
|
|
1501
|
+
value: pulumi.Input[str]
|
|
1502
|
+
locked: NotRequired[pulumi.Input[bool]]
|
|
1503
|
+
secret: NotRequired[pulumi.Input[bool]]
|
|
1504
|
+
elif False:
|
|
1505
|
+
CheckGroupEnvironmentVariableArgsDict: TypeAlias = Mapping[str, Any]
|
|
1506
|
+
|
|
1507
|
+
@pulumi.input_type
|
|
1508
|
+
class CheckGroupEnvironmentVariableArgs:
|
|
1509
|
+
def __init__(__self__, *,
|
|
1510
|
+
key: pulumi.Input[str],
|
|
1511
|
+
value: pulumi.Input[str],
|
|
1512
|
+
locked: Optional[pulumi.Input[bool]] = None,
|
|
1513
|
+
secret: Optional[pulumi.Input[bool]] = None):
|
|
1514
|
+
pulumi.set(__self__, "key", key)
|
|
1515
|
+
pulumi.set(__self__, "value", value)
|
|
1516
|
+
if locked is not None:
|
|
1517
|
+
pulumi.set(__self__, "locked", locked)
|
|
1518
|
+
if secret is not None:
|
|
1519
|
+
pulumi.set(__self__, "secret", secret)
|
|
1520
|
+
|
|
1521
|
+
@property
|
|
1522
|
+
@pulumi.getter
|
|
1523
|
+
def key(self) -> pulumi.Input[str]:
|
|
1524
|
+
return pulumi.get(self, "key")
|
|
1525
|
+
|
|
1526
|
+
@key.setter
|
|
1527
|
+
def key(self, value: pulumi.Input[str]):
|
|
1528
|
+
pulumi.set(self, "key", value)
|
|
1529
|
+
|
|
1530
|
+
@property
|
|
1531
|
+
@pulumi.getter
|
|
1532
|
+
def value(self) -> pulumi.Input[str]:
|
|
1533
|
+
return pulumi.get(self, "value")
|
|
1534
|
+
|
|
1535
|
+
@value.setter
|
|
1536
|
+
def value(self, value: pulumi.Input[str]):
|
|
1537
|
+
pulumi.set(self, "value", value)
|
|
1538
|
+
|
|
1539
|
+
@property
|
|
1540
|
+
@pulumi.getter
|
|
1541
|
+
def locked(self) -> Optional[pulumi.Input[bool]]:
|
|
1542
|
+
return pulumi.get(self, "locked")
|
|
1543
|
+
|
|
1544
|
+
@locked.setter
|
|
1545
|
+
def locked(self, value: Optional[pulumi.Input[bool]]):
|
|
1546
|
+
pulumi.set(self, "locked", value)
|
|
1547
|
+
|
|
1548
|
+
@property
|
|
1549
|
+
@pulumi.getter
|
|
1550
|
+
def secret(self) -> Optional[pulumi.Input[bool]]:
|
|
1551
|
+
return pulumi.get(self, "secret")
|
|
1552
|
+
|
|
1553
|
+
@secret.setter
|
|
1554
|
+
def secret(self, value: Optional[pulumi.Input[bool]]):
|
|
1555
|
+
pulumi.set(self, "secret", value)
|
|
1556
|
+
|
|
1557
|
+
|
|
1558
|
+
if not MYPY:
|
|
1559
|
+
class CheckGroupRetryStrategyArgsDict(TypedDict):
|
|
1560
|
+
type: pulumi.Input[str]
|
|
1561
|
+
"""
|
|
1562
|
+
Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
|
|
1563
|
+
"""
|
|
1564
|
+
base_backoff_seconds: NotRequired[pulumi.Input[int]]
|
|
1565
|
+
"""
|
|
1566
|
+
The number of seconds to wait before the first retry attempt.
|
|
1567
|
+
"""
|
|
1568
|
+
max_duration_seconds: NotRequired[pulumi.Input[int]]
|
|
1569
|
+
"""
|
|
1570
|
+
The total amount of time to continue retrying the check (maximum 600 seconds).
|
|
1571
|
+
"""
|
|
1572
|
+
max_retries: NotRequired[pulumi.Input[int]]
|
|
1573
|
+
"""
|
|
1574
|
+
The maximum number of times to retry the check. Value must be between 1 and 10.
|
|
1575
|
+
"""
|
|
1576
|
+
same_region: NotRequired[pulumi.Input[bool]]
|
|
1577
|
+
"""
|
|
1578
|
+
Whether retries should be run in the same region as the initial check run.
|
|
1579
|
+
"""
|
|
1580
|
+
elif False:
|
|
1581
|
+
CheckGroupRetryStrategyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1582
|
+
|
|
1583
|
+
@pulumi.input_type
|
|
1584
|
+
class CheckGroupRetryStrategyArgs:
|
|
1585
|
+
def __init__(__self__, *,
|
|
1586
|
+
type: pulumi.Input[str],
|
|
1587
|
+
base_backoff_seconds: Optional[pulumi.Input[int]] = None,
|
|
1588
|
+
max_duration_seconds: Optional[pulumi.Input[int]] = None,
|
|
1589
|
+
max_retries: Optional[pulumi.Input[int]] = None,
|
|
1590
|
+
same_region: Optional[pulumi.Input[bool]] = None):
|
|
1591
|
+
"""
|
|
1592
|
+
:param pulumi.Input[str] type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
|
|
1593
|
+
:param pulumi.Input[int] base_backoff_seconds: The number of seconds to wait before the first retry attempt.
|
|
1594
|
+
:param pulumi.Input[int] max_duration_seconds: The total amount of time to continue retrying the check (maximum 600 seconds).
|
|
1595
|
+
:param pulumi.Input[int] max_retries: The maximum number of times to retry the check. Value must be between 1 and 10.
|
|
1596
|
+
:param pulumi.Input[bool] same_region: Whether retries should be run in the same region as the initial check run.
|
|
1597
|
+
"""
|
|
1598
|
+
pulumi.set(__self__, "type", type)
|
|
1599
|
+
if base_backoff_seconds is not None:
|
|
1600
|
+
pulumi.set(__self__, "base_backoff_seconds", base_backoff_seconds)
|
|
1601
|
+
if max_duration_seconds is not None:
|
|
1602
|
+
pulumi.set(__self__, "max_duration_seconds", max_duration_seconds)
|
|
1603
|
+
if max_retries is not None:
|
|
1604
|
+
pulumi.set(__self__, "max_retries", max_retries)
|
|
1605
|
+
if same_region is not None:
|
|
1606
|
+
pulumi.set(__self__, "same_region", same_region)
|
|
1607
|
+
|
|
1608
|
+
@property
|
|
1609
|
+
@pulumi.getter
|
|
1610
|
+
def type(self) -> pulumi.Input[str]:
|
|
1611
|
+
"""
|
|
1612
|
+
Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
|
|
1613
|
+
"""
|
|
1614
|
+
return pulumi.get(self, "type")
|
|
1615
|
+
|
|
1616
|
+
@type.setter
|
|
1617
|
+
def type(self, value: pulumi.Input[str]):
|
|
1618
|
+
pulumi.set(self, "type", value)
|
|
1619
|
+
|
|
1620
|
+
@property
|
|
1621
|
+
@pulumi.getter(name="baseBackoffSeconds")
|
|
1622
|
+
def base_backoff_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
1623
|
+
"""
|
|
1624
|
+
The number of seconds to wait before the first retry attempt.
|
|
1625
|
+
"""
|
|
1626
|
+
return pulumi.get(self, "base_backoff_seconds")
|
|
1627
|
+
|
|
1628
|
+
@base_backoff_seconds.setter
|
|
1629
|
+
def base_backoff_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
1630
|
+
pulumi.set(self, "base_backoff_seconds", value)
|
|
1631
|
+
|
|
1632
|
+
@property
|
|
1633
|
+
@pulumi.getter(name="maxDurationSeconds")
|
|
1634
|
+
def max_duration_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
1635
|
+
"""
|
|
1636
|
+
The total amount of time to continue retrying the check (maximum 600 seconds).
|
|
1637
|
+
"""
|
|
1638
|
+
return pulumi.get(self, "max_duration_seconds")
|
|
1639
|
+
|
|
1640
|
+
@max_duration_seconds.setter
|
|
1641
|
+
def max_duration_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
1642
|
+
pulumi.set(self, "max_duration_seconds", value)
|
|
1643
|
+
|
|
1644
|
+
@property
|
|
1645
|
+
@pulumi.getter(name="maxRetries")
|
|
1646
|
+
def max_retries(self) -> Optional[pulumi.Input[int]]:
|
|
1647
|
+
"""
|
|
1648
|
+
The maximum number of times to retry the check. Value must be between 1 and 10.
|
|
1649
|
+
"""
|
|
1650
|
+
return pulumi.get(self, "max_retries")
|
|
1651
|
+
|
|
1652
|
+
@max_retries.setter
|
|
1653
|
+
def max_retries(self, value: Optional[pulumi.Input[int]]):
|
|
1654
|
+
pulumi.set(self, "max_retries", value)
|
|
1655
|
+
|
|
1656
|
+
@property
|
|
1657
|
+
@pulumi.getter(name="sameRegion")
|
|
1658
|
+
def same_region(self) -> Optional[pulumi.Input[bool]]:
|
|
1659
|
+
"""
|
|
1660
|
+
Whether retries should be run in the same region as the initial check run.
|
|
1661
|
+
"""
|
|
1662
|
+
return pulumi.get(self, "same_region")
|
|
1663
|
+
|
|
1664
|
+
@same_region.setter
|
|
1665
|
+
def same_region(self, value: Optional[pulumi.Input[bool]]):
|
|
1666
|
+
pulumi.set(self, "same_region", value)
|
|
1667
|
+
|
|
1668
|
+
|
|
1669
|
+
if not MYPY:
|
|
1670
|
+
class CheckRequestArgsDict(TypedDict):
|
|
1671
|
+
url: pulumi.Input[str]
|
|
1672
|
+
assertions: NotRequired[pulumi.Input[Sequence[pulumi.Input['CheckRequestAssertionArgsDict']]]]
|
|
1673
|
+
"""
|
|
1674
|
+
A request can have multiple assertions.
|
|
1675
|
+
"""
|
|
1676
|
+
basic_auth: NotRequired[pulumi.Input['CheckRequestBasicAuthArgsDict']]
|
|
1677
|
+
"""
|
|
1678
|
+
Set up HTTP basic authentication (username & password).
|
|
1679
|
+
"""
|
|
1680
|
+
body: NotRequired[pulumi.Input[str]]
|
|
1681
|
+
"""
|
|
1682
|
+
The body of the request.
|
|
1683
|
+
"""
|
|
1684
|
+
body_type: NotRequired[pulumi.Input[str]]
|
|
1685
|
+
"""
|
|
1686
|
+
The `Content-Type` header of the request. Possible values `NONE`, `JSON`, `FORM`, `RAW`, and `GRAPHQL`.
|
|
1687
|
+
"""
|
|
1688
|
+
follow_redirects: NotRequired[pulumi.Input[bool]]
|
|
1689
|
+
headers: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1690
|
+
ip_family: NotRequired[pulumi.Input[str]]
|
|
1691
|
+
"""
|
|
1692
|
+
IP Family to be used when executing the api check. The value can be either IPv4 or IPv6.
|
|
1693
|
+
"""
|
|
1694
|
+
method: NotRequired[pulumi.Input[str]]
|
|
1695
|
+
"""
|
|
1696
|
+
The HTTP method to use for this API check. Possible values are `GET`, `POST`, `PUT`, `HEAD`, `DELETE`, `PATCH`. (Default `GET`).
|
|
1697
|
+
"""
|
|
1698
|
+
query_parameters: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1699
|
+
skip_ssl: NotRequired[pulumi.Input[bool]]
|
|
1700
|
+
elif False:
|
|
1701
|
+
CheckRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
1702
|
+
|
|
1703
|
+
@pulumi.input_type
|
|
1704
|
+
class CheckRequestArgs:
|
|
1705
|
+
def __init__(__self__, *,
|
|
1706
|
+
url: pulumi.Input[str],
|
|
1707
|
+
assertions: Optional[pulumi.Input[Sequence[pulumi.Input['CheckRequestAssertionArgs']]]] = None,
|
|
1708
|
+
basic_auth: Optional[pulumi.Input['CheckRequestBasicAuthArgs']] = None,
|
|
1709
|
+
body: Optional[pulumi.Input[str]] = None,
|
|
1710
|
+
body_type: Optional[pulumi.Input[str]] = None,
|
|
1711
|
+
follow_redirects: Optional[pulumi.Input[bool]] = None,
|
|
1712
|
+
headers: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1713
|
+
ip_family: Optional[pulumi.Input[str]] = None,
|
|
1714
|
+
method: Optional[pulumi.Input[str]] = None,
|
|
1715
|
+
query_parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1716
|
+
skip_ssl: Optional[pulumi.Input[bool]] = None):
|
|
1717
|
+
"""
|
|
1718
|
+
:param pulumi.Input[Sequence[pulumi.Input['CheckRequestAssertionArgs']]] assertions: A request can have multiple assertions.
|
|
1719
|
+
:param pulumi.Input['CheckRequestBasicAuthArgs'] basic_auth: Set up HTTP basic authentication (username & password).
|
|
1720
|
+
:param pulumi.Input[str] body: The body of the request.
|
|
1721
|
+
:param pulumi.Input[str] body_type: The `Content-Type` header of the request. Possible values `NONE`, `JSON`, `FORM`, `RAW`, and `GRAPHQL`.
|
|
1722
|
+
:param pulumi.Input[str] ip_family: IP Family to be used when executing the api check. The value can be either IPv4 or IPv6.
|
|
1723
|
+
:param pulumi.Input[str] method: The HTTP method to use for this API check. Possible values are `GET`, `POST`, `PUT`, `HEAD`, `DELETE`, `PATCH`. (Default `GET`).
|
|
1724
|
+
"""
|
|
1725
|
+
pulumi.set(__self__, "url", url)
|
|
1726
|
+
if assertions is not None:
|
|
1727
|
+
pulumi.set(__self__, "assertions", assertions)
|
|
1728
|
+
if basic_auth is not None:
|
|
1729
|
+
pulumi.set(__self__, "basic_auth", basic_auth)
|
|
1730
|
+
if body is not None:
|
|
1731
|
+
pulumi.set(__self__, "body", body)
|
|
1732
|
+
if body_type is not None:
|
|
1733
|
+
pulumi.set(__self__, "body_type", body_type)
|
|
1734
|
+
if follow_redirects is not None:
|
|
1735
|
+
pulumi.set(__self__, "follow_redirects", follow_redirects)
|
|
1736
|
+
if headers is not None:
|
|
1737
|
+
pulumi.set(__self__, "headers", headers)
|
|
1738
|
+
if ip_family is not None:
|
|
1739
|
+
pulumi.set(__self__, "ip_family", ip_family)
|
|
1740
|
+
if method is not None:
|
|
1741
|
+
pulumi.set(__self__, "method", method)
|
|
1742
|
+
if query_parameters is not None:
|
|
1743
|
+
pulumi.set(__self__, "query_parameters", query_parameters)
|
|
1744
|
+
if skip_ssl is not None:
|
|
1745
|
+
pulumi.set(__self__, "skip_ssl", skip_ssl)
|
|
1746
|
+
|
|
1747
|
+
@property
|
|
1748
|
+
@pulumi.getter
|
|
1749
|
+
def url(self) -> pulumi.Input[str]:
|
|
1750
|
+
return pulumi.get(self, "url")
|
|
1751
|
+
|
|
1752
|
+
@url.setter
|
|
1753
|
+
def url(self, value: pulumi.Input[str]):
|
|
1754
|
+
pulumi.set(self, "url", value)
|
|
1755
|
+
|
|
1756
|
+
@property
|
|
1757
|
+
@pulumi.getter
|
|
1758
|
+
def assertions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CheckRequestAssertionArgs']]]]:
|
|
1759
|
+
"""
|
|
1760
|
+
A request can have multiple assertions.
|
|
1761
|
+
"""
|
|
1762
|
+
return pulumi.get(self, "assertions")
|
|
1763
|
+
|
|
1764
|
+
@assertions.setter
|
|
1765
|
+
def assertions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CheckRequestAssertionArgs']]]]):
|
|
1766
|
+
pulumi.set(self, "assertions", value)
|
|
1767
|
+
|
|
1768
|
+
@property
|
|
1769
|
+
@pulumi.getter(name="basicAuth")
|
|
1770
|
+
def basic_auth(self) -> Optional[pulumi.Input['CheckRequestBasicAuthArgs']]:
|
|
1771
|
+
"""
|
|
1772
|
+
Set up HTTP basic authentication (username & password).
|
|
1773
|
+
"""
|
|
1774
|
+
return pulumi.get(self, "basic_auth")
|
|
1775
|
+
|
|
1776
|
+
@basic_auth.setter
|
|
1777
|
+
def basic_auth(self, value: Optional[pulumi.Input['CheckRequestBasicAuthArgs']]):
|
|
1778
|
+
pulumi.set(self, "basic_auth", value)
|
|
1779
|
+
|
|
1780
|
+
@property
|
|
1781
|
+
@pulumi.getter
|
|
1782
|
+
def body(self) -> Optional[pulumi.Input[str]]:
|
|
1783
|
+
"""
|
|
1784
|
+
The body of the request.
|
|
1785
|
+
"""
|
|
1786
|
+
return pulumi.get(self, "body")
|
|
1787
|
+
|
|
1788
|
+
@body.setter
|
|
1789
|
+
def body(self, value: Optional[pulumi.Input[str]]):
|
|
1790
|
+
pulumi.set(self, "body", value)
|
|
1791
|
+
|
|
1792
|
+
@property
|
|
1793
|
+
@pulumi.getter(name="bodyType")
|
|
1794
|
+
def body_type(self) -> Optional[pulumi.Input[str]]:
|
|
1795
|
+
"""
|
|
1796
|
+
The `Content-Type` header of the request. Possible values `NONE`, `JSON`, `FORM`, `RAW`, and `GRAPHQL`.
|
|
1797
|
+
"""
|
|
1798
|
+
return pulumi.get(self, "body_type")
|
|
1799
|
+
|
|
1800
|
+
@body_type.setter
|
|
1801
|
+
def body_type(self, value: Optional[pulumi.Input[str]]):
|
|
1802
|
+
pulumi.set(self, "body_type", value)
|
|
1803
|
+
|
|
1804
|
+
@property
|
|
1805
|
+
@pulumi.getter(name="followRedirects")
|
|
1806
|
+
def follow_redirects(self) -> Optional[pulumi.Input[bool]]:
|
|
1807
|
+
return pulumi.get(self, "follow_redirects")
|
|
1808
|
+
|
|
1809
|
+
@follow_redirects.setter
|
|
1810
|
+
def follow_redirects(self, value: Optional[pulumi.Input[bool]]):
|
|
1811
|
+
pulumi.set(self, "follow_redirects", value)
|
|
1812
|
+
|
|
1813
|
+
@property
|
|
1814
|
+
@pulumi.getter
|
|
1815
|
+
def headers(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1816
|
+
return pulumi.get(self, "headers")
|
|
1817
|
+
|
|
1818
|
+
@headers.setter
|
|
1819
|
+
def headers(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1820
|
+
pulumi.set(self, "headers", value)
|
|
1821
|
+
|
|
1822
|
+
@property
|
|
1823
|
+
@pulumi.getter(name="ipFamily")
|
|
1824
|
+
def ip_family(self) -> Optional[pulumi.Input[str]]:
|
|
1825
|
+
"""
|
|
1826
|
+
IP Family to be used when executing the api check. The value can be either IPv4 or IPv6.
|
|
1827
|
+
"""
|
|
1828
|
+
return pulumi.get(self, "ip_family")
|
|
1829
|
+
|
|
1830
|
+
@ip_family.setter
|
|
1831
|
+
def ip_family(self, value: Optional[pulumi.Input[str]]):
|
|
1832
|
+
pulumi.set(self, "ip_family", value)
|
|
1833
|
+
|
|
1834
|
+
@property
|
|
1835
|
+
@pulumi.getter
|
|
1836
|
+
def method(self) -> Optional[pulumi.Input[str]]:
|
|
1837
|
+
"""
|
|
1838
|
+
The HTTP method to use for this API check. Possible values are `GET`, `POST`, `PUT`, `HEAD`, `DELETE`, `PATCH`. (Default `GET`).
|
|
1839
|
+
"""
|
|
1840
|
+
return pulumi.get(self, "method")
|
|
1841
|
+
|
|
1842
|
+
@method.setter
|
|
1843
|
+
def method(self, value: Optional[pulumi.Input[str]]):
|
|
1844
|
+
pulumi.set(self, "method", value)
|
|
1845
|
+
|
|
1846
|
+
@property
|
|
1847
|
+
@pulumi.getter(name="queryParameters")
|
|
1848
|
+
def query_parameters(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1849
|
+
return pulumi.get(self, "query_parameters")
|
|
1850
|
+
|
|
1851
|
+
@query_parameters.setter
|
|
1852
|
+
def query_parameters(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1853
|
+
pulumi.set(self, "query_parameters", value)
|
|
1854
|
+
|
|
1855
|
+
@property
|
|
1856
|
+
@pulumi.getter(name="skipSsl")
|
|
1857
|
+
def skip_ssl(self) -> Optional[pulumi.Input[bool]]:
|
|
1858
|
+
return pulumi.get(self, "skip_ssl")
|
|
1859
|
+
|
|
1860
|
+
@skip_ssl.setter
|
|
1861
|
+
def skip_ssl(self, value: Optional[pulumi.Input[bool]]):
|
|
1862
|
+
pulumi.set(self, "skip_ssl", value)
|
|
1863
|
+
|
|
1864
|
+
|
|
1865
|
+
if not MYPY:
|
|
1866
|
+
class CheckRequestAssertionArgsDict(TypedDict):
|
|
1867
|
+
comparison: pulumi.Input[str]
|
|
1868
|
+
"""
|
|
1869
|
+
The type of comparison to be executed between expected and actual value of the assertion. Possible values `EQUALS`, `NOT_EQUALS`, `HAS_KEY`, `NOT_HAS_KEY`, `HAS_VALUE`, `NOT_HAS_VALUE`, `IS_EMPTY`, `NOT_EMPTY`, `GREATER_THAN`, `LESS_THAN`, `CONTAINS`, `NOT_CONTAINS`, `IS_NULL`, and `NOT_NULL`.
|
|
1870
|
+
"""
|
|
1871
|
+
source: pulumi.Input[str]
|
|
1872
|
+
"""
|
|
1873
|
+
The source of the asserted value. Possible values `STATUS_CODE`, `JSON_BODY`, `HEADERS`, `TEXT_BODY`, and `RESPONSE_TIME`.
|
|
1874
|
+
"""
|
|
1875
|
+
property: NotRequired[pulumi.Input[str]]
|
|
1876
|
+
target: NotRequired[pulumi.Input[str]]
|
|
1877
|
+
elif False:
|
|
1878
|
+
CheckRequestAssertionArgsDict: TypeAlias = Mapping[str, Any]
|
|
1879
|
+
|
|
1880
|
+
@pulumi.input_type
|
|
1881
|
+
class CheckRequestAssertionArgs:
|
|
1882
|
+
def __init__(__self__, *,
|
|
1883
|
+
comparison: pulumi.Input[str],
|
|
1884
|
+
source: pulumi.Input[str],
|
|
1885
|
+
property: Optional[pulumi.Input[str]] = None,
|
|
1886
|
+
target: Optional[pulumi.Input[str]] = None):
|
|
1887
|
+
"""
|
|
1888
|
+
:param pulumi.Input[str] comparison: The type of comparison to be executed between expected and actual value of the assertion. Possible values `EQUALS`, `NOT_EQUALS`, `HAS_KEY`, `NOT_HAS_KEY`, `HAS_VALUE`, `NOT_HAS_VALUE`, `IS_EMPTY`, `NOT_EMPTY`, `GREATER_THAN`, `LESS_THAN`, `CONTAINS`, `NOT_CONTAINS`, `IS_NULL`, and `NOT_NULL`.
|
|
1889
|
+
:param pulumi.Input[str] source: The source of the asserted value. Possible values `STATUS_CODE`, `JSON_BODY`, `HEADERS`, `TEXT_BODY`, and `RESPONSE_TIME`.
|
|
1890
|
+
"""
|
|
1891
|
+
pulumi.set(__self__, "comparison", comparison)
|
|
1892
|
+
pulumi.set(__self__, "source", source)
|
|
1893
|
+
if property is not None:
|
|
1894
|
+
pulumi.set(__self__, "property", property)
|
|
1895
|
+
if target is not None:
|
|
1896
|
+
pulumi.set(__self__, "target", target)
|
|
1897
|
+
|
|
1898
|
+
@property
|
|
1899
|
+
@pulumi.getter
|
|
1900
|
+
def comparison(self) -> pulumi.Input[str]:
|
|
1901
|
+
"""
|
|
1902
|
+
The type of comparison to be executed between expected and actual value of the assertion. Possible values `EQUALS`, `NOT_EQUALS`, `HAS_KEY`, `NOT_HAS_KEY`, `HAS_VALUE`, `NOT_HAS_VALUE`, `IS_EMPTY`, `NOT_EMPTY`, `GREATER_THAN`, `LESS_THAN`, `CONTAINS`, `NOT_CONTAINS`, `IS_NULL`, and `NOT_NULL`.
|
|
1903
|
+
"""
|
|
1904
|
+
return pulumi.get(self, "comparison")
|
|
1905
|
+
|
|
1906
|
+
@comparison.setter
|
|
1907
|
+
def comparison(self, value: pulumi.Input[str]):
|
|
1908
|
+
pulumi.set(self, "comparison", value)
|
|
1909
|
+
|
|
1910
|
+
@property
|
|
1911
|
+
@pulumi.getter
|
|
1912
|
+
def source(self) -> pulumi.Input[str]:
|
|
1913
|
+
"""
|
|
1914
|
+
The source of the asserted value. Possible values `STATUS_CODE`, `JSON_BODY`, `HEADERS`, `TEXT_BODY`, and `RESPONSE_TIME`.
|
|
1915
|
+
"""
|
|
1916
|
+
return pulumi.get(self, "source")
|
|
1917
|
+
|
|
1918
|
+
@source.setter
|
|
1919
|
+
def source(self, value: pulumi.Input[str]):
|
|
1920
|
+
pulumi.set(self, "source", value)
|
|
1921
|
+
|
|
1922
|
+
@property
|
|
1923
|
+
@pulumi.getter
|
|
1924
|
+
def target(self) -> Optional[pulumi.Input[str]]:
|
|
1925
|
+
return pulumi.get(self, "target")
|
|
1926
|
+
|
|
1927
|
+
@target.setter
|
|
1928
|
+
def target(self, value: Optional[pulumi.Input[str]]):
|
|
1929
|
+
pulumi.set(self, "target", value)
|
|
1930
|
+
|
|
1931
|
+
@property
|
|
1932
|
+
@pulumi.getter
|
|
1933
|
+
def property(self) -> Optional[pulumi.Input[str]]:
|
|
1934
|
+
return pulumi.get(self, "property")
|
|
1935
|
+
|
|
1936
|
+
@property.setter
|
|
1937
|
+
def property(self, value: Optional[pulumi.Input[str]]):
|
|
1938
|
+
pulumi.set(self, "property", value)
|
|
1939
|
+
|
|
1940
|
+
|
|
1941
|
+
if not MYPY:
|
|
1942
|
+
class CheckRequestBasicAuthArgsDict(TypedDict):
|
|
1943
|
+
password: pulumi.Input[str]
|
|
1944
|
+
username: pulumi.Input[str]
|
|
1945
|
+
elif False:
|
|
1946
|
+
CheckRequestBasicAuthArgsDict: TypeAlias = Mapping[str, Any]
|
|
1947
|
+
|
|
1948
|
+
@pulumi.input_type
|
|
1949
|
+
class CheckRequestBasicAuthArgs:
|
|
1950
|
+
def __init__(__self__, *,
|
|
1951
|
+
password: pulumi.Input[str],
|
|
1952
|
+
username: pulumi.Input[str]):
|
|
1953
|
+
pulumi.set(__self__, "password", password)
|
|
1954
|
+
pulumi.set(__self__, "username", username)
|
|
1955
|
+
|
|
1956
|
+
@property
|
|
1957
|
+
@pulumi.getter
|
|
1958
|
+
def password(self) -> pulumi.Input[str]:
|
|
1959
|
+
return pulumi.get(self, "password")
|
|
1960
|
+
|
|
1961
|
+
@password.setter
|
|
1962
|
+
def password(self, value: pulumi.Input[str]):
|
|
1963
|
+
pulumi.set(self, "password", value)
|
|
1964
|
+
|
|
1965
|
+
@property
|
|
1966
|
+
@pulumi.getter
|
|
1967
|
+
def username(self) -> pulumi.Input[str]:
|
|
1968
|
+
return pulumi.get(self, "username")
|
|
1969
|
+
|
|
1970
|
+
@username.setter
|
|
1971
|
+
def username(self, value: pulumi.Input[str]):
|
|
1972
|
+
pulumi.set(self, "username", value)
|
|
1973
|
+
|
|
1974
|
+
|
|
1975
|
+
if not MYPY:
|
|
1976
|
+
class CheckRetryStrategyArgsDict(TypedDict):
|
|
1977
|
+
type: pulumi.Input[str]
|
|
1978
|
+
"""
|
|
1979
|
+
Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
|
|
1980
|
+
"""
|
|
1981
|
+
base_backoff_seconds: NotRequired[pulumi.Input[int]]
|
|
1982
|
+
"""
|
|
1983
|
+
The number of seconds to wait before the first retry attempt.
|
|
1984
|
+
"""
|
|
1985
|
+
max_duration_seconds: NotRequired[pulumi.Input[int]]
|
|
1986
|
+
"""
|
|
1987
|
+
The total amount of time to continue retrying the check (maximum 600 seconds).
|
|
1988
|
+
"""
|
|
1989
|
+
max_retries: NotRequired[pulumi.Input[int]]
|
|
1990
|
+
"""
|
|
1991
|
+
The maximum number of times to retry the check. Value must be between 1 and 10.
|
|
1992
|
+
"""
|
|
1993
|
+
same_region: NotRequired[pulumi.Input[bool]]
|
|
1994
|
+
"""
|
|
1995
|
+
Whether retries should be run in the same region as the initial check run.
|
|
1996
|
+
"""
|
|
1997
|
+
elif False:
|
|
1998
|
+
CheckRetryStrategyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1999
|
+
|
|
2000
|
+
@pulumi.input_type
|
|
2001
|
+
class CheckRetryStrategyArgs:
|
|
2002
|
+
def __init__(__self__, *,
|
|
2003
|
+
type: pulumi.Input[str],
|
|
2004
|
+
base_backoff_seconds: Optional[pulumi.Input[int]] = None,
|
|
2005
|
+
max_duration_seconds: Optional[pulumi.Input[int]] = None,
|
|
2006
|
+
max_retries: Optional[pulumi.Input[int]] = None,
|
|
2007
|
+
same_region: Optional[pulumi.Input[bool]] = None):
|
|
2008
|
+
"""
|
|
2009
|
+
:param pulumi.Input[str] type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
|
|
2010
|
+
:param pulumi.Input[int] base_backoff_seconds: The number of seconds to wait before the first retry attempt.
|
|
2011
|
+
:param pulumi.Input[int] max_duration_seconds: The total amount of time to continue retrying the check (maximum 600 seconds).
|
|
2012
|
+
:param pulumi.Input[int] max_retries: The maximum number of times to retry the check. Value must be between 1 and 10.
|
|
2013
|
+
:param pulumi.Input[bool] same_region: Whether retries should be run in the same region as the initial check run.
|
|
2014
|
+
"""
|
|
2015
|
+
pulumi.set(__self__, "type", type)
|
|
2016
|
+
if base_backoff_seconds is not None:
|
|
2017
|
+
pulumi.set(__self__, "base_backoff_seconds", base_backoff_seconds)
|
|
2018
|
+
if max_duration_seconds is not None:
|
|
2019
|
+
pulumi.set(__self__, "max_duration_seconds", max_duration_seconds)
|
|
2020
|
+
if max_retries is not None:
|
|
2021
|
+
pulumi.set(__self__, "max_retries", max_retries)
|
|
2022
|
+
if same_region is not None:
|
|
2023
|
+
pulumi.set(__self__, "same_region", same_region)
|
|
2024
|
+
|
|
2025
|
+
@property
|
|
2026
|
+
@pulumi.getter
|
|
2027
|
+
def type(self) -> pulumi.Input[str]:
|
|
2028
|
+
"""
|
|
2029
|
+
Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
|
|
2030
|
+
"""
|
|
2031
|
+
return pulumi.get(self, "type")
|
|
2032
|
+
|
|
2033
|
+
@type.setter
|
|
2034
|
+
def type(self, value: pulumi.Input[str]):
|
|
2035
|
+
pulumi.set(self, "type", value)
|
|
2036
|
+
|
|
2037
|
+
@property
|
|
2038
|
+
@pulumi.getter(name="baseBackoffSeconds")
|
|
2039
|
+
def base_backoff_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
2040
|
+
"""
|
|
2041
|
+
The number of seconds to wait before the first retry attempt.
|
|
2042
|
+
"""
|
|
2043
|
+
return pulumi.get(self, "base_backoff_seconds")
|
|
2044
|
+
|
|
2045
|
+
@base_backoff_seconds.setter
|
|
2046
|
+
def base_backoff_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
2047
|
+
pulumi.set(self, "base_backoff_seconds", value)
|
|
2048
|
+
|
|
2049
|
+
@property
|
|
2050
|
+
@pulumi.getter(name="maxDurationSeconds")
|
|
2051
|
+
def max_duration_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
2052
|
+
"""
|
|
2053
|
+
The total amount of time to continue retrying the check (maximum 600 seconds).
|
|
2054
|
+
"""
|
|
2055
|
+
return pulumi.get(self, "max_duration_seconds")
|
|
2056
|
+
|
|
2057
|
+
@max_duration_seconds.setter
|
|
2058
|
+
def max_duration_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
2059
|
+
pulumi.set(self, "max_duration_seconds", value)
|
|
2060
|
+
|
|
2061
|
+
@property
|
|
2062
|
+
@pulumi.getter(name="maxRetries")
|
|
2063
|
+
def max_retries(self) -> Optional[pulumi.Input[int]]:
|
|
2064
|
+
"""
|
|
2065
|
+
The maximum number of times to retry the check. Value must be between 1 and 10.
|
|
2066
|
+
"""
|
|
2067
|
+
return pulumi.get(self, "max_retries")
|
|
2068
|
+
|
|
2069
|
+
@max_retries.setter
|
|
2070
|
+
def max_retries(self, value: Optional[pulumi.Input[int]]):
|
|
2071
|
+
pulumi.set(self, "max_retries", value)
|
|
2072
|
+
|
|
2073
|
+
@property
|
|
2074
|
+
@pulumi.getter(name="sameRegion")
|
|
2075
|
+
def same_region(self) -> Optional[pulumi.Input[bool]]:
|
|
2076
|
+
"""
|
|
2077
|
+
Whether retries should be run in the same region as the initial check run.
|
|
2078
|
+
"""
|
|
2079
|
+
return pulumi.get(self, "same_region")
|
|
2080
|
+
|
|
2081
|
+
@same_region.setter
|
|
2082
|
+
def same_region(self, value: Optional[pulumi.Input[bool]]):
|
|
2083
|
+
pulumi.set(self, "same_region", value)
|
|
2084
|
+
|
|
2085
|
+
|
|
2086
|
+
if not MYPY:
|
|
2087
|
+
class HeartbeatCheckAlertChannelSubscriptionArgsDict(TypedDict):
|
|
2088
|
+
activated: pulumi.Input[bool]
|
|
2089
|
+
channel_id: pulumi.Input[int]
|
|
2090
|
+
elif False:
|
|
2091
|
+
HeartbeatCheckAlertChannelSubscriptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
2092
|
+
|
|
2093
|
+
@pulumi.input_type
|
|
2094
|
+
class HeartbeatCheckAlertChannelSubscriptionArgs:
|
|
2095
|
+
def __init__(__self__, *,
|
|
2096
|
+
activated: pulumi.Input[bool],
|
|
2097
|
+
channel_id: pulumi.Input[int]):
|
|
2098
|
+
pulumi.set(__self__, "activated", activated)
|
|
2099
|
+
pulumi.set(__self__, "channel_id", channel_id)
|
|
2100
|
+
|
|
2101
|
+
@property
|
|
2102
|
+
@pulumi.getter
|
|
2103
|
+
def activated(self) -> pulumi.Input[bool]:
|
|
2104
|
+
return pulumi.get(self, "activated")
|
|
2105
|
+
|
|
2106
|
+
@activated.setter
|
|
2107
|
+
def activated(self, value: pulumi.Input[bool]):
|
|
2108
|
+
pulumi.set(self, "activated", value)
|
|
2109
|
+
|
|
2110
|
+
@property
|
|
2111
|
+
@pulumi.getter(name="channelId")
|
|
2112
|
+
def channel_id(self) -> pulumi.Input[int]:
|
|
2113
|
+
return pulumi.get(self, "channel_id")
|
|
2114
|
+
|
|
2115
|
+
@channel_id.setter
|
|
2116
|
+
def channel_id(self, value: pulumi.Input[int]):
|
|
2117
|
+
pulumi.set(self, "channel_id", value)
|
|
2118
|
+
|
|
2119
|
+
|
|
2120
|
+
if not MYPY:
|
|
2121
|
+
class HeartbeatCheckAlertSettingsArgsDict(TypedDict):
|
|
2122
|
+
escalation_type: NotRequired[pulumi.Input[str]]
|
|
2123
|
+
"""
|
|
2124
|
+
Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
2125
|
+
"""
|
|
2126
|
+
parallel_run_failure_thresholds: NotRequired[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsParallelRunFailureThresholdArgsDict']]]]
|
|
2127
|
+
reminders: NotRequired[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsReminderArgsDict']]]]
|
|
2128
|
+
run_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsRunBasedEscalationArgsDict']]]]
|
|
2129
|
+
ssl_certificates: NotRequired[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsSslCertificateArgsDict']]]]
|
|
2130
|
+
time_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsTimeBasedEscalationArgsDict']]]]
|
|
2131
|
+
elif False:
|
|
2132
|
+
HeartbeatCheckAlertSettingsArgsDict: TypeAlias = Mapping[str, Any]
|
|
2133
|
+
|
|
2134
|
+
@pulumi.input_type
|
|
2135
|
+
class HeartbeatCheckAlertSettingsArgs:
|
|
2136
|
+
def __init__(__self__, *,
|
|
2137
|
+
escalation_type: Optional[pulumi.Input[str]] = None,
|
|
2138
|
+
parallel_run_failure_thresholds: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsParallelRunFailureThresholdArgs']]]] = None,
|
|
2139
|
+
reminders: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsReminderArgs']]]] = None,
|
|
2140
|
+
run_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsRunBasedEscalationArgs']]]] = None,
|
|
2141
|
+
ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsSslCertificateArgs']]]] = None,
|
|
2142
|
+
time_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsTimeBasedEscalationArgs']]]] = None):
|
|
2143
|
+
"""
|
|
2144
|
+
:param pulumi.Input[str] escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
2145
|
+
"""
|
|
2146
|
+
if escalation_type is not None:
|
|
2147
|
+
pulumi.set(__self__, "escalation_type", escalation_type)
|
|
2148
|
+
if parallel_run_failure_thresholds is not None:
|
|
2149
|
+
pulumi.set(__self__, "parallel_run_failure_thresholds", parallel_run_failure_thresholds)
|
|
2150
|
+
if reminders is not None:
|
|
2151
|
+
pulumi.set(__self__, "reminders", reminders)
|
|
2152
|
+
if run_based_escalations is not None:
|
|
2153
|
+
pulumi.set(__self__, "run_based_escalations", run_based_escalations)
|
|
2154
|
+
if ssl_certificates is not None:
|
|
2155
|
+
warnings.warn("""This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""", DeprecationWarning)
|
|
2156
|
+
pulumi.log.warn("""ssl_certificates is deprecated: This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""")
|
|
2157
|
+
if ssl_certificates is not None:
|
|
2158
|
+
pulumi.set(__self__, "ssl_certificates", ssl_certificates)
|
|
2159
|
+
if time_based_escalations is not None:
|
|
2160
|
+
pulumi.set(__self__, "time_based_escalations", time_based_escalations)
|
|
2161
|
+
|
|
2162
|
+
@property
|
|
2163
|
+
@pulumi.getter(name="escalationType")
|
|
2164
|
+
def escalation_type(self) -> Optional[pulumi.Input[str]]:
|
|
2165
|
+
"""
|
|
2166
|
+
Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
2167
|
+
"""
|
|
2168
|
+
return pulumi.get(self, "escalation_type")
|
|
2169
|
+
|
|
2170
|
+
@escalation_type.setter
|
|
2171
|
+
def escalation_type(self, value: Optional[pulumi.Input[str]]):
|
|
2172
|
+
pulumi.set(self, "escalation_type", value)
|
|
2173
|
+
|
|
2174
|
+
@property
|
|
2175
|
+
@pulumi.getter(name="parallelRunFailureThresholds")
|
|
2176
|
+
def parallel_run_failure_thresholds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsParallelRunFailureThresholdArgs']]]]:
|
|
2177
|
+
return pulumi.get(self, "parallel_run_failure_thresholds")
|
|
2178
|
+
|
|
2179
|
+
@parallel_run_failure_thresholds.setter
|
|
2180
|
+
def parallel_run_failure_thresholds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsParallelRunFailureThresholdArgs']]]]):
|
|
2181
|
+
pulumi.set(self, "parallel_run_failure_thresholds", value)
|
|
2182
|
+
|
|
2183
|
+
@property
|
|
2184
|
+
@pulumi.getter
|
|
2185
|
+
def reminders(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsReminderArgs']]]]:
|
|
2186
|
+
return pulumi.get(self, "reminders")
|
|
2187
|
+
|
|
2188
|
+
@reminders.setter
|
|
2189
|
+
def reminders(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsReminderArgs']]]]):
|
|
2190
|
+
pulumi.set(self, "reminders", value)
|
|
2191
|
+
|
|
2192
|
+
@property
|
|
2193
|
+
@pulumi.getter(name="runBasedEscalations")
|
|
2194
|
+
def run_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsRunBasedEscalationArgs']]]]:
|
|
2195
|
+
return pulumi.get(self, "run_based_escalations")
|
|
2196
|
+
|
|
2197
|
+
@run_based_escalations.setter
|
|
2198
|
+
def run_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsRunBasedEscalationArgs']]]]):
|
|
2199
|
+
pulumi.set(self, "run_based_escalations", value)
|
|
2200
|
+
|
|
2201
|
+
@property
|
|
2202
|
+
@pulumi.getter(name="sslCertificates")
|
|
2203
|
+
@_utilities.deprecated("""This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""")
|
|
2204
|
+
def ssl_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsSslCertificateArgs']]]]:
|
|
2205
|
+
return pulumi.get(self, "ssl_certificates")
|
|
2206
|
+
|
|
2207
|
+
@ssl_certificates.setter
|
|
2208
|
+
def ssl_certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsSslCertificateArgs']]]]):
|
|
2209
|
+
pulumi.set(self, "ssl_certificates", value)
|
|
2210
|
+
|
|
2211
|
+
@property
|
|
2212
|
+
@pulumi.getter(name="timeBasedEscalations")
|
|
2213
|
+
def time_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsTimeBasedEscalationArgs']]]]:
|
|
2214
|
+
return pulumi.get(self, "time_based_escalations")
|
|
2215
|
+
|
|
2216
|
+
@time_based_escalations.setter
|
|
2217
|
+
def time_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HeartbeatCheckAlertSettingsTimeBasedEscalationArgs']]]]):
|
|
2218
|
+
pulumi.set(self, "time_based_escalations", value)
|
|
2219
|
+
|
|
2220
|
+
|
|
2221
|
+
if not MYPY:
|
|
2222
|
+
class HeartbeatCheckAlertSettingsParallelRunFailureThresholdArgsDict(TypedDict):
|
|
2223
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
2224
|
+
"""
|
|
2225
|
+
Applicable only for checks scheduled in parallel in multiple locations.
|
|
2226
|
+
"""
|
|
2227
|
+
percentage: NotRequired[pulumi.Input[int]]
|
|
2228
|
+
"""
|
|
2229
|
+
Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
2230
|
+
"""
|
|
2231
|
+
elif False:
|
|
2232
|
+
HeartbeatCheckAlertSettingsParallelRunFailureThresholdArgsDict: TypeAlias = Mapping[str, Any]
|
|
2233
|
+
|
|
2234
|
+
@pulumi.input_type
|
|
2235
|
+
class HeartbeatCheckAlertSettingsParallelRunFailureThresholdArgs:
|
|
2236
|
+
def __init__(__self__, *,
|
|
2237
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
2238
|
+
percentage: Optional[pulumi.Input[int]] = None):
|
|
2239
|
+
"""
|
|
2240
|
+
:param pulumi.Input[bool] enabled: Applicable only for checks scheduled in parallel in multiple locations.
|
|
2241
|
+
:param pulumi.Input[int] percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
2242
|
+
"""
|
|
2243
|
+
if enabled is not None:
|
|
2244
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
2245
|
+
if percentage is not None:
|
|
2246
|
+
pulumi.set(__self__, "percentage", percentage)
|
|
2247
|
+
|
|
2248
|
+
@property
|
|
2249
|
+
@pulumi.getter
|
|
2250
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
2251
|
+
"""
|
|
2252
|
+
Applicable only for checks scheduled in parallel in multiple locations.
|
|
2253
|
+
"""
|
|
2254
|
+
return pulumi.get(self, "enabled")
|
|
2255
|
+
|
|
2256
|
+
@enabled.setter
|
|
2257
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
2258
|
+
pulumi.set(self, "enabled", value)
|
|
2259
|
+
|
|
2260
|
+
@property
|
|
2261
|
+
@pulumi.getter
|
|
2262
|
+
def percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2263
|
+
"""
|
|
2264
|
+
Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
2265
|
+
"""
|
|
2266
|
+
return pulumi.get(self, "percentage")
|
|
2267
|
+
|
|
2268
|
+
@percentage.setter
|
|
2269
|
+
def percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2270
|
+
pulumi.set(self, "percentage", value)
|
|
2271
|
+
|
|
2272
|
+
|
|
2273
|
+
if not MYPY:
|
|
2274
|
+
class HeartbeatCheckAlertSettingsReminderArgsDict(TypedDict):
|
|
2275
|
+
amount: NotRequired[pulumi.Input[int]]
|
|
2276
|
+
"""
|
|
2277
|
+
How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
2278
|
+
"""
|
|
2279
|
+
interval: NotRequired[pulumi.Input[int]]
|
|
2280
|
+
"""
|
|
2281
|
+
Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
2282
|
+
"""
|
|
2283
|
+
elif False:
|
|
2284
|
+
HeartbeatCheckAlertSettingsReminderArgsDict: TypeAlias = Mapping[str, Any]
|
|
2285
|
+
|
|
2286
|
+
@pulumi.input_type
|
|
2287
|
+
class HeartbeatCheckAlertSettingsReminderArgs:
|
|
2288
|
+
def __init__(__self__, *,
|
|
2289
|
+
amount: Optional[pulumi.Input[int]] = None,
|
|
2290
|
+
interval: Optional[pulumi.Input[int]] = None):
|
|
2291
|
+
"""
|
|
2292
|
+
:param pulumi.Input[int] amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
2293
|
+
:param pulumi.Input[int] interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
2294
|
+
"""
|
|
2295
|
+
if amount is not None:
|
|
2296
|
+
pulumi.set(__self__, "amount", amount)
|
|
2297
|
+
if interval is not None:
|
|
2298
|
+
pulumi.set(__self__, "interval", interval)
|
|
2299
|
+
|
|
2300
|
+
@property
|
|
2301
|
+
@pulumi.getter
|
|
2302
|
+
def amount(self) -> Optional[pulumi.Input[int]]:
|
|
2303
|
+
"""
|
|
2304
|
+
How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
2305
|
+
"""
|
|
2306
|
+
return pulumi.get(self, "amount")
|
|
2307
|
+
|
|
2308
|
+
@amount.setter
|
|
2309
|
+
def amount(self, value: Optional[pulumi.Input[int]]):
|
|
2310
|
+
pulumi.set(self, "amount", value)
|
|
2311
|
+
|
|
2312
|
+
@property
|
|
2313
|
+
@pulumi.getter
|
|
2314
|
+
def interval(self) -> Optional[pulumi.Input[int]]:
|
|
2315
|
+
"""
|
|
2316
|
+
Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
2317
|
+
"""
|
|
2318
|
+
return pulumi.get(self, "interval")
|
|
2319
|
+
|
|
2320
|
+
@interval.setter
|
|
2321
|
+
def interval(self, value: Optional[pulumi.Input[int]]):
|
|
2322
|
+
pulumi.set(self, "interval", value)
|
|
2323
|
+
|
|
2324
|
+
|
|
2325
|
+
if not MYPY:
|
|
2326
|
+
class HeartbeatCheckAlertSettingsRunBasedEscalationArgsDict(TypedDict):
|
|
2327
|
+
failed_run_threshold: NotRequired[pulumi.Input[int]]
|
|
2328
|
+
"""
|
|
2329
|
+
After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
2330
|
+
"""
|
|
2331
|
+
elif False:
|
|
2332
|
+
HeartbeatCheckAlertSettingsRunBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
2333
|
+
|
|
2334
|
+
@pulumi.input_type
|
|
2335
|
+
class HeartbeatCheckAlertSettingsRunBasedEscalationArgs:
|
|
2336
|
+
def __init__(__self__, *,
|
|
2337
|
+
failed_run_threshold: Optional[pulumi.Input[int]] = None):
|
|
2338
|
+
"""
|
|
2339
|
+
:param pulumi.Input[int] failed_run_threshold: After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
2340
|
+
"""
|
|
2341
|
+
if failed_run_threshold is not None:
|
|
2342
|
+
pulumi.set(__self__, "failed_run_threshold", failed_run_threshold)
|
|
2343
|
+
|
|
2344
|
+
@property
|
|
2345
|
+
@pulumi.getter(name="failedRunThreshold")
|
|
2346
|
+
def failed_run_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
2347
|
+
"""
|
|
2348
|
+
After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
2349
|
+
"""
|
|
2350
|
+
return pulumi.get(self, "failed_run_threshold")
|
|
2351
|
+
|
|
2352
|
+
@failed_run_threshold.setter
|
|
2353
|
+
def failed_run_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
2354
|
+
pulumi.set(self, "failed_run_threshold", value)
|
|
2355
|
+
|
|
2356
|
+
|
|
2357
|
+
if not MYPY:
|
|
2358
|
+
class HeartbeatCheckAlertSettingsSslCertificateArgsDict(TypedDict):
|
|
2359
|
+
alert_threshold: NotRequired[pulumi.Input[int]]
|
|
2360
|
+
"""
|
|
2361
|
+
How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
|
|
2362
|
+
"""
|
|
2363
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
2364
|
+
"""
|
|
2365
|
+
Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
|
|
2366
|
+
"""
|
|
2367
|
+
elif False:
|
|
2368
|
+
HeartbeatCheckAlertSettingsSslCertificateArgsDict: TypeAlias = Mapping[str, Any]
|
|
2369
|
+
|
|
2370
|
+
@pulumi.input_type
|
|
2371
|
+
class HeartbeatCheckAlertSettingsSslCertificateArgs:
|
|
2372
|
+
def __init__(__self__, *,
|
|
2373
|
+
alert_threshold: Optional[pulumi.Input[int]] = None,
|
|
2374
|
+
enabled: Optional[pulumi.Input[bool]] = None):
|
|
2375
|
+
"""
|
|
2376
|
+
:param pulumi.Input[int] alert_threshold: How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
|
|
2377
|
+
:param pulumi.Input[bool] enabled: Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
|
|
2378
|
+
"""
|
|
2379
|
+
if alert_threshold is not None:
|
|
2380
|
+
pulumi.set(__self__, "alert_threshold", alert_threshold)
|
|
2381
|
+
if enabled is not None:
|
|
2382
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
2383
|
+
|
|
2384
|
+
@property
|
|
2385
|
+
@pulumi.getter(name="alertThreshold")
|
|
2386
|
+
def alert_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
2387
|
+
"""
|
|
2388
|
+
How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
|
|
2389
|
+
"""
|
|
2390
|
+
return pulumi.get(self, "alert_threshold")
|
|
2391
|
+
|
|
2392
|
+
@alert_threshold.setter
|
|
2393
|
+
def alert_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
2394
|
+
pulumi.set(self, "alert_threshold", value)
|
|
2395
|
+
|
|
2396
|
+
@property
|
|
2397
|
+
@pulumi.getter
|
|
2398
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
2399
|
+
"""
|
|
2400
|
+
Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
|
|
2401
|
+
"""
|
|
2402
|
+
return pulumi.get(self, "enabled")
|
|
2403
|
+
|
|
2404
|
+
@enabled.setter
|
|
2405
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
2406
|
+
pulumi.set(self, "enabled", value)
|
|
2407
|
+
|
|
2408
|
+
|
|
2409
|
+
if not MYPY:
|
|
2410
|
+
class HeartbeatCheckAlertSettingsTimeBasedEscalationArgsDict(TypedDict):
|
|
2411
|
+
minutes_failing_threshold: NotRequired[pulumi.Input[int]]
|
|
2412
|
+
"""
|
|
2413
|
+
After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
2414
|
+
"""
|
|
2415
|
+
elif False:
|
|
2416
|
+
HeartbeatCheckAlertSettingsTimeBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
2417
|
+
|
|
2418
|
+
@pulumi.input_type
|
|
2419
|
+
class HeartbeatCheckAlertSettingsTimeBasedEscalationArgs:
|
|
2420
|
+
def __init__(__self__, *,
|
|
2421
|
+
minutes_failing_threshold: Optional[pulumi.Input[int]] = None):
|
|
2422
|
+
"""
|
|
2423
|
+
:param pulumi.Input[int] minutes_failing_threshold: After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
2424
|
+
"""
|
|
2425
|
+
if minutes_failing_threshold is not None:
|
|
2426
|
+
pulumi.set(__self__, "minutes_failing_threshold", minutes_failing_threshold)
|
|
2427
|
+
|
|
2428
|
+
@property
|
|
2429
|
+
@pulumi.getter(name="minutesFailingThreshold")
|
|
2430
|
+
def minutes_failing_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
2431
|
+
"""
|
|
2432
|
+
After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
2433
|
+
"""
|
|
2434
|
+
return pulumi.get(self, "minutes_failing_threshold")
|
|
2435
|
+
|
|
2436
|
+
@minutes_failing_threshold.setter
|
|
2437
|
+
def minutes_failing_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
2438
|
+
pulumi.set(self, "minutes_failing_threshold", value)
|
|
2439
|
+
|
|
2440
|
+
|
|
2441
|
+
if not MYPY:
|
|
2442
|
+
class HeartbeatCheckHeartbeatArgsDict(TypedDict):
|
|
2443
|
+
grace: pulumi.Input[int]
|
|
2444
|
+
"""
|
|
2445
|
+
How long Checkly should wait before triggering any alerts when a ping does not arrive within the set period.
|
|
2446
|
+
"""
|
|
2447
|
+
grace_unit: pulumi.Input[str]
|
|
2448
|
+
"""
|
|
2449
|
+
Possible values `seconds`, `minutes`, `hours` and `days`.
|
|
2450
|
+
"""
|
|
2451
|
+
period: pulumi.Input[int]
|
|
2452
|
+
"""
|
|
2453
|
+
How often you expect a ping to the ping URL.
|
|
2454
|
+
"""
|
|
2455
|
+
period_unit: pulumi.Input[str]
|
|
2456
|
+
"""
|
|
2457
|
+
Possible values `seconds`, `minutes`, `hours` and `days`.
|
|
2458
|
+
"""
|
|
2459
|
+
ping_token: NotRequired[pulumi.Input[str]]
|
|
2460
|
+
"""
|
|
2461
|
+
Custom token to generate your ping URL. Checkly will expect a ping to `https://ping.checklyhq.com/[PING_TOKEN]`.
|
|
2462
|
+
"""
|
|
2463
|
+
elif False:
|
|
2464
|
+
HeartbeatCheckHeartbeatArgsDict: TypeAlias = Mapping[str, Any]
|
|
2465
|
+
|
|
2466
|
+
@pulumi.input_type
|
|
2467
|
+
class HeartbeatCheckHeartbeatArgs:
|
|
2468
|
+
def __init__(__self__, *,
|
|
2469
|
+
grace: pulumi.Input[int],
|
|
2470
|
+
grace_unit: pulumi.Input[str],
|
|
2471
|
+
period: pulumi.Input[int],
|
|
2472
|
+
period_unit: pulumi.Input[str],
|
|
2473
|
+
ping_token: Optional[pulumi.Input[str]] = None):
|
|
2474
|
+
"""
|
|
2475
|
+
:param pulumi.Input[int] grace: How long Checkly should wait before triggering any alerts when a ping does not arrive within the set period.
|
|
2476
|
+
:param pulumi.Input[str] grace_unit: Possible values `seconds`, `minutes`, `hours` and `days`.
|
|
2477
|
+
:param pulumi.Input[int] period: How often you expect a ping to the ping URL.
|
|
2478
|
+
:param pulumi.Input[str] period_unit: Possible values `seconds`, `minutes`, `hours` and `days`.
|
|
2479
|
+
:param pulumi.Input[str] ping_token: Custom token to generate your ping URL. Checkly will expect a ping to `https://ping.checklyhq.com/[PING_TOKEN]`.
|
|
2480
|
+
"""
|
|
2481
|
+
pulumi.set(__self__, "grace", grace)
|
|
2482
|
+
pulumi.set(__self__, "grace_unit", grace_unit)
|
|
2483
|
+
pulumi.set(__self__, "period", period)
|
|
2484
|
+
pulumi.set(__self__, "period_unit", period_unit)
|
|
2485
|
+
if ping_token is not None:
|
|
2486
|
+
pulumi.set(__self__, "ping_token", ping_token)
|
|
2487
|
+
|
|
2488
|
+
@property
|
|
2489
|
+
@pulumi.getter
|
|
2490
|
+
def grace(self) -> pulumi.Input[int]:
|
|
2491
|
+
"""
|
|
2492
|
+
How long Checkly should wait before triggering any alerts when a ping does not arrive within the set period.
|
|
2493
|
+
"""
|
|
2494
|
+
return pulumi.get(self, "grace")
|
|
2495
|
+
|
|
2496
|
+
@grace.setter
|
|
2497
|
+
def grace(self, value: pulumi.Input[int]):
|
|
2498
|
+
pulumi.set(self, "grace", value)
|
|
2499
|
+
|
|
2500
|
+
@property
|
|
2501
|
+
@pulumi.getter(name="graceUnit")
|
|
2502
|
+
def grace_unit(self) -> pulumi.Input[str]:
|
|
2503
|
+
"""
|
|
2504
|
+
Possible values `seconds`, `minutes`, `hours` and `days`.
|
|
2505
|
+
"""
|
|
2506
|
+
return pulumi.get(self, "grace_unit")
|
|
2507
|
+
|
|
2508
|
+
@grace_unit.setter
|
|
2509
|
+
def grace_unit(self, value: pulumi.Input[str]):
|
|
2510
|
+
pulumi.set(self, "grace_unit", value)
|
|
2511
|
+
|
|
2512
|
+
@property
|
|
2513
|
+
@pulumi.getter
|
|
2514
|
+
def period(self) -> pulumi.Input[int]:
|
|
2515
|
+
"""
|
|
2516
|
+
How often you expect a ping to the ping URL.
|
|
2517
|
+
"""
|
|
2518
|
+
return pulumi.get(self, "period")
|
|
2519
|
+
|
|
2520
|
+
@period.setter
|
|
2521
|
+
def period(self, value: pulumi.Input[int]):
|
|
2522
|
+
pulumi.set(self, "period", value)
|
|
2523
|
+
|
|
2524
|
+
@property
|
|
2525
|
+
@pulumi.getter(name="periodUnit")
|
|
2526
|
+
def period_unit(self) -> pulumi.Input[str]:
|
|
2527
|
+
"""
|
|
2528
|
+
Possible values `seconds`, `minutes`, `hours` and `days`.
|
|
2529
|
+
"""
|
|
2530
|
+
return pulumi.get(self, "period_unit")
|
|
2531
|
+
|
|
2532
|
+
@period_unit.setter
|
|
2533
|
+
def period_unit(self, value: pulumi.Input[str]):
|
|
2534
|
+
pulumi.set(self, "period_unit", value)
|
|
2535
|
+
|
|
2536
|
+
@property
|
|
2537
|
+
@pulumi.getter(name="pingToken")
|
|
2538
|
+
def ping_token(self) -> Optional[pulumi.Input[str]]:
|
|
2539
|
+
"""
|
|
2540
|
+
Custom token to generate your ping URL. Checkly will expect a ping to `https://ping.checklyhq.com/[PING_TOKEN]`.
|
|
2541
|
+
"""
|
|
2542
|
+
return pulumi.get(self, "ping_token")
|
|
2543
|
+
|
|
2544
|
+
@ping_token.setter
|
|
2545
|
+
def ping_token(self, value: Optional[pulumi.Input[str]]):
|
|
2546
|
+
pulumi.set(self, "ping_token", value)
|
|
2547
|
+
|
|
2548
|
+
|
|
2549
|
+
if not MYPY:
|
|
2550
|
+
class TcpCheckAlertChannelSubscriptionArgsDict(TypedDict):
|
|
2551
|
+
activated: pulumi.Input[bool]
|
|
2552
|
+
channel_id: pulumi.Input[int]
|
|
2553
|
+
elif False:
|
|
2554
|
+
TcpCheckAlertChannelSubscriptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
2555
|
+
|
|
2556
|
+
@pulumi.input_type
|
|
2557
|
+
class TcpCheckAlertChannelSubscriptionArgs:
|
|
2558
|
+
def __init__(__self__, *,
|
|
2559
|
+
activated: pulumi.Input[bool],
|
|
2560
|
+
channel_id: pulumi.Input[int]):
|
|
2561
|
+
pulumi.set(__self__, "activated", activated)
|
|
2562
|
+
pulumi.set(__self__, "channel_id", channel_id)
|
|
2563
|
+
|
|
2564
|
+
@property
|
|
2565
|
+
@pulumi.getter
|
|
2566
|
+
def activated(self) -> pulumi.Input[bool]:
|
|
2567
|
+
return pulumi.get(self, "activated")
|
|
2568
|
+
|
|
2569
|
+
@activated.setter
|
|
2570
|
+
def activated(self, value: pulumi.Input[bool]):
|
|
2571
|
+
pulumi.set(self, "activated", value)
|
|
2572
|
+
|
|
2573
|
+
@property
|
|
2574
|
+
@pulumi.getter(name="channelId")
|
|
2575
|
+
def channel_id(self) -> pulumi.Input[int]:
|
|
2576
|
+
return pulumi.get(self, "channel_id")
|
|
2577
|
+
|
|
2578
|
+
@channel_id.setter
|
|
2579
|
+
def channel_id(self, value: pulumi.Input[int]):
|
|
2580
|
+
pulumi.set(self, "channel_id", value)
|
|
2581
|
+
|
|
2582
|
+
|
|
2583
|
+
if not MYPY:
|
|
2584
|
+
class TcpCheckAlertSettingsArgsDict(TypedDict):
|
|
2585
|
+
escalation_type: NotRequired[pulumi.Input[str]]
|
|
2586
|
+
"""
|
|
2587
|
+
Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
2588
|
+
"""
|
|
2589
|
+
parallel_run_failure_thresholds: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsParallelRunFailureThresholdArgsDict']]]]
|
|
2590
|
+
reminders: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsReminderArgsDict']]]]
|
|
2591
|
+
run_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsRunBasedEscalationArgsDict']]]]
|
|
2592
|
+
time_based_escalations: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsTimeBasedEscalationArgsDict']]]]
|
|
2593
|
+
elif False:
|
|
2594
|
+
TcpCheckAlertSettingsArgsDict: TypeAlias = Mapping[str, Any]
|
|
2595
|
+
|
|
2596
|
+
@pulumi.input_type
|
|
2597
|
+
class TcpCheckAlertSettingsArgs:
|
|
2598
|
+
def __init__(__self__, *,
|
|
2599
|
+
escalation_type: Optional[pulumi.Input[str]] = None,
|
|
2600
|
+
parallel_run_failure_thresholds: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsParallelRunFailureThresholdArgs']]]] = None,
|
|
2601
|
+
reminders: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsReminderArgs']]]] = None,
|
|
2602
|
+
run_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsRunBasedEscalationArgs']]]] = None,
|
|
2603
|
+
time_based_escalations: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsTimeBasedEscalationArgs']]]] = None):
|
|
2604
|
+
"""
|
|
2605
|
+
:param pulumi.Input[str] escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
2606
|
+
"""
|
|
2607
|
+
if escalation_type is not None:
|
|
2608
|
+
pulumi.set(__self__, "escalation_type", escalation_type)
|
|
2609
|
+
if parallel_run_failure_thresholds is not None:
|
|
2610
|
+
pulumi.set(__self__, "parallel_run_failure_thresholds", parallel_run_failure_thresholds)
|
|
2611
|
+
if reminders is not None:
|
|
2612
|
+
pulumi.set(__self__, "reminders", reminders)
|
|
2613
|
+
if run_based_escalations is not None:
|
|
2614
|
+
pulumi.set(__self__, "run_based_escalations", run_based_escalations)
|
|
2615
|
+
if time_based_escalations is not None:
|
|
2616
|
+
pulumi.set(__self__, "time_based_escalations", time_based_escalations)
|
|
2617
|
+
|
|
2618
|
+
@property
|
|
2619
|
+
@pulumi.getter(name="escalationType")
|
|
2620
|
+
def escalation_type(self) -> Optional[pulumi.Input[str]]:
|
|
2621
|
+
"""
|
|
2622
|
+
Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
|
|
2623
|
+
"""
|
|
2624
|
+
return pulumi.get(self, "escalation_type")
|
|
2625
|
+
|
|
2626
|
+
@escalation_type.setter
|
|
2627
|
+
def escalation_type(self, value: Optional[pulumi.Input[str]]):
|
|
2628
|
+
pulumi.set(self, "escalation_type", value)
|
|
2629
|
+
|
|
2630
|
+
@property
|
|
2631
|
+
@pulumi.getter(name="parallelRunFailureThresholds")
|
|
2632
|
+
def parallel_run_failure_thresholds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsParallelRunFailureThresholdArgs']]]]:
|
|
2633
|
+
return pulumi.get(self, "parallel_run_failure_thresholds")
|
|
2634
|
+
|
|
2635
|
+
@parallel_run_failure_thresholds.setter
|
|
2636
|
+
def parallel_run_failure_thresholds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsParallelRunFailureThresholdArgs']]]]):
|
|
2637
|
+
pulumi.set(self, "parallel_run_failure_thresholds", value)
|
|
2638
|
+
|
|
2639
|
+
@property
|
|
2640
|
+
@pulumi.getter
|
|
2641
|
+
def reminders(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsReminderArgs']]]]:
|
|
2642
|
+
return pulumi.get(self, "reminders")
|
|
2643
|
+
|
|
2644
|
+
@reminders.setter
|
|
2645
|
+
def reminders(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsReminderArgs']]]]):
|
|
2646
|
+
pulumi.set(self, "reminders", value)
|
|
2647
|
+
|
|
2648
|
+
@property
|
|
2649
|
+
@pulumi.getter(name="runBasedEscalations")
|
|
2650
|
+
def run_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsRunBasedEscalationArgs']]]]:
|
|
2651
|
+
return pulumi.get(self, "run_based_escalations")
|
|
2652
|
+
|
|
2653
|
+
@run_based_escalations.setter
|
|
2654
|
+
def run_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsRunBasedEscalationArgs']]]]):
|
|
2655
|
+
pulumi.set(self, "run_based_escalations", value)
|
|
2656
|
+
|
|
2657
|
+
@property
|
|
2658
|
+
@pulumi.getter(name="timeBasedEscalations")
|
|
2659
|
+
def time_based_escalations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsTimeBasedEscalationArgs']]]]:
|
|
2660
|
+
return pulumi.get(self, "time_based_escalations")
|
|
2661
|
+
|
|
2662
|
+
@time_based_escalations.setter
|
|
2663
|
+
def time_based_escalations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckAlertSettingsTimeBasedEscalationArgs']]]]):
|
|
2664
|
+
pulumi.set(self, "time_based_escalations", value)
|
|
2665
|
+
|
|
2666
|
+
|
|
2667
|
+
if not MYPY:
|
|
2668
|
+
class TcpCheckAlertSettingsParallelRunFailureThresholdArgsDict(TypedDict):
|
|
2669
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
2670
|
+
"""
|
|
2671
|
+
Applicable only for checks scheduled in parallel in multiple locations.
|
|
2672
|
+
"""
|
|
2673
|
+
percentage: NotRequired[pulumi.Input[int]]
|
|
2674
|
+
"""
|
|
2675
|
+
Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
2676
|
+
"""
|
|
2677
|
+
elif False:
|
|
2678
|
+
TcpCheckAlertSettingsParallelRunFailureThresholdArgsDict: TypeAlias = Mapping[str, Any]
|
|
2679
|
+
|
|
2680
|
+
@pulumi.input_type
|
|
2681
|
+
class TcpCheckAlertSettingsParallelRunFailureThresholdArgs:
|
|
2682
|
+
def __init__(__self__, *,
|
|
2683
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
2684
|
+
percentage: Optional[pulumi.Input[int]] = None):
|
|
2685
|
+
"""
|
|
2686
|
+
:param pulumi.Input[bool] enabled: Applicable only for checks scheduled in parallel in multiple locations.
|
|
2687
|
+
:param pulumi.Input[int] percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
2688
|
+
"""
|
|
2689
|
+
if enabled is not None:
|
|
2690
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
2691
|
+
if percentage is not None:
|
|
2692
|
+
pulumi.set(__self__, "percentage", percentage)
|
|
2693
|
+
|
|
2694
|
+
@property
|
|
2695
|
+
@pulumi.getter
|
|
2696
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
2697
|
+
"""
|
|
2698
|
+
Applicable only for checks scheduled in parallel in multiple locations.
|
|
2699
|
+
"""
|
|
2700
|
+
return pulumi.get(self, "enabled")
|
|
2701
|
+
|
|
2702
|
+
@enabled.setter
|
|
2703
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
2704
|
+
pulumi.set(self, "enabled", value)
|
|
2705
|
+
|
|
2706
|
+
@property
|
|
2707
|
+
@pulumi.getter
|
|
2708
|
+
def percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2709
|
+
"""
|
|
2710
|
+
Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
|
|
2711
|
+
"""
|
|
2712
|
+
return pulumi.get(self, "percentage")
|
|
2713
|
+
|
|
2714
|
+
@percentage.setter
|
|
2715
|
+
def percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2716
|
+
pulumi.set(self, "percentage", value)
|
|
2717
|
+
|
|
2718
|
+
|
|
2719
|
+
if not MYPY:
|
|
2720
|
+
class TcpCheckAlertSettingsReminderArgsDict(TypedDict):
|
|
2721
|
+
amount: NotRequired[pulumi.Input[int]]
|
|
2722
|
+
"""
|
|
2723
|
+
How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
2724
|
+
"""
|
|
2725
|
+
interval: NotRequired[pulumi.Input[int]]
|
|
2726
|
+
"""
|
|
2727
|
+
Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
2728
|
+
"""
|
|
2729
|
+
elif False:
|
|
2730
|
+
TcpCheckAlertSettingsReminderArgsDict: TypeAlias = Mapping[str, Any]
|
|
2731
|
+
|
|
2732
|
+
@pulumi.input_type
|
|
2733
|
+
class TcpCheckAlertSettingsReminderArgs:
|
|
2734
|
+
def __init__(__self__, *,
|
|
2735
|
+
amount: Optional[pulumi.Input[int]] = None,
|
|
2736
|
+
interval: Optional[pulumi.Input[int]] = None):
|
|
2737
|
+
"""
|
|
2738
|
+
:param pulumi.Input[int] amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
2739
|
+
:param pulumi.Input[int] interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
2740
|
+
"""
|
|
2741
|
+
if amount is not None:
|
|
2742
|
+
pulumi.set(__self__, "amount", amount)
|
|
2743
|
+
if interval is not None:
|
|
2744
|
+
pulumi.set(__self__, "interval", interval)
|
|
2745
|
+
|
|
2746
|
+
@property
|
|
2747
|
+
@pulumi.getter
|
|
2748
|
+
def amount(self) -> Optional[pulumi.Input[int]]:
|
|
2749
|
+
"""
|
|
2750
|
+
How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
|
|
2751
|
+
"""
|
|
2752
|
+
return pulumi.get(self, "amount")
|
|
2753
|
+
|
|
2754
|
+
@amount.setter
|
|
2755
|
+
def amount(self, value: Optional[pulumi.Input[int]]):
|
|
2756
|
+
pulumi.set(self, "amount", value)
|
|
2757
|
+
|
|
2758
|
+
@property
|
|
2759
|
+
@pulumi.getter
|
|
2760
|
+
def interval(self) -> Optional[pulumi.Input[int]]:
|
|
2761
|
+
"""
|
|
2762
|
+
Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
2763
|
+
"""
|
|
2764
|
+
return pulumi.get(self, "interval")
|
|
2765
|
+
|
|
2766
|
+
@interval.setter
|
|
2767
|
+
def interval(self, value: Optional[pulumi.Input[int]]):
|
|
2768
|
+
pulumi.set(self, "interval", value)
|
|
2769
|
+
|
|
2770
|
+
|
|
2771
|
+
if not MYPY:
|
|
2772
|
+
class TcpCheckAlertSettingsRunBasedEscalationArgsDict(TypedDict):
|
|
2773
|
+
failed_run_threshold: NotRequired[pulumi.Input[int]]
|
|
2774
|
+
"""
|
|
2775
|
+
After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
2776
|
+
"""
|
|
2777
|
+
elif False:
|
|
2778
|
+
TcpCheckAlertSettingsRunBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
2779
|
+
|
|
2780
|
+
@pulumi.input_type
|
|
2781
|
+
class TcpCheckAlertSettingsRunBasedEscalationArgs:
|
|
2782
|
+
def __init__(__self__, *,
|
|
2783
|
+
failed_run_threshold: Optional[pulumi.Input[int]] = None):
|
|
2784
|
+
"""
|
|
2785
|
+
:param pulumi.Input[int] failed_run_threshold: After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
2786
|
+
"""
|
|
2787
|
+
if failed_run_threshold is not None:
|
|
2788
|
+
pulumi.set(__self__, "failed_run_threshold", failed_run_threshold)
|
|
2789
|
+
|
|
2790
|
+
@property
|
|
2791
|
+
@pulumi.getter(name="failedRunThreshold")
|
|
2792
|
+
def failed_run_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
2793
|
+
"""
|
|
2794
|
+
After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
|
|
2795
|
+
"""
|
|
2796
|
+
return pulumi.get(self, "failed_run_threshold")
|
|
2797
|
+
|
|
2798
|
+
@failed_run_threshold.setter
|
|
2799
|
+
def failed_run_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
2800
|
+
pulumi.set(self, "failed_run_threshold", value)
|
|
2801
|
+
|
|
2802
|
+
|
|
2803
|
+
if not MYPY:
|
|
2804
|
+
class TcpCheckAlertSettingsTimeBasedEscalationArgsDict(TypedDict):
|
|
2805
|
+
minutes_failing_threshold: NotRequired[pulumi.Input[int]]
|
|
2806
|
+
"""
|
|
2807
|
+
After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
2808
|
+
"""
|
|
2809
|
+
elif False:
|
|
2810
|
+
TcpCheckAlertSettingsTimeBasedEscalationArgsDict: TypeAlias = Mapping[str, Any]
|
|
2811
|
+
|
|
2812
|
+
@pulumi.input_type
|
|
2813
|
+
class TcpCheckAlertSettingsTimeBasedEscalationArgs:
|
|
2814
|
+
def __init__(__self__, *,
|
|
2815
|
+
minutes_failing_threshold: Optional[pulumi.Input[int]] = None):
|
|
2816
|
+
"""
|
|
2817
|
+
:param pulumi.Input[int] minutes_failing_threshold: After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
2818
|
+
"""
|
|
2819
|
+
if minutes_failing_threshold is not None:
|
|
2820
|
+
pulumi.set(__self__, "minutes_failing_threshold", minutes_failing_threshold)
|
|
2821
|
+
|
|
2822
|
+
@property
|
|
2823
|
+
@pulumi.getter(name="minutesFailingThreshold")
|
|
2824
|
+
def minutes_failing_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
2825
|
+
"""
|
|
2826
|
+
After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
|
|
2827
|
+
"""
|
|
2828
|
+
return pulumi.get(self, "minutes_failing_threshold")
|
|
2829
|
+
|
|
2830
|
+
@minutes_failing_threshold.setter
|
|
2831
|
+
def minutes_failing_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
2832
|
+
pulumi.set(self, "minutes_failing_threshold", value)
|
|
2833
|
+
|
|
2834
|
+
|
|
2835
|
+
if not MYPY:
|
|
2836
|
+
class TcpCheckRequestArgsDict(TypedDict):
|
|
2837
|
+
hostname: pulumi.Input[str]
|
|
2838
|
+
"""
|
|
2839
|
+
The hostname or IP to connect to. Do not include a scheme or a port in this value.
|
|
2840
|
+
"""
|
|
2841
|
+
port: pulumi.Input[int]
|
|
2842
|
+
"""
|
|
2843
|
+
The port number to connect to.
|
|
2844
|
+
"""
|
|
2845
|
+
assertions: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpCheckRequestAssertionArgsDict']]]]
|
|
2846
|
+
"""
|
|
2847
|
+
A request can have multiple assertions.
|
|
2848
|
+
"""
|
|
2849
|
+
data: NotRequired[pulumi.Input[str]]
|
|
2850
|
+
"""
|
|
2851
|
+
The data to send to the target host.
|
|
2852
|
+
"""
|
|
2853
|
+
ip_family: NotRequired[pulumi.Input[str]]
|
|
2854
|
+
"""
|
|
2855
|
+
The IP family to use when executing the TCP check. The value can be either `IPv4` or `IPv6`.
|
|
2856
|
+
"""
|
|
2857
|
+
elif False:
|
|
2858
|
+
TcpCheckRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
2859
|
+
|
|
2860
|
+
@pulumi.input_type
|
|
2861
|
+
class TcpCheckRequestArgs:
|
|
2862
|
+
def __init__(__self__, *,
|
|
2863
|
+
hostname: pulumi.Input[str],
|
|
2864
|
+
port: pulumi.Input[int],
|
|
2865
|
+
assertions: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckRequestAssertionArgs']]]] = None,
|
|
2866
|
+
data: Optional[pulumi.Input[str]] = None,
|
|
2867
|
+
ip_family: Optional[pulumi.Input[str]] = None):
|
|
2868
|
+
"""
|
|
2869
|
+
:param pulumi.Input[str] hostname: The hostname or IP to connect to. Do not include a scheme or a port in this value.
|
|
2870
|
+
:param pulumi.Input[int] port: The port number to connect to.
|
|
2871
|
+
:param pulumi.Input[Sequence[pulumi.Input['TcpCheckRequestAssertionArgs']]] assertions: A request can have multiple assertions.
|
|
2872
|
+
:param pulumi.Input[str] data: The data to send to the target host.
|
|
2873
|
+
:param pulumi.Input[str] ip_family: The IP family to use when executing the TCP check. The value can be either `IPv4` or `IPv6`.
|
|
2874
|
+
"""
|
|
2875
|
+
pulumi.set(__self__, "hostname", hostname)
|
|
2876
|
+
pulumi.set(__self__, "port", port)
|
|
2877
|
+
if assertions is not None:
|
|
2878
|
+
pulumi.set(__self__, "assertions", assertions)
|
|
2879
|
+
if data is not None:
|
|
2880
|
+
pulumi.set(__self__, "data", data)
|
|
2881
|
+
if ip_family is not None:
|
|
2882
|
+
pulumi.set(__self__, "ip_family", ip_family)
|
|
2883
|
+
|
|
2884
|
+
@property
|
|
2885
|
+
@pulumi.getter
|
|
2886
|
+
def hostname(self) -> pulumi.Input[str]:
|
|
2887
|
+
"""
|
|
2888
|
+
The hostname or IP to connect to. Do not include a scheme or a port in this value.
|
|
2889
|
+
"""
|
|
2890
|
+
return pulumi.get(self, "hostname")
|
|
2891
|
+
|
|
2892
|
+
@hostname.setter
|
|
2893
|
+
def hostname(self, value: pulumi.Input[str]):
|
|
2894
|
+
pulumi.set(self, "hostname", value)
|
|
2895
|
+
|
|
2896
|
+
@property
|
|
2897
|
+
@pulumi.getter
|
|
2898
|
+
def port(self) -> pulumi.Input[int]:
|
|
2899
|
+
"""
|
|
2900
|
+
The port number to connect to.
|
|
2901
|
+
"""
|
|
2902
|
+
return pulumi.get(self, "port")
|
|
2903
|
+
|
|
2904
|
+
@port.setter
|
|
2905
|
+
def port(self, value: pulumi.Input[int]):
|
|
2906
|
+
pulumi.set(self, "port", value)
|
|
2907
|
+
|
|
2908
|
+
@property
|
|
2909
|
+
@pulumi.getter
|
|
2910
|
+
def assertions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckRequestAssertionArgs']]]]:
|
|
2911
|
+
"""
|
|
2912
|
+
A request can have multiple assertions.
|
|
2913
|
+
"""
|
|
2914
|
+
return pulumi.get(self, "assertions")
|
|
2915
|
+
|
|
2916
|
+
@assertions.setter
|
|
2917
|
+
def assertions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpCheckRequestAssertionArgs']]]]):
|
|
2918
|
+
pulumi.set(self, "assertions", value)
|
|
2919
|
+
|
|
2920
|
+
@property
|
|
2921
|
+
@pulumi.getter
|
|
2922
|
+
def data(self) -> Optional[pulumi.Input[str]]:
|
|
2923
|
+
"""
|
|
2924
|
+
The data to send to the target host.
|
|
2925
|
+
"""
|
|
2926
|
+
return pulumi.get(self, "data")
|
|
2927
|
+
|
|
2928
|
+
@data.setter
|
|
2929
|
+
def data(self, value: Optional[pulumi.Input[str]]):
|
|
2930
|
+
pulumi.set(self, "data", value)
|
|
2931
|
+
|
|
2932
|
+
@property
|
|
2933
|
+
@pulumi.getter(name="ipFamily")
|
|
2934
|
+
def ip_family(self) -> Optional[pulumi.Input[str]]:
|
|
2935
|
+
"""
|
|
2936
|
+
The IP family to use when executing the TCP check. The value can be either `IPv4` or `IPv6`.
|
|
2937
|
+
"""
|
|
2938
|
+
return pulumi.get(self, "ip_family")
|
|
2939
|
+
|
|
2940
|
+
@ip_family.setter
|
|
2941
|
+
def ip_family(self, value: Optional[pulumi.Input[str]]):
|
|
2942
|
+
pulumi.set(self, "ip_family", value)
|
|
2943
|
+
|
|
2944
|
+
|
|
2945
|
+
if not MYPY:
|
|
2946
|
+
class TcpCheckRequestAssertionArgsDict(TypedDict):
|
|
2947
|
+
comparison: pulumi.Input[str]
|
|
2948
|
+
"""
|
|
2949
|
+
The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `HAS_KEY`, `NOT_HAS_KEY`, `HAS_VALUE`, `NOT_HAS_VALUE`, `IS_EMPTY`, `NOT_EMPTY`, `GREATER_THAN`, `LESS_THAN`, `CONTAINS`, `NOT_CONTAINS`, `IS_NULL`, and `NOT_NULL`.
|
|
2950
|
+
"""
|
|
2951
|
+
source: pulumi.Input[str]
|
|
2952
|
+
"""
|
|
2953
|
+
The source of the asserted value. Possible values are `RESPONSE_DATA` and `RESPONSE_TIME`.
|
|
2954
|
+
"""
|
|
2955
|
+
property: NotRequired[pulumi.Input[str]]
|
|
2956
|
+
target: NotRequired[pulumi.Input[str]]
|
|
2957
|
+
elif False:
|
|
2958
|
+
TcpCheckRequestAssertionArgsDict: TypeAlias = Mapping[str, Any]
|
|
2959
|
+
|
|
2960
|
+
@pulumi.input_type
|
|
2961
|
+
class TcpCheckRequestAssertionArgs:
|
|
2962
|
+
def __init__(__self__, *,
|
|
2963
|
+
comparison: pulumi.Input[str],
|
|
2964
|
+
source: pulumi.Input[str],
|
|
2965
|
+
property: Optional[pulumi.Input[str]] = None,
|
|
2966
|
+
target: Optional[pulumi.Input[str]] = None):
|
|
2967
|
+
"""
|
|
2968
|
+
:param pulumi.Input[str] comparison: The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `HAS_KEY`, `NOT_HAS_KEY`, `HAS_VALUE`, `NOT_HAS_VALUE`, `IS_EMPTY`, `NOT_EMPTY`, `GREATER_THAN`, `LESS_THAN`, `CONTAINS`, `NOT_CONTAINS`, `IS_NULL`, and `NOT_NULL`.
|
|
2969
|
+
:param pulumi.Input[str] source: The source of the asserted value. Possible values are `RESPONSE_DATA` and `RESPONSE_TIME`.
|
|
2970
|
+
"""
|
|
2971
|
+
pulumi.set(__self__, "comparison", comparison)
|
|
2972
|
+
pulumi.set(__self__, "source", source)
|
|
2973
|
+
if property is not None:
|
|
2974
|
+
pulumi.set(__self__, "property", property)
|
|
2975
|
+
if target is not None:
|
|
2976
|
+
pulumi.set(__self__, "target", target)
|
|
2977
|
+
|
|
2978
|
+
@property
|
|
2979
|
+
@pulumi.getter
|
|
2980
|
+
def comparison(self) -> pulumi.Input[str]:
|
|
2981
|
+
"""
|
|
2982
|
+
The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `HAS_KEY`, `NOT_HAS_KEY`, `HAS_VALUE`, `NOT_HAS_VALUE`, `IS_EMPTY`, `NOT_EMPTY`, `GREATER_THAN`, `LESS_THAN`, `CONTAINS`, `NOT_CONTAINS`, `IS_NULL`, and `NOT_NULL`.
|
|
2983
|
+
"""
|
|
2984
|
+
return pulumi.get(self, "comparison")
|
|
2985
|
+
|
|
2986
|
+
@comparison.setter
|
|
2987
|
+
def comparison(self, value: pulumi.Input[str]):
|
|
2988
|
+
pulumi.set(self, "comparison", value)
|
|
2989
|
+
|
|
2990
|
+
@property
|
|
2991
|
+
@pulumi.getter
|
|
2992
|
+
def source(self) -> pulumi.Input[str]:
|
|
2993
|
+
"""
|
|
2994
|
+
The source of the asserted value. Possible values are `RESPONSE_DATA` and `RESPONSE_TIME`.
|
|
2995
|
+
"""
|
|
2996
|
+
return pulumi.get(self, "source")
|
|
2997
|
+
|
|
2998
|
+
@source.setter
|
|
2999
|
+
def source(self, value: pulumi.Input[str]):
|
|
3000
|
+
pulumi.set(self, "source", value)
|
|
3001
|
+
|
|
3002
|
+
@property
|
|
3003
|
+
@pulumi.getter
|
|
3004
|
+
def target(self) -> Optional[pulumi.Input[str]]:
|
|
3005
|
+
return pulumi.get(self, "target")
|
|
3006
|
+
|
|
3007
|
+
@target.setter
|
|
3008
|
+
def target(self, value: Optional[pulumi.Input[str]]):
|
|
3009
|
+
pulumi.set(self, "target", value)
|
|
3010
|
+
|
|
3011
|
+
@property
|
|
3012
|
+
@pulumi.getter
|
|
3013
|
+
def property(self) -> Optional[pulumi.Input[str]]:
|
|
3014
|
+
return pulumi.get(self, "property")
|
|
3015
|
+
|
|
3016
|
+
@property.setter
|
|
3017
|
+
def property(self, value: Optional[pulumi.Input[str]]):
|
|
3018
|
+
pulumi.set(self, "property", value)
|
|
3019
|
+
|
|
3020
|
+
|
|
3021
|
+
if not MYPY:
|
|
3022
|
+
class TcpCheckRetryStrategyArgsDict(TypedDict):
|
|
3023
|
+
type: pulumi.Input[str]
|
|
3024
|
+
"""
|
|
3025
|
+
Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
|
|
3026
|
+
"""
|
|
3027
|
+
base_backoff_seconds: NotRequired[pulumi.Input[int]]
|
|
3028
|
+
"""
|
|
3029
|
+
The number of seconds to wait before the first retry attempt.
|
|
3030
|
+
"""
|
|
3031
|
+
max_duration_seconds: NotRequired[pulumi.Input[int]]
|
|
3032
|
+
"""
|
|
3033
|
+
The total amount of time to continue retrying the check (maximum 600 seconds).
|
|
3034
|
+
"""
|
|
3035
|
+
max_retries: NotRequired[pulumi.Input[int]]
|
|
3036
|
+
"""
|
|
3037
|
+
The maximum number of times to retry the check. Value must be between 1 and 10.
|
|
3038
|
+
"""
|
|
3039
|
+
same_region: NotRequired[pulumi.Input[bool]]
|
|
3040
|
+
"""
|
|
3041
|
+
Whether retries should be run in the same region as the initial check run.
|
|
3042
|
+
"""
|
|
3043
|
+
elif False:
|
|
3044
|
+
TcpCheckRetryStrategyArgsDict: TypeAlias = Mapping[str, Any]
|
|
3045
|
+
|
|
3046
|
+
@pulumi.input_type
|
|
3047
|
+
class TcpCheckRetryStrategyArgs:
|
|
3048
|
+
def __init__(__self__, *,
|
|
3049
|
+
type: pulumi.Input[str],
|
|
3050
|
+
base_backoff_seconds: Optional[pulumi.Input[int]] = None,
|
|
3051
|
+
max_duration_seconds: Optional[pulumi.Input[int]] = None,
|
|
3052
|
+
max_retries: Optional[pulumi.Input[int]] = None,
|
|
3053
|
+
same_region: Optional[pulumi.Input[bool]] = None):
|
|
3054
|
+
"""
|
|
3055
|
+
:param pulumi.Input[str] type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
|
|
3056
|
+
:param pulumi.Input[int] base_backoff_seconds: The number of seconds to wait before the first retry attempt.
|
|
3057
|
+
:param pulumi.Input[int] max_duration_seconds: The total amount of time to continue retrying the check (maximum 600 seconds).
|
|
3058
|
+
:param pulumi.Input[int] max_retries: The maximum number of times to retry the check. Value must be between 1 and 10.
|
|
3059
|
+
:param pulumi.Input[bool] same_region: Whether retries should be run in the same region as the initial check run.
|
|
3060
|
+
"""
|
|
3061
|
+
pulumi.set(__self__, "type", type)
|
|
3062
|
+
if base_backoff_seconds is not None:
|
|
3063
|
+
pulumi.set(__self__, "base_backoff_seconds", base_backoff_seconds)
|
|
3064
|
+
if max_duration_seconds is not None:
|
|
3065
|
+
pulumi.set(__self__, "max_duration_seconds", max_duration_seconds)
|
|
3066
|
+
if max_retries is not None:
|
|
3067
|
+
pulumi.set(__self__, "max_retries", max_retries)
|
|
3068
|
+
if same_region is not None:
|
|
3069
|
+
pulumi.set(__self__, "same_region", same_region)
|
|
3070
|
+
|
|
3071
|
+
@property
|
|
3072
|
+
@pulumi.getter
|
|
3073
|
+
def type(self) -> pulumi.Input[str]:
|
|
3074
|
+
"""
|
|
3075
|
+
Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
|
|
3076
|
+
"""
|
|
3077
|
+
return pulumi.get(self, "type")
|
|
3078
|
+
|
|
3079
|
+
@type.setter
|
|
3080
|
+
def type(self, value: pulumi.Input[str]):
|
|
3081
|
+
pulumi.set(self, "type", value)
|
|
3082
|
+
|
|
3083
|
+
@property
|
|
3084
|
+
@pulumi.getter(name="baseBackoffSeconds")
|
|
3085
|
+
def base_backoff_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
3086
|
+
"""
|
|
3087
|
+
The number of seconds to wait before the first retry attempt.
|
|
3088
|
+
"""
|
|
3089
|
+
return pulumi.get(self, "base_backoff_seconds")
|
|
3090
|
+
|
|
3091
|
+
@base_backoff_seconds.setter
|
|
3092
|
+
def base_backoff_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
3093
|
+
pulumi.set(self, "base_backoff_seconds", value)
|
|
3094
|
+
|
|
3095
|
+
@property
|
|
3096
|
+
@pulumi.getter(name="maxDurationSeconds")
|
|
3097
|
+
def max_duration_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
3098
|
+
"""
|
|
3099
|
+
The total amount of time to continue retrying the check (maximum 600 seconds).
|
|
3100
|
+
"""
|
|
3101
|
+
return pulumi.get(self, "max_duration_seconds")
|
|
3102
|
+
|
|
3103
|
+
@max_duration_seconds.setter
|
|
3104
|
+
def max_duration_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
3105
|
+
pulumi.set(self, "max_duration_seconds", value)
|
|
3106
|
+
|
|
3107
|
+
@property
|
|
3108
|
+
@pulumi.getter(name="maxRetries")
|
|
3109
|
+
def max_retries(self) -> Optional[pulumi.Input[int]]:
|
|
3110
|
+
"""
|
|
3111
|
+
The maximum number of times to retry the check. Value must be between 1 and 10.
|
|
3112
|
+
"""
|
|
3113
|
+
return pulumi.get(self, "max_retries")
|
|
3114
|
+
|
|
3115
|
+
@max_retries.setter
|
|
3116
|
+
def max_retries(self, value: Optional[pulumi.Input[int]]):
|
|
3117
|
+
pulumi.set(self, "max_retries", value)
|
|
3118
|
+
|
|
3119
|
+
@property
|
|
3120
|
+
@pulumi.getter(name="sameRegion")
|
|
3121
|
+
def same_region(self) -> Optional[pulumi.Input[bool]]:
|
|
3122
|
+
"""
|
|
3123
|
+
Whether retries should be run in the same region as the initial check run.
|
|
3124
|
+
"""
|
|
3125
|
+
return pulumi.get(self, "same_region")
|
|
3126
|
+
|
|
3127
|
+
@same_region.setter
|
|
3128
|
+
def same_region(self, value: Optional[pulumi.Input[bool]]):
|
|
3129
|
+
pulumi.set(self, "same_region", value)
|
|
3130
|
+
|
|
3131
|
+
|