pulumi-newrelic 5.22.0__py3-none-any.whl → 5.58.0a1763707205__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of pulumi-newrelic might be problematic. Click here for more details.

Files changed (92) hide show
  1. pulumi_newrelic/__init__.py +28 -1
  2. pulumi_newrelic/_inputs.py +10385 -2976
  3. pulumi_newrelic/_utilities.py +50 -10
  4. pulumi_newrelic/account_management.py +48 -42
  5. pulumi_newrelic/alert_channel.py +165 -175
  6. pulumi_newrelic/alert_condition.py +307 -319
  7. pulumi_newrelic/alert_muting_rule.py +193 -140
  8. pulumi_newrelic/alert_policy.py +121 -117
  9. pulumi_newrelic/alert_policy_channel.py +89 -79
  10. pulumi_newrelic/api_access_key.py +195 -193
  11. pulumi_newrelic/browser_application.py +120 -114
  12. pulumi_newrelic/cloud/__init__.py +3 -1
  13. pulumi_newrelic/cloud/_inputs.py +4267 -2714
  14. pulumi_newrelic/cloud/aws_govcloud_integrations.py +206 -196
  15. pulumi_newrelic/cloud/aws_govcloud_link_account.py +143 -228
  16. pulumi_newrelic/cloud/aws_integrations.py +510 -1490
  17. pulumi_newrelic/cloud/aws_link_account.py +80 -76
  18. pulumi_newrelic/cloud/azure_integrations.py +673 -587
  19. pulumi_newrelic/cloud/azure_link_account.py +121 -117
  20. pulumi_newrelic/cloud/gcp_integrations.py +428 -408
  21. pulumi_newrelic/cloud/gcp_link_account.py +65 -61
  22. pulumi_newrelic/cloud/oci_link_account.py +926 -0
  23. pulumi_newrelic/cloud/outputs.py +1678 -2321
  24. pulumi_newrelic/config/__init__.py +2 -1
  25. pulumi_newrelic/config/__init__.pyi +8 -3
  26. pulumi_newrelic/config/vars.py +22 -17
  27. pulumi_newrelic/data_partition_rule.py +119 -117
  28. pulumi_newrelic/entity_tags.py +111 -53
  29. pulumi_newrelic/events_to_metrics_rule.py +106 -102
  30. pulumi_newrelic/get_account.py +41 -33
  31. pulumi_newrelic/get_alert_channel.py +73 -28
  32. pulumi_newrelic/get_alert_policy.py +82 -33
  33. pulumi_newrelic/get_application.py +51 -43
  34. pulumi_newrelic/get_authentication_domain.py +27 -23
  35. pulumi_newrelic/get_cloud_account.py +43 -35
  36. pulumi_newrelic/get_entity.py +126 -183
  37. pulumi_newrelic/get_group.py +76 -31
  38. pulumi_newrelic/get_key_transaction.py +117 -42
  39. pulumi_newrelic/get_notification_destination.py +75 -38
  40. pulumi_newrelic/get_obfuscation_expression.py +47 -39
  41. pulumi_newrelic/get_service_level_alert_helper.py +189 -171
  42. pulumi_newrelic/get_test_grok_pattern.py +47 -36
  43. pulumi_newrelic/get_user.py +39 -31
  44. pulumi_newrelic/group.py +59 -199
  45. pulumi_newrelic/infra_alert_condition.py +399 -405
  46. pulumi_newrelic/insights/__init__.py +2 -1
  47. pulumi_newrelic/insights/_inputs.py +71 -28
  48. pulumi_newrelic/insights/event.py +54 -52
  49. pulumi_newrelic/insights/outputs.py +28 -23
  50. pulumi_newrelic/key_transaction.py +465 -0
  51. pulumi_newrelic/log_parsing_rule.py +159 -157
  52. pulumi_newrelic/monitor_downtime.py +311 -331
  53. pulumi_newrelic/notification_channel.py +534 -464
  54. pulumi_newrelic/notification_destination.py +238 -141
  55. pulumi_newrelic/nrql_alert_condition.py +820 -614
  56. pulumi_newrelic/nrql_drop_rule.py +113 -151
  57. pulumi_newrelic/obfuscation_expression.py +80 -76
  58. pulumi_newrelic/obfuscation_rule.py +115 -109
  59. pulumi_newrelic/one_dashboard.py +110 -104
  60. pulumi_newrelic/one_dashboard_json.py +69 -63
  61. pulumi_newrelic/one_dashboard_raw.py +212 -206
  62. pulumi_newrelic/outputs.py +4936 -2234
  63. pulumi_newrelic/pipeline_cloud_rule.py +335 -0
  64. pulumi_newrelic/plugins/__init__.py +2 -1
  65. pulumi_newrelic/plugins/_inputs.py +519 -89
  66. pulumi_newrelic/plugins/application_settings.py +463 -187
  67. pulumi_newrelic/plugins/outputs.py +336 -74
  68. pulumi_newrelic/plugins/workload.py +313 -189
  69. pulumi_newrelic/provider.py +156 -142
  70. pulumi_newrelic/pulumi-plugin.json +2 -1
  71. pulumi_newrelic/service_level.py +263 -263
  72. pulumi_newrelic/synthetics/__init__.py +2 -1
  73. pulumi_newrelic/synthetics/_inputs.py +265 -108
  74. pulumi_newrelic/synthetics/alert_condition.py +170 -180
  75. pulumi_newrelic/synthetics/broken_links_monitor.py +297 -249
  76. pulumi_newrelic/synthetics/cert_check_monitor.py +306 -258
  77. pulumi_newrelic/synthetics/get_private_location.py +51 -47
  78. pulumi_newrelic/synthetics/get_secure_credential.py +39 -31
  79. pulumi_newrelic/synthetics/monitor.py +658 -460
  80. pulumi_newrelic/synthetics/multi_location_alert_condition.py +211 -205
  81. pulumi_newrelic/synthetics/outputs.py +92 -87
  82. pulumi_newrelic/synthetics/private_location.py +118 -112
  83. pulumi_newrelic/synthetics/script_monitor.py +613 -373
  84. pulumi_newrelic/synthetics/secure_credential.py +97 -95
  85. pulumi_newrelic/synthetics/step_monitor.py +445 -275
  86. pulumi_newrelic/user.py +84 -80
  87. pulumi_newrelic/workflow.py +336 -322
  88. {pulumi_newrelic-5.22.0.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/METADATA +7 -6
  89. pulumi_newrelic-5.58.0a1763707205.dist-info/RECORD +92 -0
  90. {pulumi_newrelic-5.22.0.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/WHEEL +1 -1
  91. pulumi_newrelic-5.22.0.dist-info/RECORD +0 -89
  92. {pulumi_newrelic-5.22.0.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/top_level.txt +0 -0
pulumi_newrelic/monitor_downtime.py CHANGED
@@ -1,12 +1,17 @@
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
+ import sys
7
8
  import pulumi
8
9
  import pulumi.runtime
9
10
  from typing import Any, Mapping, Optional, Sequence, Union, overload
11
+ if sys.version_info >= (3, 11):
12
+ from typing import NotRequired, TypedDict, TypeAlias
13
+ else:
14
+ from typing_extensions import NotRequired, TypedDict, TypeAlias
10
15
  from . import _utilities
11
16
  from . import outputs
12
17
  from ._inputs import *
@@ -16,30 +21,28 @@ __all__ = ['MonitorDowntimeArgs', 'MonitorDowntime']
16
21
  @pulumi.input_type
17
22
  class MonitorDowntimeArgs:
18
23
  def __init__(__self__, *,
19
- end_time: pulumi.Input[str],
20
- mode: pulumi.Input[str],
21
- start_time: pulumi.Input[str],
22
- time_zone: pulumi.Input[str],
23
- account_id: Optional[pulumi.Input[int]] = None,
24
+ end_time: pulumi.Input[_builtins.str],
25
+ mode: pulumi.Input[_builtins.str],
26
+ start_time: pulumi.Input[_builtins.str],
27
+ time_zone: pulumi.Input[_builtins.str],
28
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
24
29
  end_repeat: Optional[pulumi.Input['MonitorDowntimeEndRepeatArgs']] = None,
25
30
  frequency: Optional[pulumi.Input['MonitorDowntimeFrequencyArgs']] = None,
26
- maintenance_days: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
27
- monitor_guids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
28
- name: Optional[pulumi.Input[str]] = None):
31
+ maintenance_days: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
32
+ monitor_guids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
33
+ name: Optional[pulumi.Input[_builtins.str]] = None):
29
34
  """
30
35
  The set of arguments for constructing a MonitorDowntime resource.
31
- :param pulumi.Input[str] end_time: The time at which the monitor downtime would end operating, a timestamp specified in the ISO 8601 format without the offset/timezone - for instance, `2024-01-05T14:27:07`.
32
- :param pulumi.Input[str] mode: One of the four modes of operation of monitor downtimes - `ONE_TIME`, `DAILY`, `MONTHLY` or `WEEKLY`.
33
- :param pulumi.Input[str] start_time: The time at which the monitor downtime would begin to operate, a timestamp specified in the ISO 8601 format without the offset/timezone - for instance, `2023-12-20T10:48:53`.
34
- :param pulumi.Input[str] time_zone: The timezone that applies to the Monitor Downtime schedule.
35
- :param pulumi.Input[int] account_id: The account in which the monitor downtime would be created. Defaults to the value of the environment variable `NEW_RELIC_ACCOUNT_ID` (or the `account_id` specified in the `provider{}`), if not specified.
36
- :param pulumi.Input['MonitorDowntimeEndRepeatArgs'] end_repeat: Options which may be used to specify when the repeat cycle of the monitor should end. This argument comprises the following nested arguments -
37
- :param pulumi.Input['MonitorDowntimeFrequencyArgs'] frequency: Options which may be used to specify the configuration of a monthly monitor downtime. This argument comprises the following nested arguments -
38
- :param pulumi.Input[Sequence[pulumi.Input[str]]] maintenance_days: A list of days on which weekly monitor downtimes would function. Valid values which go into this list would be `"SUNDAY"`, `"MONDAY"`, `"TUESDAY"`, `"WEDNESDAY"`, `"THURSDAY"`, `"FRIDAY"` and/or `"SATURDAY"`.
39
-
40
- > **NOTE:** `maintenance_days` **can only be used with the mode** `WEEKLY`, and **is a required argument** with weekly monitor downtimes (i.e. if the `mode` is `WEEKLY`).
41
- :param pulumi.Input[Sequence[pulumi.Input[str]]] monitor_guids: A list of GUIDs of synthetic monitors the monitor downtime would need to be applied to.
42
- :param pulumi.Input[str] name: Name of the monitor downtime to be created.
36
+ :param pulumi.Input[_builtins.str] end_time: A datetime stamp signifying the end of the Monitor Downtime.
37
+ :param pulumi.Input[_builtins.str] mode: An identifier of the type of Monitor Downtime to be created.
38
+ :param pulumi.Input[_builtins.str] start_time: A datetime stamp signifying the start of the Monitor Downtime.
39
+ :param pulumi.Input[_builtins.str] time_zone: The timezone that applies to the Monitor Downtime schedule.
40
+ :param pulumi.Input[_builtins.str] account_id: The ID of the New Relic account in which the Monitor Downtime shall be created. Defaults to the `account_id` in the provider{} configuration if not specified.
41
+ :param pulumi.Input['MonitorDowntimeEndRepeatArgs'] end_repeat: A specification of when the Monitor Downtime should end its repeat cycle, by number of occurrences or date.
42
+ :param pulumi.Input['MonitorDowntimeFrequencyArgs'] frequency: Configuration options for which days of the month a monitor downtime will occur
43
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] maintenance_days: A list of maintenance days to be included with the created weekly Monitor Downtime.
44
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] monitor_guids: A list of GUIDs of monitors, to which the created Monitor Downtime shall be applied.
45
+ :param pulumi.Input[_builtins.str] name: A name to identify the Monitor Downtime to be created.
43
46
  """
44
47
  pulumi.set(__self__, "end_time", end_time)
45
48
  pulumi.set(__self__, "mode", mode)
@@ -58,71 +61,71 @@ class MonitorDowntimeArgs:
58
61
  if name is not None:
59
62
  pulumi.set(__self__, "name", name)
60
63
 
61
- @property
64
+ @_builtins.property
62
65
  @pulumi.getter(name="endTime")
63
- def end_time(self) -> pulumi.Input[str]:
66
+ def end_time(self) -> pulumi.Input[_builtins.str]:
64
67
  """
65
- The time at which the monitor downtime would end operating, a timestamp specified in the ISO 8601 format without the offset/timezone - for instance, `2024-01-05T14:27:07`.
68
+ A datetime stamp signifying the end of the Monitor Downtime.
66
69
  """
67
70
  return pulumi.get(self, "end_time")
68
71
 
69
72
  @end_time.setter
70
- def end_time(self, value: pulumi.Input[str]):
73
+ def end_time(self, value: pulumi.Input[_builtins.str]):
71
74
  pulumi.set(self, "end_time", value)
72
75
 
73
- @property
76
+ @_builtins.property
74
77
  @pulumi.getter
75
- def mode(self) -> pulumi.Input[str]:
78
+ def mode(self) -> pulumi.Input[_builtins.str]:
76
79
  """
77
- One of the four modes of operation of monitor downtimes - `ONE_TIME`, `DAILY`, `MONTHLY` or `WEEKLY`.
80
+ An identifier of the type of Monitor Downtime to be created.
78
81
  """
79
82
  return pulumi.get(self, "mode")
80
83
 
81
84
  @mode.setter
82
- def mode(self, value: pulumi.Input[str]):
85
+ def mode(self, value: pulumi.Input[_builtins.str]):
83
86
  pulumi.set(self, "mode", value)
84
87
 
85
- @property
88
+ @_builtins.property
86
89
  @pulumi.getter(name="startTime")
87
- def start_time(self) -> pulumi.Input[str]:
90
+ def start_time(self) -> pulumi.Input[_builtins.str]:
88
91
  """
89
- The time at which the monitor downtime would begin to operate, a timestamp specified in the ISO 8601 format without the offset/timezone - for instance, `2023-12-20T10:48:53`.
92
+ A datetime stamp signifying the start of the Monitor Downtime.
90
93
  """
91
94
  return pulumi.get(self, "start_time")
92
95
 
93
96
  @start_time.setter
94
- def start_time(self, value: pulumi.Input[str]):
97
+ def start_time(self, value: pulumi.Input[_builtins.str]):
95
98
  pulumi.set(self, "start_time", value)
96
99
 
97
- @property
100
+ @_builtins.property
98
101
  @pulumi.getter(name="timeZone")
99
- def time_zone(self) -> pulumi.Input[str]:
102
+ def time_zone(self) -> pulumi.Input[_builtins.str]:
100
103
  """
101
104
  The timezone that applies to the Monitor Downtime schedule.
102
105
  """
103
106
  return pulumi.get(self, "time_zone")
104
107
 
105
108
  @time_zone.setter
106
- def time_zone(self, value: pulumi.Input[str]):
109
+ def time_zone(self, value: pulumi.Input[_builtins.str]):
107
110
  pulumi.set(self, "time_zone", value)
108
111
 
109
- @property
112
+ @_builtins.property
110
113
  @pulumi.getter(name="accountId")
111
- def account_id(self) -> Optional[pulumi.Input[int]]:
114
+ def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
112
115
  """
113
- The account in which the monitor downtime would be created. Defaults to the value of the environment variable `NEW_RELIC_ACCOUNT_ID` (or the `account_id` specified in the `provider{}`), if not specified.
116
+ The ID of the New Relic account in which the Monitor Downtime shall be created. Defaults to the `account_id` in the provider{} configuration if not specified.
114
117
  """
115
118
  return pulumi.get(self, "account_id")
116
119
 
117
120
  @account_id.setter
118
- def account_id(self, value: Optional[pulumi.Input[int]]):
121
+ def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
119
122
  pulumi.set(self, "account_id", value)
120
123
 
121
- @property
124
+ @_builtins.property
122
125
  @pulumi.getter(name="endRepeat")
123
126
  def end_repeat(self) -> Optional[pulumi.Input['MonitorDowntimeEndRepeatArgs']]:
124
127
  """
125
- Options which may be used to specify when the repeat cycle of the monitor should end. This argument comprises the following nested arguments -
128
+ A specification of when the Monitor Downtime should end its repeat cycle, by number of occurrences or date.
126
129
  """
127
130
  return pulumi.get(self, "end_repeat")
128
131
 
@@ -130,11 +133,11 @@ class MonitorDowntimeArgs:
130
133
  def end_repeat(self, value: Optional[pulumi.Input['MonitorDowntimeEndRepeatArgs']]):
131
134
  pulumi.set(self, "end_repeat", value)
132
135
 
133
- @property
136
+ @_builtins.property
134
137
  @pulumi.getter
135
138
  def frequency(self) -> Optional[pulumi.Input['MonitorDowntimeFrequencyArgs']]:
136
139
  """
137
- Options which may be used to specify the configuration of a monthly monitor downtime. This argument comprises the following nested arguments -
140
+ Configuration options for which days of the month a monitor downtime will occur
138
141
  """
139
142
  return pulumi.get(self, "frequency")
140
143
 
@@ -142,72 +145,68 @@ class MonitorDowntimeArgs:
142
145
  def frequency(self, value: Optional[pulumi.Input['MonitorDowntimeFrequencyArgs']]):
143
146
  pulumi.set(self, "frequency", value)
144
147
 
145
- @property
148
+ @_builtins.property
146
149
  @pulumi.getter(name="maintenanceDays")
147
- def maintenance_days(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
150
+ def maintenance_days(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
148
151
  """
149
- A list of days on which weekly monitor downtimes would function. Valid values which go into this list would be `"SUNDAY"`, `"MONDAY"`, `"TUESDAY"`, `"WEDNESDAY"`, `"THURSDAY"`, `"FRIDAY"` and/or `"SATURDAY"`.
150
-
151
- > **NOTE:** `maintenance_days` **can only be used with the mode** `WEEKLY`, and **is a required argument** with weekly monitor downtimes (i.e. if the `mode` is `WEEKLY`).
152
+ A list of maintenance days to be included with the created weekly Monitor Downtime.
152
153
  """
153
154
  return pulumi.get(self, "maintenance_days")
154
155
 
155
156
  @maintenance_days.setter
156
- def maintenance_days(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
157
+ def maintenance_days(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
157
158
  pulumi.set(self, "maintenance_days", value)
158
159
 
159
- @property
160
+ @_builtins.property
160
161
  @pulumi.getter(name="monitorGuids")
161
- def monitor_guids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
162
+ def monitor_guids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
162
163
  """
163
- A list of GUIDs of synthetic monitors the monitor downtime would need to be applied to.
164
+ A list of GUIDs of monitors, to which the created Monitor Downtime shall be applied.
164
165
  """
165
166
  return pulumi.get(self, "monitor_guids")
166
167
 
167
168
  @monitor_guids.setter
168
- def monitor_guids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
169
+ def monitor_guids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
169
170
  pulumi.set(self, "monitor_guids", value)
170
171
 
171
- @property
172
+ @_builtins.property
172
173
  @pulumi.getter
173
- def name(self) -> Optional[pulumi.Input[str]]:
174
+ def name(self) -> Optional[pulumi.Input[_builtins.str]]:
174
175
  """
175
- Name of the monitor downtime to be created.
176
+ A name to identify the Monitor Downtime to be created.
176
177
  """
177
178
  return pulumi.get(self, "name")
178
179
 
179
180
  @name.setter
180
- def name(self, value: Optional[pulumi.Input[str]]):
181
+ def name(self, value: Optional[pulumi.Input[_builtins.str]]):
181
182
  pulumi.set(self, "name", value)
182
183
 
183
184
 
184
185
  @pulumi.input_type
185
186
  class _MonitorDowntimeState:
186
187
  def __init__(__self__, *,
187
- account_id: Optional[pulumi.Input[int]] = None,
188
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
188
189
  end_repeat: Optional[pulumi.Input['MonitorDowntimeEndRepeatArgs']] = None,
189
- end_time: Optional[pulumi.Input[str]] = None,
190
+ end_time: Optional[pulumi.Input[_builtins.str]] = None,
190
191
  frequency: Optional[pulumi.Input['MonitorDowntimeFrequencyArgs']] = None,
191
- maintenance_days: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
192
- mode: Optional[pulumi.Input[str]] = None,
193
- monitor_guids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
194
- name: Optional[pulumi.Input[str]] = None,
195
- start_time: Optional[pulumi.Input[str]] = None,
196
- time_zone: Optional[pulumi.Input[str]] = None):
192
+ maintenance_days: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
193
+ mode: Optional[pulumi.Input[_builtins.str]] = None,
194
+ monitor_guids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
195
+ name: Optional[pulumi.Input[_builtins.str]] = None,
196
+ start_time: Optional[pulumi.Input[_builtins.str]] = None,
197
+ time_zone: Optional[pulumi.Input[_builtins.str]] = None):
197
198
  """
198
199
  Input properties used for looking up and filtering MonitorDowntime resources.
199
- :param pulumi.Input[int] account_id: The account in which the monitor downtime would be created. Defaults to the value of the environment variable `NEW_RELIC_ACCOUNT_ID` (or the `account_id` specified in the `provider{}`), if not specified.
200
- :param pulumi.Input['MonitorDowntimeEndRepeatArgs'] end_repeat: Options which may be used to specify when the repeat cycle of the monitor should end. This argument comprises the following nested arguments -
201
- :param pulumi.Input[str] end_time: The time at which the monitor downtime would end operating, a timestamp specified in the ISO 8601 format without the offset/timezone - for instance, `2024-01-05T14:27:07`.
202
- :param pulumi.Input['MonitorDowntimeFrequencyArgs'] frequency: Options which may be used to specify the configuration of a monthly monitor downtime. This argument comprises the following nested arguments -
203
- :param pulumi.Input[Sequence[pulumi.Input[str]]] maintenance_days: A list of days on which weekly monitor downtimes would function. Valid values which go into this list would be `"SUNDAY"`, `"MONDAY"`, `"TUESDAY"`, `"WEDNESDAY"`, `"THURSDAY"`, `"FRIDAY"` and/or `"SATURDAY"`.
204
-
205
- > **NOTE:** `maintenance_days` **can only be used with the mode** `WEEKLY`, and **is a required argument** with weekly monitor downtimes (i.e. if the `mode` is `WEEKLY`).
206
- :param pulumi.Input[str] mode: One of the four modes of operation of monitor downtimes - `ONE_TIME`, `DAILY`, `MONTHLY` or `WEEKLY`.
207
- :param pulumi.Input[Sequence[pulumi.Input[str]]] monitor_guids: A list of GUIDs of synthetic monitors the monitor downtime would need to be applied to.
208
- :param pulumi.Input[str] name: Name of the monitor downtime to be created.
209
- :param pulumi.Input[str] start_time: The time at which the monitor downtime would begin to operate, a timestamp specified in the ISO 8601 format without the offset/timezone - for instance, `2023-12-20T10:48:53`.
210
- :param pulumi.Input[str] time_zone: The timezone that applies to the Monitor Downtime schedule.
200
+ :param pulumi.Input[_builtins.str] account_id: The ID of the New Relic account in which the Monitor Downtime shall be created. Defaults to the `account_id` in the provider{} configuration if not specified.
201
+ :param pulumi.Input['MonitorDowntimeEndRepeatArgs'] end_repeat: A specification of when the Monitor Downtime should end its repeat cycle, by number of occurrences or date.
202
+ :param pulumi.Input[_builtins.str] end_time: A datetime stamp signifying the end of the Monitor Downtime.
203
+ :param pulumi.Input['MonitorDowntimeFrequencyArgs'] frequency: Configuration options for which days of the month a monitor downtime will occur
204
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] maintenance_days: A list of maintenance days to be included with the created weekly Monitor Downtime.
205
+ :param pulumi.Input[_builtins.str] mode: An identifier of the type of Monitor Downtime to be created.
206
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] monitor_guids: A list of GUIDs of monitors, to which the created Monitor Downtime shall be applied.
207
+ :param pulumi.Input[_builtins.str] name: A name to identify the Monitor Downtime to be created.
208
+ :param pulumi.Input[_builtins.str] start_time: A datetime stamp signifying the start of the Monitor Downtime.
209
+ :param pulumi.Input[_builtins.str] time_zone: The timezone that applies to the Monitor Downtime schedule.
211
210
  """
212
211
  if account_id is not None:
213
212
  pulumi.set(__self__, "account_id", account_id)
@@ -230,23 +229,23 @@ class _MonitorDowntimeState:
230
229
  if time_zone is not None:
231
230
  pulumi.set(__self__, "time_zone", time_zone)
232
231
 
233
- @property
232
+ @_builtins.property
234
233
  @pulumi.getter(name="accountId")
235
- def account_id(self) -> Optional[pulumi.Input[int]]:
234
+ def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
236
235
  """
237
- The account in which the monitor downtime would be created. Defaults to the value of the environment variable `NEW_RELIC_ACCOUNT_ID` (or the `account_id` specified in the `provider{}`), if not specified.
236
+ The ID of the New Relic account in which the Monitor Downtime shall be created. Defaults to the `account_id` in the provider{} configuration if not specified.
238
237
  """
239
238
  return pulumi.get(self, "account_id")
240
239
 
241
240
  @account_id.setter
242
- def account_id(self, value: Optional[pulumi.Input[int]]):
241
+ def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
243
242
  pulumi.set(self, "account_id", value)
244
243
 
245
- @property
244
+ @_builtins.property
246
245
  @pulumi.getter(name="endRepeat")
247
246
  def end_repeat(self) -> Optional[pulumi.Input['MonitorDowntimeEndRepeatArgs']]:
248
247
  """
249
- Options which may be used to specify when the repeat cycle of the monitor should end. This argument comprises the following nested arguments -
248
+ A specification of when the Monitor Downtime should end its repeat cycle, by number of occurrences or date.
250
249
  """
251
250
  return pulumi.get(self, "end_repeat")
252
251
 
@@ -254,23 +253,23 @@ class _MonitorDowntimeState:
254
253
  def end_repeat(self, value: Optional[pulumi.Input['MonitorDowntimeEndRepeatArgs']]):
255
254
  pulumi.set(self, "end_repeat", value)
256
255
 
257
- @property
256
+ @_builtins.property
258
257
  @pulumi.getter(name="endTime")
259
- def end_time(self) -> Optional[pulumi.Input[str]]:
258
+ def end_time(self) -> Optional[pulumi.Input[_builtins.str]]:
260
259
  """
261
- The time at which the monitor downtime would end operating, a timestamp specified in the ISO 8601 format without the offset/timezone - for instance, `2024-01-05T14:27:07`.
260
+ A datetime stamp signifying the end of the Monitor Downtime.
262
261
  """
263
262
  return pulumi.get(self, "end_time")
264
263
 
265
264
  @end_time.setter
266
- def end_time(self, value: Optional[pulumi.Input[str]]):
265
+ def end_time(self, value: Optional[pulumi.Input[_builtins.str]]):
267
266
  pulumi.set(self, "end_time", value)
268
267
 
269
- @property
268
+ @_builtins.property
270
269
  @pulumi.getter
271
270
  def frequency(self) -> Optional[pulumi.Input['MonitorDowntimeFrequencyArgs']]:
272
271
  """
273
- Options which may be used to specify the configuration of a monthly monitor downtime. This argument comprises the following nested arguments -
272
+ Configuration options for which days of the month a monitor downtime will occur
274
273
  """
275
274
  return pulumi.get(self, "frequency")
276
275
 
@@ -278,125 +277,123 @@ class _MonitorDowntimeState:
278
277
  def frequency(self, value: Optional[pulumi.Input['MonitorDowntimeFrequencyArgs']]):
279
278
  pulumi.set(self, "frequency", value)
280
279
 
281
- @property
280
+ @_builtins.property
282
281
  @pulumi.getter(name="maintenanceDays")
283
- def maintenance_days(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
282
+ def maintenance_days(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
284
283
  """
285
- A list of days on which weekly monitor downtimes would function. Valid values which go into this list would be `"SUNDAY"`, `"MONDAY"`, `"TUESDAY"`, `"WEDNESDAY"`, `"THURSDAY"`, `"FRIDAY"` and/or `"SATURDAY"`.
286
-
287
- > **NOTE:** `maintenance_days` **can only be used with the mode** `WEEKLY`, and **is a required argument** with weekly monitor downtimes (i.e. if the `mode` is `WEEKLY`).
284
+ A list of maintenance days to be included with the created weekly Monitor Downtime.
288
285
  """
289
286
  return pulumi.get(self, "maintenance_days")
290
287
 
291
288
  @maintenance_days.setter
292
- def maintenance_days(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
289
+ def maintenance_days(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
293
290
  pulumi.set(self, "maintenance_days", value)
294
291
 
295
- @property
292
+ @_builtins.property
296
293
  @pulumi.getter
297
- def mode(self) -> Optional[pulumi.Input[str]]:
294
+ def mode(self) -> Optional[pulumi.Input[_builtins.str]]:
298
295
  """
299
- One of the four modes of operation of monitor downtimes - `ONE_TIME`, `DAILY`, `MONTHLY` or `WEEKLY`.
296
+ An identifier of the type of Monitor Downtime to be created.
300
297
  """
301
298
  return pulumi.get(self, "mode")
302
299
 
303
300
  @mode.setter
304
- def mode(self, value: Optional[pulumi.Input[str]]):
301
+ def mode(self, value: Optional[pulumi.Input[_builtins.str]]):
305
302
  pulumi.set(self, "mode", value)
306
303
 
307
- @property
304
+ @_builtins.property
308
305
  @pulumi.getter(name="monitorGuids")
309
- def monitor_guids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
306
+ def monitor_guids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
310
307
  """
311
- A list of GUIDs of synthetic monitors the monitor downtime would need to be applied to.
308
+ A list of GUIDs of monitors, to which the created Monitor Downtime shall be applied.
312
309
  """
313
310
  return pulumi.get(self, "monitor_guids")
314
311
 
315
312
  @monitor_guids.setter
316
- def monitor_guids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
313
+ def monitor_guids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
317
314
  pulumi.set(self, "monitor_guids", value)
318
315
 
319
- @property
316
+ @_builtins.property
320
317
  @pulumi.getter
321
- def name(self) -> Optional[pulumi.Input[str]]:
318
+ def name(self) -> Optional[pulumi.Input[_builtins.str]]:
322
319
  """
323
- Name of the monitor downtime to be created.
320
+ A name to identify the Monitor Downtime to be created.
324
321
  """
325
322
  return pulumi.get(self, "name")
326
323
 
327
324
  @name.setter
328
- def name(self, value: Optional[pulumi.Input[str]]):
325
+ def name(self, value: Optional[pulumi.Input[_builtins.str]]):
329
326
  pulumi.set(self, "name", value)
330
327
 
331
- @property
328
+ @_builtins.property
332
329
  @pulumi.getter(name="startTime")
333
- def start_time(self) -> Optional[pulumi.Input[str]]:
330
+ def start_time(self) -> Optional[pulumi.Input[_builtins.str]]:
334
331
  """
335
- The time at which the monitor downtime would begin to operate, a timestamp specified in the ISO 8601 format without the offset/timezone - for instance, `2023-12-20T10:48:53`.
332
+ A datetime stamp signifying the start of the Monitor Downtime.
336
333
  """
337
334
  return pulumi.get(self, "start_time")
338
335
 
339
336
  @start_time.setter
340
- def start_time(self, value: Optional[pulumi.Input[str]]):
337
+ def start_time(self, value: Optional[pulumi.Input[_builtins.str]]):
341
338
  pulumi.set(self, "start_time", value)
342
339
 
343
- @property
340
+ @_builtins.property
344
341
  @pulumi.getter(name="timeZone")
345
- def time_zone(self) -> Optional[pulumi.Input[str]]:
342
+ def time_zone(self) -> Optional[pulumi.Input[_builtins.str]]:
346
343
  """
347
344
  The timezone that applies to the Monitor Downtime schedule.
348
345
  """
349
346
  return pulumi.get(self, "time_zone")
350
347
 
351
348
  @time_zone.setter
352
- def time_zone(self, value: Optional[pulumi.Input[str]]):
349
+ def time_zone(self, value: Optional[pulumi.Input[_builtins.str]]):
353
350
  pulumi.set(self, "time_zone", value)
354
351
 
355
352
 
353
+ @pulumi.type_token("newrelic:index/monitorDowntime:MonitorDowntime")
356
354
  class MonitorDowntime(pulumi.CustomResource):
357
355
  @overload
358
356
  def __init__(__self__,
359
357
  resource_name: str,
360
358
  opts: Optional[pulumi.ResourceOptions] = None,
361
- account_id: Optional[pulumi.Input[int]] = None,
362
- end_repeat: Optional[pulumi.Input[pulumi.InputType['MonitorDowntimeEndRepeatArgs']]] = None,
363
- end_time: Optional[pulumi.Input[str]] = None,
364
- frequency: Optional[pulumi.Input[pulumi.InputType['MonitorDowntimeFrequencyArgs']]] = None,
365
- maintenance_days: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
366
- mode: Optional[pulumi.Input[str]] = None,
367
- monitor_guids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
368
- name: Optional[pulumi.Input[str]] = None,
369
- start_time: Optional[pulumi.Input[str]] = None,
370
- time_zone: Optional[pulumi.Input[str]] = None,
359
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
360
+ end_repeat: Optional[pulumi.Input[Union['MonitorDowntimeEndRepeatArgs', 'MonitorDowntimeEndRepeatArgsDict']]] = None,
361
+ end_time: Optional[pulumi.Input[_builtins.str]] = None,
362
+ frequency: Optional[pulumi.Input[Union['MonitorDowntimeFrequencyArgs', 'MonitorDowntimeFrequencyArgsDict']]] = None,
363
+ maintenance_days: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
364
+ mode: Optional[pulumi.Input[_builtins.str]] = None,
365
+ monitor_guids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
366
+ name: Optional[pulumi.Input[_builtins.str]] = None,
367
+ start_time: Optional[pulumi.Input[_builtins.str]] = None,
368
+ time_zone: Optional[pulumi.Input[_builtins.str]] = None,
371
369
  __props__=None):
372
370
  """
373
371
  Use this resource to create, update, and delete [Monitor Downtimes](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/using-monitors/monitor-downtimes-disable-monitoring-during-scheduled-maintenance-times/) in New Relic.
374
372
 
375
373
  ## Example Usage
376
374
 
377
- <!--Start PulumiCodeChooser -->
378
375
  ```python
379
376
  import pulumi
380
377
  import pulumi_newrelic as newrelic
381
378
 
382
379
  foo = newrelic.MonitorDowntime("foo",
383
- end_repeat=newrelic.MonitorDowntimeEndRepeatArgs(
384
- on_date="2023-12-20",
385
- ),
386
- end_time="2023-12-10T02:45:30",
387
- maintenance_days=[
388
- "FRIDAY",
389
- "SATURDAY",
390
- ],
391
- mode="WEEKLY",
380
+ name="Sample Monitor Downtime",
392
381
  monitor_guids=[
393
382
  "<GUID-1>",
394
383
  "<GUID-2>",
395
384
  ],
385
+ mode="WEEKLY",
396
386
  start_time="2023-11-30T10:30:00",
397
- time_zone="Asia/Kolkata")
387
+ end_time="2023-12-10T02:45:30",
388
+ time_zone="Asia/Kolkata",
389
+ end_repeat={
390
+ "on_date": "2023-12-20",
391
+ },
392
+ maintenance_days=[
393
+ "FRIDAY",
394
+ "SATURDAY",
395
+ ])
398
396
  ```
399
- <!--End PulumiCodeChooser -->
400
397
  Monitor Downtimes are of four types; **one-time**, **daily**, **weekly** and **monthly**. For more details on each type and the right arguments that go with them, check out the argument reference and examples sections below.
401
398
 
402
399
  ## Examples
@@ -405,22 +402,21 @@ class MonitorDowntime(pulumi.CustomResource):
405
402
 
406
403
  The below example illustrates creating a **one-time** monitor downtime.
407
404
 
408
- <!--Start PulumiCodeChooser -->
409
405
  ```python
410
406
  import pulumi
411
407
  import pulumi_newrelic as newrelic
412
408
 
413
- sample_one_time_newrelic_monitor_downtime = newrelic.MonitorDowntime("sampleOneTimeNewrelicMonitorDowntime",
414
- end_time="2024-01-04T16:24:30",
415
- mode="ONE_TIME",
409
+ sample_one_time_newrelic_monitor_downtime = newrelic.MonitorDowntime("sample_one_time_newrelic_monitor_downtime",
410
+ name="Sample One Time Monitor Downtime",
416
411
  monitor_guids=[
417
412
  "<GUID-1>",
418
413
  "<GUID-2>",
419
414
  ],
415
+ mode="ONE_TIME",
420
416
  start_time="2023-12-04T10:15:00",
417
+ end_time="2024-01-04T16:24:30",
421
418
  time_zone="America/Los_Angeles")
422
419
  ```
423
- <!--End PulumiCodeChooser -->
424
420
 
425
421
  ### Daily Monitor Downtime
426
422
 
@@ -428,25 +424,24 @@ class MonitorDowntime(pulumi.CustomResource):
428
424
 
429
425
  Note that `end_repeat` has been specified in the configuration; however, this is optional, in accordance with the rules of `end_repeat` specified in the argument reference section above. This example uses the `on_date` nested argument of `end_repeat`, however, the other nested argument, `on_repeat` may also be used _instead_, as you may see in some of the other examples below; though both `on_date` and `on_repeat` cannot be specified together, as they are mutually exclusive.
430
426
 
431
- <!--Start PulumiCodeChooser -->
432
427
  ```python
433
428
  import pulumi
434
429
  import pulumi_newrelic as newrelic
435
430
 
436
- sample_daily_newrelic_monitor_downtime = newrelic.MonitorDowntime("sampleDailyNewrelicMonitorDowntime",
437
- end_repeat=newrelic.MonitorDowntimeEndRepeatArgs(
438
- on_date="2023-12-25",
439
- ),
440
- end_time="2024-01-04T07:15:00",
441
- mode="DAILY",
431
+ sample_daily_newrelic_monitor_downtime = newrelic.MonitorDowntime("sample_daily_newrelic_monitor_downtime",
432
+ name="Sample Daily Monitor Downtime",
442
433
  monitor_guids=[
443
434
  "<GUID-1>",
444
435
  "<GUID-2>",
445
436
  ],
437
+ mode="DAILY",
446
438
  start_time="2023-12-04T18:15:00",
439
+ end_time="2024-01-04T07:15:00",
440
+ end_repeat={
441
+ "on_date": "2023-12-25",
442
+ },
447
443
  time_zone="Asia/Kolkata")
448
444
  ```
449
- <!--End PulumiCodeChooser -->
450
445
 
451
446
  ### Weekly Monitor Downtime
452
447
 
@@ -454,26 +449,25 @@ class MonitorDowntime(pulumi.CustomResource):
454
449
 
455
450
  Note that `maintenance_days` has been specified in the configuration as it is required with weekly monitor downtimes; and `end_repeat` has not been specified as it is optional, all in accordance with the rules of these arguments specified in the argument reference section above.
456
451
 
457
- <!--Start PulumiCodeChooser -->
458
452
  ```python
459
453
  import pulumi
460
454
  import pulumi_newrelic as newrelic
461
455
 
462
- sample_weekly_newrelic_monitor_downtime = newrelic.MonitorDowntime("sampleWeeklyNewrelicMonitorDowntime",
463
- end_time="2024-01-04T23:55:00",
464
- maintenance_days=[
465
- "SATURDAY",
466
- "SUNDAY",
467
- ],
468
- mode="WEEKLY",
456
+ sample_weekly_newrelic_monitor_downtime = newrelic.MonitorDowntime("sample_weekly_newrelic_monitor_downtime",
457
+ name="Sample Weekly Monitor Downtime",
469
458
  monitor_guids=[
470
459
  "<GUID-1>",
471
460
  "<GUID-2>",
472
461
  ],
462
+ mode="WEEKLY",
473
463
  start_time="2023-12-04T14:15:00",
474
- time_zone="US/Hawaii")
464
+ end_time="2024-01-04T23:55:00",
465
+ time_zone="US/Hawaii",
466
+ maintenance_days=[
467
+ "SATURDAY",
468
+ "SUNDAY",
469
+ ])
475
470
  ```
476
- <!--End PulumiCodeChooser -->
477
471
 
478
472
  ### Monthly Monitor Downtime
479
473
 
@@ -481,59 +475,57 @@ class MonitorDowntime(pulumi.CustomResource):
481
475
 
482
476
  Note that `frequency` has been specified in the configuration as it is required with monthly monitor downtimes, and `end_repeat` has been specified too, though it is optional. `frequency` has been specified with `days_of_week` comprising both of its nested arguments, `ordinal_day_of_month` and `week_day`; all in accordance with the rules of these arguments specified in the argument reference section above.
483
477
 
484
- <!--Start PulumiCodeChooser -->
485
478
  ```python
486
479
  import pulumi
487
480
  import pulumi_newrelic as newrelic
488
481
 
489
- sample_monthly_newrelic_monitor_downtime = newrelic.MonitorDowntime("sampleMonthlyNewrelicMonitorDowntime",
490
- end_repeat=newrelic.MonitorDowntimeEndRepeatArgs(
491
- on_repeat=6,
492
- ),
493
- end_time="2024-01-04T19:15:00",
494
- frequency=newrelic.MonitorDowntimeFrequencyArgs(
495
- days_of_week=newrelic.MonitorDowntimeFrequencyDaysOfWeekArgs(
496
- ordinal_day_of_month="SECOND",
497
- week_day="SATURDAY",
498
- ),
499
- ),
500
- mode="MONTHLY",
482
+ sample_monthly_newrelic_monitor_downtime = newrelic.MonitorDowntime("sample_monthly_newrelic_monitor_downtime",
483
+ name="Sample Monthly Monitor Downtime",
501
484
  monitor_guids=[
502
485
  "<GUID-1>",
503
486
  "<GUID-2>",
504
487
  ],
488
+ mode="MONTHLY",
505
489
  start_time="2023-12-04T07:15:00",
506
- time_zone="Europe/Dublin")
490
+ end_time="2024-01-04T19:15:00",
491
+ end_repeat={
492
+ "on_repeat": 6,
493
+ },
494
+ time_zone="Europe/Dublin",
495
+ frequency={
496
+ "days_of_week": {
497
+ "ordinal_day_of_month": "SECOND",
498
+ "week_day": "SATURDAY",
499
+ },
500
+ })
507
501
  ```
508
- <!--End PulumiCodeChooser -->
509
502
  However, the `frequency` block in monthly monitor downtimes may also be specified with its other nested argument, `days_of_month`, as shown in the example below - though both `days_of_month` and `days_of_week` cannot be specified together, as they are mutually exclusive.
510
- <!--Start PulumiCodeChooser -->
511
503
  ```python
512
504
  import pulumi
513
505
  import pulumi_newrelic as newrelic
514
506
 
515
- sample_monthly_newrelic_monitor_downtime = newrelic.MonitorDowntime("sampleMonthlyNewrelicMonitorDowntime",
516
- end_repeat=newrelic.MonitorDowntimeEndRepeatArgs(
517
- on_repeat=6,
518
- ),
507
+ sample_monthly_newrelic_monitor_downtime = newrelic.MonitorDowntime("sample_monthly_newrelic_monitor_downtime",
508
+ name="Sample Monthly Monitor Downtime",
509
+ monitor_guids=[
510
+ "<GUID-1>",
511
+ "<GUID-2>",
512
+ ],
513
+ mode="MONTHLY",
514
+ start_time="2023-12-04T07:15:00",
519
515
  end_time="2024-01-04T19:15:00",
520
- frequency=newrelic.MonitorDowntimeFrequencyArgs(
521
- days_of_months=[
516
+ end_repeat={
517
+ "on_repeat": 6,
518
+ },
519
+ time_zone="Europe/Dublin",
520
+ frequency={
521
+ "days_of_months": [
522
522
  3,
523
523
  6,
524
524
  14,
525
525
  23,
526
526
  ],
527
- ),
528
- mode="MONTHLY",
529
- monitor_guids=[
530
- "<GUID-1>",
531
- "<GUID-2>",
532
- ],
533
- start_time="2023-12-04T07:15:00",
534
- time_zone="Europe/Dublin")
527
+ })
535
528
  ```
536
- <!--End PulumiCodeChooser -->
537
529
 
538
530
  ## Import
539
531
 
@@ -547,18 +539,16 @@ class MonitorDowntime(pulumi.CustomResource):
547
539
 
548
540
  :param str resource_name: The name of the resource.
549
541
  :param pulumi.ResourceOptions opts: Options for the resource.
550
- :param pulumi.Input[int] account_id: The account in which the monitor downtime would be created. Defaults to the value of the environment variable `NEW_RELIC_ACCOUNT_ID` (or the `account_id` specified in the `provider{}`), if not specified.
551
- :param pulumi.Input[pulumi.InputType['MonitorDowntimeEndRepeatArgs']] end_repeat: Options which may be used to specify when the repeat cycle of the monitor should end. This argument comprises the following nested arguments -
552
- :param pulumi.Input[str] end_time: The time at which the monitor downtime would end operating, a timestamp specified in the ISO 8601 format without the offset/timezone - for instance, `2024-01-05T14:27:07`.
553
- :param pulumi.Input[pulumi.InputType['MonitorDowntimeFrequencyArgs']] frequency: Options which may be used to specify the configuration of a monthly monitor downtime. This argument comprises the following nested arguments -
554
- :param pulumi.Input[Sequence[pulumi.Input[str]]] maintenance_days: A list of days on which weekly monitor downtimes would function. Valid values which go into this list would be `"SUNDAY"`, `"MONDAY"`, `"TUESDAY"`, `"WEDNESDAY"`, `"THURSDAY"`, `"FRIDAY"` and/or `"SATURDAY"`.
555
-
556
- > **NOTE:** `maintenance_days` **can only be used with the mode** `WEEKLY`, and **is a required argument** with weekly monitor downtimes (i.e. if the `mode` is `WEEKLY`).
557
- :param pulumi.Input[str] mode: One of the four modes of operation of monitor downtimes - `ONE_TIME`, `DAILY`, `MONTHLY` or `WEEKLY`.
558
- :param pulumi.Input[Sequence[pulumi.Input[str]]] monitor_guids: A list of GUIDs of synthetic monitors the monitor downtime would need to be applied to.
559
- :param pulumi.Input[str] name: Name of the monitor downtime to be created.
560
- :param pulumi.Input[str] start_time: The time at which the monitor downtime would begin to operate, a timestamp specified in the ISO 8601 format without the offset/timezone - for instance, `2023-12-20T10:48:53`.
561
- :param pulumi.Input[str] time_zone: The timezone that applies to the Monitor Downtime schedule.
542
+ :param pulumi.Input[_builtins.str] account_id: The ID of the New Relic account in which the Monitor Downtime shall be created. Defaults to the `account_id` in the provider{} configuration if not specified.
543
+ :param pulumi.Input[Union['MonitorDowntimeEndRepeatArgs', 'MonitorDowntimeEndRepeatArgsDict']] end_repeat: A specification of when the Monitor Downtime should end its repeat cycle, by number of occurrences or date.
544
+ :param pulumi.Input[_builtins.str] end_time: A datetime stamp signifying the end of the Monitor Downtime.
545
+ :param pulumi.Input[Union['MonitorDowntimeFrequencyArgs', 'MonitorDowntimeFrequencyArgsDict']] frequency: Configuration options for which days of the month a monitor downtime will occur
546
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] maintenance_days: A list of maintenance days to be included with the created weekly Monitor Downtime.
547
+ :param pulumi.Input[_builtins.str] mode: An identifier of the type of Monitor Downtime to be created.
548
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] monitor_guids: A list of GUIDs of monitors, to which the created Monitor Downtime shall be applied.
549
+ :param pulumi.Input[_builtins.str] name: A name to identify the Monitor Downtime to be created.
550
+ :param pulumi.Input[_builtins.str] start_time: A datetime stamp signifying the start of the Monitor Downtime.
551
+ :param pulumi.Input[_builtins.str] time_zone: The timezone that applies to the Monitor Downtime schedule.
562
552
  """
563
553
  ...
564
554
  @overload
@@ -571,29 +561,28 @@ class MonitorDowntime(pulumi.CustomResource):
571
561
 
572
562
  ## Example Usage
573
563
 
574
- <!--Start PulumiCodeChooser -->
575
564
  ```python
576
565
  import pulumi
577
566
  import pulumi_newrelic as newrelic
578
567
 
579
568
  foo = newrelic.MonitorDowntime("foo",
580
- end_repeat=newrelic.MonitorDowntimeEndRepeatArgs(
581
- on_date="2023-12-20",
582
- ),
583
- end_time="2023-12-10T02:45:30",
584
- maintenance_days=[
585
- "FRIDAY",
586
- "SATURDAY",
587
- ],
588
- mode="WEEKLY",
569
+ name="Sample Monitor Downtime",
589
570
  monitor_guids=[
590
571
  "<GUID-1>",
591
572
  "<GUID-2>",
592
573
  ],
574
+ mode="WEEKLY",
593
575
  start_time="2023-11-30T10:30:00",
594
- time_zone="Asia/Kolkata")
576
+ end_time="2023-12-10T02:45:30",
577
+ time_zone="Asia/Kolkata",
578
+ end_repeat={
579
+ "on_date": "2023-12-20",
580
+ },
581
+ maintenance_days=[
582
+ "FRIDAY",
583
+ "SATURDAY",
584
+ ])
595
585
  ```
596
- <!--End PulumiCodeChooser -->
597
586
  Monitor Downtimes are of four types; **one-time**, **daily**, **weekly** and **monthly**. For more details on each type and the right arguments that go with them, check out the argument reference and examples sections below.
598
587
 
599
588
  ## Examples
@@ -602,22 +591,21 @@ class MonitorDowntime(pulumi.CustomResource):
602
591
 
603
592
  The below example illustrates creating a **one-time** monitor downtime.
604
593
 
605
- <!--Start PulumiCodeChooser -->
606
594
  ```python
607
595
  import pulumi
608
596
  import pulumi_newrelic as newrelic
609
597
 
610
- sample_one_time_newrelic_monitor_downtime = newrelic.MonitorDowntime("sampleOneTimeNewrelicMonitorDowntime",
611
- end_time="2024-01-04T16:24:30",
612
- mode="ONE_TIME",
598
+ sample_one_time_newrelic_monitor_downtime = newrelic.MonitorDowntime("sample_one_time_newrelic_monitor_downtime",
599
+ name="Sample One Time Monitor Downtime",
613
600
  monitor_guids=[
614
601
  "<GUID-1>",
615
602
  "<GUID-2>",
616
603
  ],
604
+ mode="ONE_TIME",
617
605
  start_time="2023-12-04T10:15:00",
606
+ end_time="2024-01-04T16:24:30",
618
607
  time_zone="America/Los_Angeles")
619
608
  ```
620
- <!--End PulumiCodeChooser -->
621
609
 
622
610
  ### Daily Monitor Downtime
623
611
 
@@ -625,25 +613,24 @@ class MonitorDowntime(pulumi.CustomResource):
625
613
 
626
614
  Note that `end_repeat` has been specified in the configuration; however, this is optional, in accordance with the rules of `end_repeat` specified in the argument reference section above. This example uses the `on_date` nested argument of `end_repeat`, however, the other nested argument, `on_repeat` may also be used _instead_, as you may see in some of the other examples below; though both `on_date` and `on_repeat` cannot be specified together, as they are mutually exclusive.
627
615
 
628
- <!--Start PulumiCodeChooser -->
629
616
  ```python
630
617
  import pulumi
631
618
  import pulumi_newrelic as newrelic
632
619
 
633
- sample_daily_newrelic_monitor_downtime = newrelic.MonitorDowntime("sampleDailyNewrelicMonitorDowntime",
634
- end_repeat=newrelic.MonitorDowntimeEndRepeatArgs(
635
- on_date="2023-12-25",
636
- ),
637
- end_time="2024-01-04T07:15:00",
638
- mode="DAILY",
620
+ sample_daily_newrelic_monitor_downtime = newrelic.MonitorDowntime("sample_daily_newrelic_monitor_downtime",
621
+ name="Sample Daily Monitor Downtime",
639
622
  monitor_guids=[
640
623
  "<GUID-1>",
641
624
  "<GUID-2>",
642
625
  ],
626
+ mode="DAILY",
643
627
  start_time="2023-12-04T18:15:00",
628
+ end_time="2024-01-04T07:15:00",
629
+ end_repeat={
630
+ "on_date": "2023-12-25",
631
+ },
644
632
  time_zone="Asia/Kolkata")
645
633
  ```
646
- <!--End PulumiCodeChooser -->
647
634
 
648
635
  ### Weekly Monitor Downtime
649
636
 
@@ -651,26 +638,25 @@ class MonitorDowntime(pulumi.CustomResource):
651
638
 
652
639
  Note that `maintenance_days` has been specified in the configuration as it is required with weekly monitor downtimes; and `end_repeat` has not been specified as it is optional, all in accordance with the rules of these arguments specified in the argument reference section above.
653
640
 
654
- <!--Start PulumiCodeChooser -->
655
641
  ```python
656
642
  import pulumi
657
643
  import pulumi_newrelic as newrelic
658
644
 
659
- sample_weekly_newrelic_monitor_downtime = newrelic.MonitorDowntime("sampleWeeklyNewrelicMonitorDowntime",
660
- end_time="2024-01-04T23:55:00",
661
- maintenance_days=[
662
- "SATURDAY",
663
- "SUNDAY",
664
- ],
665
- mode="WEEKLY",
645
+ sample_weekly_newrelic_monitor_downtime = newrelic.MonitorDowntime("sample_weekly_newrelic_monitor_downtime",
646
+ name="Sample Weekly Monitor Downtime",
666
647
  monitor_guids=[
667
648
  "<GUID-1>",
668
649
  "<GUID-2>",
669
650
  ],
651
+ mode="WEEKLY",
670
652
  start_time="2023-12-04T14:15:00",
671
- time_zone="US/Hawaii")
653
+ end_time="2024-01-04T23:55:00",
654
+ time_zone="US/Hawaii",
655
+ maintenance_days=[
656
+ "SATURDAY",
657
+ "SUNDAY",
658
+ ])
672
659
  ```
673
- <!--End PulumiCodeChooser -->
674
660
 
675
661
  ### Monthly Monitor Downtime
676
662
 
@@ -678,59 +664,57 @@ class MonitorDowntime(pulumi.CustomResource):
678
664
 
679
665
  Note that `frequency` has been specified in the configuration as it is required with monthly monitor downtimes, and `end_repeat` has been specified too, though it is optional. `frequency` has been specified with `days_of_week` comprising both of its nested arguments, `ordinal_day_of_month` and `week_day`; all in accordance with the rules of these arguments specified in the argument reference section above.
680
666
 
681
- <!--Start PulumiCodeChooser -->
682
667
  ```python
683
668
  import pulumi
684
669
  import pulumi_newrelic as newrelic
685
670
 
686
- sample_monthly_newrelic_monitor_downtime = newrelic.MonitorDowntime("sampleMonthlyNewrelicMonitorDowntime",
687
- end_repeat=newrelic.MonitorDowntimeEndRepeatArgs(
688
- on_repeat=6,
689
- ),
690
- end_time="2024-01-04T19:15:00",
691
- frequency=newrelic.MonitorDowntimeFrequencyArgs(
692
- days_of_week=newrelic.MonitorDowntimeFrequencyDaysOfWeekArgs(
693
- ordinal_day_of_month="SECOND",
694
- week_day="SATURDAY",
695
- ),
696
- ),
697
- mode="MONTHLY",
671
+ sample_monthly_newrelic_monitor_downtime = newrelic.MonitorDowntime("sample_monthly_newrelic_monitor_downtime",
672
+ name="Sample Monthly Monitor Downtime",
698
673
  monitor_guids=[
699
674
  "<GUID-1>",
700
675
  "<GUID-2>",
701
676
  ],
677
+ mode="MONTHLY",
702
678
  start_time="2023-12-04T07:15:00",
703
- time_zone="Europe/Dublin")
679
+ end_time="2024-01-04T19:15:00",
680
+ end_repeat={
681
+ "on_repeat": 6,
682
+ },
683
+ time_zone="Europe/Dublin",
684
+ frequency={
685
+ "days_of_week": {
686
+ "ordinal_day_of_month": "SECOND",
687
+ "week_day": "SATURDAY",
688
+ },
689
+ })
704
690
  ```
705
- <!--End PulumiCodeChooser -->
706
691
  However, the `frequency` block in monthly monitor downtimes may also be specified with its other nested argument, `days_of_month`, as shown in the example below - though both `days_of_month` and `days_of_week` cannot be specified together, as they are mutually exclusive.
707
- <!--Start PulumiCodeChooser -->
708
692
  ```python
709
693
  import pulumi
710
694
  import pulumi_newrelic as newrelic
711
695
 
712
- sample_monthly_newrelic_monitor_downtime = newrelic.MonitorDowntime("sampleMonthlyNewrelicMonitorDowntime",
713
- end_repeat=newrelic.MonitorDowntimeEndRepeatArgs(
714
- on_repeat=6,
715
- ),
696
+ sample_monthly_newrelic_monitor_downtime = newrelic.MonitorDowntime("sample_monthly_newrelic_monitor_downtime",
697
+ name="Sample Monthly Monitor Downtime",
698
+ monitor_guids=[
699
+ "<GUID-1>",
700
+ "<GUID-2>",
701
+ ],
702
+ mode="MONTHLY",
703
+ start_time="2023-12-04T07:15:00",
716
704
  end_time="2024-01-04T19:15:00",
717
- frequency=newrelic.MonitorDowntimeFrequencyArgs(
718
- days_of_months=[
705
+ end_repeat={
706
+ "on_repeat": 6,
707
+ },
708
+ time_zone="Europe/Dublin",
709
+ frequency={
710
+ "days_of_months": [
719
711
  3,
720
712
  6,
721
713
  14,
722
714
  23,
723
715
  ],
724
- ),
725
- mode="MONTHLY",
726
- monitor_guids=[
727
- "<GUID-1>",
728
- "<GUID-2>",
729
- ],
730
- start_time="2023-12-04T07:15:00",
731
- time_zone="Europe/Dublin")
716
+ })
732
717
  ```
733
- <!--End PulumiCodeChooser -->
734
718
 
735
719
  ## Import
736
720
 
@@ -757,16 +741,16 @@ class MonitorDowntime(pulumi.CustomResource):
757
741
  def _internal_init(__self__,
758
742
  resource_name: str,
759
743
  opts: Optional[pulumi.ResourceOptions] = None,
760
- account_id: Optional[pulumi.Input[int]] = None,
761
- end_repeat: Optional[pulumi.Input[pulumi.InputType['MonitorDowntimeEndRepeatArgs']]] = None,
762
- end_time: Optional[pulumi.Input[str]] = None,
763
- frequency: Optional[pulumi.Input[pulumi.InputType['MonitorDowntimeFrequencyArgs']]] = None,
764
- maintenance_days: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
765
- mode: Optional[pulumi.Input[str]] = None,
766
- monitor_guids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
767
- name: Optional[pulumi.Input[str]] = None,
768
- start_time: Optional[pulumi.Input[str]] = None,
769
- time_zone: Optional[pulumi.Input[str]] = None,
744
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
745
+ end_repeat: Optional[pulumi.Input[Union['MonitorDowntimeEndRepeatArgs', 'MonitorDowntimeEndRepeatArgsDict']]] = None,
746
+ end_time: Optional[pulumi.Input[_builtins.str]] = None,
747
+ frequency: Optional[pulumi.Input[Union['MonitorDowntimeFrequencyArgs', 'MonitorDowntimeFrequencyArgsDict']]] = None,
748
+ maintenance_days: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
749
+ mode: Optional[pulumi.Input[_builtins.str]] = None,
750
+ monitor_guids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
751
+ name: Optional[pulumi.Input[_builtins.str]] = None,
752
+ start_time: Optional[pulumi.Input[_builtins.str]] = None,
753
+ time_zone: Optional[pulumi.Input[_builtins.str]] = None,
770
754
  __props__=None):
771
755
  opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
772
756
  if not isinstance(opts, pulumi.ResourceOptions):
@@ -804,16 +788,16 @@ class MonitorDowntime(pulumi.CustomResource):
804
788
  def get(resource_name: str,
805
789
  id: pulumi.Input[str],
806
790
  opts: Optional[pulumi.ResourceOptions] = None,
807
- account_id: Optional[pulumi.Input[int]] = None,
808
- end_repeat: Optional[pulumi.Input[pulumi.InputType['MonitorDowntimeEndRepeatArgs']]] = None,
809
- end_time: Optional[pulumi.Input[str]] = None,
810
- frequency: Optional[pulumi.Input[pulumi.InputType['MonitorDowntimeFrequencyArgs']]] = None,
811
- maintenance_days: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
812
- mode: Optional[pulumi.Input[str]] = None,
813
- monitor_guids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
814
- name: Optional[pulumi.Input[str]] = None,
815
- start_time: Optional[pulumi.Input[str]] = None,
816
- time_zone: Optional[pulumi.Input[str]] = None) -> 'MonitorDowntime':
791
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
792
+ end_repeat: Optional[pulumi.Input[Union['MonitorDowntimeEndRepeatArgs', 'MonitorDowntimeEndRepeatArgsDict']]] = None,
793
+ end_time: Optional[pulumi.Input[_builtins.str]] = None,
794
+ frequency: Optional[pulumi.Input[Union['MonitorDowntimeFrequencyArgs', 'MonitorDowntimeFrequencyArgsDict']]] = None,
795
+ maintenance_days: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
796
+ mode: Optional[pulumi.Input[_builtins.str]] = None,
797
+ monitor_guids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
798
+ name: Optional[pulumi.Input[_builtins.str]] = None,
799
+ start_time: Optional[pulumi.Input[_builtins.str]] = None,
800
+ time_zone: Optional[pulumi.Input[_builtins.str]] = None) -> 'MonitorDowntime':
817
801
  """
818
802
  Get an existing MonitorDowntime resource's state with the given name, id, and optional extra
819
803
  properties used to qualify the lookup.
@@ -821,18 +805,16 @@ class MonitorDowntime(pulumi.CustomResource):
821
805
  :param str resource_name: The unique name of the resulting resource.
822
806
  :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
823
807
  :param pulumi.ResourceOptions opts: Options for the resource.
824
- :param pulumi.Input[int] account_id: The account in which the monitor downtime would be created. Defaults to the value of the environment variable `NEW_RELIC_ACCOUNT_ID` (or the `account_id` specified in the `provider{}`), if not specified.
825
- :param pulumi.Input[pulumi.InputType['MonitorDowntimeEndRepeatArgs']] end_repeat: Options which may be used to specify when the repeat cycle of the monitor should end. This argument comprises the following nested arguments -
826
- :param pulumi.Input[str] end_time: The time at which the monitor downtime would end operating, a timestamp specified in the ISO 8601 format without the offset/timezone - for instance, `2024-01-05T14:27:07`.
827
- :param pulumi.Input[pulumi.InputType['MonitorDowntimeFrequencyArgs']] frequency: Options which may be used to specify the configuration of a monthly monitor downtime. This argument comprises the following nested arguments -
828
- :param pulumi.Input[Sequence[pulumi.Input[str]]] maintenance_days: A list of days on which weekly monitor downtimes would function. Valid values which go into this list would be `"SUNDAY"`, `"MONDAY"`, `"TUESDAY"`, `"WEDNESDAY"`, `"THURSDAY"`, `"FRIDAY"` and/or `"SATURDAY"`.
829
-
830
- > **NOTE:** `maintenance_days` **can only be used with the mode** `WEEKLY`, and **is a required argument** with weekly monitor downtimes (i.e. if the `mode` is `WEEKLY`).
831
- :param pulumi.Input[str] mode: One of the four modes of operation of monitor downtimes - `ONE_TIME`, `DAILY`, `MONTHLY` or `WEEKLY`.
832
- :param pulumi.Input[Sequence[pulumi.Input[str]]] monitor_guids: A list of GUIDs of synthetic monitors the monitor downtime would need to be applied to.
833
- :param pulumi.Input[str] name: Name of the monitor downtime to be created.
834
- :param pulumi.Input[str] start_time: The time at which the monitor downtime would begin to operate, a timestamp specified in the ISO 8601 format without the offset/timezone - for instance, `2023-12-20T10:48:53`.
835
- :param pulumi.Input[str] time_zone: The timezone that applies to the Monitor Downtime schedule.
808
+ :param pulumi.Input[_builtins.str] account_id: The ID of the New Relic account in which the Monitor Downtime shall be created. Defaults to the `account_id` in the provider{} configuration if not specified.
809
+ :param pulumi.Input[Union['MonitorDowntimeEndRepeatArgs', 'MonitorDowntimeEndRepeatArgsDict']] end_repeat: A specification of when the Monitor Downtime should end its repeat cycle, by number of occurrences or date.
810
+ :param pulumi.Input[_builtins.str] end_time: A datetime stamp signifying the end of the Monitor Downtime.
811
+ :param pulumi.Input[Union['MonitorDowntimeFrequencyArgs', 'MonitorDowntimeFrequencyArgsDict']] frequency: Configuration options for which days of the month a monitor downtime will occur
812
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] maintenance_days: A list of maintenance days to be included with the created weekly Monitor Downtime.
813
+ :param pulumi.Input[_builtins.str] mode: An identifier of the type of Monitor Downtime to be created.
814
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] monitor_guids: A list of GUIDs of monitors, to which the created Monitor Downtime shall be applied.
815
+ :param pulumi.Input[_builtins.str] name: A name to identify the Monitor Downtime to be created.
816
+ :param pulumi.Input[_builtins.str] start_time: A datetime stamp signifying the start of the Monitor Downtime.
817
+ :param pulumi.Input[_builtins.str] time_zone: The timezone that applies to the Monitor Downtime schedule.
836
818
  """
837
819
  opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
838
820
 
@@ -850,83 +832,81 @@ class MonitorDowntime(pulumi.CustomResource):
850
832
  __props__.__dict__["time_zone"] = time_zone
851
833
  return MonitorDowntime(resource_name, opts=opts, __props__=__props__)
852
834
 
853
- @property
835
+ @_builtins.property
854
836
  @pulumi.getter(name="accountId")
855
- def account_id(self) -> pulumi.Output[int]:
837
+ def account_id(self) -> pulumi.Output[_builtins.str]:
856
838
  """
857
- The account in which the monitor downtime would be created. Defaults to the value of the environment variable `NEW_RELIC_ACCOUNT_ID` (or the `account_id` specified in the `provider{}`), if not specified.
839
+ The ID of the New Relic account in which the Monitor Downtime shall be created. Defaults to the `account_id` in the provider{} configuration if not specified.
858
840
  """
859
841
  return pulumi.get(self, "account_id")
860
842
 
861
- @property
843
+ @_builtins.property
862
844
  @pulumi.getter(name="endRepeat")
863
845
  def end_repeat(self) -> pulumi.Output[Optional['outputs.MonitorDowntimeEndRepeat']]:
864
846
  """
865
- Options which may be used to specify when the repeat cycle of the monitor should end. This argument comprises the following nested arguments -
847
+ A specification of when the Monitor Downtime should end its repeat cycle, by number of occurrences or date.
866
848
  """
867
849
  return pulumi.get(self, "end_repeat")
868
850
 
869
- @property
851
+ @_builtins.property
870
852
  @pulumi.getter(name="endTime")
871
- def end_time(self) -> pulumi.Output[str]:
853
+ def end_time(self) -> pulumi.Output[_builtins.str]:
872
854
  """
873
- The time at which the monitor downtime would end operating, a timestamp specified in the ISO 8601 format without the offset/timezone - for instance, `2024-01-05T14:27:07`.
855
+ A datetime stamp signifying the end of the Monitor Downtime.
874
856
  """
875
857
  return pulumi.get(self, "end_time")
876
858
 
877
- @property
859
+ @_builtins.property
878
860
  @pulumi.getter
879
861
  def frequency(self) -> pulumi.Output[Optional['outputs.MonitorDowntimeFrequency']]:
880
862
  """
881
- Options which may be used to specify the configuration of a monthly monitor downtime. This argument comprises the following nested arguments -
863
+ Configuration options for which days of the month a monitor downtime will occur
882
864
  """
883
865
  return pulumi.get(self, "frequency")
884
866
 
885
- @property
867
+ @_builtins.property
886
868
  @pulumi.getter(name="maintenanceDays")
887
- def maintenance_days(self) -> pulumi.Output[Optional[Sequence[str]]]:
869
+ def maintenance_days(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
888
870
  """
889
- A list of days on which weekly monitor downtimes would function. Valid values which go into this list would be `"SUNDAY"`, `"MONDAY"`, `"TUESDAY"`, `"WEDNESDAY"`, `"THURSDAY"`, `"FRIDAY"` and/or `"SATURDAY"`.
890
-
891
- > **NOTE:** `maintenance_days` **can only be used with the mode** `WEEKLY`, and **is a required argument** with weekly monitor downtimes (i.e. if the `mode` is `WEEKLY`).
871
+ A list of maintenance days to be included with the created weekly Monitor Downtime.
892
872
  """
893
873
  return pulumi.get(self, "maintenance_days")
894
874
 
895
- @property
875
+ @_builtins.property
896
876
  @pulumi.getter
897
- def mode(self) -> pulumi.Output[str]:
877
+ def mode(self) -> pulumi.Output[_builtins.str]:
898
878
  """
899
- One of the four modes of operation of monitor downtimes - `ONE_TIME`, `DAILY`, `MONTHLY` or `WEEKLY`.
879
+ An identifier of the type of Monitor Downtime to be created.
900
880
  """
901
881
  return pulumi.get(self, "mode")
902
882
 
903
- @property
883
+ @_builtins.property
904
884
  @pulumi.getter(name="monitorGuids")
905
- def monitor_guids(self) -> pulumi.Output[Optional[Sequence[str]]]:
885
+ def monitor_guids(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
906
886
  """
907
- A list of GUIDs of synthetic monitors the monitor downtime would need to be applied to.
887
+ A list of GUIDs of monitors, to which the created Monitor Downtime shall be applied.
908
888
  """
909
889
  return pulumi.get(self, "monitor_guids")
910
890
 
911
- @property
891
+ @_builtins.property
912
892
  @pulumi.getter
913
- def name(self) -> pulumi.Output[str]:
893
+ def name(self) -> pulumi.Output[_builtins.str]:
914
894
  """
915
- Name of the monitor downtime to be created.
895
+ A name to identify the Monitor Downtime to be created.
916
896
  """
917
897
  return pulumi.get(self, "name")
918
898
 
919
- @property
899
+ @_builtins.property
920
900
  @pulumi.getter(name="startTime")
921
- def start_time(self) -> pulumi.Output[str]:
901
+ def start_time(self) -> pulumi.Output[_builtins.str]:
922
902
  """
923
- The time at which the monitor downtime would begin to operate, a timestamp specified in the ISO 8601 format without the offset/timezone - for instance, `2023-12-20T10:48:53`.
903
+ A datetime stamp signifying the start of the Monitor Downtime.
924
904
  """
925
905
  return pulumi.get(self, "start_time")
926
906
 
927
- @property
907
+ @_builtins.property
928
908
  @pulumi.getter(name="timeZone")
929
- def time_zone(self) -> pulumi.Output[str]:
909
+ def time_zone(self) -> pulumi.Output[_builtins.str]:
930
910
  """
931
911
  The timezone that applies to the Monitor Downtime schedule.
932
912
  """