pulumi-newrelic 5.48.0a1752905769__py3-none-any.whl → 5.49.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (89) hide show
  1. pulumi_newrelic/__init__.py +1 -1
  2. pulumi_newrelic/_inputs.py +3897 -3739
  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 +2724 -2632
  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.48.0a1752905769.dist-info → pulumi_newrelic-5.49.0.dist-info}/METADATA +1 -1
  86. pulumi_newrelic-5.49.0.dist-info/RECORD +90 -0
  87. pulumi_newrelic-5.48.0a1752905769.dist-info/RECORD +0 -90
  88. {pulumi_newrelic-5.48.0a1752905769.dist-info → pulumi_newrelic-5.49.0.dist-info}/WHEEL +0 -0
  89. {pulumi_newrelic-5.48.0a1752905769.dist-info → pulumi_newrelic-5.49.0.dist-info}/top_level.txt +0 -0
pulumi_newrelic/synthetics/cert_check_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,30 +21,30 @@ __all__ = ['CertCheckMonitorArgs', 'CertCheckMonitor']
22
21
  @pulumi.input_type
23
22
  class CertCheckMonitorArgs:
24
23
  def __init__(__self__, *,
25
- certificate_expiration: pulumi.Input[builtins.int],
26
- domain: pulumi.Input[builtins.str],
27
- period: pulumi.Input[builtins.str],
28
- status: pulumi.Input[builtins.str],
29
- account_id: Optional[pulumi.Input[builtins.str]] = None,
30
- locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
31
- locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
32
- name: Optional[pulumi.Input[builtins.str]] = None,
33
- runtime_type: Optional[pulumi.Input[builtins.str]] = None,
34
- runtime_type_version: Optional[pulumi.Input[builtins.str]] = None,
24
+ certificate_expiration: pulumi.Input[_builtins.int],
25
+ domain: pulumi.Input[_builtins.str],
26
+ period: pulumi.Input[_builtins.str],
27
+ status: pulumi.Input[_builtins.str],
28
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
29
+ locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
30
+ locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
31
+ name: Optional[pulumi.Input[_builtins.str]] = None,
32
+ runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
33
+ runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
35
34
  tags: Optional[pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]]] = None,
36
- use_unsupported_legacy_runtime: Optional[pulumi.Input[builtins.bool]] = None):
35
+ use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
37
36
  """
38
37
  The set of arguments for constructing a CertCheckMonitor resource.
39
- :param pulumi.Input[builtins.int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
40
- :param pulumi.Input[builtins.str] domain: The domain of the host that will have its certificate checked.
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`).
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]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
45
- :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.
46
- :param pulumi.Input[builtins.str] name: The name for the monitor.
47
- :param pulumi.Input[builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
48
- :param pulumi.Input[builtins.str] runtime_type_version: The specific semver version of the runtime type.
38
+ :param pulumi.Input[_builtins.int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
39
+ :param pulumi.Input[_builtins.str] domain: The domain of the host that will have its certificate checked.
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`).
42
+ :param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
43
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
44
+ :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.
45
+ :param pulumi.Input[_builtins.str] name: The name for the monitor.
46
+ :param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
47
+ :param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
49
48
  :param pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
50
49
  """
51
50
  pulumi.set(__self__, "certificate_expiration", certificate_expiration)
@@ -69,127 +68,127 @@ class CertCheckMonitorArgs:
69
68
  if use_unsupported_legacy_runtime is not None:
70
69
  pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
71
70
 
72
- @property
71
+ @_builtins.property
73
72
  @pulumi.getter(name="certificateExpiration")
74
- def certificate_expiration(self) -> pulumi.Input[builtins.int]:
73
+ def certificate_expiration(self) -> pulumi.Input[_builtins.int]:
75
74
  """
76
75
  The desired number of remaining days until the certificate expires to trigger a monitor failure.
77
76
  """
78
77
  return pulumi.get(self, "certificate_expiration")
79
78
 
80
79
  @certificate_expiration.setter
81
- def certificate_expiration(self, value: pulumi.Input[builtins.int]):
80
+ def certificate_expiration(self, value: pulumi.Input[_builtins.int]):
82
81
  pulumi.set(self, "certificate_expiration", value)
83
82
 
84
- @property
83
+ @_builtins.property
85
84
  @pulumi.getter
86
- def domain(self) -> pulumi.Input[builtins.str]:
85
+ def domain(self) -> pulumi.Input[_builtins.str]:
87
86
  """
88
87
  The domain of the host that will have its certificate checked.
89
88
  """
90
89
  return pulumi.get(self, "domain")
91
90
 
92
91
  @domain.setter
93
- def domain(self, value: pulumi.Input[builtins.str]):
92
+ def domain(self, value: pulumi.Input[_builtins.str]):
94
93
  pulumi.set(self, "domain", value)
95
94
 
96
- @property
95
+ @_builtins.property
97
96
  @pulumi.getter
98
- def period(self) -> pulumi.Input[builtins.str]:
97
+ def period(self) -> pulumi.Input[_builtins.str]:
99
98
  """
100
99
  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`.
101
100
  """
102
101
  return pulumi.get(self, "period")
103
102
 
104
103
  @period.setter
105
- def period(self, value: pulumi.Input[builtins.str]):
104
+ def period(self, value: pulumi.Input[_builtins.str]):
106
105
  pulumi.set(self, "period", value)
107
106
 
108
- @property
107
+ @_builtins.property
109
108
  @pulumi.getter
110
- def status(self) -> pulumi.Input[builtins.str]:
109
+ def status(self) -> pulumi.Input[_builtins.str]:
111
110
  """
112
111
  The run state of the monitor. (`ENABLED` or `DISABLED`).
113
112
  """
114
113
  return pulumi.get(self, "status")
115
114
 
116
115
  @status.setter
117
- def status(self, value: pulumi.Input[builtins.str]):
116
+ def status(self, value: pulumi.Input[_builtins.str]):
118
117
  pulumi.set(self, "status", value)
119
118
 
120
- @property
119
+ @_builtins.property
121
120
  @pulumi.getter(name="accountId")
122
- def account_id(self) -> Optional[pulumi.Input[builtins.str]]:
121
+ def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
123
122
  """
124
123
  The account in which the Synthetics monitor will be created.
125
124
  """
126
125
  return pulumi.get(self, "account_id")
127
126
 
128
127
  @account_id.setter
129
- def account_id(self, value: Optional[pulumi.Input[builtins.str]]):
128
+ def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
130
129
  pulumi.set(self, "account_id", value)
131
130
 
132
- @property
131
+ @_builtins.property
133
132
  @pulumi.getter(name="locationsPrivates")
134
- def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
133
+ def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
135
134
  """
136
135
  The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
137
136
  """
138
137
  return pulumi.get(self, "locations_privates")
139
138
 
140
139
  @locations_privates.setter
141
- def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
140
+ def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
142
141
  pulumi.set(self, "locations_privates", value)
143
142
 
144
- @property
143
+ @_builtins.property
145
144
  @pulumi.getter(name="locationsPublics")
146
- def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
145
+ def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
147
146
  """
148
147
  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.
149
148
  """
150
149
  return pulumi.get(self, "locations_publics")
151
150
 
152
151
  @locations_publics.setter
153
- def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
152
+ def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
154
153
  pulumi.set(self, "locations_publics", value)
155
154
 
156
- @property
155
+ @_builtins.property
157
156
  @pulumi.getter
158
- def name(self) -> Optional[pulumi.Input[builtins.str]]:
157
+ def name(self) -> Optional[pulumi.Input[_builtins.str]]:
159
158
  """
160
159
  The name for the monitor.
161
160
  """
162
161
  return pulumi.get(self, "name")
163
162
 
164
163
  @name.setter
165
- def name(self, value: Optional[pulumi.Input[builtins.str]]):
164
+ def name(self, value: Optional[pulumi.Input[_builtins.str]]):
166
165
  pulumi.set(self, "name", value)
167
166
 
168
- @property
167
+ @_builtins.property
169
168
  @pulumi.getter(name="runtimeType")
170
- def runtime_type(self) -> Optional[pulumi.Input[builtins.str]]:
169
+ def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
171
170
  """
172
171
  The runtime that the monitor will use to run jobs (`NODE_API`).
173
172
  """
174
173
  return pulumi.get(self, "runtime_type")
175
174
 
176
175
  @runtime_type.setter
177
- def runtime_type(self, value: Optional[pulumi.Input[builtins.str]]):
176
+ def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
178
177
  pulumi.set(self, "runtime_type", value)
179
178
 
180
- @property
179
+ @_builtins.property
181
180
  @pulumi.getter(name="runtimeTypeVersion")
182
- def runtime_type_version(self) -> Optional[pulumi.Input[builtins.str]]:
181
+ def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
183
182
  """
184
183
  The specific semver version of the runtime type.
185
184
  """
186
185
  return pulumi.get(self, "runtime_type_version")
187
186
 
188
187
  @runtime_type_version.setter
189
- def runtime_type_version(self, value: Optional[pulumi.Input[builtins.str]]):
188
+ def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
190
189
  pulumi.set(self, "runtime_type_version", value)
191
190
 
192
- @property
191
+ @_builtins.property
193
192
  @pulumi.getter
194
193
  def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]]]:
195
194
  """
@@ -201,47 +200,47 @@ class CertCheckMonitorArgs:
201
200
  def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]]]):
202
201
  pulumi.set(self, "tags", value)
203
202
 
204
- @property
203
+ @_builtins.property
205
204
  @pulumi.getter(name="useUnsupportedLegacyRuntime")
206
- def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[builtins.bool]]:
205
+ def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
207
206
  return pulumi.get(self, "use_unsupported_legacy_runtime")
208
207
 
209
208
  @use_unsupported_legacy_runtime.setter
210
- def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[builtins.bool]]):
209
+ def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
211
210
  pulumi.set(self, "use_unsupported_legacy_runtime", value)
212
211
 
213
212
 
214
213
  @pulumi.input_type
215
214
  class _CertCheckMonitorState:
216
215
  def __init__(__self__, *,
217
- account_id: Optional[pulumi.Input[builtins.str]] = None,
218
- certificate_expiration: Optional[pulumi.Input[builtins.int]] = None,
219
- domain: Optional[pulumi.Input[builtins.str]] = None,
220
- locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
221
- locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
222
- monitor_id: Optional[pulumi.Input[builtins.str]] = None,
223
- name: Optional[pulumi.Input[builtins.str]] = None,
224
- period: Optional[pulumi.Input[builtins.str]] = None,
225
- period_in_minutes: Optional[pulumi.Input[builtins.int]] = None,
226
- runtime_type: Optional[pulumi.Input[builtins.str]] = None,
227
- runtime_type_version: Optional[pulumi.Input[builtins.str]] = None,
228
- status: Optional[pulumi.Input[builtins.str]] = None,
216
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
217
+ certificate_expiration: Optional[pulumi.Input[_builtins.int]] = None,
218
+ domain: Optional[pulumi.Input[_builtins.str]] = None,
219
+ locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
220
+ locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
221
+ monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
222
+ name: Optional[pulumi.Input[_builtins.str]] = None,
223
+ period: Optional[pulumi.Input[_builtins.str]] = None,
224
+ period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
225
+ runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
226
+ runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
227
+ status: Optional[pulumi.Input[_builtins.str]] = None,
229
228
  tags: Optional[pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]]] = None,
230
- use_unsupported_legacy_runtime: Optional[pulumi.Input[builtins.bool]] = None):
229
+ use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
231
230
  """
232
231
  Input properties used for looking up and filtering CertCheckMonitor resources.
233
- :param pulumi.Input[builtins.str] account_id: The account in which the Synthetics monitor will be created.
234
- :param pulumi.Input[builtins.int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
235
- :param pulumi.Input[builtins.str] domain: The domain of the host that will have its certificate checked.
236
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
237
- :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.
238
- :param pulumi.Input[builtins.str] monitor_id: The monitor id of the certificate check synthetics monitor (not to be confused with the GUID of the monitor).
239
- :param pulumi.Input[builtins.str] name: The name for the monitor.
240
- :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`.
241
- :param pulumi.Input[builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
242
- :param pulumi.Input[builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
243
- :param pulumi.Input[builtins.str] runtime_type_version: The specific semver version of the runtime type.
244
- :param pulumi.Input[builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
232
+ :param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
233
+ :param pulumi.Input[_builtins.int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
234
+ :param pulumi.Input[_builtins.str] domain: The domain of the host that will have its certificate checked.
235
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
236
+ :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.
237
+ :param pulumi.Input[_builtins.str] monitor_id: The monitor id of the certificate check synthetics monitor (not to be confused with the GUID of the monitor).
238
+ :param pulumi.Input[_builtins.str] name: The name for the monitor.
239
+ :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`.
240
+ :param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
241
+ :param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
242
+ :param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
243
+ :param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
245
244
  :param pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
246
245
  """
247
246
  if account_id is not None:
@@ -273,151 +272,151 @@ class _CertCheckMonitorState:
273
272
  if use_unsupported_legacy_runtime is not None:
274
273
  pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
275
274
 
276
- @property
275
+ @_builtins.property
277
276
  @pulumi.getter(name="accountId")
278
- def account_id(self) -> Optional[pulumi.Input[builtins.str]]:
277
+ def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
279
278
  """
280
279
  The account in which the Synthetics monitor will be created.
281
280
  """
282
281
  return pulumi.get(self, "account_id")
283
282
 
284
283
  @account_id.setter
285
- def account_id(self, value: Optional[pulumi.Input[builtins.str]]):
284
+ def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
286
285
  pulumi.set(self, "account_id", value)
287
286
 
288
- @property
287
+ @_builtins.property
289
288
  @pulumi.getter(name="certificateExpiration")
290
- def certificate_expiration(self) -> Optional[pulumi.Input[builtins.int]]:
289
+ def certificate_expiration(self) -> Optional[pulumi.Input[_builtins.int]]:
291
290
  """
292
291
  The desired number of remaining days until the certificate expires to trigger a monitor failure.
293
292
  """
294
293
  return pulumi.get(self, "certificate_expiration")
295
294
 
296
295
  @certificate_expiration.setter
297
- def certificate_expiration(self, value: Optional[pulumi.Input[builtins.int]]):
296
+ def certificate_expiration(self, value: Optional[pulumi.Input[_builtins.int]]):
298
297
  pulumi.set(self, "certificate_expiration", value)
299
298
 
300
- @property
299
+ @_builtins.property
301
300
  @pulumi.getter
302
- def domain(self) -> Optional[pulumi.Input[builtins.str]]:
301
+ def domain(self) -> Optional[pulumi.Input[_builtins.str]]:
303
302
  """
304
303
  The domain of the host that will have its certificate checked.
305
304
  """
306
305
  return pulumi.get(self, "domain")
307
306
 
308
307
  @domain.setter
309
- def domain(self, value: Optional[pulumi.Input[builtins.str]]):
308
+ def domain(self, value: Optional[pulumi.Input[_builtins.str]]):
310
309
  pulumi.set(self, "domain", value)
311
310
 
312
- @property
311
+ @_builtins.property
313
312
  @pulumi.getter(name="locationsPrivates")
314
- def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
313
+ def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
315
314
  """
316
315
  The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
317
316
  """
318
317
  return pulumi.get(self, "locations_privates")
319
318
 
320
319
  @locations_privates.setter
321
- def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
320
+ def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
322
321
  pulumi.set(self, "locations_privates", value)
323
322
 
324
- @property
323
+ @_builtins.property
325
324
  @pulumi.getter(name="locationsPublics")
326
- def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
325
+ def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
327
326
  """
328
327
  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.
329
328
  """
330
329
  return pulumi.get(self, "locations_publics")
331
330
 
332
331
  @locations_publics.setter
333
- def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
332
+ def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
334
333
  pulumi.set(self, "locations_publics", value)
335
334
 
336
- @property
335
+ @_builtins.property
337
336
  @pulumi.getter(name="monitorId")
338
- def monitor_id(self) -> Optional[pulumi.Input[builtins.str]]:
337
+ def monitor_id(self) -> Optional[pulumi.Input[_builtins.str]]:
339
338
  """
340
339
  The monitor id of the certificate check synthetics monitor (not to be confused with the GUID of the monitor).
341
340
  """
342
341
  return pulumi.get(self, "monitor_id")
343
342
 
344
343
  @monitor_id.setter
345
- def monitor_id(self, value: Optional[pulumi.Input[builtins.str]]):
344
+ def monitor_id(self, value: Optional[pulumi.Input[_builtins.str]]):
346
345
  pulumi.set(self, "monitor_id", value)
347
346
 
348
- @property
347
+ @_builtins.property
349
348
  @pulumi.getter
350
- def name(self) -> Optional[pulumi.Input[builtins.str]]:
349
+ def name(self) -> Optional[pulumi.Input[_builtins.str]]:
351
350
  """
352
351
  The name for the monitor.
353
352
  """
354
353
  return pulumi.get(self, "name")
355
354
 
356
355
  @name.setter
357
- def name(self, value: Optional[pulumi.Input[builtins.str]]):
356
+ def name(self, value: Optional[pulumi.Input[_builtins.str]]):
358
357
  pulumi.set(self, "name", value)
359
358
 
360
- @property
359
+ @_builtins.property
361
360
  @pulumi.getter
362
- def period(self) -> Optional[pulumi.Input[builtins.str]]:
361
+ def period(self) -> Optional[pulumi.Input[_builtins.str]]:
363
362
  """
364
363
  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`.
365
364
  """
366
365
  return pulumi.get(self, "period")
367
366
 
368
367
  @period.setter
369
- def period(self, value: Optional[pulumi.Input[builtins.str]]):
368
+ def period(self, value: Optional[pulumi.Input[_builtins.str]]):
370
369
  pulumi.set(self, "period", value)
371
370
 
372
- @property
371
+ @_builtins.property
373
372
  @pulumi.getter(name="periodInMinutes")
374
- def period_in_minutes(self) -> Optional[pulumi.Input[builtins.int]]:
373
+ def period_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
375
374
  """
376
375
  The interval in minutes at which Synthetic monitor should run.
377
376
  """
378
377
  return pulumi.get(self, "period_in_minutes")
379
378
 
380
379
  @period_in_minutes.setter
381
- def period_in_minutes(self, value: Optional[pulumi.Input[builtins.int]]):
380
+ def period_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
382
381
  pulumi.set(self, "period_in_minutes", value)
383
382
 
384
- @property
383
+ @_builtins.property
385
384
  @pulumi.getter(name="runtimeType")
386
- def runtime_type(self) -> Optional[pulumi.Input[builtins.str]]:
385
+ def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
387
386
  """
388
387
  The runtime that the monitor will use to run jobs (`NODE_API`).
389
388
  """
390
389
  return pulumi.get(self, "runtime_type")
391
390
 
392
391
  @runtime_type.setter
393
- def runtime_type(self, value: Optional[pulumi.Input[builtins.str]]):
392
+ def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
394
393
  pulumi.set(self, "runtime_type", value)
395
394
 
396
- @property
395
+ @_builtins.property
397
396
  @pulumi.getter(name="runtimeTypeVersion")
398
- def runtime_type_version(self) -> Optional[pulumi.Input[builtins.str]]:
397
+ def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
399
398
  """
400
399
  The specific semver version of the runtime type.
401
400
  """
402
401
  return pulumi.get(self, "runtime_type_version")
403
402
 
404
403
  @runtime_type_version.setter
405
- def runtime_type_version(self, value: Optional[pulumi.Input[builtins.str]]):
404
+ def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
406
405
  pulumi.set(self, "runtime_type_version", value)
407
406
 
408
- @property
407
+ @_builtins.property
409
408
  @pulumi.getter
410
- def status(self) -> Optional[pulumi.Input[builtins.str]]:
409
+ def status(self) -> Optional[pulumi.Input[_builtins.str]]:
411
410
  """
412
411
  The run state of the monitor. (`ENABLED` or `DISABLED`).
413
412
  """
414
413
  return pulumi.get(self, "status")
415
414
 
416
415
  @status.setter
417
- def status(self, value: Optional[pulumi.Input[builtins.str]]):
416
+ def status(self, value: Optional[pulumi.Input[_builtins.str]]):
418
417
  pulumi.set(self, "status", value)
419
418
 
420
- @property
419
+ @_builtins.property
421
420
  @pulumi.getter
422
421
  def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]]]:
423
422
  """
@@ -429,13 +428,13 @@ class _CertCheckMonitorState:
429
428
  def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]]]):
430
429
  pulumi.set(self, "tags", value)
431
430
 
432
- @property
431
+ @_builtins.property
433
432
  @pulumi.getter(name="useUnsupportedLegacyRuntime")
434
- def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[builtins.bool]]:
433
+ def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
435
434
  return pulumi.get(self, "use_unsupported_legacy_runtime")
436
435
 
437
436
  @use_unsupported_legacy_runtime.setter
438
- def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[builtins.bool]]):
437
+ def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
439
438
  pulumi.set(self, "use_unsupported_legacy_runtime", value)
440
439
 
441
440
 
@@ -445,18 +444,18 @@ class CertCheckMonitor(pulumi.CustomResource):
445
444
  def __init__(__self__,
446
445
  resource_name: str,
447
446
  opts: Optional[pulumi.ResourceOptions] = None,
448
- account_id: Optional[pulumi.Input[builtins.str]] = None,
449
- certificate_expiration: Optional[pulumi.Input[builtins.int]] = None,
450
- domain: Optional[pulumi.Input[builtins.str]] = None,
451
- locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
452
- locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
453
- name: Optional[pulumi.Input[builtins.str]] = None,
454
- period: Optional[pulumi.Input[builtins.str]] = None,
455
- runtime_type: Optional[pulumi.Input[builtins.str]] = None,
456
- runtime_type_version: Optional[pulumi.Input[builtins.str]] = None,
457
- status: Optional[pulumi.Input[builtins.str]] = None,
447
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
448
+ certificate_expiration: Optional[pulumi.Input[_builtins.int]] = None,
449
+ domain: Optional[pulumi.Input[_builtins.str]] = None,
450
+ locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
451
+ locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
452
+ name: Optional[pulumi.Input[_builtins.str]] = None,
453
+ period: Optional[pulumi.Input[_builtins.str]] = None,
454
+ runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
455
+ runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
456
+ status: Optional[pulumi.Input[_builtins.str]] = None,
458
457
  tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['CertCheckMonitorTagArgs', 'CertCheckMonitorTagArgsDict']]]]] = None,
459
- use_unsupported_legacy_runtime: Optional[pulumi.Input[builtins.bool]] = None,
458
+ use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
460
459
  __props__=None):
461
460
  """
462
461
  ## Example Usage
@@ -522,16 +521,16 @@ class CertCheckMonitor(pulumi.CustomResource):
522
521
 
523
522
  :param str resource_name: The name of the resource.
524
523
  :param pulumi.ResourceOptions opts: Options for the resource.
525
- :param pulumi.Input[builtins.str] account_id: The account in which the Synthetics monitor will be created.
526
- :param pulumi.Input[builtins.int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
527
- :param pulumi.Input[builtins.str] domain: The domain of the host that will have its certificate checked.
528
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
529
- :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.
530
- :param pulumi.Input[builtins.str] name: The name for the monitor.
531
- :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`.
532
- :param pulumi.Input[builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
533
- :param pulumi.Input[builtins.str] runtime_type_version: The specific semver version of the runtime type.
534
- :param pulumi.Input[builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
524
+ :param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
525
+ :param pulumi.Input[_builtins.int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
526
+ :param pulumi.Input[_builtins.str] domain: The domain of the host that will have its certificate checked.
527
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
528
+ :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.
529
+ :param pulumi.Input[_builtins.str] name: The name for the monitor.
530
+ :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`.
531
+ :param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
532
+ :param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
533
+ :param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
535
534
  :param pulumi.Input[Sequence[pulumi.Input[Union['CertCheckMonitorTagArgs', 'CertCheckMonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
536
535
  """
537
536
  ...
@@ -617,18 +616,18 @@ class CertCheckMonitor(pulumi.CustomResource):
617
616
  def _internal_init(__self__,
618
617
  resource_name: str,
619
618
  opts: Optional[pulumi.ResourceOptions] = None,
620
- account_id: Optional[pulumi.Input[builtins.str]] = None,
621
- certificate_expiration: Optional[pulumi.Input[builtins.int]] = None,
622
- domain: Optional[pulumi.Input[builtins.str]] = None,
623
- locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
624
- locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
625
- name: Optional[pulumi.Input[builtins.str]] = None,
626
- period: Optional[pulumi.Input[builtins.str]] = None,
627
- runtime_type: Optional[pulumi.Input[builtins.str]] = None,
628
- runtime_type_version: Optional[pulumi.Input[builtins.str]] = None,
629
- status: Optional[pulumi.Input[builtins.str]] = None,
619
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
620
+ certificate_expiration: Optional[pulumi.Input[_builtins.int]] = None,
621
+ domain: Optional[pulumi.Input[_builtins.str]] = None,
622
+ locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
623
+ locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
624
+ name: Optional[pulumi.Input[_builtins.str]] = None,
625
+ period: Optional[pulumi.Input[_builtins.str]] = None,
626
+ runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
627
+ runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
628
+ status: Optional[pulumi.Input[_builtins.str]] = None,
630
629
  tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['CertCheckMonitorTagArgs', 'CertCheckMonitorTagArgsDict']]]]] = None,
631
- use_unsupported_legacy_runtime: Optional[pulumi.Input[builtins.bool]] = None,
630
+ use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
632
631
  __props__=None):
633
632
  opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
634
633
  if not isinstance(opts, pulumi.ResourceOptions):
@@ -670,20 +669,20 @@ class CertCheckMonitor(pulumi.CustomResource):
670
669
  def get(resource_name: str,
671
670
  id: pulumi.Input[str],
672
671
  opts: Optional[pulumi.ResourceOptions] = None,
673
- account_id: Optional[pulumi.Input[builtins.str]] = None,
674
- certificate_expiration: Optional[pulumi.Input[builtins.int]] = None,
675
- domain: Optional[pulumi.Input[builtins.str]] = None,
676
- locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
677
- locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
678
- monitor_id: Optional[pulumi.Input[builtins.str]] = None,
679
- name: Optional[pulumi.Input[builtins.str]] = None,
680
- period: Optional[pulumi.Input[builtins.str]] = None,
681
- period_in_minutes: Optional[pulumi.Input[builtins.int]] = None,
682
- runtime_type: Optional[pulumi.Input[builtins.str]] = None,
683
- runtime_type_version: Optional[pulumi.Input[builtins.str]] = None,
684
- status: Optional[pulumi.Input[builtins.str]] = None,
672
+ account_id: Optional[pulumi.Input[_builtins.str]] = None,
673
+ certificate_expiration: Optional[pulumi.Input[_builtins.int]] = None,
674
+ domain: Optional[pulumi.Input[_builtins.str]] = None,
675
+ locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
676
+ locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
677
+ monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
678
+ name: Optional[pulumi.Input[_builtins.str]] = None,
679
+ period: Optional[pulumi.Input[_builtins.str]] = None,
680
+ period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
681
+ runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
682
+ runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
683
+ status: Optional[pulumi.Input[_builtins.str]] = None,
685
684
  tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['CertCheckMonitorTagArgs', 'CertCheckMonitorTagArgsDict']]]]] = None,
686
- use_unsupported_legacy_runtime: Optional[pulumi.Input[builtins.bool]] = None) -> 'CertCheckMonitor':
685
+ use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None) -> 'CertCheckMonitor':
687
686
  """
688
687
  Get an existing CertCheckMonitor resource's state with the given name, id, and optional extra
689
688
  properties used to qualify the lookup.
@@ -691,18 +690,18 @@ class CertCheckMonitor(pulumi.CustomResource):
691
690
  :param str resource_name: The unique name of the resulting resource.
692
691
  :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
693
692
  :param pulumi.ResourceOptions opts: Options for the resource.
694
- :param pulumi.Input[builtins.str] account_id: The account in which the Synthetics monitor will be created.
695
- :param pulumi.Input[builtins.int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
696
- :param pulumi.Input[builtins.str] domain: The domain of the host that will have its certificate checked.
697
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
698
- :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.
699
- :param pulumi.Input[builtins.str] monitor_id: The monitor id of the certificate check synthetics monitor (not to be confused with the GUID of the monitor).
700
- :param pulumi.Input[builtins.str] name: The name for the monitor.
701
- :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`.
702
- :param pulumi.Input[builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
703
- :param pulumi.Input[builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
704
- :param pulumi.Input[builtins.str] runtime_type_version: The specific semver version of the runtime type.
705
- :param pulumi.Input[builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
693
+ :param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
694
+ :param pulumi.Input[_builtins.int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
695
+ :param pulumi.Input[_builtins.str] domain: The domain of the host that will have its certificate checked.
696
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
697
+ :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.
698
+ :param pulumi.Input[_builtins.str] monitor_id: The monitor id of the certificate check synthetics monitor (not to be confused with the GUID of the monitor).
699
+ :param pulumi.Input[_builtins.str] name: The name for the monitor.
700
+ :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`.
701
+ :param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
702
+ :param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
703
+ :param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
704
+ :param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
706
705
  :param pulumi.Input[Sequence[pulumi.Input[Union['CertCheckMonitorTagArgs', 'CertCheckMonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
707
706
  """
708
707
  opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
@@ -725,103 +724,103 @@ class CertCheckMonitor(pulumi.CustomResource):
725
724
  __props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
726
725
  return CertCheckMonitor(resource_name, opts=opts, __props__=__props__)
727
726
 
728
- @property
727
+ @_builtins.property
729
728
  @pulumi.getter(name="accountId")
730
- def account_id(self) -> pulumi.Output[builtins.str]:
729
+ def account_id(self) -> pulumi.Output[_builtins.str]:
731
730
  """
732
731
  The account in which the Synthetics monitor will be created.
733
732
  """
734
733
  return pulumi.get(self, "account_id")
735
734
 
736
- @property
735
+ @_builtins.property
737
736
  @pulumi.getter(name="certificateExpiration")
738
- def certificate_expiration(self) -> pulumi.Output[builtins.int]:
737
+ def certificate_expiration(self) -> pulumi.Output[_builtins.int]:
739
738
  """
740
739
  The desired number of remaining days until the certificate expires to trigger a monitor failure.
741
740
  """
742
741
  return pulumi.get(self, "certificate_expiration")
743
742
 
744
- @property
743
+ @_builtins.property
745
744
  @pulumi.getter
746
- def domain(self) -> pulumi.Output[builtins.str]:
745
+ def domain(self) -> pulumi.Output[_builtins.str]:
747
746
  """
748
747
  The domain of the host that will have its certificate checked.
749
748
  """
750
749
  return pulumi.get(self, "domain")
751
750
 
752
- @property
751
+ @_builtins.property
753
752
  @pulumi.getter(name="locationsPrivates")
754
- def locations_privates(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]:
753
+ def locations_privates(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
755
754
  """
756
755
  The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
757
756
  """
758
757
  return pulumi.get(self, "locations_privates")
759
758
 
760
- @property
759
+ @_builtins.property
761
760
  @pulumi.getter(name="locationsPublics")
762
- def locations_publics(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]:
761
+ def locations_publics(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
763
762
  """
764
763
  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.
765
764
  """
766
765
  return pulumi.get(self, "locations_publics")
767
766
 
768
- @property
767
+ @_builtins.property
769
768
  @pulumi.getter(name="monitorId")
770
- def monitor_id(self) -> pulumi.Output[builtins.str]:
769
+ def monitor_id(self) -> pulumi.Output[_builtins.str]:
771
770
  """
772
771
  The monitor id of the certificate check synthetics monitor (not to be confused with the GUID of the monitor).
773
772
  """
774
773
  return pulumi.get(self, "monitor_id")
775
774
 
776
- @property
775
+ @_builtins.property
777
776
  @pulumi.getter
778
- def name(self) -> pulumi.Output[builtins.str]:
777
+ def name(self) -> pulumi.Output[_builtins.str]:
779
778
  """
780
779
  The name for the monitor.
781
780
  """
782
781
  return pulumi.get(self, "name")
783
782
 
784
- @property
783
+ @_builtins.property
785
784
  @pulumi.getter
786
- def period(self) -> pulumi.Output[builtins.str]:
785
+ def period(self) -> pulumi.Output[_builtins.str]:
787
786
  """
788
787
  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`.
789
788
  """
790
789
  return pulumi.get(self, "period")
791
790
 
792
- @property
791
+ @_builtins.property
793
792
  @pulumi.getter(name="periodInMinutes")
794
- def period_in_minutes(self) -> pulumi.Output[builtins.int]:
793
+ def period_in_minutes(self) -> pulumi.Output[_builtins.int]:
795
794
  """
796
795
  The interval in minutes at which Synthetic monitor should run.
797
796
  """
798
797
  return pulumi.get(self, "period_in_minutes")
799
798
 
800
- @property
799
+ @_builtins.property
801
800
  @pulumi.getter(name="runtimeType")
802
- def runtime_type(self) -> pulumi.Output[Optional[builtins.str]]:
801
+ def runtime_type(self) -> pulumi.Output[Optional[_builtins.str]]:
803
802
  """
804
803
  The runtime that the monitor will use to run jobs (`NODE_API`).
805
804
  """
806
805
  return pulumi.get(self, "runtime_type")
807
806
 
808
- @property
807
+ @_builtins.property
809
808
  @pulumi.getter(name="runtimeTypeVersion")
810
- def runtime_type_version(self) -> pulumi.Output[Optional[builtins.str]]:
809
+ def runtime_type_version(self) -> pulumi.Output[Optional[_builtins.str]]:
811
810
  """
812
811
  The specific semver version of the runtime type.
813
812
  """
814
813
  return pulumi.get(self, "runtime_type_version")
815
814
 
816
- @property
815
+ @_builtins.property
817
816
  @pulumi.getter
818
- def status(self) -> pulumi.Output[builtins.str]:
817
+ def status(self) -> pulumi.Output[_builtins.str]:
819
818
  """
820
819
  The run state of the monitor. (`ENABLED` or `DISABLED`).
821
820
  """
822
821
  return pulumi.get(self, "status")
823
822
 
824
- @property
823
+ @_builtins.property
825
824
  @pulumi.getter
826
825
  def tags(self) -> pulumi.Output[Optional[Sequence['outputs.CertCheckMonitorTag']]]:
827
826
  """
@@ -829,8 +828,8 @@ class CertCheckMonitor(pulumi.CustomResource):
829
828
  """
830
829
  return pulumi.get(self, "tags")
831
830
 
832
- @property
831
+ @_builtins.property
833
832
  @pulumi.getter(name="useUnsupportedLegacyRuntime")
834
- def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[builtins.bool]]:
833
+ def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[_builtins.bool]]:
835
834
  return pulumi.get(self, "use_unsupported_legacy_runtime")
836
835