mongodbatlas.getStreamPrivatelinkEndpoints

import * as pulumi from "@pulumi/pulumi";
import * as confluent from "@pulumi/confluent";
import * as mongodbatlas from "@pulumi/mongodbatlas";
import * as std from "@pulumi/std";

const staging = new confluent.index.Environment("staging", {displayName: "Staging"});
const privateLink = new confluent.index.Network("private_link", {
    displayName: "terraform-test-private-link-network-manual",
    cloud: "AWS",
    region: awsRegion,
    connectionTypes: ["PRIVATELINK"],
    zones: std.index.keys({
        input: subnetsToPrivatelink,
    }).result,
    environment: [{
        id: staging.id,
    }],
    dnsConfig: [{
        resolution: "PRIVATE",
    }],
});
const aws = new confluent.index.PrivateLinkAccess("aws", {
    displayName: "example-private-link-access",
    aws: [{
        account: awsAccountId,
    }],
    environment: [{
        id: staging.id,
    }],
    network: [{
        id: privateLink.id,
    }],
});
const dedicated = new confluent.index.KafkaCluster("dedicated", {
    displayName: "example-dedicated-cluster",
    availability: "MULTI_ZONE",
    cloud: privateLink.cloud,
    region: privateLink.region,
    dedicated: [{
        cku: 2,
    }],
    environment: [{
        id: staging.id,
    }],
    network: [{
        id: privateLink.id,
    }],
});
const test = new mongodbatlas.StreamPrivatelinkEndpoint("test", {
    projectId: projectId,
    dnsDomain: privateLink.dnsDomain,
    providerName: "AWS",
    region: awsRegion,
    vendor: "CONFLUENT",
    serviceEndpointId: privateLink.aws[0].privateLinkEndpointService,
    dnsSubDomains: privateLink.zonalSubdomains,
});
const singularDatasource = test.id.apply(id => mongodbatlas.getStreamPrivatelinkEndpointOutput({
    projectId: projectId,
    id: id,
}));
const pluralDatasource = mongodbatlas.getStreamPrivatelinkEndpoints({
    projectId: projectId,
});
export const interfaceEndpointId = singularDatasource.apply(singularDatasource => singularDatasource.interfaceEndpointId);
export const interfaceEndpointIds = pluralDatasource.then(pluralDatasource => pluralDatasource.results.map(__item => __item.interfaceEndpointId));

import pulumi
import pulumi_confluent as confluent
import pulumi_mongodbatlas as mongodbatlas
import pulumi_std as std

staging = confluent.index.Environment("staging", display_name=Staging)
private_link = confluent.index.Network("private_link",
    display_name=terraform-test-private-link-network-manual,
    cloud=AWS,
    region=aws_region,
    connection_types=[PRIVATELINK],
    zones=std.index.keys(input=subnets_to_privatelink).result,
    environment=[{
        id: staging.id,
    }],
    dns_config=[{
        resolution: PRIVATE,
    }])
aws = confluent.index.PrivateLinkAccess("aws",
    display_name=example-private-link-access,
    aws=[{
        account: aws_account_id,
    }],
    environment=[{
        id: staging.id,
    }],
    network=[{
        id: private_link.id,
    }])
dedicated = confluent.index.KafkaCluster("dedicated",
    display_name=example-dedicated-cluster,
    availability=MULTI_ZONE,
    cloud=private_link.cloud,
    region=private_link.region,
    dedicated=[{
        cku: 2,
    }],
    environment=[{
        id: staging.id,
    }],
    network=[{
        id: private_link.id,
    }])
test = mongodbatlas.StreamPrivatelinkEndpoint("test",
    project_id=project_id,
    dns_domain=private_link["dnsDomain"],
    provider_name="AWS",
    region=aws_region,
    vendor="CONFLUENT",
    service_endpoint_id=private_link["aws"][0]["privateLinkEndpointService"],
    dns_sub_domains=private_link["zonalSubdomains"])
singular_datasource = test.id.apply(lambda id: mongodbatlas.get_stream_privatelink_endpoint_output(project_id=project_id,
    id=id))
plural_datasource = mongodbatlas.get_stream_privatelink_endpoints(project_id=project_id)
pulumi.export("interfaceEndpointId", singular_datasource.interface_endpoint_id)
pulumi.export("interfaceEndpointIds", [__item.interface_endpoint_id for __item in plural_datasource.results])

package main

import (
	"github.com/pulumi/pulumi-confluent/sdk/go/confluent"
	"github.com/pulumi/pulumi-mongodbatlas/sdk/v4/go/mongodbatlas"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
staging, err := confluent.NewEnvironment(ctx, "staging", &confluent.EnvironmentArgs{
DisplayName: "Staging",
})
if err != nil {
return err
}
privateLink, err := confluent.NewNetwork(ctx, "private_link", &confluent.NetworkArgs{
DisplayName: "terraform-test-private-link-network-manual",
Cloud: "AWS",
Region: awsRegion,
ConnectionTypes: []string{
"PRIVATELINK",
},
Zones: std.Keys(ctx, map[string]interface{}{
"input": subnetsToPrivatelink,
}, nil).Result,
Environment: []map[string]interface{}{
map[string]interface{}{
"id": staging.Id,
},
},
DnsConfig: []map[string]interface{}{
map[string]interface{}{
"resolution": "PRIVATE",
},
},
})
if err != nil {
return err
}
_, err = confluent.NewPrivateLinkAccess(ctx, "aws", &confluent.PrivateLinkAccessArgs{
DisplayName: "example-private-link-access",
Aws: []map[string]interface{}{
map[string]interface{}{
"account": awsAccountId,
},
},
Environment: []map[string]interface{}{
map[string]interface{}{
"id": staging.Id,
},
},
Network: []map[string]interface{}{
map[string]interface{}{
"id": privateLink.Id,
},
},
})
if err != nil {
return err
}
_, err = confluent.NewKafkaCluster(ctx, "dedicated", &confluent.KafkaClusterArgs{
DisplayName: "example-dedicated-cluster",
Availability: "MULTI_ZONE",
Cloud: privateLink.Cloud,
Region: privateLink.Region,
Dedicated: []map[string]interface{}{
map[string]interface{}{
"cku": 2,
},
},
Environment: []map[string]interface{}{
map[string]interface{}{
"id": staging.Id,
},
},
Network: []map[string]interface{}{
map[string]interface{}{
"id": privateLink.Id,
},
},
})
if err != nil {
return err
}
test, err := mongodbatlas.NewStreamPrivatelinkEndpoint(ctx, "test", &mongodbatlas.StreamPrivatelinkEndpointArgs{
ProjectId: pulumi.Any(projectId),
DnsDomain: privateLink.DnsDomain,
ProviderName: pulumi.String("AWS"),
Region: pulumi.Any(awsRegion),
Vendor: pulumi.String("CONFLUENT"),
ServiceEndpointId: privateLink.Aws[0].PrivateLinkEndpointService,
DnsSubDomains: privateLink.ZonalSubdomains,
})
if err != nil {
return err
}
singularDatasource := test.ID().ApplyT(func(id string) (mongodbatlas.GetStreamPrivatelinkEndpointResult, error) {
return mongodbatlas.GetStreamPrivatelinkEndpointResult(interface{}(mongodbatlas.LookupStreamPrivatelinkEndpoint(ctx, &mongodbatlas.LookupStreamPrivatelinkEndpointArgs{
ProjectId: projectId,
Id: id,
}, nil))), nil
}).(mongodbatlas.GetStreamPrivatelinkEndpointResultOutput)
pluralDatasource, err := mongodbatlas.LookupStreamPrivatelinkEndpoints(ctx, &mongodbatlas.LookupStreamPrivatelinkEndpointsArgs{
ProjectId: projectId,
}, nil);
if err != nil {
return err
}
ctx.Export("interfaceEndpointId", singularDatasource.ApplyT(func(singularDatasource mongodbatlas.GetStreamPrivatelinkEndpointResult) (*string, error) {
return &singularDatasource.InterfaceEndpointId, nil
}).(pulumi.StringPtrOutput))
ctx.Export("interfaceEndpointIds", pulumi.StringArray(%!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ example.pp:74,11-58)))
return nil
})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Confluent = Pulumi.Confluent;
using Mongodbatlas = Pulumi.Mongodbatlas;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var staging = new Confluent.Index.Environment("staging", new()
    {
        DisplayName = "Staging",
    });

    var privateLink = new Confluent.Index.Network("private_link", new()
    {
        DisplayName = "terraform-test-private-link-network-manual",
        Cloud = "AWS",
        Region = awsRegion,
        ConnectionTypes = new[]
        {
            "PRIVATELINK",
        },
        Zones = Std.Index.Keys.Invoke(new()
        {
            Input = subnetsToPrivatelink,
        }).Result,
        Environment = new[]
        {
            
            {
                { "id", staging.Id },
            },
        },
        DnsConfig = new[]
        {
            
            {
                { "resolution", "PRIVATE" },
            },
        },
    });

    var aws = new Confluent.Index.PrivateLinkAccess("aws", new()
    {
        DisplayName = "example-private-link-access",
        Aws = new[]
        {
            
            {
                { "account", awsAccountId },
            },
        },
        Environment = new[]
        {
            
            {
                { "id", staging.Id },
            },
        },
        Network = new[]
        {
            
            {
                { "id", privateLink.Id },
            },
        },
    });

    var dedicated = new Confluent.Index.KafkaCluster("dedicated", new()
    {
        DisplayName = "example-dedicated-cluster",
        Availability = "MULTI_ZONE",
        Cloud = privateLink.Cloud,
        Region = privateLink.Region,
        Dedicated = new[]
        {
            
            {
                { "cku", 2 },
            },
        },
        Environment = new[]
        {
            
            {
                { "id", staging.Id },
            },
        },
        Network = new[]
        {
            
            {
                { "id", privateLink.Id },
            },
        },
    });

    var test = new Mongodbatlas.StreamPrivatelinkEndpoint("test", new()
    {
        ProjectId = projectId,
        DnsDomain = privateLink.DnsDomain,
        ProviderName = "AWS",
        Region = awsRegion,
        Vendor = "CONFLUENT",
        ServiceEndpointId = privateLink.Aws[0].PrivateLinkEndpointService,
        DnsSubDomains = privateLink.ZonalSubdomains,
    });

    var singularDatasource = Mongodbatlas.GetStreamPrivatelinkEndpoint.Invoke(new()
    {
        ProjectId = projectId,
        Id = test.Id,
    });

    var pluralDatasource = Mongodbatlas.GetStreamPrivatelinkEndpoints.Invoke(new()
    {
        ProjectId = projectId,
    });

    return new Dictionary<string, object?>
    {
        ["interfaceEndpointId"] = singularDatasource.Apply(getStreamPrivatelinkEndpointResult => getStreamPrivatelinkEndpointResult.InterfaceEndpointId),
        ["interfaceEndpointIds"] = pluralDatasource.Apply(getStreamPrivatelinkEndpointsResult => getStreamPrivatelinkEndpointsResult.Results).Select(__item => __item.InterfaceEndpointId).ToList(),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.confluent.Environment;
import com.pulumi.confluent.EnvironmentArgs;
import com.pulumi.confluent.Network;
import com.pulumi.confluent.NetworkArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.confluent.PrivateLinkAccess;
import com.pulumi.confluent.PrivateLinkAccessArgs;
import com.pulumi.confluent.KafkaCluster;
import com.pulumi.confluent.KafkaClusterArgs;
import com.pulumi.mongodbatlas.StreamPrivatelinkEndpoint;
import com.pulumi.mongodbatlas.StreamPrivatelinkEndpointArgs;
import com.pulumi.mongodbatlas.MongodbatlasFunctions;
import com.pulumi.mongodbatlas.inputs.GetStreamPrivatelinkEndpointArgs;
import com.pulumi.mongodbatlas.inputs.GetStreamPrivatelinkEndpointsArgs;
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) {
        var staging = new Environment("staging", EnvironmentArgs.builder()
            .displayName("Staging")
            .build());

        var privateLink = new Network("privateLink", NetworkArgs.builder()
            .displayName("terraform-test-private-link-network-manual")
            .cloud("AWS")
            .region(awsRegion)
            .connectionTypes(List.of("PRIVATELINK"))
            .zones(StdFunctions.keys(Map.of("input", subnetsToPrivatelink)).result())
            .environment(List.of(Map.of("id", staging.id())))
            .dnsConfig(List.of(Map.of("resolution", "PRIVATE")))
            .build());

        var aws = new PrivateLinkAccess("aws", PrivateLinkAccessArgs.builder()
            .displayName("example-private-link-access")
            .aws(List.of(Map.of("account", awsAccountId)))
            .environment(List.of(Map.of("id", staging.id())))
            .network(List.of(Map.of("id", privateLink.id())))
            .build());

        var dedicated = new KafkaCluster("dedicated", KafkaClusterArgs.builder()
            .displayName("example-dedicated-cluster")
            .availability("MULTI_ZONE")
            .cloud(privateLink.cloud())
            .region(privateLink.region())
            .dedicated(List.of(Map.of("cku", 2)))
            .environment(List.of(Map.of("id", staging.id())))
            .network(List.of(Map.of("id", privateLink.id())))
            .build());

        var test = new StreamPrivatelinkEndpoint("test", StreamPrivatelinkEndpointArgs.builder()
            .projectId(projectId)
            .dnsDomain(privateLink.dnsDomain())
            .providerName("AWS")
            .region(awsRegion)
            .vendor("CONFLUENT")
            .serviceEndpointId(privateLink.aws()[0].privateLinkEndpointService())
            .dnsSubDomains(privateLink.zonalSubdomains())
            .build());

        final var singularDatasource = test.id().applyValue(_id -> MongodbatlasFunctions.getStreamPrivatelinkEndpoint(GetStreamPrivatelinkEndpointArgs.builder()
            .projectId(projectId)
            .id(_id)
            .build()));

        final var pluralDatasource = MongodbatlasFunctions.getStreamPrivatelinkEndpoints(GetStreamPrivatelinkEndpointsArgs.builder()
            .projectId(projectId)
            .build());

        ctx.export("interfaceEndpointId", singularDatasource.applyValue(_singularDatasource -> _singularDatasource.interfaceEndpointId()));
        ctx.export("interfaceEndpointIds", pluralDatasource.results().stream().map(element -> element.interfaceEndpointId()).collect(toList()));
    }
}

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as mongodbatlas from "@pulumi/mongodbatlas";

// S3 bucket for stream data
const streamBucket = new aws.index.S3Bucket("stream_bucket", {
    bucket: s3BucketName,
    forceDestroy: true,
});
const streamBucketVersioning = new aws.index.S3BucketVersioning("stream_bucket_versioning", {
    bucket: streamBucket.id,
    versioningConfiguration: [{
        status: "Enabled",
    }],
});
const streamBucketEncryption = new aws.index.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption", {
    bucket: streamBucket.id,
    rule: [{
        applyServerSideEncryptionByDefault: [{
            sseAlgorithm: "AES256",
        }],
    }],
});
// PrivateLink for S3
const _this = new mongodbatlas.StreamPrivatelinkEndpoint("this", {
    projectId: projectId,
    providerName: "AWS",
    vendor: "S3",
    region: region,
    serviceEndpointId: serviceEndpointId,
});
export const privatelinkEndpointId = _this.id;

import pulumi
import pulumi_aws as aws
import pulumi_mongodbatlas as mongodbatlas

# S3 bucket for stream data
stream_bucket = aws.index.S3Bucket("stream_bucket",
    bucket=s3_bucket_name,
    force_destroy=True)
stream_bucket_versioning = aws.index.S3BucketVersioning("stream_bucket_versioning",
    bucket=stream_bucket.id,
    versioning_configuration=[{
        status: Enabled,
    }])
stream_bucket_encryption = aws.index.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption",
    bucket=stream_bucket.id,
    rule=[{
        applyServerSideEncryptionByDefault: [{
            sseAlgorithm: AES256,
        }],
    }])
# PrivateLink for S3
this = mongodbatlas.StreamPrivatelinkEndpoint("this",
    project_id=project_id,
    provider_name="AWS",
    vendor="S3",
    region=region,
    service_endpoint_id=service_endpoint_id)
pulumi.export("privatelinkEndpointId", this.id)

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws"
	"github.com/pulumi/pulumi-mongodbatlas/sdk/v4/go/mongodbatlas"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// S3 bucket for stream data
		streamBucket, err := aws.NewS3Bucket(ctx, "stream_bucket", &aws.S3BucketArgs{
			Bucket:       s3BucketName,
			ForceDestroy: true,
		})
		if err != nil {
			return err
		}
		_, err = aws.NewS3BucketVersioning(ctx, "stream_bucket_versioning", &aws.S3BucketVersioningArgs{
			Bucket: streamBucket.Id,
			VersioningConfiguration: []map[string]interface{}{
				map[string]interface{}{
					"status": "Enabled",
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = aws.NewS3BucketServerSideEncryptionConfiguration(ctx, "stream_bucket_encryption", &aws.S3BucketServerSideEncryptionConfigurationArgs{
			Bucket: streamBucket.Id,
			Rule: []map[string]interface{}{
				map[string]interface{}{
					"applyServerSideEncryptionByDefault": []map[string]interface{}{
						map[string]interface{}{
							"sseAlgorithm": "AES256",
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// PrivateLink for S3
		this, err := mongodbatlas.NewStreamPrivatelinkEndpoint(ctx, "this", &mongodbatlas.StreamPrivatelinkEndpointArgs{
			ProjectId:         pulumi.Any(projectId),
			ProviderName:      pulumi.String("AWS"),
			Vendor:            pulumi.String("S3"),
			Region:            pulumi.Any(region),
			ServiceEndpointId: pulumi.Any(serviceEndpointId),
		})
		if err != nil {
			return err
		}
		ctx.Export("privatelinkEndpointId", this.ID())
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Mongodbatlas = Pulumi.Mongodbatlas;

return await Deployment.RunAsync(() => 
{
    // S3 bucket for stream data
    var streamBucket = new Aws.Index.S3Bucket("stream_bucket", new()
    {
        Bucket = s3BucketName,
        ForceDestroy = true,
    });

    var streamBucketVersioning = new Aws.Index.S3BucketVersioning("stream_bucket_versioning", new()
    {
        Bucket = streamBucket.Id,
        VersioningConfiguration = new[]
        {
            
            {
                { "status", "Enabled" },
            },
        },
    });

    var streamBucketEncryption = new Aws.Index.S3BucketServerSideEncryptionConfiguration("stream_bucket_encryption", new()
    {
        Bucket = streamBucket.Id,
        Rule = new[]
        {
            
            {
                { "applyServerSideEncryptionByDefault", new[]
                {
                    
                    {
                        { "sseAlgorithm", "AES256" },
                    },
                } },
            },
        },
    });

    // PrivateLink for S3
    var @this = new Mongodbatlas.StreamPrivatelinkEndpoint("this", new()
    {
        ProjectId = projectId,
        ProviderName = "AWS",
        Vendor = "S3",
        Region = region,
        ServiceEndpointId = serviceEndpointId,
    });

    return new Dictionary<string, object?>
    {
        ["privatelinkEndpointId"] = @this.Id,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.S3Bucket;
import com.pulumi.aws.S3BucketArgs;
import com.pulumi.aws.S3BucketVersioning;
import com.pulumi.aws.S3BucketVersioningArgs;
import com.pulumi.aws.S3BucketServerSideEncryptionConfiguration;
import com.pulumi.aws.S3BucketServerSideEncryptionConfigurationArgs;
import com.pulumi.mongodbatlas.StreamPrivatelinkEndpoint;
import com.pulumi.mongodbatlas.StreamPrivatelinkEndpointArgs;
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) {
        // S3 bucket for stream data
        var streamBucket = new S3Bucket("streamBucket", S3BucketArgs.builder()
            .bucket(s3BucketName)
            .forceDestroy(true)
            .build());

        var streamBucketVersioning = new S3BucketVersioning("streamBucketVersioning", S3BucketVersioningArgs.builder()
            .bucket(streamBucket.id())
            .versioningConfiguration(List.of(Map.of("status", "Enabled")))
            .build());

        var streamBucketEncryption = new S3BucketServerSideEncryptionConfiguration("streamBucketEncryption", S3BucketServerSideEncryptionConfigurationArgs.builder()
            .bucket(streamBucket.id())
            .rule(List.of(Map.of("applyServerSideEncryptionByDefault", List.of(Map.of("sseAlgorithm", "AES256")))))
            .build());

        // PrivateLink for S3
        var this_ = new StreamPrivatelinkEndpoint("this", StreamPrivatelinkEndpointArgs.builder()
            .projectId(projectId)
            .providerName("AWS")
            .vendor("S3")
            .region(region)
            .serviceEndpointId(serviceEndpointId)
            .build());

        ctx.export("privatelinkEndpointId", this_.id());
    }
}

resources:
  # S3 bucket for stream data
  streamBucket:
    type: aws:S3Bucket
    name: stream_bucket
    properties:
      bucket: ${s3BucketName}
      forceDestroy: true
  streamBucketVersioning:
    type: aws:S3BucketVersioning
    name: stream_bucket_versioning
    properties:
      bucket: ${streamBucket.id}
      versioningConfiguration:
        - status: Enabled
  streamBucketEncryption:
    type: aws:S3BucketServerSideEncryptionConfiguration
    name: stream_bucket_encryption
    properties:
      bucket: ${streamBucket.id}
      rule:
        - applyServerSideEncryptionByDefault:
            - sseAlgorithm: AES256
  # PrivateLink for S3
  this:
    type: mongodbatlas:StreamPrivatelinkEndpoint
    properties:
      projectId: ${projectId}
      providerName: AWS
      vendor: S3
      region: ${region}
      serviceEndpointId: ${serviceEndpointId}
outputs:
  privatelinkEndpointId: ${this.id}

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

const gcpConfluentStreamPrivatelinkEndpoint = new mongodbatlas.StreamPrivatelinkEndpoint("gcp_confluent", {
    projectId: projectId,
    providerName: "GCP",
    vendor: "CONFLUENT",
    region: gcpRegion,
    dnsDomain: confluentDnsDomain,
    dnsSubDomains: confluentDnsSubdomains,
    serviceAttachmentUris: [
        "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-1",
        "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-2",
    ],
});
const gcpConfluent = gcpConfluentStreamPrivatelinkEndpoint.id.apply(id => mongodbatlas.getStreamPrivatelinkEndpointOutput({
    projectId: projectId,
    id: id,
}));
export const privatelinkEndpointId = gcpConfluentStreamPrivatelinkEndpoint.id;
export const privatelinkEndpointState = gcpConfluent.apply(gcpConfluent => gcpConfluent.state);
export const serviceAttachmentUris = gcpConfluentStreamPrivatelinkEndpoint.serviceAttachmentUris;

import pulumi
import pulumi_mongodbatlas as mongodbatlas

gcp_confluent_stream_privatelink_endpoint = mongodbatlas.StreamPrivatelinkEndpoint("gcp_confluent",
    project_id=project_id,
    provider_name="GCP",
    vendor="CONFLUENT",
    region=gcp_region,
    dns_domain=confluent_dns_domain,
    dns_sub_domains=confluent_dns_subdomains,
    service_attachment_uris=[
        "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-1",
        "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-2",
    ])
gcp_confluent = gcp_confluent_stream_privatelink_endpoint.id.apply(lambda id: mongodbatlas.get_stream_privatelink_endpoint_output(project_id=project_id,
    id=id))
pulumi.export("privatelinkEndpointId", gcp_confluent_stream_privatelink_endpoint.id)
pulumi.export("privatelinkEndpointState", gcp_confluent.state)
pulumi.export("serviceAttachmentUris", gcp_confluent_stream_privatelink_endpoint.service_attachment_uris)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		gcpConfluentStreamPrivatelinkEndpoint, err := mongodbatlas.NewStreamPrivatelinkEndpoint(ctx, "gcp_confluent", &mongodbatlas.StreamPrivatelinkEndpointArgs{
			ProjectId:     pulumi.Any(projectId),
			ProviderName:  pulumi.String("GCP"),
			Vendor:        pulumi.String("CONFLUENT"),
			Region:        pulumi.Any(gcpRegion),
			DnsDomain:     pulumi.Any(confluentDnsDomain),
			DnsSubDomains: pulumi.Any(confluentDnsSubdomains),
			ServiceAttachmentUris: pulumi.StringArray{
				pulumi.String("projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-1"),
				pulumi.String("projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-2"),
			},
		})
		if err != nil {
			return err
		}
		gcpConfluent := gcpConfluentStreamPrivatelinkEndpoint.ID().ApplyT(func(id string) (mongodbatlas.GetStreamPrivatelinkEndpointResult, error) {
			return mongodbatlas.GetStreamPrivatelinkEndpointResult(interface{}(mongodbatlas.LookupStreamPrivatelinkEndpoint(ctx, &mongodbatlas.LookupStreamPrivatelinkEndpointArgs{
				ProjectId: projectId,
				Id:        id,
			}, nil))), nil
		}).(mongodbatlas.GetStreamPrivatelinkEndpointResultOutput)
		ctx.Export("privatelinkEndpointId", gcpConfluentStreamPrivatelinkEndpoint.ID())
		ctx.Export("privatelinkEndpointState", gcpConfluent.ApplyT(func(gcpConfluent mongodbatlas.GetStreamPrivatelinkEndpointResult) (*string, error) {
			return &gcpConfluent.State, nil
		}).(pulumi.StringPtrOutput))
		ctx.Export("serviceAttachmentUris", gcpConfluentStreamPrivatelinkEndpoint.ServiceAttachmentUris)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var gcpConfluentStreamPrivatelinkEndpoint = new Mongodbatlas.StreamPrivatelinkEndpoint("gcp_confluent", new()
    {
        ProjectId = projectId,
        ProviderName = "GCP",
        Vendor = "CONFLUENT",
        Region = gcpRegion,
        DnsDomain = confluentDnsDomain,
        DnsSubDomains = confluentDnsSubdomains,
        ServiceAttachmentUris = new[]
        {
            "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-1",
            "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-2",
        },
    });

    var gcpConfluent = Mongodbatlas.GetStreamPrivatelinkEndpoint.Invoke(new()
    {
        ProjectId = projectId,
        Id = gcpConfluentStreamPrivatelinkEndpoint.Id,
    });

    return new Dictionary<string, object?>
    {
        ["privatelinkEndpointId"] = gcpConfluentStreamPrivatelinkEndpoint.Id,
        ["privatelinkEndpointState"] = gcpConfluent.Apply(getStreamPrivatelinkEndpointResult => getStreamPrivatelinkEndpointResult.State),
        ["serviceAttachmentUris"] = gcpConfluentStreamPrivatelinkEndpoint.ServiceAttachmentUris,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.StreamPrivatelinkEndpoint;
import com.pulumi.mongodbatlas.StreamPrivatelinkEndpointArgs;
import com.pulumi.mongodbatlas.MongodbatlasFunctions;
import com.pulumi.mongodbatlas.inputs.GetStreamPrivatelinkEndpointArgs;
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) {
        var gcpConfluentStreamPrivatelinkEndpoint = new StreamPrivatelinkEndpoint("gcpConfluentStreamPrivatelinkEndpoint", StreamPrivatelinkEndpointArgs.builder()
            .projectId(projectId)
            .providerName("GCP")
            .vendor("CONFLUENT")
            .region(gcpRegion)
            .dnsDomain(confluentDnsDomain)
            .dnsSubDomains(confluentDnsSubdomains)
            .serviceAttachmentUris(            
                "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-1",
                "projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-2")
            .build());

        final var gcpConfluent = gcpConfluentStreamPrivatelinkEndpoint.id().applyValue(_id -> MongodbatlasFunctions.getStreamPrivatelinkEndpoint(GetStreamPrivatelinkEndpointArgs.builder()
            .projectId(projectId)
            .id(_id)
            .build()));

        ctx.export("privatelinkEndpointId", gcpConfluentStreamPrivatelinkEndpoint.id());
        ctx.export("privatelinkEndpointState", gcpConfluent.applyValue(_gcpConfluent -> _gcpConfluent.state()));
        ctx.export("serviceAttachmentUris", gcpConfluentStreamPrivatelinkEndpoint.serviceAttachmentUris());
    }
}

resources:
  gcpConfluentStreamPrivatelinkEndpoint:
    type: mongodbatlas:StreamPrivatelinkEndpoint
    name: gcp_confluent
    properties:
      projectId: ${projectId}
      providerName: GCP
      vendor: CONFLUENT
      region: ${gcpRegion}
      dnsDomain: ${confluentDnsDomain}
      dnsSubDomains: ${confluentDnsSubdomains}
      serviceAttachmentUris:
        - projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-1
        - projects/my-project/regions/us-west1/serviceAttachments/confluent-attachment-2
variables:
  gcpConfluent:
    fn::invoke:
      function: mongodbatlas:getStreamPrivatelinkEndpoint
      arguments:
        projectId: ${projectId}
        id: ${gcpConfluentStreamPrivatelinkEndpoint.id}
outputs:
  privatelinkEndpointId: ${gcpConfluentStreamPrivatelinkEndpoint.id}
  privatelinkEndpointState: ${gcpConfluent.state}
  serviceAttachmentUris: ${gcpConfluentStreamPrivatelinkEndpoint.serviceAttachmentUris}

function getStreamPrivatelinkEndpoints(args: GetStreamPrivatelinkEndpointsArgs, opts?: InvokeOptions): Promise<GetStreamPrivatelinkEndpointsResult>
function getStreamPrivatelinkEndpointsOutput(args: GetStreamPrivatelinkEndpointsOutputArgs, opts?: InvokeOptions): Output<GetStreamPrivatelinkEndpointsResult>

def get_stream_privatelink_endpoints(project_id: Optional[str] = None,
                                     opts: Optional[InvokeOptions] = None) -> GetStreamPrivatelinkEndpointsResult
def get_stream_privatelink_endpoints_output(project_id: Optional[pulumi.Input[str]] = None,
                                     opts: Optional[InvokeOptions] = None) -> Output[GetStreamPrivatelinkEndpointsResult]

func LookupStreamPrivatelinkEndpoints(ctx *Context, args *LookupStreamPrivatelinkEndpointsArgs, opts ...InvokeOption) (*LookupStreamPrivatelinkEndpointsResult, error)
func LookupStreamPrivatelinkEndpointsOutput(ctx *Context, args *LookupStreamPrivatelinkEndpointsOutputArgs, opts ...InvokeOption) LookupStreamPrivatelinkEndpointsResultOutput

public static class GetStreamPrivatelinkEndpoints 
{
    public static Task<GetStreamPrivatelinkEndpointsResult> InvokeAsync(GetStreamPrivatelinkEndpointsArgs args, InvokeOptions? opts = null)
    public static Output<GetStreamPrivatelinkEndpointsResult> Invoke(GetStreamPrivatelinkEndpointsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetStreamPrivatelinkEndpointsResult> getStreamPrivatelinkEndpoints(GetStreamPrivatelinkEndpointsArgs args, InvokeOptions options)
public static Output<GetStreamPrivatelinkEndpointsResult> getStreamPrivatelinkEndpoints(GetStreamPrivatelinkEndpointsArgs args, InvokeOptions options)

fn::invoke:
  function: mongodbatlas:index/getStreamPrivatelinkEndpoints:getStreamPrivatelinkEndpoints
  arguments:
    # arguments dictionary