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/nrql_alert_condition.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
@@ -22,61 +23,61 @@ __all__ = ['NrqlAlertConditionArgs', 'NrqlAlertCondition']
22
23
  class NrqlAlertConditionArgs:
23
24
  def __init__(__self__, *,
24
25
  nrql: pulumi.Input['NrqlAlertConditionNrqlArgs'],
25
- policy_id: pulumi.Input[str],
26
- account_id: Optional[pulumi.Input[str]] = None,
27
- aggregation_delay: Optional[pulumi.Input[str]] = None,
28
- aggregation_method: Optional[pulumi.Input[str]] = None,
29
- aggregation_timer: Optional[pulumi.Input[str]] = None,
30
- aggregation_window: Optional[pulumi.Input[int]] = None,
31
- baseline_direction: Optional[pulumi.Input[str]] = None,
32
- close_violations_on_expiration: Optional[pulumi.Input[bool]] = None,
26
+ policy_id: pulumi.Input[builtins.str],
27
+ account_id: Optional[pulumi.Input[builtins.str]] = None,
28
+ aggregation_delay: Optional[pulumi.Input[builtins.str]] = None,
29
+ aggregation_method: Optional[pulumi.Input[builtins.str]] = None,
30
+ aggregation_timer: Optional[pulumi.Input[builtins.str]] = None,
31
+ aggregation_window: Optional[pulumi.Input[builtins.int]] = None,
32
+ baseline_direction: Optional[pulumi.Input[builtins.str]] = None,
33
+ close_violations_on_expiration: Optional[pulumi.Input[builtins.bool]] = None,
33
34
  critical: Optional[pulumi.Input['NrqlAlertConditionCriticalArgs']] = None,
34
- description: Optional[pulumi.Input[str]] = None,
35
- enabled: Optional[pulumi.Input[bool]] = None,
36
- evaluation_delay: Optional[pulumi.Input[int]] = None,
37
- expiration_duration: Optional[pulumi.Input[int]] = None,
38
- fill_option: Optional[pulumi.Input[str]] = None,
39
- fill_value: Optional[pulumi.Input[float]] = None,
40
- ignore_on_expected_termination: Optional[pulumi.Input[bool]] = None,
41
- name: Optional[pulumi.Input[str]] = None,
42
- open_violation_on_expiration: Optional[pulumi.Input[bool]] = None,
43
- runbook_url: Optional[pulumi.Input[str]] = None,
44
- slide_by: Optional[pulumi.Input[int]] = None,
35
+ description: Optional[pulumi.Input[builtins.str]] = None,
36
+ enabled: Optional[pulumi.Input[builtins.bool]] = None,
37
+ evaluation_delay: Optional[pulumi.Input[builtins.int]] = None,
38
+ expiration_duration: Optional[pulumi.Input[builtins.int]] = None,
39
+ fill_option: Optional[pulumi.Input[builtins.str]] = None,
40
+ fill_value: Optional[pulumi.Input[builtins.float]] = None,
41
+ ignore_on_expected_termination: Optional[pulumi.Input[builtins.bool]] = None,
42
+ name: Optional[pulumi.Input[builtins.str]] = None,
43
+ open_violation_on_expiration: Optional[pulumi.Input[builtins.bool]] = None,
44
+ runbook_url: Optional[pulumi.Input[builtins.str]] = None,
45
+ slide_by: Optional[pulumi.Input[builtins.int]] = None,
45
46
  terms: Optional[pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]]] = None,
46
- title_template: Optional[pulumi.Input[str]] = None,
47
- type: Optional[pulumi.Input[str]] = None,
48
- violation_time_limit: Optional[pulumi.Input[str]] = None,
49
- violation_time_limit_seconds: Optional[pulumi.Input[int]] = None,
47
+ title_template: Optional[pulumi.Input[builtins.str]] = None,
48
+ type: Optional[pulumi.Input[builtins.str]] = None,
49
+ violation_time_limit: Optional[pulumi.Input[builtins.str]] = None,
50
+ violation_time_limit_seconds: Optional[pulumi.Input[builtins.int]] = None,
50
51
  warning: Optional[pulumi.Input['NrqlAlertConditionWarningArgs']] = None):
51
52
  """
52
53
  The set of arguments for constructing a NrqlAlertCondition resource.
53
54
  :param pulumi.Input['NrqlAlertConditionNrqlArgs'] nrql: A NRQL query. See NRQL below for details.
54
- :param pulumi.Input[str] policy_id: The ID of the policy where this condition should be used.
55
- :param pulumi.Input[str] account_id: The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
56
- :param pulumi.Input[str] aggregation_delay: How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
57
- :param pulumi.Input[str] aggregation_method: Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
58
- :param pulumi.Input[str] aggregation_timer: How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
59
- :param pulumi.Input[int] aggregation_window: The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
60
- :param pulumi.Input[str] baseline_direction: The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
61
- :param pulumi.Input[bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
55
+ :param pulumi.Input[builtins.str] policy_id: The ID of the policy where this condition should be used.
56
+ :param pulumi.Input[builtins.str] account_id: The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
57
+ :param pulumi.Input[builtins.str] aggregation_delay: How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
58
+ :param pulumi.Input[builtins.str] aggregation_method: Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
59
+ :param pulumi.Input[builtins.str] aggregation_timer: How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
60
+ :param pulumi.Input[builtins.int] aggregation_window: The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
61
+ :param pulumi.Input[builtins.str] baseline_direction: The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
62
+ :param pulumi.Input[builtins.bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
62
63
  :param pulumi.Input['NrqlAlertConditionCriticalArgs'] critical: A list containing the `critical` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
63
- :param pulumi.Input[str] description: The description of the NRQL alert condition.
64
- :param pulumi.Input[bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
65
- :param pulumi.Input[int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
66
- :param pulumi.Input[int] expiration_duration: The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
67
- :param pulumi.Input[str] fill_option: Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
68
- :param pulumi.Input[float] fill_value: This value will be used for filling gaps in the signal.
69
- :param pulumi.Input[bool] ignore_on_expected_termination: Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
70
- :param pulumi.Input[str] name: The title of the condition.
71
- :param pulumi.Input[bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
72
- :param pulumi.Input[str] runbook_url: Runbook URL to display in notifications.
73
- :param pulumi.Input[int] slide_by: Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
64
+ :param pulumi.Input[builtins.str] description: The description of the NRQL alert condition.
65
+ :param pulumi.Input[builtins.bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
66
+ :param pulumi.Input[builtins.int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
67
+ :param pulumi.Input[builtins.int] expiration_duration: The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
68
+ :param pulumi.Input[builtins.str] fill_option: Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
69
+ :param pulumi.Input[builtins.float] fill_value: This value will be used for filling gaps in the signal.
70
+ :param pulumi.Input[builtins.bool] ignore_on_expected_termination: Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
71
+ :param pulumi.Input[builtins.str] name: The title of the condition.
72
+ :param pulumi.Input[builtins.bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
73
+ :param pulumi.Input[builtins.str] runbook_url: Runbook URL to display in notifications.
74
+ :param pulumi.Input[builtins.int] slide_by: Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
74
75
  :param pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]] terms: **DEPRECATED** Use `critical`, and `warning` instead. A list of terms for this condition. See Terms below for details.
75
- :param pulumi.Input[str] title_template: The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
76
- :param pulumi.Input[str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
77
- :param pulumi.Input[str] violation_time_limit: **DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
76
+ :param pulumi.Input[builtins.str] title_template: The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
77
+ :param pulumi.Input[builtins.str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
78
+ :param pulumi.Input[builtins.str] violation_time_limit: **DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
78
79
  <small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
79
- :param pulumi.Input[int] violation_time_limit_seconds: Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
80
+ :param pulumi.Input[builtins.int] violation_time_limit_seconds: Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
80
81
  <small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
81
82
  :param pulumi.Input['NrqlAlertConditionWarningArgs'] warning: A list containing the `warning` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
82
83
  """
@@ -153,98 +154,98 @@ class NrqlAlertConditionArgs:
153
154
 
154
155
  @property
155
156
  @pulumi.getter(name="policyId")
156
- def policy_id(self) -> pulumi.Input[str]:
157
+ def policy_id(self) -> pulumi.Input[builtins.str]:
157
158
  """
158
159
  The ID of the policy where this condition should be used.
159
160
  """
160
161
  return pulumi.get(self, "policy_id")
161
162
 
162
163
  @policy_id.setter
163
- def policy_id(self, value: pulumi.Input[str]):
164
+ def policy_id(self, value: pulumi.Input[builtins.str]):
164
165
  pulumi.set(self, "policy_id", value)
165
166
 
166
167
  @property
167
168
  @pulumi.getter(name="accountId")
168
- def account_id(self) -> Optional[pulumi.Input[str]]:
169
+ def account_id(self) -> Optional[pulumi.Input[builtins.str]]:
169
170
  """
170
171
  The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
171
172
  """
172
173
  return pulumi.get(self, "account_id")
173
174
 
174
175
  @account_id.setter
175
- def account_id(self, value: Optional[pulumi.Input[str]]):
176
+ def account_id(self, value: Optional[pulumi.Input[builtins.str]]):
176
177
  pulumi.set(self, "account_id", value)
177
178
 
178
179
  @property
179
180
  @pulumi.getter(name="aggregationDelay")
180
- def aggregation_delay(self) -> Optional[pulumi.Input[str]]:
181
+ def aggregation_delay(self) -> Optional[pulumi.Input[builtins.str]]:
181
182
  """
182
183
  How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
183
184
  """
184
185
  return pulumi.get(self, "aggregation_delay")
185
186
 
186
187
  @aggregation_delay.setter
187
- def aggregation_delay(self, value: Optional[pulumi.Input[str]]):
188
+ def aggregation_delay(self, value: Optional[pulumi.Input[builtins.str]]):
188
189
  pulumi.set(self, "aggregation_delay", value)
189
190
 
190
191
  @property
191
192
  @pulumi.getter(name="aggregationMethod")
192
- def aggregation_method(self) -> Optional[pulumi.Input[str]]:
193
+ def aggregation_method(self) -> Optional[pulumi.Input[builtins.str]]:
193
194
  """
194
195
  Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
195
196
  """
196
197
  return pulumi.get(self, "aggregation_method")
197
198
 
198
199
  @aggregation_method.setter
199
- def aggregation_method(self, value: Optional[pulumi.Input[str]]):
200
+ def aggregation_method(self, value: Optional[pulumi.Input[builtins.str]]):
200
201
  pulumi.set(self, "aggregation_method", value)
201
202
 
202
203
  @property
203
204
  @pulumi.getter(name="aggregationTimer")
204
- def aggregation_timer(self) -> Optional[pulumi.Input[str]]:
205
+ def aggregation_timer(self) -> Optional[pulumi.Input[builtins.str]]:
205
206
  """
206
207
  How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
207
208
  """
208
209
  return pulumi.get(self, "aggregation_timer")
209
210
 
210
211
  @aggregation_timer.setter
211
- def aggregation_timer(self, value: Optional[pulumi.Input[str]]):
212
+ def aggregation_timer(self, value: Optional[pulumi.Input[builtins.str]]):
212
213
  pulumi.set(self, "aggregation_timer", value)
213
214
 
214
215
  @property
215
216
  @pulumi.getter(name="aggregationWindow")
216
- def aggregation_window(self) -> Optional[pulumi.Input[int]]:
217
+ def aggregation_window(self) -> Optional[pulumi.Input[builtins.int]]:
217
218
  """
218
219
  The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
219
220
  """
220
221
  return pulumi.get(self, "aggregation_window")
221
222
 
222
223
  @aggregation_window.setter
223
- def aggregation_window(self, value: Optional[pulumi.Input[int]]):
224
+ def aggregation_window(self, value: Optional[pulumi.Input[builtins.int]]):
224
225
  pulumi.set(self, "aggregation_window", value)
225
226
 
226
227
  @property
227
228
  @pulumi.getter(name="baselineDirection")
228
- def baseline_direction(self) -> Optional[pulumi.Input[str]]:
229
+ def baseline_direction(self) -> Optional[pulumi.Input[builtins.str]]:
229
230
  """
230
231
  The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
231
232
  """
232
233
  return pulumi.get(self, "baseline_direction")
233
234
 
234
235
  @baseline_direction.setter
235
- def baseline_direction(self, value: Optional[pulumi.Input[str]]):
236
+ def baseline_direction(self, value: Optional[pulumi.Input[builtins.str]]):
236
237
  pulumi.set(self, "baseline_direction", value)
237
238
 
238
239
  @property
239
240
  @pulumi.getter(name="closeViolationsOnExpiration")
240
- def close_violations_on_expiration(self) -> Optional[pulumi.Input[bool]]:
241
+ def close_violations_on_expiration(self) -> Optional[pulumi.Input[builtins.bool]]:
241
242
  """
242
243
  Whether to close all open incidents when the signal expires.
243
244
  """
244
245
  return pulumi.get(self, "close_violations_on_expiration")
245
246
 
246
247
  @close_violations_on_expiration.setter
247
- def close_violations_on_expiration(self, value: Optional[pulumi.Input[bool]]):
248
+ def close_violations_on_expiration(self, value: Optional[pulumi.Input[builtins.bool]]):
248
249
  pulumi.set(self, "close_violations_on_expiration", value)
249
250
 
250
251
  @property
@@ -261,134 +262,134 @@ class NrqlAlertConditionArgs:
261
262
 
262
263
  @property
263
264
  @pulumi.getter
264
- def description(self) -> Optional[pulumi.Input[str]]:
265
+ def description(self) -> Optional[pulumi.Input[builtins.str]]:
265
266
  """
266
267
  The description of the NRQL alert condition.
267
268
  """
268
269
  return pulumi.get(self, "description")
269
270
 
270
271
  @description.setter
271
- def description(self, value: Optional[pulumi.Input[str]]):
272
+ def description(self, value: Optional[pulumi.Input[builtins.str]]):
272
273
  pulumi.set(self, "description", value)
273
274
 
274
275
  @property
275
276
  @pulumi.getter
276
- def enabled(self) -> Optional[pulumi.Input[bool]]:
277
+ def enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
277
278
  """
278
279
  Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
279
280
  """
280
281
  return pulumi.get(self, "enabled")
281
282
 
282
283
  @enabled.setter
283
- def enabled(self, value: Optional[pulumi.Input[bool]]):
284
+ def enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
284
285
  pulumi.set(self, "enabled", value)
285
286
 
286
287
  @property
287
288
  @pulumi.getter(name="evaluationDelay")
288
- def evaluation_delay(self) -> Optional[pulumi.Input[int]]:
289
+ def evaluation_delay(self) -> Optional[pulumi.Input[builtins.int]]:
289
290
  """
290
291
  How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
291
292
  """
292
293
  return pulumi.get(self, "evaluation_delay")
293
294
 
294
295
  @evaluation_delay.setter
295
- def evaluation_delay(self, value: Optional[pulumi.Input[int]]):
296
+ def evaluation_delay(self, value: Optional[pulumi.Input[builtins.int]]):
296
297
  pulumi.set(self, "evaluation_delay", value)
297
298
 
298
299
  @property
299
300
  @pulumi.getter(name="expirationDuration")
300
- def expiration_duration(self) -> Optional[pulumi.Input[int]]:
301
+ def expiration_duration(self) -> Optional[pulumi.Input[builtins.int]]:
301
302
  """
302
303
  The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
303
304
  """
304
305
  return pulumi.get(self, "expiration_duration")
305
306
 
306
307
  @expiration_duration.setter
307
- def expiration_duration(self, value: Optional[pulumi.Input[int]]):
308
+ def expiration_duration(self, value: Optional[pulumi.Input[builtins.int]]):
308
309
  pulumi.set(self, "expiration_duration", value)
309
310
 
310
311
  @property
311
312
  @pulumi.getter(name="fillOption")
312
- def fill_option(self) -> Optional[pulumi.Input[str]]:
313
+ def fill_option(self) -> Optional[pulumi.Input[builtins.str]]:
313
314
  """
314
315
  Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
315
316
  """
316
317
  return pulumi.get(self, "fill_option")
317
318
 
318
319
  @fill_option.setter
319
- def fill_option(self, value: Optional[pulumi.Input[str]]):
320
+ def fill_option(self, value: Optional[pulumi.Input[builtins.str]]):
320
321
  pulumi.set(self, "fill_option", value)
321
322
 
322
323
  @property
323
324
  @pulumi.getter(name="fillValue")
324
- def fill_value(self) -> Optional[pulumi.Input[float]]:
325
+ def fill_value(self) -> Optional[pulumi.Input[builtins.float]]:
325
326
  """
326
327
  This value will be used for filling gaps in the signal.
327
328
  """
328
329
  return pulumi.get(self, "fill_value")
329
330
 
330
331
  @fill_value.setter
331
- def fill_value(self, value: Optional[pulumi.Input[float]]):
332
+ def fill_value(self, value: Optional[pulumi.Input[builtins.float]]):
332
333
  pulumi.set(self, "fill_value", value)
333
334
 
334
335
  @property
335
336
  @pulumi.getter(name="ignoreOnExpectedTermination")
336
- def ignore_on_expected_termination(self) -> Optional[pulumi.Input[bool]]:
337
+ def ignore_on_expected_termination(self) -> Optional[pulumi.Input[builtins.bool]]:
337
338
  """
338
339
  Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
339
340
  """
340
341
  return pulumi.get(self, "ignore_on_expected_termination")
341
342
 
342
343
  @ignore_on_expected_termination.setter
343
- def ignore_on_expected_termination(self, value: Optional[pulumi.Input[bool]]):
344
+ def ignore_on_expected_termination(self, value: Optional[pulumi.Input[builtins.bool]]):
344
345
  pulumi.set(self, "ignore_on_expected_termination", value)
345
346
 
346
347
  @property
347
348
  @pulumi.getter
348
- def name(self) -> Optional[pulumi.Input[str]]:
349
+ def name(self) -> Optional[pulumi.Input[builtins.str]]:
349
350
  """
350
351
  The title of the condition.
351
352
  """
352
353
  return pulumi.get(self, "name")
353
354
 
354
355
  @name.setter
355
- def name(self, value: Optional[pulumi.Input[str]]):
356
+ def name(self, value: Optional[pulumi.Input[builtins.str]]):
356
357
  pulumi.set(self, "name", value)
357
358
 
358
359
  @property
359
360
  @pulumi.getter(name="openViolationOnExpiration")
360
- def open_violation_on_expiration(self) -> Optional[pulumi.Input[bool]]:
361
+ def open_violation_on_expiration(self) -> Optional[pulumi.Input[builtins.bool]]:
361
362
  """
362
363
  Whether to create a new incident to capture that the signal expired.
363
364
  """
364
365
  return pulumi.get(self, "open_violation_on_expiration")
365
366
 
366
367
  @open_violation_on_expiration.setter
367
- def open_violation_on_expiration(self, value: Optional[pulumi.Input[bool]]):
368
+ def open_violation_on_expiration(self, value: Optional[pulumi.Input[builtins.bool]]):
368
369
  pulumi.set(self, "open_violation_on_expiration", value)
369
370
 
370
371
  @property
371
372
  @pulumi.getter(name="runbookUrl")
372
- def runbook_url(self) -> Optional[pulumi.Input[str]]:
373
+ def runbook_url(self) -> Optional[pulumi.Input[builtins.str]]:
373
374
  """
374
375
  Runbook URL to display in notifications.
375
376
  """
376
377
  return pulumi.get(self, "runbook_url")
377
378
 
378
379
  @runbook_url.setter
379
- def runbook_url(self, value: Optional[pulumi.Input[str]]):
380
+ def runbook_url(self, value: Optional[pulumi.Input[builtins.str]]):
380
381
  pulumi.set(self, "runbook_url", value)
381
382
 
382
383
  @property
383
384
  @pulumi.getter(name="slideBy")
384
- def slide_by(self) -> Optional[pulumi.Input[int]]:
385
+ def slide_by(self) -> Optional[pulumi.Input[builtins.int]]:
385
386
  """
386
387
  Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
387
388
  """
388
389
  return pulumi.get(self, "slide_by")
389
390
 
390
391
  @slide_by.setter
391
- def slide_by(self, value: Optional[pulumi.Input[int]]):
392
+ def slide_by(self, value: Optional[pulumi.Input[builtins.int]]):
392
393
  pulumi.set(self, "slide_by", value)
393
394
 
394
395
  @property
@@ -406,32 +407,32 @@ class NrqlAlertConditionArgs:
406
407
 
407
408
  @property
408
409
  @pulumi.getter(name="titleTemplate")
409
- def title_template(self) -> Optional[pulumi.Input[str]]:
410
+ def title_template(self) -> Optional[pulumi.Input[builtins.str]]:
410
411
  """
411
412
  The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
412
413
  """
413
414
  return pulumi.get(self, "title_template")
414
415
 
415
416
  @title_template.setter
416
- def title_template(self, value: Optional[pulumi.Input[str]]):
417
+ def title_template(self, value: Optional[pulumi.Input[builtins.str]]):
417
418
  pulumi.set(self, "title_template", value)
418
419
 
419
420
  @property
420
421
  @pulumi.getter
421
- def type(self) -> Optional[pulumi.Input[str]]:
422
+ def type(self) -> Optional[pulumi.Input[builtins.str]]:
422
423
  """
423
424
  The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
424
425
  """
425
426
  return pulumi.get(self, "type")
426
427
 
427
428
  @type.setter
428
- def type(self, value: Optional[pulumi.Input[str]]):
429
+ def type(self, value: Optional[pulumi.Input[builtins.str]]):
429
430
  pulumi.set(self, "type", value)
430
431
 
431
432
  @property
432
433
  @pulumi.getter(name="violationTimeLimit")
433
434
  @_utilities.deprecated("""use `violation_time_limit_seconds` attribute instead""")
434
- def violation_time_limit(self) -> Optional[pulumi.Input[str]]:
435
+ def violation_time_limit(self) -> Optional[pulumi.Input[builtins.str]]:
435
436
  """
436
437
  **DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
437
438
  <small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
@@ -439,12 +440,12 @@ class NrqlAlertConditionArgs:
439
440
  return pulumi.get(self, "violation_time_limit")
440
441
 
441
442
  @violation_time_limit.setter
442
- def violation_time_limit(self, value: Optional[pulumi.Input[str]]):
443
+ def violation_time_limit(self, value: Optional[pulumi.Input[builtins.str]]):
443
444
  pulumi.set(self, "violation_time_limit", value)
444
445
 
445
446
  @property
446
447
  @pulumi.getter(name="violationTimeLimitSeconds")
447
- def violation_time_limit_seconds(self) -> Optional[pulumi.Input[int]]:
448
+ def violation_time_limit_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
448
449
  """
449
450
  Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
450
451
  <small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
@@ -452,7 +453,7 @@ class NrqlAlertConditionArgs:
452
453
  return pulumi.get(self, "violation_time_limit_seconds")
453
454
 
454
455
  @violation_time_limit_seconds.setter
455
- def violation_time_limit_seconds(self, value: Optional[pulumi.Input[int]]):
456
+ def violation_time_limit_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
456
457
  pulumi.set(self, "violation_time_limit_seconds", value)
457
458
 
458
459
  @property
@@ -471,64 +472,64 @@ class NrqlAlertConditionArgs:
471
472
  @pulumi.input_type
472
473
  class _NrqlAlertConditionState:
473
474
  def __init__(__self__, *,
474
- account_id: Optional[pulumi.Input[str]] = None,
475
- aggregation_delay: Optional[pulumi.Input[str]] = None,
476
- aggregation_method: Optional[pulumi.Input[str]] = None,
477
- aggregation_timer: Optional[pulumi.Input[str]] = None,
478
- aggregation_window: Optional[pulumi.Input[int]] = None,
479
- baseline_direction: Optional[pulumi.Input[str]] = None,
480
- close_violations_on_expiration: Optional[pulumi.Input[bool]] = None,
475
+ account_id: Optional[pulumi.Input[builtins.str]] = None,
476
+ aggregation_delay: Optional[pulumi.Input[builtins.str]] = None,
477
+ aggregation_method: Optional[pulumi.Input[builtins.str]] = None,
478
+ aggregation_timer: Optional[pulumi.Input[builtins.str]] = None,
479
+ aggregation_window: Optional[pulumi.Input[builtins.int]] = None,
480
+ baseline_direction: Optional[pulumi.Input[builtins.str]] = None,
481
+ close_violations_on_expiration: Optional[pulumi.Input[builtins.bool]] = None,
481
482
  critical: Optional[pulumi.Input['NrqlAlertConditionCriticalArgs']] = None,
482
- description: Optional[pulumi.Input[str]] = None,
483
- enabled: Optional[pulumi.Input[bool]] = None,
484
- entity_guid: Optional[pulumi.Input[str]] = None,
485
- evaluation_delay: Optional[pulumi.Input[int]] = None,
486
- expiration_duration: Optional[pulumi.Input[int]] = None,
487
- fill_option: Optional[pulumi.Input[str]] = None,
488
- fill_value: Optional[pulumi.Input[float]] = None,
489
- ignore_on_expected_termination: Optional[pulumi.Input[bool]] = None,
490
- name: Optional[pulumi.Input[str]] = None,
483
+ description: Optional[pulumi.Input[builtins.str]] = None,
484
+ enabled: Optional[pulumi.Input[builtins.bool]] = None,
485
+ entity_guid: Optional[pulumi.Input[builtins.str]] = None,
486
+ evaluation_delay: Optional[pulumi.Input[builtins.int]] = None,
487
+ expiration_duration: Optional[pulumi.Input[builtins.int]] = None,
488
+ fill_option: Optional[pulumi.Input[builtins.str]] = None,
489
+ fill_value: Optional[pulumi.Input[builtins.float]] = None,
490
+ ignore_on_expected_termination: Optional[pulumi.Input[builtins.bool]] = None,
491
+ name: Optional[pulumi.Input[builtins.str]] = None,
491
492
  nrql: Optional[pulumi.Input['NrqlAlertConditionNrqlArgs']] = None,
492
- open_violation_on_expiration: Optional[pulumi.Input[bool]] = None,
493
- policy_id: Optional[pulumi.Input[str]] = None,
494
- runbook_url: Optional[pulumi.Input[str]] = None,
495
- slide_by: Optional[pulumi.Input[int]] = None,
493
+ open_violation_on_expiration: Optional[pulumi.Input[builtins.bool]] = None,
494
+ policy_id: Optional[pulumi.Input[builtins.str]] = None,
495
+ runbook_url: Optional[pulumi.Input[builtins.str]] = None,
496
+ slide_by: Optional[pulumi.Input[builtins.int]] = None,
496
497
  terms: Optional[pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]]] = None,
497
- title_template: Optional[pulumi.Input[str]] = None,
498
- type: Optional[pulumi.Input[str]] = None,
499
- violation_time_limit: Optional[pulumi.Input[str]] = None,
500
- violation_time_limit_seconds: Optional[pulumi.Input[int]] = None,
498
+ title_template: Optional[pulumi.Input[builtins.str]] = None,
499
+ type: Optional[pulumi.Input[builtins.str]] = None,
500
+ violation_time_limit: Optional[pulumi.Input[builtins.str]] = None,
501
+ violation_time_limit_seconds: Optional[pulumi.Input[builtins.int]] = None,
501
502
  warning: Optional[pulumi.Input['NrqlAlertConditionWarningArgs']] = None):
502
503
  """
503
504
  Input properties used for looking up and filtering NrqlAlertCondition resources.
504
- :param pulumi.Input[str] account_id: The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
505
- :param pulumi.Input[str] aggregation_delay: How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
506
- :param pulumi.Input[str] aggregation_method: Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
507
- :param pulumi.Input[str] aggregation_timer: How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
508
- :param pulumi.Input[int] aggregation_window: The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
509
- :param pulumi.Input[str] baseline_direction: The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
510
- :param pulumi.Input[bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
505
+ :param pulumi.Input[builtins.str] account_id: The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
506
+ :param pulumi.Input[builtins.str] aggregation_delay: How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
507
+ :param pulumi.Input[builtins.str] aggregation_method: Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
508
+ :param pulumi.Input[builtins.str] aggregation_timer: How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
509
+ :param pulumi.Input[builtins.int] aggregation_window: The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
510
+ :param pulumi.Input[builtins.str] baseline_direction: The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
511
+ :param pulumi.Input[builtins.bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
511
512
  :param pulumi.Input['NrqlAlertConditionCriticalArgs'] critical: A list containing the `critical` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
512
- :param pulumi.Input[str] description: The description of the NRQL alert condition.
513
- :param pulumi.Input[bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
514
- :param pulumi.Input[str] entity_guid: The unique entity identifier of the NRQL Condition in New Relic.
515
- :param pulumi.Input[int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
516
- :param pulumi.Input[int] expiration_duration: The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
517
- :param pulumi.Input[str] fill_option: Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
518
- :param pulumi.Input[float] fill_value: This value will be used for filling gaps in the signal.
519
- :param pulumi.Input[bool] ignore_on_expected_termination: Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
520
- :param pulumi.Input[str] name: The title of the condition.
513
+ :param pulumi.Input[builtins.str] description: The description of the NRQL alert condition.
514
+ :param pulumi.Input[builtins.bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
515
+ :param pulumi.Input[builtins.str] entity_guid: The unique entity identifier of the NRQL Condition in New Relic.
516
+ :param pulumi.Input[builtins.int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
517
+ :param pulumi.Input[builtins.int] expiration_duration: The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
518
+ :param pulumi.Input[builtins.str] fill_option: Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
519
+ :param pulumi.Input[builtins.float] fill_value: This value will be used for filling gaps in the signal.
520
+ :param pulumi.Input[builtins.bool] ignore_on_expected_termination: Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
521
+ :param pulumi.Input[builtins.str] name: The title of the condition.
521
522
  :param pulumi.Input['NrqlAlertConditionNrqlArgs'] nrql: A NRQL query. See NRQL below for details.
522
- :param pulumi.Input[bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
523
- :param pulumi.Input[str] policy_id: The ID of the policy where this condition should be used.
524
- :param pulumi.Input[str] runbook_url: Runbook URL to display in notifications.
525
- :param pulumi.Input[int] slide_by: Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
523
+ :param pulumi.Input[builtins.bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
524
+ :param pulumi.Input[builtins.str] policy_id: The ID of the policy where this condition should be used.
525
+ :param pulumi.Input[builtins.str] runbook_url: Runbook URL to display in notifications.
526
+ :param pulumi.Input[builtins.int] slide_by: Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
526
527
  :param pulumi.Input[Sequence[pulumi.Input['NrqlAlertConditionTermArgs']]] terms: **DEPRECATED** Use `critical`, and `warning` instead. A list of terms for this condition. See Terms below for details.
527
- :param pulumi.Input[str] title_template: The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
528
- :param pulumi.Input[str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
529
- :param pulumi.Input[str] violation_time_limit: **DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
528
+ :param pulumi.Input[builtins.str] title_template: The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
529
+ :param pulumi.Input[builtins.str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
530
+ :param pulumi.Input[builtins.str] violation_time_limit: **DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
530
531
  <small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
531
- :param pulumi.Input[int] violation_time_limit_seconds: Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
532
+ :param pulumi.Input[builtins.int] violation_time_limit_seconds: Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
532
533
  <small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
533
534
  :param pulumi.Input['NrqlAlertConditionWarningArgs'] warning: A list containing the `warning` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
534
535
  """
@@ -597,86 +598,86 @@ class _NrqlAlertConditionState:
597
598
 
598
599
  @property
599
600
  @pulumi.getter(name="accountId")
600
- def account_id(self) -> Optional[pulumi.Input[str]]:
601
+ def account_id(self) -> Optional[pulumi.Input[builtins.str]]:
601
602
  """
602
603
  The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
603
604
  """
604
605
  return pulumi.get(self, "account_id")
605
606
 
606
607
  @account_id.setter
607
- def account_id(self, value: Optional[pulumi.Input[str]]):
608
+ def account_id(self, value: Optional[pulumi.Input[builtins.str]]):
608
609
  pulumi.set(self, "account_id", value)
609
610
 
610
611
  @property
611
612
  @pulumi.getter(name="aggregationDelay")
612
- def aggregation_delay(self) -> Optional[pulumi.Input[str]]:
613
+ def aggregation_delay(self) -> Optional[pulumi.Input[builtins.str]]:
613
614
  """
614
615
  How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
615
616
  """
616
617
  return pulumi.get(self, "aggregation_delay")
617
618
 
618
619
  @aggregation_delay.setter
619
- def aggregation_delay(self, value: Optional[pulumi.Input[str]]):
620
+ def aggregation_delay(self, value: Optional[pulumi.Input[builtins.str]]):
620
621
  pulumi.set(self, "aggregation_delay", value)
621
622
 
622
623
  @property
623
624
  @pulumi.getter(name="aggregationMethod")
624
- def aggregation_method(self) -> Optional[pulumi.Input[str]]:
625
+ def aggregation_method(self) -> Optional[pulumi.Input[builtins.str]]:
625
626
  """
626
627
  Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
627
628
  """
628
629
  return pulumi.get(self, "aggregation_method")
629
630
 
630
631
  @aggregation_method.setter
631
- def aggregation_method(self, value: Optional[pulumi.Input[str]]):
632
+ def aggregation_method(self, value: Optional[pulumi.Input[builtins.str]]):
632
633
  pulumi.set(self, "aggregation_method", value)
633
634
 
634
635
  @property
635
636
  @pulumi.getter(name="aggregationTimer")
636
- def aggregation_timer(self) -> Optional[pulumi.Input[str]]:
637
+ def aggregation_timer(self) -> Optional[pulumi.Input[builtins.str]]:
637
638
  """
638
639
  How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
639
640
  """
640
641
  return pulumi.get(self, "aggregation_timer")
641
642
 
642
643
  @aggregation_timer.setter
643
- def aggregation_timer(self, value: Optional[pulumi.Input[str]]):
644
+ def aggregation_timer(self, value: Optional[pulumi.Input[builtins.str]]):
644
645
  pulumi.set(self, "aggregation_timer", value)
645
646
 
646
647
  @property
647
648
  @pulumi.getter(name="aggregationWindow")
648
- def aggregation_window(self) -> Optional[pulumi.Input[int]]:
649
+ def aggregation_window(self) -> Optional[pulumi.Input[builtins.int]]:
649
650
  """
650
651
  The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
651
652
  """
652
653
  return pulumi.get(self, "aggregation_window")
653
654
 
654
655
  @aggregation_window.setter
655
- def aggregation_window(self, value: Optional[pulumi.Input[int]]):
656
+ def aggregation_window(self, value: Optional[pulumi.Input[builtins.int]]):
656
657
  pulumi.set(self, "aggregation_window", value)
657
658
 
658
659
  @property
659
660
  @pulumi.getter(name="baselineDirection")
660
- def baseline_direction(self) -> Optional[pulumi.Input[str]]:
661
+ def baseline_direction(self) -> Optional[pulumi.Input[builtins.str]]:
661
662
  """
662
663
  The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
663
664
  """
664
665
  return pulumi.get(self, "baseline_direction")
665
666
 
666
667
  @baseline_direction.setter
667
- def baseline_direction(self, value: Optional[pulumi.Input[str]]):
668
+ def baseline_direction(self, value: Optional[pulumi.Input[builtins.str]]):
668
669
  pulumi.set(self, "baseline_direction", value)
669
670
 
670
671
  @property
671
672
  @pulumi.getter(name="closeViolationsOnExpiration")
672
- def close_violations_on_expiration(self) -> Optional[pulumi.Input[bool]]:
673
+ def close_violations_on_expiration(self) -> Optional[pulumi.Input[builtins.bool]]:
673
674
  """
674
675
  Whether to close all open incidents when the signal expires.
675
676
  """
676
677
  return pulumi.get(self, "close_violations_on_expiration")
677
678
 
678
679
  @close_violations_on_expiration.setter
679
- def close_violations_on_expiration(self, value: Optional[pulumi.Input[bool]]):
680
+ def close_violations_on_expiration(self, value: Optional[pulumi.Input[builtins.bool]]):
680
681
  pulumi.set(self, "close_violations_on_expiration", value)
681
682
 
682
683
  @property
@@ -693,110 +694,110 @@ class _NrqlAlertConditionState:
693
694
 
694
695
  @property
695
696
  @pulumi.getter
696
- def description(self) -> Optional[pulumi.Input[str]]:
697
+ def description(self) -> Optional[pulumi.Input[builtins.str]]:
697
698
  """
698
699
  The description of the NRQL alert condition.
699
700
  """
700
701
  return pulumi.get(self, "description")
701
702
 
702
703
  @description.setter
703
- def description(self, value: Optional[pulumi.Input[str]]):
704
+ def description(self, value: Optional[pulumi.Input[builtins.str]]):
704
705
  pulumi.set(self, "description", value)
705
706
 
706
707
  @property
707
708
  @pulumi.getter
708
- def enabled(self) -> Optional[pulumi.Input[bool]]:
709
+ def enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
709
710
  """
710
711
  Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
711
712
  """
712
713
  return pulumi.get(self, "enabled")
713
714
 
714
715
  @enabled.setter
715
- def enabled(self, value: Optional[pulumi.Input[bool]]):
716
+ def enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
716
717
  pulumi.set(self, "enabled", value)
717
718
 
718
719
  @property
719
720
  @pulumi.getter(name="entityGuid")
720
- def entity_guid(self) -> Optional[pulumi.Input[str]]:
721
+ def entity_guid(self) -> Optional[pulumi.Input[builtins.str]]:
721
722
  """
722
723
  The unique entity identifier of the NRQL Condition in New Relic.
723
724
  """
724
725
  return pulumi.get(self, "entity_guid")
725
726
 
726
727
  @entity_guid.setter
727
- def entity_guid(self, value: Optional[pulumi.Input[str]]):
728
+ def entity_guid(self, value: Optional[pulumi.Input[builtins.str]]):
728
729
  pulumi.set(self, "entity_guid", value)
729
730
 
730
731
  @property
731
732
  @pulumi.getter(name="evaluationDelay")
732
- def evaluation_delay(self) -> Optional[pulumi.Input[int]]:
733
+ def evaluation_delay(self) -> Optional[pulumi.Input[builtins.int]]:
733
734
  """
734
735
  How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
735
736
  """
736
737
  return pulumi.get(self, "evaluation_delay")
737
738
 
738
739
  @evaluation_delay.setter
739
- def evaluation_delay(self, value: Optional[pulumi.Input[int]]):
740
+ def evaluation_delay(self, value: Optional[pulumi.Input[builtins.int]]):
740
741
  pulumi.set(self, "evaluation_delay", value)
741
742
 
742
743
  @property
743
744
  @pulumi.getter(name="expirationDuration")
744
- def expiration_duration(self) -> Optional[pulumi.Input[int]]:
745
+ def expiration_duration(self) -> Optional[pulumi.Input[builtins.int]]:
745
746
  """
746
747
  The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
747
748
  """
748
749
  return pulumi.get(self, "expiration_duration")
749
750
 
750
751
  @expiration_duration.setter
751
- def expiration_duration(self, value: Optional[pulumi.Input[int]]):
752
+ def expiration_duration(self, value: Optional[pulumi.Input[builtins.int]]):
752
753
  pulumi.set(self, "expiration_duration", value)
753
754
 
754
755
  @property
755
756
  @pulumi.getter(name="fillOption")
756
- def fill_option(self) -> Optional[pulumi.Input[str]]:
757
+ def fill_option(self) -> Optional[pulumi.Input[builtins.str]]:
757
758
  """
758
759
  Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
759
760
  """
760
761
  return pulumi.get(self, "fill_option")
761
762
 
762
763
  @fill_option.setter
763
- def fill_option(self, value: Optional[pulumi.Input[str]]):
764
+ def fill_option(self, value: Optional[pulumi.Input[builtins.str]]):
764
765
  pulumi.set(self, "fill_option", value)
765
766
 
766
767
  @property
767
768
  @pulumi.getter(name="fillValue")
768
- def fill_value(self) -> Optional[pulumi.Input[float]]:
769
+ def fill_value(self) -> Optional[pulumi.Input[builtins.float]]:
769
770
  """
770
771
  This value will be used for filling gaps in the signal.
771
772
  """
772
773
  return pulumi.get(self, "fill_value")
773
774
 
774
775
  @fill_value.setter
775
- def fill_value(self, value: Optional[pulumi.Input[float]]):
776
+ def fill_value(self, value: Optional[pulumi.Input[builtins.float]]):
776
777
  pulumi.set(self, "fill_value", value)
777
778
 
778
779
  @property
779
780
  @pulumi.getter(name="ignoreOnExpectedTermination")
780
- def ignore_on_expected_termination(self) -> Optional[pulumi.Input[bool]]:
781
+ def ignore_on_expected_termination(self) -> Optional[pulumi.Input[builtins.bool]]:
781
782
  """
782
783
  Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
783
784
  """
784
785
  return pulumi.get(self, "ignore_on_expected_termination")
785
786
 
786
787
  @ignore_on_expected_termination.setter
787
- def ignore_on_expected_termination(self, value: Optional[pulumi.Input[bool]]):
788
+ def ignore_on_expected_termination(self, value: Optional[pulumi.Input[builtins.bool]]):
788
789
  pulumi.set(self, "ignore_on_expected_termination", value)
789
790
 
790
791
  @property
791
792
  @pulumi.getter
792
- def name(self) -> Optional[pulumi.Input[str]]:
793
+ def name(self) -> Optional[pulumi.Input[builtins.str]]:
793
794
  """
794
795
  The title of the condition.
795
796
  """
796
797
  return pulumi.get(self, "name")
797
798
 
798
799
  @name.setter
799
- def name(self, value: Optional[pulumi.Input[str]]):
800
+ def name(self, value: Optional[pulumi.Input[builtins.str]]):
800
801
  pulumi.set(self, "name", value)
801
802
 
802
803
  @property
@@ -813,50 +814,50 @@ class _NrqlAlertConditionState:
813
814
 
814
815
  @property
815
816
  @pulumi.getter(name="openViolationOnExpiration")
816
- def open_violation_on_expiration(self) -> Optional[pulumi.Input[bool]]:
817
+ def open_violation_on_expiration(self) -> Optional[pulumi.Input[builtins.bool]]:
817
818
  """
818
819
  Whether to create a new incident to capture that the signal expired.
819
820
  """
820
821
  return pulumi.get(self, "open_violation_on_expiration")
821
822
 
822
823
  @open_violation_on_expiration.setter
823
- def open_violation_on_expiration(self, value: Optional[pulumi.Input[bool]]):
824
+ def open_violation_on_expiration(self, value: Optional[pulumi.Input[builtins.bool]]):
824
825
  pulumi.set(self, "open_violation_on_expiration", value)
825
826
 
826
827
  @property
827
828
  @pulumi.getter(name="policyId")
828
- def policy_id(self) -> Optional[pulumi.Input[str]]:
829
+ def policy_id(self) -> Optional[pulumi.Input[builtins.str]]:
829
830
  """
830
831
  The ID of the policy where this condition should be used.
831
832
  """
832
833
  return pulumi.get(self, "policy_id")
833
834
 
834
835
  @policy_id.setter
835
- def policy_id(self, value: Optional[pulumi.Input[str]]):
836
+ def policy_id(self, value: Optional[pulumi.Input[builtins.str]]):
836
837
  pulumi.set(self, "policy_id", value)
837
838
 
838
839
  @property
839
840
  @pulumi.getter(name="runbookUrl")
840
- def runbook_url(self) -> Optional[pulumi.Input[str]]:
841
+ def runbook_url(self) -> Optional[pulumi.Input[builtins.str]]:
841
842
  """
842
843
  Runbook URL to display in notifications.
843
844
  """
844
845
  return pulumi.get(self, "runbook_url")
845
846
 
846
847
  @runbook_url.setter
847
- def runbook_url(self, value: Optional[pulumi.Input[str]]):
848
+ def runbook_url(self, value: Optional[pulumi.Input[builtins.str]]):
848
849
  pulumi.set(self, "runbook_url", value)
849
850
 
850
851
  @property
851
852
  @pulumi.getter(name="slideBy")
852
- def slide_by(self) -> Optional[pulumi.Input[int]]:
853
+ def slide_by(self) -> Optional[pulumi.Input[builtins.int]]:
853
854
  """
854
855
  Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
855
856
  """
856
857
  return pulumi.get(self, "slide_by")
857
858
 
858
859
  @slide_by.setter
859
- def slide_by(self, value: Optional[pulumi.Input[int]]):
860
+ def slide_by(self, value: Optional[pulumi.Input[builtins.int]]):
860
861
  pulumi.set(self, "slide_by", value)
861
862
 
862
863
  @property
@@ -874,32 +875,32 @@ class _NrqlAlertConditionState:
874
875
 
875
876
  @property
876
877
  @pulumi.getter(name="titleTemplate")
877
- def title_template(self) -> Optional[pulumi.Input[str]]:
878
+ def title_template(self) -> Optional[pulumi.Input[builtins.str]]:
878
879
  """
879
880
  The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
880
881
  """
881
882
  return pulumi.get(self, "title_template")
882
883
 
883
884
  @title_template.setter
884
- def title_template(self, value: Optional[pulumi.Input[str]]):
885
+ def title_template(self, value: Optional[pulumi.Input[builtins.str]]):
885
886
  pulumi.set(self, "title_template", value)
886
887
 
887
888
  @property
888
889
  @pulumi.getter
889
- def type(self) -> Optional[pulumi.Input[str]]:
890
+ def type(self) -> Optional[pulumi.Input[builtins.str]]:
890
891
  """
891
892
  The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
892
893
  """
893
894
  return pulumi.get(self, "type")
894
895
 
895
896
  @type.setter
896
- def type(self, value: Optional[pulumi.Input[str]]):
897
+ def type(self, value: Optional[pulumi.Input[builtins.str]]):
897
898
  pulumi.set(self, "type", value)
898
899
 
899
900
  @property
900
901
  @pulumi.getter(name="violationTimeLimit")
901
902
  @_utilities.deprecated("""use `violation_time_limit_seconds` attribute instead""")
902
- def violation_time_limit(self) -> Optional[pulumi.Input[str]]:
903
+ def violation_time_limit(self) -> Optional[pulumi.Input[builtins.str]]:
903
904
  """
904
905
  **DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
905
906
  <small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
@@ -907,12 +908,12 @@ class _NrqlAlertConditionState:
907
908
  return pulumi.get(self, "violation_time_limit")
908
909
 
909
910
  @violation_time_limit.setter
910
- def violation_time_limit(self, value: Optional[pulumi.Input[str]]):
911
+ def violation_time_limit(self, value: Optional[pulumi.Input[builtins.str]]):
911
912
  pulumi.set(self, "violation_time_limit", value)
912
913
 
913
914
  @property
914
915
  @pulumi.getter(name="violationTimeLimitSeconds")
915
- def violation_time_limit_seconds(self) -> Optional[pulumi.Input[int]]:
916
+ def violation_time_limit_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
916
917
  """
917
918
  Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
918
919
  <small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
@@ -920,7 +921,7 @@ class _NrqlAlertConditionState:
920
921
  return pulumi.get(self, "violation_time_limit_seconds")
921
922
 
922
923
  @violation_time_limit_seconds.setter
923
- def violation_time_limit_seconds(self, value: Optional[pulumi.Input[int]]):
924
+ def violation_time_limit_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
924
925
  pulumi.set(self, "violation_time_limit_seconds", value)
925
926
 
926
927
  @property
@@ -941,32 +942,32 @@ class NrqlAlertCondition(pulumi.CustomResource):
941
942
  def __init__(__self__,
942
943
  resource_name: str,
943
944
  opts: Optional[pulumi.ResourceOptions] = None,
944
- account_id: Optional[pulumi.Input[str]] = None,
945
- aggregation_delay: Optional[pulumi.Input[str]] = None,
946
- aggregation_method: Optional[pulumi.Input[str]] = None,
947
- aggregation_timer: Optional[pulumi.Input[str]] = None,
948
- aggregation_window: Optional[pulumi.Input[int]] = None,
949
- baseline_direction: Optional[pulumi.Input[str]] = None,
950
- close_violations_on_expiration: Optional[pulumi.Input[bool]] = None,
945
+ account_id: Optional[pulumi.Input[builtins.str]] = None,
946
+ aggregation_delay: Optional[pulumi.Input[builtins.str]] = None,
947
+ aggregation_method: Optional[pulumi.Input[builtins.str]] = None,
948
+ aggregation_timer: Optional[pulumi.Input[builtins.str]] = None,
949
+ aggregation_window: Optional[pulumi.Input[builtins.int]] = None,
950
+ baseline_direction: Optional[pulumi.Input[builtins.str]] = None,
951
+ close_violations_on_expiration: Optional[pulumi.Input[builtins.bool]] = None,
951
952
  critical: Optional[pulumi.Input[Union['NrqlAlertConditionCriticalArgs', 'NrqlAlertConditionCriticalArgsDict']]] = None,
952
- description: Optional[pulumi.Input[str]] = None,
953
- enabled: Optional[pulumi.Input[bool]] = None,
954
- evaluation_delay: Optional[pulumi.Input[int]] = None,
955
- expiration_duration: Optional[pulumi.Input[int]] = None,
956
- fill_option: Optional[pulumi.Input[str]] = None,
957
- fill_value: Optional[pulumi.Input[float]] = None,
958
- ignore_on_expected_termination: Optional[pulumi.Input[bool]] = None,
959
- name: Optional[pulumi.Input[str]] = None,
953
+ description: Optional[pulumi.Input[builtins.str]] = None,
954
+ enabled: Optional[pulumi.Input[builtins.bool]] = None,
955
+ evaluation_delay: Optional[pulumi.Input[builtins.int]] = None,
956
+ expiration_duration: Optional[pulumi.Input[builtins.int]] = None,
957
+ fill_option: Optional[pulumi.Input[builtins.str]] = None,
958
+ fill_value: Optional[pulumi.Input[builtins.float]] = None,
959
+ ignore_on_expected_termination: Optional[pulumi.Input[builtins.bool]] = None,
960
+ name: Optional[pulumi.Input[builtins.str]] = None,
960
961
  nrql: Optional[pulumi.Input[Union['NrqlAlertConditionNrqlArgs', 'NrqlAlertConditionNrqlArgsDict']]] = None,
961
- open_violation_on_expiration: Optional[pulumi.Input[bool]] = None,
962
- policy_id: Optional[pulumi.Input[str]] = None,
963
- runbook_url: Optional[pulumi.Input[str]] = None,
964
- slide_by: Optional[pulumi.Input[int]] = None,
962
+ open_violation_on_expiration: Optional[pulumi.Input[builtins.bool]] = None,
963
+ policy_id: Optional[pulumi.Input[builtins.str]] = None,
964
+ runbook_url: Optional[pulumi.Input[builtins.str]] = None,
965
+ slide_by: Optional[pulumi.Input[builtins.int]] = None,
965
966
  terms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NrqlAlertConditionTermArgs', 'NrqlAlertConditionTermArgsDict']]]]] = None,
966
- title_template: Optional[pulumi.Input[str]] = None,
967
- type: Optional[pulumi.Input[str]] = None,
968
- violation_time_limit: Optional[pulumi.Input[str]] = None,
969
- violation_time_limit_seconds: Optional[pulumi.Input[int]] = None,
967
+ title_template: Optional[pulumi.Input[builtins.str]] = None,
968
+ type: Optional[pulumi.Input[builtins.str]] = None,
969
+ violation_time_limit: Optional[pulumi.Input[builtins.str]] = None,
970
+ violation_time_limit_seconds: Optional[pulumi.Input[builtins.int]] = None,
970
971
  warning: Optional[pulumi.Input[Union['NrqlAlertConditionWarningArgs', 'NrqlAlertConditionWarningArgsDict']]] = None,
971
972
  __props__=None):
972
973
  """
@@ -1244,33 +1245,33 @@ class NrqlAlertCondition(pulumi.CustomResource):
1244
1245
 
1245
1246
  :param str resource_name: The name of the resource.
1246
1247
  :param pulumi.ResourceOptions opts: Options for the resource.
1247
- :param pulumi.Input[str] account_id: The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
1248
- :param pulumi.Input[str] aggregation_delay: How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
1249
- :param pulumi.Input[str] aggregation_method: Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
1250
- :param pulumi.Input[str] aggregation_timer: How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
1251
- :param pulumi.Input[int] aggregation_window: The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
1252
- :param pulumi.Input[str] baseline_direction: The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
1253
- :param pulumi.Input[bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
1248
+ :param pulumi.Input[builtins.str] account_id: The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
1249
+ :param pulumi.Input[builtins.str] aggregation_delay: How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
1250
+ :param pulumi.Input[builtins.str] aggregation_method: Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
1251
+ :param pulumi.Input[builtins.str] aggregation_timer: How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
1252
+ :param pulumi.Input[builtins.int] aggregation_window: The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
1253
+ :param pulumi.Input[builtins.str] baseline_direction: The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
1254
+ :param pulumi.Input[builtins.bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
1254
1255
  :param pulumi.Input[Union['NrqlAlertConditionCriticalArgs', 'NrqlAlertConditionCriticalArgsDict']] critical: A list containing the `critical` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
1255
- :param pulumi.Input[str] description: The description of the NRQL alert condition.
1256
- :param pulumi.Input[bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
1257
- :param pulumi.Input[int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
1258
- :param pulumi.Input[int] expiration_duration: The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
1259
- :param pulumi.Input[str] fill_option: Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
1260
- :param pulumi.Input[float] fill_value: This value will be used for filling gaps in the signal.
1261
- :param pulumi.Input[bool] ignore_on_expected_termination: Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
1262
- :param pulumi.Input[str] name: The title of the condition.
1256
+ :param pulumi.Input[builtins.str] description: The description of the NRQL alert condition.
1257
+ :param pulumi.Input[builtins.bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
1258
+ :param pulumi.Input[builtins.int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
1259
+ :param pulumi.Input[builtins.int] expiration_duration: The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
1260
+ :param pulumi.Input[builtins.str] fill_option: Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
1261
+ :param pulumi.Input[builtins.float] fill_value: This value will be used for filling gaps in the signal.
1262
+ :param pulumi.Input[builtins.bool] ignore_on_expected_termination: Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
1263
+ :param pulumi.Input[builtins.str] name: The title of the condition.
1263
1264
  :param pulumi.Input[Union['NrqlAlertConditionNrqlArgs', 'NrqlAlertConditionNrqlArgsDict']] nrql: A NRQL query. See NRQL below for details.
1264
- :param pulumi.Input[bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
1265
- :param pulumi.Input[str] policy_id: The ID of the policy where this condition should be used.
1266
- :param pulumi.Input[str] runbook_url: Runbook URL to display in notifications.
1267
- :param pulumi.Input[int] slide_by: Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
1265
+ :param pulumi.Input[builtins.bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
1266
+ :param pulumi.Input[builtins.str] policy_id: The ID of the policy where this condition should be used.
1267
+ :param pulumi.Input[builtins.str] runbook_url: Runbook URL to display in notifications.
1268
+ :param pulumi.Input[builtins.int] slide_by: Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
1268
1269
  :param pulumi.Input[Sequence[pulumi.Input[Union['NrqlAlertConditionTermArgs', 'NrqlAlertConditionTermArgsDict']]]] terms: **DEPRECATED** Use `critical`, and `warning` instead. A list of terms for this condition. See Terms below for details.
1269
- :param pulumi.Input[str] title_template: The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
1270
- :param pulumi.Input[str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
1271
- :param pulumi.Input[str] violation_time_limit: **DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
1270
+ :param pulumi.Input[builtins.str] title_template: The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
1271
+ :param pulumi.Input[builtins.str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
1272
+ :param pulumi.Input[builtins.str] violation_time_limit: **DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
1272
1273
  <small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
1273
- :param pulumi.Input[int] violation_time_limit_seconds: Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
1274
+ :param pulumi.Input[builtins.int] violation_time_limit_seconds: Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
1274
1275
  <small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
1275
1276
  :param pulumi.Input[Union['NrqlAlertConditionWarningArgs', 'NrqlAlertConditionWarningArgsDict']] warning: A list containing the `warning` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
1276
1277
  """
@@ -1568,32 +1569,32 @@ class NrqlAlertCondition(pulumi.CustomResource):
1568
1569
  def _internal_init(__self__,
1569
1570
  resource_name: str,
1570
1571
  opts: Optional[pulumi.ResourceOptions] = None,
1571
- account_id: Optional[pulumi.Input[str]] = None,
1572
- aggregation_delay: Optional[pulumi.Input[str]] = None,
1573
- aggregation_method: Optional[pulumi.Input[str]] = None,
1574
- aggregation_timer: Optional[pulumi.Input[str]] = None,
1575
- aggregation_window: Optional[pulumi.Input[int]] = None,
1576
- baseline_direction: Optional[pulumi.Input[str]] = None,
1577
- close_violations_on_expiration: Optional[pulumi.Input[bool]] = None,
1572
+ account_id: Optional[pulumi.Input[builtins.str]] = None,
1573
+ aggregation_delay: Optional[pulumi.Input[builtins.str]] = None,
1574
+ aggregation_method: Optional[pulumi.Input[builtins.str]] = None,
1575
+ aggregation_timer: Optional[pulumi.Input[builtins.str]] = None,
1576
+ aggregation_window: Optional[pulumi.Input[builtins.int]] = None,
1577
+ baseline_direction: Optional[pulumi.Input[builtins.str]] = None,
1578
+ close_violations_on_expiration: Optional[pulumi.Input[builtins.bool]] = None,
1578
1579
  critical: Optional[pulumi.Input[Union['NrqlAlertConditionCriticalArgs', 'NrqlAlertConditionCriticalArgsDict']]] = None,
1579
- description: Optional[pulumi.Input[str]] = None,
1580
- enabled: Optional[pulumi.Input[bool]] = None,
1581
- evaluation_delay: Optional[pulumi.Input[int]] = None,
1582
- expiration_duration: Optional[pulumi.Input[int]] = None,
1583
- fill_option: Optional[pulumi.Input[str]] = None,
1584
- fill_value: Optional[pulumi.Input[float]] = None,
1585
- ignore_on_expected_termination: Optional[pulumi.Input[bool]] = None,
1586
- name: Optional[pulumi.Input[str]] = None,
1580
+ description: Optional[pulumi.Input[builtins.str]] = None,
1581
+ enabled: Optional[pulumi.Input[builtins.bool]] = None,
1582
+ evaluation_delay: Optional[pulumi.Input[builtins.int]] = None,
1583
+ expiration_duration: Optional[pulumi.Input[builtins.int]] = None,
1584
+ fill_option: Optional[pulumi.Input[builtins.str]] = None,
1585
+ fill_value: Optional[pulumi.Input[builtins.float]] = None,
1586
+ ignore_on_expected_termination: Optional[pulumi.Input[builtins.bool]] = None,
1587
+ name: Optional[pulumi.Input[builtins.str]] = None,
1587
1588
  nrql: Optional[pulumi.Input[Union['NrqlAlertConditionNrqlArgs', 'NrqlAlertConditionNrqlArgsDict']]] = None,
1588
- open_violation_on_expiration: Optional[pulumi.Input[bool]] = None,
1589
- policy_id: Optional[pulumi.Input[str]] = None,
1590
- runbook_url: Optional[pulumi.Input[str]] = None,
1591
- slide_by: Optional[pulumi.Input[int]] = None,
1589
+ open_violation_on_expiration: Optional[pulumi.Input[builtins.bool]] = None,
1590
+ policy_id: Optional[pulumi.Input[builtins.str]] = None,
1591
+ runbook_url: Optional[pulumi.Input[builtins.str]] = None,
1592
+ slide_by: Optional[pulumi.Input[builtins.int]] = None,
1592
1593
  terms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NrqlAlertConditionTermArgs', 'NrqlAlertConditionTermArgsDict']]]]] = None,
1593
- title_template: Optional[pulumi.Input[str]] = None,
1594
- type: Optional[pulumi.Input[str]] = None,
1595
- violation_time_limit: Optional[pulumi.Input[str]] = None,
1596
- violation_time_limit_seconds: Optional[pulumi.Input[int]] = None,
1594
+ title_template: Optional[pulumi.Input[builtins.str]] = None,
1595
+ type: Optional[pulumi.Input[builtins.str]] = None,
1596
+ violation_time_limit: Optional[pulumi.Input[builtins.str]] = None,
1597
+ violation_time_limit_seconds: Optional[pulumi.Input[builtins.int]] = None,
1597
1598
  warning: Optional[pulumi.Input[Union['NrqlAlertConditionWarningArgs', 'NrqlAlertConditionWarningArgsDict']]] = None,
1598
1599
  __props__=None):
1599
1600
  opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
@@ -1646,33 +1647,33 @@ class NrqlAlertCondition(pulumi.CustomResource):
1646
1647
  def get(resource_name: str,
1647
1648
  id: pulumi.Input[str],
1648
1649
  opts: Optional[pulumi.ResourceOptions] = None,
1649
- account_id: Optional[pulumi.Input[str]] = None,
1650
- aggregation_delay: Optional[pulumi.Input[str]] = None,
1651
- aggregation_method: Optional[pulumi.Input[str]] = None,
1652
- aggregation_timer: Optional[pulumi.Input[str]] = None,
1653
- aggregation_window: Optional[pulumi.Input[int]] = None,
1654
- baseline_direction: Optional[pulumi.Input[str]] = None,
1655
- close_violations_on_expiration: Optional[pulumi.Input[bool]] = None,
1650
+ account_id: Optional[pulumi.Input[builtins.str]] = None,
1651
+ aggregation_delay: Optional[pulumi.Input[builtins.str]] = None,
1652
+ aggregation_method: Optional[pulumi.Input[builtins.str]] = None,
1653
+ aggregation_timer: Optional[pulumi.Input[builtins.str]] = None,
1654
+ aggregation_window: Optional[pulumi.Input[builtins.int]] = None,
1655
+ baseline_direction: Optional[pulumi.Input[builtins.str]] = None,
1656
+ close_violations_on_expiration: Optional[pulumi.Input[builtins.bool]] = None,
1656
1657
  critical: Optional[pulumi.Input[Union['NrqlAlertConditionCriticalArgs', 'NrqlAlertConditionCriticalArgsDict']]] = None,
1657
- description: Optional[pulumi.Input[str]] = None,
1658
- enabled: Optional[pulumi.Input[bool]] = None,
1659
- entity_guid: Optional[pulumi.Input[str]] = None,
1660
- evaluation_delay: Optional[pulumi.Input[int]] = None,
1661
- expiration_duration: Optional[pulumi.Input[int]] = None,
1662
- fill_option: Optional[pulumi.Input[str]] = None,
1663
- fill_value: Optional[pulumi.Input[float]] = None,
1664
- ignore_on_expected_termination: Optional[pulumi.Input[bool]] = None,
1665
- name: Optional[pulumi.Input[str]] = None,
1658
+ description: Optional[pulumi.Input[builtins.str]] = None,
1659
+ enabled: Optional[pulumi.Input[builtins.bool]] = None,
1660
+ entity_guid: Optional[pulumi.Input[builtins.str]] = None,
1661
+ evaluation_delay: Optional[pulumi.Input[builtins.int]] = None,
1662
+ expiration_duration: Optional[pulumi.Input[builtins.int]] = None,
1663
+ fill_option: Optional[pulumi.Input[builtins.str]] = None,
1664
+ fill_value: Optional[pulumi.Input[builtins.float]] = None,
1665
+ ignore_on_expected_termination: Optional[pulumi.Input[builtins.bool]] = None,
1666
+ name: Optional[pulumi.Input[builtins.str]] = None,
1666
1667
  nrql: Optional[pulumi.Input[Union['NrqlAlertConditionNrqlArgs', 'NrqlAlertConditionNrqlArgsDict']]] = None,
1667
- open_violation_on_expiration: Optional[pulumi.Input[bool]] = None,
1668
- policy_id: Optional[pulumi.Input[str]] = None,
1669
- runbook_url: Optional[pulumi.Input[str]] = None,
1670
- slide_by: Optional[pulumi.Input[int]] = None,
1668
+ open_violation_on_expiration: Optional[pulumi.Input[builtins.bool]] = None,
1669
+ policy_id: Optional[pulumi.Input[builtins.str]] = None,
1670
+ runbook_url: Optional[pulumi.Input[builtins.str]] = None,
1671
+ slide_by: Optional[pulumi.Input[builtins.int]] = None,
1671
1672
  terms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NrqlAlertConditionTermArgs', 'NrqlAlertConditionTermArgsDict']]]]] = None,
1672
- title_template: Optional[pulumi.Input[str]] = None,
1673
- type: Optional[pulumi.Input[str]] = None,
1674
- violation_time_limit: Optional[pulumi.Input[str]] = None,
1675
- violation_time_limit_seconds: Optional[pulumi.Input[int]] = None,
1673
+ title_template: Optional[pulumi.Input[builtins.str]] = None,
1674
+ type: Optional[pulumi.Input[builtins.str]] = None,
1675
+ violation_time_limit: Optional[pulumi.Input[builtins.str]] = None,
1676
+ violation_time_limit_seconds: Optional[pulumi.Input[builtins.int]] = None,
1676
1677
  warning: Optional[pulumi.Input[Union['NrqlAlertConditionWarningArgs', 'NrqlAlertConditionWarningArgsDict']]] = None) -> 'NrqlAlertCondition':
1677
1678
  """
1678
1679
  Get an existing NrqlAlertCondition resource's state with the given name, id, and optional extra
@@ -1681,34 +1682,34 @@ class NrqlAlertCondition(pulumi.CustomResource):
1681
1682
  :param str resource_name: The unique name of the resulting resource.
1682
1683
  :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
1683
1684
  :param pulumi.ResourceOptions opts: Options for the resource.
1684
- :param pulumi.Input[str] account_id: The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
1685
- :param pulumi.Input[str] aggregation_delay: How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
1686
- :param pulumi.Input[str] aggregation_method: Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
1687
- :param pulumi.Input[str] aggregation_timer: How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
1688
- :param pulumi.Input[int] aggregation_window: The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
1689
- :param pulumi.Input[str] baseline_direction: The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
1690
- :param pulumi.Input[bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
1685
+ :param pulumi.Input[builtins.str] account_id: The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
1686
+ :param pulumi.Input[builtins.str] aggregation_delay: How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
1687
+ :param pulumi.Input[builtins.str] aggregation_method: Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
1688
+ :param pulumi.Input[builtins.str] aggregation_timer: How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
1689
+ :param pulumi.Input[builtins.int] aggregation_window: The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
1690
+ :param pulumi.Input[builtins.str] baseline_direction: The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
1691
+ :param pulumi.Input[builtins.bool] close_violations_on_expiration: Whether to close all open incidents when the signal expires.
1691
1692
  :param pulumi.Input[Union['NrqlAlertConditionCriticalArgs', 'NrqlAlertConditionCriticalArgsDict']] critical: A list containing the `critical` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
1692
- :param pulumi.Input[str] description: The description of the NRQL alert condition.
1693
- :param pulumi.Input[bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
1694
- :param pulumi.Input[str] entity_guid: The unique entity identifier of the NRQL Condition in New Relic.
1695
- :param pulumi.Input[int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
1696
- :param pulumi.Input[int] expiration_duration: The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
1697
- :param pulumi.Input[str] fill_option: Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
1698
- :param pulumi.Input[float] fill_value: This value will be used for filling gaps in the signal.
1699
- :param pulumi.Input[bool] ignore_on_expected_termination: Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
1700
- :param pulumi.Input[str] name: The title of the condition.
1693
+ :param pulumi.Input[builtins.str] description: The description of the NRQL alert condition.
1694
+ :param pulumi.Input[builtins.bool] enabled: Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
1695
+ :param pulumi.Input[builtins.str] entity_guid: The unique entity identifier of the NRQL Condition in New Relic.
1696
+ :param pulumi.Input[builtins.int] evaluation_delay: How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
1697
+ :param pulumi.Input[builtins.int] expiration_duration: The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
1698
+ :param pulumi.Input[builtins.str] fill_option: Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
1699
+ :param pulumi.Input[builtins.float] fill_value: This value will be used for filling gaps in the signal.
1700
+ :param pulumi.Input[builtins.bool] ignore_on_expected_termination: Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
1701
+ :param pulumi.Input[builtins.str] name: The title of the condition.
1701
1702
  :param pulumi.Input[Union['NrqlAlertConditionNrqlArgs', 'NrqlAlertConditionNrqlArgsDict']] nrql: A NRQL query. See NRQL below for details.
1702
- :param pulumi.Input[bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
1703
- :param pulumi.Input[str] policy_id: The ID of the policy where this condition should be used.
1704
- :param pulumi.Input[str] runbook_url: Runbook URL to display in notifications.
1705
- :param pulumi.Input[int] slide_by: Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
1703
+ :param pulumi.Input[builtins.bool] open_violation_on_expiration: Whether to create a new incident to capture that the signal expired.
1704
+ :param pulumi.Input[builtins.str] policy_id: The ID of the policy where this condition should be used.
1705
+ :param pulumi.Input[builtins.str] runbook_url: Runbook URL to display in notifications.
1706
+ :param pulumi.Input[builtins.int] slide_by: Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
1706
1707
  :param pulumi.Input[Sequence[pulumi.Input[Union['NrqlAlertConditionTermArgs', 'NrqlAlertConditionTermArgsDict']]]] terms: **DEPRECATED** Use `critical`, and `warning` instead. A list of terms for this condition. See Terms below for details.
1707
- :param pulumi.Input[str] title_template: The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
1708
- :param pulumi.Input[str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
1709
- :param pulumi.Input[str] violation_time_limit: **DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
1708
+ :param pulumi.Input[builtins.str] title_template: The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
1709
+ :param pulumi.Input[builtins.str] type: The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
1710
+ :param pulumi.Input[builtins.str] violation_time_limit: **DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
1710
1711
  <small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
1711
- :param pulumi.Input[int] violation_time_limit_seconds: Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
1712
+ :param pulumi.Input[builtins.int] violation_time_limit_seconds: Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
1712
1713
  <small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
1713
1714
  :param pulumi.Input[Union['NrqlAlertConditionWarningArgs', 'NrqlAlertConditionWarningArgsDict']] warning: A list containing the `warning` threshold values. At least one `critical` or `warning` threshold must be defined. See Terms below for details.
1714
1715
  """
@@ -1748,7 +1749,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1748
1749
 
1749
1750
  @property
1750
1751
  @pulumi.getter(name="accountId")
1751
- def account_id(self) -> pulumi.Output[str]:
1752
+ def account_id(self) -> pulumi.Output[builtins.str]:
1752
1753
  """
1753
1754
  The New Relic account ID of the account you wish to create the condition. Defaults to the account ID set in your environment variable `NEW_RELIC_ACCOUNT_ID`.
1754
1755
  """
@@ -1756,7 +1757,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1756
1757
 
1757
1758
  @property
1758
1759
  @pulumi.getter(name="aggregationDelay")
1759
- def aggregation_delay(self) -> pulumi.Output[Optional[str]]:
1760
+ def aggregation_delay(self) -> pulumi.Output[Optional[builtins.str]]:
1760
1761
  """
1761
1762
  How long we wait for data that belongs in each aggregation window. Depending on your data, a longer delay may increase accuracy but delay notifications. Use `aggregation_delay` with the `event_flow` and `cadence` methods. The maximum delay is 1200 seconds (20 minutes) when using `event_flow` and 3600 seconds (60 minutes) when using `cadence`. In both cases, the minimum delay is 0 seconds and the default is 120 seconds. `aggregation_delay` cannot be set with `nrql.evaluation_offset`.
1762
1763
  """
@@ -1764,7 +1765,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1764
1765
 
1765
1766
  @property
1766
1767
  @pulumi.getter(name="aggregationMethod")
1767
- def aggregation_method(self) -> pulumi.Output[Optional[str]]:
1768
+ def aggregation_method(self) -> pulumi.Output[Optional[builtins.str]]:
1768
1769
  """
1769
1770
  Determines when we consider an aggregation window to be complete so that we can evaluate the signal for incidents. Possible values are `cadence`, `event_flow` or `event_timer`. Default is `event_flow`. `aggregation_method` cannot be set with `nrql.evaluation_offset`.
1770
1771
  """
@@ -1772,7 +1773,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1772
1773
 
1773
1774
  @property
1774
1775
  @pulumi.getter(name="aggregationTimer")
1775
- def aggregation_timer(self) -> pulumi.Output[Optional[str]]:
1776
+ def aggregation_timer(self) -> pulumi.Output[Optional[builtins.str]]:
1776
1777
  """
1777
1778
  How long we wait after each data point arrives to make sure we've processed the whole batch. Use `aggregation_timer` with the `event_timer` method. The timer value can range from 0 seconds to 1200 seconds (20 minutes); the default is 60 seconds. `aggregation_timer` cannot be set with `nrql.evaluation_offset`.
1778
1779
  """
@@ -1780,7 +1781,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1780
1781
 
1781
1782
  @property
1782
1783
  @pulumi.getter(name="aggregationWindow")
1783
- def aggregation_window(self) -> pulumi.Output[int]:
1784
+ def aggregation_window(self) -> pulumi.Output[builtins.int]:
1784
1785
  """
1785
1786
  The duration of the time window used to evaluate the NRQL query, in seconds. The value must be at least 30 seconds, and no more than 21600 seconds (6 hours). Default is 60 seconds.
1786
1787
  """
@@ -1788,7 +1789,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1788
1789
 
1789
1790
  @property
1790
1791
  @pulumi.getter(name="baselineDirection")
1791
- def baseline_direction(self) -> pulumi.Output[Optional[str]]:
1792
+ def baseline_direction(self) -> pulumi.Output[Optional[builtins.str]]:
1792
1793
  """
1793
1794
  The baseline direction of a _baseline_ NRQL alert condition. Valid values are: `lower_only`, `upper_and_lower`, `upper_only` (case insensitive).
1794
1795
  """
@@ -1796,7 +1797,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1796
1797
 
1797
1798
  @property
1798
1799
  @pulumi.getter(name="closeViolationsOnExpiration")
1799
- def close_violations_on_expiration(self) -> pulumi.Output[Optional[bool]]:
1800
+ def close_violations_on_expiration(self) -> pulumi.Output[Optional[builtins.bool]]:
1800
1801
  """
1801
1802
  Whether to close all open incidents when the signal expires.
1802
1803
  """
@@ -1812,7 +1813,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1812
1813
 
1813
1814
  @property
1814
1815
  @pulumi.getter
1815
- def description(self) -> pulumi.Output[Optional[str]]:
1816
+ def description(self) -> pulumi.Output[Optional[builtins.str]]:
1816
1817
  """
1817
1818
  The description of the NRQL alert condition.
1818
1819
  """
@@ -1820,7 +1821,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1820
1821
 
1821
1822
  @property
1822
1823
  @pulumi.getter
1823
- def enabled(self) -> pulumi.Output[Optional[bool]]:
1824
+ def enabled(self) -> pulumi.Output[Optional[builtins.bool]]:
1824
1825
  """
1825
1826
  Whether to enable the alert condition. Valid values are `true` and `false`. Defaults to `true`.
1826
1827
  """
@@ -1828,7 +1829,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1828
1829
 
1829
1830
  @property
1830
1831
  @pulumi.getter(name="entityGuid")
1831
- def entity_guid(self) -> pulumi.Output[str]:
1832
+ def entity_guid(self) -> pulumi.Output[builtins.str]:
1832
1833
  """
1833
1834
  The unique entity identifier of the NRQL Condition in New Relic.
1834
1835
  """
@@ -1836,7 +1837,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1836
1837
 
1837
1838
  @property
1838
1839
  @pulumi.getter(name="evaluationDelay")
1839
- def evaluation_delay(self) -> pulumi.Output[Optional[int]]:
1840
+ def evaluation_delay(self) -> pulumi.Output[Optional[builtins.int]]:
1840
1841
  """
1841
1842
  How long we wait until the signal starts evaluating. The maximum delay is 7200 seconds (120 minutes).
1842
1843
  """
@@ -1844,7 +1845,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1844
1845
 
1845
1846
  @property
1846
1847
  @pulumi.getter(name="expirationDuration")
1847
- def expiration_duration(self) -> pulumi.Output[Optional[int]]:
1848
+ def expiration_duration(self) -> pulumi.Output[Optional[builtins.int]]:
1848
1849
  """
1849
1850
  The amount of time (in seconds) to wait before considering the signal expired. The value must be at least 30 seconds, and no more than 172800 seconds (48 hours).
1850
1851
  """
@@ -1852,7 +1853,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1852
1853
 
1853
1854
  @property
1854
1855
  @pulumi.getter(name="fillOption")
1855
- def fill_option(self) -> pulumi.Output[Optional[str]]:
1856
+ def fill_option(self) -> pulumi.Output[Optional[builtins.str]]:
1856
1857
  """
1857
1858
  Which strategy to use when filling gaps in the signal. Possible values are `none`, `last_value` or `static`. If `static`, the `fill_value` field will be used for filling gaps in the signal.
1858
1859
  """
@@ -1860,7 +1861,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1860
1861
 
1861
1862
  @property
1862
1863
  @pulumi.getter(name="fillValue")
1863
- def fill_value(self) -> pulumi.Output[Optional[float]]:
1864
+ def fill_value(self) -> pulumi.Output[Optional[builtins.float]]:
1864
1865
  """
1865
1866
  This value will be used for filling gaps in the signal.
1866
1867
  """
@@ -1868,7 +1869,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1868
1869
 
1869
1870
  @property
1870
1871
  @pulumi.getter(name="ignoreOnExpectedTermination")
1871
- def ignore_on_expected_termination(self) -> pulumi.Output[Optional[bool]]:
1872
+ def ignore_on_expected_termination(self) -> pulumi.Output[Optional[builtins.bool]]:
1872
1873
  """
1873
1874
  Whether an alert condition should ignore expected termination of a signal when considering whether to create a loss of signal incident. Defaults to false.
1874
1875
  """
@@ -1876,7 +1877,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1876
1877
 
1877
1878
  @property
1878
1879
  @pulumi.getter
1879
- def name(self) -> pulumi.Output[str]:
1880
+ def name(self) -> pulumi.Output[builtins.str]:
1880
1881
  """
1881
1882
  The title of the condition.
1882
1883
  """
@@ -1892,7 +1893,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1892
1893
 
1893
1894
  @property
1894
1895
  @pulumi.getter(name="openViolationOnExpiration")
1895
- def open_violation_on_expiration(self) -> pulumi.Output[Optional[bool]]:
1896
+ def open_violation_on_expiration(self) -> pulumi.Output[Optional[builtins.bool]]:
1896
1897
  """
1897
1898
  Whether to create a new incident to capture that the signal expired.
1898
1899
  """
@@ -1900,7 +1901,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1900
1901
 
1901
1902
  @property
1902
1903
  @pulumi.getter(name="policyId")
1903
- def policy_id(self) -> pulumi.Output[str]:
1904
+ def policy_id(self) -> pulumi.Output[builtins.str]:
1904
1905
  """
1905
1906
  The ID of the policy where this condition should be used.
1906
1907
  """
@@ -1908,7 +1909,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1908
1909
 
1909
1910
  @property
1910
1911
  @pulumi.getter(name="runbookUrl")
1911
- def runbook_url(self) -> pulumi.Output[Optional[str]]:
1912
+ def runbook_url(self) -> pulumi.Output[Optional[builtins.str]]:
1912
1913
  """
1913
1914
  Runbook URL to display in notifications.
1914
1915
  """
@@ -1916,7 +1917,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1916
1917
 
1917
1918
  @property
1918
1919
  @pulumi.getter(name="slideBy")
1919
- def slide_by(self) -> pulumi.Output[Optional[int]]:
1920
+ def slide_by(self) -> pulumi.Output[Optional[builtins.int]]:
1920
1921
  """
1921
1922
  Gathers data in overlapping time windows to smooth the chart line, making it easier to spot trends. The `slide_by` value is specified in seconds and must be smaller than and a factor of the `aggregation_window`.
1922
1923
  """
@@ -1933,7 +1934,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1933
1934
 
1934
1935
  @property
1935
1936
  @pulumi.getter(name="titleTemplate")
1936
- def title_template(self) -> pulumi.Output[Optional[str]]:
1937
+ def title_template(self) -> pulumi.Output[Optional[builtins.str]]:
1937
1938
  """
1938
1939
  The custom title to be used when incidents are opened by the condition. Setting this field will override the default title. Must be [Handlebars](https://handlebarsjs.com/) format.
1939
1940
  """
@@ -1941,7 +1942,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1941
1942
 
1942
1943
  @property
1943
1944
  @pulumi.getter
1944
- def type(self) -> pulumi.Output[Optional[str]]:
1945
+ def type(self) -> pulumi.Output[Optional[builtins.str]]:
1945
1946
  """
1946
1947
  The type of the condition. Valid values are `static` or `baseline`. Defaults to `static`.
1947
1948
  """
@@ -1950,7 +1951,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1950
1951
  @property
1951
1952
  @pulumi.getter(name="violationTimeLimit")
1952
1953
  @_utilities.deprecated("""use `violation_time_limit_seconds` attribute instead""")
1953
- def violation_time_limit(self) -> pulumi.Output[str]:
1954
+ def violation_time_limit(self) -> pulumi.Output[builtins.str]:
1954
1955
  """
1955
1956
  **DEPRECATED:** Use `violation_time_limit_seconds` instead. Sets a time limit, in hours, that will automatically force-close a long-lasting incident after the time limit you select. Possible values are `ONE_HOUR`, `TWO_HOURS`, `FOUR_HOURS`, `EIGHT_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`, `THIRTY_DAYS` (case insensitive).<br>
1956
1957
  <small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>
@@ -1959,7 +1960,7 @@ class NrqlAlertCondition(pulumi.CustomResource):
1959
1960
 
1960
1961
  @property
1961
1962
  @pulumi.getter(name="violationTimeLimitSeconds")
1962
- def violation_time_limit_seconds(self) -> pulumi.Output[Optional[int]]:
1963
+ def violation_time_limit_seconds(self) -> pulumi.Output[Optional[builtins.int]]:
1963
1964
  """
1964
1965
  Sets a time limit, in seconds, that will automatically force-close a long-lasting incident after the time limit you select. The value must be between 300 seconds (5 minutes) to 2592000 seconds (30 days) (inclusive). <br>
1965
1966
  <small>\\***Note**: One of `violation_time_limit` _or_ `violation_time_limit_seconds` must be set, but not both.</small>