pulumi-newrelic 5.21.0a1710157101__py3-none-any.whl → 5.39.0a1736834464__py3-none-any.whl

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__ = [
@@ -170,7 +175,6 @@ def get_service_level_alert_helper(alert_type: Optional[str] = None,
 
     Firstly set up your service level objective, we recommend using local variables for the `target` and `time_window.rolling.count`, as they are also necessary for the helper.
 
-    <!--Start PulumiCodeChooser -->
     ```python
     import pulumi
     import pulumi_newrelic as newrelic
@@ -179,104 +183,102 @@ 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",
+                },
+            },
+        })
     ```
-    <!--End PulumiCodeChooser -->
     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`.
     If the Service Level was configured with good events that would be unnecessary as the field defaults to `false`.
 
     Here is an example of a `slow_burn` alert.
 
-    <!--Start PulumiCodeChooser -->
     ```python
     import pulumi
     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",
         aggregation_delay="120",
         slide_by=900)
     ```
-    <!--End PulumiCodeChooser -->
 
     Here is an example of a custom alert:
 
-    <!--Start PulumiCodeChooser -->
     ```python
     import pulumi
     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",
         aggregation_delay="120",
         slide_by=60)
     ```
-    <!--End PulumiCodeChooser -->
 
 
     :param str alert_type: The type of alert we want to set. Valid values are:
@@ -311,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,
@@ -321,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/).
 
@@ -329,7 +328,6 @@ def get_service_level_alert_helper_output(alert_type: Optional[pulumi.Input[str]
 
     Firstly set up your service level objective, we recommend using local variables for the `target` and `time_window.rolling.count`, as they are also necessary for the helper.
 
-    <!--Start PulumiCodeChooser -->
     ```python
     import pulumi
     import pulumi_newrelic as newrelic
@@ -338,104 +336,102 @@ 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",
+                },
+            },
+        })
     ```
-    <!--End PulumiCodeChooser -->
     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`.
     If the Service Level was configured with good events that would be unnecessary as the field defaults to `false`.
 
     Here is an example of a `slow_burn` alert.
 
-    <!--Start PulumiCodeChooser -->
     ```python
     import pulumi
     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",
         aggregation_delay="120",
         slide_by=900)
     ```
-    <!--End PulumiCodeChooser -->
 
     Here is an example of a custom alert:
 
-    <!--Start PulumiCodeChooser -->
     ```python
     import pulumi
     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",
         aggregation_delay="120",
         slide_by=60)
     ```
-    <!--End PulumiCodeChooser -->
 
 
     :param str alert_type: The type of alert we want to set. Valid values are:
@@ -446,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')))

pulumi_newrelic/get_test_grok_pattern.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
 from . import outputs
 
@@ -23,8 +28,8 @@ class GetTestGrokPatternResult:
     A collection of values returned by getTestGrokPattern.
     """
     def __init__(__self__, account_id=None, grok=None, id=None, log_lines=None, test_groks=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 grok and not isinstance(grok, str):
             raise TypeError("Expected argument 'grok' to be a str")
@@ -41,7 +46,7 @@ class GetTestGrokPatternResult:
 
     @property
     @pulumi.getter(name="accountId")
-    def account_id(self) -> Optional[int]:
+    def account_id(self) -> Optional[str]:
         return pulumi.get(self, "account_id")
 
     @property
@@ -84,28 +89,27 @@ class AwaitableGetTestGrokPatternResult(GetTestGrokPatternResult):
             test_groks=self.test_groks)
 
 
-def get_test_grok_pattern(account_id: Optional[int] = None,
+def get_test_grok_pattern(account_id: Optional[str] = None,
                           grok: Optional[str] = None,
                           log_lines: Optional[Sequence[str]] = None,
                           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetTestGrokPatternResult:
     """
     ## Example Usage
 
-    <!--Start PulumiCodeChooser -->
     ```python
     import pulumi
     import pulumi_newrelic as newrelic
 
-    foo = newrelic.get_test_grok_pattern(grok="%%{IP:host_ip}",
+    # Data source
+    foo = newrelic.get_test_grok_pattern(grok="%{IP:host_ip}",
         log_lines=[
             "host_ip: 43.3.120.2",
             "bytes_received: 2048",
         ])
     ```
-    <!--End PulumiCodeChooser -->
 
 
-    :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 grok: The Grok pattern to test.
     :param Sequence[str] log_lines: The log lines to test the Grok pattern against.
     """
@@ -122,32 +126,39 @@ def get_test_grok_pattern(account_id: Optional[int] = None,
         id=pulumi.get(__ret__, 'id'),
         log_lines=pulumi.get(__ret__, 'log_lines'),
         test_groks=pulumi.get(__ret__, 'test_groks'))
-
-
-@_utilities.lift_output_func(get_test_grok_pattern)
-def get_test_grok_pattern_output(account_id: Optional[pulumi.Input[Optional[int]]] = None,
+def get_test_grok_pattern_output(account_id: Optional[pulumi.Input[Optional[str]]] = None,
                                  grok: Optional[pulumi.Input[str]] = None,
                                  log_lines: Optional[pulumi.Input[Sequence[str]]] = None,
-                                 opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetTestGrokPatternResult]:
+                                 opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetTestGrokPatternResult]:
     """
     ## Example Usage
 
-    <!--Start PulumiCodeChooser -->
     ```python
     import pulumi
     import pulumi_newrelic as newrelic
 
-    foo = newrelic.get_test_grok_pattern(grok="%%{IP:host_ip}",
+    # Data source
+    foo = newrelic.get_test_grok_pattern(grok="%{IP:host_ip}",
         log_lines=[
             "host_ip: 43.3.120.2",
             "bytes_received: 2048",
         ])
     ```
-    <!--End PulumiCodeChooser -->
 
 
-    :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 grok: The Grok pattern to test.
     :param Sequence[str] log_lines: The log lines to test the Grok pattern against.
     """
-    ...
+    __args__ = dict()
+    __args__['accountId'] = account_id
+    __args__['grok'] = grok
+    __args__['logLines'] = log_lines
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('newrelic:index/getTestGrokPattern:getTestGrokPattern', __args__, opts=opts, typ=GetTestGrokPatternResult)
+    return __ret__.apply(lambda __response__: GetTestGrokPatternResult(
+        account_id=pulumi.get(__response__, 'account_id'),
+        grok=pulumi.get(__response__, 'grok'),
+        id=pulumi.get(__response__, 'id'),
+        log_lines=pulumi.get(__response__, 'log_lines'),
+        test_groks=pulumi.get(__response__, 'test_groks')))

pulumi_newrelic/get_user.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__ = [
@@ -81,7 +86,6 @@ def get_user(authentication_domain_id: Optional[str] = None,
     ## Example Usage
 
     The below example illustrates fetching a the ID of a user (and other arguments) using the ID of the authentication domain the user belongs to, as well as a name and/or email ID, which can be used as criteria to search for a user who matches these specified parameters.
-    <!--Start PulumiCodeChooser -->
     ```python
     import pulumi
     import pulumi_newrelic as newrelic
@@ -92,7 +96,6 @@ def get_user(authentication_domain_id: Optional[str] = None,
     user_two = newrelic.get_user(authentication_domain_id=foo.id,
         email_id="test_user@random.com")
     ```
-    <!--End PulumiCodeChooser -->
 
 
     :param str authentication_domain_id: The ID of the authentication domain the user to be searched for belongs to.
@@ -117,20 +120,16 @@ def get_user(authentication_domain_id: Optional[str] = None,
         email_id=pulumi.get(__ret__, 'email_id'),
         id=pulumi.get(__ret__, 'id'),
         name=pulumi.get(__ret__, 'name'))
-
-
-@_utilities.lift_output_func(get_user)
 def get_user_output(authentication_domain_id: Optional[pulumi.Input[str]] = None,
                     email_id: Optional[pulumi.Input[Optional[str]]] = None,
                     name: Optional[pulumi.Input[Optional[str]]] = None,
-                    opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetUserResult]:
+                    opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetUserResult]:
     """
     The `User` data source helps search for a user by their name and/or email ID, and accordingly, fetch the ID of the matching user.
 
     ## Example Usage
 
     The below example illustrates fetching a the ID of a user (and other arguments) using the ID of the authentication domain the user belongs to, as well as a name and/or email ID, which can be used as criteria to search for a user who matches these specified parameters.
-    <!--Start PulumiCodeChooser -->
     ```python
     import pulumi
     import pulumi_newrelic as newrelic
@@ -141,7 +140,6 @@ def get_user_output(authentication_domain_id: Optional[pulumi.Input[str]] = None
     user_two = newrelic.get_user(authentication_domain_id=foo.id,
         email_id="test_user@random.com")
     ```
-    <!--End PulumiCodeChooser -->
 
 
     :param str authentication_domain_id: The ID of the authentication domain the user to be searched for belongs to.
@@ -154,4 +152,14 @@ def get_user_output(authentication_domain_id: Optional[pulumi.Input[str]] = None
            > **NOTE** The ID of an authentication domain can be retrieved using its name, via the data source `get_authentication_domain`, as shown in the example above. Head over to the documentation of this data source for more details and examples.
     :param str name: The name of the user to search for.
     """
-    ...
+    __args__ = dict()
+    __args__['authenticationDomainId'] = authentication_domain_id
+    __args__['emailId'] = email_id
+    __args__['name'] = name
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('newrelic:index/getUser:getUser', __args__, opts=opts, typ=GetUserResult)
+    return __ret__.apply(lambda __response__: GetUserResult(
+        authentication_domain_id=pulumi.get(__response__, 'authentication_domain_id'),
+        email_id=pulumi.get(__response__, 'email_id'),
+        id=pulumi.get(__response__, 'id'),
+        name=pulumi.get(__response__, 'name')))