pulumi-newrelic 5.20.0a1709643785__py3-none-any.whl → 5.39.0a1736834464__py3-none-any.whl

pulumi_newrelic/get_notification_destination.py

@@ -4,11 +4,17 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
 from . import outputs
+from ._inputs import *
 
 __all__ = [
     'GetNotificationDestinationResult',
@@ -22,13 +28,16 @@ class GetNotificationDestinationResult:
     """
     A collection of values returned by getNotificationDestination.
     """
-    def __init__(__self__, account_id=None, active=None, id=None, name=None, properties=None, status=None, type=None):
-        if account_id and not isinstance(account_id, int):
-            raise TypeError("Expected argument 'account_id' to be a int")
+    def __init__(__self__, account_id=None, active=None, guid=None, id=None, name=None, properties=None, secure_urls=None, status=None, type=None):
+        if account_id and not isinstance(account_id, str):
+            raise TypeError("Expected argument 'account_id' to be a str")
         pulumi.set(__self__, "account_id", account_id)
         if active and not isinstance(active, bool):
             raise TypeError("Expected argument 'active' to be a bool")
         pulumi.set(__self__, "active", active)
+        if guid and not isinstance(guid, str):
+            raise TypeError("Expected argument 'guid' to be a str")
+        pulumi.set(__self__, "guid", guid)
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
@@ -38,6 +47,9 @@ class GetNotificationDestinationResult:
         if properties and not isinstance(properties, list):
             raise TypeError("Expected argument 'properties' to be a list")
         pulumi.set(__self__, "properties", properties)
+        if secure_urls and not isinstance(secure_urls, list):
+            raise TypeError("Expected argument 'secure_urls' to be a list")
+        pulumi.set(__self__, "secure_urls", secure_urls)
         if status and not isinstance(status, str):
             raise TypeError("Expected argument 'status' to be a str")
         pulumi.set(__self__, "status", status)
@@ -47,7 +59,7 @@ class GetNotificationDestinationResult:
 
     @property
     @pulumi.getter(name="accountId")
-    def account_id(self) -> int:
+    def account_id(self) -> str:
         return pulumi.get(self, "account_id")
 
     @property
@@ -58,6 +70,14 @@ class GetNotificationDestinationResult:
         """
         return pulumi.get(self, "active")
 
+    @property
+    @pulumi.getter
+    def guid(self) -> str:
+        """
+        The unique entity identifier of the destination in New Relic.
+        """
+        return pulumi.get(self, "guid")
+
     @property
     @pulumi.getter
     def id(self) -> Optional[str]:
@@ -79,6 +99,14 @@ class GetNotificationDestinationResult:
         """
         return pulumi.get(self, "properties")
 
+    @property
+    @pulumi.getter(name="secureUrls")
+    def secure_urls(self) -> Sequence['outputs.GetNotificationDestinationSecureUrlResult']:
+        """
+        The URL in secure format, showing only the `prefix`, as the `secure_suffix` is a secret.
+        """
+        return pulumi.get(self, "secure_urls")
+
     @property
     @pulumi.getter
     def status(self) -> str:
@@ -91,7 +119,7 @@ class GetNotificationDestinationResult:
     @pulumi.getter
     def type(self) -> str:
         """
-        The notification destination type, either: `EMAIL`, `SERVICE_NOW`, `WEBHOOK`, `JIRA`, `MOBILE_PUSH`, `EVENT_BRIDGE`, `PAGERDUTY_ACCOUNT_INTEGRATION` or `PAGERDUTY_SERVICE_INTEGRATION`, `SLACK` and `SLACK_COLLABORATION`.
+        The notification destination type, either: `EMAIL`, `SERVICE_NOW`, `SERVICE_NOW_APP`, `WEBHOOK`, `JIRA`, `MOBILE_PUSH`, `EVENT_BRIDGE`, `PAGERDUTY_ACCOUNT_INTEGRATION` or `PAGERDUTY_SERVICE_INTEGRATION`, `SLACK` and `SLACK_COLLABORATION`.
         """
         return pulumi.get(self, "type")
 
@@ -104,55 +132,77 @@ class AwaitableGetNotificationDestinationResult(GetNotificationDestinationResult
         return GetNotificationDestinationResult(
             account_id=self.account_id,
             active=self.active,
+            guid=self.guid,
             id=self.id,
             name=self.name,
             properties=self.properties,
+            secure_urls=self.secure_urls,
             status=self.status,
             type=self.type)
 
 
-def get_notification_destination(account_id: Optional[int] = None,
+def get_notification_destination(account_id: Optional[str] = None,
                                  id: Optional[str] = None,
                                  name: Optional[str] = None,
+                                 secure_urls: Optional[Sequence[Union['GetNotificationDestinationSecureUrlArgs', 'GetNotificationDestinationSecureUrlArgsDict']]] = None,
                                  opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetNotificationDestinationResult:
     """
     Use this data source to access information about an existing resource.
 
-    :param int account_id: The New Relic account ID to operate on.  This allows you to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID`.
+    :param str account_id: The New Relic account ID to operate on.  This allows you to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID`.
     :param str id: The id of the notification destination in New Relic.
     :param str name: The name of the notification destination.
            
            Optional:
+    :param Sequence[Union['GetNotificationDestinationSecureUrlArgs', 'GetNotificationDestinationSecureUrlArgsDict']] secure_urls: The URL in secure format, showing only the `prefix`, as the `secure_suffix` is a secret.
     """
     __args__ = dict()
     __args__['accountId'] = account_id
     __args__['id'] = id
     __args__['name'] = name
+    __args__['secureUrls'] = secure_urls
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('newrelic:index/getNotificationDestination:getNotificationDestination', __args__, opts=opts, typ=GetNotificationDestinationResult).value
 
     return AwaitableGetNotificationDestinationResult(
         account_id=pulumi.get(__ret__, 'account_id'),
         active=pulumi.get(__ret__, 'active'),
+        guid=pulumi.get(__ret__, 'guid'),
         id=pulumi.get(__ret__, 'id'),
         name=pulumi.get(__ret__, 'name'),
         properties=pulumi.get(__ret__, 'properties'),
+        secure_urls=pulumi.get(__ret__, 'secure_urls'),
         status=pulumi.get(__ret__, 'status'),
         type=pulumi.get(__ret__, 'type'))
-
-
-@_utilities.lift_output_func(get_notification_destination)
-def get_notification_destination_output(account_id: Optional[pulumi.Input[Optional[int]]] = None,
+def get_notification_destination_output(account_id: Optional[pulumi.Input[Optional[str]]] = None,
                                         id: Optional[pulumi.Input[Optional[str]]] = None,
                                         name: Optional[pulumi.Input[Optional[str]]] = None,
-                                        opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetNotificationDestinationResult]:
+                                        secure_urls: Optional[pulumi.Input[Optional[Sequence[Union['GetNotificationDestinationSecureUrlArgs', 'GetNotificationDestinationSecureUrlArgsDict']]]]] = None,
+                                        opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetNotificationDestinationResult]:
     """
     Use this data source to access information about an existing resource.
 
-    :param int account_id: The New Relic account ID to operate on.  This allows you to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID`.
+    :param str account_id: The New Relic account ID to operate on.  This allows you to override the `account_id` attribute set on the provider. Defaults to the environment variable `NEW_RELIC_ACCOUNT_ID`.
     :param str id: The id of the notification destination in New Relic.
     :param str name: The name of the notification destination.
            
            Optional:
+    :param Sequence[Union['GetNotificationDestinationSecureUrlArgs', 'GetNotificationDestinationSecureUrlArgsDict']] secure_urls: The URL in secure format, showing only the `prefix`, as the `secure_suffix` is a secret.
     """
-    ...
+    __args__ = dict()
+    __args__['accountId'] = account_id
+    __args__['id'] = id
+    __args__['name'] = name
+    __args__['secureUrls'] = secure_urls
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('newrelic:index/getNotificationDestination:getNotificationDestination', __args__, opts=opts, typ=GetNotificationDestinationResult)
+    return __ret__.apply(lambda __response__: GetNotificationDestinationResult(
+        account_id=pulumi.get(__response__, 'account_id'),
+        active=pulumi.get(__response__, 'active'),
+        guid=pulumi.get(__response__, 'guid'),
+        id=pulumi.get(__response__, 'id'),
+        name=pulumi.get(__response__, 'name'),
+        properties=pulumi.get(__response__, 'properties'),
+        secure_urls=pulumi.get(__response__, 'secure_urls'),
+        status=pulumi.get(__response__, 'status'),
+        type=pulumi.get(__response__, 'type')))

pulumi_newrelic/get_obfuscation_expression.py

@@ -4,9 +4,14 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
 
 __all__ = [
@@ -22,8 +27,8 @@ class GetObfuscationExpressionResult:
     A collection of values returned by getObfuscationExpression.
     """
     def __init__(__self__, account_id=None, id=None, name=None):
-        if account_id and not isinstance(account_id, int):
-            raise TypeError("Expected argument 'account_id' to be a int")
+        if account_id and not isinstance(account_id, str):
+            raise TypeError("Expected argument 'account_id' to be a str")
         pulumi.set(__self__, "account_id", account_id)
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
@@ -34,7 +39,7 @@ class GetObfuscationExpressionResult:
 
     @property
     @pulumi.getter(name="accountId")
-    def account_id(self) -> Optional[int]:
+    def account_id(self) -> Optional[str]:
         return pulumi.get(self, "account_id")
 
     @property
@@ -62,7 +67,7 @@ class AwaitableGetObfuscationExpressionResult(GetObfuscationExpressionResult):
             name=self.name)
 
 
-def get_obfuscation_expression(account_id: Optional[int] = None,
+def get_obfuscation_expression(account_id: Optional[str] = None,
                                name: Optional[str] = None,
                                opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetObfuscationExpressionResult:
     """
@@ -74,21 +79,22 @@ def get_obfuscation_expression(account_id: Optional[int] = None,
     import pulumi
     import pulumi_newrelic as newrelic
 
-    expression = newrelic.get_obfuscation_expression(account_id=123456,
+    expression = newrelic.get_obfuscation_expression(account_id="123456",
         name="The expression")
     rule = newrelic.ObfuscationRule("rule",
+        name="ruleName",
         description="description of the rule",
         filter="hostStatus=running",
         enabled=True,
-        actions=[newrelic.ObfuscationRuleActionArgs(
-            attributes=["message"],
-            expression_id=expression.id,
-            method="MASK",
-        )])
+        actions=[{
+            "attributes": ["message"],
+            "expression_id": expression.id,
+            "method": "MASK",
+        }])
     ```
 
 
-    :param int account_id: The account id associated with the obfuscation expression. If left empty will default to account ID specified in provider level configuration.
+    :param str account_id: The account id associated with the obfuscation expression. If left empty will default to account ID specified in provider level configuration.
     :param str name: Name of expression.
     """
     __args__ = dict()
@@ -101,12 +107,9 @@ def get_obfuscation_expression(account_id: Optional[int] = None,
         account_id=pulumi.get(__ret__, 'account_id'),
         id=pulumi.get(__ret__, 'id'),
         name=pulumi.get(__ret__, 'name'))
-
-
-@_utilities.lift_output_func(get_obfuscation_expression)
-def get_obfuscation_expression_output(account_id: Optional[pulumi.Input[Optional[int]]] = None,
+def get_obfuscation_expression_output(account_id: Optional[pulumi.Input[Optional[str]]] = None,
                                       name: Optional[pulumi.Input[str]] = None,
-                                      opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetObfuscationExpressionResult]:
+                                      opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetObfuscationExpressionResult]:
     """
     Use this data source to get information about a specific Obfuscation Expression in New Relic that already exists.
 
@@ -116,21 +119,30 @@ def get_obfuscation_expression_output(account_id: Optional[pulumi.Input[Optional
     import pulumi
     import pulumi_newrelic as newrelic
 
-    expression = newrelic.get_obfuscation_expression(account_id=123456,
+    expression = newrelic.get_obfuscation_expression(account_id="123456",
         name="The expression")
     rule = newrelic.ObfuscationRule("rule",
+        name="ruleName",
         description="description of the rule",
         filter="hostStatus=running",
         enabled=True,
-        actions=[newrelic.ObfuscationRuleActionArgs(
-            attributes=["message"],
-            expression_id=expression.id,
-            method="MASK",
-        )])
+        actions=[{
+            "attributes": ["message"],
+            "expression_id": expression.id,
+            "method": "MASK",
+        }])
     ```
 
 
-    :param int account_id: The account id associated with the obfuscation expression. If left empty will default to account ID specified in provider level configuration.
+    :param str account_id: The account id associated with the obfuscation expression. If left empty will default to account ID specified in provider level configuration.
     :param str name: Name of expression.
     """
-    ...
+    __args__ = dict()
+    __args__['accountId'] = account_id
+    __args__['name'] = name
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('newrelic:index/getObfuscationExpression:getObfuscationExpression', __args__, opts=opts, typ=GetObfuscationExpressionResult)
+    return __ret__.apply(lambda __response__: GetObfuscationExpressionResult(
+        account_id=pulumi.get(__response__, 'account_id'),
+        id=pulumi.get(__response__, 'id'),
+        name=pulumi.get(__response__, 'name')))

pulumi_newrelic/get_service_level_alert_helper.py

@@ -4,9 +4,14 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
 
 __all__ = [
@@ -178,27 +183,28 @@ def get_service_level_alert_helper(alert_type: Optional[str] = None,
     foo_period = 28
     foo = newrelic.ServiceLevel("foo",
         guid="MXxBUE18QVBQTElDQVRJT058MQ",
+        name="Latency",
         description="Proportion of requests that are served faster than a threshold.",
-        events=newrelic.ServiceLevelEventsArgs(
-            account_id=12345678,
-            valid_events=newrelic.ServiceLevelEventsValidEventsArgs(
-                from_="Transaction",
-                where="appName = 'Example application' AND (transactionType='Web')",
-            ),
-            bad_events=newrelic.ServiceLevelEventsBadEventsArgs(
-                from_="Transaction",
-                where="appName = 'Example application' AND (transactionType= 'Web') AND duration > 0.1",
-            ),
-        ),
-        objective=newrelic.ServiceLevelObjectiveArgs(
-            target=foo_target,
-            time_window=newrelic.ServiceLevelObjectiveTimeWindowArgs(
-                rolling=newrelic.ServiceLevelObjectiveTimeWindowRollingArgs(
-                    count=foo_period,
-                    unit="DAY",
-                ),
-            ),
-        ))
+        events={
+            "account_id": "12345678",
+            "valid_events": {
+                "from_": "Transaction",
+                "where": "appName = 'Example application' AND (transactionType='Web')",
+            },
+            "bad_events": {
+                "from_": "Transaction",
+                "where": "appName = 'Example application' AND (transactionType= 'Web') AND duration > 0.1",
+            },
+        },
+        objective={
+            "target": foo_target,
+            "time_window": {
+                "rolling": {
+                    "count": foo_period,
+                    "unit": "DAY",
+                },
+            },
+        })
     ```
     Then use the helper to obtain the necessary fields to set up an alert on that Service Level.
     Note that the Service Level was set up using bad events, that's why `is_bad_events` is set to `true`.
@@ -211,25 +217,26 @@ def get_service_level_alert_helper(alert_type: Optional[str] = None,
     import pulumi_newrelic as newrelic
 
     foo_slow_burn = newrelic.get_service_level_alert_helper(alert_type="slow_burn",
-        sli_guid=newrelic_service_level["foo"]["sli_guid"],
-        slo_target=local["foo_target"],
-        slo_period=local["foo_period"],
+        sli_guid=foo["sliGuid"],
+        slo_target=foo_target,
+        slo_period=foo_period,
         is_bad_events=True)
-    your_condition = newrelic.NrqlAlertCondition("yourCondition",
-        account_id=12345678,
-        policy_id=67890,
+    your_condition = newrelic.NrqlAlertCondition("your_condition",
+        account_id="12345678",
+        policy_id="67890",
         type="static",
+        name="Slow burn alert",
         enabled=True,
         violation_time_limit_seconds=259200,
-        nrql=newrelic.NrqlAlertConditionNrqlArgs(
-            query=foo_slow_burn.nrql,
-        ),
-        critical=newrelic.NrqlAlertConditionCriticalArgs(
-            operator="above_or_equals",
-            threshold=foo_slow_burn.threshold,
-            threshold_duration=900,
-            threshold_occurrences="at_least_once",
-        ),
+        nrql={
+            "query": foo_slow_burn.nrql,
+        },
+        critical={
+            "operator": "above_or_equals",
+            "threshold": foo_slow_burn.threshold,
+            "threshold_duration": 900,
+            "threshold_occurrences": "at_least_once",
+        },
         fill_option="none",
         aggregation_window=foo_slow_burn.evaluation_period,
         aggregation_method="event_flow",
@@ -244,27 +251,28 @@ def get_service_level_alert_helper(alert_type: Optional[str] = None,
     import pulumi_newrelic as newrelic
 
     foo_custom = newrelic.get_service_level_alert_helper(alert_type="custom",
-        sli_guid=newrelic_service_level["foo"]["sli_guid"],
-        slo_target=local["foo_target"],
-        slo_period=local["foo_period"],
+        sli_guid=foo["sliGuid"],
+        slo_target=foo_target,
+        slo_period=foo_period,
         custom_tolerated_budget_consumption=4,
         custom_evaluation_period=5400,
         is_bad_events=True)
-    your_condition = newrelic.NrqlAlertCondition("yourCondition",
-        account_id=12345678,
-        policy_id=67890,
+    your_condition = newrelic.NrqlAlertCondition("your_condition",
+        account_id="12345678",
+        policy_id="67890",
         type="static",
+        name="Custom burn alert",
         enabled=True,
         violation_time_limit_seconds=259200,
-        nrql=newrelic.NrqlAlertConditionNrqlArgs(
-            query=foo_custom.nrql,
-        ),
-        critical=newrelic.NrqlAlertConditionCriticalArgs(
-            operator="above_or_equals",
-            threshold=foo_custom.threshold,
-            threshold_duration=900,
-            threshold_occurrences="at_least_once",
-        ),
+        nrql={
+            "query": foo_custom.nrql,
+        },
+        critical={
+            "operator": "above_or_equals",
+            "threshold": foo_custom.threshold,
+            "threshold_duration": 900,
+            "threshold_occurrences": "at_least_once",
+        },
         fill_option="none",
         aggregation_window=foo_custom.evaluation_period,
         aggregation_method="event_flow",
@@ -305,9 +313,6 @@ def get_service_level_alert_helper(alert_type: Optional[str] = None,
         slo_target=pulumi.get(__ret__, 'slo_target'),
         threshold=pulumi.get(__ret__, 'threshold'),
         tolerated_budget_consumption=pulumi.get(__ret__, 'tolerated_budget_consumption'))
-
-
-@_utilities.lift_output_func(get_service_level_alert_helper)
 def get_service_level_alert_helper_output(alert_type: Optional[pulumi.Input[str]] = None,
                                           custom_evaluation_period: Optional[pulumi.Input[Optional[int]]] = None,
                                           custom_tolerated_budget_consumption: Optional[pulumi.Input[Optional[float]]] = None,
@@ -315,7 +320,7 @@ def get_service_level_alert_helper_output(alert_type: Optional[pulumi.Input[str]
                                           sli_guid: Optional[pulumi.Input[str]] = None,
                                           slo_period: Optional[pulumi.Input[int]] = None,
                                           slo_target: Optional[pulumi.Input[float]] = None,
-                                          opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetServiceLevelAlertHelperResult]:
+                                          opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetServiceLevelAlertHelperResult]:
     """
     Use this data source to obtain the necessary fields to set up alerts on your service levels. It can be used for a `custom` alert_type in order to set up an alert with custom tolerated budget consumption and custom evaluation period or for recommended ones like `fast_burn` or `slow_burn`. For more information check [the documentation](https://docs.newrelic.com/docs/service-level-management/alerts-slm/).
 
@@ -331,27 +336,28 @@ def get_service_level_alert_helper_output(alert_type: Optional[pulumi.Input[str]
     foo_period = 28
     foo = newrelic.ServiceLevel("foo",
         guid="MXxBUE18QVBQTElDQVRJT058MQ",
+        name="Latency",
         description="Proportion of requests that are served faster than a threshold.",
-        events=newrelic.ServiceLevelEventsArgs(
-            account_id=12345678,
-            valid_events=newrelic.ServiceLevelEventsValidEventsArgs(
-                from_="Transaction",
-                where="appName = 'Example application' AND (transactionType='Web')",
-            ),
-            bad_events=newrelic.ServiceLevelEventsBadEventsArgs(
-                from_="Transaction",
-                where="appName = 'Example application' AND (transactionType= 'Web') AND duration > 0.1",
-            ),
-        ),
-        objective=newrelic.ServiceLevelObjectiveArgs(
-            target=foo_target,
-            time_window=newrelic.ServiceLevelObjectiveTimeWindowArgs(
-                rolling=newrelic.ServiceLevelObjectiveTimeWindowRollingArgs(
-                    count=foo_period,
-                    unit="DAY",
-                ),
-            ),
-        ))
+        events={
+            "account_id": "12345678",
+            "valid_events": {
+                "from_": "Transaction",
+                "where": "appName = 'Example application' AND (transactionType='Web')",
+            },
+            "bad_events": {
+                "from_": "Transaction",
+                "where": "appName = 'Example application' AND (transactionType= 'Web') AND duration > 0.1",
+            },
+        },
+        objective={
+            "target": foo_target,
+            "time_window": {
+                "rolling": {
+                    "count": foo_period,
+                    "unit": "DAY",
+                },
+            },
+        })
     ```
     Then use the helper to obtain the necessary fields to set up an alert on that Service Level.
     Note that the Service Level was set up using bad events, that's why `is_bad_events` is set to `true`.
@@ -364,25 +370,26 @@ def get_service_level_alert_helper_output(alert_type: Optional[pulumi.Input[str]
     import pulumi_newrelic as newrelic
 
     foo_slow_burn = newrelic.get_service_level_alert_helper(alert_type="slow_burn",
-        sli_guid=newrelic_service_level["foo"]["sli_guid"],
-        slo_target=local["foo_target"],
-        slo_period=local["foo_period"],
+        sli_guid=foo["sliGuid"],
+        slo_target=foo_target,
+        slo_period=foo_period,
         is_bad_events=True)
-    your_condition = newrelic.NrqlAlertCondition("yourCondition",
-        account_id=12345678,
-        policy_id=67890,
+    your_condition = newrelic.NrqlAlertCondition("your_condition",
+        account_id="12345678",
+        policy_id="67890",
         type="static",
+        name="Slow burn alert",
         enabled=True,
         violation_time_limit_seconds=259200,
-        nrql=newrelic.NrqlAlertConditionNrqlArgs(
-            query=foo_slow_burn.nrql,
-        ),
-        critical=newrelic.NrqlAlertConditionCriticalArgs(
-            operator="above_or_equals",
-            threshold=foo_slow_burn.threshold,
-            threshold_duration=900,
-            threshold_occurrences="at_least_once",
-        ),
+        nrql={
+            "query": foo_slow_burn.nrql,
+        },
+        critical={
+            "operator": "above_or_equals",
+            "threshold": foo_slow_burn.threshold,
+            "threshold_duration": 900,
+            "threshold_occurrences": "at_least_once",
+        },
         fill_option="none",
         aggregation_window=foo_slow_burn.evaluation_period,
         aggregation_method="event_flow",
@@ -397,27 +404,28 @@ def get_service_level_alert_helper_output(alert_type: Optional[pulumi.Input[str]
     import pulumi_newrelic as newrelic
 
     foo_custom = newrelic.get_service_level_alert_helper(alert_type="custom",
-        sli_guid=newrelic_service_level["foo"]["sli_guid"],
-        slo_target=local["foo_target"],
-        slo_period=local["foo_period"],
+        sli_guid=foo["sliGuid"],
+        slo_target=foo_target,
+        slo_period=foo_period,
         custom_tolerated_budget_consumption=4,
         custom_evaluation_period=5400,
         is_bad_events=True)
-    your_condition = newrelic.NrqlAlertCondition("yourCondition",
-        account_id=12345678,
-        policy_id=67890,
+    your_condition = newrelic.NrqlAlertCondition("your_condition",
+        account_id="12345678",
+        policy_id="67890",
         type="static",
+        name="Custom burn alert",
         enabled=True,
         violation_time_limit_seconds=259200,
-        nrql=newrelic.NrqlAlertConditionNrqlArgs(
-            query=foo_custom.nrql,
-        ),
-        critical=newrelic.NrqlAlertConditionCriticalArgs(
-            operator="above_or_equals",
-            threshold=foo_custom.threshold,
-            threshold_duration=900,
-            threshold_occurrences="at_least_once",
-        ),
+        nrql={
+            "query": foo_custom.nrql,
+        },
+        critical={
+            "operator": "above_or_equals",
+            "threshold": foo_custom.threshold,
+            "threshold_duration": 900,
+            "threshold_occurrences": "at_least_once",
+        },
         fill_option="none",
         aggregation_window=foo_custom.evaluation_period,
         aggregation_method="event_flow",
@@ -434,4 +442,26 @@ def get_service_level_alert_helper_output(alert_type: Optional[pulumi.Input[str]
     :param int slo_period: The time window of the Service Level Objective in days. Valid values are `1`, `7` and `28`.
     :param float slo_target: The target of the Service Level Objective, valid values between `0` and `100`.
     """
-    ...
+    __args__ = dict()
+    __args__['alertType'] = alert_type
+    __args__['customEvaluationPeriod'] = custom_evaluation_period
+    __args__['customToleratedBudgetConsumption'] = custom_tolerated_budget_consumption
+    __args__['isBadEvents'] = is_bad_events
+    __args__['sliGuid'] = sli_guid
+    __args__['sloPeriod'] = slo_period
+    __args__['sloTarget'] = slo_target
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('newrelic:index/getServiceLevelAlertHelper:getServiceLevelAlertHelper', __args__, opts=opts, typ=GetServiceLevelAlertHelperResult)
+    return __ret__.apply(lambda __response__: GetServiceLevelAlertHelperResult(
+        alert_type=pulumi.get(__response__, 'alert_type'),
+        custom_evaluation_period=pulumi.get(__response__, 'custom_evaluation_period'),
+        custom_tolerated_budget_consumption=pulumi.get(__response__, 'custom_tolerated_budget_consumption'),
+        evaluation_period=pulumi.get(__response__, 'evaluation_period'),
+        id=pulumi.get(__response__, 'id'),
+        is_bad_events=pulumi.get(__response__, 'is_bad_events'),
+        nrql=pulumi.get(__response__, 'nrql'),
+        sli_guid=pulumi.get(__response__, 'sli_guid'),
+        slo_period=pulumi.get(__response__, 'slo_period'),
+        slo_target=pulumi.get(__response__, 'slo_target'),
+        threshold=pulumi.get(__response__, 'threshold'),
+        tolerated_budget_consumption=pulumi.get(__response__, 'tolerated_budget_consumption')))