newrelic.getAuthenticationDomain

import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.get_authentication_domain(name="Test Authentication Domain")
pulumi.export("foo", foo.id)

package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v5/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foo, err := newrelic.GetAuthenticationDomain(ctx, &newrelic.GetAuthenticationDomainArgs{
			Name: "Test Authentication Domain",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("foo", foo.Id)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using NewRelic = Pulumi.NewRelic;

return await Deployment.RunAsync(() => 
{
    var foo = NewRelic.GetAuthenticationDomain.Invoke(new()
    {
        Name = "Test Authentication Domain",
    });

    return new Dictionary<string, object?>
    {
        ["foo"] = foo.Apply(getAuthenticationDomainResult => getAuthenticationDomainResult.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.NewrelicFunctions;
import com.pulumi.newrelic.inputs.GetAuthenticationDomainArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var foo = NewrelicFunctions.getAuthenticationDomain(GetAuthenticationDomainArgs.builder()
            .name("Test Authentication Domain")
            .build());

        ctx.export("foo", foo.id());
    }
}

variables:
  foo:
    fn::invoke:
      function: newrelic:getAuthenticationDomain
      arguments:
        name: Test Authentication Domain
outputs:
  foo: ${foo.id}

def get_authentication_domain(name: Optional[str] = None,
                              opts: Optional[InvokeOptions] = None) -> GetAuthenticationDomainResult
def get_authentication_domain_output(name: Optional[pulumi.Input[str]] = None,
                              opts: Optional[InvokeOptions] = None) -> Output[GetAuthenticationDomainResult]

func GetAuthenticationDomain(ctx *Context, args *GetAuthenticationDomainArgs, opts ...InvokeOption) (*GetAuthenticationDomainResult, error)
func GetAuthenticationDomainOutput(ctx *Context, args *GetAuthenticationDomainOutputArgs, opts ...InvokeOption) GetAuthenticationDomainResultOutput

public static class GetAuthenticationDomain 
{
    public static Task<GetAuthenticationDomainResult> InvokeAsync(GetAuthenticationDomainArgs args, InvokeOptions? opts = null)
    public static Output<GetAuthenticationDomainResult> Invoke(GetAuthenticationDomainInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetAuthenticationDomainResult> getAuthenticationDomain(GetAuthenticationDomainArgs args, InvokeOptions options)
public static Output<GetAuthenticationDomainResult> getAuthenticationDomain(GetAuthenticationDomainArgs args, InvokeOptions options)

fn::invoke:
  function: newrelic:index/getAuthenticationDomain:getAuthenticationDomain
  arguments:
    # arguments dictionary