dbtcloud.getPrivatelinkEndpoints

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

export = async () => {
    const all = await dbtcloud.getPrivatelinkEndpoints({});
    const snowflakeEndpoint = .filter(endpoint => endpoint.name == "Snowflake Production Endpoint").map(endpoint => (endpoint))[0];
    // Use the endpoint in a global connection
    const snowflake = new dbtcloud.GlobalConnection("snowflake", {
        name: "Snowflake via PrivateLink",
        privateLinkEndpointId: snowflakeEndpoint.id,
        snowflake: {
            account: "my-snowflake-account",
            database: "ANALYTICS",
            warehouse: "COMPUTE_WH",
        },
    });
    const snowflakeEndpoints = .filter(endpoint => endpoint.type == "snowflake").map(endpoint => (endpoint));
    // Create connections for all Snowflake endpoints
    const snowflakeConnections: dbtcloud.GlobalConnection[] = [];
    for (const range of Object.entries(.reduce((__obj, ep) => ({ ...__obj, [ep.id]: ep }))).map(([k, v]) => ({key: k, value: v}))) {
        snowflakeConnections.push(new dbtcloud.GlobalConnection(`snowflake_connections-${range.key}`, {
            name: `Connection for ${range.value.name}`,
            privateLinkEndpointId: range.value.id,
            snowflake: {
                account: "my-account",
                database: "ANALYTICS",
                warehouse: "COMPUTE_WH",
            },
        }));
    }
}

import pulumi
import pulumi_dbtcloud as dbtcloud

all = dbtcloud.get_privatelink_endpoints()
snowflake_endpoint = [endpoint for endpoint in all.endpoints if endpoint.name == "Snowflake Production Endpoint"][0]
# Use the endpoint in a global connection
snowflake = dbtcloud.GlobalConnection("snowflake",
    name="Snowflake via PrivateLink",
    private_link_endpoint_id=snowflake_endpoint.id,
    snowflake={
        "account": "my-snowflake-account",
        "database": "ANALYTICS",
        "warehouse": "COMPUTE_WH",
    })
snowflake_endpoints = [endpoint for endpoint in all.endpoints if endpoint.type == "snowflake"]
# Create connections for all Snowflake endpoints
snowflake_connections = []
for range in [{"key": k, "value": v} for [k, v] in enumerate({ep.id: ep for ep in snowflake_endpoints})]:
    snowflake_connections.append(dbtcloud.GlobalConnection(f"snowflake_connections-{range['key']}",
        name=f"Connection for {range['value'].name}",
        private_link_endpoint_id=%!v(PANIC=Format method: runtime error: index out of range [-1]),
        snowflake={
            "account": "my-account",
            "database": "ANALYTICS",
            "warehouse": "COMPUTE_WH",
        }))

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

return await Deployment.RunAsync(async() => 
{
    var all = await DbtCloud.GetPrivatelinkEndpoints.InvokeAsync();

    var snowflakeEndpoint = [0];

    // Use the endpoint in a global connection
    var snowflake = new DbtCloud.GlobalConnection("snowflake", new()
    {
        Name = "Snowflake via PrivateLink",
        PrivateLinkEndpointId = snowflakeEndpoint.Id,
        Snowflake = new DbtCloud.Inputs.GlobalConnectionSnowflakeArgs
        {
            Account = "my-snowflake-account",
            Database = "ANALYTICS",
            Warehouse = "COMPUTE_WH",
        },
    });

    var snowflakeEndpoints = ;

    // Create connections for all Snowflake endpoints
    var snowflakeConnections = new List<DbtCloud.GlobalConnection>();
    foreach (var range in .Select(pair => new { pair.Key, pair.Value }))
    {
        snowflakeConnections.Add(new DbtCloud.GlobalConnection($"snowflake_connections-{range.Key}", new()
        {
            Name = $"Connection for {range.Value.Name}",
            PrivateLinkEndpointId = range.Value.Id,
            Snowflake = new DbtCloud.Inputs.GlobalConnectionSnowflakeArgs
            {
                Account = "my-account",
                Database = "ANALYTICS",
                Warehouse = "COMPUTE_WH",
            },
        }));
    }
});

function getPrivatelinkEndpoints(opts?: InvokeOptions): Promise<GetPrivatelinkEndpointsResult>
function getPrivatelinkEndpointsOutput(opts?: InvokeOptions): Output<GetPrivatelinkEndpointsResult>

def get_privatelink_endpoints(opts: Optional[InvokeOptions] = None) -> GetPrivatelinkEndpointsResult
def get_privatelink_endpoints_output(opts: Optional[InvokeOptions] = None) -> Output[GetPrivatelinkEndpointsResult]

func GetPrivatelinkEndpoints(ctx *Context, opts ...InvokeOption) (*GetPrivatelinkEndpointsResult, error)
func GetPrivatelinkEndpointsOutput(ctx *Context, opts ...InvokeOption) GetPrivatelinkEndpointsResultOutput

public static class GetPrivatelinkEndpoints 
{
    public static Task<GetPrivatelinkEndpointsResult> InvokeAsync(InvokeOptions? opts = null)
    public static Output<GetPrivatelinkEndpointsResult> Invoke(InvokeOptions? opts = null)
}

public static CompletableFuture<GetPrivatelinkEndpointsResult> getPrivatelinkEndpoints(InvokeOptions options)
public static Output<GetPrivatelinkEndpointsResult> getPrivatelinkEndpoints(InvokeOptions options)

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