@pulumi/mongodbatlas 3.37.0-alpha.1762842753 → 3.37.0-alpha.1763072353

package/getFlexClusters.d.ts

@@ -8,6 +8,31 @@ import * as outputs from "./types/output";
  * **RECOMMENDATION:** We recommend using the `mongodbatlas.getAdvancedClusters` data source instead of the `mongodbatlas.getFlexClusters` data source to retrieve Flex clusters. The `mongodbatlas.getAdvancedClusters` data source not only supports Flex clusters, but also supports free and dedicated clusters, providing easier migration between different cluster types. For more information, see the Advanced Clusters data source.
  *
  * ## Example Usage
+ *
+ * ### S
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const example_clusterFlexCluster = new mongodbatlas.FlexCluster("example-cluster", {
+ *     projectId: projectId,
+ *     name: clusterName,
+ *     providerSettings: {
+ *         backingProviderName: "AWS",
+ *         regionName: "US_EAST_1",
+ *     },
+ *     terminationProtectionEnabled: true,
+ * });
+ * const example_cluster = example_clusterFlexCluster.name.apply(name => mongodbatlas.getFlexClusterOutput({
+ *     projectId: projectId,
+ *     name: name,
+ * }));
+ * const example_clusters = mongodbatlas.getFlexClusters({
+ *     projectId: projectId,
+ * });
+ * export const mongodbatlasFlexCluster = example_cluster.apply(example_cluster => example_cluster.name);
+ * export const mongodbatlasFlexClustersNames = example_clusters.then(example_clusters => .map(cluster => (cluster.name)));
+ * ```
  */
 export declare function getFlexClusters(args: GetFlexClustersArgs, opts?: pulumi.InvokeOptions): Promise<GetFlexClustersResult>;
 /**
@@ -44,6 +69,31 @@ export interface GetFlexClustersResult {
  * **RECOMMENDATION:** We recommend using the `mongodbatlas.getAdvancedClusters` data source instead of the `mongodbatlas.getFlexClusters` data source to retrieve Flex clusters. The `mongodbatlas.getAdvancedClusters` data source not only supports Flex clusters, but also supports free and dedicated clusters, providing easier migration between different cluster types. For more information, see the Advanced Clusters data source.
  *
  * ## Example Usage
+ *
+ * ### S
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const example_clusterFlexCluster = new mongodbatlas.FlexCluster("example-cluster", {
+ *     projectId: projectId,
+ *     name: clusterName,
+ *     providerSettings: {
+ *         backingProviderName: "AWS",
+ *         regionName: "US_EAST_1",
+ *     },
+ *     terminationProtectionEnabled: true,
+ * });
+ * const example_cluster = example_clusterFlexCluster.name.apply(name => mongodbatlas.getFlexClusterOutput({
+ *     projectId: projectId,
+ *     name: name,
+ * }));
+ * const example_clusters = mongodbatlas.getFlexClusters({
+ *     projectId: projectId,
+ * });
+ * export const mongodbatlasFlexCluster = example_cluster.apply(example_cluster => example_cluster.name);
+ * export const mongodbatlasFlexClustersNames = example_clusters.then(example_clusters => .map(cluster => (cluster.name)));
+ * ```
  */
 export declare function getFlexClustersOutput(args: GetFlexClustersOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output<GetFlexClustersResult>;
 /**

package/getFlexClusters.js

@@ -13,6 +13,31 @@ const utilities = require("./utilities");
  * **RECOMMENDATION:** We recommend using the `mongodbatlas.getAdvancedClusters` data source instead of the `mongodbatlas.getFlexClusters` data source to retrieve Flex clusters. The `mongodbatlas.getAdvancedClusters` data source not only supports Flex clusters, but also supports free and dedicated clusters, providing easier migration between different cluster types. For more information, see the Advanced Clusters data source.
  *
  * ## Example Usage
+ *
+ * ### S
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const example_clusterFlexCluster = new mongodbatlas.FlexCluster("example-cluster", {
+ *     projectId: projectId,
+ *     name: clusterName,
+ *     providerSettings: {
+ *         backingProviderName: "AWS",
+ *         regionName: "US_EAST_1",
+ *     },
+ *     terminationProtectionEnabled: true,
+ * });
+ * const example_cluster = example_clusterFlexCluster.name.apply(name => mongodbatlas.getFlexClusterOutput({
+ *     projectId: projectId,
+ *     name: name,
+ * }));
+ * const example_clusters = mongodbatlas.getFlexClusters({
+ *     projectId: projectId,
+ * });
+ * export const mongodbatlasFlexCluster = example_cluster.apply(example_cluster => example_cluster.name);
+ * export const mongodbatlasFlexClustersNames = example_clusters.then(example_clusters => .map(cluster => (cluster.name)));
+ * ```
  */
 function getFlexClusters(args, opts) {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
@@ -29,6 +54,31 @@ exports.getFlexClusters = getFlexClusters;
  * **RECOMMENDATION:** We recommend using the `mongodbatlas.getAdvancedClusters` data source instead of the `mongodbatlas.getFlexClusters` data source to retrieve Flex clusters. The `mongodbatlas.getAdvancedClusters` data source not only supports Flex clusters, but also supports free and dedicated clusters, providing easier migration between different cluster types. For more information, see the Advanced Clusters data source.
  *
  * ## Example Usage
+ *
+ * ### S
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const example_clusterFlexCluster = new mongodbatlas.FlexCluster("example-cluster", {
+ *     projectId: projectId,
+ *     name: clusterName,
+ *     providerSettings: {
+ *         backingProviderName: "AWS",
+ *         regionName: "US_EAST_1",
+ *     },
+ *     terminationProtectionEnabled: true,
+ * });
+ * const example_cluster = example_clusterFlexCluster.name.apply(name => mongodbatlas.getFlexClusterOutput({
+ *     projectId: projectId,
+ *     name: name,
+ * }));
+ * const example_clusters = mongodbatlas.getFlexClusters({
+ *     projectId: projectId,
+ * });
+ * export const mongodbatlasFlexCluster = example_cluster.apply(example_cluster => example_cluster.name);
+ * export const mongodbatlasFlexClustersNames = example_clusters.then(example_clusters => .map(cluster => (cluster.name)));
+ * ```
  */
 function getFlexClustersOutput(args, opts) {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});

package/getFlexClusters.js.map

@@ -1 +1 @@
-{"version":3,"file":"getFlexClusters.js","sourceRoot":"","sources":["../getFlexClusters.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;GAQG;AACH,SAAgB,eAAe,CAAC,IAAyB,EAAE,IAA2B;IAClF,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,oDAAoD,EAAE;QAC/E,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AALD,0CAKC;AA6BD;;;;;;;;GAQG;AACH,SAAgB,qBAAqB,CAAC,IAA+B,EAAE,IAAiC;IACpG,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,oDAAoD,EAAE;QACrF,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AALD,sDAKC"}
+{"version":3,"file":"getFlexClusters.js","sourceRoot":"","sources":["../getFlexClusters.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,SAAgB,eAAe,CAAC,IAAyB,EAAE,IAA2B;IAClF,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,oDAAoD,EAAE;QAC/E,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AALD,0CAKC;AA6BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,SAAgB,qBAAqB,CAAC,IAA+B,EAAE,IAAiC;IACpG,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,oDAAoD,EAAE;QACrF,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AALD,sDAKC"}

package/getSearchDeployment.d.ts

@@ -8,6 +8,45 @@ import * as outputs from "./types/output";
  * ## Example Usage
  *
  * ### S
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const exampleProject = new mongodbatlas.Project("example", {
+ *     name: "project-name",
+ *     orgId: orgId,
+ * });
+ * const exampleAdvancedCluster = new mongodbatlas.AdvancedCluster("example", {
+ *     projectId: exampleProject.id,
+ *     name: "ClusterExample",
+ *     clusterType: "REPLICASET",
+ *     replicationSpecs: [{
+ *         regionConfigs: [{
+ *             electableSpecs: {
+ *                 instanceSize: "M10",
+ *                 nodeCount: 3,
+ *             },
+ *             providerName: "AWS",
+ *             priority: 7,
+ *             regionName: "US_EAST_1",
+ *         }],
+ *     }],
+ * });
+ * const exampleSearchDeployment = new mongodbatlas.SearchDeployment("example", {
+ *     projectId: exampleProject.id,
+ *     clusterName: exampleAdvancedCluster.name,
+ *     specs: [{
+ *         instanceSize: "S20_HIGHCPU_NVME",
+ *         nodeCount: 2,
+ *     }],
+ * });
+ * const example = mongodbatlas.getSearchDeploymentOutput({
+ *     projectId: exampleSearchDeployment.projectId,
+ *     clusterName: exampleSearchDeployment.clusterName,
+ * });
+ * export const mongodbatlasSearchDeploymentId = example.apply(example => example.id);
+ * export const mongodbatlasSearchDeploymentEncryptionAtRestProvider = example.apply(example => example.encryptionAtRestProvider);
+ * ```
  */
 export declare function getSearchDeployment(args: GetSearchDeploymentArgs, opts?: pulumi.InvokeOptions): Promise<GetSearchDeploymentResult>;
 /**
@@ -60,6 +99,45 @@ export interface GetSearchDeploymentResult {
  * ## Example Usage
  *
  * ### S
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const exampleProject = new mongodbatlas.Project("example", {
+ *     name: "project-name",
+ *     orgId: orgId,
+ * });
+ * const exampleAdvancedCluster = new mongodbatlas.AdvancedCluster("example", {
+ *     projectId: exampleProject.id,
+ *     name: "ClusterExample",
+ *     clusterType: "REPLICASET",
+ *     replicationSpecs: [{
+ *         regionConfigs: [{
+ *             electableSpecs: {
+ *                 instanceSize: "M10",
+ *                 nodeCount: 3,
+ *             },
+ *             providerName: "AWS",
+ *             priority: 7,
+ *             regionName: "US_EAST_1",
+ *         }],
+ *     }],
+ * });
+ * const exampleSearchDeployment = new mongodbatlas.SearchDeployment("example", {
+ *     projectId: exampleProject.id,
+ *     clusterName: exampleAdvancedCluster.name,
+ *     specs: [{
+ *         instanceSize: "S20_HIGHCPU_NVME",
+ *         nodeCount: 2,
+ *     }],
+ * });
+ * const example = mongodbatlas.getSearchDeploymentOutput({
+ *     projectId: exampleSearchDeployment.projectId,
+ *     clusterName: exampleSearchDeployment.clusterName,
+ * });
+ * export const mongodbatlasSearchDeploymentId = example.apply(example => example.id);
+ * export const mongodbatlasSearchDeploymentEncryptionAtRestProvider = example.apply(example => example.encryptionAtRestProvider);
+ * ```
  */
 export declare function getSearchDeploymentOutput(args: GetSearchDeploymentOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output<GetSearchDeploymentResult>;
 /**

package/getSearchDeployment.js

@@ -13,6 +13,45 @@ const utilities = require("./utilities");
  * ## Example Usage
  *
  * ### S
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const exampleProject = new mongodbatlas.Project("example", {
+ *     name: "project-name",
+ *     orgId: orgId,
+ * });
+ * const exampleAdvancedCluster = new mongodbatlas.AdvancedCluster("example", {
+ *     projectId: exampleProject.id,
+ *     name: "ClusterExample",
+ *     clusterType: "REPLICASET",
+ *     replicationSpecs: [{
+ *         regionConfigs: [{
+ *             electableSpecs: {
+ *                 instanceSize: "M10",
+ *                 nodeCount: 3,
+ *             },
+ *             providerName: "AWS",
+ *             priority: 7,
+ *             regionName: "US_EAST_1",
+ *         }],
+ *     }],
+ * });
+ * const exampleSearchDeployment = new mongodbatlas.SearchDeployment("example", {
+ *     projectId: exampleProject.id,
+ *     clusterName: exampleAdvancedCluster.name,
+ *     specs: [{
+ *         instanceSize: "S20_HIGHCPU_NVME",
+ *         nodeCount: 2,
+ *     }],
+ * });
+ * const example = mongodbatlas.getSearchDeploymentOutput({
+ *     projectId: exampleSearchDeployment.projectId,
+ *     clusterName: exampleSearchDeployment.clusterName,
+ * });
+ * export const mongodbatlasSearchDeploymentId = example.apply(example => example.id);
+ * export const mongodbatlasSearchDeploymentEncryptionAtRestProvider = example.apply(example => example.encryptionAtRestProvider);
+ * ```
  */
 function getSearchDeployment(args, opts) {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
@@ -30,6 +69,45 @@ exports.getSearchDeployment = getSearchDeployment;
  * ## Example Usage
  *
  * ### S
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const exampleProject = new mongodbatlas.Project("example", {
+ *     name: "project-name",
+ *     orgId: orgId,
+ * });
+ * const exampleAdvancedCluster = new mongodbatlas.AdvancedCluster("example", {
+ *     projectId: exampleProject.id,
+ *     name: "ClusterExample",
+ *     clusterType: "REPLICASET",
+ *     replicationSpecs: [{
+ *         regionConfigs: [{
+ *             electableSpecs: {
+ *                 instanceSize: "M10",
+ *                 nodeCount: 3,
+ *             },
+ *             providerName: "AWS",
+ *             priority: 7,
+ *             regionName: "US_EAST_1",
+ *         }],
+ *     }],
+ * });
+ * const exampleSearchDeployment = new mongodbatlas.SearchDeployment("example", {
+ *     projectId: exampleProject.id,
+ *     clusterName: exampleAdvancedCluster.name,
+ *     specs: [{
+ *         instanceSize: "S20_HIGHCPU_NVME",
+ *         nodeCount: 2,
+ *     }],
+ * });
+ * const example = mongodbatlas.getSearchDeploymentOutput({
+ *     projectId: exampleSearchDeployment.projectId,
+ *     clusterName: exampleSearchDeployment.clusterName,
+ * });
+ * export const mongodbatlasSearchDeploymentId = example.apply(example => example.id);
+ * export const mongodbatlasSearchDeploymentEncryptionAtRestProvider = example.apply(example => example.encryptionAtRestProvider);
+ * ```
  */
 function getSearchDeploymentOutput(args, opts) {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});

package/getSearchDeployment.js.map

@@ -1 +1 @@
-{"version":3,"file":"getSearchDeployment.js","sourceRoot":"","sources":["../getSearchDeployment.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;GAQG;AACH,SAAgB,mBAAmB,CAAC,IAA6B,EAAE,IAA2B;IAC1F,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,4DAA4D,EAAE;QACvF,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,kDAMC;AA6CD;;;;;;;;GAQG;AACH,SAAgB,yBAAyB,CAAC,IAAmC,EAAE,IAAiC;IAC5G,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,4DAA4D,EAAE;QAC7F,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,8DAMC"}
+{"version":3,"file":"getSearchDeployment.js","sourceRoot":"","sources":["../getSearchDeployment.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,SAAgB,mBAAmB,CAAC,IAA6B,EAAE,IAA2B;IAC1F,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,4DAA4D,EAAE;QACvF,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,kDAMC;AA6CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,SAAgB,yBAAyB,CAAC,IAAmC,EAAE,IAAiC;IAC5G,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,4DAA4D,EAAE;QAC7F,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,8DAMC"}

package/getStreamPrivatelinkEndpoint.d.ts

@@ -8,6 +8,76 @@ import * as pulumi from "@pulumi/pulumi";
  *
  * ### S
  *
+ * ### AWS Confluent Privatelink
+ * ```typescript
+ * 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));
+ * ```
+ *
  * ### AWS S3 Privatelink
  * ```typescript
  * import * as pulumi from "@pulumi/pulumi";
@@ -80,6 +150,76 @@ export interface GetStreamPrivatelinkEndpointResult {
  *
  * ### S
  *
+ * ### AWS Confluent Privatelink
+ * ```typescript
+ * 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));
+ * ```
+ *
  * ### AWS S3 Privatelink
  * ```typescript
  * import * as pulumi from "@pulumi/pulumi";

package/getStreamPrivatelinkEndpoint.js

@@ -14,6 +14,76 @@ const utilities = require("./utilities");
  *
  * ### S
  *
+ * ### AWS Confluent Privatelink
+ * ```typescript
+ * 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));
+ * ```
+ *
  * ### AWS S3 Privatelink
  * ```typescript
  * import * as pulumi from "@pulumi/pulumi";
@@ -67,6 +137,76 @@ exports.getStreamPrivatelinkEndpoint = getStreamPrivatelinkEndpoint;
  *
  * ### S
  *
+ * ### AWS Confluent Privatelink
+ * ```typescript
+ * 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));
+ * ```
+ *
  * ### AWS S3 Privatelink
  * ```typescript
  * import * as pulumi from "@pulumi/pulumi";

package/getStreamPrivatelinkEndpoint.js.map

@@ -1 +1 @@
-{"version":3,"file":"getStreamPrivatelinkEndpoint.js","sourceRoot":"","sources":["../getStreamPrivatelinkEndpoint.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AACzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,SAAgB,4BAA4B,CAAC,IAAsC,EAAE,IAA2B;IAC5G,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,8EAA8E,EAAE;QACzG,IAAI,EAAE,IAAI,CAAC,EAAE;QACb,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,oEAMC;AA6BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,SAAgB,kCAAkC,CAAC,IAA4C,EAAE,IAAiC;IAC9H,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,8EAA8E,EAAE;QAC/G,IAAI,EAAE,IAAI,CAAC,EAAE;QACb,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,gFAMC"}
+{"version":3,"file":"getStreamPrivatelinkEndpoint.js","sourceRoot":"","sources":["../getStreamPrivatelinkEndpoint.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AACzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkHG;AACH,SAAgB,4BAA4B,CAAC,IAAsC,EAAE,IAA2B;IAC5G,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,8EAA8E,EAAE;QACzG,IAAI,EAAE,IAAI,CAAC,EAAE;QACb,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,oEAMC;AA6BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkHG;AACH,SAAgB,kCAAkC,CAAC,IAA4C,EAAE,IAAiC;IAC9H,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,8EAA8E,EAAE;QAC/G,IAAI,EAAE,IAAI,CAAC,EAAE;QACb,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,gFAMC"}