pulumi-newrelic 5.48.0a1753156041__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 +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.48.0a1753156041.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.0a1753156041.dist-info/RECORD +0 -90
  88. {pulumi_newrelic-5.48.0a1753156041.dist-info → pulumi_newrelic-5.49.0.dist-info}/WHEEL +0 -0
  89. {pulumi_newrelic-5.48.0a1753156041.dist-info → pulumi_newrelic-5.49.0.dist-info}/top_level.txt +0 -0
pulumi_newrelic/plugins/_inputs.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
@@ -46,19 +45,19 @@ MYPY = False
46
45
 
47
46
  if not MYPY:
48
47
  class ApplicationSettingsErrorCollectorArgsDict(TypedDict):
49
- expected_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
48
+ expected_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
50
49
  """
51
50
  A list of expected error classes.
52
51
  """
53
- expected_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
52
+ expected_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
54
53
  """
55
54
  A list of expected error codes(any status code between 100-900).
56
55
  """
57
- ignored_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
56
+ ignored_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
58
57
  """
59
58
  A list of ignored error classes.
60
59
  """
61
- ignored_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
60
+ ignored_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
62
61
  """
63
62
  A list of ignored error codes(any status code between 100-900).
64
63
  """
@@ -68,15 +67,15 @@ elif False:
68
67
  @pulumi.input_type
69
68
  class ApplicationSettingsErrorCollectorArgs:
70
69
  def __init__(__self__, *,
71
- expected_error_classes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
72
- expected_error_codes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
73
- ignored_error_classes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
74
- ignored_error_codes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
70
+ expected_error_classes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
71
+ expected_error_codes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
72
+ ignored_error_classes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
73
+ ignored_error_codes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
75
74
  """
76
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] expected_error_classes: A list of expected error classes.
77
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] expected_error_codes: A list of expected error codes(any status code between 100-900).
78
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ignored_error_classes: A list of ignored error classes.
79
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ignored_error_codes: A list of ignored error codes(any status code between 100-900).
75
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] expected_error_classes: A list of expected error classes.
76
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] expected_error_codes: A list of expected error codes(any status code between 100-900).
77
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ignored_error_classes: A list of ignored error classes.
78
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ignored_error_codes: A list of ignored error codes(any status code between 100-900).
80
79
  """
81
80
  if expected_error_classes is not None:
82
81
  pulumi.set(__self__, "expected_error_classes", expected_error_classes)
@@ -87,52 +86,52 @@ class ApplicationSettingsErrorCollectorArgs:
87
86
  if ignored_error_codes is not None:
88
87
  pulumi.set(__self__, "ignored_error_codes", ignored_error_codes)
89
88
 
90
- @property
89
+ @_builtins.property
91
90
  @pulumi.getter(name="expectedErrorClasses")
92
- def expected_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
91
+ def expected_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
93
92
  """
94
93
  A list of expected error classes.
95
94
  """
96
95
  return pulumi.get(self, "expected_error_classes")
97
96
 
98
97
  @expected_error_classes.setter
99
- def expected_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
98
+ def expected_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
100
99
  pulumi.set(self, "expected_error_classes", value)
101
100
 
102
- @property
101
+ @_builtins.property
103
102
  @pulumi.getter(name="expectedErrorCodes")
104
- def expected_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
103
+ def expected_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
105
104
  """
106
105
  A list of expected error codes(any status code between 100-900).
107
106
  """
108
107
  return pulumi.get(self, "expected_error_codes")
109
108
 
110
109
  @expected_error_codes.setter
111
- def expected_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
110
+ def expected_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
112
111
  pulumi.set(self, "expected_error_codes", value)
113
112
 
114
- @property
113
+ @_builtins.property
115
114
  @pulumi.getter(name="ignoredErrorClasses")
116
- def ignored_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
115
+ def ignored_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
117
116
  """
118
117
  A list of ignored error classes.
119
118
  """
120
119
  return pulumi.get(self, "ignored_error_classes")
121
120
 
122
121
  @ignored_error_classes.setter
123
- def ignored_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
122
+ def ignored_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
124
123
  pulumi.set(self, "ignored_error_classes", value)
125
124
 
126
- @property
125
+ @_builtins.property
127
126
  @pulumi.getter(name="ignoredErrorCodes")
128
- def ignored_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
127
+ def ignored_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
129
128
  """
130
129
  A list of ignored error codes(any status code between 100-900).
131
130
  """
132
131
  return pulumi.get(self, "ignored_error_codes")
133
132
 
134
133
  @ignored_error_codes.setter
135
- def ignored_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
134
+ def ignored_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
136
135
  pulumi.set(self, "ignored_error_codes", value)
137
136
 
138
137
 
@@ -146,15 +145,15 @@ if not MYPY:
146
145
  """
147
146
  Configuration block for SQL logging. Including this block enables SQL logging. The following arguments are supported:
148
147
  """
149
- stack_trace_threshold_value: NotRequired[pulumi.Input[builtins.float]]
148
+ stack_trace_threshold_value: NotRequired[pulumi.Input[_builtins.float]]
150
149
  """
151
150
  The response time threshold for collecting stack traces.
152
151
  """
153
- transaction_threshold_type: NotRequired[pulumi.Input[builtins.str]]
152
+ transaction_threshold_type: NotRequired[pulumi.Input[_builtins.str]]
154
153
  """
155
154
  The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
156
155
  """
157
- transaction_threshold_value: NotRequired[pulumi.Input[builtins.float]]
156
+ transaction_threshold_value: NotRequired[pulumi.Input[_builtins.float]]
158
157
  """
159
158
  The threshold value for transactions(in seconds).
160
159
  """
@@ -166,15 +165,15 @@ class ApplicationSettingsTransactionTracerArgs:
166
165
  def __init__(__self__, *,
167
166
  explain_query_plans: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]]] = None,
168
167
  sql: Optional[pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs']] = None,
169
- stack_trace_threshold_value: Optional[pulumi.Input[builtins.float]] = None,
170
- transaction_threshold_type: Optional[pulumi.Input[builtins.str]] = None,
171
- transaction_threshold_value: Optional[pulumi.Input[builtins.float]] = None):
168
+ stack_trace_threshold_value: Optional[pulumi.Input[_builtins.float]] = None,
169
+ transaction_threshold_type: Optional[pulumi.Input[_builtins.str]] = None,
170
+ transaction_threshold_value: Optional[pulumi.Input[_builtins.float]] = None):
172
171
  """
173
172
  :param pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]] explain_query_plans: Configuration block for query plans. Including this block enables the capture of query plans. The following arguments are supported:
174
173
  :param pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs'] sql: Configuration block for SQL logging. Including this block enables SQL logging. The following arguments are supported:
175
- :param pulumi.Input[builtins.float] stack_trace_threshold_value: The response time threshold for collecting stack traces.
176
- :param pulumi.Input[builtins.str] transaction_threshold_type: The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
177
- :param pulumi.Input[builtins.float] transaction_threshold_value: The threshold value for transactions(in seconds).
174
+ :param pulumi.Input[_builtins.float] stack_trace_threshold_value: The response time threshold for collecting stack traces.
175
+ :param pulumi.Input[_builtins.str] transaction_threshold_type: The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
176
+ :param pulumi.Input[_builtins.float] transaction_threshold_value: The threshold value for transactions(in seconds).
178
177
  """
179
178
  if explain_query_plans is not None:
180
179
  pulumi.set(__self__, "explain_query_plans", explain_query_plans)
@@ -187,7 +186,7 @@ class ApplicationSettingsTransactionTracerArgs:
187
186
  if transaction_threshold_value is not None:
188
187
  pulumi.set(__self__, "transaction_threshold_value", transaction_threshold_value)
189
188
 
190
- @property
189
+ @_builtins.property
191
190
  @pulumi.getter(name="explainQueryPlans")
192
191
  def explain_query_plans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]]]:
193
192
  """
@@ -199,7 +198,7 @@ class ApplicationSettingsTransactionTracerArgs:
199
198
  def explain_query_plans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]]]):
200
199
  pulumi.set(self, "explain_query_plans", value)
201
200
 
202
- @property
201
+ @_builtins.property
203
202
  @pulumi.getter
204
203
  def sql(self) -> Optional[pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs']]:
205
204
  """
@@ -211,50 +210,50 @@ class ApplicationSettingsTransactionTracerArgs:
211
210
  def sql(self, value: Optional[pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs']]):
212
211
  pulumi.set(self, "sql", value)
213
212
 
214
- @property
213
+ @_builtins.property
215
214
  @pulumi.getter(name="stackTraceThresholdValue")
216
- def stack_trace_threshold_value(self) -> Optional[pulumi.Input[builtins.float]]:
215
+ def stack_trace_threshold_value(self) -> Optional[pulumi.Input[_builtins.float]]:
217
216
  """
218
217
  The response time threshold for collecting stack traces.
219
218
  """
220
219
  return pulumi.get(self, "stack_trace_threshold_value")
221
220
 
222
221
  @stack_trace_threshold_value.setter
223
- def stack_trace_threshold_value(self, value: Optional[pulumi.Input[builtins.float]]):
222
+ def stack_trace_threshold_value(self, value: Optional[pulumi.Input[_builtins.float]]):
224
223
  pulumi.set(self, "stack_trace_threshold_value", value)
225
224
 
226
- @property
225
+ @_builtins.property
227
226
  @pulumi.getter(name="transactionThresholdType")
228
- def transaction_threshold_type(self) -> Optional[pulumi.Input[builtins.str]]:
227
+ def transaction_threshold_type(self) -> Optional[pulumi.Input[_builtins.str]]:
229
228
  """
230
229
  The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
231
230
  """
232
231
  return pulumi.get(self, "transaction_threshold_type")
233
232
 
234
233
  @transaction_threshold_type.setter
235
- def transaction_threshold_type(self, value: Optional[pulumi.Input[builtins.str]]):
234
+ def transaction_threshold_type(self, value: Optional[pulumi.Input[_builtins.str]]):
236
235
  pulumi.set(self, "transaction_threshold_type", value)
237
236
 
238
- @property
237
+ @_builtins.property
239
238
  @pulumi.getter(name="transactionThresholdValue")
240
- def transaction_threshold_value(self) -> Optional[pulumi.Input[builtins.float]]:
239
+ def transaction_threshold_value(self) -> Optional[pulumi.Input[_builtins.float]]:
241
240
  """
242
241
  The threshold value for transactions(in seconds).
243
242
  """
244
243
  return pulumi.get(self, "transaction_threshold_value")
245
244
 
246
245
  @transaction_threshold_value.setter
247
- def transaction_threshold_value(self, value: Optional[pulumi.Input[builtins.float]]):
246
+ def transaction_threshold_value(self, value: Optional[pulumi.Input[_builtins.float]]):
248
247
  pulumi.set(self, "transaction_threshold_value", value)
249
248
 
250
249
 
251
250
  if not MYPY:
252
251
  class ApplicationSettingsTransactionTracerExplainQueryPlanArgsDict(TypedDict):
253
- query_plan_threshold_type: NotRequired[pulumi.Input[builtins.str]]
252
+ query_plan_threshold_type: NotRequired[pulumi.Input[_builtins.str]]
254
253
  """
255
254
  The type of threshold for query plans. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
256
255
  """
257
- query_plan_threshold_value: NotRequired[pulumi.Input[builtins.float]]
256
+ query_plan_threshold_value: NotRequired[pulumi.Input[_builtins.float]]
258
257
  """
259
258
  The response time threshold for capturing query plans(in seconds).
260
259
  """
@@ -264,45 +263,45 @@ elif False:
264
263
  @pulumi.input_type
265
264
  class ApplicationSettingsTransactionTracerExplainQueryPlanArgs:
266
265
  def __init__(__self__, *,
267
- query_plan_threshold_type: Optional[pulumi.Input[builtins.str]] = None,
268
- query_plan_threshold_value: Optional[pulumi.Input[builtins.float]] = None):
266
+ query_plan_threshold_type: Optional[pulumi.Input[_builtins.str]] = None,
267
+ query_plan_threshold_value: Optional[pulumi.Input[_builtins.float]] = None):
269
268
  """
270
- :param pulumi.Input[builtins.str] query_plan_threshold_type: The type of threshold for query plans. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
271
- :param pulumi.Input[builtins.float] query_plan_threshold_value: The response time threshold for capturing query plans(in seconds).
269
+ :param pulumi.Input[_builtins.str] query_plan_threshold_type: The type of threshold for query plans. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
270
+ :param pulumi.Input[_builtins.float] query_plan_threshold_value: The response time threshold for capturing query plans(in seconds).
272
271
  """
273
272
  if query_plan_threshold_type is not None:
274
273
  pulumi.set(__self__, "query_plan_threshold_type", query_plan_threshold_type)
275
274
  if query_plan_threshold_value is not None:
276
275
  pulumi.set(__self__, "query_plan_threshold_value", query_plan_threshold_value)
277
276
 
278
- @property
277
+ @_builtins.property
279
278
  @pulumi.getter(name="queryPlanThresholdType")
280
- def query_plan_threshold_type(self) -> Optional[pulumi.Input[builtins.str]]:
279
+ def query_plan_threshold_type(self) -> Optional[pulumi.Input[_builtins.str]]:
281
280
  """
282
281
  The type of threshold for query plans. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
283
282
  """
284
283
  return pulumi.get(self, "query_plan_threshold_type")
285
284
 
286
285
  @query_plan_threshold_type.setter
287
- def query_plan_threshold_type(self, value: Optional[pulumi.Input[builtins.str]]):
286
+ def query_plan_threshold_type(self, value: Optional[pulumi.Input[_builtins.str]]):
288
287
  pulumi.set(self, "query_plan_threshold_type", value)
289
288
 
290
- @property
289
+ @_builtins.property
291
290
  @pulumi.getter(name="queryPlanThresholdValue")
292
- def query_plan_threshold_value(self) -> Optional[pulumi.Input[builtins.float]]:
291
+ def query_plan_threshold_value(self) -> Optional[pulumi.Input[_builtins.float]]:
293
292
  """
294
293
  The response time threshold for capturing query plans(in seconds).
295
294
  """
296
295
  return pulumi.get(self, "query_plan_threshold_value")
297
296
 
298
297
  @query_plan_threshold_value.setter
299
- def query_plan_threshold_value(self, value: Optional[pulumi.Input[builtins.float]]):
298
+ def query_plan_threshold_value(self, value: Optional[pulumi.Input[_builtins.float]]):
300
299
  pulumi.set(self, "query_plan_threshold_value", value)
301
300
 
302
301
 
303
302
  if not MYPY:
304
303
  class ApplicationSettingsTransactionTracerSqlArgsDict(TypedDict):
305
- record_sql: pulumi.Input[builtins.str]
304
+ record_sql: pulumi.Input[_builtins.str]
306
305
  """
307
306
  The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
308
307
  """
@@ -312,28 +311,28 @@ elif False:
312
311
  @pulumi.input_type
313
312
  class ApplicationSettingsTransactionTracerSqlArgs:
314
313
  def __init__(__self__, *,
315
- record_sql: pulumi.Input[builtins.str]):
314
+ record_sql: pulumi.Input[_builtins.str]):
316
315
  """
317
- :param pulumi.Input[builtins.str] record_sql: The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
316
+ :param pulumi.Input[_builtins.str] record_sql: The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
318
317
  """
319
318
  pulumi.set(__self__, "record_sql", record_sql)
320
319
 
321
- @property
320
+ @_builtins.property
322
321
  @pulumi.getter(name="recordSql")
323
- def record_sql(self) -> pulumi.Input[builtins.str]:
322
+ def record_sql(self) -> pulumi.Input[_builtins.str]:
324
323
  """
325
324
  The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
326
325
  """
327
326
  return pulumi.get(self, "record_sql")
328
327
 
329
328
  @record_sql.setter
330
- def record_sql(self, value: pulumi.Input[builtins.str]):
329
+ def record_sql(self, value: pulumi.Input[_builtins.str]):
331
330
  pulumi.set(self, "record_sql", value)
332
331
 
333
332
 
334
333
  if not MYPY:
335
334
  class WorkloadEntitySearchQueryArgsDict(TypedDict):
336
- query: pulumi.Input[builtins.str]
335
+ query: pulumi.Input[_builtins.str]
337
336
  """
338
337
  A valid entity search query; empty, and null values are considered invalid.
339
338
  """
@@ -343,28 +342,28 @@ elif False:
343
342
  @pulumi.input_type
344
343
  class WorkloadEntitySearchQueryArgs:
345
344
  def __init__(__self__, *,
346
- query: pulumi.Input[builtins.str]):
345
+ query: pulumi.Input[_builtins.str]):
347
346
  """
348
- :param pulumi.Input[builtins.str] query: A valid entity search query; empty, and null values are considered invalid.
347
+ :param pulumi.Input[_builtins.str] query: A valid entity search query; empty, and null values are considered invalid.
349
348
  """
350
349
  pulumi.set(__self__, "query", query)
351
350
 
352
- @property
351
+ @_builtins.property
353
352
  @pulumi.getter
354
- def query(self) -> pulumi.Input[builtins.str]:
353
+ def query(self) -> pulumi.Input[_builtins.str]:
355
354
  """
356
355
  A valid entity search query; empty, and null values are considered invalid.
357
356
  """
358
357
  return pulumi.get(self, "query")
359
358
 
360
359
  @query.setter
361
- def query(self, value: pulumi.Input[builtins.str]):
360
+ def query(self, value: pulumi.Input[_builtins.str]):
362
361
  pulumi.set(self, "query", value)
363
362
 
364
363
 
365
364
  if not MYPY:
366
365
  class WorkloadStatusConfigAutomaticArgsDict(TypedDict):
367
- enabled: pulumi.Input[builtins.bool]
366
+ enabled: pulumi.Input[_builtins.bool]
368
367
  """
369
368
  Whether the automatic status configuration is enabled or not.
370
369
  """
@@ -382,11 +381,11 @@ elif False:
382
381
  @pulumi.input_type
383
382
  class WorkloadStatusConfigAutomaticArgs:
384
383
  def __init__(__self__, *,
385
- enabled: pulumi.Input[builtins.bool],
384
+ enabled: pulumi.Input[_builtins.bool],
386
385
  remaining_entities_rule: Optional[pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs']] = None,
387
386
  rules: Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]]] = None):
388
387
  """
389
- :param pulumi.Input[builtins.bool] enabled: Whether the automatic status configuration is enabled or not.
388
+ :param pulumi.Input[_builtins.bool] enabled: Whether the automatic status configuration is enabled or not.
390
389
  :param pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs'] remaining_entities_rule: An additional meta-rule that can consider all entities that haven't been evaluated by any other rule.
391
390
  :param pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]] rules: A list of rules.
392
391
  """
@@ -396,19 +395,19 @@ class WorkloadStatusConfigAutomaticArgs:
396
395
  if rules is not None:
397
396
  pulumi.set(__self__, "rules", rules)
398
397
 
399
- @property
398
+ @_builtins.property
400
399
  @pulumi.getter
401
- def enabled(self) -> pulumi.Input[builtins.bool]:
400
+ def enabled(self) -> pulumi.Input[_builtins.bool]:
402
401
  """
403
402
  Whether the automatic status configuration is enabled or not.
404
403
  """
405
404
  return pulumi.get(self, "enabled")
406
405
 
407
406
  @enabled.setter
408
- def enabled(self, value: pulumi.Input[builtins.bool]):
407
+ def enabled(self, value: pulumi.Input[_builtins.bool]):
409
408
  pulumi.set(self, "enabled", value)
410
409
 
411
- @property
410
+ @_builtins.property
412
411
  @pulumi.getter(name="remainingEntitiesRule")
413
412
  def remaining_entities_rule(self) -> Optional[pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs']]:
414
413
  """
@@ -420,7 +419,7 @@ class WorkloadStatusConfigAutomaticArgs:
420
419
  def remaining_entities_rule(self, value: Optional[pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs']]):
421
420
  pulumi.set(self, "remaining_entities_rule", value)
422
421
 
423
- @property
422
+ @_builtins.property
424
423
  @pulumi.getter
425
424
  def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]]]:
426
425
  """
@@ -451,7 +450,7 @@ class WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs:
451
450
  """
452
451
  pulumi.set(__self__, "remaining_entities_rule_rollup", remaining_entities_rule_rollup)
453
452
 
454
- @property
453
+ @_builtins.property
455
454
  @pulumi.getter(name="remainingEntitiesRuleRollup")
456
455
  def remaining_entities_rule_rollup(self) -> pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs']:
457
456
  """
@@ -466,19 +465,19 @@ class WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs:
466
465
 
467
466
  if not MYPY:
468
467
  class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgsDict(TypedDict):
469
- group_by: pulumi.Input[builtins.str]
468
+ group_by: pulumi.Input[_builtins.str]
470
469
  """
471
470
  The grouping to be applied to the remaining entities.
472
471
  """
473
- strategy: pulumi.Input[builtins.str]
472
+ strategy: pulumi.Input[_builtins.str]
474
473
  """
475
474
  The rollup strategy that is applied to a group of entities.
476
475
  """
477
- threshold_type: NotRequired[pulumi.Input[builtins.str]]
476
+ threshold_type: NotRequired[pulumi.Input[_builtins.str]]
478
477
  """
479
478
  Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
480
479
  """
481
- threshold_value: NotRequired[pulumi.Input[builtins.int]]
480
+ threshold_value: NotRequired[pulumi.Input[_builtins.int]]
482
481
  """
483
482
  Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
484
483
  """
@@ -488,15 +487,15 @@ elif False:
488
487
  @pulumi.input_type
489
488
  class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs:
490
489
  def __init__(__self__, *,
491
- group_by: pulumi.Input[builtins.str],
492
- strategy: pulumi.Input[builtins.str],
493
- threshold_type: Optional[pulumi.Input[builtins.str]] = None,
494
- threshold_value: Optional[pulumi.Input[builtins.int]] = None):
490
+ group_by: pulumi.Input[_builtins.str],
491
+ strategy: pulumi.Input[_builtins.str],
492
+ threshold_type: Optional[pulumi.Input[_builtins.str]] = None,
493
+ threshold_value: Optional[pulumi.Input[_builtins.int]] = None):
495
494
  """
496
- :param pulumi.Input[builtins.str] group_by: The grouping to be applied to the remaining entities.
497
- :param pulumi.Input[builtins.str] strategy: The rollup strategy that is applied to a group of entities.
498
- :param pulumi.Input[builtins.str] threshold_type: Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
499
- :param pulumi.Input[builtins.int] threshold_value: Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
495
+ :param pulumi.Input[_builtins.str] group_by: The grouping to be applied to the remaining entities.
496
+ :param pulumi.Input[_builtins.str] strategy: The rollup strategy that is applied to a group of entities.
497
+ :param pulumi.Input[_builtins.str] threshold_type: Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
498
+ :param pulumi.Input[_builtins.int] threshold_value: Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
500
499
  """
501
500
  pulumi.set(__self__, "group_by", group_by)
502
501
  pulumi.set(__self__, "strategy", strategy)
@@ -505,52 +504,52 @@ class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRol
505
504
  if threshold_value is not None:
506
505
  pulumi.set(__self__, "threshold_value", threshold_value)
507
506
 
508
- @property
507
+ @_builtins.property
509
508
  @pulumi.getter(name="groupBy")
510
- def group_by(self) -> pulumi.Input[builtins.str]:
509
+ def group_by(self) -> pulumi.Input[_builtins.str]:
511
510
  """
512
511
  The grouping to be applied to the remaining entities.
513
512
  """
514
513
  return pulumi.get(self, "group_by")
515
514
 
516
515
  @group_by.setter
517
- def group_by(self, value: pulumi.Input[builtins.str]):
516
+ def group_by(self, value: pulumi.Input[_builtins.str]):
518
517
  pulumi.set(self, "group_by", value)
519
518
 
520
- @property
519
+ @_builtins.property
521
520
  @pulumi.getter
522
- def strategy(self) -> pulumi.Input[builtins.str]:
521
+ def strategy(self) -> pulumi.Input[_builtins.str]:
523
522
  """
524
523
  The rollup strategy that is applied to a group of entities.
525
524
  """
526
525
  return pulumi.get(self, "strategy")
527
526
 
528
527
  @strategy.setter
529
- def strategy(self, value: pulumi.Input[builtins.str]):
528
+ def strategy(self, value: pulumi.Input[_builtins.str]):
530
529
  pulumi.set(self, "strategy", value)
531
530
 
532
- @property
531
+ @_builtins.property
533
532
  @pulumi.getter(name="thresholdType")
534
- def threshold_type(self) -> Optional[pulumi.Input[builtins.str]]:
533
+ def threshold_type(self) -> Optional[pulumi.Input[_builtins.str]]:
535
534
  """
536
535
  Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
537
536
  """
538
537
  return pulumi.get(self, "threshold_type")
539
538
 
540
539
  @threshold_type.setter
541
- def threshold_type(self, value: Optional[pulumi.Input[builtins.str]]):
540
+ def threshold_type(self, value: Optional[pulumi.Input[_builtins.str]]):
542
541
  pulumi.set(self, "threshold_type", value)
543
542
 
544
- @property
543
+ @_builtins.property
545
544
  @pulumi.getter(name="thresholdValue")
546
- def threshold_value(self) -> Optional[pulumi.Input[builtins.int]]:
545
+ def threshold_value(self) -> Optional[pulumi.Input[_builtins.int]]:
547
546
  """
548
547
  Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
549
548
  """
550
549
  return pulumi.get(self, "threshold_value")
551
550
 
552
551
  @threshold_value.setter
553
- def threshold_value(self, value: Optional[pulumi.Input[builtins.int]]):
552
+ def threshold_value(self, value: Optional[pulumi.Input[_builtins.int]]):
554
553
  pulumi.set(self, "threshold_value", value)
555
554
 
556
555
 
@@ -560,7 +559,7 @@ if not MYPY:
560
559
  """
561
560
  The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
562
561
  """
563
- entity_guids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
562
+ entity_guids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
564
563
  """
565
564
  A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
566
565
  """
@@ -575,11 +574,11 @@ elif False:
575
574
  class WorkloadStatusConfigAutomaticRuleArgs:
576
575
  def __init__(__self__, *,
577
576
  rollup: pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs'],
578
- entity_guids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
577
+ entity_guids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
579
578
  nrql_queries: Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleNrqlQueryArgs']]]] = None):
580
579
  """
581
580
  :param pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs'] rollup: The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
582
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] entity_guids: A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
581
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] entity_guids: A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
583
582
  :param pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleNrqlQueryArgs']]] nrql_queries: A list of entity search queries used to retrieve the entities that compose the rule. See Nested nrql_query blocks below for details. At least one of `entity_guids` or `nrql_query` must be defined.
584
583
  """
585
584
  pulumi.set(__self__, "rollup", rollup)
@@ -588,7 +587,7 @@ class WorkloadStatusConfigAutomaticRuleArgs:
588
587
  if nrql_queries is not None:
589
588
  pulumi.set(__self__, "nrql_queries", nrql_queries)
590
589
 
591
- @property
590
+ @_builtins.property
592
591
  @pulumi.getter
593
592
  def rollup(self) -> pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs']:
594
593
  """
@@ -600,19 +599,19 @@ class WorkloadStatusConfigAutomaticRuleArgs:
600
599
  def rollup(self, value: pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs']):
601
600
  pulumi.set(self, "rollup", value)
602
601
 
603
- @property
602
+ @_builtins.property
604
603
  @pulumi.getter(name="entityGuids")
605
- def entity_guids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
604
+ def entity_guids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
606
605
  """
607
606
  A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
608
607
  """
609
608
  return pulumi.get(self, "entity_guids")
610
609
 
611
610
  @entity_guids.setter
612
- def entity_guids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
611
+ def entity_guids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
613
612
  pulumi.set(self, "entity_guids", value)
614
613
 
615
- @property
614
+ @_builtins.property
616
615
  @pulumi.getter(name="nrqlQueries")
617
616
  def nrql_queries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleNrqlQueryArgs']]]]:
618
617
  """
@@ -627,7 +626,7 @@ class WorkloadStatusConfigAutomaticRuleArgs:
627
626
 
628
627
  if not MYPY:
629
628
  class WorkloadStatusConfigAutomaticRuleNrqlQueryArgsDict(TypedDict):
630
- query: pulumi.Input[builtins.str]
629
+ query: pulumi.Input[_builtins.str]
631
630
  """
632
631
  The entity search query that is used to perform the search of a group of entities.
633
632
  """
@@ -637,36 +636,36 @@ elif False:
637
636
  @pulumi.input_type
638
637
  class WorkloadStatusConfigAutomaticRuleNrqlQueryArgs:
639
638
  def __init__(__self__, *,
640
- query: pulumi.Input[builtins.str]):
639
+ query: pulumi.Input[_builtins.str]):
641
640
  """
642
- :param pulumi.Input[builtins.str] query: The entity search query that is used to perform the search of a group of entities.
641
+ :param pulumi.Input[_builtins.str] query: The entity search query that is used to perform the search of a group of entities.
643
642
  """
644
643
  pulumi.set(__self__, "query", query)
645
644
 
646
- @property
645
+ @_builtins.property
647
646
  @pulumi.getter
648
- def query(self) -> pulumi.Input[builtins.str]:
647
+ def query(self) -> pulumi.Input[_builtins.str]:
649
648
  """
650
649
  The entity search query that is used to perform the search of a group of entities.
651
650
  """
652
651
  return pulumi.get(self, "query")
653
652
 
654
653
  @query.setter
655
- def query(self, value: pulumi.Input[builtins.str]):
654
+ def query(self, value: pulumi.Input[_builtins.str]):
656
655
  pulumi.set(self, "query", value)
657
656
 
658
657
 
659
658
  if not MYPY:
660
659
  class WorkloadStatusConfigAutomaticRuleRollupArgsDict(TypedDict):
661
- strategy: pulumi.Input[builtins.str]
660
+ strategy: pulumi.Input[_builtins.str]
662
661
  """
663
662
  The rollup strategy that is applied to a group of entities.
664
663
  """
665
- threshold_type: NotRequired[pulumi.Input[builtins.str]]
664
+ threshold_type: NotRequired[pulumi.Input[_builtins.str]]
666
665
  """
667
666
  Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
668
667
  """
669
- threshold_value: NotRequired[pulumi.Input[builtins.int]]
668
+ threshold_value: NotRequired[pulumi.Input[_builtins.int]]
670
669
  """
671
670
  Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
672
671
  """
@@ -676,13 +675,13 @@ elif False:
676
675
  @pulumi.input_type
677
676
  class WorkloadStatusConfigAutomaticRuleRollupArgs:
678
677
  def __init__(__self__, *,
679
- strategy: pulumi.Input[builtins.str],
680
- threshold_type: Optional[pulumi.Input[builtins.str]] = None,
681
- threshold_value: Optional[pulumi.Input[builtins.int]] = None):
678
+ strategy: pulumi.Input[_builtins.str],
679
+ threshold_type: Optional[pulumi.Input[_builtins.str]] = None,
680
+ threshold_value: Optional[pulumi.Input[_builtins.int]] = None):
682
681
  """
683
- :param pulumi.Input[builtins.str] strategy: The rollup strategy that is applied to a group of entities.
684
- :param pulumi.Input[builtins.str] threshold_type: Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
685
- :param pulumi.Input[builtins.int] threshold_value: Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
682
+ :param pulumi.Input[_builtins.str] strategy: The rollup strategy that is applied to a group of entities.
683
+ :param pulumi.Input[_builtins.str] threshold_type: Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
684
+ :param pulumi.Input[_builtins.int] threshold_value: Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
686
685
  """
687
686
  pulumi.set(__self__, "strategy", strategy)
688
687
  if threshold_type is not None:
@@ -690,58 +689,58 @@ class WorkloadStatusConfigAutomaticRuleRollupArgs:
690
689
  if threshold_value is not None:
691
690
  pulumi.set(__self__, "threshold_value", threshold_value)
692
691
 
693
- @property
692
+ @_builtins.property
694
693
  @pulumi.getter
695
- def strategy(self) -> pulumi.Input[builtins.str]:
694
+ def strategy(self) -> pulumi.Input[_builtins.str]:
696
695
  """
697
696
  The rollup strategy that is applied to a group of entities.
698
697
  """
699
698
  return pulumi.get(self, "strategy")
700
699
 
701
700
  @strategy.setter
702
- def strategy(self, value: pulumi.Input[builtins.str]):
701
+ def strategy(self, value: pulumi.Input[_builtins.str]):
703
702
  pulumi.set(self, "strategy", value)
704
703
 
705
- @property
704
+ @_builtins.property
706
705
  @pulumi.getter(name="thresholdType")
707
- def threshold_type(self) -> Optional[pulumi.Input[builtins.str]]:
706
+ def threshold_type(self) -> Optional[pulumi.Input[_builtins.str]]:
708
707
  """
709
708
  Type of threshold defined for the rule. This is an optional field that only applies when strategy is WORST_STATUS_WINS. Use a threshold to roll up the worst status only after a certain amount of entities are not operational.
710
709
  """
711
710
  return pulumi.get(self, "threshold_type")
712
711
 
713
712
  @threshold_type.setter
714
- def threshold_type(self, value: Optional[pulumi.Input[builtins.str]]):
713
+ def threshold_type(self, value: Optional[pulumi.Input[_builtins.str]]):
715
714
  pulumi.set(self, "threshold_type", value)
716
715
 
717
- @property
716
+ @_builtins.property
718
717
  @pulumi.getter(name="thresholdValue")
719
- def threshold_value(self) -> Optional[pulumi.Input[builtins.int]]:
718
+ def threshold_value(self) -> Optional[pulumi.Input[_builtins.int]]:
720
719
  """
721
720
  Threshold value defined for the rule. This optional field is used in combination with thresholdType. If the threshold type is null, the threshold value will be ignored.
722
721
  """
723
722
  return pulumi.get(self, "threshold_value")
724
723
 
725
724
  @threshold_value.setter
726
- def threshold_value(self, value: Optional[pulumi.Input[builtins.int]]):
725
+ def threshold_value(self, value: Optional[pulumi.Input[_builtins.int]]):
727
726
  pulumi.set(self, "threshold_value", value)
728
727
 
729
728
 
730
729
  if not MYPY:
731
730
  class WorkloadStatusConfigStaticArgsDict(TypedDict):
732
- enabled: pulumi.Input[builtins.bool]
731
+ enabled: pulumi.Input[_builtins.bool]
733
732
  """
734
733
  Whether the static status configuration is enabled or not.
735
734
  """
736
- status: pulumi.Input[builtins.str]
735
+ status: pulumi.Input[_builtins.str]
737
736
  """
738
737
  The status of the workload.
739
738
  """
740
- description: NotRequired[pulumi.Input[builtins.str]]
739
+ description: NotRequired[pulumi.Input[_builtins.str]]
741
740
  """
742
741
  Relevant information about the workload.
743
742
  """
744
- summary: NotRequired[pulumi.Input[builtins.str]]
743
+ summary: NotRequired[pulumi.Input[_builtins.str]]
745
744
  """
746
745
  A short description of the status of the workload.
747
746
  """
@@ -751,15 +750,15 @@ elif False:
751
750
  @pulumi.input_type
752
751
  class WorkloadStatusConfigStaticArgs:
753
752
  def __init__(__self__, *,
754
- enabled: pulumi.Input[builtins.bool],
755
- status: pulumi.Input[builtins.str],
756
- description: Optional[pulumi.Input[builtins.str]] = None,
757
- summary: Optional[pulumi.Input[builtins.str]] = None):
753
+ enabled: pulumi.Input[_builtins.bool],
754
+ status: pulumi.Input[_builtins.str],
755
+ description: Optional[pulumi.Input[_builtins.str]] = None,
756
+ summary: Optional[pulumi.Input[_builtins.str]] = None):
758
757
  """
759
- :param pulumi.Input[builtins.bool] enabled: Whether the static status configuration is enabled or not.
760
- :param pulumi.Input[builtins.str] status: The status of the workload.
761
- :param pulumi.Input[builtins.str] description: Relevant information about the workload.
762
- :param pulumi.Input[builtins.str] summary: A short description of the status of the workload.
758
+ :param pulumi.Input[_builtins.bool] enabled: Whether the static status configuration is enabled or not.
759
+ :param pulumi.Input[_builtins.str] status: The status of the workload.
760
+ :param pulumi.Input[_builtins.str] description: Relevant information about the workload.
761
+ :param pulumi.Input[_builtins.str] summary: A short description of the status of the workload.
763
762
  """
764
763
  pulumi.set(__self__, "enabled", enabled)
765
764
  pulumi.set(__self__, "status", status)
@@ -768,52 +767,52 @@ class WorkloadStatusConfigStaticArgs:
768
767
  if summary is not None:
769
768
  pulumi.set(__self__, "summary", summary)
770
769
 
771
- @property
770
+ @_builtins.property
772
771
  @pulumi.getter
773
- def enabled(self) -> pulumi.Input[builtins.bool]:
772
+ def enabled(self) -> pulumi.Input[_builtins.bool]:
774
773
  """
775
774
  Whether the static status configuration is enabled or not.
776
775
  """
777
776
  return pulumi.get(self, "enabled")
778
777
 
779
778
  @enabled.setter
780
- def enabled(self, value: pulumi.Input[builtins.bool]):
779
+ def enabled(self, value: pulumi.Input[_builtins.bool]):
781
780
  pulumi.set(self, "enabled", value)
782
781
 
783
- @property
782
+ @_builtins.property
784
783
  @pulumi.getter
785
- def status(self) -> pulumi.Input[builtins.str]:
784
+ def status(self) -> pulumi.Input[_builtins.str]:
786
785
  """
787
786
  The status of the workload.
788
787
  """
789
788
  return pulumi.get(self, "status")
790
789
 
791
790
  @status.setter
792
- def status(self, value: pulumi.Input[builtins.str]):
791
+ def status(self, value: pulumi.Input[_builtins.str]):
793
792
  pulumi.set(self, "status", value)
794
793
 
795
- @property
794
+ @_builtins.property
796
795
  @pulumi.getter
797
- def description(self) -> Optional[pulumi.Input[builtins.str]]:
796
+ def description(self) -> Optional[pulumi.Input[_builtins.str]]:
798
797
  """
799
798
  Relevant information about the workload.
800
799
  """
801
800
  return pulumi.get(self, "description")
802
801
 
803
802
  @description.setter
804
- def description(self, value: Optional[pulumi.Input[builtins.str]]):
803
+ def description(self, value: Optional[pulumi.Input[_builtins.str]]):
805
804
  pulumi.set(self, "description", value)
806
805
 
807
- @property
806
+ @_builtins.property
808
807
  @pulumi.getter
809
- def summary(self) -> Optional[pulumi.Input[builtins.str]]:
808
+ def summary(self) -> Optional[pulumi.Input[_builtins.str]]:
810
809
  """
811
810
  A short description of the status of the workload.
812
811
  """
813
812
  return pulumi.get(self, "summary")
814
813
 
815
814
  @summary.setter
816
- def summary(self, value: Optional[pulumi.Input[builtins.str]]):
815
+ def summary(self, value: Optional[pulumi.Input[_builtins.str]]):
817
816
  pulumi.set(self, "summary", value)
818
817
 
819
818