pulumi-checkly 2.5.0a1758735363__py3-none-any.whl → 2.5.0a1759322016__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.
Files changed (33) hide show
  1. pulumi_checkly/__init__.py +2 -1
  2. pulumi_checkly/_inputs.py +1635 -1365
  3. pulumi_checkly/_utilities.py +9 -5
  4. pulumi_checkly/alert_channel.py +109 -108
  5. pulumi_checkly/check.py +473 -472
  6. pulumi_checkly/check_group.py +300 -299
  7. pulumi_checkly/client_certificate.py +88 -87
  8. pulumi_checkly/config/__init__.py +2 -1
  9. pulumi_checkly/config/__init__.pyi +2 -2
  10. pulumi_checkly/config/vars.py +5 -5
  11. pulumi_checkly/dashboard.py +403 -402
  12. pulumi_checkly/environment_variable.py +55 -54
  13. pulumi_checkly/get_static_ips.py +18 -18
  14. pulumi_checkly/heartbeat_check.py +100 -99
  15. pulumi_checkly/heartbeat_monitor.py +100 -99
  16. pulumi_checkly/maintenance_window.py +122 -121
  17. pulumi_checkly/outputs.py +1152 -897
  18. pulumi_checkly/private_location.py +63 -62
  19. pulumi_checkly/provider.py +56 -36
  20. pulumi_checkly/pulumi-plugin.json +1 -1
  21. pulumi_checkly/snippet.py +37 -36
  22. pulumi_checkly/status_page.py +125 -124
  23. pulumi_checkly/status_page_service.py +20 -19
  24. pulumi_checkly/tcp_check.py +297 -296
  25. pulumi_checkly/tcp_monitor.py +297 -296
  26. pulumi_checkly/trigger_check.py +54 -53
  27. pulumi_checkly/trigger_check_group.py +54 -53
  28. pulumi_checkly/url_monitor.py +280 -279
  29. {pulumi_checkly-2.5.0a1758735363.dist-info → pulumi_checkly-2.5.0a1759322016.dist-info}/METADATA +2 -2
  30. pulumi_checkly-2.5.0a1759322016.dist-info/RECORD +33 -0
  31. pulumi_checkly-2.5.0a1758735363.dist-info/RECORD +0 -33
  32. {pulumi_checkly-2.5.0a1758735363.dist-info → pulumi_checkly-2.5.0a1759322016.dist-info}/WHEEL +0 -0
  33. {pulumi_checkly-2.5.0a1758735363.dist-info → pulumi_checkly-2.5.0a1759322016.dist-info}/top_level.txt +0 -0
pulumi_checkly/outputs.py CHANGED
@@ -1,8 +1,8 @@
1
1
  # coding=utf-8
2
- # *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
2
+ # *** WARNING: this file was generated by pulumi-language-python. ***
3
3
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
4
4
 
5
- import copy
5
+ import builtins as _builtins
6
6
  import warnings
7
7
  import sys
8
8
  import pulumi
@@ -43,10 +43,12 @@ __all__ = [
43
43
  'CheckGroupApiCheckDefaultsBasicAuth',
44
44
  'CheckGroupEnvironmentVariable',
45
45
  'CheckGroupRetryStrategy',
46
+ 'CheckGroupRetryStrategyOnlyOn',
46
47
  'CheckRequest',
47
48
  'CheckRequestAssertion',
48
49
  'CheckRequestBasicAuth',
49
50
  'CheckRetryStrategy',
51
+ 'CheckRetryStrategyOnlyOn',
50
52
  'CheckTriggerIncident',
51
53
  'HeartbeatCheckAlertChannelSubscription',
52
54
  'HeartbeatCheckAlertSettings',
@@ -77,6 +79,7 @@ __all__ = [
77
79
  'TcpCheckRequest',
78
80
  'TcpCheckRequestAssertion',
79
81
  'TcpCheckRetryStrategy',
82
+ 'TcpCheckRetryStrategyOnlyOn',
80
83
  'TcpCheckTriggerIncident',
81
84
  'TcpMonitorAlertChannelSubscription',
82
85
  'TcpMonitorAlertSettings',
@@ -87,6 +90,7 @@ __all__ = [
87
90
  'TcpMonitorRequest',
88
91
  'TcpMonitorRequestAssertion',
89
92
  'TcpMonitorRetryStrategy',
93
+ 'TcpMonitorRetryStrategyOnlyOn',
90
94
  'TcpMonitorTriggerIncident',
91
95
  'UrlMonitorAlertChannelSubscription',
92
96
  'UrlMonitorAlertSettings',
@@ -97,32 +101,33 @@ __all__ = [
97
101
  'UrlMonitorRequest',
98
102
  'UrlMonitorRequestAssertion',
99
103
  'UrlMonitorRetryStrategy',
104
+ 'UrlMonitorRetryStrategyOnlyOn',
100
105
  'UrlMonitorTriggerIncident',
101
106
  ]
102
107
 
103
108
  @pulumi.output_type
104
109
  class AlertChannelCall(dict):
105
110
  def __init__(__self__, *,
106
- name: str,
107
- number: str):
111
+ name: _builtins.str,
112
+ number: _builtins.str):
108
113
  """
109
- :param str name: The name of this alert channel
110
- :param str number: The mobile number to receive the alerts
114
+ :param _builtins.str name: The name of this alert channel
115
+ :param _builtins.str number: The mobile number to receive the alerts
111
116
  """
112
117
  pulumi.set(__self__, "name", name)
113
118
  pulumi.set(__self__, "number", number)
114
119
 
115
- @property
120
+ @_builtins.property
116
121
  @pulumi.getter
117
- def name(self) -> str:
122
+ def name(self) -> _builtins.str:
118
123
  """
119
124
  The name of this alert channel
120
125
  """
121
126
  return pulumi.get(self, "name")
122
127
 
123
- @property
128
+ @_builtins.property
124
129
  @pulumi.getter
125
- def number(self) -> str:
130
+ def number(self) -> _builtins.str:
126
131
  """
127
132
  The mobile number to receive the alerts
128
133
  """
@@ -132,15 +137,15 @@ class AlertChannelCall(dict):
132
137
  @pulumi.output_type
133
138
  class AlertChannelEmail(dict):
134
139
  def __init__(__self__, *,
135
- address: str):
140
+ address: _builtins.str):
136
141
  """
137
- :param str address: The email address of this email alert channel.
142
+ :param _builtins.str address: The email address of this email alert channel.
138
143
  """
139
144
  pulumi.set(__self__, "address", address)
140
145
 
141
- @property
146
+ @_builtins.property
142
147
  @pulumi.getter
143
- def address(self) -> str:
148
+ def address(self) -> _builtins.str:
144
149
  """
145
150
  The email address of this email alert channel.
146
151
  """
@@ -167,33 +172,33 @@ class AlertChannelOpsgenie(dict):
167
172
  return super().get(key, default)
168
173
 
169
174
  def __init__(__self__, *,
170
- api_key: str,
171
- name: str,
172
- priority: str,
173
- region: str):
175
+ api_key: _builtins.str,
176
+ name: _builtins.str,
177
+ priority: _builtins.str,
178
+ region: _builtins.str):
174
179
  pulumi.set(__self__, "api_key", api_key)
175
180
  pulumi.set(__self__, "name", name)
176
181
  pulumi.set(__self__, "priority", priority)
177
182
  pulumi.set(__self__, "region", region)
178
183
 
179
- @property
184
+ @_builtins.property
180
185
  @pulumi.getter(name="apiKey")
181
- def api_key(self) -> str:
186
+ def api_key(self) -> _builtins.str:
182
187
  return pulumi.get(self, "api_key")
183
188
 
184
- @property
189
+ @_builtins.property
185
190
  @pulumi.getter
186
- def name(self) -> str:
191
+ def name(self) -> _builtins.str:
187
192
  return pulumi.get(self, "name")
188
193
 
189
- @property
194
+ @_builtins.property
190
195
  @pulumi.getter
191
- def priority(self) -> str:
196
+ def priority(self) -> _builtins.str:
192
197
  return pulumi.get(self, "priority")
193
198
 
194
- @property
199
+ @_builtins.property
195
200
  @pulumi.getter
196
- def region(self) -> str:
201
+ def region(self) -> _builtins.str:
197
202
  return pulumi.get(self, "region")
198
203
 
199
204
 
@@ -219,54 +224,54 @@ class AlertChannelPagerduty(dict):
219
224
  return super().get(key, default)
220
225
 
221
226
  def __init__(__self__, *,
222
- service_key: str,
223
- account: Optional[str] = None,
224
- service_name: Optional[str] = None):
227
+ service_key: _builtins.str,
228
+ account: Optional[_builtins.str] = None,
229
+ service_name: Optional[_builtins.str] = None):
225
230
  pulumi.set(__self__, "service_key", service_key)
226
231
  if account is not None:
227
232
  pulumi.set(__self__, "account", account)
228
233
  if service_name is not None:
229
234
  pulumi.set(__self__, "service_name", service_name)
230
235
 
231
- @property
236
+ @_builtins.property
232
237
  @pulumi.getter(name="serviceKey")
233
- def service_key(self) -> str:
238
+ def service_key(self) -> _builtins.str:
234
239
  return pulumi.get(self, "service_key")
235
240
 
236
- @property
241
+ @_builtins.property
237
242
  @pulumi.getter
238
- def account(self) -> Optional[str]:
243
+ def account(self) -> Optional[_builtins.str]:
239
244
  return pulumi.get(self, "account")
240
245
 
241
- @property
246
+ @_builtins.property
242
247
  @pulumi.getter(name="serviceName")
243
- def service_name(self) -> Optional[str]:
248
+ def service_name(self) -> Optional[_builtins.str]:
244
249
  return pulumi.get(self, "service_name")
245
250
 
246
251
 
247
252
  @pulumi.output_type
248
253
  class AlertChannelSlack(dict):
249
254
  def __init__(__self__, *,
250
- channel: str,
251
- url: str):
255
+ channel: _builtins.str,
256
+ url: _builtins.str):
252
257
  """
253
- :param str channel: The name of the alert's Slack channel
254
- :param str url: The Slack webhook URL
258
+ :param _builtins.str channel: The name of the alert's Slack channel
259
+ :param _builtins.str url: The Slack webhook URL
255
260
  """
256
261
  pulumi.set(__self__, "channel", channel)
257
262
  pulumi.set(__self__, "url", url)
258
263
 
259
- @property
264
+ @_builtins.property
260
265
  @pulumi.getter
261
- def channel(self) -> str:
266
+ def channel(self) -> _builtins.str:
262
267
  """
263
268
  The name of the alert's Slack channel
264
269
  """
265
270
  return pulumi.get(self, "channel")
266
271
 
267
- @property
272
+ @_builtins.property
268
273
  @pulumi.getter
269
- def url(self) -> str:
274
+ def url(self) -> _builtins.str:
270
275
  """
271
276
  The Slack webhook URL
272
277
  """
@@ -276,26 +281,26 @@ class AlertChannelSlack(dict):
276
281
  @pulumi.output_type
277
282
  class AlertChannelSms(dict):
278
283
  def __init__(__self__, *,
279
- name: str,
280
- number: str):
284
+ name: _builtins.str,
285
+ number: _builtins.str):
281
286
  """
282
- :param str name: The name of this alert channel
283
- :param str number: The mobile number to receive the alerts
287
+ :param _builtins.str name: The name of this alert channel
288
+ :param _builtins.str number: The mobile number to receive the alerts
284
289
  """
285
290
  pulumi.set(__self__, "name", name)
286
291
  pulumi.set(__self__, "number", number)
287
292
 
288
- @property
293
+ @_builtins.property
289
294
  @pulumi.getter
290
- def name(self) -> str:
295
+ def name(self) -> _builtins.str:
291
296
  """
292
297
  The name of this alert channel
293
298
  """
294
299
  return pulumi.get(self, "name")
295
300
 
296
- @property
301
+ @_builtins.property
297
302
  @pulumi.getter
298
- def number(self) -> str:
303
+ def number(self) -> _builtins.str:
299
304
  """
300
305
  The mobile number to receive the alerts
301
306
  """
@@ -326,17 +331,17 @@ class AlertChannelWebhook(dict):
326
331
  return super().get(key, default)
327
332
 
328
333
  def __init__(__self__, *,
329
- name: str,
330
- url: str,
331
- headers: Optional[Mapping[str, str]] = None,
332
- method: Optional[str] = None,
333
- query_parameters: Optional[Mapping[str, str]] = None,
334
- template: Optional[str] = None,
335
- webhook_secret: Optional[str] = None,
336
- webhook_type: Optional[str] = None):
337
- """
338
- :param str method: (Default `POST`)
339
- :param 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'.
334
+ name: _builtins.str,
335
+ url: _builtins.str,
336
+ headers: Optional[Mapping[str, _builtins.str]] = None,
337
+ method: Optional[_builtins.str] = None,
338
+ query_parameters: Optional[Mapping[str, _builtins.str]] = None,
339
+ template: Optional[_builtins.str] = None,
340
+ webhook_secret: Optional[_builtins.str] = None,
341
+ webhook_type: Optional[_builtins.str] = None):
342
+ """
343
+ :param _builtins.str method: (Default `POST`)
344
+ :param _builtins.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'.
340
345
  """
341
346
  pulumi.set(__self__, "name", name)
342
347
  pulumi.set(__self__, "url", url)
@@ -353,47 +358,47 @@ class AlertChannelWebhook(dict):
353
358
  if webhook_type is not None:
354
359
  pulumi.set(__self__, "webhook_type", webhook_type)
355
360
 
356
- @property
361
+ @_builtins.property
357
362
  @pulumi.getter
358
- def name(self) -> str:
363
+ def name(self) -> _builtins.str:
359
364
  return pulumi.get(self, "name")
360
365
 
361
- @property
366
+ @_builtins.property
362
367
  @pulumi.getter
363
- def url(self) -> str:
368
+ def url(self) -> _builtins.str:
364
369
  return pulumi.get(self, "url")
365
370
 
366
- @property
371
+ @_builtins.property
367
372
  @pulumi.getter
368
- def headers(self) -> Optional[Mapping[str, str]]:
373
+ def headers(self) -> Optional[Mapping[str, _builtins.str]]:
369
374
  return pulumi.get(self, "headers")
370
375
 
371
- @property
376
+ @_builtins.property
372
377
  @pulumi.getter
373
- def method(self) -> Optional[str]:
378
+ def method(self) -> Optional[_builtins.str]:
374
379
  """
375
380
  (Default `POST`)
376
381
  """
377
382
  return pulumi.get(self, "method")
378
383
 
379
- @property
384
+ @_builtins.property
380
385
  @pulumi.getter(name="queryParameters")
381
- def query_parameters(self) -> Optional[Mapping[str, str]]:
386
+ def query_parameters(self) -> Optional[Mapping[str, _builtins.str]]:
382
387
  return pulumi.get(self, "query_parameters")
383
388
 
384
- @property
389
+ @_builtins.property
385
390
  @pulumi.getter
386
- def template(self) -> Optional[str]:
391
+ def template(self) -> Optional[_builtins.str]:
387
392
  return pulumi.get(self, "template")
388
393
 
389
- @property
394
+ @_builtins.property
390
395
  @pulumi.getter(name="webhookSecret")
391
- def webhook_secret(self) -> Optional[str]:
396
+ def webhook_secret(self) -> Optional[_builtins.str]:
392
397
  return pulumi.get(self, "webhook_secret")
393
398
 
394
- @property
399
+ @_builtins.property
395
400
  @pulumi.getter(name="webhookType")
396
- def webhook_type(self) -> Optional[str]:
401
+ def webhook_type(self) -> Optional[_builtins.str]:
397
402
  """
398
403
  Type of the webhook. Possible values are 'WEBHOOK*DISCORD', 'WEBHOOK*FIREHYDRANT', 'WEBHOOK*GITLAB*ALERT', 'WEBHOOK*SPIKESH', 'WEBHOOK*SPLUNK', 'WEBHOOK*MSTEAMS' and 'WEBHOOK*TELEGRAM'.
399
404
  """
@@ -420,19 +425,19 @@ class CheckAlertChannelSubscription(dict):
420
425
  return super().get(key, default)
421
426
 
422
427
  def __init__(__self__, *,
423
- activated: bool,
424
- channel_id: int):
428
+ activated: _builtins.bool,
429
+ channel_id: _builtins.int):
425
430
  pulumi.set(__self__, "activated", activated)
426
431
  pulumi.set(__self__, "channel_id", channel_id)
427
432
 
428
- @property
433
+ @_builtins.property
429
434
  @pulumi.getter
430
- def activated(self) -> bool:
435
+ def activated(self) -> _builtins.bool:
431
436
  return pulumi.get(self, "activated")
432
437
 
433
- @property
438
+ @_builtins.property
434
439
  @pulumi.getter(name="channelId")
435
- def channel_id(self) -> int:
440
+ def channel_id(self) -> _builtins.int:
436
441
  return pulumi.get(self, "channel_id")
437
442
 
438
443
 
@@ -464,14 +469,14 @@ class CheckAlertSettings(dict):
464
469
  return super().get(key, default)
465
470
 
466
471
  def __init__(__self__, *,
467
- escalation_type: Optional[str] = None,
472
+ escalation_type: Optional[_builtins.str] = None,
468
473
  parallel_run_failure_thresholds: Optional[Sequence['outputs.CheckAlertSettingsParallelRunFailureThreshold']] = None,
469
474
  reminders: Optional[Sequence['outputs.CheckAlertSettingsReminder']] = None,
470
475
  run_based_escalations: Optional[Sequence['outputs.CheckAlertSettingsRunBasedEscalation']] = None,
471
476
  ssl_certificates: Optional[Sequence['outputs.CheckAlertSettingsSslCertificate']] = None,
472
477
  time_based_escalations: Optional[Sequence['outputs.CheckAlertSettingsTimeBasedEscalation']] = None):
473
478
  """
474
- :param str escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
479
+ :param _builtins.str escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
475
480
  """
476
481
  if escalation_type is not None:
477
482
  pulumi.set(__self__, "escalation_type", escalation_type)
@@ -486,36 +491,36 @@ class CheckAlertSettings(dict):
486
491
  if time_based_escalations is not None:
487
492
  pulumi.set(__self__, "time_based_escalations", time_based_escalations)
488
493
 
489
- @property
494
+ @_builtins.property
490
495
  @pulumi.getter(name="escalationType")
491
- def escalation_type(self) -> Optional[str]:
496
+ def escalation_type(self) -> Optional[_builtins.str]:
492
497
  """
493
498
  Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
494
499
  """
495
500
  return pulumi.get(self, "escalation_type")
496
501
 
497
- @property
502
+ @_builtins.property
498
503
  @pulumi.getter(name="parallelRunFailureThresholds")
499
504
  def parallel_run_failure_thresholds(self) -> Optional[Sequence['outputs.CheckAlertSettingsParallelRunFailureThreshold']]:
500
505
  return pulumi.get(self, "parallel_run_failure_thresholds")
501
506
 
502
- @property
507
+ @_builtins.property
503
508
  @pulumi.getter
504
509
  def reminders(self) -> Optional[Sequence['outputs.CheckAlertSettingsReminder']]:
505
510
  return pulumi.get(self, "reminders")
506
511
 
507
- @property
512
+ @_builtins.property
508
513
  @pulumi.getter(name="runBasedEscalations")
509
514
  def run_based_escalations(self) -> Optional[Sequence['outputs.CheckAlertSettingsRunBasedEscalation']]:
510
515
  return pulumi.get(self, "run_based_escalations")
511
516
 
512
- @property
517
+ @_builtins.property
513
518
  @pulumi.getter(name="sslCertificates")
514
519
  @_utilities.deprecated("""This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""")
515
520
  def ssl_certificates(self) -> Optional[Sequence['outputs.CheckAlertSettingsSslCertificate']]:
516
521
  return pulumi.get(self, "ssl_certificates")
517
522
 
518
- @property
523
+ @_builtins.property
519
524
  @pulumi.getter(name="timeBasedEscalations")
520
525
  def time_based_escalations(self) -> Optional[Sequence['outputs.CheckAlertSettingsTimeBasedEscalation']]:
521
526
  return pulumi.get(self, "time_based_escalations")
@@ -524,28 +529,28 @@ class CheckAlertSettings(dict):
524
529
  @pulumi.output_type
525
530
  class CheckAlertSettingsParallelRunFailureThreshold(dict):
526
531
  def __init__(__self__, *,
527
- enabled: Optional[bool] = None,
528
- percentage: Optional[int] = None):
532
+ enabled: Optional[_builtins.bool] = None,
533
+ percentage: Optional[_builtins.int] = None):
529
534
  """
530
- :param bool enabled: Applicable only for checks scheduled in parallel in multiple locations.
531
- :param int percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
535
+ :param _builtins.bool enabled: Applicable only for checks scheduled in parallel in multiple locations.
536
+ :param _builtins.int percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
532
537
  """
533
538
  if enabled is not None:
534
539
  pulumi.set(__self__, "enabled", enabled)
535
540
  if percentage is not None:
536
541
  pulumi.set(__self__, "percentage", percentage)
537
542
 
538
- @property
543
+ @_builtins.property
539
544
  @pulumi.getter
540
- def enabled(self) -> Optional[bool]:
545
+ def enabled(self) -> Optional[_builtins.bool]:
541
546
  """
542
547
  Applicable only for checks scheduled in parallel in multiple locations.
543
548
  """
544
549
  return pulumi.get(self, "enabled")
545
550
 
546
- @property
551
+ @_builtins.property
547
552
  @pulumi.getter
548
- def percentage(self) -> Optional[int]:
553
+ def percentage(self) -> Optional[_builtins.int]:
549
554
  """
550
555
  Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
551
556
  """
@@ -555,28 +560,28 @@ class CheckAlertSettingsParallelRunFailureThreshold(dict):
555
560
  @pulumi.output_type
556
561
  class CheckAlertSettingsReminder(dict):
557
562
  def __init__(__self__, *,
558
- amount: Optional[int] = None,
559
- interval: Optional[int] = None):
563
+ amount: Optional[_builtins.int] = None,
564
+ interval: Optional[_builtins.int] = None):
560
565
  """
561
- :param int amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
562
- :param int interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
566
+ :param _builtins.int amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
567
+ :param _builtins.int interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
563
568
  """
564
569
  if amount is not None:
565
570
  pulumi.set(__self__, "amount", amount)
566
571
  if interval is not None:
567
572
  pulumi.set(__self__, "interval", interval)
568
573
 
569
- @property
574
+ @_builtins.property
570
575
  @pulumi.getter
571
- def amount(self) -> Optional[int]:
576
+ def amount(self) -> Optional[_builtins.int]:
572
577
  """
573
578
  How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
574
579
  """
575
580
  return pulumi.get(self, "amount")
576
581
 
577
- @property
582
+ @_builtins.property
578
583
  @pulumi.getter
579
- def interval(self) -> Optional[int]:
584
+ def interval(self) -> Optional[_builtins.int]:
580
585
  """
581
586
  Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
582
587
  """
@@ -603,16 +608,16 @@ class CheckAlertSettingsRunBasedEscalation(dict):
603
608
  return super().get(key, default)
604
609
 
605
610
  def __init__(__self__, *,
606
- failed_run_threshold: Optional[int] = None):
611
+ failed_run_threshold: Optional[_builtins.int] = None):
607
612
  """
608
- :param 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`).
613
+ :param _builtins.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`).
609
614
  """
610
615
  if failed_run_threshold is not None:
611
616
  pulumi.set(__self__, "failed_run_threshold", failed_run_threshold)
612
617
 
613
- @property
618
+ @_builtins.property
614
619
  @pulumi.getter(name="failedRunThreshold")
615
- def failed_run_threshold(self) -> Optional[int]:
620
+ def failed_run_threshold(self) -> Optional[_builtins.int]:
616
621
  """
617
622
  After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
618
623
  """
@@ -639,28 +644,28 @@ class CheckAlertSettingsSslCertificate(dict):
639
644
  return super().get(key, default)
640
645
 
641
646
  def __init__(__self__, *,
642
- alert_threshold: Optional[int] = None,
643
- enabled: Optional[bool] = None):
647
+ alert_threshold: Optional[_builtins.int] = None,
648
+ enabled: Optional[_builtins.bool] = None):
644
649
  """
645
- :param int alert_threshold: How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
646
- :param bool enabled: Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
650
+ :param _builtins.int alert_threshold: How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
651
+ :param _builtins.bool enabled: Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
647
652
  """
648
653
  if alert_threshold is not None:
649
654
  pulumi.set(__self__, "alert_threshold", alert_threshold)
650
655
  if enabled is not None:
651
656
  pulumi.set(__self__, "enabled", enabled)
652
657
 
653
- @property
658
+ @_builtins.property
654
659
  @pulumi.getter(name="alertThreshold")
655
- def alert_threshold(self) -> Optional[int]:
660
+ def alert_threshold(self) -> Optional[_builtins.int]:
656
661
  """
657
662
  How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
658
663
  """
659
664
  return pulumi.get(self, "alert_threshold")
660
665
 
661
- @property
666
+ @_builtins.property
662
667
  @pulumi.getter
663
- def enabled(self) -> Optional[bool]:
668
+ def enabled(self) -> Optional[_builtins.bool]:
664
669
  """
665
670
  Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
666
671
  """
@@ -687,16 +692,16 @@ class CheckAlertSettingsTimeBasedEscalation(dict):
687
692
  return super().get(key, default)
688
693
 
689
694
  def __init__(__self__, *,
690
- minutes_failing_threshold: Optional[int] = None):
695
+ minutes_failing_threshold: Optional[_builtins.int] = None):
691
696
  """
692
- :param 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`).
697
+ :param _builtins.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`).
693
698
  """
694
699
  if minutes_failing_threshold is not None:
695
700
  pulumi.set(__self__, "minutes_failing_threshold", minutes_failing_threshold)
696
701
 
697
- @property
702
+ @_builtins.property
698
703
  @pulumi.getter(name="minutesFailingThreshold")
699
- def minutes_failing_threshold(self) -> Optional[int]:
704
+ def minutes_failing_threshold(self) -> Optional[_builtins.int]:
700
705
  """
701
706
  After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
702
707
  """
@@ -706,10 +711,10 @@ class CheckAlertSettingsTimeBasedEscalation(dict):
706
711
  @pulumi.output_type
707
712
  class CheckEnvironmentVariable(dict):
708
713
  def __init__(__self__, *,
709
- key: str,
710
- value: str,
711
- locked: Optional[bool] = None,
712
- secret: Optional[bool] = None):
714
+ key: _builtins.str,
715
+ value: _builtins.str,
716
+ locked: Optional[_builtins.bool] = None,
717
+ secret: Optional[_builtins.bool] = None):
713
718
  pulumi.set(__self__, "key", key)
714
719
  pulumi.set(__self__, "value", value)
715
720
  if locked is not None:
@@ -717,24 +722,24 @@ class CheckEnvironmentVariable(dict):
717
722
  if secret is not None:
718
723
  pulumi.set(__self__, "secret", secret)
719
724
 
720
- @property
725
+ @_builtins.property
721
726
  @pulumi.getter
722
- def key(self) -> str:
727
+ def key(self) -> _builtins.str:
723
728
  return pulumi.get(self, "key")
724
729
 
725
- @property
730
+ @_builtins.property
726
731
  @pulumi.getter
727
- def value(self) -> str:
732
+ def value(self) -> _builtins.str:
728
733
  return pulumi.get(self, "value")
729
734
 
730
- @property
735
+ @_builtins.property
731
736
  @pulumi.getter
732
- def locked(self) -> Optional[bool]:
737
+ def locked(self) -> Optional[_builtins.bool]:
733
738
  return pulumi.get(self, "locked")
734
739
 
735
- @property
740
+ @_builtins.property
736
741
  @pulumi.getter
737
- def secret(self) -> Optional[bool]:
742
+ def secret(self) -> Optional[_builtins.bool]:
738
743
  return pulumi.get(self, "secret")
739
744
 
740
745
 
@@ -758,19 +763,19 @@ class CheckGroupAlertChannelSubscription(dict):
758
763
  return super().get(key, default)
759
764
 
760
765
  def __init__(__self__, *,
761
- activated: bool,
762
- channel_id: int):
766
+ activated: _builtins.bool,
767
+ channel_id: _builtins.int):
763
768
  pulumi.set(__self__, "activated", activated)
764
769
  pulumi.set(__self__, "channel_id", channel_id)
765
770
 
766
- @property
771
+ @_builtins.property
767
772
  @pulumi.getter
768
- def activated(self) -> bool:
773
+ def activated(self) -> _builtins.bool:
769
774
  return pulumi.get(self, "activated")
770
775
 
771
- @property
776
+ @_builtins.property
772
777
  @pulumi.getter(name="channelId")
773
- def channel_id(self) -> int:
778
+ def channel_id(self) -> _builtins.int:
774
779
  return pulumi.get(self, "channel_id")
775
780
 
776
781
 
@@ -802,14 +807,14 @@ class CheckGroupAlertSettings(dict):
802
807
  return super().get(key, default)
803
808
 
804
809
  def __init__(__self__, *,
805
- escalation_type: Optional[str] = None,
810
+ escalation_type: Optional[_builtins.str] = None,
806
811
  parallel_run_failure_thresholds: Optional[Sequence['outputs.CheckGroupAlertSettingsParallelRunFailureThreshold']] = None,
807
812
  reminders: Optional[Sequence['outputs.CheckGroupAlertSettingsReminder']] = None,
808
813
  run_based_escalations: Optional[Sequence['outputs.CheckGroupAlertSettingsRunBasedEscalation']] = None,
809
814
  ssl_certificates: Optional[Sequence['outputs.CheckGroupAlertSettingsSslCertificate']] = None,
810
815
  time_based_escalations: Optional[Sequence['outputs.CheckGroupAlertSettingsTimeBasedEscalation']] = None):
811
816
  """
812
- :param str escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
817
+ :param _builtins.str escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
813
818
  """
814
819
  if escalation_type is not None:
815
820
  pulumi.set(__self__, "escalation_type", escalation_type)
@@ -824,36 +829,36 @@ class CheckGroupAlertSettings(dict):
824
829
  if time_based_escalations is not None:
825
830
  pulumi.set(__self__, "time_based_escalations", time_based_escalations)
826
831
 
827
- @property
832
+ @_builtins.property
828
833
  @pulumi.getter(name="escalationType")
829
- def escalation_type(self) -> Optional[str]:
834
+ def escalation_type(self) -> Optional[_builtins.str]:
830
835
  """
831
836
  Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
832
837
  """
833
838
  return pulumi.get(self, "escalation_type")
834
839
 
835
- @property
840
+ @_builtins.property
836
841
  @pulumi.getter(name="parallelRunFailureThresholds")
837
842
  def parallel_run_failure_thresholds(self) -> Optional[Sequence['outputs.CheckGroupAlertSettingsParallelRunFailureThreshold']]:
838
843
  return pulumi.get(self, "parallel_run_failure_thresholds")
839
844
 
840
- @property
845
+ @_builtins.property
841
846
  @pulumi.getter
842
847
  def reminders(self) -> Optional[Sequence['outputs.CheckGroupAlertSettingsReminder']]:
843
848
  return pulumi.get(self, "reminders")
844
849
 
845
- @property
850
+ @_builtins.property
846
851
  @pulumi.getter(name="runBasedEscalations")
847
852
  def run_based_escalations(self) -> Optional[Sequence['outputs.CheckGroupAlertSettingsRunBasedEscalation']]:
848
853
  return pulumi.get(self, "run_based_escalations")
849
854
 
850
- @property
855
+ @_builtins.property
851
856
  @pulumi.getter(name="sslCertificates")
852
857
  @_utilities.deprecated("""This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""")
853
858
  def ssl_certificates(self) -> Optional[Sequence['outputs.CheckGroupAlertSettingsSslCertificate']]:
854
859
  return pulumi.get(self, "ssl_certificates")
855
860
 
856
- @property
861
+ @_builtins.property
857
862
  @pulumi.getter(name="timeBasedEscalations")
858
863
  def time_based_escalations(self) -> Optional[Sequence['outputs.CheckGroupAlertSettingsTimeBasedEscalation']]:
859
864
  return pulumi.get(self, "time_based_escalations")
@@ -862,28 +867,28 @@ class CheckGroupAlertSettings(dict):
862
867
  @pulumi.output_type
863
868
  class CheckGroupAlertSettingsParallelRunFailureThreshold(dict):
864
869
  def __init__(__self__, *,
865
- enabled: Optional[bool] = None,
866
- percentage: Optional[int] = None):
870
+ enabled: Optional[_builtins.bool] = None,
871
+ percentage: Optional[_builtins.int] = None):
867
872
  """
868
- :param bool enabled: Applicable only for checks scheduled in parallel in multiple locations.
869
- :param int percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
873
+ :param _builtins.bool enabled: Applicable only for checks scheduled in parallel in multiple locations.
874
+ :param _builtins.int percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
870
875
  """
871
876
  if enabled is not None:
872
877
  pulumi.set(__self__, "enabled", enabled)
873
878
  if percentage is not None:
874
879
  pulumi.set(__self__, "percentage", percentage)
875
880
 
876
- @property
881
+ @_builtins.property
877
882
  @pulumi.getter
878
- def enabled(self) -> Optional[bool]:
883
+ def enabled(self) -> Optional[_builtins.bool]:
879
884
  """
880
885
  Applicable only for checks scheduled in parallel in multiple locations.
881
886
  """
882
887
  return pulumi.get(self, "enabled")
883
888
 
884
- @property
889
+ @_builtins.property
885
890
  @pulumi.getter
886
- def percentage(self) -> Optional[int]:
891
+ def percentage(self) -> Optional[_builtins.int]:
887
892
  """
888
893
  Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
889
894
  """
@@ -893,28 +898,28 @@ class CheckGroupAlertSettingsParallelRunFailureThreshold(dict):
893
898
  @pulumi.output_type
894
899
  class CheckGroupAlertSettingsReminder(dict):
895
900
  def __init__(__self__, *,
896
- amount: Optional[int] = None,
897
- interval: Optional[int] = None):
901
+ amount: Optional[_builtins.int] = None,
902
+ interval: Optional[_builtins.int] = None):
898
903
  """
899
- :param int amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
900
- :param int interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
904
+ :param _builtins.int amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
905
+ :param _builtins.int interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
901
906
  """
902
907
  if amount is not None:
903
908
  pulumi.set(__self__, "amount", amount)
904
909
  if interval is not None:
905
910
  pulumi.set(__self__, "interval", interval)
906
911
 
907
- @property
912
+ @_builtins.property
908
913
  @pulumi.getter
909
- def amount(self) -> Optional[int]:
914
+ def amount(self) -> Optional[_builtins.int]:
910
915
  """
911
916
  How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
912
917
  """
913
918
  return pulumi.get(self, "amount")
914
919
 
915
- @property
920
+ @_builtins.property
916
921
  @pulumi.getter
917
- def interval(self) -> Optional[int]:
922
+ def interval(self) -> Optional[_builtins.int]:
918
923
  """
919
924
  Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
920
925
  """
@@ -941,16 +946,16 @@ class CheckGroupAlertSettingsRunBasedEscalation(dict):
941
946
  return super().get(key, default)
942
947
 
943
948
  def __init__(__self__, *,
944
- failed_run_threshold: Optional[int] = None):
949
+ failed_run_threshold: Optional[_builtins.int] = None):
945
950
  """
946
- :param 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`).
951
+ :param _builtins.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`).
947
952
  """
948
953
  if failed_run_threshold is not None:
949
954
  pulumi.set(__self__, "failed_run_threshold", failed_run_threshold)
950
955
 
951
- @property
956
+ @_builtins.property
952
957
  @pulumi.getter(name="failedRunThreshold")
953
- def failed_run_threshold(self) -> Optional[int]:
958
+ def failed_run_threshold(self) -> Optional[_builtins.int]:
954
959
  """
955
960
  After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
956
961
  """
@@ -977,28 +982,28 @@ class CheckGroupAlertSettingsSslCertificate(dict):
977
982
  return super().get(key, default)
978
983
 
979
984
  def __init__(__self__, *,
980
- alert_threshold: Optional[int] = None,
981
- enabled: Optional[bool] = None):
985
+ alert_threshold: Optional[_builtins.int] = None,
986
+ enabled: Optional[_builtins.bool] = None):
982
987
  """
983
- :param int alert_threshold: At what moment in time to start alerting on SSL certificates. Possible values `3`, `7`, `14`, `30`. (Default `3`).
984
- :param bool enabled: Determines if alert notifications should be sent for expiring SSL certificates.
988
+ :param _builtins.int alert_threshold: At what moment in time to start alerting on SSL certificates. Possible values `3`, `7`, `14`, `30`. (Default `3`).
989
+ :param _builtins.bool enabled: Determines if alert notifications should be sent for expiring SSL certificates.
985
990
  """
986
991
  if alert_threshold is not None:
987
992
  pulumi.set(__self__, "alert_threshold", alert_threshold)
988
993
  if enabled is not None:
989
994
  pulumi.set(__self__, "enabled", enabled)
990
995
 
991
- @property
996
+ @_builtins.property
992
997
  @pulumi.getter(name="alertThreshold")
993
- def alert_threshold(self) -> Optional[int]:
998
+ def alert_threshold(self) -> Optional[_builtins.int]:
994
999
  """
995
1000
  At what moment in time to start alerting on SSL certificates. Possible values `3`, `7`, `14`, `30`. (Default `3`).
996
1001
  """
997
1002
  return pulumi.get(self, "alert_threshold")
998
1003
 
999
- @property
1004
+ @_builtins.property
1000
1005
  @pulumi.getter
1001
- def enabled(self) -> Optional[bool]:
1006
+ def enabled(self) -> Optional[_builtins.bool]:
1002
1007
  """
1003
1008
  Determines if alert notifications should be sent for expiring SSL certificates.
1004
1009
  """
@@ -1025,16 +1030,16 @@ class CheckGroupAlertSettingsTimeBasedEscalation(dict):
1025
1030
  return super().get(key, default)
1026
1031
 
1027
1032
  def __init__(__self__, *,
1028
- minutes_failing_threshold: Optional[int] = None):
1033
+ minutes_failing_threshold: Optional[_builtins.int] = None):
1029
1034
  """
1030
- :param 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`).
1035
+ :param _builtins.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`).
1031
1036
  """
1032
1037
  if minutes_failing_threshold is not None:
1033
1038
  pulumi.set(__self__, "minutes_failing_threshold", minutes_failing_threshold)
1034
1039
 
1035
- @property
1040
+ @_builtins.property
1036
1041
  @pulumi.getter(name="minutesFailingThreshold")
1037
- def minutes_failing_threshold(self) -> Optional[int]:
1042
+ def minutes_failing_threshold(self) -> Optional[_builtins.int]:
1038
1043
  """
1039
1044
  After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
1040
1045
  """
@@ -1065,11 +1070,11 @@ class CheckGroupApiCheckDefaults(dict):
1065
1070
  def __init__(__self__, *,
1066
1071
  assertions: Optional[Sequence['outputs.CheckGroupApiCheckDefaultsAssertion']] = None,
1067
1072
  basic_auth: Optional['outputs.CheckGroupApiCheckDefaultsBasicAuth'] = None,
1068
- headers: Optional[Mapping[str, str]] = None,
1069
- query_parameters: Optional[Mapping[str, str]] = None,
1070
- url: Optional[str] = None):
1073
+ headers: Optional[Mapping[str, _builtins.str]] = None,
1074
+ query_parameters: Optional[Mapping[str, _builtins.str]] = None,
1075
+ url: Optional[_builtins.str] = None):
1071
1076
  """
1072
- :param str url: The base url for this group which you can reference with the `GROUP_BASE_URL` variable in all group checks.
1077
+ :param _builtins.str url: The base url for this group which you can reference with the `GROUP_BASE_URL` variable in all group checks.
1073
1078
  """
1074
1079
  if assertions is not None:
1075
1080
  pulumi.set(__self__, "assertions", assertions)
@@ -1084,29 +1089,29 @@ class CheckGroupApiCheckDefaults(dict):
1084
1089
  if url is not None:
1085
1090
  pulumi.set(__self__, "url", url)
1086
1091
 
1087
- @property
1092
+ @_builtins.property
1088
1093
  @pulumi.getter
1089
1094
  def assertions(self) -> Optional[Sequence['outputs.CheckGroupApiCheckDefaultsAssertion']]:
1090
1095
  return pulumi.get(self, "assertions")
1091
1096
 
1092
- @property
1097
+ @_builtins.property
1093
1098
  @pulumi.getter(name="basicAuth")
1094
1099
  def basic_auth(self) -> Optional['outputs.CheckGroupApiCheckDefaultsBasicAuth']:
1095
1100
  return pulumi.get(self, "basic_auth")
1096
1101
 
1097
- @property
1102
+ @_builtins.property
1098
1103
  @pulumi.getter
1099
- def headers(self) -> Optional[Mapping[str, str]]:
1104
+ def headers(self) -> Optional[Mapping[str, _builtins.str]]:
1100
1105
  return pulumi.get(self, "headers")
1101
1106
 
1102
- @property
1107
+ @_builtins.property
1103
1108
  @pulumi.getter(name="queryParameters")
1104
- def query_parameters(self) -> Optional[Mapping[str, str]]:
1109
+ def query_parameters(self) -> Optional[Mapping[str, _builtins.str]]:
1105
1110
  return pulumi.get(self, "query_parameters")
1106
1111
 
1107
- @property
1112
+ @_builtins.property
1108
1113
  @pulumi.getter
1109
- def url(self) -> Optional[str]:
1114
+ def url(self) -> Optional[_builtins.str]:
1110
1115
  """
1111
1116
  The base url for this group which you can reference with the `GROUP_BASE_URL` variable in all group checks.
1112
1117
  """
@@ -1116,13 +1121,13 @@ class CheckGroupApiCheckDefaults(dict):
1116
1121
  @pulumi.output_type
1117
1122
  class CheckGroupApiCheckDefaultsAssertion(dict):
1118
1123
  def __init__(__self__, *,
1119
- comparison: str,
1120
- source: str,
1121
- target: str,
1122
- property: Optional[str] = None):
1124
+ comparison: _builtins.str,
1125
+ source: _builtins.str,
1126
+ target: _builtins.str,
1127
+ property: Optional[_builtins.str] = None):
1123
1128
  """
1124
- :param 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`.
1125
- :param str source: The source of the asserted value. Possible values `STATUS_CODE`, `JSON_BODY`, `HEADERS`, `TEXT_BODY`, and `RESPONSE_TIME`.
1129
+ :param _builtins.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`.
1130
+ :param _builtins.str source: The source of the asserted value. Possible values `STATUS_CODE`, `JSON_BODY`, `HEADERS`, `TEXT_BODY`, and `RESPONSE_TIME`.
1126
1131
  """
1127
1132
  pulumi.set(__self__, "comparison", comparison)
1128
1133
  pulumi.set(__self__, "source", source)
@@ -1130,59 +1135,59 @@ class CheckGroupApiCheckDefaultsAssertion(dict):
1130
1135
  if property is not None:
1131
1136
  pulumi.set(__self__, "property", property)
1132
1137
 
1133
- @property
1138
+ @_builtins.property
1134
1139
  @pulumi.getter
1135
- def comparison(self) -> str:
1140
+ def comparison(self) -> _builtins.str:
1136
1141
  """
1137
1142
  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`.
1138
1143
  """
1139
1144
  return pulumi.get(self, "comparison")
1140
1145
 
1141
- @property
1146
+ @_builtins.property
1142
1147
  @pulumi.getter
1143
- def source(self) -> str:
1148
+ def source(self) -> _builtins.str:
1144
1149
  """
1145
1150
  The source of the asserted value. Possible values `STATUS_CODE`, `JSON_BODY`, `HEADERS`, `TEXT_BODY`, and `RESPONSE_TIME`.
1146
1151
  """
1147
1152
  return pulumi.get(self, "source")
1148
1153
 
1149
- @property
1154
+ @_builtins.property
1150
1155
  @pulumi.getter
1151
- def target(self) -> str:
1156
+ def target(self) -> _builtins.str:
1152
1157
  return pulumi.get(self, "target")
1153
1158
 
1154
- @property
1159
+ @_builtins.property
1155
1160
  @pulumi.getter
1156
- def property(self) -> Optional[str]:
1161
+ def property(self) -> Optional[_builtins.str]:
1157
1162
  return pulumi.get(self, "property")
1158
1163
 
1159
1164
 
1160
1165
  @pulumi.output_type
1161
1166
  class CheckGroupApiCheckDefaultsBasicAuth(dict):
1162
1167
  def __init__(__self__, *,
1163
- password: str,
1164
- username: str):
1168
+ password: _builtins.str,
1169
+ username: _builtins.str):
1165
1170
  pulumi.set(__self__, "password", password)
1166
1171
  pulumi.set(__self__, "username", username)
1167
1172
 
1168
- @property
1173
+ @_builtins.property
1169
1174
  @pulumi.getter
1170
- def password(self) -> str:
1175
+ def password(self) -> _builtins.str:
1171
1176
  return pulumi.get(self, "password")
1172
1177
 
1173
- @property
1178
+ @_builtins.property
1174
1179
  @pulumi.getter
1175
- def username(self) -> str:
1180
+ def username(self) -> _builtins.str:
1176
1181
  return pulumi.get(self, "username")
1177
1182
 
1178
1183
 
1179
1184
  @pulumi.output_type
1180
1185
  class CheckGroupEnvironmentVariable(dict):
1181
1186
  def __init__(__self__, *,
1182
- key: str,
1183
- value: str,
1184
- locked: Optional[bool] = None,
1185
- secret: Optional[bool] = None):
1187
+ key: _builtins.str,
1188
+ value: _builtins.str,
1189
+ locked: Optional[_builtins.bool] = None,
1190
+ secret: Optional[_builtins.bool] = None):
1186
1191
  pulumi.set(__self__, "key", key)
1187
1192
  pulumi.set(__self__, "value", value)
1188
1193
  if locked is not None:
@@ -1190,24 +1195,24 @@ class CheckGroupEnvironmentVariable(dict):
1190
1195
  if secret is not None:
1191
1196
  pulumi.set(__self__, "secret", secret)
1192
1197
 
1193
- @property
1198
+ @_builtins.property
1194
1199
  @pulumi.getter
1195
- def key(self) -> str:
1200
+ def key(self) -> _builtins.str:
1196
1201
  return pulumi.get(self, "key")
1197
1202
 
1198
- @property
1203
+ @_builtins.property
1199
1204
  @pulumi.getter
1200
- def value(self) -> str:
1205
+ def value(self) -> _builtins.str:
1201
1206
  return pulumi.get(self, "value")
1202
1207
 
1203
- @property
1208
+ @_builtins.property
1204
1209
  @pulumi.getter
1205
- def locked(self) -> Optional[bool]:
1210
+ def locked(self) -> Optional[_builtins.bool]:
1206
1211
  return pulumi.get(self, "locked")
1207
1212
 
1208
- @property
1213
+ @_builtins.property
1209
1214
  @pulumi.getter
1210
- def secret(self) -> Optional[bool]:
1215
+ def secret(self) -> Optional[_builtins.bool]:
1211
1216
  return pulumi.get(self, "secret")
1212
1217
 
1213
1218
 
@@ -1222,6 +1227,8 @@ class CheckGroupRetryStrategy(dict):
1222
1227
  suggest = "max_duration_seconds"
1223
1228
  elif key == "maxRetries":
1224
1229
  suggest = "max_retries"
1230
+ elif key == "onlyOn":
1231
+ suggest = "only_on"
1225
1232
  elif key == "sameRegion":
1226
1233
  suggest = "same_region"
1227
1234
 
@@ -1237,17 +1244,19 @@ class CheckGroupRetryStrategy(dict):
1237
1244
  return super().get(key, default)
1238
1245
 
1239
1246
  def __init__(__self__, *,
1240
- type: str,
1241
- base_backoff_seconds: Optional[int] = None,
1242
- max_duration_seconds: Optional[int] = None,
1243
- max_retries: Optional[int] = None,
1244
- same_region: Optional[bool] = None):
1245
- """
1246
- :param str type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
1247
- :param int base_backoff_seconds: The number of seconds to wait before the first retry attempt.
1248
- :param int max_duration_seconds: The total amount of time to continue retrying the check (maximum 600 seconds).
1249
- :param int max_retries: The maximum number of times to retry the check. Value must be between 1 and 10.
1250
- :param bool same_region: Whether retries should be run in the same region as the initial check run.
1247
+ type: _builtins.str,
1248
+ base_backoff_seconds: Optional[_builtins.int] = None,
1249
+ max_duration_seconds: Optional[_builtins.int] = None,
1250
+ max_retries: Optional[_builtins.int] = None,
1251
+ only_on: Optional['outputs.CheckGroupRetryStrategyOnlyOn'] = None,
1252
+ same_region: Optional[_builtins.bool] = None):
1253
+ """
1254
+ :param _builtins.str type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, `EXPONENTIAL`, `SINGLE_RETRY`, and `NO_RETRIES`.
1255
+ :param _builtins.int base_backoff_seconds: The number of seconds to wait before the first retry attempt. (Default `60`).
1256
+ :param _builtins.int max_duration_seconds: The total amount of time to continue retrying the check/monitor (maximum 600 seconds). Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `600`).
1257
+ :param _builtins.int max_retries: The maximum number of times to retry the check/monitor. Value must be between `1` and `10`. Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `2`).
1258
+ :param 'CheckGroupRetryStrategyOnlyOnArgs' only_on: Apply the retry strategy only if the defined conditions match.
1259
+ :param _builtins.bool same_region: Whether retries should be run in the same region as the initial check/monitor run. (Default `true`).
1251
1260
  """
1252
1261
  pulumi.set(__self__, "type", type)
1253
1262
  if base_backoff_seconds is not None:
@@ -1256,50 +1265,96 @@ class CheckGroupRetryStrategy(dict):
1256
1265
  pulumi.set(__self__, "max_duration_seconds", max_duration_seconds)
1257
1266
  if max_retries is not None:
1258
1267
  pulumi.set(__self__, "max_retries", max_retries)
1268
+ if only_on is not None:
1269
+ pulumi.set(__self__, "only_on", only_on)
1259
1270
  if same_region is not None:
1260
1271
  pulumi.set(__self__, "same_region", same_region)
1261
1272
 
1262
- @property
1273
+ @_builtins.property
1263
1274
  @pulumi.getter
1264
- def type(self) -> str:
1275
+ def type(self) -> _builtins.str:
1265
1276
  """
1266
- Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
1277
+ Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, `EXPONENTIAL`, `SINGLE_RETRY`, and `NO_RETRIES`.
1267
1278
  """
1268
1279
  return pulumi.get(self, "type")
1269
1280
 
1270
- @property
1281
+ @_builtins.property
1271
1282
  @pulumi.getter(name="baseBackoffSeconds")
1272
- def base_backoff_seconds(self) -> Optional[int]:
1283
+ def base_backoff_seconds(self) -> Optional[_builtins.int]:
1273
1284
  """
1274
- The number of seconds to wait before the first retry attempt.
1285
+ The number of seconds to wait before the first retry attempt. (Default `60`).
1275
1286
  """
1276
1287
  return pulumi.get(self, "base_backoff_seconds")
1277
1288
 
1278
- @property
1289
+ @_builtins.property
1279
1290
  @pulumi.getter(name="maxDurationSeconds")
1280
- def max_duration_seconds(self) -> Optional[int]:
1291
+ def max_duration_seconds(self) -> Optional[_builtins.int]:
1281
1292
  """
1282
- The total amount of time to continue retrying the check (maximum 600 seconds).
1293
+ The total amount of time to continue retrying the check/monitor (maximum 600 seconds). Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `600`).
1283
1294
  """
1284
1295
  return pulumi.get(self, "max_duration_seconds")
1285
1296
 
1286
- @property
1297
+ @_builtins.property
1287
1298
  @pulumi.getter(name="maxRetries")
1288
- def max_retries(self) -> Optional[int]:
1299
+ def max_retries(self) -> Optional[_builtins.int]:
1289
1300
  """
1290
- The maximum number of times to retry the check. Value must be between 1 and 10.
1301
+ The maximum number of times to retry the check/monitor. Value must be between `1` and `10`. Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `2`).
1291
1302
  """
1292
1303
  return pulumi.get(self, "max_retries")
1293
1304
 
1294
- @property
1305
+ @_builtins.property
1306
+ @pulumi.getter(name="onlyOn")
1307
+ def only_on(self) -> Optional['outputs.CheckGroupRetryStrategyOnlyOn']:
1308
+ """
1309
+ Apply the retry strategy only if the defined conditions match.
1310
+ """
1311
+ return pulumi.get(self, "only_on")
1312
+
1313
+ @_builtins.property
1295
1314
  @pulumi.getter(name="sameRegion")
1296
- def same_region(self) -> Optional[bool]:
1315
+ def same_region(self) -> Optional[_builtins.bool]:
1297
1316
  """
1298
- Whether retries should be run in the same region as the initial check run.
1317
+ Whether retries should be run in the same region as the initial check/monitor run. (Default `true`).
1299
1318
  """
1300
1319
  return pulumi.get(self, "same_region")
1301
1320
 
1302
1321
 
1322
+ @pulumi.output_type
1323
+ class CheckGroupRetryStrategyOnlyOn(dict):
1324
+ @staticmethod
1325
+ def __key_warning(key: str):
1326
+ suggest = None
1327
+ if key == "networkError":
1328
+ suggest = "network_error"
1329
+
1330
+ if suggest:
1331
+ pulumi.log.warn(f"Key '{key}' not found in CheckGroupRetryStrategyOnlyOn. Access the value via the '{suggest}' property getter instead.")
1332
+
1333
+ def __getitem__(self, key: str) -> Any:
1334
+ CheckGroupRetryStrategyOnlyOn.__key_warning(key)
1335
+ return super().__getitem__(key)
1336
+
1337
+ def get(self, key: str, default = None) -> Any:
1338
+ CheckGroupRetryStrategyOnlyOn.__key_warning(key)
1339
+ return super().get(key, default)
1340
+
1341
+ def __init__(__self__, *,
1342
+ network_error: Optional[_builtins.bool] = None):
1343
+ """
1344
+ :param _builtins.bool network_error: When `true`, retry only if the cause of the failure is a network error. (Default `false`).
1345
+ """
1346
+ if network_error is not None:
1347
+ pulumi.set(__self__, "network_error", network_error)
1348
+
1349
+ @_builtins.property
1350
+ @pulumi.getter(name="networkError")
1351
+ def network_error(self) -> Optional[_builtins.bool]:
1352
+ """
1353
+ When `true`, retry only if the cause of the failure is a network error. (Default `false`).
1354
+ """
1355
+ return pulumi.get(self, "network_error")
1356
+
1357
+
1303
1358
  @pulumi.output_type
1304
1359
  class CheckRequest(dict):
1305
1360
  @staticmethod
@@ -1330,24 +1385,24 @@ class CheckRequest(dict):
1330
1385
  return super().get(key, default)
1331
1386
 
1332
1387
  def __init__(__self__, *,
1333
- url: str,
1388
+ url: _builtins.str,
1334
1389
  assertions: Optional[Sequence['outputs.CheckRequestAssertion']] = None,
1335
1390
  basic_auth: Optional['outputs.CheckRequestBasicAuth'] = None,
1336
- body: Optional[str] = None,
1337
- body_type: Optional[str] = None,
1338
- follow_redirects: Optional[bool] = None,
1339
- headers: Optional[Mapping[str, str]] = None,
1340
- ip_family: Optional[str] = None,
1341
- method: Optional[str] = None,
1342
- query_parameters: Optional[Mapping[str, str]] = None,
1343
- skip_ssl: Optional[bool] = None):
1391
+ body: Optional[_builtins.str] = None,
1392
+ body_type: Optional[_builtins.str] = None,
1393
+ follow_redirects: Optional[_builtins.bool] = None,
1394
+ headers: Optional[Mapping[str, _builtins.str]] = None,
1395
+ ip_family: Optional[_builtins.str] = None,
1396
+ method: Optional[_builtins.str] = None,
1397
+ query_parameters: Optional[Mapping[str, _builtins.str]] = None,
1398
+ skip_ssl: Optional[_builtins.bool] = None):
1344
1399
  """
1345
1400
  :param Sequence['CheckRequestAssertionArgs'] assertions: A request can have multiple assertions.
1346
1401
  :param 'CheckRequestBasicAuthArgs' basic_auth: Set up HTTP basic authentication (username & password).
1347
- :param str body: The body of the request.
1348
- :param str body_type: The `Content-Type` header of the request. Possible values `NONE`, `JSON`, `FORM`, `RAW`, and `GRAPHQL`.
1349
- :param str ip_family: IP Family to be used when executing the api check. The value can be either IPv4 or IPv6.
1350
- :param str method: The HTTP method to use for this API check. Possible values are `GET`, `POST`, `PUT`, `HEAD`, `DELETE`, `PATCH`. (Default `GET`).
1402
+ :param _builtins.str body: The body of the request.
1403
+ :param _builtins.str body_type: The `Content-Type` header of the request. Possible values `NONE`, `JSON`, `FORM`, `RAW`, and `GRAPHQL`.
1404
+ :param _builtins.str ip_family: IP Family to be used when executing the api check. The value can be either IPv4 or IPv6.
1405
+ :param _builtins.str method: The HTTP method to use for this API check. Possible values are `GET`, `POST`, `PUT`, `HEAD`, `DELETE`, `PATCH`. (Default `GET`).
1351
1406
  """
1352
1407
  pulumi.set(__self__, "url", url)
1353
1408
  if assertions is not None:
@@ -1371,12 +1426,12 @@ class CheckRequest(dict):
1371
1426
  if skip_ssl is not None:
1372
1427
  pulumi.set(__self__, "skip_ssl", skip_ssl)
1373
1428
 
1374
- @property
1429
+ @_builtins.property
1375
1430
  @pulumi.getter
1376
- def url(self) -> str:
1431
+ def url(self) -> _builtins.str:
1377
1432
  return pulumi.get(self, "url")
1378
1433
 
1379
- @property
1434
+ @_builtins.property
1380
1435
  @pulumi.getter
1381
1436
  def assertions(self) -> Optional[Sequence['outputs.CheckRequestAssertion']]:
1382
1437
  """
@@ -1384,7 +1439,7 @@ class CheckRequest(dict):
1384
1439
  """
1385
1440
  return pulumi.get(self, "assertions")
1386
1441
 
1387
- @property
1442
+ @_builtins.property
1388
1443
  @pulumi.getter(name="basicAuth")
1389
1444
  def basic_auth(self) -> Optional['outputs.CheckRequestBasicAuth']:
1390
1445
  """
@@ -1392,69 +1447,69 @@ class CheckRequest(dict):
1392
1447
  """
1393
1448
  return pulumi.get(self, "basic_auth")
1394
1449
 
1395
- @property
1450
+ @_builtins.property
1396
1451
  @pulumi.getter
1397
- def body(self) -> Optional[str]:
1452
+ def body(self) -> Optional[_builtins.str]:
1398
1453
  """
1399
1454
  The body of the request.
1400
1455
  """
1401
1456
  return pulumi.get(self, "body")
1402
1457
 
1403
- @property
1458
+ @_builtins.property
1404
1459
  @pulumi.getter(name="bodyType")
1405
- def body_type(self) -> Optional[str]:
1460
+ def body_type(self) -> Optional[_builtins.str]:
1406
1461
  """
1407
1462
  The `Content-Type` header of the request. Possible values `NONE`, `JSON`, `FORM`, `RAW`, and `GRAPHQL`.
1408
1463
  """
1409
1464
  return pulumi.get(self, "body_type")
1410
1465
 
1411
- @property
1466
+ @_builtins.property
1412
1467
  @pulumi.getter(name="followRedirects")
1413
- def follow_redirects(self) -> Optional[bool]:
1468
+ def follow_redirects(self) -> Optional[_builtins.bool]:
1414
1469
  return pulumi.get(self, "follow_redirects")
1415
1470
 
1416
- @property
1471
+ @_builtins.property
1417
1472
  @pulumi.getter
1418
- def headers(self) -> Optional[Mapping[str, str]]:
1473
+ def headers(self) -> Optional[Mapping[str, _builtins.str]]:
1419
1474
  return pulumi.get(self, "headers")
1420
1475
 
1421
- @property
1476
+ @_builtins.property
1422
1477
  @pulumi.getter(name="ipFamily")
1423
- def ip_family(self) -> Optional[str]:
1478
+ def ip_family(self) -> Optional[_builtins.str]:
1424
1479
  """
1425
1480
  IP Family to be used when executing the api check. The value can be either IPv4 or IPv6.
1426
1481
  """
1427
1482
  return pulumi.get(self, "ip_family")
1428
1483
 
1429
- @property
1484
+ @_builtins.property
1430
1485
  @pulumi.getter
1431
- def method(self) -> Optional[str]:
1486
+ def method(self) -> Optional[_builtins.str]:
1432
1487
  """
1433
1488
  The HTTP method to use for this API check. Possible values are `GET`, `POST`, `PUT`, `HEAD`, `DELETE`, `PATCH`. (Default `GET`).
1434
1489
  """
1435
1490
  return pulumi.get(self, "method")
1436
1491
 
1437
- @property
1492
+ @_builtins.property
1438
1493
  @pulumi.getter(name="queryParameters")
1439
- def query_parameters(self) -> Optional[Mapping[str, str]]:
1494
+ def query_parameters(self) -> Optional[Mapping[str, _builtins.str]]:
1440
1495
  return pulumi.get(self, "query_parameters")
1441
1496
 
1442
- @property
1497
+ @_builtins.property
1443
1498
  @pulumi.getter(name="skipSsl")
1444
- def skip_ssl(self) -> Optional[bool]:
1499
+ def skip_ssl(self) -> Optional[_builtins.bool]:
1445
1500
  return pulumi.get(self, "skip_ssl")
1446
1501
 
1447
1502
 
1448
1503
  @pulumi.output_type
1449
1504
  class CheckRequestAssertion(dict):
1450
1505
  def __init__(__self__, *,
1451
- comparison: str,
1452
- source: str,
1453
- property: Optional[str] = None,
1454
- target: Optional[str] = None):
1506
+ comparison: _builtins.str,
1507
+ source: _builtins.str,
1508
+ property: Optional[_builtins.str] = None,
1509
+ target: Optional[_builtins.str] = None):
1455
1510
  """
1456
- :param 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`.
1457
- :param str source: The source of the asserted value. Possible values `STATUS_CODE`, `JSON_BODY`, `HEADERS`, `TEXT_BODY`, and `RESPONSE_TIME`.
1511
+ :param _builtins.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`.
1512
+ :param _builtins.str source: The source of the asserted value. Possible values `STATUS_CODE`, `JSON_BODY`, `HEADERS`, `TEXT_BODY`, and `RESPONSE_TIME`.
1458
1513
  """
1459
1514
  pulumi.set(__self__, "comparison", comparison)
1460
1515
  pulumi.set(__self__, "source", source)
@@ -1463,49 +1518,49 @@ class CheckRequestAssertion(dict):
1463
1518
  if target is not None:
1464
1519
  pulumi.set(__self__, "target", target)
1465
1520
 
1466
- @property
1521
+ @_builtins.property
1467
1522
  @pulumi.getter
1468
- def comparison(self) -> str:
1523
+ def comparison(self) -> _builtins.str:
1469
1524
  """
1470
1525
  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`.
1471
1526
  """
1472
1527
  return pulumi.get(self, "comparison")
1473
1528
 
1474
- @property
1529
+ @_builtins.property
1475
1530
  @pulumi.getter
1476
- def source(self) -> str:
1531
+ def source(self) -> _builtins.str:
1477
1532
  """
1478
1533
  The source of the asserted value. Possible values `STATUS_CODE`, `JSON_BODY`, `HEADERS`, `TEXT_BODY`, and `RESPONSE_TIME`.
1479
1534
  """
1480
1535
  return pulumi.get(self, "source")
1481
1536
 
1482
- @property
1537
+ @_builtins.property
1483
1538
  @pulumi.getter
1484
- def target(self) -> Optional[str]:
1485
- return pulumi.get(self, "target")
1539
+ def property(self) -> Optional[_builtins.str]:
1540
+ return pulumi.get(self, "property")
1486
1541
 
1487
- @property
1542
+ @_builtins.property
1488
1543
  @pulumi.getter
1489
- def property(self) -> Optional[str]:
1490
- return pulumi.get(self, "property")
1544
+ def target(self) -> Optional[_builtins.str]:
1545
+ return pulumi.get(self, "target")
1491
1546
 
1492
1547
 
1493
1548
  @pulumi.output_type
1494
1549
  class CheckRequestBasicAuth(dict):
1495
1550
  def __init__(__self__, *,
1496
- password: str,
1497
- username: str):
1551
+ password: _builtins.str,
1552
+ username: _builtins.str):
1498
1553
  pulumi.set(__self__, "password", password)
1499
1554
  pulumi.set(__self__, "username", username)
1500
1555
 
1501
- @property
1556
+ @_builtins.property
1502
1557
  @pulumi.getter
1503
- def password(self) -> str:
1558
+ def password(self) -> _builtins.str:
1504
1559
  return pulumi.get(self, "password")
1505
1560
 
1506
- @property
1561
+ @_builtins.property
1507
1562
  @pulumi.getter
1508
- def username(self) -> str:
1563
+ def username(self) -> _builtins.str:
1509
1564
  return pulumi.get(self, "username")
1510
1565
 
1511
1566
 
@@ -1520,6 +1575,8 @@ class CheckRetryStrategy(dict):
1520
1575
  suggest = "max_duration_seconds"
1521
1576
  elif key == "maxRetries":
1522
1577
  suggest = "max_retries"
1578
+ elif key == "onlyOn":
1579
+ suggest = "only_on"
1523
1580
  elif key == "sameRegion":
1524
1581
  suggest = "same_region"
1525
1582
 
@@ -1535,17 +1592,19 @@ class CheckRetryStrategy(dict):
1535
1592
  return super().get(key, default)
1536
1593
 
1537
1594
  def __init__(__self__, *,
1538
- type: str,
1539
- base_backoff_seconds: Optional[int] = None,
1540
- max_duration_seconds: Optional[int] = None,
1541
- max_retries: Optional[int] = None,
1542
- same_region: Optional[bool] = None):
1543
- """
1544
- :param str type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
1545
- :param int base_backoff_seconds: The number of seconds to wait before the first retry attempt.
1546
- :param int max_duration_seconds: The total amount of time to continue retrying the check (maximum 600 seconds).
1547
- :param int max_retries: The maximum number of times to retry the check. Value must be between 1 and 10.
1548
- :param bool same_region: Whether retries should be run in the same region as the initial check run.
1595
+ type: _builtins.str,
1596
+ base_backoff_seconds: Optional[_builtins.int] = None,
1597
+ max_duration_seconds: Optional[_builtins.int] = None,
1598
+ max_retries: Optional[_builtins.int] = None,
1599
+ only_on: Optional['outputs.CheckRetryStrategyOnlyOn'] = None,
1600
+ same_region: Optional[_builtins.bool] = None):
1601
+ """
1602
+ :param _builtins.str type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, `EXPONENTIAL`, `SINGLE_RETRY`, and `NO_RETRIES`.
1603
+ :param _builtins.int base_backoff_seconds: The number of seconds to wait before the first retry attempt. (Default `60`).
1604
+ :param _builtins.int max_duration_seconds: The total amount of time to continue retrying the check/monitor (maximum 600 seconds). Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `600`).
1605
+ :param _builtins.int max_retries: The maximum number of times to retry the check/monitor. Value must be between `1` and `10`. Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `2`).
1606
+ :param 'CheckRetryStrategyOnlyOnArgs' only_on: Apply the retry strategy only if the defined conditions match.
1607
+ :param _builtins.bool same_region: Whether retries should be run in the same region as the initial check/monitor run. (Default `true`).
1549
1608
  """
1550
1609
  pulumi.set(__self__, "type", type)
1551
1610
  if base_backoff_seconds is not None:
@@ -1554,50 +1613,96 @@ class CheckRetryStrategy(dict):
1554
1613
  pulumi.set(__self__, "max_duration_seconds", max_duration_seconds)
1555
1614
  if max_retries is not None:
1556
1615
  pulumi.set(__self__, "max_retries", max_retries)
1616
+ if only_on is not None:
1617
+ pulumi.set(__self__, "only_on", only_on)
1557
1618
  if same_region is not None:
1558
1619
  pulumi.set(__self__, "same_region", same_region)
1559
1620
 
1560
- @property
1621
+ @_builtins.property
1561
1622
  @pulumi.getter
1562
- def type(self) -> str:
1623
+ def type(self) -> _builtins.str:
1563
1624
  """
1564
- Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
1625
+ Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, `EXPONENTIAL`, `SINGLE_RETRY`, and `NO_RETRIES`.
1565
1626
  """
1566
1627
  return pulumi.get(self, "type")
1567
1628
 
1568
- @property
1629
+ @_builtins.property
1569
1630
  @pulumi.getter(name="baseBackoffSeconds")
1570
- def base_backoff_seconds(self) -> Optional[int]:
1631
+ def base_backoff_seconds(self) -> Optional[_builtins.int]:
1571
1632
  """
1572
- The number of seconds to wait before the first retry attempt.
1633
+ The number of seconds to wait before the first retry attempt. (Default `60`).
1573
1634
  """
1574
1635
  return pulumi.get(self, "base_backoff_seconds")
1575
1636
 
1576
- @property
1637
+ @_builtins.property
1577
1638
  @pulumi.getter(name="maxDurationSeconds")
1578
- def max_duration_seconds(self) -> Optional[int]:
1639
+ def max_duration_seconds(self) -> Optional[_builtins.int]:
1579
1640
  """
1580
- The total amount of time to continue retrying the check (maximum 600 seconds).
1641
+ The total amount of time to continue retrying the check/monitor (maximum 600 seconds). Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `600`).
1581
1642
  """
1582
1643
  return pulumi.get(self, "max_duration_seconds")
1583
1644
 
1584
- @property
1645
+ @_builtins.property
1585
1646
  @pulumi.getter(name="maxRetries")
1586
- def max_retries(self) -> Optional[int]:
1647
+ def max_retries(self) -> Optional[_builtins.int]:
1587
1648
  """
1588
- The maximum number of times to retry the check. Value must be between 1 and 10.
1649
+ The maximum number of times to retry the check/monitor. Value must be between `1` and `10`. Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `2`).
1589
1650
  """
1590
1651
  return pulumi.get(self, "max_retries")
1591
1652
 
1592
- @property
1653
+ @_builtins.property
1654
+ @pulumi.getter(name="onlyOn")
1655
+ def only_on(self) -> Optional['outputs.CheckRetryStrategyOnlyOn']:
1656
+ """
1657
+ Apply the retry strategy only if the defined conditions match.
1658
+ """
1659
+ return pulumi.get(self, "only_on")
1660
+
1661
+ @_builtins.property
1593
1662
  @pulumi.getter(name="sameRegion")
1594
- def same_region(self) -> Optional[bool]:
1663
+ def same_region(self) -> Optional[_builtins.bool]:
1595
1664
  """
1596
- Whether retries should be run in the same region as the initial check run.
1665
+ Whether retries should be run in the same region as the initial check/monitor run. (Default `true`).
1597
1666
  """
1598
1667
  return pulumi.get(self, "same_region")
1599
1668
 
1600
1669
 
1670
+ @pulumi.output_type
1671
+ class CheckRetryStrategyOnlyOn(dict):
1672
+ @staticmethod
1673
+ def __key_warning(key: str):
1674
+ suggest = None
1675
+ if key == "networkError":
1676
+ suggest = "network_error"
1677
+
1678
+ if suggest:
1679
+ pulumi.log.warn(f"Key '{key}' not found in CheckRetryStrategyOnlyOn. Access the value via the '{suggest}' property getter instead.")
1680
+
1681
+ def __getitem__(self, key: str) -> Any:
1682
+ CheckRetryStrategyOnlyOn.__key_warning(key)
1683
+ return super().__getitem__(key)
1684
+
1685
+ def get(self, key: str, default = None) -> Any:
1686
+ CheckRetryStrategyOnlyOn.__key_warning(key)
1687
+ return super().get(key, default)
1688
+
1689
+ def __init__(__self__, *,
1690
+ network_error: Optional[_builtins.bool] = None):
1691
+ """
1692
+ :param _builtins.bool network_error: When `true`, retry only if the cause of the failure is a network error. (Default `false`).
1693
+ """
1694
+ if network_error is not None:
1695
+ pulumi.set(__self__, "network_error", network_error)
1696
+
1697
+ @_builtins.property
1698
+ @pulumi.getter(name="networkError")
1699
+ def network_error(self) -> Optional[_builtins.bool]:
1700
+ """
1701
+ When `true`, retry only if the cause of the failure is a network error. (Default `false`).
1702
+ """
1703
+ return pulumi.get(self, "network_error")
1704
+
1705
+
1601
1706
  @pulumi.output_type
1602
1707
  class CheckTriggerIncident(dict):
1603
1708
  @staticmethod
@@ -1620,17 +1725,17 @@ class CheckTriggerIncident(dict):
1620
1725
  return super().get(key, default)
1621
1726
 
1622
1727
  def __init__(__self__, *,
1623
- description: str,
1624
- name: str,
1625
- notify_subscribers: bool,
1626
- service_id: str,
1627
- severity: str):
1628
- """
1629
- :param str description: A detailed description of the incident.
1630
- :param str name: The name of the incident.
1631
- :param bool notify_subscribers: Whether to notify subscribers when the incident is triggered.
1632
- :param str service_id: The status page service that this incident will be associated with.
1633
- :param str severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
1728
+ description: _builtins.str,
1729
+ name: _builtins.str,
1730
+ notify_subscribers: _builtins.bool,
1731
+ service_id: _builtins.str,
1732
+ severity: _builtins.str):
1733
+ """
1734
+ :param _builtins.str description: A detailed description of the incident.
1735
+ :param _builtins.str name: The name of the incident.
1736
+ :param _builtins.bool notify_subscribers: Whether to notify subscribers when the incident is triggered.
1737
+ :param _builtins.str service_id: The status page service that this incident will be associated with.
1738
+ :param _builtins.str severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
1634
1739
  """
1635
1740
  pulumi.set(__self__, "description", description)
1636
1741
  pulumi.set(__self__, "name", name)
@@ -1638,41 +1743,41 @@ class CheckTriggerIncident(dict):
1638
1743
  pulumi.set(__self__, "service_id", service_id)
1639
1744
  pulumi.set(__self__, "severity", severity)
1640
1745
 
1641
- @property
1746
+ @_builtins.property
1642
1747
  @pulumi.getter
1643
- def description(self) -> str:
1748
+ def description(self) -> _builtins.str:
1644
1749
  """
1645
1750
  A detailed description of the incident.
1646
1751
  """
1647
1752
  return pulumi.get(self, "description")
1648
1753
 
1649
- @property
1754
+ @_builtins.property
1650
1755
  @pulumi.getter
1651
- def name(self) -> str:
1756
+ def name(self) -> _builtins.str:
1652
1757
  """
1653
1758
  The name of the incident.
1654
1759
  """
1655
1760
  return pulumi.get(self, "name")
1656
1761
 
1657
- @property
1762
+ @_builtins.property
1658
1763
  @pulumi.getter(name="notifySubscribers")
1659
- def notify_subscribers(self) -> bool:
1764
+ def notify_subscribers(self) -> _builtins.bool:
1660
1765
  """
1661
1766
  Whether to notify subscribers when the incident is triggered.
1662
1767
  """
1663
1768
  return pulumi.get(self, "notify_subscribers")
1664
1769
 
1665
- @property
1770
+ @_builtins.property
1666
1771
  @pulumi.getter(name="serviceId")
1667
- def service_id(self) -> str:
1772
+ def service_id(self) -> _builtins.str:
1668
1773
  """
1669
1774
  The status page service that this incident will be associated with.
1670
1775
  """
1671
1776
  return pulumi.get(self, "service_id")
1672
1777
 
1673
- @property
1778
+ @_builtins.property
1674
1779
  @pulumi.getter
1675
- def severity(self) -> str:
1780
+ def severity(self) -> _builtins.str:
1676
1781
  """
1677
1782
  The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
1678
1783
  """
@@ -1699,19 +1804,19 @@ class HeartbeatCheckAlertChannelSubscription(dict):
1699
1804
  return super().get(key, default)
1700
1805
 
1701
1806
  def __init__(__self__, *,
1702
- activated: bool,
1703
- channel_id: int):
1807
+ activated: _builtins.bool,
1808
+ channel_id: _builtins.int):
1704
1809
  pulumi.set(__self__, "activated", activated)
1705
1810
  pulumi.set(__self__, "channel_id", channel_id)
1706
1811
 
1707
- @property
1812
+ @_builtins.property
1708
1813
  @pulumi.getter
1709
- def activated(self) -> bool:
1814
+ def activated(self) -> _builtins.bool:
1710
1815
  return pulumi.get(self, "activated")
1711
1816
 
1712
- @property
1817
+ @_builtins.property
1713
1818
  @pulumi.getter(name="channelId")
1714
- def channel_id(self) -> int:
1819
+ def channel_id(self) -> _builtins.int:
1715
1820
  return pulumi.get(self, "channel_id")
1716
1821
 
1717
1822
 
@@ -1743,14 +1848,14 @@ class HeartbeatCheckAlertSettings(dict):
1743
1848
  return super().get(key, default)
1744
1849
 
1745
1850
  def __init__(__self__, *,
1746
- escalation_type: Optional[str] = None,
1851
+ escalation_type: Optional[_builtins.str] = None,
1747
1852
  parallel_run_failure_thresholds: Optional[Sequence['outputs.HeartbeatCheckAlertSettingsParallelRunFailureThreshold']] = None,
1748
1853
  reminders: Optional[Sequence['outputs.HeartbeatCheckAlertSettingsReminder']] = None,
1749
1854
  run_based_escalations: Optional[Sequence['outputs.HeartbeatCheckAlertSettingsRunBasedEscalation']] = None,
1750
1855
  ssl_certificates: Optional[Sequence['outputs.HeartbeatCheckAlertSettingsSslCertificate']] = None,
1751
1856
  time_based_escalations: Optional[Sequence['outputs.HeartbeatCheckAlertSettingsTimeBasedEscalation']] = None):
1752
1857
  """
1753
- :param str escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
1858
+ :param _builtins.str escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
1754
1859
  """
1755
1860
  if escalation_type is not None:
1756
1861
  pulumi.set(__self__, "escalation_type", escalation_type)
@@ -1765,36 +1870,36 @@ class HeartbeatCheckAlertSettings(dict):
1765
1870
  if time_based_escalations is not None:
1766
1871
  pulumi.set(__self__, "time_based_escalations", time_based_escalations)
1767
1872
 
1768
- @property
1873
+ @_builtins.property
1769
1874
  @pulumi.getter(name="escalationType")
1770
- def escalation_type(self) -> Optional[str]:
1875
+ def escalation_type(self) -> Optional[_builtins.str]:
1771
1876
  """
1772
1877
  Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
1773
1878
  """
1774
1879
  return pulumi.get(self, "escalation_type")
1775
1880
 
1776
- @property
1881
+ @_builtins.property
1777
1882
  @pulumi.getter(name="parallelRunFailureThresholds")
1778
1883
  def parallel_run_failure_thresholds(self) -> Optional[Sequence['outputs.HeartbeatCheckAlertSettingsParallelRunFailureThreshold']]:
1779
1884
  return pulumi.get(self, "parallel_run_failure_thresholds")
1780
1885
 
1781
- @property
1886
+ @_builtins.property
1782
1887
  @pulumi.getter
1783
1888
  def reminders(self) -> Optional[Sequence['outputs.HeartbeatCheckAlertSettingsReminder']]:
1784
1889
  return pulumi.get(self, "reminders")
1785
1890
 
1786
- @property
1891
+ @_builtins.property
1787
1892
  @pulumi.getter(name="runBasedEscalations")
1788
1893
  def run_based_escalations(self) -> Optional[Sequence['outputs.HeartbeatCheckAlertSettingsRunBasedEscalation']]:
1789
1894
  return pulumi.get(self, "run_based_escalations")
1790
1895
 
1791
- @property
1896
+ @_builtins.property
1792
1897
  @pulumi.getter(name="sslCertificates")
1793
1898
  @_utilities.deprecated("""This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""")
1794
1899
  def ssl_certificates(self) -> Optional[Sequence['outputs.HeartbeatCheckAlertSettingsSslCertificate']]:
1795
1900
  return pulumi.get(self, "ssl_certificates")
1796
1901
 
1797
- @property
1902
+ @_builtins.property
1798
1903
  @pulumi.getter(name="timeBasedEscalations")
1799
1904
  def time_based_escalations(self) -> Optional[Sequence['outputs.HeartbeatCheckAlertSettingsTimeBasedEscalation']]:
1800
1905
  return pulumi.get(self, "time_based_escalations")
@@ -1803,28 +1908,28 @@ class HeartbeatCheckAlertSettings(dict):
1803
1908
  @pulumi.output_type
1804
1909
  class HeartbeatCheckAlertSettingsParallelRunFailureThreshold(dict):
1805
1910
  def __init__(__self__, *,
1806
- enabled: Optional[bool] = None,
1807
- percentage: Optional[int] = None):
1911
+ enabled: Optional[_builtins.bool] = None,
1912
+ percentage: Optional[_builtins.int] = None):
1808
1913
  """
1809
- :param bool enabled: Applicable only for checks scheduled in parallel in multiple locations.
1810
- :param int percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
1914
+ :param _builtins.bool enabled: Applicable only for checks scheduled in parallel in multiple locations.
1915
+ :param _builtins.int percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
1811
1916
  """
1812
1917
  if enabled is not None:
1813
1918
  pulumi.set(__self__, "enabled", enabled)
1814
1919
  if percentage is not None:
1815
1920
  pulumi.set(__self__, "percentage", percentage)
1816
1921
 
1817
- @property
1922
+ @_builtins.property
1818
1923
  @pulumi.getter
1819
- def enabled(self) -> Optional[bool]:
1924
+ def enabled(self) -> Optional[_builtins.bool]:
1820
1925
  """
1821
1926
  Applicable only for checks scheduled in parallel in multiple locations.
1822
1927
  """
1823
1928
  return pulumi.get(self, "enabled")
1824
1929
 
1825
- @property
1930
+ @_builtins.property
1826
1931
  @pulumi.getter
1827
- def percentage(self) -> Optional[int]:
1932
+ def percentage(self) -> Optional[_builtins.int]:
1828
1933
  """
1829
1934
  Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
1830
1935
  """
@@ -1834,28 +1939,28 @@ class HeartbeatCheckAlertSettingsParallelRunFailureThreshold(dict):
1834
1939
  @pulumi.output_type
1835
1940
  class HeartbeatCheckAlertSettingsReminder(dict):
1836
1941
  def __init__(__self__, *,
1837
- amount: Optional[int] = None,
1838
- interval: Optional[int] = None):
1942
+ amount: Optional[_builtins.int] = None,
1943
+ interval: Optional[_builtins.int] = None):
1839
1944
  """
1840
- :param int amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
1841
- :param int interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
1945
+ :param _builtins.int amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
1946
+ :param _builtins.int interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
1842
1947
  """
1843
1948
  if amount is not None:
1844
1949
  pulumi.set(__self__, "amount", amount)
1845
1950
  if interval is not None:
1846
1951
  pulumi.set(__self__, "interval", interval)
1847
1952
 
1848
- @property
1953
+ @_builtins.property
1849
1954
  @pulumi.getter
1850
- def amount(self) -> Optional[int]:
1955
+ def amount(self) -> Optional[_builtins.int]:
1851
1956
  """
1852
1957
  How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
1853
1958
  """
1854
1959
  return pulumi.get(self, "amount")
1855
1960
 
1856
- @property
1961
+ @_builtins.property
1857
1962
  @pulumi.getter
1858
- def interval(self) -> Optional[int]:
1963
+ def interval(self) -> Optional[_builtins.int]:
1859
1964
  """
1860
1965
  Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
1861
1966
  """
@@ -1882,16 +1987,16 @@ class HeartbeatCheckAlertSettingsRunBasedEscalation(dict):
1882
1987
  return super().get(key, default)
1883
1988
 
1884
1989
  def __init__(__self__, *,
1885
- failed_run_threshold: Optional[int] = None):
1990
+ failed_run_threshold: Optional[_builtins.int] = None):
1886
1991
  """
1887
- :param 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`).
1992
+ :param _builtins.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`).
1888
1993
  """
1889
1994
  if failed_run_threshold is not None:
1890
1995
  pulumi.set(__self__, "failed_run_threshold", failed_run_threshold)
1891
1996
 
1892
- @property
1997
+ @_builtins.property
1893
1998
  @pulumi.getter(name="failedRunThreshold")
1894
- def failed_run_threshold(self) -> Optional[int]:
1999
+ def failed_run_threshold(self) -> Optional[_builtins.int]:
1895
2000
  """
1896
2001
  After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
1897
2002
  """
@@ -1918,28 +2023,28 @@ class HeartbeatCheckAlertSettingsSslCertificate(dict):
1918
2023
  return super().get(key, default)
1919
2024
 
1920
2025
  def __init__(__self__, *,
1921
- alert_threshold: Optional[int] = None,
1922
- enabled: Optional[bool] = None):
2026
+ alert_threshold: Optional[_builtins.int] = None,
2027
+ enabled: Optional[_builtins.bool] = None):
1923
2028
  """
1924
- :param int alert_threshold: How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
1925
- :param bool enabled: Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
2029
+ :param _builtins.int alert_threshold: How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
2030
+ :param _builtins.bool enabled: Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
1926
2031
  """
1927
2032
  if alert_threshold is not None:
1928
2033
  pulumi.set(__self__, "alert_threshold", alert_threshold)
1929
2034
  if enabled is not None:
1930
2035
  pulumi.set(__self__, "enabled", enabled)
1931
2036
 
1932
- @property
2037
+ @_builtins.property
1933
2038
  @pulumi.getter(name="alertThreshold")
1934
- def alert_threshold(self) -> Optional[int]:
2039
+ def alert_threshold(self) -> Optional[_builtins.int]:
1935
2040
  """
1936
2041
  How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
1937
2042
  """
1938
2043
  return pulumi.get(self, "alert_threshold")
1939
2044
 
1940
- @property
2045
+ @_builtins.property
1941
2046
  @pulumi.getter
1942
- def enabled(self) -> Optional[bool]:
2047
+ def enabled(self) -> Optional[_builtins.bool]:
1943
2048
  """
1944
2049
  Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
1945
2050
  """
@@ -1966,16 +2071,16 @@ class HeartbeatCheckAlertSettingsTimeBasedEscalation(dict):
1966
2071
  return super().get(key, default)
1967
2072
 
1968
2073
  def __init__(__self__, *,
1969
- minutes_failing_threshold: Optional[int] = None):
2074
+ minutes_failing_threshold: Optional[_builtins.int] = None):
1970
2075
  """
1971
- :param 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`).
2076
+ :param _builtins.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`).
1972
2077
  """
1973
2078
  if minutes_failing_threshold is not None:
1974
2079
  pulumi.set(__self__, "minutes_failing_threshold", minutes_failing_threshold)
1975
2080
 
1976
- @property
2081
+ @_builtins.property
1977
2082
  @pulumi.getter(name="minutesFailingThreshold")
1978
- def minutes_failing_threshold(self) -> Optional[int]:
2083
+ def minutes_failing_threshold(self) -> Optional[_builtins.int]:
1979
2084
  """
1980
2085
  After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
1981
2086
  """
@@ -2006,17 +2111,17 @@ class HeartbeatCheckHeartbeat(dict):
2006
2111
  return super().get(key, default)
2007
2112
 
2008
2113
  def __init__(__self__, *,
2009
- grace: int,
2010
- grace_unit: str,
2011
- period: int,
2012
- period_unit: str,
2013
- ping_token: Optional[str] = None):
2014
- """
2015
- :param int grace: How long Checkly should wait before triggering any alerts when a ping does not arrive within the set period.
2016
- :param str grace_unit: Possible values `seconds`, `minutes`, `hours` and `days`.
2017
- :param int period: How often you expect a ping to the ping URL.
2018
- :param str period_unit: Possible values `seconds`, `minutes`, `hours` and `days`.
2019
- :param str ping_token: Custom token to generate your ping URL. Checkly will expect a ping to `https://ping.checklyhq.com/[PING_TOKEN]`.
2114
+ grace: _builtins.int,
2115
+ grace_unit: _builtins.str,
2116
+ period: _builtins.int,
2117
+ period_unit: _builtins.str,
2118
+ ping_token: Optional[_builtins.str] = None):
2119
+ """
2120
+ :param _builtins.int grace: How long Checkly should wait before triggering any alerts when a ping does not arrive within the set period.
2121
+ :param _builtins.str grace_unit: Possible values `seconds`, `minutes`, `hours` and `days`.
2122
+ :param _builtins.int period: How often you expect a ping to the ping URL.
2123
+ :param _builtins.str period_unit: Possible values `seconds`, `minutes`, `hours` and `days`.
2124
+ :param _builtins.str ping_token: Custom token to generate your ping URL. Checkly will expect a ping to `https://ping.checklyhq.com/[PING_TOKEN]`.
2020
2125
  """
2021
2126
  pulumi.set(__self__, "grace", grace)
2022
2127
  pulumi.set(__self__, "grace_unit", grace_unit)
@@ -2025,41 +2130,41 @@ class HeartbeatCheckHeartbeat(dict):
2025
2130
  if ping_token is not None:
2026
2131
  pulumi.set(__self__, "ping_token", ping_token)
2027
2132
 
2028
- @property
2133
+ @_builtins.property
2029
2134
  @pulumi.getter
2030
- def grace(self) -> int:
2135
+ def grace(self) -> _builtins.int:
2031
2136
  """
2032
2137
  How long Checkly should wait before triggering any alerts when a ping does not arrive within the set period.
2033
2138
  """
2034
2139
  return pulumi.get(self, "grace")
2035
2140
 
2036
- @property
2141
+ @_builtins.property
2037
2142
  @pulumi.getter(name="graceUnit")
2038
- def grace_unit(self) -> str:
2143
+ def grace_unit(self) -> _builtins.str:
2039
2144
  """
2040
2145
  Possible values `seconds`, `minutes`, `hours` and `days`.
2041
2146
  """
2042
2147
  return pulumi.get(self, "grace_unit")
2043
2148
 
2044
- @property
2149
+ @_builtins.property
2045
2150
  @pulumi.getter
2046
- def period(self) -> int:
2151
+ def period(self) -> _builtins.int:
2047
2152
  """
2048
2153
  How often you expect a ping to the ping URL.
2049
2154
  """
2050
2155
  return pulumi.get(self, "period")
2051
2156
 
2052
- @property
2157
+ @_builtins.property
2053
2158
  @pulumi.getter(name="periodUnit")
2054
- def period_unit(self) -> str:
2159
+ def period_unit(self) -> _builtins.str:
2055
2160
  """
2056
2161
  Possible values `seconds`, `minutes`, `hours` and `days`.
2057
2162
  """
2058
2163
  return pulumi.get(self, "period_unit")
2059
2164
 
2060
- @property
2165
+ @_builtins.property
2061
2166
  @pulumi.getter(name="pingToken")
2062
- def ping_token(self) -> Optional[str]:
2167
+ def ping_token(self) -> Optional[_builtins.str]:
2063
2168
  """
2064
2169
  Custom token to generate your ping URL. Checkly will expect a ping to `https://ping.checklyhq.com/[PING_TOKEN]`.
2065
2170
  """
@@ -2088,17 +2193,17 @@ class HeartbeatCheckTriggerIncident(dict):
2088
2193
  return super().get(key, default)
2089
2194
 
2090
2195
  def __init__(__self__, *,
2091
- description: str,
2092
- name: str,
2093
- notify_subscribers: bool,
2094
- service_id: str,
2095
- severity: str):
2096
- """
2097
- :param str description: A detailed description of the incident.
2098
- :param str name: The name of the incident.
2099
- :param bool notify_subscribers: Whether to notify subscribers when the incident is triggered.
2100
- :param str service_id: The status page service that this incident will be associated with.
2101
- :param str severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
2196
+ description: _builtins.str,
2197
+ name: _builtins.str,
2198
+ notify_subscribers: _builtins.bool,
2199
+ service_id: _builtins.str,
2200
+ severity: _builtins.str):
2201
+ """
2202
+ :param _builtins.str description: A detailed description of the incident.
2203
+ :param _builtins.str name: The name of the incident.
2204
+ :param _builtins.bool notify_subscribers: Whether to notify subscribers when the incident is triggered.
2205
+ :param _builtins.str service_id: The status page service that this incident will be associated with.
2206
+ :param _builtins.str severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
2102
2207
  """
2103
2208
  pulumi.set(__self__, "description", description)
2104
2209
  pulumi.set(__self__, "name", name)
@@ -2106,41 +2211,41 @@ class HeartbeatCheckTriggerIncident(dict):
2106
2211
  pulumi.set(__self__, "service_id", service_id)
2107
2212
  pulumi.set(__self__, "severity", severity)
2108
2213
 
2109
- @property
2214
+ @_builtins.property
2110
2215
  @pulumi.getter
2111
- def description(self) -> str:
2216
+ def description(self) -> _builtins.str:
2112
2217
  """
2113
2218
  A detailed description of the incident.
2114
2219
  """
2115
2220
  return pulumi.get(self, "description")
2116
2221
 
2117
- @property
2222
+ @_builtins.property
2118
2223
  @pulumi.getter
2119
- def name(self) -> str:
2224
+ def name(self) -> _builtins.str:
2120
2225
  """
2121
2226
  The name of the incident.
2122
2227
  """
2123
2228
  return pulumi.get(self, "name")
2124
2229
 
2125
- @property
2230
+ @_builtins.property
2126
2231
  @pulumi.getter(name="notifySubscribers")
2127
- def notify_subscribers(self) -> bool:
2232
+ def notify_subscribers(self) -> _builtins.bool:
2128
2233
  """
2129
2234
  Whether to notify subscribers when the incident is triggered.
2130
2235
  """
2131
2236
  return pulumi.get(self, "notify_subscribers")
2132
2237
 
2133
- @property
2238
+ @_builtins.property
2134
2239
  @pulumi.getter(name="serviceId")
2135
- def service_id(self) -> str:
2240
+ def service_id(self) -> _builtins.str:
2136
2241
  """
2137
2242
  The status page service that this incident will be associated with.
2138
2243
  """
2139
2244
  return pulumi.get(self, "service_id")
2140
2245
 
2141
- @property
2246
+ @_builtins.property
2142
2247
  @pulumi.getter
2143
- def severity(self) -> str:
2248
+ def severity(self) -> _builtins.str:
2144
2249
  """
2145
2250
  The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
2146
2251
  """
@@ -2167,19 +2272,19 @@ class HeartbeatMonitorAlertChannelSubscription(dict):
2167
2272
  return super().get(key, default)
2168
2273
 
2169
2274
  def __init__(__self__, *,
2170
- activated: bool,
2171
- channel_id: int):
2275
+ activated: _builtins.bool,
2276
+ channel_id: _builtins.int):
2172
2277
  pulumi.set(__self__, "activated", activated)
2173
2278
  pulumi.set(__self__, "channel_id", channel_id)
2174
2279
 
2175
- @property
2280
+ @_builtins.property
2176
2281
  @pulumi.getter
2177
- def activated(self) -> bool:
2282
+ def activated(self) -> _builtins.bool:
2178
2283
  return pulumi.get(self, "activated")
2179
2284
 
2180
- @property
2285
+ @_builtins.property
2181
2286
  @pulumi.getter(name="channelId")
2182
- def channel_id(self) -> int:
2287
+ def channel_id(self) -> _builtins.int:
2183
2288
  return pulumi.get(self, "channel_id")
2184
2289
 
2185
2290
 
@@ -2211,14 +2316,14 @@ class HeartbeatMonitorAlertSettings(dict):
2211
2316
  return super().get(key, default)
2212
2317
 
2213
2318
  def __init__(__self__, *,
2214
- escalation_type: Optional[str] = None,
2319
+ escalation_type: Optional[_builtins.str] = None,
2215
2320
  parallel_run_failure_thresholds: Optional[Sequence['outputs.HeartbeatMonitorAlertSettingsParallelRunFailureThreshold']] = None,
2216
2321
  reminders: Optional[Sequence['outputs.HeartbeatMonitorAlertSettingsReminder']] = None,
2217
2322
  run_based_escalations: Optional[Sequence['outputs.HeartbeatMonitorAlertSettingsRunBasedEscalation']] = None,
2218
2323
  ssl_certificates: Optional[Sequence['outputs.HeartbeatMonitorAlertSettingsSslCertificate']] = None,
2219
2324
  time_based_escalations: Optional[Sequence['outputs.HeartbeatMonitorAlertSettingsTimeBasedEscalation']] = None):
2220
2325
  """
2221
- :param str escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
2326
+ :param _builtins.str escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
2222
2327
  """
2223
2328
  if escalation_type is not None:
2224
2329
  pulumi.set(__self__, "escalation_type", escalation_type)
@@ -2233,36 +2338,36 @@ class HeartbeatMonitorAlertSettings(dict):
2233
2338
  if time_based_escalations is not None:
2234
2339
  pulumi.set(__self__, "time_based_escalations", time_based_escalations)
2235
2340
 
2236
- @property
2341
+ @_builtins.property
2237
2342
  @pulumi.getter(name="escalationType")
2238
- def escalation_type(self) -> Optional[str]:
2343
+ def escalation_type(self) -> Optional[_builtins.str]:
2239
2344
  """
2240
2345
  Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
2241
2346
  """
2242
2347
  return pulumi.get(self, "escalation_type")
2243
2348
 
2244
- @property
2349
+ @_builtins.property
2245
2350
  @pulumi.getter(name="parallelRunFailureThresholds")
2246
2351
  def parallel_run_failure_thresholds(self) -> Optional[Sequence['outputs.HeartbeatMonitorAlertSettingsParallelRunFailureThreshold']]:
2247
2352
  return pulumi.get(self, "parallel_run_failure_thresholds")
2248
2353
 
2249
- @property
2354
+ @_builtins.property
2250
2355
  @pulumi.getter
2251
2356
  def reminders(self) -> Optional[Sequence['outputs.HeartbeatMonitorAlertSettingsReminder']]:
2252
2357
  return pulumi.get(self, "reminders")
2253
2358
 
2254
- @property
2359
+ @_builtins.property
2255
2360
  @pulumi.getter(name="runBasedEscalations")
2256
2361
  def run_based_escalations(self) -> Optional[Sequence['outputs.HeartbeatMonitorAlertSettingsRunBasedEscalation']]:
2257
2362
  return pulumi.get(self, "run_based_escalations")
2258
2363
 
2259
- @property
2364
+ @_builtins.property
2260
2365
  @pulumi.getter(name="sslCertificates")
2261
2366
  @_utilities.deprecated("""This property is deprecated and it's ignored by the Checkly Public API. It will be removed in a future version.""")
2262
2367
  def ssl_certificates(self) -> Optional[Sequence['outputs.HeartbeatMonitorAlertSettingsSslCertificate']]:
2263
2368
  return pulumi.get(self, "ssl_certificates")
2264
2369
 
2265
- @property
2370
+ @_builtins.property
2266
2371
  @pulumi.getter(name="timeBasedEscalations")
2267
2372
  def time_based_escalations(self) -> Optional[Sequence['outputs.HeartbeatMonitorAlertSettingsTimeBasedEscalation']]:
2268
2373
  return pulumi.get(self, "time_based_escalations")
@@ -2271,28 +2376,28 @@ class HeartbeatMonitorAlertSettings(dict):
2271
2376
  @pulumi.output_type
2272
2377
  class HeartbeatMonitorAlertSettingsParallelRunFailureThreshold(dict):
2273
2378
  def __init__(__self__, *,
2274
- enabled: Optional[bool] = None,
2275
- percentage: Optional[int] = None):
2379
+ enabled: Optional[_builtins.bool] = None,
2380
+ percentage: Optional[_builtins.int] = None):
2276
2381
  """
2277
- :param bool enabled: Applicable only for checks scheduled in parallel in multiple locations.
2278
- :param int percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
2382
+ :param _builtins.bool enabled: Applicable only for checks scheduled in parallel in multiple locations.
2383
+ :param _builtins.int percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
2279
2384
  """
2280
2385
  if enabled is not None:
2281
2386
  pulumi.set(__self__, "enabled", enabled)
2282
2387
  if percentage is not None:
2283
2388
  pulumi.set(__self__, "percentage", percentage)
2284
2389
 
2285
- @property
2390
+ @_builtins.property
2286
2391
  @pulumi.getter
2287
- def enabled(self) -> Optional[bool]:
2392
+ def enabled(self) -> Optional[_builtins.bool]:
2288
2393
  """
2289
2394
  Applicable only for checks scheduled in parallel in multiple locations.
2290
2395
  """
2291
2396
  return pulumi.get(self, "enabled")
2292
2397
 
2293
- @property
2398
+ @_builtins.property
2294
2399
  @pulumi.getter
2295
- def percentage(self) -> Optional[int]:
2400
+ def percentage(self) -> Optional[_builtins.int]:
2296
2401
  """
2297
2402
  Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
2298
2403
  """
@@ -2302,28 +2407,28 @@ class HeartbeatMonitorAlertSettingsParallelRunFailureThreshold(dict):
2302
2407
  @pulumi.output_type
2303
2408
  class HeartbeatMonitorAlertSettingsReminder(dict):
2304
2409
  def __init__(__self__, *,
2305
- amount: Optional[int] = None,
2306
- interval: Optional[int] = None):
2410
+ amount: Optional[_builtins.int] = None,
2411
+ interval: Optional[_builtins.int] = None):
2307
2412
  """
2308
- :param int amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
2309
- :param int interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
2413
+ :param _builtins.int amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
2414
+ :param _builtins.int interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
2310
2415
  """
2311
2416
  if amount is not None:
2312
2417
  pulumi.set(__self__, "amount", amount)
2313
2418
  if interval is not None:
2314
2419
  pulumi.set(__self__, "interval", interval)
2315
2420
 
2316
- @property
2421
+ @_builtins.property
2317
2422
  @pulumi.getter
2318
- def amount(self) -> Optional[int]:
2423
+ def amount(self) -> Optional[_builtins.int]:
2319
2424
  """
2320
2425
  How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
2321
2426
  """
2322
2427
  return pulumi.get(self, "amount")
2323
2428
 
2324
- @property
2429
+ @_builtins.property
2325
2430
  @pulumi.getter
2326
- def interval(self) -> Optional[int]:
2431
+ def interval(self) -> Optional[_builtins.int]:
2327
2432
  """
2328
2433
  Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
2329
2434
  """
@@ -2350,16 +2455,16 @@ class HeartbeatMonitorAlertSettingsRunBasedEscalation(dict):
2350
2455
  return super().get(key, default)
2351
2456
 
2352
2457
  def __init__(__self__, *,
2353
- failed_run_threshold: Optional[int] = None):
2458
+ failed_run_threshold: Optional[_builtins.int] = None):
2354
2459
  """
2355
- :param 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`).
2460
+ :param _builtins.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`).
2356
2461
  """
2357
2462
  if failed_run_threshold is not None:
2358
2463
  pulumi.set(__self__, "failed_run_threshold", failed_run_threshold)
2359
2464
 
2360
- @property
2465
+ @_builtins.property
2361
2466
  @pulumi.getter(name="failedRunThreshold")
2362
- def failed_run_threshold(self) -> Optional[int]:
2467
+ def failed_run_threshold(self) -> Optional[_builtins.int]:
2363
2468
  """
2364
2469
  After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
2365
2470
  """
@@ -2386,28 +2491,28 @@ class HeartbeatMonitorAlertSettingsSslCertificate(dict):
2386
2491
  return super().get(key, default)
2387
2492
 
2388
2493
  def __init__(__self__, *,
2389
- alert_threshold: Optional[int] = None,
2390
- enabled: Optional[bool] = None):
2494
+ alert_threshold: Optional[_builtins.int] = None,
2495
+ enabled: Optional[_builtins.bool] = None):
2391
2496
  """
2392
- :param int alert_threshold: How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
2393
- :param bool enabled: Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
2497
+ :param _builtins.int alert_threshold: How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
2498
+ :param _builtins.bool enabled: Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
2394
2499
  """
2395
2500
  if alert_threshold is not None:
2396
2501
  pulumi.set(__self__, "alert_threshold", alert_threshold)
2397
2502
  if enabled is not None:
2398
2503
  pulumi.set(__self__, "enabled", enabled)
2399
2504
 
2400
- @property
2505
+ @_builtins.property
2401
2506
  @pulumi.getter(name="alertThreshold")
2402
- def alert_threshold(self) -> Optional[int]:
2507
+ def alert_threshold(self) -> Optional[_builtins.int]:
2403
2508
  """
2404
2509
  How long before SSL certificate expiry to send alerts. Possible values `3`, `7`, `14`, `30`. (Default `3`).
2405
2510
  """
2406
2511
  return pulumi.get(self, "alert_threshold")
2407
2512
 
2408
- @property
2513
+ @_builtins.property
2409
2514
  @pulumi.getter
2410
- def enabled(self) -> Optional[bool]:
2515
+ def enabled(self) -> Optional[_builtins.bool]:
2411
2516
  """
2412
2517
  Determines if alert notifications should be sent for expiring SSL certificates. Possible values `true`, and `false`. (Default `false`).
2413
2518
  """
@@ -2434,16 +2539,16 @@ class HeartbeatMonitorAlertSettingsTimeBasedEscalation(dict):
2434
2539
  return super().get(key, default)
2435
2540
 
2436
2541
  def __init__(__self__, *,
2437
- minutes_failing_threshold: Optional[int] = None):
2542
+ minutes_failing_threshold: Optional[_builtins.int] = None):
2438
2543
  """
2439
- :param 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`).
2544
+ :param _builtins.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`).
2440
2545
  """
2441
2546
  if minutes_failing_threshold is not None:
2442
2547
  pulumi.set(__self__, "minutes_failing_threshold", minutes_failing_threshold)
2443
2548
 
2444
- @property
2549
+ @_builtins.property
2445
2550
  @pulumi.getter(name="minutesFailingThreshold")
2446
- def minutes_failing_threshold(self) -> Optional[int]:
2551
+ def minutes_failing_threshold(self) -> Optional[_builtins.int]:
2447
2552
  """
2448
2553
  After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
2449
2554
  """
@@ -2474,17 +2579,17 @@ class HeartbeatMonitorHeartbeat(dict):
2474
2579
  return super().get(key, default)
2475
2580
 
2476
2581
  def __init__(__self__, *,
2477
- grace: int,
2478
- grace_unit: str,
2479
- period: int,
2480
- period_unit: str,
2481
- ping_token: Optional[str] = None):
2482
- """
2483
- :param int grace: How long Checkly should wait before triggering any alerts when a ping does not arrive within the set period.
2484
- :param str grace_unit: Possible values `seconds`, `minutes`, `hours` and `days`.
2485
- :param int period: How often you expect a ping to the ping URL.
2486
- :param str period_unit: Possible values `seconds`, `minutes`, `hours` and `days`.
2487
- :param str ping_token: Custom token to generate your ping URL. Checkly will expect a ping to `https://ping.checklyhq.com/[PING_TOKEN]`.
2582
+ grace: _builtins.int,
2583
+ grace_unit: _builtins.str,
2584
+ period: _builtins.int,
2585
+ period_unit: _builtins.str,
2586
+ ping_token: Optional[_builtins.str] = None):
2587
+ """
2588
+ :param _builtins.int grace: How long Checkly should wait before triggering any alerts when a ping does not arrive within the set period.
2589
+ :param _builtins.str grace_unit: Possible values `seconds`, `minutes`, `hours` and `days`.
2590
+ :param _builtins.int period: How often you expect a ping to the ping URL.
2591
+ :param _builtins.str period_unit: Possible values `seconds`, `minutes`, `hours` and `days`.
2592
+ :param _builtins.str ping_token: Custom token to generate your ping URL. Checkly will expect a ping to `https://ping.checklyhq.com/[PING_TOKEN]`.
2488
2593
  """
2489
2594
  pulumi.set(__self__, "grace", grace)
2490
2595
  pulumi.set(__self__, "grace_unit", grace_unit)
@@ -2493,41 +2598,41 @@ class HeartbeatMonitorHeartbeat(dict):
2493
2598
  if ping_token is not None:
2494
2599
  pulumi.set(__self__, "ping_token", ping_token)
2495
2600
 
2496
- @property
2601
+ @_builtins.property
2497
2602
  @pulumi.getter
2498
- def grace(self) -> int:
2603
+ def grace(self) -> _builtins.int:
2499
2604
  """
2500
2605
  How long Checkly should wait before triggering any alerts when a ping does not arrive within the set period.
2501
2606
  """
2502
2607
  return pulumi.get(self, "grace")
2503
2608
 
2504
- @property
2609
+ @_builtins.property
2505
2610
  @pulumi.getter(name="graceUnit")
2506
- def grace_unit(self) -> str:
2611
+ def grace_unit(self) -> _builtins.str:
2507
2612
  """
2508
2613
  Possible values `seconds`, `minutes`, `hours` and `days`.
2509
2614
  """
2510
2615
  return pulumi.get(self, "grace_unit")
2511
2616
 
2512
- @property
2617
+ @_builtins.property
2513
2618
  @pulumi.getter
2514
- def period(self) -> int:
2619
+ def period(self) -> _builtins.int:
2515
2620
  """
2516
2621
  How often you expect a ping to the ping URL.
2517
2622
  """
2518
2623
  return pulumi.get(self, "period")
2519
2624
 
2520
- @property
2625
+ @_builtins.property
2521
2626
  @pulumi.getter(name="periodUnit")
2522
- def period_unit(self) -> str:
2627
+ def period_unit(self) -> _builtins.str:
2523
2628
  """
2524
2629
  Possible values `seconds`, `minutes`, `hours` and `days`.
2525
2630
  """
2526
2631
  return pulumi.get(self, "period_unit")
2527
2632
 
2528
- @property
2633
+ @_builtins.property
2529
2634
  @pulumi.getter(name="pingToken")
2530
- def ping_token(self) -> Optional[str]:
2635
+ def ping_token(self) -> Optional[_builtins.str]:
2531
2636
  """
2532
2637
  Custom token to generate your ping URL. Checkly will expect a ping to `https://ping.checklyhq.com/[PING_TOKEN]`.
2533
2638
  """
@@ -2556,17 +2661,17 @@ class HeartbeatMonitorTriggerIncident(dict):
2556
2661
  return super().get(key, default)
2557
2662
 
2558
2663
  def __init__(__self__, *,
2559
- description: str,
2560
- name: str,
2561
- notify_subscribers: bool,
2562
- service_id: str,
2563
- severity: str):
2564
- """
2565
- :param str description: A detailed description of the incident.
2566
- :param str name: The name of the incident.
2567
- :param bool notify_subscribers: Whether to notify subscribers when the incident is triggered.
2568
- :param str service_id: The status page service that this incident will be associated with.
2569
- :param str severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
2664
+ description: _builtins.str,
2665
+ name: _builtins.str,
2666
+ notify_subscribers: _builtins.bool,
2667
+ service_id: _builtins.str,
2668
+ severity: _builtins.str):
2669
+ """
2670
+ :param _builtins.str description: A detailed description of the incident.
2671
+ :param _builtins.str name: The name of the incident.
2672
+ :param _builtins.bool notify_subscribers: Whether to notify subscribers when the incident is triggered.
2673
+ :param _builtins.str service_id: The status page service that this incident will be associated with.
2674
+ :param _builtins.str severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
2570
2675
  """
2571
2676
  pulumi.set(__self__, "description", description)
2572
2677
  pulumi.set(__self__, "name", name)
@@ -2574,41 +2679,41 @@ class HeartbeatMonitorTriggerIncident(dict):
2574
2679
  pulumi.set(__self__, "service_id", service_id)
2575
2680
  pulumi.set(__self__, "severity", severity)
2576
2681
 
2577
- @property
2682
+ @_builtins.property
2578
2683
  @pulumi.getter
2579
- def description(self) -> str:
2684
+ def description(self) -> _builtins.str:
2580
2685
  """
2581
2686
  A detailed description of the incident.
2582
2687
  """
2583
2688
  return pulumi.get(self, "description")
2584
2689
 
2585
- @property
2690
+ @_builtins.property
2586
2691
  @pulumi.getter
2587
- def name(self) -> str:
2692
+ def name(self) -> _builtins.str:
2588
2693
  """
2589
2694
  The name of the incident.
2590
2695
  """
2591
2696
  return pulumi.get(self, "name")
2592
2697
 
2593
- @property
2698
+ @_builtins.property
2594
2699
  @pulumi.getter(name="notifySubscribers")
2595
- def notify_subscribers(self) -> bool:
2700
+ def notify_subscribers(self) -> _builtins.bool:
2596
2701
  """
2597
2702
  Whether to notify subscribers when the incident is triggered.
2598
2703
  """
2599
2704
  return pulumi.get(self, "notify_subscribers")
2600
2705
 
2601
- @property
2706
+ @_builtins.property
2602
2707
  @pulumi.getter(name="serviceId")
2603
- def service_id(self) -> str:
2708
+ def service_id(self) -> _builtins.str:
2604
2709
  """
2605
2710
  The status page service that this incident will be associated with.
2606
2711
  """
2607
2712
  return pulumi.get(self, "service_id")
2608
2713
 
2609
- @property
2714
+ @_builtins.property
2610
2715
  @pulumi.getter
2611
- def severity(self) -> str:
2716
+ def severity(self) -> _builtins.str:
2612
2717
  """
2613
2718
  The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
2614
2719
  """
@@ -2635,24 +2740,24 @@ class StatusPageCard(dict):
2635
2740
  return super().get(key, default)
2636
2741
 
2637
2742
  def __init__(__self__, *,
2638
- name: str,
2743
+ name: _builtins.str,
2639
2744
  service_attachments: Sequence['outputs.StatusPageCardServiceAttachment']):
2640
2745
  """
2641
- :param str name: The name of the card.
2746
+ :param _builtins.str name: The name of the card.
2642
2747
  :param Sequence['StatusPageCardServiceAttachmentArgs'] service_attachments: A list of services to attach to the card.
2643
2748
  """
2644
2749
  pulumi.set(__self__, "name", name)
2645
2750
  pulumi.set(__self__, "service_attachments", service_attachments)
2646
2751
 
2647
- @property
2752
+ @_builtins.property
2648
2753
  @pulumi.getter
2649
- def name(self) -> str:
2754
+ def name(self) -> _builtins.str:
2650
2755
  """
2651
2756
  The name of the card.
2652
2757
  """
2653
2758
  return pulumi.get(self, "name")
2654
2759
 
2655
- @property
2760
+ @_builtins.property
2656
2761
  @pulumi.getter(name="serviceAttachments")
2657
2762
  def service_attachments(self) -> Sequence['outputs.StatusPageCardServiceAttachment']:
2658
2763
  """
@@ -2681,15 +2786,15 @@ class StatusPageCardServiceAttachment(dict):
2681
2786
  return super().get(key, default)
2682
2787
 
2683
2788
  def __init__(__self__, *,
2684
- service_id: str):
2789
+ service_id: _builtins.str):
2685
2790
  """
2686
- :param str service_id: The ID of the service.
2791
+ :param _builtins.str service_id: The ID of the service.
2687
2792
  """
2688
2793
  pulumi.set(__self__, "service_id", service_id)
2689
2794
 
2690
- @property
2795
+ @_builtins.property
2691
2796
  @pulumi.getter(name="serviceId")
2692
- def service_id(self) -> str:
2797
+ def service_id(self) -> _builtins.str:
2693
2798
  """
2694
2799
  The ID of the service.
2695
2800
  """
@@ -2716,19 +2821,19 @@ class TcpCheckAlertChannelSubscription(dict):
2716
2821
  return super().get(key, default)
2717
2822
 
2718
2823
  def __init__(__self__, *,
2719
- activated: bool,
2720
- channel_id: int):
2824
+ activated: _builtins.bool,
2825
+ channel_id: _builtins.int):
2721
2826
  pulumi.set(__self__, "activated", activated)
2722
2827
  pulumi.set(__self__, "channel_id", channel_id)
2723
2828
 
2724
- @property
2829
+ @_builtins.property
2725
2830
  @pulumi.getter
2726
- def activated(self) -> bool:
2831
+ def activated(self) -> _builtins.bool:
2727
2832
  return pulumi.get(self, "activated")
2728
2833
 
2729
- @property
2834
+ @_builtins.property
2730
2835
  @pulumi.getter(name="channelId")
2731
- def channel_id(self) -> int:
2836
+ def channel_id(self) -> _builtins.int:
2732
2837
  return pulumi.get(self, "channel_id")
2733
2838
 
2734
2839
 
@@ -2758,13 +2863,13 @@ class TcpCheckAlertSettings(dict):
2758
2863
  return super().get(key, default)
2759
2864
 
2760
2865
  def __init__(__self__, *,
2761
- escalation_type: Optional[str] = None,
2866
+ escalation_type: Optional[_builtins.str] = None,
2762
2867
  parallel_run_failure_thresholds: Optional[Sequence['outputs.TcpCheckAlertSettingsParallelRunFailureThreshold']] = None,
2763
2868
  reminders: Optional[Sequence['outputs.TcpCheckAlertSettingsReminder']] = None,
2764
2869
  run_based_escalations: Optional[Sequence['outputs.TcpCheckAlertSettingsRunBasedEscalation']] = None,
2765
2870
  time_based_escalations: Optional[Sequence['outputs.TcpCheckAlertSettingsTimeBasedEscalation']] = None):
2766
2871
  """
2767
- :param str escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
2872
+ :param _builtins.str escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
2768
2873
  """
2769
2874
  if escalation_type is not None:
2770
2875
  pulumi.set(__self__, "escalation_type", escalation_type)
@@ -2777,30 +2882,30 @@ class TcpCheckAlertSettings(dict):
2777
2882
  if time_based_escalations is not None:
2778
2883
  pulumi.set(__self__, "time_based_escalations", time_based_escalations)
2779
2884
 
2780
- @property
2885
+ @_builtins.property
2781
2886
  @pulumi.getter(name="escalationType")
2782
- def escalation_type(self) -> Optional[str]:
2887
+ def escalation_type(self) -> Optional[_builtins.str]:
2783
2888
  """
2784
2889
  Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
2785
2890
  """
2786
2891
  return pulumi.get(self, "escalation_type")
2787
2892
 
2788
- @property
2893
+ @_builtins.property
2789
2894
  @pulumi.getter(name="parallelRunFailureThresholds")
2790
2895
  def parallel_run_failure_thresholds(self) -> Optional[Sequence['outputs.TcpCheckAlertSettingsParallelRunFailureThreshold']]:
2791
2896
  return pulumi.get(self, "parallel_run_failure_thresholds")
2792
2897
 
2793
- @property
2898
+ @_builtins.property
2794
2899
  @pulumi.getter
2795
2900
  def reminders(self) -> Optional[Sequence['outputs.TcpCheckAlertSettingsReminder']]:
2796
2901
  return pulumi.get(self, "reminders")
2797
2902
 
2798
- @property
2903
+ @_builtins.property
2799
2904
  @pulumi.getter(name="runBasedEscalations")
2800
2905
  def run_based_escalations(self) -> Optional[Sequence['outputs.TcpCheckAlertSettingsRunBasedEscalation']]:
2801
2906
  return pulumi.get(self, "run_based_escalations")
2802
2907
 
2803
- @property
2908
+ @_builtins.property
2804
2909
  @pulumi.getter(name="timeBasedEscalations")
2805
2910
  def time_based_escalations(self) -> Optional[Sequence['outputs.TcpCheckAlertSettingsTimeBasedEscalation']]:
2806
2911
  return pulumi.get(self, "time_based_escalations")
@@ -2809,28 +2914,28 @@ class TcpCheckAlertSettings(dict):
2809
2914
  @pulumi.output_type
2810
2915
  class TcpCheckAlertSettingsParallelRunFailureThreshold(dict):
2811
2916
  def __init__(__self__, *,
2812
- enabled: Optional[bool] = None,
2813
- percentage: Optional[int] = None):
2917
+ enabled: Optional[_builtins.bool] = None,
2918
+ percentage: Optional[_builtins.int] = None):
2814
2919
  """
2815
- :param bool enabled: Applicable only for checks scheduled in parallel in multiple locations.
2816
- :param int percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
2920
+ :param _builtins.bool enabled: Applicable only for checks scheduled in parallel in multiple locations.
2921
+ :param _builtins.int percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
2817
2922
  """
2818
2923
  if enabled is not None:
2819
2924
  pulumi.set(__self__, "enabled", enabled)
2820
2925
  if percentage is not None:
2821
2926
  pulumi.set(__self__, "percentage", percentage)
2822
2927
 
2823
- @property
2928
+ @_builtins.property
2824
2929
  @pulumi.getter
2825
- def enabled(self) -> Optional[bool]:
2930
+ def enabled(self) -> Optional[_builtins.bool]:
2826
2931
  """
2827
2932
  Applicable only for checks scheduled in parallel in multiple locations.
2828
2933
  """
2829
2934
  return pulumi.get(self, "enabled")
2830
2935
 
2831
- @property
2936
+ @_builtins.property
2832
2937
  @pulumi.getter
2833
- def percentage(self) -> Optional[int]:
2938
+ def percentage(self) -> Optional[_builtins.int]:
2834
2939
  """
2835
2940
  Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
2836
2941
  """
@@ -2840,28 +2945,28 @@ class TcpCheckAlertSettingsParallelRunFailureThreshold(dict):
2840
2945
  @pulumi.output_type
2841
2946
  class TcpCheckAlertSettingsReminder(dict):
2842
2947
  def __init__(__self__, *,
2843
- amount: Optional[int] = None,
2844
- interval: Optional[int] = None):
2948
+ amount: Optional[_builtins.int] = None,
2949
+ interval: Optional[_builtins.int] = None):
2845
2950
  """
2846
- :param int amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
2847
- :param int interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
2951
+ :param _builtins.int amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
2952
+ :param _builtins.int interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
2848
2953
  """
2849
2954
  if amount is not None:
2850
2955
  pulumi.set(__self__, "amount", amount)
2851
2956
  if interval is not None:
2852
2957
  pulumi.set(__self__, "interval", interval)
2853
2958
 
2854
- @property
2959
+ @_builtins.property
2855
2960
  @pulumi.getter
2856
- def amount(self) -> Optional[int]:
2961
+ def amount(self) -> Optional[_builtins.int]:
2857
2962
  """
2858
2963
  How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
2859
2964
  """
2860
2965
  return pulumi.get(self, "amount")
2861
2966
 
2862
- @property
2967
+ @_builtins.property
2863
2968
  @pulumi.getter
2864
- def interval(self) -> Optional[int]:
2969
+ def interval(self) -> Optional[_builtins.int]:
2865
2970
  """
2866
2971
  Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
2867
2972
  """
@@ -2888,16 +2993,16 @@ class TcpCheckAlertSettingsRunBasedEscalation(dict):
2888
2993
  return super().get(key, default)
2889
2994
 
2890
2995
  def __init__(__self__, *,
2891
- failed_run_threshold: Optional[int] = None):
2996
+ failed_run_threshold: Optional[_builtins.int] = None):
2892
2997
  """
2893
- :param 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`).
2998
+ :param _builtins.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`).
2894
2999
  """
2895
3000
  if failed_run_threshold is not None:
2896
3001
  pulumi.set(__self__, "failed_run_threshold", failed_run_threshold)
2897
3002
 
2898
- @property
3003
+ @_builtins.property
2899
3004
  @pulumi.getter(name="failedRunThreshold")
2900
- def failed_run_threshold(self) -> Optional[int]:
3005
+ def failed_run_threshold(self) -> Optional[_builtins.int]:
2901
3006
  """
2902
3007
  After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
2903
3008
  """
@@ -2924,16 +3029,16 @@ class TcpCheckAlertSettingsTimeBasedEscalation(dict):
2924
3029
  return super().get(key, default)
2925
3030
 
2926
3031
  def __init__(__self__, *,
2927
- minutes_failing_threshold: Optional[int] = None):
3032
+ minutes_failing_threshold: Optional[_builtins.int] = None):
2928
3033
  """
2929
- :param 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`).
3034
+ :param _builtins.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`).
2930
3035
  """
2931
3036
  if minutes_failing_threshold is not None:
2932
3037
  pulumi.set(__self__, "minutes_failing_threshold", minutes_failing_threshold)
2933
3038
 
2934
- @property
3039
+ @_builtins.property
2935
3040
  @pulumi.getter(name="minutesFailingThreshold")
2936
- def minutes_failing_threshold(self) -> Optional[int]:
3041
+ def minutes_failing_threshold(self) -> Optional[_builtins.int]:
2937
3042
  """
2938
3043
  After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
2939
3044
  """
@@ -2960,17 +3065,17 @@ class TcpCheckRequest(dict):
2960
3065
  return super().get(key, default)
2961
3066
 
2962
3067
  def __init__(__self__, *,
2963
- hostname: str,
2964
- port: int,
3068
+ hostname: _builtins.str,
3069
+ port: _builtins.int,
2965
3070
  assertions: Optional[Sequence['outputs.TcpCheckRequestAssertion']] = None,
2966
- data: Optional[str] = None,
2967
- ip_family: Optional[str] = None):
3071
+ data: Optional[_builtins.str] = None,
3072
+ ip_family: Optional[_builtins.str] = None):
2968
3073
  """
2969
- :param str hostname: The hostname or IP to connect to. Do not include a scheme or a port in this value.
2970
- :param int port: The port number to connect to.
3074
+ :param _builtins.str hostname: The hostname or IP to connect to. Do not include a scheme or a port in this value.
3075
+ :param _builtins.int port: The port number to connect to.
2971
3076
  :param Sequence['TcpCheckRequestAssertionArgs'] assertions: A request can have multiple assertions.
2972
- :param str data: The data to send to the target host.
2973
- :param str ip_family: The IP family to use when executing the TCP check. The value can be either `IPv4` or `IPv6`.
3077
+ :param _builtins.str data: The data to send to the target host.
3078
+ :param _builtins.str ip_family: The IP family to use when executing the TCP check. The value can be either `IPv4` or `IPv6`.
2974
3079
  """
2975
3080
  pulumi.set(__self__, "hostname", hostname)
2976
3081
  pulumi.set(__self__, "port", port)
@@ -2981,23 +3086,23 @@ class TcpCheckRequest(dict):
2981
3086
  if ip_family is not None:
2982
3087
  pulumi.set(__self__, "ip_family", ip_family)
2983
3088
 
2984
- @property
3089
+ @_builtins.property
2985
3090
  @pulumi.getter
2986
- def hostname(self) -> str:
3091
+ def hostname(self) -> _builtins.str:
2987
3092
  """
2988
3093
  The hostname or IP to connect to. Do not include a scheme or a port in this value.
2989
3094
  """
2990
3095
  return pulumi.get(self, "hostname")
2991
3096
 
2992
- @property
3097
+ @_builtins.property
2993
3098
  @pulumi.getter
2994
- def port(self) -> int:
3099
+ def port(self) -> _builtins.int:
2995
3100
  """
2996
3101
  The port number to connect to.
2997
3102
  """
2998
3103
  return pulumi.get(self, "port")
2999
3104
 
3000
- @property
3105
+ @_builtins.property
3001
3106
  @pulumi.getter
3002
3107
  def assertions(self) -> Optional[Sequence['outputs.TcpCheckRequestAssertion']]:
3003
3108
  """
@@ -3005,17 +3110,17 @@ class TcpCheckRequest(dict):
3005
3110
  """
3006
3111
  return pulumi.get(self, "assertions")
3007
3112
 
3008
- @property
3113
+ @_builtins.property
3009
3114
  @pulumi.getter
3010
- def data(self) -> Optional[str]:
3115
+ def data(self) -> Optional[_builtins.str]:
3011
3116
  """
3012
3117
  The data to send to the target host.
3013
3118
  """
3014
3119
  return pulumi.get(self, "data")
3015
3120
 
3016
- @property
3121
+ @_builtins.property
3017
3122
  @pulumi.getter(name="ipFamily")
3018
- def ip_family(self) -> Optional[str]:
3123
+ def ip_family(self) -> Optional[_builtins.str]:
3019
3124
  """
3020
3125
  The IP family to use when executing the TCP check. The value can be either `IPv4` or `IPv6`.
3021
3126
  """
@@ -3025,13 +3130,13 @@ class TcpCheckRequest(dict):
3025
3130
  @pulumi.output_type
3026
3131
  class TcpCheckRequestAssertion(dict):
3027
3132
  def __init__(__self__, *,
3028
- comparison: str,
3029
- source: str,
3030
- property: Optional[str] = None,
3031
- target: Optional[str] = None):
3133
+ comparison: _builtins.str,
3134
+ source: _builtins.str,
3135
+ property: Optional[_builtins.str] = None,
3136
+ target: Optional[_builtins.str] = None):
3032
3137
  """
3033
- :param 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`.
3034
- :param str source: The source of the asserted value. Possible values are `RESPONSE_DATA` and `RESPONSE_TIME`.
3138
+ :param _builtins.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`.
3139
+ :param _builtins.str source: The source of the asserted value. Possible values are `RESPONSE_DATA` and `RESPONSE_TIME`.
3035
3140
  """
3036
3141
  pulumi.set(__self__, "comparison", comparison)
3037
3142
  pulumi.set(__self__, "source", source)
@@ -3040,31 +3145,31 @@ class TcpCheckRequestAssertion(dict):
3040
3145
  if target is not None:
3041
3146
  pulumi.set(__self__, "target", target)
3042
3147
 
3043
- @property
3148
+ @_builtins.property
3044
3149
  @pulumi.getter
3045
- def comparison(self) -> str:
3150
+ def comparison(self) -> _builtins.str:
3046
3151
  """
3047
3152
  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`.
3048
3153
  """
3049
3154
  return pulumi.get(self, "comparison")
3050
3155
 
3051
- @property
3156
+ @_builtins.property
3052
3157
  @pulumi.getter
3053
- def source(self) -> str:
3158
+ def source(self) -> _builtins.str:
3054
3159
  """
3055
3160
  The source of the asserted value. Possible values are `RESPONSE_DATA` and `RESPONSE_TIME`.
3056
3161
  """
3057
3162
  return pulumi.get(self, "source")
3058
3163
 
3059
- @property
3164
+ @_builtins.property
3060
3165
  @pulumi.getter
3061
- def target(self) -> Optional[str]:
3062
- return pulumi.get(self, "target")
3166
+ def property(self) -> Optional[_builtins.str]:
3167
+ return pulumi.get(self, "property")
3063
3168
 
3064
- @property
3169
+ @_builtins.property
3065
3170
  @pulumi.getter
3066
- def property(self) -> Optional[str]:
3067
- return pulumi.get(self, "property")
3171
+ def target(self) -> Optional[_builtins.str]:
3172
+ return pulumi.get(self, "target")
3068
3173
 
3069
3174
 
3070
3175
  @pulumi.output_type
@@ -3078,6 +3183,8 @@ class TcpCheckRetryStrategy(dict):
3078
3183
  suggest = "max_duration_seconds"
3079
3184
  elif key == "maxRetries":
3080
3185
  suggest = "max_retries"
3186
+ elif key == "onlyOn":
3187
+ suggest = "only_on"
3081
3188
  elif key == "sameRegion":
3082
3189
  suggest = "same_region"
3083
3190
 
@@ -3093,17 +3200,19 @@ class TcpCheckRetryStrategy(dict):
3093
3200
  return super().get(key, default)
3094
3201
 
3095
3202
  def __init__(__self__, *,
3096
- type: str,
3097
- base_backoff_seconds: Optional[int] = None,
3098
- max_duration_seconds: Optional[int] = None,
3099
- max_retries: Optional[int] = None,
3100
- same_region: Optional[bool] = None):
3101
- """
3102
- :param str type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
3103
- :param int base_backoff_seconds: The number of seconds to wait before the first retry attempt.
3104
- :param int max_duration_seconds: The total amount of time to continue retrying the check (maximum 600 seconds).
3105
- :param int max_retries: The maximum number of times to retry the check. Value must be between 1 and 10.
3106
- :param bool same_region: Whether retries should be run in the same region as the initial check run.
3203
+ type: _builtins.str,
3204
+ base_backoff_seconds: Optional[_builtins.int] = None,
3205
+ max_duration_seconds: Optional[_builtins.int] = None,
3206
+ max_retries: Optional[_builtins.int] = None,
3207
+ only_on: Optional['outputs.TcpCheckRetryStrategyOnlyOn'] = None,
3208
+ same_region: Optional[_builtins.bool] = None):
3209
+ """
3210
+ :param _builtins.str type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, `EXPONENTIAL`, `SINGLE_RETRY`, and `NO_RETRIES`.
3211
+ :param _builtins.int base_backoff_seconds: The number of seconds to wait before the first retry attempt. (Default `60`).
3212
+ :param _builtins.int max_duration_seconds: The total amount of time to continue retrying the check/monitor (maximum 600 seconds). Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `600`).
3213
+ :param _builtins.int max_retries: The maximum number of times to retry the check/monitor. Value must be between `1` and `10`. Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `2`).
3214
+ :param 'TcpCheckRetryStrategyOnlyOnArgs' only_on: Apply the retry strategy only if the defined conditions match.
3215
+ :param _builtins.bool same_region: Whether retries should be run in the same region as the initial check/monitor run. (Default `true`).
3107
3216
  """
3108
3217
  pulumi.set(__self__, "type", type)
3109
3218
  if base_backoff_seconds is not None:
@@ -3112,50 +3221,96 @@ class TcpCheckRetryStrategy(dict):
3112
3221
  pulumi.set(__self__, "max_duration_seconds", max_duration_seconds)
3113
3222
  if max_retries is not None:
3114
3223
  pulumi.set(__self__, "max_retries", max_retries)
3224
+ if only_on is not None:
3225
+ pulumi.set(__self__, "only_on", only_on)
3115
3226
  if same_region is not None:
3116
3227
  pulumi.set(__self__, "same_region", same_region)
3117
3228
 
3118
- @property
3229
+ @_builtins.property
3119
3230
  @pulumi.getter
3120
- def type(self) -> str:
3231
+ def type(self) -> _builtins.str:
3121
3232
  """
3122
- Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
3233
+ Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, `EXPONENTIAL`, `SINGLE_RETRY`, and `NO_RETRIES`.
3123
3234
  """
3124
3235
  return pulumi.get(self, "type")
3125
3236
 
3126
- @property
3237
+ @_builtins.property
3127
3238
  @pulumi.getter(name="baseBackoffSeconds")
3128
- def base_backoff_seconds(self) -> Optional[int]:
3239
+ def base_backoff_seconds(self) -> Optional[_builtins.int]:
3129
3240
  """
3130
- The number of seconds to wait before the first retry attempt.
3241
+ The number of seconds to wait before the first retry attempt. (Default `60`).
3131
3242
  """
3132
3243
  return pulumi.get(self, "base_backoff_seconds")
3133
3244
 
3134
- @property
3245
+ @_builtins.property
3135
3246
  @pulumi.getter(name="maxDurationSeconds")
3136
- def max_duration_seconds(self) -> Optional[int]:
3247
+ def max_duration_seconds(self) -> Optional[_builtins.int]:
3137
3248
  """
3138
- The total amount of time to continue retrying the check (maximum 600 seconds).
3249
+ The total amount of time to continue retrying the check/monitor (maximum 600 seconds). Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `600`).
3139
3250
  """
3140
3251
  return pulumi.get(self, "max_duration_seconds")
3141
3252
 
3142
- @property
3253
+ @_builtins.property
3143
3254
  @pulumi.getter(name="maxRetries")
3144
- def max_retries(self) -> Optional[int]:
3255
+ def max_retries(self) -> Optional[_builtins.int]:
3145
3256
  """
3146
- The maximum number of times to retry the check. Value must be between 1 and 10.
3257
+ The maximum number of times to retry the check/monitor. Value must be between `1` and `10`. Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `2`).
3147
3258
  """
3148
3259
  return pulumi.get(self, "max_retries")
3149
3260
 
3150
- @property
3261
+ @_builtins.property
3262
+ @pulumi.getter(name="onlyOn")
3263
+ def only_on(self) -> Optional['outputs.TcpCheckRetryStrategyOnlyOn']:
3264
+ """
3265
+ Apply the retry strategy only if the defined conditions match.
3266
+ """
3267
+ return pulumi.get(self, "only_on")
3268
+
3269
+ @_builtins.property
3151
3270
  @pulumi.getter(name="sameRegion")
3152
- def same_region(self) -> Optional[bool]:
3271
+ def same_region(self) -> Optional[_builtins.bool]:
3153
3272
  """
3154
- Whether retries should be run in the same region as the initial check run.
3273
+ Whether retries should be run in the same region as the initial check/monitor run. (Default `true`).
3155
3274
  """
3156
3275
  return pulumi.get(self, "same_region")
3157
3276
 
3158
3277
 
3278
+ @pulumi.output_type
3279
+ class TcpCheckRetryStrategyOnlyOn(dict):
3280
+ @staticmethod
3281
+ def __key_warning(key: str):
3282
+ suggest = None
3283
+ if key == "networkError":
3284
+ suggest = "network_error"
3285
+
3286
+ if suggest:
3287
+ pulumi.log.warn(f"Key '{key}' not found in TcpCheckRetryStrategyOnlyOn. Access the value via the '{suggest}' property getter instead.")
3288
+
3289
+ def __getitem__(self, key: str) -> Any:
3290
+ TcpCheckRetryStrategyOnlyOn.__key_warning(key)
3291
+ return super().__getitem__(key)
3292
+
3293
+ def get(self, key: str, default = None) -> Any:
3294
+ TcpCheckRetryStrategyOnlyOn.__key_warning(key)
3295
+ return super().get(key, default)
3296
+
3297
+ def __init__(__self__, *,
3298
+ network_error: Optional[_builtins.bool] = None):
3299
+ """
3300
+ :param _builtins.bool network_error: When `true`, retry only if the cause of the failure is a network error. (Default `false`).
3301
+ """
3302
+ if network_error is not None:
3303
+ pulumi.set(__self__, "network_error", network_error)
3304
+
3305
+ @_builtins.property
3306
+ @pulumi.getter(name="networkError")
3307
+ def network_error(self) -> Optional[_builtins.bool]:
3308
+ """
3309
+ When `true`, retry only if the cause of the failure is a network error. (Default `false`).
3310
+ """
3311
+ return pulumi.get(self, "network_error")
3312
+
3313
+
3159
3314
  @pulumi.output_type
3160
3315
  class TcpCheckTriggerIncident(dict):
3161
3316
  @staticmethod
@@ -3178,17 +3333,17 @@ class TcpCheckTriggerIncident(dict):
3178
3333
  return super().get(key, default)
3179
3334
 
3180
3335
  def __init__(__self__, *,
3181
- description: str,
3182
- name: str,
3183
- notify_subscribers: bool,
3184
- service_id: str,
3185
- severity: str):
3186
- """
3187
- :param str description: A detailed description of the incident.
3188
- :param str name: The name of the incident.
3189
- :param bool notify_subscribers: Whether to notify subscribers when the incident is triggered.
3190
- :param str service_id: The status page service that this incident will be associated with.
3191
- :param str severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
3336
+ description: _builtins.str,
3337
+ name: _builtins.str,
3338
+ notify_subscribers: _builtins.bool,
3339
+ service_id: _builtins.str,
3340
+ severity: _builtins.str):
3341
+ """
3342
+ :param _builtins.str description: A detailed description of the incident.
3343
+ :param _builtins.str name: The name of the incident.
3344
+ :param _builtins.bool notify_subscribers: Whether to notify subscribers when the incident is triggered.
3345
+ :param _builtins.str service_id: The status page service that this incident will be associated with.
3346
+ :param _builtins.str severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
3192
3347
  """
3193
3348
  pulumi.set(__self__, "description", description)
3194
3349
  pulumi.set(__self__, "name", name)
@@ -3196,41 +3351,41 @@ class TcpCheckTriggerIncident(dict):
3196
3351
  pulumi.set(__self__, "service_id", service_id)
3197
3352
  pulumi.set(__self__, "severity", severity)
3198
3353
 
3199
- @property
3354
+ @_builtins.property
3200
3355
  @pulumi.getter
3201
- def description(self) -> str:
3356
+ def description(self) -> _builtins.str:
3202
3357
  """
3203
3358
  A detailed description of the incident.
3204
3359
  """
3205
3360
  return pulumi.get(self, "description")
3206
3361
 
3207
- @property
3362
+ @_builtins.property
3208
3363
  @pulumi.getter
3209
- def name(self) -> str:
3364
+ def name(self) -> _builtins.str:
3210
3365
  """
3211
3366
  The name of the incident.
3212
3367
  """
3213
3368
  return pulumi.get(self, "name")
3214
3369
 
3215
- @property
3370
+ @_builtins.property
3216
3371
  @pulumi.getter(name="notifySubscribers")
3217
- def notify_subscribers(self) -> bool:
3372
+ def notify_subscribers(self) -> _builtins.bool:
3218
3373
  """
3219
3374
  Whether to notify subscribers when the incident is triggered.
3220
3375
  """
3221
3376
  return pulumi.get(self, "notify_subscribers")
3222
3377
 
3223
- @property
3378
+ @_builtins.property
3224
3379
  @pulumi.getter(name="serviceId")
3225
- def service_id(self) -> str:
3380
+ def service_id(self) -> _builtins.str:
3226
3381
  """
3227
3382
  The status page service that this incident will be associated with.
3228
3383
  """
3229
3384
  return pulumi.get(self, "service_id")
3230
3385
 
3231
- @property
3386
+ @_builtins.property
3232
3387
  @pulumi.getter
3233
- def severity(self) -> str:
3388
+ def severity(self) -> _builtins.str:
3234
3389
  """
3235
3390
  The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
3236
3391
  """
@@ -3257,19 +3412,19 @@ class TcpMonitorAlertChannelSubscription(dict):
3257
3412
  return super().get(key, default)
3258
3413
 
3259
3414
  def __init__(__self__, *,
3260
- activated: bool,
3261
- channel_id: int):
3415
+ activated: _builtins.bool,
3416
+ channel_id: _builtins.int):
3262
3417
  pulumi.set(__self__, "activated", activated)
3263
3418
  pulumi.set(__self__, "channel_id", channel_id)
3264
3419
 
3265
- @property
3420
+ @_builtins.property
3266
3421
  @pulumi.getter
3267
- def activated(self) -> bool:
3422
+ def activated(self) -> _builtins.bool:
3268
3423
  return pulumi.get(self, "activated")
3269
3424
 
3270
- @property
3425
+ @_builtins.property
3271
3426
  @pulumi.getter(name="channelId")
3272
- def channel_id(self) -> int:
3427
+ def channel_id(self) -> _builtins.int:
3273
3428
  return pulumi.get(self, "channel_id")
3274
3429
 
3275
3430
 
@@ -3299,13 +3454,13 @@ class TcpMonitorAlertSettings(dict):
3299
3454
  return super().get(key, default)
3300
3455
 
3301
3456
  def __init__(__self__, *,
3302
- escalation_type: Optional[str] = None,
3457
+ escalation_type: Optional[_builtins.str] = None,
3303
3458
  parallel_run_failure_thresholds: Optional[Sequence['outputs.TcpMonitorAlertSettingsParallelRunFailureThreshold']] = None,
3304
3459
  reminders: Optional[Sequence['outputs.TcpMonitorAlertSettingsReminder']] = None,
3305
3460
  run_based_escalations: Optional[Sequence['outputs.TcpMonitorAlertSettingsRunBasedEscalation']] = None,
3306
3461
  time_based_escalations: Optional[Sequence['outputs.TcpMonitorAlertSettingsTimeBasedEscalation']] = None):
3307
3462
  """
3308
- :param str escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
3463
+ :param _builtins.str escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
3309
3464
  """
3310
3465
  if escalation_type is not None:
3311
3466
  pulumi.set(__self__, "escalation_type", escalation_type)
@@ -3318,30 +3473,30 @@ class TcpMonitorAlertSettings(dict):
3318
3473
  if time_based_escalations is not None:
3319
3474
  pulumi.set(__self__, "time_based_escalations", time_based_escalations)
3320
3475
 
3321
- @property
3476
+ @_builtins.property
3322
3477
  @pulumi.getter(name="escalationType")
3323
- def escalation_type(self) -> Optional[str]:
3478
+ def escalation_type(self) -> Optional[_builtins.str]:
3324
3479
  """
3325
3480
  Determines what type of escalation to use. Possible values are `RUN_BASED` or `TIME_BASED`.
3326
3481
  """
3327
3482
  return pulumi.get(self, "escalation_type")
3328
3483
 
3329
- @property
3484
+ @_builtins.property
3330
3485
  @pulumi.getter(name="parallelRunFailureThresholds")
3331
3486
  def parallel_run_failure_thresholds(self) -> Optional[Sequence['outputs.TcpMonitorAlertSettingsParallelRunFailureThreshold']]:
3332
3487
  return pulumi.get(self, "parallel_run_failure_thresholds")
3333
3488
 
3334
- @property
3489
+ @_builtins.property
3335
3490
  @pulumi.getter
3336
3491
  def reminders(self) -> Optional[Sequence['outputs.TcpMonitorAlertSettingsReminder']]:
3337
3492
  return pulumi.get(self, "reminders")
3338
3493
 
3339
- @property
3494
+ @_builtins.property
3340
3495
  @pulumi.getter(name="runBasedEscalations")
3341
3496
  def run_based_escalations(self) -> Optional[Sequence['outputs.TcpMonitorAlertSettingsRunBasedEscalation']]:
3342
3497
  return pulumi.get(self, "run_based_escalations")
3343
3498
 
3344
- @property
3499
+ @_builtins.property
3345
3500
  @pulumi.getter(name="timeBasedEscalations")
3346
3501
  def time_based_escalations(self) -> Optional[Sequence['outputs.TcpMonitorAlertSettingsTimeBasedEscalation']]:
3347
3502
  return pulumi.get(self, "time_based_escalations")
@@ -3350,28 +3505,28 @@ class TcpMonitorAlertSettings(dict):
3350
3505
  @pulumi.output_type
3351
3506
  class TcpMonitorAlertSettingsParallelRunFailureThreshold(dict):
3352
3507
  def __init__(__self__, *,
3353
- enabled: Optional[bool] = None,
3354
- percentage: Optional[int] = None):
3508
+ enabled: Optional[_builtins.bool] = None,
3509
+ percentage: Optional[_builtins.int] = None):
3355
3510
  """
3356
- :param bool enabled: Applicable only for checks scheduled in parallel in multiple locations.
3357
- :param int percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
3511
+ :param _builtins.bool enabled: Applicable only for checks scheduled in parallel in multiple locations.
3512
+ :param _builtins.int percentage: Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
3358
3513
  """
3359
3514
  if enabled is not None:
3360
3515
  pulumi.set(__self__, "enabled", enabled)
3361
3516
  if percentage is not None:
3362
3517
  pulumi.set(__self__, "percentage", percentage)
3363
3518
 
3364
- @property
3519
+ @_builtins.property
3365
3520
  @pulumi.getter
3366
- def enabled(self) -> Optional[bool]:
3521
+ def enabled(self) -> Optional[_builtins.bool]:
3367
3522
  """
3368
3523
  Applicable only for checks scheduled in parallel in multiple locations.
3369
3524
  """
3370
3525
  return pulumi.get(self, "enabled")
3371
3526
 
3372
- @property
3527
+ @_builtins.property
3373
3528
  @pulumi.getter
3374
- def percentage(self) -> Optional[int]:
3529
+ def percentage(self) -> Optional[_builtins.int]:
3375
3530
  """
3376
3531
  Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `100`, and `100`. (Default `10`).
3377
3532
  """
@@ -3381,28 +3536,28 @@ class TcpMonitorAlertSettingsParallelRunFailureThreshold(dict):
3381
3536
  @pulumi.output_type
3382
3537
  class TcpMonitorAlertSettingsReminder(dict):
3383
3538
  def __init__(__self__, *,
3384
- amount: Optional[int] = None,
3385
- interval: Optional[int] = None):
3539
+ amount: Optional[_builtins.int] = None,
3540
+ interval: Optional[_builtins.int] = None):
3386
3541
  """
3387
- :param int amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
3388
- :param int interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
3542
+ :param _builtins.int amount: How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
3543
+ :param _builtins.int interval: Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
3389
3544
  """
3390
3545
  if amount is not None:
3391
3546
  pulumi.set(__self__, "amount", amount)
3392
3547
  if interval is not None:
3393
3548
  pulumi.set(__self__, "interval", interval)
3394
3549
 
3395
- @property
3550
+ @_builtins.property
3396
3551
  @pulumi.getter
3397
- def amount(self) -> Optional[int]:
3552
+ def amount(self) -> Optional[_builtins.int]:
3398
3553
  """
3399
3554
  How many reminders to send out after the initial alert notification. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000`
3400
3555
  """
3401
3556
  return pulumi.get(self, "amount")
3402
3557
 
3403
- @property
3558
+ @_builtins.property
3404
3559
  @pulumi.getter
3405
- def interval(self) -> Optional[int]:
3560
+ def interval(self) -> Optional[_builtins.int]:
3406
3561
  """
3407
3562
  Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
3408
3563
  """
@@ -3429,16 +3584,16 @@ class TcpMonitorAlertSettingsRunBasedEscalation(dict):
3429
3584
  return super().get(key, default)
3430
3585
 
3431
3586
  def __init__(__self__, *,
3432
- failed_run_threshold: Optional[int] = None):
3587
+ failed_run_threshold: Optional[_builtins.int] = None):
3433
3588
  """
3434
- :param 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`).
3589
+ :param _builtins.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`).
3435
3590
  """
3436
3591
  if failed_run_threshold is not None:
3437
3592
  pulumi.set(__self__, "failed_run_threshold", failed_run_threshold)
3438
3593
 
3439
- @property
3594
+ @_builtins.property
3440
3595
  @pulumi.getter(name="failedRunThreshold")
3441
- def failed_run_threshold(self) -> Optional[int]:
3596
+ def failed_run_threshold(self) -> Optional[_builtins.int]:
3442
3597
  """
3443
3598
  After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default `1`).
3444
3599
  """
@@ -3465,16 +3620,16 @@ class TcpMonitorAlertSettingsTimeBasedEscalation(dict):
3465
3620
  return super().get(key, default)
3466
3621
 
3467
3622
  def __init__(__self__, *,
3468
- minutes_failing_threshold: Optional[int] = None):
3623
+ minutes_failing_threshold: Optional[_builtins.int] = None):
3469
3624
  """
3470
- :param 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`).
3625
+ :param _builtins.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`).
3471
3626
  """
3472
3627
  if minutes_failing_threshold is not None:
3473
3628
  pulumi.set(__self__, "minutes_failing_threshold", minutes_failing_threshold)
3474
3629
 
3475
- @property
3630
+ @_builtins.property
3476
3631
  @pulumi.getter(name="minutesFailingThreshold")
3477
- def minutes_failing_threshold(self) -> Optional[int]:
3632
+ def minutes_failing_threshold(self) -> Optional[_builtins.int]:
3478
3633
  """
3479
3634
  After how many minutes after a check starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
3480
3635
  """
@@ -3501,17 +3656,17 @@ class TcpMonitorRequest(dict):
3501
3656
  return super().get(key, default)
3502
3657
 
3503
3658
  def __init__(__self__, *,
3504
- hostname: str,
3505
- port: int,
3659
+ hostname: _builtins.str,
3660
+ port: _builtins.int,
3506
3661
  assertions: Optional[Sequence['outputs.TcpMonitorRequestAssertion']] = None,
3507
- data: Optional[str] = None,
3508
- ip_family: Optional[str] = None):
3662
+ data: Optional[_builtins.str] = None,
3663
+ ip_family: Optional[_builtins.str] = None):
3509
3664
  """
3510
- :param str hostname: The hostname or IP to connect to. Do not include a scheme or a port in this value.
3511
- :param int port: The port number to connect to.
3665
+ :param _builtins.str hostname: The hostname or IP to connect to. Do not include a scheme or a port in this value.
3666
+ :param _builtins.int port: The port number to connect to.
3512
3667
  :param Sequence['TcpMonitorRequestAssertionArgs'] assertions: A request can have multiple assertions.
3513
- :param str data: The data to send to the target host.
3514
- :param str ip_family: The IP family to use when executing the TCP check. The value can be either `IPv4` or `IPv6`.
3668
+ :param _builtins.str data: The data to send to the target host.
3669
+ :param _builtins.str ip_family: The IP family to use when executing the TCP check. The value can be either `IPv4` or `IPv6`.
3515
3670
  """
3516
3671
  pulumi.set(__self__, "hostname", hostname)
3517
3672
  pulumi.set(__self__, "port", port)
@@ -3522,23 +3677,23 @@ class TcpMonitorRequest(dict):
3522
3677
  if ip_family is not None:
3523
3678
  pulumi.set(__self__, "ip_family", ip_family)
3524
3679
 
3525
- @property
3680
+ @_builtins.property
3526
3681
  @pulumi.getter
3527
- def hostname(self) -> str:
3682
+ def hostname(self) -> _builtins.str:
3528
3683
  """
3529
3684
  The hostname or IP to connect to. Do not include a scheme or a port in this value.
3530
3685
  """
3531
3686
  return pulumi.get(self, "hostname")
3532
3687
 
3533
- @property
3688
+ @_builtins.property
3534
3689
  @pulumi.getter
3535
- def port(self) -> int:
3690
+ def port(self) -> _builtins.int:
3536
3691
  """
3537
3692
  The port number to connect to.
3538
3693
  """
3539
3694
  return pulumi.get(self, "port")
3540
3695
 
3541
- @property
3696
+ @_builtins.property
3542
3697
  @pulumi.getter
3543
3698
  def assertions(self) -> Optional[Sequence['outputs.TcpMonitorRequestAssertion']]:
3544
3699
  """
@@ -3546,17 +3701,17 @@ class TcpMonitorRequest(dict):
3546
3701
  """
3547
3702
  return pulumi.get(self, "assertions")
3548
3703
 
3549
- @property
3704
+ @_builtins.property
3550
3705
  @pulumi.getter
3551
- def data(self) -> Optional[str]:
3706
+ def data(self) -> Optional[_builtins.str]:
3552
3707
  """
3553
3708
  The data to send to the target host.
3554
3709
  """
3555
3710
  return pulumi.get(self, "data")
3556
3711
 
3557
- @property
3712
+ @_builtins.property
3558
3713
  @pulumi.getter(name="ipFamily")
3559
- def ip_family(self) -> Optional[str]:
3714
+ def ip_family(self) -> Optional[_builtins.str]:
3560
3715
  """
3561
3716
  The IP family to use when executing the TCP check. The value can be either `IPv4` or `IPv6`.
3562
3717
  """
@@ -3566,13 +3721,13 @@ class TcpMonitorRequest(dict):
3566
3721
  @pulumi.output_type
3567
3722
  class TcpMonitorRequestAssertion(dict):
3568
3723
  def __init__(__self__, *,
3569
- comparison: str,
3570
- source: str,
3571
- property: Optional[str] = None,
3572
- target: Optional[str] = None):
3724
+ comparison: _builtins.str,
3725
+ source: _builtins.str,
3726
+ property: Optional[_builtins.str] = None,
3727
+ target: Optional[_builtins.str] = None):
3573
3728
  """
3574
- :param 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`.
3575
- :param str source: The source of the asserted value. Possible values are `RESPONSE_DATA` and `RESPONSE_TIME`.
3729
+ :param _builtins.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`.
3730
+ :param _builtins.str source: The source of the asserted value. Possible values are `RESPONSE_DATA` and `RESPONSE_TIME`.
3576
3731
  """
3577
3732
  pulumi.set(__self__, "comparison", comparison)
3578
3733
  pulumi.set(__self__, "source", source)
@@ -3581,31 +3736,31 @@ class TcpMonitorRequestAssertion(dict):
3581
3736
  if target is not None:
3582
3737
  pulumi.set(__self__, "target", target)
3583
3738
 
3584
- @property
3739
+ @_builtins.property
3585
3740
  @pulumi.getter
3586
- def comparison(self) -> str:
3741
+ def comparison(self) -> _builtins.str:
3587
3742
  """
3588
3743
  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`.
3589
3744
  """
3590
3745
  return pulumi.get(self, "comparison")
3591
3746
 
3592
- @property
3747
+ @_builtins.property
3593
3748
  @pulumi.getter
3594
- def source(self) -> str:
3749
+ def source(self) -> _builtins.str:
3595
3750
  """
3596
3751
  The source of the asserted value. Possible values are `RESPONSE_DATA` and `RESPONSE_TIME`.
3597
3752
  """
3598
3753
  return pulumi.get(self, "source")
3599
3754
 
3600
- @property
3755
+ @_builtins.property
3601
3756
  @pulumi.getter
3602
- def target(self) -> Optional[str]:
3603
- return pulumi.get(self, "target")
3757
+ def property(self) -> Optional[_builtins.str]:
3758
+ return pulumi.get(self, "property")
3604
3759
 
3605
- @property
3760
+ @_builtins.property
3606
3761
  @pulumi.getter
3607
- def property(self) -> Optional[str]:
3608
- return pulumi.get(self, "property")
3762
+ def target(self) -> Optional[_builtins.str]:
3763
+ return pulumi.get(self, "target")
3609
3764
 
3610
3765
 
3611
3766
  @pulumi.output_type
@@ -3619,6 +3774,8 @@ class TcpMonitorRetryStrategy(dict):
3619
3774
  suggest = "max_duration_seconds"
3620
3775
  elif key == "maxRetries":
3621
3776
  suggest = "max_retries"
3777
+ elif key == "onlyOn":
3778
+ suggest = "only_on"
3622
3779
  elif key == "sameRegion":
3623
3780
  suggest = "same_region"
3624
3781
 
@@ -3634,17 +3791,19 @@ class TcpMonitorRetryStrategy(dict):
3634
3791
  return super().get(key, default)
3635
3792
 
3636
3793
  def __init__(__self__, *,
3637
- type: str,
3638
- base_backoff_seconds: Optional[int] = None,
3639
- max_duration_seconds: Optional[int] = None,
3640
- max_retries: Optional[int] = None,
3641
- same_region: Optional[bool] = None):
3642
- """
3643
- :param str type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
3644
- :param int base_backoff_seconds: The number of seconds to wait before the first retry attempt.
3645
- :param int max_duration_seconds: The total amount of time to continue retrying the check (maximum 600 seconds).
3646
- :param int max_retries: The maximum number of times to retry the check. Value must be between 1 and 10.
3647
- :param bool same_region: Whether retries should be run in the same region as the initial check run.
3794
+ type: _builtins.str,
3795
+ base_backoff_seconds: Optional[_builtins.int] = None,
3796
+ max_duration_seconds: Optional[_builtins.int] = None,
3797
+ max_retries: Optional[_builtins.int] = None,
3798
+ only_on: Optional['outputs.TcpMonitorRetryStrategyOnlyOn'] = None,
3799
+ same_region: Optional[_builtins.bool] = None):
3800
+ """
3801
+ :param _builtins.str type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, `EXPONENTIAL`, `SINGLE_RETRY`, and `NO_RETRIES`.
3802
+ :param _builtins.int base_backoff_seconds: The number of seconds to wait before the first retry attempt. (Default `60`).
3803
+ :param _builtins.int max_duration_seconds: The total amount of time to continue retrying the check/monitor (maximum 600 seconds). Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `600`).
3804
+ :param _builtins.int max_retries: The maximum number of times to retry the check/monitor. Value must be between `1` and `10`. Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `2`).
3805
+ :param 'TcpMonitorRetryStrategyOnlyOnArgs' only_on: Apply the retry strategy only if the defined conditions match.
3806
+ :param _builtins.bool same_region: Whether retries should be run in the same region as the initial check/monitor run. (Default `true`).
3648
3807
  """
3649
3808
  pulumi.set(__self__, "type", type)
3650
3809
  if base_backoff_seconds is not None:
@@ -3653,50 +3812,96 @@ class TcpMonitorRetryStrategy(dict):
3653
3812
  pulumi.set(__self__, "max_duration_seconds", max_duration_seconds)
3654
3813
  if max_retries is not None:
3655
3814
  pulumi.set(__self__, "max_retries", max_retries)
3815
+ if only_on is not None:
3816
+ pulumi.set(__self__, "only_on", only_on)
3656
3817
  if same_region is not None:
3657
3818
  pulumi.set(__self__, "same_region", same_region)
3658
3819
 
3659
- @property
3820
+ @_builtins.property
3660
3821
  @pulumi.getter
3661
- def type(self) -> str:
3822
+ def type(self) -> _builtins.str:
3662
3823
  """
3663
- Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, or `EXPONENTIAL`.
3824
+ Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, `EXPONENTIAL`, `SINGLE_RETRY`, and `NO_RETRIES`.
3664
3825
  """
3665
3826
  return pulumi.get(self, "type")
3666
3827
 
3667
- @property
3828
+ @_builtins.property
3668
3829
  @pulumi.getter(name="baseBackoffSeconds")
3669
- def base_backoff_seconds(self) -> Optional[int]:
3830
+ def base_backoff_seconds(self) -> Optional[_builtins.int]:
3670
3831
  """
3671
- The number of seconds to wait before the first retry attempt.
3832
+ The number of seconds to wait before the first retry attempt. (Default `60`).
3672
3833
  """
3673
3834
  return pulumi.get(self, "base_backoff_seconds")
3674
3835
 
3675
- @property
3836
+ @_builtins.property
3676
3837
  @pulumi.getter(name="maxDurationSeconds")
3677
- def max_duration_seconds(self) -> Optional[int]:
3838
+ def max_duration_seconds(self) -> Optional[_builtins.int]:
3678
3839
  """
3679
- The total amount of time to continue retrying the check (maximum 600 seconds).
3840
+ The total amount of time to continue retrying the check/monitor (maximum 600 seconds). Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `600`).
3680
3841
  """
3681
3842
  return pulumi.get(self, "max_duration_seconds")
3682
3843
 
3683
- @property
3844
+ @_builtins.property
3684
3845
  @pulumi.getter(name="maxRetries")
3685
- def max_retries(self) -> Optional[int]:
3846
+ def max_retries(self) -> Optional[_builtins.int]:
3686
3847
  """
3687
- The maximum number of times to retry the check. Value must be between 1 and 10.
3848
+ The maximum number of times to retry the check/monitor. Value must be between `1` and `10`. Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `2`).
3688
3849
  """
3689
3850
  return pulumi.get(self, "max_retries")
3690
3851
 
3691
- @property
3852
+ @_builtins.property
3853
+ @pulumi.getter(name="onlyOn")
3854
+ def only_on(self) -> Optional['outputs.TcpMonitorRetryStrategyOnlyOn']:
3855
+ """
3856
+ Apply the retry strategy only if the defined conditions match.
3857
+ """
3858
+ return pulumi.get(self, "only_on")
3859
+
3860
+ @_builtins.property
3692
3861
  @pulumi.getter(name="sameRegion")
3693
- def same_region(self) -> Optional[bool]:
3862
+ def same_region(self) -> Optional[_builtins.bool]:
3694
3863
  """
3695
- Whether retries should be run in the same region as the initial check run.
3864
+ Whether retries should be run in the same region as the initial check/monitor run. (Default `true`).
3696
3865
  """
3697
3866
  return pulumi.get(self, "same_region")
3698
3867
 
3699
3868
 
3869
+ @pulumi.output_type
3870
+ class TcpMonitorRetryStrategyOnlyOn(dict):
3871
+ @staticmethod
3872
+ def __key_warning(key: str):
3873
+ suggest = None
3874
+ if key == "networkError":
3875
+ suggest = "network_error"
3876
+
3877
+ if suggest:
3878
+ pulumi.log.warn(f"Key '{key}' not found in TcpMonitorRetryStrategyOnlyOn. Access the value via the '{suggest}' property getter instead.")
3879
+
3880
+ def __getitem__(self, key: str) -> Any:
3881
+ TcpMonitorRetryStrategyOnlyOn.__key_warning(key)
3882
+ return super().__getitem__(key)
3883
+
3884
+ def get(self, key: str, default = None) -> Any:
3885
+ TcpMonitorRetryStrategyOnlyOn.__key_warning(key)
3886
+ return super().get(key, default)
3887
+
3888
+ def __init__(__self__, *,
3889
+ network_error: Optional[_builtins.bool] = None):
3890
+ """
3891
+ :param _builtins.bool network_error: When `true`, retry only if the cause of the failure is a network error. (Default `false`).
3892
+ """
3893
+ if network_error is not None:
3894
+ pulumi.set(__self__, "network_error", network_error)
3895
+
3896
+ @_builtins.property
3897
+ @pulumi.getter(name="networkError")
3898
+ def network_error(self) -> Optional[_builtins.bool]:
3899
+ """
3900
+ When `true`, retry only if the cause of the failure is a network error. (Default `false`).
3901
+ """
3902
+ return pulumi.get(self, "network_error")
3903
+
3904
+
3700
3905
  @pulumi.output_type
3701
3906
  class TcpMonitorTriggerIncident(dict):
3702
3907
  @staticmethod
@@ -3719,17 +3924,17 @@ class TcpMonitorTriggerIncident(dict):
3719
3924
  return super().get(key, default)
3720
3925
 
3721
3926
  def __init__(__self__, *,
3722
- description: str,
3723
- name: str,
3724
- notify_subscribers: bool,
3725
- service_id: str,
3726
- severity: str):
3727
- """
3728
- :param str description: A detailed description of the incident.
3729
- :param str name: The name of the incident.
3730
- :param bool notify_subscribers: Whether to notify subscribers when the incident is triggered.
3731
- :param str service_id: The status page service that this incident will be associated with.
3732
- :param str severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
3927
+ description: _builtins.str,
3928
+ name: _builtins.str,
3929
+ notify_subscribers: _builtins.bool,
3930
+ service_id: _builtins.str,
3931
+ severity: _builtins.str):
3932
+ """
3933
+ :param _builtins.str description: A detailed description of the incident.
3934
+ :param _builtins.str name: The name of the incident.
3935
+ :param _builtins.bool notify_subscribers: Whether to notify subscribers when the incident is triggered.
3936
+ :param _builtins.str service_id: The status page service that this incident will be associated with.
3937
+ :param _builtins.str severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
3733
3938
  """
3734
3939
  pulumi.set(__self__, "description", description)
3735
3940
  pulumi.set(__self__, "name", name)
@@ -3737,41 +3942,41 @@ class TcpMonitorTriggerIncident(dict):
3737
3942
  pulumi.set(__self__, "service_id", service_id)
3738
3943
  pulumi.set(__self__, "severity", severity)
3739
3944
 
3740
- @property
3945
+ @_builtins.property
3741
3946
  @pulumi.getter
3742
- def description(self) -> str:
3947
+ def description(self) -> _builtins.str:
3743
3948
  """
3744
3949
  A detailed description of the incident.
3745
3950
  """
3746
3951
  return pulumi.get(self, "description")
3747
3952
 
3748
- @property
3953
+ @_builtins.property
3749
3954
  @pulumi.getter
3750
- def name(self) -> str:
3955
+ def name(self) -> _builtins.str:
3751
3956
  """
3752
3957
  The name of the incident.
3753
3958
  """
3754
3959
  return pulumi.get(self, "name")
3755
3960
 
3756
- @property
3961
+ @_builtins.property
3757
3962
  @pulumi.getter(name="notifySubscribers")
3758
- def notify_subscribers(self) -> bool:
3963
+ def notify_subscribers(self) -> _builtins.bool:
3759
3964
  """
3760
3965
  Whether to notify subscribers when the incident is triggered.
3761
3966
  """
3762
3967
  return pulumi.get(self, "notify_subscribers")
3763
3968
 
3764
- @property
3969
+ @_builtins.property
3765
3970
  @pulumi.getter(name="serviceId")
3766
- def service_id(self) -> str:
3971
+ def service_id(self) -> _builtins.str:
3767
3972
  """
3768
3973
  The status page service that this incident will be associated with.
3769
3974
  """
3770
3975
  return pulumi.get(self, "service_id")
3771
3976
 
3772
- @property
3977
+ @_builtins.property
3773
3978
  @pulumi.getter
3774
- def severity(self) -> str:
3979
+ def severity(self) -> _builtins.str:
3775
3980
  """
3776
3981
  The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
3777
3982
  """
@@ -3798,26 +4003,26 @@ class UrlMonitorAlertChannelSubscription(dict):
3798
4003
  return super().get(key, default)
3799
4004
 
3800
4005
  def __init__(__self__, *,
3801
- activated: bool,
3802
- channel_id: int):
4006
+ activated: _builtins.bool,
4007
+ channel_id: _builtins.int):
3803
4008
  """
3804
- :param bool activated: Whether an alert should be sent to this channel.
3805
- :param int channel_id: The ID of the alert channel.
4009
+ :param _builtins.bool activated: Whether an alert should be sent to this channel.
4010
+ :param _builtins.int channel_id: The ID of the alert channel.
3806
4011
  """
3807
4012
  pulumi.set(__self__, "activated", activated)
3808
4013
  pulumi.set(__self__, "channel_id", channel_id)
3809
4014
 
3810
- @property
4015
+ @_builtins.property
3811
4016
  @pulumi.getter
3812
- def activated(self) -> bool:
4017
+ def activated(self) -> _builtins.bool:
3813
4018
  """
3814
4019
  Whether an alert should be sent to this channel.
3815
4020
  """
3816
4021
  return pulumi.get(self, "activated")
3817
4022
 
3818
- @property
4023
+ @_builtins.property
3819
4024
  @pulumi.getter(name="channelId")
3820
- def channel_id(self) -> int:
4025
+ def channel_id(self) -> _builtins.int:
3821
4026
  """
3822
4027
  The ID of the alert channel.
3823
4028
  """
@@ -3850,13 +4055,13 @@ class UrlMonitorAlertSettings(dict):
3850
4055
  return super().get(key, default)
3851
4056
 
3852
4057
  def __init__(__self__, *,
3853
- escalation_type: str,
4058
+ escalation_type: _builtins.str,
3854
4059
  parallel_run_failure_thresholds: Optional[Sequence['outputs.UrlMonitorAlertSettingsParallelRunFailureThreshold']] = None,
3855
4060
  reminders: Optional[Sequence['outputs.UrlMonitorAlertSettingsReminder']] = None,
3856
4061
  run_based_escalations: Optional[Sequence['outputs.UrlMonitorAlertSettingsRunBasedEscalation']] = None,
3857
4062
  time_based_escalations: Optional[Sequence['outputs.UrlMonitorAlertSettingsTimeBasedEscalation']] = None):
3858
4063
  """
3859
- :param str escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` and `TIME_BASED`.
4064
+ :param _builtins.str escalation_type: Determines what type of escalation to use. Possible values are `RUN_BASED` and `TIME_BASED`.
3860
4065
  :param Sequence['UrlMonitorAlertSettingsParallelRunFailureThresholdArgs'] parallel_run_failure_thresholds: Configuration for parallel run failure threshold.
3861
4066
  :param Sequence['UrlMonitorAlertSettingsReminderArgs'] reminders: Defines how often to send reminder notifications after initial alert.
3862
4067
  :param Sequence['UrlMonitorAlertSettingsRunBasedEscalationArgs'] run_based_escalations: Configuration for run-based escalation.
@@ -3872,15 +4077,15 @@ class UrlMonitorAlertSettings(dict):
3872
4077
  if time_based_escalations is not None:
3873
4078
  pulumi.set(__self__, "time_based_escalations", time_based_escalations)
3874
4079
 
3875
- @property
4080
+ @_builtins.property
3876
4081
  @pulumi.getter(name="escalationType")
3877
- def escalation_type(self) -> str:
4082
+ def escalation_type(self) -> _builtins.str:
3878
4083
  """
3879
4084
  Determines what type of escalation to use. Possible values are `RUN_BASED` and `TIME_BASED`.
3880
4085
  """
3881
4086
  return pulumi.get(self, "escalation_type")
3882
4087
 
3883
- @property
4088
+ @_builtins.property
3884
4089
  @pulumi.getter(name="parallelRunFailureThresholds")
3885
4090
  def parallel_run_failure_thresholds(self) -> Optional[Sequence['outputs.UrlMonitorAlertSettingsParallelRunFailureThreshold']]:
3886
4091
  """
@@ -3888,7 +4093,7 @@ class UrlMonitorAlertSettings(dict):
3888
4093
  """
3889
4094
  return pulumi.get(self, "parallel_run_failure_thresholds")
3890
4095
 
3891
- @property
4096
+ @_builtins.property
3892
4097
  @pulumi.getter
3893
4098
  def reminders(self) -> Optional[Sequence['outputs.UrlMonitorAlertSettingsReminder']]:
3894
4099
  """
@@ -3896,7 +4101,7 @@ class UrlMonitorAlertSettings(dict):
3896
4101
  """
3897
4102
  return pulumi.get(self, "reminders")
3898
4103
 
3899
- @property
4104
+ @_builtins.property
3900
4105
  @pulumi.getter(name="runBasedEscalations")
3901
4106
  def run_based_escalations(self) -> Optional[Sequence['outputs.UrlMonitorAlertSettingsRunBasedEscalation']]:
3902
4107
  """
@@ -3904,7 +4109,7 @@ class UrlMonitorAlertSettings(dict):
3904
4109
  """
3905
4110
  return pulumi.get(self, "run_based_escalations")
3906
4111
 
3907
- @property
4112
+ @_builtins.property
3908
4113
  @pulumi.getter(name="timeBasedEscalations")
3909
4114
  def time_based_escalations(self) -> Optional[Sequence['outputs.UrlMonitorAlertSettingsTimeBasedEscalation']]:
3910
4115
  """
@@ -3916,28 +4121,28 @@ class UrlMonitorAlertSettings(dict):
3916
4121
  @pulumi.output_type
3917
4122
  class UrlMonitorAlertSettingsParallelRunFailureThreshold(dict):
3918
4123
  def __init__(__self__, *,
3919
- enabled: Optional[bool] = None,
3920
- percentage: Optional[int] = None):
4124
+ enabled: Optional[_builtins.bool] = None,
4125
+ percentage: Optional[_builtins.int] = None):
3921
4126
  """
3922
- :param bool enabled: Whether parallel run failure threshold is enabled. Applicable only for monitors scheduled in parallel in multiple locations. (Default `false`).
3923
- :param int percentage: Percentage of runs that must fail to trigger alert. Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `90`, and `100`. (Default `10`).
4127
+ :param _builtins.bool enabled: Whether parallel run failure threshold is enabled. Applicable only for monitors scheduled in parallel in multiple locations. (Default `false`).
4128
+ :param _builtins.int percentage: Percentage of runs that must fail to trigger alert. Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `90`, and `100`. (Default `10`).
3924
4129
  """
3925
4130
  if enabled is not None:
3926
4131
  pulumi.set(__self__, "enabled", enabled)
3927
4132
  if percentage is not None:
3928
4133
  pulumi.set(__self__, "percentage", percentage)
3929
4134
 
3930
- @property
4135
+ @_builtins.property
3931
4136
  @pulumi.getter
3932
- def enabled(self) -> Optional[bool]:
4137
+ def enabled(self) -> Optional[_builtins.bool]:
3933
4138
  """
3934
4139
  Whether parallel run failure threshold is enabled. Applicable only for monitors scheduled in parallel in multiple locations. (Default `false`).
3935
4140
  """
3936
4141
  return pulumi.get(self, "enabled")
3937
4142
 
3938
- @property
4143
+ @_builtins.property
3939
4144
  @pulumi.getter
3940
- def percentage(self) -> Optional[int]:
4145
+ def percentage(self) -> Optional[_builtins.int]:
3941
4146
  """
3942
4147
  Percentage of runs that must fail to trigger alert. Possible values are `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `90`, and `100`. (Default `10`).
3943
4148
  """
@@ -3947,28 +4152,28 @@ class UrlMonitorAlertSettingsParallelRunFailureThreshold(dict):
3947
4152
  @pulumi.output_type
3948
4153
  class UrlMonitorAlertSettingsReminder(dict):
3949
4154
  def __init__(__self__, *,
3950
- amount: Optional[int] = None,
3951
- interval: Optional[int] = None):
4155
+ amount: Optional[_builtins.int] = None,
4156
+ interval: Optional[_builtins.int] = None):
3952
4157
  """
3953
- :param int amount: Number of reminder notifications to send. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000` (`0` to disable, `100000` for unlimited). (Default `0`).
3954
- :param int interval: Interval between reminder notifications in minutes. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
4158
+ :param _builtins.int amount: Number of reminder notifications to send. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000` (`0` to disable, `100000` for unlimited). (Default `0`).
4159
+ :param _builtins.int interval: Interval between reminder notifications in minutes. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
3955
4160
  """
3956
4161
  if amount is not None:
3957
4162
  pulumi.set(__self__, "amount", amount)
3958
4163
  if interval is not None:
3959
4164
  pulumi.set(__self__, "interval", interval)
3960
4165
 
3961
- @property
4166
+ @_builtins.property
3962
4167
  @pulumi.getter
3963
- def amount(self) -> Optional[int]:
4168
+ def amount(self) -> Optional[_builtins.int]:
3964
4169
  """
3965
4170
  Number of reminder notifications to send. Possible values are `0`, `1`, `2`, `3`, `4`, `5`, and `100000` (`0` to disable, `100000` for unlimited). (Default `0`).
3966
4171
  """
3967
4172
  return pulumi.get(self, "amount")
3968
4173
 
3969
- @property
4174
+ @_builtins.property
3970
4175
  @pulumi.getter
3971
- def interval(self) -> Optional[int]:
4176
+ def interval(self) -> Optional[_builtins.int]:
3972
4177
  """
3973
4178
  Interval between reminder notifications in minutes. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
3974
4179
  """
@@ -3995,16 +4200,16 @@ class UrlMonitorAlertSettingsRunBasedEscalation(dict):
3995
4200
  return super().get(key, default)
3996
4201
 
3997
4202
  def __init__(__self__, *,
3998
- failed_run_threshold: Optional[int] = None):
4203
+ failed_run_threshold: Optional[_builtins.int] = None):
3999
4204
  """
4000
- :param 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`).
4205
+ :param _builtins.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`).
4001
4206
  """
4002
4207
  if failed_run_threshold is not None:
4003
4208
  pulumi.set(__self__, "failed_run_threshold", failed_run_threshold)
4004
4209
 
4005
- @property
4210
+ @_builtins.property
4006
4211
  @pulumi.getter(name="failedRunThreshold")
4007
- def failed_run_threshold(self) -> Optional[int]:
4212
+ def failed_run_threshold(self) -> Optional[_builtins.int]:
4008
4213
  """
4009
4214
  After how many failed consecutive check runs an alert notification should be sent. Possible values are between `1` and `5`. (Default `1`).
4010
4215
  """
@@ -4031,16 +4236,16 @@ class UrlMonitorAlertSettingsTimeBasedEscalation(dict):
4031
4236
  return super().get(key, default)
4032
4237
 
4033
4238
  def __init__(__self__, *,
4034
- minutes_failing_threshold: Optional[int] = None):
4239
+ minutes_failing_threshold: Optional[_builtins.int] = None):
4035
4240
  """
4036
- :param int minutes_failing_threshold: After how many minutes after a monitor starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
4241
+ :param _builtins.int minutes_failing_threshold: After how many minutes after a monitor starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
4037
4242
  """
4038
4243
  if minutes_failing_threshold is not None:
4039
4244
  pulumi.set(__self__, "minutes_failing_threshold", minutes_failing_threshold)
4040
4245
 
4041
- @property
4246
+ @_builtins.property
4042
4247
  @pulumi.getter(name="minutesFailingThreshold")
4043
- def minutes_failing_threshold(self) -> Optional[int]:
4248
+ def minutes_failing_threshold(self) -> Optional[_builtins.int]:
4044
4249
  """
4045
4250
  After how many minutes after a monitor starts failing an alert should be sent. Possible values are `5`, `10`, `15`, and `30`. (Default `5`).
4046
4251
  """
@@ -4071,17 +4276,17 @@ class UrlMonitorRequest(dict):
4071
4276
  return super().get(key, default)
4072
4277
 
4073
4278
  def __init__(__self__, *,
4074
- url: str,
4279
+ url: _builtins.str,
4075
4280
  assertions: Optional[Sequence['outputs.UrlMonitorRequestAssertion']] = None,
4076
- follow_redirects: Optional[bool] = None,
4077
- ip_family: Optional[str] = None,
4078
- skip_ssl: Optional[bool] = None):
4281
+ follow_redirects: Optional[_builtins.bool] = None,
4282
+ ip_family: Optional[_builtins.str] = None,
4283
+ skip_ssl: Optional[_builtins.bool] = None):
4079
4284
  """
4080
- :param str url: The URL to monitor. Must be a valid HTTP or HTTPS URL.
4285
+ :param _builtins.str url: The URL to monitor. Must be a valid HTTP or HTTPS URL.
4081
4286
  :param Sequence['UrlMonitorRequestAssertionArgs'] assertions: Assertions to validate the HTTP response. URL monitors only support status code assertions.
4082
- :param bool follow_redirects: Whether to follow HTTP redirects automatically. (Default `true`).
4083
- :param str ip_family: IP family version to use for the connection. The value can be either `IPv4` or `IPv6`. (Default `IPv4`).
4084
- :param bool skip_ssl: Whether to skip SSL certificate verification. (Default `false`).
4287
+ :param _builtins.bool follow_redirects: Whether to follow HTTP redirects automatically. (Default `true`).
4288
+ :param _builtins.str ip_family: IP family version to use for the connection. The value can be either `IPv4` or `IPv6`. (Default `IPv4`).
4289
+ :param _builtins.bool skip_ssl: Whether to skip SSL certificate verification. (Default `false`).
4085
4290
  """
4086
4291
  pulumi.set(__self__, "url", url)
4087
4292
  if assertions is not None:
@@ -4093,15 +4298,15 @@ class UrlMonitorRequest(dict):
4093
4298
  if skip_ssl is not None:
4094
4299
  pulumi.set(__self__, "skip_ssl", skip_ssl)
4095
4300
 
4096
- @property
4301
+ @_builtins.property
4097
4302
  @pulumi.getter
4098
- def url(self) -> str:
4303
+ def url(self) -> _builtins.str:
4099
4304
  """
4100
4305
  The URL to monitor. Must be a valid HTTP or HTTPS URL.
4101
4306
  """
4102
4307
  return pulumi.get(self, "url")
4103
4308
 
4104
- @property
4309
+ @_builtins.property
4105
4310
  @pulumi.getter
4106
4311
  def assertions(self) -> Optional[Sequence['outputs.UrlMonitorRequestAssertion']]:
4107
4312
  """
@@ -4109,25 +4314,25 @@ class UrlMonitorRequest(dict):
4109
4314
  """
4110
4315
  return pulumi.get(self, "assertions")
4111
4316
 
4112
- @property
4317
+ @_builtins.property
4113
4318
  @pulumi.getter(name="followRedirects")
4114
- def follow_redirects(self) -> Optional[bool]:
4319
+ def follow_redirects(self) -> Optional[_builtins.bool]:
4115
4320
  """
4116
4321
  Whether to follow HTTP redirects automatically. (Default `true`).
4117
4322
  """
4118
4323
  return pulumi.get(self, "follow_redirects")
4119
4324
 
4120
- @property
4325
+ @_builtins.property
4121
4326
  @pulumi.getter(name="ipFamily")
4122
- def ip_family(self) -> Optional[str]:
4327
+ def ip_family(self) -> Optional[_builtins.str]:
4123
4328
  """
4124
4329
  IP family version to use for the connection. The value can be either `IPv4` or `IPv6`. (Default `IPv4`).
4125
4330
  """
4126
4331
  return pulumi.get(self, "ip_family")
4127
4332
 
4128
- @property
4333
+ @_builtins.property
4129
4334
  @pulumi.getter(name="skipSsl")
4130
- def skip_ssl(self) -> Optional[bool]:
4335
+ def skip_ssl(self) -> Optional[_builtins.bool]:
4131
4336
  """
4132
4337
  Whether to skip SSL certificate verification. (Default `false`).
4133
4338
  """
@@ -4137,14 +4342,14 @@ class UrlMonitorRequest(dict):
4137
4342
  @pulumi.output_type
4138
4343
  class UrlMonitorRequestAssertion(dict):
4139
4344
  def __init__(__self__, *,
4140
- comparison: str,
4141
- source: str,
4142
- target: str,
4143
- property: Optional[str] = None):
4345
+ comparison: _builtins.str,
4346
+ source: _builtins.str,
4347
+ target: _builtins.str,
4348
+ property: Optional[_builtins.str] = None):
4144
4349
  """
4145
- :param str comparison: The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `GREATER_THAN` and `LESS_THAN`.
4146
- :param str source: The source of the asserted value. The only allowed value is `STATUS_CODE`.
4147
- :param str target: The target value. Typically `200` when the source is `STATUS_CODE`.
4350
+ :param _builtins.str comparison: The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `GREATER_THAN` and `LESS_THAN`.
4351
+ :param _builtins.str source: The source of the asserted value. The only allowed value is `STATUS_CODE`.
4352
+ :param _builtins.str target: The target value. Typically `200` when the source is `STATUS_CODE`.
4148
4353
  """
4149
4354
  pulumi.set(__self__, "comparison", comparison)
4150
4355
  pulumi.set(__self__, "source", source)
@@ -4152,33 +4357,33 @@ class UrlMonitorRequestAssertion(dict):
4152
4357
  if property is not None:
4153
4358
  pulumi.set(__self__, "property", property)
4154
4359
 
4155
- @property
4360
+ @_builtins.property
4156
4361
  @pulumi.getter
4157
- def comparison(self) -> str:
4362
+ def comparison(self) -> _builtins.str:
4158
4363
  """
4159
4364
  The type of comparison to be executed between expected and actual value of the assertion. Possible values are `EQUALS`, `NOT_EQUALS`, `GREATER_THAN` and `LESS_THAN`.
4160
4365
  """
4161
4366
  return pulumi.get(self, "comparison")
4162
4367
 
4163
- @property
4368
+ @_builtins.property
4164
4369
  @pulumi.getter
4165
- def source(self) -> str:
4370
+ def source(self) -> _builtins.str:
4166
4371
  """
4167
4372
  The source of the asserted value. The only allowed value is `STATUS_CODE`.
4168
4373
  """
4169
4374
  return pulumi.get(self, "source")
4170
4375
 
4171
- @property
4376
+ @_builtins.property
4172
4377
  @pulumi.getter
4173
- def target(self) -> str:
4378
+ def target(self) -> _builtins.str:
4174
4379
  """
4175
4380
  The target value. Typically `200` when the source is `STATUS_CODE`.
4176
4381
  """
4177
4382
  return pulumi.get(self, "target")
4178
4383
 
4179
- @property
4384
+ @_builtins.property
4180
4385
  @pulumi.getter
4181
- def property(self) -> Optional[str]:
4386
+ def property(self) -> Optional[_builtins.str]:
4182
4387
  return pulumi.get(self, "property")
4183
4388
 
4184
4389
 
@@ -4193,6 +4398,8 @@ class UrlMonitorRetryStrategy(dict):
4193
4398
  suggest = "max_duration_seconds"
4194
4399
  elif key == "maxRetries":
4195
4400
  suggest = "max_retries"
4401
+ elif key == "onlyOn":
4402
+ suggest = "only_on"
4196
4403
  elif key == "sameRegion":
4197
4404
  suggest = "same_region"
4198
4405
 
@@ -4208,17 +4415,19 @@ class UrlMonitorRetryStrategy(dict):
4208
4415
  return super().get(key, default)
4209
4416
 
4210
4417
  def __init__(__self__, *,
4211
- type: str,
4212
- base_backoff_seconds: Optional[int] = None,
4213
- max_duration_seconds: Optional[int] = None,
4214
- max_retries: Optional[int] = None,
4215
- same_region: Optional[bool] = None):
4216
- """
4217
- :param str type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, and `EXPONENTIAL`.
4218
- :param int base_backoff_seconds: The number of seconds to wait before the first retry attempt. (Default `60`).
4219
- :param int max_duration_seconds: The total amount of time to continue retrying the monitor (maximum 600 seconds). (Default `600`).
4220
- :param int max_retries: The maximum number of times to retry the monitor. Value must be between `1` and `10`. (Default `2`).
4221
- :param bool same_region: Whether retries should be run in the same region as the initial monitor run. (Default `true`).
4418
+ type: _builtins.str,
4419
+ base_backoff_seconds: Optional[_builtins.int] = None,
4420
+ max_duration_seconds: Optional[_builtins.int] = None,
4421
+ max_retries: Optional[_builtins.int] = None,
4422
+ only_on: Optional['outputs.UrlMonitorRetryStrategyOnlyOn'] = None,
4423
+ same_region: Optional[_builtins.bool] = None):
4424
+ """
4425
+ :param _builtins.str type: Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, `EXPONENTIAL`, `SINGLE_RETRY`, and `NO_RETRIES`.
4426
+ :param _builtins.int base_backoff_seconds: The number of seconds to wait before the first retry attempt. (Default `60`).
4427
+ :param _builtins.int max_duration_seconds: The total amount of time to continue retrying the check/monitor (maximum 600 seconds). Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `600`).
4428
+ :param _builtins.int max_retries: The maximum number of times to retry the check/monitor. Value must be between `1` and `10`. Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `2`).
4429
+ :param 'UrlMonitorRetryStrategyOnlyOnArgs' only_on: Apply the retry strategy only if the defined conditions match.
4430
+ :param _builtins.bool same_region: Whether retries should be run in the same region as the initial check/monitor run. (Default `true`).
4222
4431
  """
4223
4432
  pulumi.set(__self__, "type", type)
4224
4433
  if base_backoff_seconds is not None:
@@ -4227,50 +4436,96 @@ class UrlMonitorRetryStrategy(dict):
4227
4436
  pulumi.set(__self__, "max_duration_seconds", max_duration_seconds)
4228
4437
  if max_retries is not None:
4229
4438
  pulumi.set(__self__, "max_retries", max_retries)
4439
+ if only_on is not None:
4440
+ pulumi.set(__self__, "only_on", only_on)
4230
4441
  if same_region is not None:
4231
4442
  pulumi.set(__self__, "same_region", same_region)
4232
4443
 
4233
- @property
4444
+ @_builtins.property
4234
4445
  @pulumi.getter
4235
- def type(self) -> str:
4446
+ def type(self) -> _builtins.str:
4236
4447
  """
4237
- Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, and `EXPONENTIAL`.
4448
+ Determines which type of retry strategy to use. Possible values are `FIXED`, `LINEAR`, `EXPONENTIAL`, `SINGLE_RETRY`, and `NO_RETRIES`.
4238
4449
  """
4239
4450
  return pulumi.get(self, "type")
4240
4451
 
4241
- @property
4452
+ @_builtins.property
4242
4453
  @pulumi.getter(name="baseBackoffSeconds")
4243
- def base_backoff_seconds(self) -> Optional[int]:
4454
+ def base_backoff_seconds(self) -> Optional[_builtins.int]:
4244
4455
  """
4245
4456
  The number of seconds to wait before the first retry attempt. (Default `60`).
4246
4457
  """
4247
4458
  return pulumi.get(self, "base_backoff_seconds")
4248
4459
 
4249
- @property
4460
+ @_builtins.property
4250
4461
  @pulumi.getter(name="maxDurationSeconds")
4251
- def max_duration_seconds(self) -> Optional[int]:
4462
+ def max_duration_seconds(self) -> Optional[_builtins.int]:
4252
4463
  """
4253
- The total amount of time to continue retrying the monitor (maximum 600 seconds). (Default `600`).
4464
+ The total amount of time to continue retrying the check/monitor (maximum 600 seconds). Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `600`).
4254
4465
  """
4255
4466
  return pulumi.get(self, "max_duration_seconds")
4256
4467
 
4257
- @property
4468
+ @_builtins.property
4258
4469
  @pulumi.getter(name="maxRetries")
4259
- def max_retries(self) -> Optional[int]:
4470
+ def max_retries(self) -> Optional[_builtins.int]:
4260
4471
  """
4261
- The maximum number of times to retry the monitor. Value must be between `1` and `10`. (Default `2`).
4472
+ The maximum number of times to retry the check/monitor. Value must be between `1` and `10`. Available when `type` is `FIXED`, `LINEAR`, or `EXPONENTIAL`. (Default `2`).
4262
4473
  """
4263
4474
  return pulumi.get(self, "max_retries")
4264
4475
 
4265
- @property
4476
+ @_builtins.property
4477
+ @pulumi.getter(name="onlyOn")
4478
+ def only_on(self) -> Optional['outputs.UrlMonitorRetryStrategyOnlyOn']:
4479
+ """
4480
+ Apply the retry strategy only if the defined conditions match.
4481
+ """
4482
+ return pulumi.get(self, "only_on")
4483
+
4484
+ @_builtins.property
4266
4485
  @pulumi.getter(name="sameRegion")
4267
- def same_region(self) -> Optional[bool]:
4486
+ def same_region(self) -> Optional[_builtins.bool]:
4268
4487
  """
4269
- Whether retries should be run in the same region as the initial monitor run. (Default `true`).
4488
+ Whether retries should be run in the same region as the initial check/monitor run. (Default `true`).
4270
4489
  """
4271
4490
  return pulumi.get(self, "same_region")
4272
4491
 
4273
4492
 
4493
+ @pulumi.output_type
4494
+ class UrlMonitorRetryStrategyOnlyOn(dict):
4495
+ @staticmethod
4496
+ def __key_warning(key: str):
4497
+ suggest = None
4498
+ if key == "networkError":
4499
+ suggest = "network_error"
4500
+
4501
+ if suggest:
4502
+ pulumi.log.warn(f"Key '{key}' not found in UrlMonitorRetryStrategyOnlyOn. Access the value via the '{suggest}' property getter instead.")
4503
+
4504
+ def __getitem__(self, key: str) -> Any:
4505
+ UrlMonitorRetryStrategyOnlyOn.__key_warning(key)
4506
+ return super().__getitem__(key)
4507
+
4508
+ def get(self, key: str, default = None) -> Any:
4509
+ UrlMonitorRetryStrategyOnlyOn.__key_warning(key)
4510
+ return super().get(key, default)
4511
+
4512
+ def __init__(__self__, *,
4513
+ network_error: Optional[_builtins.bool] = None):
4514
+ """
4515
+ :param _builtins.bool network_error: When `true`, retry only if the cause of the failure is a network error. (Default `false`).
4516
+ """
4517
+ if network_error is not None:
4518
+ pulumi.set(__self__, "network_error", network_error)
4519
+
4520
+ @_builtins.property
4521
+ @pulumi.getter(name="networkError")
4522
+ def network_error(self) -> Optional[_builtins.bool]:
4523
+ """
4524
+ When `true`, retry only if the cause of the failure is a network error. (Default `false`).
4525
+ """
4526
+ return pulumi.get(self, "network_error")
4527
+
4528
+
4274
4529
  @pulumi.output_type
4275
4530
  class UrlMonitorTriggerIncident(dict):
4276
4531
  @staticmethod
@@ -4293,17 +4548,17 @@ class UrlMonitorTriggerIncident(dict):
4293
4548
  return super().get(key, default)
4294
4549
 
4295
4550
  def __init__(__self__, *,
4296
- description: str,
4297
- name: str,
4298
- notify_subscribers: bool,
4299
- service_id: str,
4300
- severity: str):
4301
- """
4302
- :param str description: A detailed description of the incident.
4303
- :param str name: The name of the incident.
4304
- :param bool notify_subscribers: Whether to notify subscribers when the incident is triggered.
4305
- :param str service_id: The status page service that this incident will be associated with.
4306
- :param str severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
4551
+ description: _builtins.str,
4552
+ name: _builtins.str,
4553
+ notify_subscribers: _builtins.bool,
4554
+ service_id: _builtins.str,
4555
+ severity: _builtins.str):
4556
+ """
4557
+ :param _builtins.str description: A detailed description of the incident.
4558
+ :param _builtins.str name: The name of the incident.
4559
+ :param _builtins.bool notify_subscribers: Whether to notify subscribers when the incident is triggered.
4560
+ :param _builtins.str service_id: The status page service that this incident will be associated with.
4561
+ :param _builtins.str severity: The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
4307
4562
  """
4308
4563
  pulumi.set(__self__, "description", description)
4309
4564
  pulumi.set(__self__, "name", name)
@@ -4311,41 +4566,41 @@ class UrlMonitorTriggerIncident(dict):
4311
4566
  pulumi.set(__self__, "service_id", service_id)
4312
4567
  pulumi.set(__self__, "severity", severity)
4313
4568
 
4314
- @property
4569
+ @_builtins.property
4315
4570
  @pulumi.getter
4316
- def description(self) -> str:
4571
+ def description(self) -> _builtins.str:
4317
4572
  """
4318
4573
  A detailed description of the incident.
4319
4574
  """
4320
4575
  return pulumi.get(self, "description")
4321
4576
 
4322
- @property
4577
+ @_builtins.property
4323
4578
  @pulumi.getter
4324
- def name(self) -> str:
4579
+ def name(self) -> _builtins.str:
4325
4580
  """
4326
4581
  The name of the incident.
4327
4582
  """
4328
4583
  return pulumi.get(self, "name")
4329
4584
 
4330
- @property
4585
+ @_builtins.property
4331
4586
  @pulumi.getter(name="notifySubscribers")
4332
- def notify_subscribers(self) -> bool:
4587
+ def notify_subscribers(self) -> _builtins.bool:
4333
4588
  """
4334
4589
  Whether to notify subscribers when the incident is triggered.
4335
4590
  """
4336
4591
  return pulumi.get(self, "notify_subscribers")
4337
4592
 
4338
- @property
4593
+ @_builtins.property
4339
4594
  @pulumi.getter(name="serviceId")
4340
- def service_id(self) -> str:
4595
+ def service_id(self) -> _builtins.str:
4341
4596
  """
4342
4597
  The status page service that this incident will be associated with.
4343
4598
  """
4344
4599
  return pulumi.get(self, "service_id")
4345
4600
 
4346
- @property
4601
+ @_builtins.property
4347
4602
  @pulumi.getter
4348
- def severity(self) -> str:
4603
+ def severity(self) -> _builtins.str:
4349
4604
  """
4350
4605
  The severity level of the incident. Possible values are `MINOR`, `MEDIUM`, `MAJOR`, and `CRITICAL`.
4351
4606
  """