pulumi-newrelic 5.45.0a1743574084__py3-none-any.whl → 5.45.0a1744183332__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 -0
  2. pulumi_newrelic/_inputs.py +2961 -2960
  3. pulumi_newrelic/account_management.py +29 -28
  4. pulumi_newrelic/alert_channel.py +43 -42
  5. pulumi_newrelic/alert_condition.py +176 -175
  6. pulumi_newrelic/alert_muting_rule.py +71 -70
  7. pulumi_newrelic/alert_policy.py +57 -56
  8. pulumi_newrelic/alert_policy_channel.py +43 -42
  9. pulumi_newrelic/api_access_key.py +92 -91
  10. pulumi_newrelic/browser_application.py +92 -91
  11. pulumi_newrelic/cloud/__init__.py +1 -0
  12. pulumi_newrelic/cloud/_inputs.py +1765 -1764
  13. pulumi_newrelic/cloud/aws_govcloud_integrations.py +29 -28
  14. pulumi_newrelic/cloud/aws_govcloud_link_account.py +57 -56
  15. pulumi_newrelic/cloud/aws_integrations.py +29 -28
  16. pulumi_newrelic/cloud/aws_link_account.py +57 -56
  17. pulumi_newrelic/cloud/azure_integrations.py +29 -28
  18. pulumi_newrelic/cloud/azure_link_account.py +85 -84
  19. pulumi_newrelic/cloud/gcp_integrations.py +29 -28
  20. pulumi_newrelic/cloud/gcp_link_account.py +45 -44
  21. pulumi_newrelic/cloud/outputs.py +1057 -1056
  22. pulumi_newrelic/config/__init__.py +1 -0
  23. pulumi_newrelic/config/__init__.pyi +1 -0
  24. pulumi_newrelic/config/vars.py +1 -0
  25. pulumi_newrelic/data_partition_rule.py +92 -91
  26. pulumi_newrelic/entity_tags.py +15 -14
  27. pulumi_newrelic/events_to_metrics_rule.py +78 -77
  28. pulumi_newrelic/get_account.py +17 -16
  29. pulumi_newrelic/get_alert_channel.py +14 -13
  30. pulumi_newrelic/get_alert_policy.py +19 -18
  31. pulumi_newrelic/get_application.py +9 -8
  32. pulumi_newrelic/get_authentication_domain.py +7 -6
  33. pulumi_newrelic/get_cloud_account.py +17 -16
  34. pulumi_newrelic/get_entity.py +40 -39
  35. pulumi_newrelic/get_group.py +13 -12
  36. pulumi_newrelic/get_key_transaction.py +19 -18
  37. pulumi_newrelic/get_notification_destination.py +20 -19
  38. pulumi_newrelic/get_obfuscation_expression.py +12 -11
  39. pulumi_newrelic/get_service_level_alert_helper.py +41 -40
  40. pulumi_newrelic/get_test_grok_pattern.py +17 -16
  41. pulumi_newrelic/get_user.py +17 -16
  42. pulumi_newrelic/group.py +43 -42
  43. pulumi_newrelic/infra_alert_condition.py +204 -203
  44. pulumi_newrelic/insights/__init__.py +1 -0
  45. pulumi_newrelic/insights/_inputs.py +26 -25
  46. pulumi_newrelic/insights/event.py +1 -0
  47. pulumi_newrelic/insights/outputs.py +16 -15
  48. pulumi_newrelic/key_transaction.py +85 -84
  49. pulumi_newrelic/log_parsing_rule.py +120 -119
  50. pulumi_newrelic/monitor_downtime.py +113 -112
  51. pulumi_newrelic/notification_channel.py +92 -91
  52. pulumi_newrelic/notification_destination.py +78 -77
  53. pulumi_newrelic/nrql_alert_condition.py +330 -329
  54. pulumi_newrelic/nrql_drop_rule.py +64 -63
  55. pulumi_newrelic/obfuscation_expression.py +57 -56
  56. pulumi_newrelic/obfuscation_rule.py +71 -70
  57. pulumi_newrelic/one_dashboard.py +71 -70
  58. pulumi_newrelic/one_dashboard_json.py +50 -49
  59. pulumi_newrelic/one_dashboard_raw.py +71 -70
  60. pulumi_newrelic/outputs.py +1831 -1830
  61. pulumi_newrelic/plugins/__init__.py +1 -0
  62. pulumi_newrelic/plugins/_inputs.py +126 -125
  63. pulumi_newrelic/plugins/application_settings.py +132 -131
  64. pulumi_newrelic/plugins/outputs.py +76 -75
  65. pulumi_newrelic/plugins/workload.py +99 -98
  66. pulumi_newrelic/provider.py +80 -79
  67. pulumi_newrelic/pulumi-plugin.json +1 -1
  68. pulumi_newrelic/service_level.py +57 -56
  69. pulumi_newrelic/synthetics/__init__.py +1 -0
  70. pulumi_newrelic/synthetics/_inputs.py +106 -105
  71. pulumi_newrelic/synthetics/alert_condition.py +78 -77
  72. pulumi_newrelic/synthetics/broken_links_monitor.py +151 -150
  73. pulumi_newrelic/synthetics/cert_check_monitor.py +158 -157
  74. pulumi_newrelic/synthetics/get_private_location.py +17 -16
  75. pulumi_newrelic/synthetics/get_secure_credential.py +14 -13
  76. pulumi_newrelic/synthetics/monitor.py +298 -297
  77. pulumi_newrelic/synthetics/multi_location_alert_condition.py +92 -91
  78. pulumi_newrelic/synthetics/outputs.py +64 -63
  79. pulumi_newrelic/synthetics/private_location.py +85 -84
  80. pulumi_newrelic/synthetics/script_monitor.py +235 -234
  81. pulumi_newrelic/synthetics/secure_credential.py +71 -70
  82. pulumi_newrelic/synthetics/step_monitor.py +165 -164
  83. pulumi_newrelic/user.py +57 -56
  84. pulumi_newrelic/workflow.py +106 -105
  85. {pulumi_newrelic-5.45.0a1743574084.dist-info → pulumi_newrelic-5.45.0a1744183332.dist-info}/METADATA +1 -1
  86. pulumi_newrelic-5.45.0a1744183332.dist-info/RECORD +90 -0
  87. pulumi_newrelic-5.45.0a1743574084.dist-info/RECORD +0 -90
  88. {pulumi_newrelic-5.45.0a1743574084.dist-info → pulumi_newrelic-5.45.0a1744183332.dist-info}/WHEEL +0 -0
  89. {pulumi_newrelic-5.45.0a1743574084.dist-info → pulumi_newrelic-5.45.0a1744183332.dist-info}/top_level.txt +0 -0
pulumi_newrelic/plugins/_inputs.py CHANGED
@@ -2,6 +2,7 @@
2
2
  # *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
3
3
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
4
4
 
5
+ import builtins
5
6
  import copy
6
7
  import warnings
7
8
  import sys
@@ -45,19 +46,19 @@ MYPY = False
45
46
 
46
47
  if not MYPY:
47
48
  class ApplicationSettingsErrorCollectorArgsDict(TypedDict):
48
- expected_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
49
+ expected_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
49
50
  """
50
51
  A list of expected error classes.
51
52
  """
52
- expected_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
53
+ expected_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
53
54
  """
54
55
  A list of expected error codes(any status code between 100-900).
55
56
  """
56
- ignored_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
57
+ ignored_error_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
57
58
  """
58
59
  A list of ignored error classes.
59
60
  """
60
- ignored_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
61
+ ignored_error_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
61
62
  """
62
63
  A list of ignored error codes(any status code between 100-900).
63
64
  """
@@ -67,15 +68,15 @@ elif False:
67
68
  @pulumi.input_type
68
69
  class ApplicationSettingsErrorCollectorArgs:
69
70
  def __init__(__self__, *,
70
- expected_error_classes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
71
- expected_error_codes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
72
- ignored_error_classes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
73
- ignored_error_codes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
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):
74
75
  """
75
- :param pulumi.Input[Sequence[pulumi.Input[str]]] expected_error_classes: A list of expected error classes.
76
- :param pulumi.Input[Sequence[pulumi.Input[str]]] expected_error_codes: A list of expected error codes(any status code between 100-900).
77
- :param pulumi.Input[Sequence[pulumi.Input[str]]] ignored_error_classes: A list of ignored error classes.
78
- :param pulumi.Input[Sequence[pulumi.Input[str]]] ignored_error_codes: A list of ignored error codes(any status code between 100-900).
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).
79
80
  """
80
81
  if expected_error_classes is not None:
81
82
  pulumi.set(__self__, "expected_error_classes", expected_error_classes)
@@ -88,50 +89,50 @@ class ApplicationSettingsErrorCollectorArgs:
88
89
 
89
90
  @property
90
91
  @pulumi.getter(name="expectedErrorClasses")
91
- def expected_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
92
+ def expected_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
92
93
  """
93
94
  A list of expected error classes.
94
95
  """
95
96
  return pulumi.get(self, "expected_error_classes")
96
97
 
97
98
  @expected_error_classes.setter
98
- def expected_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
99
+ def expected_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
99
100
  pulumi.set(self, "expected_error_classes", value)
100
101
 
101
102
  @property
102
103
  @pulumi.getter(name="expectedErrorCodes")
103
- def expected_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
104
+ def expected_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
104
105
  """
105
106
  A list of expected error codes(any status code between 100-900).
106
107
  """
107
108
  return pulumi.get(self, "expected_error_codes")
108
109
 
109
110
  @expected_error_codes.setter
110
- def expected_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
111
+ def expected_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
111
112
  pulumi.set(self, "expected_error_codes", value)
112
113
 
113
114
  @property
114
115
  @pulumi.getter(name="ignoredErrorClasses")
115
- def ignored_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
116
+ def ignored_error_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
116
117
  """
117
118
  A list of ignored error classes.
118
119
  """
119
120
  return pulumi.get(self, "ignored_error_classes")
120
121
 
121
122
  @ignored_error_classes.setter
122
- def ignored_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
123
+ def ignored_error_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
123
124
  pulumi.set(self, "ignored_error_classes", value)
124
125
 
125
126
  @property
126
127
  @pulumi.getter(name="ignoredErrorCodes")
127
- def ignored_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
128
+ def ignored_error_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
128
129
  """
129
130
  A list of ignored error codes(any status code between 100-900).
130
131
  """
131
132
  return pulumi.get(self, "ignored_error_codes")
132
133
 
133
134
  @ignored_error_codes.setter
134
- def ignored_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
135
+ def ignored_error_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
135
136
  pulumi.set(self, "ignored_error_codes", value)
136
137
 
137
138
 
@@ -145,15 +146,15 @@ if not MYPY:
145
146
  """
146
147
  Configuration block for SQL logging. Including this block enables SQL logging. The following arguments are supported:
147
148
  """
148
- stack_trace_threshold_value: NotRequired[pulumi.Input[float]]
149
+ stack_trace_threshold_value: NotRequired[pulumi.Input[builtins.float]]
149
150
  """
150
151
  The response time threshold for collecting stack traces.
151
152
  """
152
- transaction_threshold_type: NotRequired[pulumi.Input[str]]
153
+ transaction_threshold_type: NotRequired[pulumi.Input[builtins.str]]
153
154
  """
154
155
  The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
155
156
  """
156
- transaction_threshold_value: NotRequired[pulumi.Input[float]]
157
+ transaction_threshold_value: NotRequired[pulumi.Input[builtins.float]]
157
158
  """
158
159
  The threshold value for transactions(in seconds).
159
160
  """
@@ -165,15 +166,15 @@ class ApplicationSettingsTransactionTracerArgs:
165
166
  def __init__(__self__, *,
166
167
  explain_query_plans: Optional[pulumi.Input[Sequence[pulumi.Input['ApplicationSettingsTransactionTracerExplainQueryPlanArgs']]]] = None,
167
168
  sql: Optional[pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs']] = None,
168
- stack_trace_threshold_value: Optional[pulumi.Input[float]] = None,
169
- transaction_threshold_type: Optional[pulumi.Input[str]] = None,
170
- transaction_threshold_value: Optional[pulumi.Input[float]] = 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):
171
172
  """
172
173
  :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:
173
174
  :param pulumi.Input['ApplicationSettingsTransactionTracerSqlArgs'] sql: Configuration block for SQL logging. Including this block enables SQL logging. The following arguments are supported:
174
- :param pulumi.Input[float] stack_trace_threshold_value: The response time threshold for collecting stack traces.
175
- :param pulumi.Input[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[float] transaction_threshold_value: The threshold value for transactions(in seconds).
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).
177
178
  """
178
179
  if explain_query_plans is not None:
179
180
  pulumi.set(__self__, "explain_query_plans", explain_query_plans)
@@ -212,48 +213,48 @@ class ApplicationSettingsTransactionTracerArgs:
212
213
 
213
214
  @property
214
215
  @pulumi.getter(name="stackTraceThresholdValue")
215
- def stack_trace_threshold_value(self) -> Optional[pulumi.Input[float]]:
216
+ def stack_trace_threshold_value(self) -> Optional[pulumi.Input[builtins.float]]:
216
217
  """
217
218
  The response time threshold for collecting stack traces.
218
219
  """
219
220
  return pulumi.get(self, "stack_trace_threshold_value")
220
221
 
221
222
  @stack_trace_threshold_value.setter
222
- def stack_trace_threshold_value(self, value: Optional[pulumi.Input[float]]):
223
+ def stack_trace_threshold_value(self, value: Optional[pulumi.Input[builtins.float]]):
223
224
  pulumi.set(self, "stack_trace_threshold_value", value)
224
225
 
225
226
  @property
226
227
  @pulumi.getter(name="transactionThresholdType")
227
- def transaction_threshold_type(self) -> Optional[pulumi.Input[str]]:
228
+ def transaction_threshold_type(self) -> Optional[pulumi.Input[builtins.str]]:
228
229
  """
229
230
  The type of threshold for transactions. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
230
231
  """
231
232
  return pulumi.get(self, "transaction_threshold_type")
232
233
 
233
234
  @transaction_threshold_type.setter
234
- def transaction_threshold_type(self, value: Optional[pulumi.Input[str]]):
235
+ def transaction_threshold_type(self, value: Optional[pulumi.Input[builtins.str]]):
235
236
  pulumi.set(self, "transaction_threshold_type", value)
236
237
 
237
238
  @property
238
239
  @pulumi.getter(name="transactionThresholdValue")
239
- def transaction_threshold_value(self) -> Optional[pulumi.Input[float]]:
240
+ def transaction_threshold_value(self) -> Optional[pulumi.Input[builtins.float]]:
240
241
  """
241
242
  The threshold value for transactions(in seconds).
242
243
  """
243
244
  return pulumi.get(self, "transaction_threshold_value")
244
245
 
245
246
  @transaction_threshold_value.setter
246
- def transaction_threshold_value(self, value: Optional[pulumi.Input[float]]):
247
+ def transaction_threshold_value(self, value: Optional[pulumi.Input[builtins.float]]):
247
248
  pulumi.set(self, "transaction_threshold_value", value)
248
249
 
249
250
 
250
251
  if not MYPY:
251
252
  class ApplicationSettingsTransactionTracerExplainQueryPlanArgsDict(TypedDict):
252
- query_plan_threshold_type: NotRequired[pulumi.Input[str]]
253
+ query_plan_threshold_type: NotRequired[pulumi.Input[builtins.str]]
253
254
  """
254
255
  The type of threshold for query plans. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
255
256
  """
256
- query_plan_threshold_value: NotRequired[pulumi.Input[float]]
257
+ query_plan_threshold_value: NotRequired[pulumi.Input[builtins.float]]
257
258
  """
258
259
  The response time threshold for capturing query plans(in seconds).
259
260
  """
@@ -263,11 +264,11 @@ elif False:
263
264
  @pulumi.input_type
264
265
  class ApplicationSettingsTransactionTracerExplainQueryPlanArgs:
265
266
  def __init__(__self__, *,
266
- query_plan_threshold_type: Optional[pulumi.Input[str]] = None,
267
- query_plan_threshold_value: Optional[pulumi.Input[float]] = None):
267
+ query_plan_threshold_type: Optional[pulumi.Input[builtins.str]] = None,
268
+ query_plan_threshold_value: Optional[pulumi.Input[builtins.float]] = None):
268
269
  """
269
- :param pulumi.Input[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[float] query_plan_threshold_value: The response time threshold for capturing query plans(in seconds).
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).
271
272
  """
272
273
  if query_plan_threshold_type is not None:
273
274
  pulumi.set(__self__, "query_plan_threshold_type", query_plan_threshold_type)
@@ -276,32 +277,32 @@ class ApplicationSettingsTransactionTracerExplainQueryPlanArgs:
276
277
 
277
278
  @property
278
279
  @pulumi.getter(name="queryPlanThresholdType")
279
- def query_plan_threshold_type(self) -> Optional[pulumi.Input[str]]:
280
+ def query_plan_threshold_type(self) -> Optional[pulumi.Input[builtins.str]]:
280
281
  """
281
282
  The type of threshold for query plans. Valid values are `VALUE`,`APDEX_F`(4 times your apdex target)
282
283
  """
283
284
  return pulumi.get(self, "query_plan_threshold_type")
284
285
 
285
286
  @query_plan_threshold_type.setter
286
- def query_plan_threshold_type(self, value: Optional[pulumi.Input[str]]):
287
+ def query_plan_threshold_type(self, value: Optional[pulumi.Input[builtins.str]]):
287
288
  pulumi.set(self, "query_plan_threshold_type", value)
288
289
 
289
290
  @property
290
291
  @pulumi.getter(name="queryPlanThresholdValue")
291
- def query_plan_threshold_value(self) -> Optional[pulumi.Input[float]]:
292
+ def query_plan_threshold_value(self) -> Optional[pulumi.Input[builtins.float]]:
292
293
  """
293
294
  The response time threshold for capturing query plans(in seconds).
294
295
  """
295
296
  return pulumi.get(self, "query_plan_threshold_value")
296
297
 
297
298
  @query_plan_threshold_value.setter
298
- def query_plan_threshold_value(self, value: Optional[pulumi.Input[float]]):
299
+ def query_plan_threshold_value(self, value: Optional[pulumi.Input[builtins.float]]):
299
300
  pulumi.set(self, "query_plan_threshold_value", value)
300
301
 
301
302
 
302
303
  if not MYPY:
303
304
  class ApplicationSettingsTransactionTracerSqlArgsDict(TypedDict):
304
- record_sql: pulumi.Input[str]
305
+ record_sql: pulumi.Input[builtins.str]
305
306
  """
306
307
  The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
307
308
  """
@@ -311,28 +312,28 @@ elif False:
311
312
  @pulumi.input_type
312
313
  class ApplicationSettingsTransactionTracerSqlArgs:
313
314
  def __init__(__self__, *,
314
- record_sql: pulumi.Input[str]):
315
+ record_sql: pulumi.Input[builtins.str]):
315
316
  """
316
- :param pulumi.Input[str] record_sql: The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
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).
317
318
  """
318
319
  pulumi.set(__self__, "record_sql", record_sql)
319
320
 
320
321
  @property
321
322
  @pulumi.getter(name="recordSql")
322
- def record_sql(self) -> pulumi.Input[str]:
323
+ def record_sql(self) -> pulumi.Input[builtins.str]:
323
324
  """
324
325
  The level of SQL recording. Valid values ar `OBFUSCATED`,`OFF`,`RAW` (Mandatory attribute when `sql` block is provided).
325
326
  """
326
327
  return pulumi.get(self, "record_sql")
327
328
 
328
329
  @record_sql.setter
329
- def record_sql(self, value: pulumi.Input[str]):
330
+ def record_sql(self, value: pulumi.Input[builtins.str]):
330
331
  pulumi.set(self, "record_sql", value)
331
332
 
332
333
 
333
334
  if not MYPY:
334
335
  class WorkloadEntitySearchQueryArgsDict(TypedDict):
335
- query: pulumi.Input[str]
336
+ query: pulumi.Input[builtins.str]
336
337
  """
337
338
  A valid entity search query; empty, and null values are considered invalid.
338
339
  """
@@ -342,28 +343,28 @@ elif False:
342
343
  @pulumi.input_type
343
344
  class WorkloadEntitySearchQueryArgs:
344
345
  def __init__(__self__, *,
345
- query: pulumi.Input[str]):
346
+ query: pulumi.Input[builtins.str]):
346
347
  """
347
- :param pulumi.Input[str] query: A valid entity search query; empty, and null values are considered invalid.
348
+ :param pulumi.Input[builtins.str] query: A valid entity search query; empty, and null values are considered invalid.
348
349
  """
349
350
  pulumi.set(__self__, "query", query)
350
351
 
351
352
  @property
352
353
  @pulumi.getter
353
- def query(self) -> pulumi.Input[str]:
354
+ def query(self) -> pulumi.Input[builtins.str]:
354
355
  """
355
356
  A valid entity search query; empty, and null values are considered invalid.
356
357
  """
357
358
  return pulumi.get(self, "query")
358
359
 
359
360
  @query.setter
360
- def query(self, value: pulumi.Input[str]):
361
+ def query(self, value: pulumi.Input[builtins.str]):
361
362
  pulumi.set(self, "query", value)
362
363
 
363
364
 
364
365
  if not MYPY:
365
366
  class WorkloadStatusConfigAutomaticArgsDict(TypedDict):
366
- enabled: pulumi.Input[bool]
367
+ enabled: pulumi.Input[builtins.bool]
367
368
  """
368
369
  Whether the automatic status configuration is enabled or not.
369
370
  """
@@ -381,11 +382,11 @@ elif False:
381
382
  @pulumi.input_type
382
383
  class WorkloadStatusConfigAutomaticArgs:
383
384
  def __init__(__self__, *,
384
- enabled: pulumi.Input[bool],
385
+ enabled: pulumi.Input[builtins.bool],
385
386
  remaining_entities_rule: Optional[pulumi.Input['WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs']] = None,
386
387
  rules: Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]]] = None):
387
388
  """
388
- :param pulumi.Input[bool] enabled: Whether the automatic status configuration is enabled or not.
389
+ :param pulumi.Input[builtins.bool] enabled: Whether the automatic status configuration is enabled or not.
389
390
  :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.
390
391
  :param pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleArgs']]] rules: A list of rules.
391
392
  """
@@ -397,14 +398,14 @@ class WorkloadStatusConfigAutomaticArgs:
397
398
 
398
399
  @property
399
400
  @pulumi.getter
400
- def enabled(self) -> pulumi.Input[bool]:
401
+ def enabled(self) -> pulumi.Input[builtins.bool]:
401
402
  """
402
403
  Whether the automatic status configuration is enabled or not.
403
404
  """
404
405
  return pulumi.get(self, "enabled")
405
406
 
406
407
  @enabled.setter
407
- def enabled(self, value: pulumi.Input[bool]):
408
+ def enabled(self, value: pulumi.Input[builtins.bool]):
408
409
  pulumi.set(self, "enabled", value)
409
410
 
410
411
  @property
@@ -465,19 +466,19 @@ class WorkloadStatusConfigAutomaticRemainingEntitiesRuleArgs:
465
466
 
466
467
  if not MYPY:
467
468
  class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgsDict(TypedDict):
468
- group_by: pulumi.Input[str]
469
+ group_by: pulumi.Input[builtins.str]
469
470
  """
470
471
  The grouping to be applied to the remaining entities.
471
472
  """
472
- strategy: pulumi.Input[str]
473
+ strategy: pulumi.Input[builtins.str]
473
474
  """
474
475
  The rollup strategy that is applied to a group of entities.
475
476
  """
476
- threshold_type: NotRequired[pulumi.Input[str]]
477
+ threshold_type: NotRequired[pulumi.Input[builtins.str]]
477
478
  """
478
479
  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.
479
480
  """
480
- threshold_value: NotRequired[pulumi.Input[int]]
481
+ threshold_value: NotRequired[pulumi.Input[builtins.int]]
481
482
  """
482
483
  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.
483
484
  """
@@ -487,15 +488,15 @@ elif False:
487
488
  @pulumi.input_type
488
489
  class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRollupArgs:
489
490
  def __init__(__self__, *,
490
- group_by: pulumi.Input[str],
491
- strategy: pulumi.Input[str],
492
- threshold_type: Optional[pulumi.Input[str]] = None,
493
- threshold_value: Optional[pulumi.Input[int]] = None):
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):
494
495
  """
495
- :param pulumi.Input[str] group_by: The grouping to be applied to the remaining entities.
496
- :param pulumi.Input[str] strategy: The rollup strategy that is applied to a group of entities.
497
- :param pulumi.Input[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[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.
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.
499
500
  """
500
501
  pulumi.set(__self__, "group_by", group_by)
501
502
  pulumi.set(__self__, "strategy", strategy)
@@ -506,50 +507,50 @@ class WorkloadStatusConfigAutomaticRemainingEntitiesRuleRemainingEntitiesRuleRol
506
507
 
507
508
  @property
508
509
  @pulumi.getter(name="groupBy")
509
- def group_by(self) -> pulumi.Input[str]:
510
+ def group_by(self) -> pulumi.Input[builtins.str]:
510
511
  """
511
512
  The grouping to be applied to the remaining entities.
512
513
  """
513
514
  return pulumi.get(self, "group_by")
514
515
 
515
516
  @group_by.setter
516
- def group_by(self, value: pulumi.Input[str]):
517
+ def group_by(self, value: pulumi.Input[builtins.str]):
517
518
  pulumi.set(self, "group_by", value)
518
519
 
519
520
  @property
520
521
  @pulumi.getter
521
- def strategy(self) -> pulumi.Input[str]:
522
+ def strategy(self) -> pulumi.Input[builtins.str]:
522
523
  """
523
524
  The rollup strategy that is applied to a group of entities.
524
525
  """
525
526
  return pulumi.get(self, "strategy")
526
527
 
527
528
  @strategy.setter
528
- def strategy(self, value: pulumi.Input[str]):
529
+ def strategy(self, value: pulumi.Input[builtins.str]):
529
530
  pulumi.set(self, "strategy", value)
530
531
 
531
532
  @property
532
533
  @pulumi.getter(name="thresholdType")
533
- def threshold_type(self) -> Optional[pulumi.Input[str]]:
534
+ def threshold_type(self) -> Optional[pulumi.Input[builtins.str]]:
534
535
  """
535
536
  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.
536
537
  """
537
538
  return pulumi.get(self, "threshold_type")
538
539
 
539
540
  @threshold_type.setter
540
- def threshold_type(self, value: Optional[pulumi.Input[str]]):
541
+ def threshold_type(self, value: Optional[pulumi.Input[builtins.str]]):
541
542
  pulumi.set(self, "threshold_type", value)
542
543
 
543
544
  @property
544
545
  @pulumi.getter(name="thresholdValue")
545
- def threshold_value(self) -> Optional[pulumi.Input[int]]:
546
+ def threshold_value(self) -> Optional[pulumi.Input[builtins.int]]:
546
547
  """
547
548
  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.
548
549
  """
549
550
  return pulumi.get(self, "threshold_value")
550
551
 
551
552
  @threshold_value.setter
552
- def threshold_value(self, value: Optional[pulumi.Input[int]]):
553
+ def threshold_value(self, value: Optional[pulumi.Input[builtins.int]]):
553
554
  pulumi.set(self, "threshold_value", value)
554
555
 
555
556
 
@@ -559,7 +560,7 @@ if not MYPY:
559
560
  """
560
561
  The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
561
562
  """
562
- entity_guids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
563
+ entity_guids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
563
564
  """
564
565
  A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
565
566
  """
@@ -574,11 +575,11 @@ elif False:
574
575
  class WorkloadStatusConfigAutomaticRuleArgs:
575
576
  def __init__(__self__, *,
576
577
  rollup: pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs'],
577
- entity_guids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
578
+ entity_guids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
578
579
  nrql_queries: Optional[pulumi.Input[Sequence[pulumi.Input['WorkloadStatusConfigAutomaticRuleNrqlQueryArgs']]]] = None):
579
580
  """
580
581
  :param pulumi.Input['WorkloadStatusConfigAutomaticRuleRollupArgs'] rollup: The input object used to represent a rollup strategy. See Nested rollup blocks below for details.
581
- :param pulumi.Input[Sequence[pulumi.Input[str]]] entity_guids: A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
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.
582
583
  :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.
583
584
  """
584
585
  pulumi.set(__self__, "rollup", rollup)
@@ -601,14 +602,14 @@ class WorkloadStatusConfigAutomaticRuleArgs:
601
602
 
602
603
  @property
603
604
  @pulumi.getter(name="entityGuids")
604
- def entity_guids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
605
+ def entity_guids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
605
606
  """
606
607
  A list of entity GUIDs composing the rule. At least one of `entity_guids` or `nrql_query` must be defined.
607
608
  """
608
609
  return pulumi.get(self, "entity_guids")
609
610
 
610
611
  @entity_guids.setter
611
- def entity_guids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
612
+ def entity_guids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
612
613
  pulumi.set(self, "entity_guids", value)
613
614
 
614
615
  @property
@@ -626,7 +627,7 @@ class WorkloadStatusConfigAutomaticRuleArgs:
626
627
 
627
628
  if not MYPY:
628
629
  class WorkloadStatusConfigAutomaticRuleNrqlQueryArgsDict(TypedDict):
629
- query: pulumi.Input[str]
630
+ query: pulumi.Input[builtins.str]
630
631
  """
631
632
  The entity search query that is used to perform the search of a group of entities.
632
633
  """
@@ -636,36 +637,36 @@ elif False:
636
637
  @pulumi.input_type
637
638
  class WorkloadStatusConfigAutomaticRuleNrqlQueryArgs:
638
639
  def __init__(__self__, *,
639
- query: pulumi.Input[str]):
640
+ query: pulumi.Input[builtins.str]):
640
641
  """
641
- :param pulumi.Input[str] query: The entity search query that is used to perform the search of a group of entities.
642
+ :param pulumi.Input[builtins.str] query: The entity search query that is used to perform the search of a group of entities.
642
643
  """
643
644
  pulumi.set(__self__, "query", query)
644
645
 
645
646
  @property
646
647
  @pulumi.getter
647
- def query(self) -> pulumi.Input[str]:
648
+ def query(self) -> pulumi.Input[builtins.str]:
648
649
  """
649
650
  The entity search query that is used to perform the search of a group of entities.
650
651
  """
651
652
  return pulumi.get(self, "query")
652
653
 
653
654
  @query.setter
654
- def query(self, value: pulumi.Input[str]):
655
+ def query(self, value: pulumi.Input[builtins.str]):
655
656
  pulumi.set(self, "query", value)
656
657
 
657
658
 
658
659
  if not MYPY:
659
660
  class WorkloadStatusConfigAutomaticRuleRollupArgsDict(TypedDict):
660
- strategy: pulumi.Input[str]
661
+ strategy: pulumi.Input[builtins.str]
661
662
  """
662
663
  The rollup strategy that is applied to a group of entities.
663
664
  """
664
- threshold_type: NotRequired[pulumi.Input[str]]
665
+ threshold_type: NotRequired[pulumi.Input[builtins.str]]
665
666
  """
666
667
  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.
667
668
  """
668
- threshold_value: NotRequired[pulumi.Input[int]]
669
+ threshold_value: NotRequired[pulumi.Input[builtins.int]]
669
670
  """
670
671
  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.
671
672
  """
@@ -675,13 +676,13 @@ elif False:
675
676
  @pulumi.input_type
676
677
  class WorkloadStatusConfigAutomaticRuleRollupArgs:
677
678
  def __init__(__self__, *,
678
- strategy: pulumi.Input[str],
679
- threshold_type: Optional[pulumi.Input[str]] = None,
680
- threshold_value: Optional[pulumi.Input[int]] = None):
679
+ strategy: pulumi.Input[builtins.str],
680
+ threshold_type: Optional[pulumi.Input[builtins.str]] = None,
681
+ threshold_value: Optional[pulumi.Input[builtins.int]] = None):
681
682
  """
682
- :param pulumi.Input[str] strategy: The rollup strategy that is applied to a group of entities.
683
- :param pulumi.Input[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[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.
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.
685
686
  """
686
687
  pulumi.set(__self__, "strategy", strategy)
687
688
  if threshold_type is not None:
@@ -691,56 +692,56 @@ class WorkloadStatusConfigAutomaticRuleRollupArgs:
691
692
 
692
693
  @property
693
694
  @pulumi.getter
694
- def strategy(self) -> pulumi.Input[str]:
695
+ def strategy(self) -> pulumi.Input[builtins.str]:
695
696
  """
696
697
  The rollup strategy that is applied to a group of entities.
697
698
  """
698
699
  return pulumi.get(self, "strategy")
699
700
 
700
701
  @strategy.setter
701
- def strategy(self, value: pulumi.Input[str]):
702
+ def strategy(self, value: pulumi.Input[builtins.str]):
702
703
  pulumi.set(self, "strategy", value)
703
704
 
704
705
  @property
705
706
  @pulumi.getter(name="thresholdType")
706
- def threshold_type(self) -> Optional[pulumi.Input[str]]:
707
+ def threshold_type(self) -> Optional[pulumi.Input[builtins.str]]:
707
708
  """
708
709
  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.
709
710
  """
710
711
  return pulumi.get(self, "threshold_type")
711
712
 
712
713
  @threshold_type.setter
713
- def threshold_type(self, value: Optional[pulumi.Input[str]]):
714
+ def threshold_type(self, value: Optional[pulumi.Input[builtins.str]]):
714
715
  pulumi.set(self, "threshold_type", value)
715
716
 
716
717
  @property
717
718
  @pulumi.getter(name="thresholdValue")
718
- def threshold_value(self) -> Optional[pulumi.Input[int]]:
719
+ def threshold_value(self) -> Optional[pulumi.Input[builtins.int]]:
719
720
  """
720
721
  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.
721
722
  """
722
723
  return pulumi.get(self, "threshold_value")
723
724
 
724
725
  @threshold_value.setter
725
- def threshold_value(self, value: Optional[pulumi.Input[int]]):
726
+ def threshold_value(self, value: Optional[pulumi.Input[builtins.int]]):
726
727
  pulumi.set(self, "threshold_value", value)
727
728
 
728
729
 
729
730
  if not MYPY:
730
731
  class WorkloadStatusConfigStaticArgsDict(TypedDict):
731
- enabled: pulumi.Input[bool]
732
+ enabled: pulumi.Input[builtins.bool]
732
733
  """
733
734
  Whether the static status configuration is enabled or not.
734
735
  """
735
- status: pulumi.Input[str]
736
+ status: pulumi.Input[builtins.str]
736
737
  """
737
738
  The status of the workload.
738
739
  """
739
- description: NotRequired[pulumi.Input[str]]
740
+ description: NotRequired[pulumi.Input[builtins.str]]
740
741
  """
741
742
  Relevant information about the workload.
742
743
  """
743
- summary: NotRequired[pulumi.Input[str]]
744
+ summary: NotRequired[pulumi.Input[builtins.str]]
744
745
  """
745
746
  A short description of the status of the workload.
746
747
  """
@@ -750,15 +751,15 @@ elif False:
750
751
  @pulumi.input_type
751
752
  class WorkloadStatusConfigStaticArgs:
752
753
  def __init__(__self__, *,
753
- enabled: pulumi.Input[bool],
754
- status: pulumi.Input[str],
755
- description: Optional[pulumi.Input[str]] = None,
756
- summary: Optional[pulumi.Input[str]] = None):
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):
757
758
  """
758
- :param pulumi.Input[bool] enabled: Whether the static status configuration is enabled or not.
759
- :param pulumi.Input[str] status: The status of the workload.
760
- :param pulumi.Input[str] description: Relevant information about the workload.
761
- :param pulumi.Input[str] summary: A short description of the status of the workload.
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.
762
763
  """
763
764
  pulumi.set(__self__, "enabled", enabled)
764
765
  pulumi.set(__self__, "status", status)
@@ -769,50 +770,50 @@ class WorkloadStatusConfigStaticArgs:
769
770
 
770
771
  @property
771
772
  @pulumi.getter
772
- def enabled(self) -> pulumi.Input[bool]:
773
+ def enabled(self) -> pulumi.Input[builtins.bool]:
773
774
  """
774
775
  Whether the static status configuration is enabled or not.
775
776
  """
776
777
  return pulumi.get(self, "enabled")
777
778
 
778
779
  @enabled.setter
779
- def enabled(self, value: pulumi.Input[bool]):
780
+ def enabled(self, value: pulumi.Input[builtins.bool]):
780
781
  pulumi.set(self, "enabled", value)
781
782
 
782
783
  @property
783
784
  @pulumi.getter
784
- def status(self) -> pulumi.Input[str]:
785
+ def status(self) -> pulumi.Input[builtins.str]:
785
786
  """
786
787
  The status of the workload.
787
788
  """
788
789
  return pulumi.get(self, "status")
789
790
 
790
791
  @status.setter
791
- def status(self, value: pulumi.Input[str]):
792
+ def status(self, value: pulumi.Input[builtins.str]):
792
793
  pulumi.set(self, "status", value)
793
794
 
794
795
  @property
795
796
  @pulumi.getter
796
- def description(self) -> Optional[pulumi.Input[str]]:
797
+ def description(self) -> Optional[pulumi.Input[builtins.str]]:
797
798
  """
798
799
  Relevant information about the workload.
799
800
  """
800
801
  return pulumi.get(self, "description")
801
802
 
802
803
  @description.setter
803
- def description(self, value: Optional[pulumi.Input[str]]):
804
+ def description(self, value: Optional[pulumi.Input[builtins.str]]):
804
805
  pulumi.set(self, "description", value)
805
806
 
806
807
  @property
807
808
  @pulumi.getter
808
- def summary(self) -> Optional[pulumi.Input[str]]:
809
+ def summary(self) -> Optional[pulumi.Input[builtins.str]]:
809
810
  """
810
811
  A short description of the status of the workload.
811
812
  """
812
813
  return pulumi.get(self, "summary")
813
814
 
814
815
  @summary.setter
815
- def summary(self, value: Optional[pulumi.Input[str]]):
816
+ def summary(self, value: Optional[pulumi.Input[builtins.str]]):
816
817
  pulumi.set(self, "summary", value)
817
818
 
818
819