dbtcloud.getPrivatelinkEndpoint

import * as pulumi from "@pulumi/pulumi";
import * as dbtcloud from "@pulumi/dbtcloud";

const testWithName = dbtcloud.getPrivatelinkEndpoint({
    name: "My Endpoint Name",
});
const testWithUrl = dbtcloud.getPrivatelinkEndpoint({
    privateLinkEndpointUrl: "abc.privatelink.def.com",
});
// in case multiple endpoints have the same name or URL
const testWithNameAndUrl = dbtcloud.getPrivatelinkEndpoint({
    name: "My Endpoint Name",
    privateLinkEndpointUrl: "abc.privatelink.def.com",
});

import pulumi
import pulumi_dbtcloud as dbtcloud

test_with_name = dbtcloud.get_privatelink_endpoint(name="My Endpoint Name")
test_with_url = dbtcloud.get_privatelink_endpoint(private_link_endpoint_url="abc.privatelink.def.com")
# in case multiple endpoints have the same name or URL
test_with_name_and_url = dbtcloud.get_privatelink_endpoint(name="My Endpoint Name",
    private_link_endpoint_url="abc.privatelink.def.com")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dbtcloud.GetPrivatelinkEndpoint(ctx, &dbtcloud.GetPrivatelinkEndpointArgs{
			Name: pulumi.StringRef("My Endpoint Name"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = dbtcloud.GetPrivatelinkEndpoint(ctx, &dbtcloud.GetPrivatelinkEndpointArgs{
			PrivateLinkEndpointUrl: pulumi.StringRef("abc.privatelink.def.com"),
		}, nil)
		if err != nil {
			return err
		}
		// in case multiple endpoints have the same name or URL
		_, err = dbtcloud.GetPrivatelinkEndpoint(ctx, &dbtcloud.GetPrivatelinkEndpointArgs{
			Name:                   pulumi.StringRef("My Endpoint Name"),
			PrivateLinkEndpointUrl: pulumi.StringRef("abc.privatelink.def.com"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var testWithName = DbtCloud.GetPrivatelinkEndpoint.Invoke(new()
    {
        Name = "My Endpoint Name",
    });

    var testWithUrl = DbtCloud.GetPrivatelinkEndpoint.Invoke(new()
    {
        PrivateLinkEndpointUrl = "abc.privatelink.def.com",
    });

    // in case multiple endpoints have the same name or URL
    var testWithNameAndUrl = DbtCloud.GetPrivatelinkEndpoint.Invoke(new()
    {
        Name = "My Endpoint Name",
        PrivateLinkEndpointUrl = "abc.privatelink.def.com",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dbtcloud.DbtcloudFunctions;
import com.pulumi.dbtcloud.inputs.GetPrivatelinkEndpointArgs;
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 testWithName = DbtcloudFunctions.getPrivatelinkEndpoint(GetPrivatelinkEndpointArgs.builder()
            .name("My Endpoint Name")
            .build());

        final var testWithUrl = DbtcloudFunctions.getPrivatelinkEndpoint(GetPrivatelinkEndpointArgs.builder()
            .privateLinkEndpointUrl("abc.privatelink.def.com")
            .build());

        // in case multiple endpoints have the same name or URL
        final var testWithNameAndUrl = DbtcloudFunctions.getPrivatelinkEndpoint(GetPrivatelinkEndpointArgs.builder()
            .name("My Endpoint Name")
            .privateLinkEndpointUrl("abc.privatelink.def.com")
            .build());

    }
}

variables:
  testWithName:
    fn::invoke:
      function: dbtcloud:getPrivatelinkEndpoint
      arguments:
        name: My Endpoint Name
  testWithUrl:
    fn::invoke:
      function: dbtcloud:getPrivatelinkEndpoint
      arguments:
        privateLinkEndpointUrl: abc.privatelink.def.com
  # in case multiple endpoints have the same name or URL
  testWithNameAndUrl:
    fn::invoke:
      function: dbtcloud:getPrivatelinkEndpoint
      arguments:
        name: My Endpoint Name
        privateLinkEndpointUrl: abc.privatelink.def.com

function getPrivatelinkEndpoint(args: GetPrivatelinkEndpointArgs, opts?: InvokeOptions): Promise<GetPrivatelinkEndpointResult>
function getPrivatelinkEndpointOutput(args: GetPrivatelinkEndpointOutputArgs, opts?: InvokeOptions): Output<GetPrivatelinkEndpointResult>

def get_privatelink_endpoint(name: Optional[str] = None,
                             private_link_endpoint_url: Optional[str] = None,
                             type: Optional[str] = None,
                             opts: Optional[InvokeOptions] = None) -> GetPrivatelinkEndpointResult
def get_privatelink_endpoint_output(name: Optional[pulumi.Input[str]] = None,
                             private_link_endpoint_url: Optional[pulumi.Input[str]] = None,
                             type: Optional[pulumi.Input[str]] = None,
                             opts: Optional[InvokeOptions] = None) -> Output[GetPrivatelinkEndpointResult]

func GetPrivatelinkEndpoint(ctx *Context, args *GetPrivatelinkEndpointArgs, opts ...InvokeOption) (*GetPrivatelinkEndpointResult, error)
func GetPrivatelinkEndpointOutput(ctx *Context, args *GetPrivatelinkEndpointOutputArgs, opts ...InvokeOption) GetPrivatelinkEndpointResultOutput

public static class GetPrivatelinkEndpoint 
{
    public static Task<GetPrivatelinkEndpointResult> InvokeAsync(GetPrivatelinkEndpointArgs args, InvokeOptions? opts = null)
    public static Output<GetPrivatelinkEndpointResult> Invoke(GetPrivatelinkEndpointInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetPrivatelinkEndpointResult> getPrivatelinkEndpoint(GetPrivatelinkEndpointArgs args, InvokeOptions options)
public static Output<GetPrivatelinkEndpointResult> getPrivatelinkEndpoint(GetPrivatelinkEndpointArgs args, InvokeOptions options)

fn::invoke:
  function: dbtcloud:index/getPrivatelinkEndpoint:getPrivatelinkEndpoint
  arguments:
    # arguments dictionary