@pulumi/mongodbatlas 3.39.0-alpha.1766556689 → 4.0.0

package/getStreamPrivatelinkEndpoint.d.ts

@@ -1,7 +1,5 @@
 import * as pulumi from "@pulumi/pulumi";
 /**
- * ## # Data Source: mongodbatlas.StreamPrivatelinkEndpoint
- *
  * `mongodbatlas.StreamPrivatelinkEndpoint` describes a Privatelink Endpoint for Streams.
  *
  * ## Example Usage
@@ -113,6 +111,32 @@ import * as pulumi from "@pulumi/pulumi";
  * });
  * export const privatelinkEndpointId = _this.id;
  * ```
+ *
+ * ### GCP Confluent Privatelink
+ * ```typescript
+ * 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;
+ * ```
  */
 export declare function getStreamPrivatelinkEndpoint(args: GetStreamPrivatelinkEndpointArgs, opts?: pulumi.InvokeOptions): Promise<GetStreamPrivatelinkEndpointResult>;
 /**
@@ -137,13 +161,12 @@ export interface GetStreamPrivatelinkEndpointResult {
     readonly providerAccountId: string;
     readonly providerName: string;
     readonly region: string;
+    readonly serviceAttachmentUris: string[];
     readonly serviceEndpointId: string;
     readonly state: string;
     readonly vendor: string;
 }
 /**
- * ## # Data Source: mongodbatlas.StreamPrivatelinkEndpoint
- *
  * `mongodbatlas.StreamPrivatelinkEndpoint` describes a Privatelink Endpoint for Streams.
  *
  * ## Example Usage
@@ -255,6 +278,32 @@ export interface GetStreamPrivatelinkEndpointResult {
  * });
  * export const privatelinkEndpointId = _this.id;
  * ```
+ *
+ * ### GCP Confluent Privatelink
+ * ```typescript
+ * 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;
+ * ```
  */
 export declare function getStreamPrivatelinkEndpointOutput(args: GetStreamPrivatelinkEndpointOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output<GetStreamPrivatelinkEndpointResult>;
 /**

package/getStreamPrivatelinkEndpoint.js

@@ -6,8 +6,6 @@ exports.getStreamPrivatelinkEndpointOutput = exports.getStreamPrivatelinkEndpoin
 const pulumi = require("@pulumi/pulumi");
 const utilities = require("./utilities");
 /**
- * ## # Data Source: mongodbatlas.StreamPrivatelinkEndpoint
- *
  * `mongodbatlas.StreamPrivatelinkEndpoint` describes a Privatelink Endpoint for Streams.
  *
  * ## Example Usage
@@ -119,6 +117,32 @@ const utilities = require("./utilities");
  * });
  * export const privatelinkEndpointId = _this.id;
  * ```
+ *
+ * ### GCP Confluent Privatelink
+ * ```typescript
+ * 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;
+ * ```
  */
 function getStreamPrivatelinkEndpoint(args, opts) {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
@@ -129,8 +153,6 @@ function getStreamPrivatelinkEndpoint(args, opts) {
 }
 exports.getStreamPrivatelinkEndpoint = getStreamPrivatelinkEndpoint;
 /**
- * ## # Data Source: mongodbatlas.StreamPrivatelinkEndpoint
- *
  * `mongodbatlas.StreamPrivatelinkEndpoint` describes a Privatelink Endpoint for Streams.
  *
  * ## Example Usage
@@ -242,6 +264,32 @@ exports.getStreamPrivatelinkEndpoint = getStreamPrivatelinkEndpoint;
  * });
  * export const privatelinkEndpointId = _this.id;
  * ```
+ *
+ * ### GCP Confluent Privatelink
+ * ```typescript
+ * 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;
+ * ```
  */
 function getStreamPrivatelinkEndpointOutput(args, opts) {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"getStreamPrivatelinkEndpoint.js","sourceRoot":"","sources":["../getStreamPrivatelinkEndpoint.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AACzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0IG;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;AA8BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0IG;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"}

package/getStreamPrivatelinkEndpoints.d.ts

@@ -1,8 +1,6 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as outputs from "./types/output";
 /**
- * ## # Data Source: mongodbatlas.getStreamPrivatelinkEndpoints
- *
  * `mongodbatlas.getStreamPrivatelinkEndpoints` describes a Privatelink Endpoint for Streams.
  *
  * ## Example Usage
@@ -114,6 +112,32 @@ import * as outputs from "./types/output";
  * });
  * export const privatelinkEndpointId = _this.id;
  * ```
+ *
+ * ### GCP Confluent Privatelink
+ * ```typescript
+ * 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;
+ * ```
  */
 export declare function getStreamPrivatelinkEndpoints(args: GetStreamPrivatelinkEndpointsArgs, opts?: pulumi.InvokeOptions): Promise<GetStreamPrivatelinkEndpointsResult>;
 /**
@@ -134,8 +158,6 @@ export interface GetStreamPrivatelinkEndpointsResult {
     readonly results: outputs.GetStreamPrivatelinkEndpointsResult[];
 }
 /**
- * ## # Data Source: mongodbatlas.getStreamPrivatelinkEndpoints
- *
  * `mongodbatlas.getStreamPrivatelinkEndpoints` describes a Privatelink Endpoint for Streams.
  *
  * ## Example Usage
@@ -247,6 +269,32 @@ export interface GetStreamPrivatelinkEndpointsResult {
  * });
  * export const privatelinkEndpointId = _this.id;
  * ```
+ *
+ * ### GCP Confluent Privatelink
+ * ```typescript
+ * 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;
+ * ```
  */
 export declare function getStreamPrivatelinkEndpointsOutput(args: GetStreamPrivatelinkEndpointsOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output<GetStreamPrivatelinkEndpointsResult>;
 /**

package/getStreamPrivatelinkEndpoints.js

@@ -6,8 +6,6 @@ exports.getStreamPrivatelinkEndpointsOutput = exports.getStreamPrivatelinkEndpoi
 const pulumi = require("@pulumi/pulumi");
 const utilities = require("./utilities");
 /**
- * ## # Data Source: mongodbatlas.getStreamPrivatelinkEndpoints
- *
  * `mongodbatlas.getStreamPrivatelinkEndpoints` describes a Privatelink Endpoint for Streams.
  *
  * ## Example Usage
@@ -119,6 +117,32 @@ const utilities = require("./utilities");
  * });
  * export const privatelinkEndpointId = _this.id;
  * ```
+ *
+ * ### GCP Confluent Privatelink
+ * ```typescript
+ * 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;
+ * ```
  */
 function getStreamPrivatelinkEndpoints(args, opts) {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
@@ -128,8 +152,6 @@ function getStreamPrivatelinkEndpoints(args, opts) {
 }
 exports.getStreamPrivatelinkEndpoints = getStreamPrivatelinkEndpoints;
 /**
- * ## # Data Source: mongodbatlas.getStreamPrivatelinkEndpoints
- *
  * `mongodbatlas.getStreamPrivatelinkEndpoints` describes a Privatelink Endpoint for Streams.
  *
  * ## Example Usage
@@ -241,6 +263,32 @@ exports.getStreamPrivatelinkEndpoints = getStreamPrivatelinkEndpoints;
  * });
  * export const privatelinkEndpointId = _this.id;
  * ```
+ *
+ * ### GCP Confluent Privatelink
+ * ```typescript
+ * 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;
+ * ```
  */
 function getStreamPrivatelinkEndpointsOutput(args, opts) {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});

package/getStreamPrivatelinkEndpoints.js.map

@@ -1 +1 @@
-{"version":3,"file":"getStreamPrivatelinkEndpoints.js","sourceRoot":"","sources":["../getStreamPrivatelinkEndpoints.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkHG;AACH,SAAgB,6BAA6B,CAAC,IAAuC,EAAE,IAA2B;IAC9G,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,gFAAgF,EAAE;QAC3G,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AALD,sEAKC;AAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkHG;AACH,SAAgB,mCAAmC,CAAC,IAA6C,EAAE,IAAiC;IAChI,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,gFAAgF,EAAE;QACjH,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AALD,kFAKC"}
+{"version":3,"file":"getStreamPrivatelinkEndpoints.js","sourceRoot":"","sources":["../getStreamPrivatelinkEndpoints.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0IG;AACH,SAAgB,6BAA6B,CAAC,IAAuC,EAAE,IAA2B;IAC9G,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,gFAAgF,EAAE;QAC3G,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AALD,sEAKC;AAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0IG;AACH,SAAgB,mCAAmC,CAAC,IAA6C,EAAE,IAAiC;IAChI,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,gFAAgF,EAAE;QACjH,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AALD,kFAKC"}

package/getStreamProcessor.d.ts

@@ -1,8 +1,6 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as outputs from "./types/output";
 /**
- * ## # Data Source: mongodbatlas.StreamProcessor
- *
  * `mongodbatlas.StreamProcessor` describes a stream processor.
  *
  * ## Example Usage
@@ -22,13 +20,13 @@ import * as outputs from "./types/output";
  * });
  * const example_sample = new mongodbatlas.StreamConnection("example-sample", {
  *     projectId: projectId,
- *     instanceName: example.instanceName,
+ *     workspaceName: example.instanceName,
  *     connectionName: "sample_stream_solar",
  *     type: "Sample",
  * });
  * const example_cluster = new mongodbatlas.StreamConnection("example-cluster", {
  *     projectId: projectId,
- *     instanceName: example.instanceName,
+ *     workspaceName: example.instanceName,
  *     connectionName: "ClusterConnection",
  *     type: "Cluster",
  *     clusterName: clusterName,
@@ -39,7 +37,7 @@ import * as outputs from "./types/output";
  * });
  * const example_kafka = new mongodbatlas.StreamConnection("example-kafka", {
  *     projectId: projectId,
- *     instanceName: example.instanceName,
+ *     workspaceName: example.instanceName,
  *     connectionName: "KafkaPlaintextConnection",
  *     type: "Kafka",
  *     authentication: {
@@ -57,7 +55,7 @@ import * as outputs from "./types/output";
  * });
  * const stream_processor_sample_example = new mongodbatlas.StreamProcessor("stream-processor-sample-example", {
  *     projectId: projectId,
- *     instanceName: example.instanceName,
+ *     workspaceName: example.instanceName,
  *     processorName: "sampleProcessorName",
  *     pipeline: JSON.stringify([
  *         {
@@ -80,7 +78,7 @@ import * as outputs from "./types/output";
  * });
  * const stream_processor_cluster_to_kafka_example = new mongodbatlas.StreamProcessor("stream-processor-cluster-to-kafka-example", {
  *     projectId: projectId,
- *     instanceName: example.instanceName,
+ *     workspaceName: example.instanceName,
  *     processorName: "clusterProcessorName",
  *     pipeline: JSON.stringify([
  *         {
@@ -99,7 +97,7 @@ import * as outputs from "./types/output";
  * });
  * const stream_processor_kafka_to_cluster_example = new mongodbatlas.StreamProcessor("stream-processor-kafka-to-cluster-example", {
  *     projectId: projectId,
- *     instanceName: example.instanceName,
+ *     workspaceName: example.instanceName,
  *     processorName: "kafkaProcessorName",
  *     pipeline: JSON.stringify([
  *         {
@@ -130,11 +128,11 @@ import * as outputs from "./types/output";
  * });
  * const example_stream_processors = example.instanceName.apply(instanceName => mongodbatlas.getStreamProcessorsOutput({
  *     projectId: projectId,
- *     instanceName: instanceName,
+ *     workspaceName: instanceName,
  * }));
  * const example_stream_processor = pulumi.all([example.instanceName, stream_processor_sample_example.processorName]).apply(([instanceName, processorName]) => mongodbatlas.getStreamProcessorOutput({
  *     projectId: projectId,
- *     instanceName: instanceName,
+ *     workspaceName: instanceName,
  *     processorName: processorName,
  * }));
  * export const streamProcessorsState = example_stream_processor.apply(example_stream_processor => example_stream_processor.state);
@@ -147,17 +145,18 @@ export declare function getStreamProcessor(args: GetStreamProcessorArgs, opts?:
  */
 export interface GetStreamProcessorArgs {
     /**
-     * Human-readable label that identifies the stream instance.
+     * @deprecated This parameter is deprecated. Please transition to workspace_name.
      */
-    instanceName: string;
+    instanceName?: string;
     /**
-     * Human-readable label that identifies the stream processor.
+     * Label that identifies the stream processor.
      */
     processorName: string;
     /**
      * Unique 24-hexadecimal digit string that identifies your project. Use the /groups endpoint to retrieve all projects to which the authenticated user has access.
      */
     projectId: string;
+    workspaceName?: string;
 }
 /**
  * A collection of values returned by getStreamProcessor.
@@ -165,13 +164,13 @@ export interface GetStreamProcessorArgs {
 export interface GetStreamProcessorResult {
     readonly id: string;
     /**
-     * Human-readable label that identifies the stream instance.
+     * @deprecated This parameter is deprecated. Please transition to workspace_name.
      */
-    readonly instanceName: string;
+    readonly instanceName?: string;
     readonly options: outputs.GetStreamProcessorOptions;
     readonly pipeline: string;
     /**
-     * Human-readable label that identifies the stream processor.
+     * Label that identifies the stream processor.
      */
     readonly processorName: string;
     /**
@@ -180,10 +179,9 @@ export interface GetStreamProcessorResult {
     readonly projectId: string;
     readonly state: string;
     readonly stats: string;
+    readonly workspaceName?: string;
 }
 /**
- * ## # Data Source: mongodbatlas.StreamProcessor
- *
  * `mongodbatlas.StreamProcessor` describes a stream processor.
  *
  * ## Example Usage
@@ -203,13 +201,13 @@ export interface GetStreamProcessorResult {
  * });
  * const example_sample = new mongodbatlas.StreamConnection("example-sample", {
  *     projectId: projectId,
- *     instanceName: example.instanceName,
+ *     workspaceName: example.instanceName,
  *     connectionName: "sample_stream_solar",
  *     type: "Sample",
  * });
  * const example_cluster = new mongodbatlas.StreamConnection("example-cluster", {
  *     projectId: projectId,
- *     instanceName: example.instanceName,
+ *     workspaceName: example.instanceName,
  *     connectionName: "ClusterConnection",
  *     type: "Cluster",
  *     clusterName: clusterName,
@@ -220,7 +218,7 @@ export interface GetStreamProcessorResult {
  * });
  * const example_kafka = new mongodbatlas.StreamConnection("example-kafka", {
  *     projectId: projectId,
- *     instanceName: example.instanceName,
+ *     workspaceName: example.instanceName,
  *     connectionName: "KafkaPlaintextConnection",
  *     type: "Kafka",
  *     authentication: {
@@ -238,7 +236,7 @@ export interface GetStreamProcessorResult {
  * });
  * const stream_processor_sample_example = new mongodbatlas.StreamProcessor("stream-processor-sample-example", {
  *     projectId: projectId,
- *     instanceName: example.instanceName,
+ *     workspaceName: example.instanceName,
  *     processorName: "sampleProcessorName",
  *     pipeline: JSON.stringify([
  *         {
@@ -261,7 +259,7 @@ export interface GetStreamProcessorResult {
  * });
  * const stream_processor_cluster_to_kafka_example = new mongodbatlas.StreamProcessor("stream-processor-cluster-to-kafka-example", {
  *     projectId: projectId,
- *     instanceName: example.instanceName,
+ *     workspaceName: example.instanceName,
  *     processorName: "clusterProcessorName",
  *     pipeline: JSON.stringify([
  *         {
@@ -280,7 +278,7 @@ export interface GetStreamProcessorResult {
  * });
  * const stream_processor_kafka_to_cluster_example = new mongodbatlas.StreamProcessor("stream-processor-kafka-to-cluster-example", {
  *     projectId: projectId,
- *     instanceName: example.instanceName,
+ *     workspaceName: example.instanceName,
  *     processorName: "kafkaProcessorName",
  *     pipeline: JSON.stringify([
  *         {
@@ -311,11 +309,11 @@ export interface GetStreamProcessorResult {
  * });
  * const example_stream_processors = example.instanceName.apply(instanceName => mongodbatlas.getStreamProcessorsOutput({
  *     projectId: projectId,
- *     instanceName: instanceName,
+ *     workspaceName: instanceName,
  * }));
  * const example_stream_processor = pulumi.all([example.instanceName, stream_processor_sample_example.processorName]).apply(([instanceName, processorName]) => mongodbatlas.getStreamProcessorOutput({
  *     projectId: projectId,
- *     instanceName: instanceName,
+ *     workspaceName: instanceName,
  *     processorName: processorName,
  * }));
  * export const streamProcessorsState = example_stream_processor.apply(example_stream_processor => example_stream_processor.state);
@@ -328,15 +326,16 @@ export declare function getStreamProcessorOutput(args: GetStreamProcessorOutputA
  */
 export interface GetStreamProcessorOutputArgs {
     /**
-     * Human-readable label that identifies the stream instance.
+     * @deprecated This parameter is deprecated. Please transition to workspace_name.
      */
-    instanceName: pulumi.Input<string>;
+    instanceName?: pulumi.Input<string>;
     /**
-     * Human-readable label that identifies the stream processor.
+     * Label that identifies the stream processor.
      */
     processorName: pulumi.Input<string>;
     /**
      * Unique 24-hexadecimal digit string that identifies your project. Use the /groups endpoint to retrieve all projects to which the authenticated user has access.
      */
     projectId: pulumi.Input<string>;
+    workspaceName?: pulumi.Input<string>;
 }