pulumi-newrelic 5.49.0a1753337775__py3-none-any.whl → 5.49.0a1753510512__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 (89) hide show
  1. pulumi_newrelic/__init__.py +1 -1
  2. pulumi_newrelic/_inputs.py +3759 -3760
  3. pulumi_newrelic/account_management.py +35 -36
  4. pulumi_newrelic/alert_channel.py +55 -56
  5. pulumi_newrelic/alert_condition.py +217 -218
  6. pulumi_newrelic/alert_muting_rule.py +92 -93
  7. pulumi_newrelic/alert_policy.py +69 -70
  8. pulumi_newrelic/alert_policy_channel.py +52 -53
  9. pulumi_newrelic/api_access_key.py +112 -113
  10. pulumi_newrelic/browser_application.py +113 -114
  11. pulumi_newrelic/cloud/__init__.py +1 -1
  12. pulumi_newrelic/cloud/_inputs.py +2129 -2130
  13. pulumi_newrelic/cloud/aws_govcloud_integrations.py +95 -96
  14. pulumi_newrelic/cloud/aws_govcloud_link_account.py +69 -70
  15. pulumi_newrelic/cloud/aws_integrations.py +194 -195
  16. pulumi_newrelic/cloud/aws_link_account.py +69 -70
  17. pulumi_newrelic/cloud/azure_integrations.py +131 -132
  18. pulumi_newrelic/cloud/azure_link_account.py +103 -104
  19. pulumi_newrelic/cloud/gcp_integrations.py +113 -114
  20. pulumi_newrelic/cloud/gcp_link_account.py +52 -53
  21. pulumi_newrelic/cloud/outputs.py +1417 -1418
  22. pulumi_newrelic/config/__init__.py +1 -1
  23. pulumi_newrelic/config/__init__.pyi +1 -2
  24. pulumi_newrelic/config/vars.py +14 -15
  25. pulumi_newrelic/data_partition_rule.py +112 -113
  26. pulumi_newrelic/entity_tags.py +21 -22
  27. pulumi_newrelic/events_to_metrics_rule.py +95 -96
  28. pulumi_newrelic/get_account.py +21 -22
  29. pulumi_newrelic/get_alert_channel.py +20 -21
  30. pulumi_newrelic/get_alert_policy.py +25 -26
  31. pulumi_newrelic/get_application.py +13 -14
  32. pulumi_newrelic/get_authentication_domain.py +9 -10
  33. pulumi_newrelic/get_cloud_account.py +21 -22
  34. pulumi_newrelic/get_entity.py +52 -53
  35. pulumi_newrelic/get_group.py +17 -18
  36. pulumi_newrelic/get_key_transaction.py +25 -26
  37. pulumi_newrelic/get_notification_destination.py +29 -30
  38. pulumi_newrelic/get_obfuscation_expression.py +15 -16
  39. pulumi_newrelic/get_service_level_alert_helper.py +53 -54
  40. pulumi_newrelic/get_test_grok_pattern.py +22 -23
  41. pulumi_newrelic/get_user.py +21 -22
  42. pulumi_newrelic/group.py +52 -53
  43. pulumi_newrelic/infra_alert_condition.py +255 -256
  44. pulumi_newrelic/insights/__init__.py +1 -1
  45. pulumi_newrelic/insights/_inputs.py +32 -33
  46. pulumi_newrelic/insights/event.py +4 -5
  47. pulumi_newrelic/insights/outputs.py +22 -23
  48. pulumi_newrelic/key_transaction.py +104 -105
  49. pulumi_newrelic/log_parsing_rule.py +146 -147
  50. pulumi_newrelic/monitor_downtime.py +143 -144
  51. pulumi_newrelic/notification_channel.py +115 -116
  52. pulumi_newrelic/notification_destination.py +111 -112
  53. pulumi_newrelic/nrql_alert_condition.py +430 -431
  54. pulumi_newrelic/nrql_drop_rule.py +78 -79
  55. pulumi_newrelic/obfuscation_expression.py +69 -70
  56. pulumi_newrelic/obfuscation_rule.py +89 -90
  57. pulumi_newrelic/one_dashboard.py +93 -94
  58. pulumi_newrelic/one_dashboard_json.py +62 -63
  59. pulumi_newrelic/one_dashboard_raw.py +90 -91
  60. pulumi_newrelic/outputs.py +2646 -2647
  61. pulumi_newrelic/plugins/__init__.py +1 -1
  62. pulumi_newrelic/plugins/_inputs.py +158 -159
  63. pulumi_newrelic/plugins/application_settings.py +167 -168
  64. pulumi_newrelic/plugins/outputs.py +108 -109
  65. pulumi_newrelic/plugins/workload.py +131 -132
  66. pulumi_newrelic/provider.py +106 -107
  67. pulumi_newrelic/pulumi-plugin.json +1 -1
  68. pulumi_newrelic/service_level.py +76 -77
  69. pulumi_newrelic/synthetics/__init__.py +1 -1
  70. pulumi_newrelic/synthetics/_inputs.py +127 -128
  71. pulumi_newrelic/synthetics/alert_condition.py +95 -96
  72. pulumi_newrelic/synthetics/broken_links_monitor.py +197 -198
  73. pulumi_newrelic/synthetics/cert_check_monitor.py +205 -206
  74. pulumi_newrelic/synthetics/get_private_location.py +21 -22
  75. pulumi_newrelic/synthetics/get_secure_credential.py +19 -20
  76. pulumi_newrelic/synthetics/monitor.py +378 -379
  77. pulumi_newrelic/synthetics/multi_location_alert_condition.py +118 -119
  78. pulumi_newrelic/synthetics/outputs.py +85 -86
  79. pulumi_newrelic/synthetics/private_location.py +105 -106
  80. pulumi_newrelic/synthetics/script_monitor.py +302 -303
  81. pulumi_newrelic/synthetics/secure_credential.py +86 -87
  82. pulumi_newrelic/synthetics/step_monitor.py +220 -221
  83. pulumi_newrelic/user.py +69 -70
  84. pulumi_newrelic/workflow.py +139 -140
  85. {pulumi_newrelic-5.49.0a1753337775.dist-info → pulumi_newrelic-5.49.0a1753510512.dist-info}/METADATA +1 -1
  86. pulumi_newrelic-5.49.0a1753510512.dist-info/RECORD +90 -0
  87. pulumi_newrelic-5.49.0a1753337775.dist-info/RECORD +0 -90
  88. {pulumi_newrelic-5.49.0a1753337775.dist-info → pulumi_newrelic-5.49.0a1753510512.dist-info}/WHEEL +0 -0
  89. {pulumi_newrelic-5.49.0a1753337775.dist-info → pulumi_newrelic-5.49.0a1753510512.dist-info}/top_level.txt +0 -0
pulumi_newrelic/synthetics/step_monitor.py CHANGED
@@ -2,8 +2,7 @@
2
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 builtins
6
- import copy
5
+ import builtins as _builtins
7
6
  import warnings
8
7
  import sys
9
8
  import pulumi
@@ -22,34 +21,34 @@ __all__ = ['StepMonitorArgs', 'StepMonitor']
22
21
  @pulumi.input_type
23
22
  class StepMonitorArgs:
24
23
  def __init__(__self__, *,
25
- period: pulumi.Input[builtins.str],
26
- status: pulumi.Input[builtins.str],
24
+ period: pulumi.Input[_builtins.str],
25
+ status: pulumi.Input[_builtins.str],
27
26
  steps: pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]],
28
- account_id: Optional[pulumi.Input[builtins.str]] = None,
29
- browsers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
30
- devices: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
31
- enable_screenshot_on_failure_and_script: Optional[pulumi.Input[builtins.bool]] = None,
27
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
28
+ browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
29
+ devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
30
+ enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
32
31
  location_privates: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]]] = None,
33
- locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
34
- name: Optional[pulumi.Input[builtins.str]] = None,
35
- runtime_type: Optional[pulumi.Input[builtins.str]] = None,
36
- runtime_type_version: Optional[pulumi.Input[builtins.str]] = None,
32
+ locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
33
+ name: Optional[pulumi.Input[_builtins.str]] = None,
34
+ runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
35
+ runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
37
36
  tags: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]] = None,
38
- use_unsupported_legacy_runtime: Optional[pulumi.Input[builtins.bool]] = None):
37
+ use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
39
38
  """
40
39
  The set of arguments for constructing a StepMonitor resource.
41
- :param pulumi.Input[builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
42
- :param pulumi.Input[builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
40
+ :param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
41
+ :param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
43
42
  :param pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]] steps: The steps that make up the script the monitor will run. See Nested steps blocks below for details.
44
- :param pulumi.Input[builtins.str] account_id: The account in which the Synthetics monitor will be created.
45
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
46
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
47
- :param pulumi.Input[builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
43
+ :param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
44
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
45
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
46
+ :param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
48
47
  :param pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]] location_privates: The location the monitor will run from. At least one of `locations_public` or `location_private` is required. See Nested locations_private blocks below for details.
49
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
50
- :param pulumi.Input[builtins.str] name: The name for the monitor.
51
- :param pulumi.Input[builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
52
- :param pulumi.Input[builtins.str] runtime_type_version: The specific semver version of the runtime type.
48
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
49
+ :param pulumi.Input[_builtins.str] name: The name for the monitor.
50
+ :param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
51
+ :param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
53
52
  :param pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
54
53
  """
55
54
  pulumi.set(__self__, "period", period)
@@ -78,31 +77,31 @@ class StepMonitorArgs:
78
77
  if use_unsupported_legacy_runtime is not None:
79
78
  pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
80
79
 
81
- @property
80
+ @_builtins.property
82
81
  @pulumi.getter
83
- def period(self) -> pulumi.Input[builtins.str]:
82
+ def period(self) -> pulumi.Input[_builtins.str]:
84
83
  """
85
84
  The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
86
85
  """
87
86
  return pulumi.get(self, "period")
88
87
 
89
88
  @period.setter
90
- def period(self, value: pulumi.Input[builtins.str]):
89
+ def period(self, value: pulumi.Input[_builtins.str]):
91
90
  pulumi.set(self, "period", value)
92
91
 
93
- @property
92
+ @_builtins.property
94
93
  @pulumi.getter
95
- def status(self) -> pulumi.Input[builtins.str]:
94
+ def status(self) -> pulumi.Input[_builtins.str]:
96
95
  """
97
96
  The run state of the monitor. (`ENABLED` or `DISABLED`).
98
97
  """
99
98
  return pulumi.get(self, "status")
100
99
 
101
100
  @status.setter
102
- def status(self, value: pulumi.Input[builtins.str]):
101
+ def status(self, value: pulumi.Input[_builtins.str]):
103
102
  pulumi.set(self, "status", value)
104
103
 
105
- @property
104
+ @_builtins.property
106
105
  @pulumi.getter
107
106
  def steps(self) -> pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]]:
108
107
  """
@@ -114,55 +113,55 @@ class StepMonitorArgs:
114
113
  def steps(self, value: pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]]):
115
114
  pulumi.set(self, "steps", value)
116
115
 
117
- @property
116
+ @_builtins.property
118
117
  @pulumi.getter(name="accountId")
119
- def account_id(self) -> Optional[pulumi.Input[builtins.str]]:
118
+ def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
120
119
  """
121
120
  The account in which the Synthetics monitor will be created.
122
121
  """
123
122
  return pulumi.get(self, "account_id")
124
123
 
125
124
  @account_id.setter
126
- def account_id(self, value: Optional[pulumi.Input[builtins.str]]):
125
+ def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
127
126
  pulumi.set(self, "account_id", value)
128
127
 
129
- @property
128
+ @_builtins.property
130
129
  @pulumi.getter
131
- def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
130
+ def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
132
131
  """
133
132
  The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
134
133
  """
135
134
  return pulumi.get(self, "browsers")
136
135
 
137
136
  @browsers.setter
138
- def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
137
+ def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
139
138
  pulumi.set(self, "browsers", value)
140
139
 
141
- @property
140
+ @_builtins.property
142
141
  @pulumi.getter
143
- def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
142
+ def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
144
143
  """
145
144
  The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
146
145
  """
147
146
  return pulumi.get(self, "devices")
148
147
 
149
148
  @devices.setter
150
- def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
149
+ def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
151
150
  pulumi.set(self, "devices", value)
152
151
 
153
- @property
152
+ @_builtins.property
154
153
  @pulumi.getter(name="enableScreenshotOnFailureAndScript")
155
- def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[builtins.bool]]:
154
+ def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[_builtins.bool]]:
156
155
  """
157
156
  Capture a screenshot during job execution.
158
157
  """
159
158
  return pulumi.get(self, "enable_screenshot_on_failure_and_script")
160
159
 
161
160
  @enable_screenshot_on_failure_and_script.setter
162
- def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[builtins.bool]]):
161
+ def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[_builtins.bool]]):
163
162
  pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
164
163
 
165
- @property
164
+ @_builtins.property
166
165
  @pulumi.getter(name="locationPrivates")
167
166
  def location_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]]]:
168
167
  """
@@ -174,55 +173,55 @@ class StepMonitorArgs:
174
173
  def location_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]]]):
175
174
  pulumi.set(self, "location_privates", value)
176
175
 
177
- @property
176
+ @_builtins.property
178
177
  @pulumi.getter(name="locationsPublics")
179
- def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
178
+ def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
180
179
  """
181
180
  The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
182
181
  """
183
182
  return pulumi.get(self, "locations_publics")
184
183
 
185
184
  @locations_publics.setter
186
- def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
185
+ def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
187
186
  pulumi.set(self, "locations_publics", value)
188
187
 
189
- @property
188
+ @_builtins.property
190
189
  @pulumi.getter
191
- def name(self) -> Optional[pulumi.Input[builtins.str]]:
190
+ def name(self) -> Optional[pulumi.Input[_builtins.str]]:
192
191
  """
193
192
  The name for the monitor.
194
193
  """
195
194
  return pulumi.get(self, "name")
196
195
 
197
196
  @name.setter
198
- def name(self, value: Optional[pulumi.Input[builtins.str]]):
197
+ def name(self, value: Optional[pulumi.Input[_builtins.str]]):
199
198
  pulumi.set(self, "name", value)
200
199
 
201
- @property
200
+ @_builtins.property
202
201
  @pulumi.getter(name="runtimeType")
203
- def runtime_type(self) -> Optional[pulumi.Input[builtins.str]]:
202
+ def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
204
203
  """
205
204
  The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
206
205
  """
207
206
  return pulumi.get(self, "runtime_type")
208
207
 
209
208
  @runtime_type.setter
210
- def runtime_type(self, value: Optional[pulumi.Input[builtins.str]]):
209
+ def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
211
210
  pulumi.set(self, "runtime_type", value)
212
211
 
213
- @property
212
+ @_builtins.property
214
213
  @pulumi.getter(name="runtimeTypeVersion")
215
- def runtime_type_version(self) -> Optional[pulumi.Input[builtins.str]]:
214
+ def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
216
215
  """
217
216
  The specific semver version of the runtime type.
218
217
  """
219
218
  return pulumi.get(self, "runtime_type_version")
220
219
 
221
220
  @runtime_type_version.setter
222
- def runtime_type_version(self, value: Optional[pulumi.Input[builtins.str]]):
221
+ def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
223
222
  pulumi.set(self, "runtime_type_version", value)
224
223
 
225
- @property
224
+ @_builtins.property
226
225
  @pulumi.getter
227
226
  def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]]:
228
227
  """
@@ -234,52 +233,52 @@ class StepMonitorArgs:
234
233
  def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]]):
235
234
  pulumi.set(self, "tags", value)
236
235
 
237
- @property
236
+ @_builtins.property
238
237
  @pulumi.getter(name="useUnsupportedLegacyRuntime")
239
- def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[builtins.bool]]:
238
+ def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
240
239
  return pulumi.get(self, "use_unsupported_legacy_runtime")
241
240
 
242
241
  @use_unsupported_legacy_runtime.setter
243
- def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[builtins.bool]]):
242
+ def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
244
243
  pulumi.set(self, "use_unsupported_legacy_runtime", value)
245
244
 
246
245
 
247
246
  @pulumi.input_type
248
247
  class _StepMonitorState:
249
248
  def __init__(__self__, *,
250
- account_id: Optional[pulumi.Input[builtins.str]] = None,
251
- browsers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
252
- devices: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
253
- enable_screenshot_on_failure_and_script: Optional[pulumi.Input[builtins.bool]] = None,
254
- guid: Optional[pulumi.Input[builtins.str]] = None,
249
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
250
+ browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
251
+ devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
252
+ enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
253
+ guid: Optional[pulumi.Input[_builtins.str]] = None,
255
254
  location_privates: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]]] = None,
256
- locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
257
- monitor_id: Optional[pulumi.Input[builtins.str]] = None,
258
- name: Optional[pulumi.Input[builtins.str]] = None,
259
- period: Optional[pulumi.Input[builtins.str]] = None,
260
- period_in_minutes: Optional[pulumi.Input[builtins.int]] = None,
261
- runtime_type: Optional[pulumi.Input[builtins.str]] = None,
262
- runtime_type_version: Optional[pulumi.Input[builtins.str]] = None,
263
- status: Optional[pulumi.Input[builtins.str]] = None,
255
+ locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
256
+ monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
257
+ name: Optional[pulumi.Input[_builtins.str]] = None,
258
+ period: Optional[pulumi.Input[_builtins.str]] = None,
259
+ period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
260
+ runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
261
+ runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
262
+ status: Optional[pulumi.Input[_builtins.str]] = None,
264
263
  steps: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]]] = None,
265
264
  tags: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]] = None,
266
- use_unsupported_legacy_runtime: Optional[pulumi.Input[builtins.bool]] = None):
265
+ use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
267
266
  """
268
267
  Input properties used for looking up and filtering StepMonitor resources.
269
- :param pulumi.Input[builtins.str] account_id: The account in which the Synthetics monitor will be created.
270
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
271
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
272
- :param pulumi.Input[builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
273
- :param pulumi.Input[builtins.str] guid: The unique entity identifier of the monitor in New Relic.
268
+ :param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
269
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
270
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
271
+ :param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
272
+ :param pulumi.Input[_builtins.str] guid: The unique entity identifier of the monitor in New Relic.
274
273
  :param pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]] location_privates: The location the monitor will run from. At least one of `locations_public` or `location_private` is required. See Nested locations_private blocks below for details.
275
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
276
- :param pulumi.Input[builtins.str] monitor_id: The monitor id of the synthetics step monitor (not to be confused with the GUID of the monitor).
277
- :param pulumi.Input[builtins.str] name: The name for the monitor.
278
- :param pulumi.Input[builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
279
- :param pulumi.Input[builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
280
- :param pulumi.Input[builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
281
- :param pulumi.Input[builtins.str] runtime_type_version: The specific semver version of the runtime type.
282
- :param pulumi.Input[builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
274
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
275
+ :param pulumi.Input[_builtins.str] monitor_id: The monitor id of the synthetics step monitor (not to be confused with the GUID of the monitor).
276
+ :param pulumi.Input[_builtins.str] name: The name for the monitor.
277
+ :param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
278
+ :param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
279
+ :param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
280
+ :param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
281
+ :param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
283
282
  :param pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]] steps: The steps that make up the script the monitor will run. See Nested steps blocks below for details.
284
283
  :param pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
285
284
  """
@@ -318,67 +317,67 @@ class _StepMonitorState:
318
317
  if use_unsupported_legacy_runtime is not None:
319
318
  pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
320
319
 
321
- @property
320
+ @_builtins.property
322
321
  @pulumi.getter(name="accountId")
323
- def account_id(self) -> Optional[pulumi.Input[builtins.str]]:
322
+ def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
324
323
  """
325
324
  The account in which the Synthetics monitor will be created.
326
325
  """
327
326
  return pulumi.get(self, "account_id")
328
327
 
329
328
  @account_id.setter
330
- def account_id(self, value: Optional[pulumi.Input[builtins.str]]):
329
+ def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
331
330
  pulumi.set(self, "account_id", value)
332
331
 
333
- @property
332
+ @_builtins.property
334
333
  @pulumi.getter
335
- def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
334
+ def browsers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
336
335
  """
337
336
  The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
338
337
  """
339
338
  return pulumi.get(self, "browsers")
340
339
 
341
340
  @browsers.setter
342
- def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
341
+ def browsers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
343
342
  pulumi.set(self, "browsers", value)
344
343
 
345
- @property
344
+ @_builtins.property
346
345
  @pulumi.getter
347
- def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
346
+ def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
348
347
  """
349
348
  The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
350
349
  """
351
350
  return pulumi.get(self, "devices")
352
351
 
353
352
  @devices.setter
354
- def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
353
+ def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
355
354
  pulumi.set(self, "devices", value)
356
355
 
357
- @property
356
+ @_builtins.property
358
357
  @pulumi.getter(name="enableScreenshotOnFailureAndScript")
359
- def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[builtins.bool]]:
358
+ def enable_screenshot_on_failure_and_script(self) -> Optional[pulumi.Input[_builtins.bool]]:
360
359
  """
361
360
  Capture a screenshot during job execution.
362
361
  """
363
362
  return pulumi.get(self, "enable_screenshot_on_failure_and_script")
364
363
 
365
364
  @enable_screenshot_on_failure_and_script.setter
366
- def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[builtins.bool]]):
365
+ def enable_screenshot_on_failure_and_script(self, value: Optional[pulumi.Input[_builtins.bool]]):
367
366
  pulumi.set(self, "enable_screenshot_on_failure_and_script", value)
368
367
 
369
- @property
368
+ @_builtins.property
370
369
  @pulumi.getter
371
- def guid(self) -> Optional[pulumi.Input[builtins.str]]:
370
+ def guid(self) -> Optional[pulumi.Input[_builtins.str]]:
372
371
  """
373
372
  The unique entity identifier of the monitor in New Relic.
374
373
  """
375
374
  return pulumi.get(self, "guid")
376
375
 
377
376
  @guid.setter
378
- def guid(self, value: Optional[pulumi.Input[builtins.str]]):
377
+ def guid(self, value: Optional[pulumi.Input[_builtins.str]]):
379
378
  pulumi.set(self, "guid", value)
380
379
 
381
- @property
380
+ @_builtins.property
382
381
  @pulumi.getter(name="locationPrivates")
383
382
  def location_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]]]:
384
383
  """
@@ -390,103 +389,103 @@ class _StepMonitorState:
390
389
  def location_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorLocationPrivateArgs']]]]):
391
390
  pulumi.set(self, "location_privates", value)
392
391
 
393
- @property
392
+ @_builtins.property
394
393
  @pulumi.getter(name="locationsPublics")
395
- def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
394
+ def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
396
395
  """
397
396
  The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
398
397
  """
399
398
  return pulumi.get(self, "locations_publics")
400
399
 
401
400
  @locations_publics.setter
402
- def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
401
+ def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
403
402
  pulumi.set(self, "locations_publics", value)
404
403
 
405
- @property
404
+ @_builtins.property
406
405
  @pulumi.getter(name="monitorId")
407
- def monitor_id(self) -> Optional[pulumi.Input[builtins.str]]:
406
+ def monitor_id(self) -> Optional[pulumi.Input[_builtins.str]]:
408
407
  """
409
408
  The monitor id of the synthetics step monitor (not to be confused with the GUID of the monitor).
410
409
  """
411
410
  return pulumi.get(self, "monitor_id")
412
411
 
413
412
  @monitor_id.setter
414
- def monitor_id(self, value: Optional[pulumi.Input[builtins.str]]):
413
+ def monitor_id(self, value: Optional[pulumi.Input[_builtins.str]]):
415
414
  pulumi.set(self, "monitor_id", value)
416
415
 
417
- @property
416
+ @_builtins.property
418
417
  @pulumi.getter
419
- def name(self) -> Optional[pulumi.Input[builtins.str]]:
418
+ def name(self) -> Optional[pulumi.Input[_builtins.str]]:
420
419
  """
421
420
  The name for the monitor.
422
421
  """
423
422
  return pulumi.get(self, "name")
424
423
 
425
424
  @name.setter
426
- def name(self, value: Optional[pulumi.Input[builtins.str]]):
425
+ def name(self, value: Optional[pulumi.Input[_builtins.str]]):
427
426
  pulumi.set(self, "name", value)
428
427
 
429
- @property
428
+ @_builtins.property
430
429
  @pulumi.getter
431
- def period(self) -> Optional[pulumi.Input[builtins.str]]:
430
+ def period(self) -> Optional[pulumi.Input[_builtins.str]]:
432
431
  """
433
432
  The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
434
433
  """
435
434
  return pulumi.get(self, "period")
436
435
 
437
436
  @period.setter
438
- def period(self, value: Optional[pulumi.Input[builtins.str]]):
437
+ def period(self, value: Optional[pulumi.Input[_builtins.str]]):
439
438
  pulumi.set(self, "period", value)
440
439
 
441
- @property
440
+ @_builtins.property
442
441
  @pulumi.getter(name="periodInMinutes")
443
- def period_in_minutes(self) -> Optional[pulumi.Input[builtins.int]]:
442
+ def period_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
444
443
  """
445
444
  The interval in minutes at which Synthetic monitor should run.
446
445
  """
447
446
  return pulumi.get(self, "period_in_minutes")
448
447
 
449
448
  @period_in_minutes.setter
450
- def period_in_minutes(self, value: Optional[pulumi.Input[builtins.int]]):
449
+ def period_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
451
450
  pulumi.set(self, "period_in_minutes", value)
452
451
 
453
- @property
452
+ @_builtins.property
454
453
  @pulumi.getter(name="runtimeType")
455
- def runtime_type(self) -> Optional[pulumi.Input[builtins.str]]:
454
+ def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
456
455
  """
457
456
  The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
458
457
  """
459
458
  return pulumi.get(self, "runtime_type")
460
459
 
461
460
  @runtime_type.setter
462
- def runtime_type(self, value: Optional[pulumi.Input[builtins.str]]):
461
+ def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
463
462
  pulumi.set(self, "runtime_type", value)
464
463
 
465
- @property
464
+ @_builtins.property
466
465
  @pulumi.getter(name="runtimeTypeVersion")
467
- def runtime_type_version(self) -> Optional[pulumi.Input[builtins.str]]:
466
+ def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
468
467
  """
469
468
  The specific semver version of the runtime type.
470
469
  """
471
470
  return pulumi.get(self, "runtime_type_version")
472
471
 
473
472
  @runtime_type_version.setter
474
- def runtime_type_version(self, value: Optional[pulumi.Input[builtins.str]]):
473
+ def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
475
474
  pulumi.set(self, "runtime_type_version", value)
476
475
 
477
- @property
476
+ @_builtins.property
478
477
  @pulumi.getter
479
- def status(self) -> Optional[pulumi.Input[builtins.str]]:
478
+ def status(self) -> Optional[pulumi.Input[_builtins.str]]:
480
479
  """
481
480
  The run state of the monitor. (`ENABLED` or `DISABLED`).
482
481
  """
483
482
  return pulumi.get(self, "status")
484
483
 
485
484
  @status.setter
486
- def status(self, value: Optional[pulumi.Input[builtins.str]]):
485
+ def status(self, value: Optional[pulumi.Input[_builtins.str]]):
487
486
  pulumi.set(self, "status", value)
488
487
 
489
- @property
488
+ @_builtins.property
490
489
  @pulumi.getter
491
490
  def steps(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]]]:
492
491
  """
@@ -498,7 +497,7 @@ class _StepMonitorState:
498
497
  def steps(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorStepArgs']]]]):
499
498
  pulumi.set(self, "steps", value)
500
499
 
501
- @property
500
+ @_builtins.property
502
501
  @pulumi.getter
503
502
  def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]]:
504
503
  """
@@ -510,13 +509,13 @@ class _StepMonitorState:
510
509
  def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StepMonitorTagArgs']]]]):
511
510
  pulumi.set(self, "tags", value)
512
511
 
513
- @property
512
+ @_builtins.property
514
513
  @pulumi.getter(name="useUnsupportedLegacyRuntime")
515
- def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[builtins.bool]]:
514
+ def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
516
515
  return pulumi.get(self, "use_unsupported_legacy_runtime")
517
516
 
518
517
  @use_unsupported_legacy_runtime.setter
519
- def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[builtins.bool]]):
518
+ def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
520
519
  pulumi.set(self, "use_unsupported_legacy_runtime", value)
521
520
 
522
521
 
@@ -526,20 +525,20 @@ class StepMonitor(pulumi.CustomResource):
526
525
  def __init__(__self__,
527
526
  resource_name: str,
528
527
  opts: Optional[pulumi.ResourceOptions] = None,
529
- account_id: Optional[pulumi.Input[builtins.str]] = None,
530
- browsers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
531
- devices: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
532
- enable_screenshot_on_failure_and_script: Optional[pulumi.Input[builtins.bool]] = None,
528
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
529
+ browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
530
+ devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
531
+ enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
533
532
  location_privates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorLocationPrivateArgs', 'StepMonitorLocationPrivateArgsDict']]]]] = None,
534
- locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
535
- name: Optional[pulumi.Input[builtins.str]] = None,
536
- period: Optional[pulumi.Input[builtins.str]] = None,
537
- runtime_type: Optional[pulumi.Input[builtins.str]] = None,
538
- runtime_type_version: Optional[pulumi.Input[builtins.str]] = None,
539
- status: Optional[pulumi.Input[builtins.str]] = None,
533
+ locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
534
+ name: Optional[pulumi.Input[_builtins.str]] = None,
535
+ period: Optional[pulumi.Input[_builtins.str]] = None,
536
+ runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
537
+ runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
538
+ status: Optional[pulumi.Input[_builtins.str]] = None,
540
539
  steps: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorStepArgs', 'StepMonitorStepArgsDict']]]]] = None,
541
540
  tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorTagArgs', 'StepMonitorTagArgsDict']]]]] = None,
542
- use_unsupported_legacy_runtime: Optional[pulumi.Input[builtins.bool]] = None,
541
+ use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
543
542
  __props__=None):
544
543
  """
545
544
  ## Example Usage
@@ -632,17 +631,17 @@ class StepMonitor(pulumi.CustomResource):
632
631
 
633
632
  :param str resource_name: The name of the resource.
634
633
  :param pulumi.ResourceOptions opts: Options for the resource.
635
- :param pulumi.Input[builtins.str] account_id: The account in which the Synthetics monitor will be created.
636
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
637
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
638
- :param pulumi.Input[builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
634
+ :param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
635
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
636
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
637
+ :param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
639
638
  :param pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorLocationPrivateArgs', 'StepMonitorLocationPrivateArgsDict']]]] location_privates: The location the monitor will run from. At least one of `locations_public` or `location_private` is required. See Nested locations_private blocks below for details.
640
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
641
- :param pulumi.Input[builtins.str] name: The name for the monitor.
642
- :param pulumi.Input[builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
643
- :param pulumi.Input[builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
644
- :param pulumi.Input[builtins.str] runtime_type_version: The specific semver version of the runtime type.
645
- :param pulumi.Input[builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
639
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
640
+ :param pulumi.Input[_builtins.str] name: The name for the monitor.
641
+ :param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
642
+ :param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
643
+ :param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
644
+ :param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
646
645
  :param pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorStepArgs', 'StepMonitorStepArgsDict']]]] steps: The steps that make up the script the monitor will run. See Nested steps blocks below for details.
647
646
  :param pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorTagArgs', 'StepMonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
648
647
  """
@@ -756,20 +755,20 @@ class StepMonitor(pulumi.CustomResource):
756
755
  def _internal_init(__self__,
757
756
  resource_name: str,
758
757
  opts: Optional[pulumi.ResourceOptions] = None,
759
- account_id: Optional[pulumi.Input[builtins.str]] = None,
760
- browsers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
761
- devices: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
762
- enable_screenshot_on_failure_and_script: Optional[pulumi.Input[builtins.bool]] = None,
758
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
759
+ browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
760
+ devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
761
+ enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
763
762
  location_privates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorLocationPrivateArgs', 'StepMonitorLocationPrivateArgsDict']]]]] = None,
764
- locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
765
- name: Optional[pulumi.Input[builtins.str]] = None,
766
- period: Optional[pulumi.Input[builtins.str]] = None,
767
- runtime_type: Optional[pulumi.Input[builtins.str]] = None,
768
- runtime_type_version: Optional[pulumi.Input[builtins.str]] = None,
769
- status: Optional[pulumi.Input[builtins.str]] = None,
763
+ locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
764
+ name: Optional[pulumi.Input[_builtins.str]] = None,
765
+ period: Optional[pulumi.Input[_builtins.str]] = None,
766
+ runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
767
+ runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
768
+ status: Optional[pulumi.Input[_builtins.str]] = None,
770
769
  steps: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorStepArgs', 'StepMonitorStepArgsDict']]]]] = None,
771
770
  tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorTagArgs', 'StepMonitorTagArgsDict']]]]] = None,
772
- use_unsupported_legacy_runtime: Optional[pulumi.Input[builtins.bool]] = None,
771
+ use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
773
772
  __props__=None):
774
773
  opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
775
774
  if not isinstance(opts, pulumi.ResourceOptions):
@@ -812,23 +811,23 @@ class StepMonitor(pulumi.CustomResource):
812
811
  def get(resource_name: str,
813
812
  id: pulumi.Input[str],
814
813
  opts: Optional[pulumi.ResourceOptions] = None,
815
- account_id: Optional[pulumi.Input[builtins.str]] = None,
816
- browsers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
817
- devices: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
818
- enable_screenshot_on_failure_and_script: Optional[pulumi.Input[builtins.bool]] = None,
819
- guid: Optional[pulumi.Input[builtins.str]] = None,
814
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
815
+ browsers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
816
+ devices: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
817
+ enable_screenshot_on_failure_and_script: Optional[pulumi.Input[_builtins.bool]] = None,
818
+ guid: Optional[pulumi.Input[_builtins.str]] = None,
820
819
  location_privates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorLocationPrivateArgs', 'StepMonitorLocationPrivateArgsDict']]]]] = None,
821
- locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
822
- monitor_id: Optional[pulumi.Input[builtins.str]] = None,
823
- name: Optional[pulumi.Input[builtins.str]] = None,
824
- period: Optional[pulumi.Input[builtins.str]] = None,
825
- period_in_minutes: Optional[pulumi.Input[builtins.int]] = None,
826
- runtime_type: Optional[pulumi.Input[builtins.str]] = None,
827
- runtime_type_version: Optional[pulumi.Input[builtins.str]] = None,
828
- status: Optional[pulumi.Input[builtins.str]] = None,
820
+ locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
821
+ monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
822
+ name: Optional[pulumi.Input[_builtins.str]] = None,
823
+ period: Optional[pulumi.Input[_builtins.str]] = None,
824
+ period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
825
+ runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
826
+ runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
827
+ status: Optional[pulumi.Input[_builtins.str]] = None,
829
828
  steps: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorStepArgs', 'StepMonitorStepArgsDict']]]]] = None,
830
829
  tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorTagArgs', 'StepMonitorTagArgsDict']]]]] = None,
831
- use_unsupported_legacy_runtime: Optional[pulumi.Input[builtins.bool]] = None) -> 'StepMonitor':
830
+ use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None) -> 'StepMonitor':
832
831
  """
833
832
  Get an existing StepMonitor resource's state with the given name, id, and optional extra
834
833
  properties used to qualify the lookup.
@@ -836,20 +835,20 @@ class StepMonitor(pulumi.CustomResource):
836
835
  :param str resource_name: The unique name of the resulting resource.
837
836
  :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
838
837
  :param pulumi.ResourceOptions opts: Options for the resource.
839
- :param pulumi.Input[builtins.str] account_id: The account in which the Synthetics monitor will be created.
840
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
841
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
842
- :param pulumi.Input[builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
843
- :param pulumi.Input[builtins.str] guid: The unique entity identifier of the monitor in New Relic.
838
+ :param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
839
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] browsers: The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
840
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] devices: The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
841
+ :param pulumi.Input[_builtins.bool] enable_screenshot_on_failure_and_script: Capture a screenshot during job execution.
842
+ :param pulumi.Input[_builtins.str] guid: The unique entity identifier of the monitor in New Relic.
844
843
  :param pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorLocationPrivateArgs', 'StepMonitorLocationPrivateArgsDict']]]] location_privates: The location the monitor will run from. At least one of `locations_public` or `location_private` is required. See Nested locations_private blocks below for details.
845
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
846
- :param pulumi.Input[builtins.str] monitor_id: The monitor id of the synthetics step monitor (not to be confused with the GUID of the monitor).
847
- :param pulumi.Input[builtins.str] name: The name for the monitor.
848
- :param pulumi.Input[builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
849
- :param pulumi.Input[builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
850
- :param pulumi.Input[builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
851
- :param pulumi.Input[builtins.str] runtime_type_version: The specific semver version of the runtime type.
852
- :param pulumi.Input[builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
844
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
845
+ :param pulumi.Input[_builtins.str] monitor_id: The monitor id of the synthetics step monitor (not to be confused with the GUID of the monitor).
846
+ :param pulumi.Input[_builtins.str] name: The name for the monitor.
847
+ :param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
848
+ :param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
849
+ :param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
850
+ :param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
851
+ :param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
853
852
  :param pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorStepArgs', 'StepMonitorStepArgsDict']]]] steps: The steps that make up the script the monitor will run. See Nested steps blocks below for details.
854
853
  :param pulumi.Input[Sequence[pulumi.Input[Union['StepMonitorTagArgs', 'StepMonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details.
855
854
  """
@@ -876,47 +875,47 @@ class StepMonitor(pulumi.CustomResource):
876
875
  __props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
877
876
  return StepMonitor(resource_name, opts=opts, __props__=__props__)
878
877
 
879
- @property
878
+ @_builtins.property
880
879
  @pulumi.getter(name="accountId")
881
- def account_id(self) -> pulumi.Output[builtins.str]:
880
+ def account_id(self) -> pulumi.Output[_builtins.str]:
882
881
  """
883
882
  The account in which the Synthetics monitor will be created.
884
883
  """
885
884
  return pulumi.get(self, "account_id")
886
885
 
887
- @property
886
+ @_builtins.property
888
887
  @pulumi.getter
889
- def browsers(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]:
888
+ def browsers(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
890
889
  """
891
890
  The multiple browsers list on which synthetic monitors will run. Valid values are `CHROME` and `FIREFOX`.
892
891
  """
893
892
  return pulumi.get(self, "browsers")
894
893
 
895
- @property
894
+ @_builtins.property
896
895
  @pulumi.getter
897
- def devices(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]:
896
+ def devices(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
898
897
  """
899
898
  The multiple devices list on which synthetic monitors will run. Valid values are `DESKTOP`, `MOBILE_LANDSCAPE`, `MOBILE_PORTRAIT`, `TABLET_LANDSCAPE` and `TABLET_PORTRAIT`.
900
899
  """
901
900
  return pulumi.get(self, "devices")
902
901
 
903
- @property
902
+ @_builtins.property
904
903
  @pulumi.getter(name="enableScreenshotOnFailureAndScript")
905
- def enable_screenshot_on_failure_and_script(self) -> pulumi.Output[Optional[builtins.bool]]:
904
+ def enable_screenshot_on_failure_and_script(self) -> pulumi.Output[Optional[_builtins.bool]]:
906
905
  """
907
906
  Capture a screenshot during job execution.
908
907
  """
909
908
  return pulumi.get(self, "enable_screenshot_on_failure_and_script")
910
909
 
911
- @property
910
+ @_builtins.property
912
911
  @pulumi.getter
913
- def guid(self) -> pulumi.Output[builtins.str]:
912
+ def guid(self) -> pulumi.Output[_builtins.str]:
914
913
  """
915
914
  The unique entity identifier of the monitor in New Relic.
916
915
  """
917
916
  return pulumi.get(self, "guid")
918
917
 
919
- @property
918
+ @_builtins.property
920
919
  @pulumi.getter(name="locationPrivates")
921
920
  def location_privates(self) -> pulumi.Output[Optional[Sequence['outputs.StepMonitorLocationPrivate']]]:
922
921
  """
@@ -924,71 +923,71 @@ class StepMonitor(pulumi.CustomResource):
924
923
  """
925
924
  return pulumi.get(self, "location_privates")
926
925
 
927
- @property
926
+ @_builtins.property
928
927
  @pulumi.getter(name="locationsPublics")
929
- def locations_publics(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]:
928
+ def locations_publics(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
930
929
  """
931
930
  The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
932
931
  """
933
932
  return pulumi.get(self, "locations_publics")
934
933
 
935
- @property
934
+ @_builtins.property
936
935
  @pulumi.getter(name="monitorId")
937
- def monitor_id(self) -> pulumi.Output[builtins.str]:
936
+ def monitor_id(self) -> pulumi.Output[_builtins.str]:
938
937
  """
939
938
  The monitor id of the synthetics step monitor (not to be confused with the GUID of the monitor).
940
939
  """
941
940
  return pulumi.get(self, "monitor_id")
942
941
 
943
- @property
942
+ @_builtins.property
944
943
  @pulumi.getter
945
- def name(self) -> pulumi.Output[builtins.str]:
944
+ def name(self) -> pulumi.Output[_builtins.str]:
946
945
  """
947
946
  The name for the monitor.
948
947
  """
949
948
  return pulumi.get(self, "name")
950
949
 
951
- @property
950
+ @_builtins.property
952
951
  @pulumi.getter
953
- def period(self) -> pulumi.Output[builtins.str]:
952
+ def period(self) -> pulumi.Output[_builtins.str]:
954
953
  """
955
954
  The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
956
955
  """
957
956
  return pulumi.get(self, "period")
958
957
 
959
- @property
958
+ @_builtins.property
960
959
  @pulumi.getter(name="periodInMinutes")
961
- def period_in_minutes(self) -> pulumi.Output[builtins.int]:
960
+ def period_in_minutes(self) -> pulumi.Output[_builtins.int]:
962
961
  """
963
962
  The interval in minutes at which Synthetic monitor should run.
964
963
  """
965
964
  return pulumi.get(self, "period_in_minutes")
966
965
 
967
- @property
966
+ @_builtins.property
968
967
  @pulumi.getter(name="runtimeType")
969
- def runtime_type(self) -> pulumi.Output[Optional[builtins.str]]:
968
+ def runtime_type(self) -> pulumi.Output[Optional[_builtins.str]]:
970
969
  """
971
970
  The runtime that the monitor will use to run jobs (`CHROME_BROWSER`).
972
971
  """
973
972
  return pulumi.get(self, "runtime_type")
974
973
 
975
- @property
974
+ @_builtins.property
976
975
  @pulumi.getter(name="runtimeTypeVersion")
977
- def runtime_type_version(self) -> pulumi.Output[Optional[builtins.str]]:
976
+ def runtime_type_version(self) -> pulumi.Output[Optional[_builtins.str]]:
978
977
  """
979
978
  The specific semver version of the runtime type.
980
979
  """
981
980
  return pulumi.get(self, "runtime_type_version")
982
981
 
983
- @property
982
+ @_builtins.property
984
983
  @pulumi.getter
985
- def status(self) -> pulumi.Output[builtins.str]:
984
+ def status(self) -> pulumi.Output[_builtins.str]:
986
985
  """
987
986
  The run state of the monitor. (`ENABLED` or `DISABLED`).
988
987
  """
989
988
  return pulumi.get(self, "status")
990
989
 
991
- @property
990
+ @_builtins.property
992
991
  @pulumi.getter
993
992
  def steps(self) -> pulumi.Output[Sequence['outputs.StepMonitorStep']]:
994
993
  """
@@ -996,7 +995,7 @@ class StepMonitor(pulumi.CustomResource):
996
995
  """
997
996
  return pulumi.get(self, "steps")
998
997
 
999
- @property
998
+ @_builtins.property
1000
999
  @pulumi.getter
1001
1000
  def tags(self) -> pulumi.Output[Optional[Sequence['outputs.StepMonitorTag']]]:
1002
1001
  """
@@ -1004,8 +1003,8 @@ class StepMonitor(pulumi.CustomResource):
1004
1003
  """
1005
1004
  return pulumi.get(self, "tags")
1006
1005
 
1007
- @property
1006
+ @_builtins.property
1008
1007
  @pulumi.getter(name="useUnsupportedLegacyRuntime")
1009
- def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[builtins.bool]]:
1008
+ def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[_builtins.bool]]:
1010
1009
  return pulumi.get(self, "use_unsupported_legacy_runtime")
1011
1010