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

package/getStreamPrivatelinkEndpoints.d.ts

@@ -9,6 +9,76 @@ import * as outputs from "./types/output";
  *
  * ### 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";
@@ -72,6 +142,76 @@ export interface GetStreamPrivatelinkEndpointsResult {
  *
  * ### 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/getStreamPrivatelinkEndpoints.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";
@@ -66,6 +136,76 @@ exports.getStreamPrivatelinkEndpoints = getStreamPrivatelinkEndpoints;
  *
  * ### 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/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/getStreamProcessor.d.ts

@@ -8,6 +8,138 @@ import * as outputs from "./types/output";
  * ## Example Usage
  *
  * ### S
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const example = new mongodbatlas.StreamInstance("example", {
+ *     projectId: projectId,
+ *     instanceName: "InstanceName",
+ *     dataProcessRegion: {
+ *         region: "VIRGINIA_USA",
+ *         cloudProvider: "AWS",
+ *     },
+ * });
+ * const example_sample = new mongodbatlas.StreamConnection("example-sample", {
+ *     projectId: projectId,
+ *     instanceName: example.instanceName,
+ *     connectionName: "sample_stream_solar",
+ *     type: "Sample",
+ * });
+ * const example_cluster = new mongodbatlas.StreamConnection("example-cluster", {
+ *     projectId: projectId,
+ *     instanceName: example.instanceName,
+ *     connectionName: "ClusterConnection",
+ *     type: "Cluster",
+ *     clusterName: clusterName,
+ *     dbRoleToExecute: {
+ *         role: "atlasAdmin",
+ *         type: "BUILT_IN",
+ *     },
+ * });
+ * const example_kafka = new mongodbatlas.StreamConnection("example-kafka", {
+ *     projectId: projectId,
+ *     instanceName: example.instanceName,
+ *     connectionName: "KafkaPlaintextConnection",
+ *     type: "Kafka",
+ *     authentication: {
+ *         mechanism: "PLAIN",
+ *         username: kafkaUsername,
+ *         password: kafkaPassword,
+ *     },
+ *     bootstrapServers: "localhost:9092,localhost:9092",
+ *     config: {
+ *         "auto.offset.reset": "earliest",
+ *     },
+ *     security: {
+ *         protocol: "SASL_PLAINTEXT",
+ *     },
+ * });
+ * const stream_processor_sample_example = new mongodbatlas.StreamProcessor("stream-processor-sample-example", {
+ *     projectId: projectId,
+ *     instanceName: example.instanceName,
+ *     processorName: "sampleProcessorName",
+ *     pipeline: JSON.stringify([
+ *         {
+ *             $source: {
+ *                 connectionName: mongodbatlasStreamConnection["example-sample"].connectionName,
+ *             },
+ *         },
+ *         {
+ *             $emit: {
+ *                 connectionName: mongodbatlasStreamConnection["example-cluster"].connectionName,
+ *                 db: "sample",
+ *                 coll: "solar",
+ *                 timeseries: {
+ *                     timeField: "_ts",
+ *                 },
+ *             },
+ *         },
+ *     ]),
+ *     state: "STARTED",
+ * });
+ * const stream_processor_cluster_to_kafka_example = new mongodbatlas.StreamProcessor("stream-processor-cluster-to-kafka-example", {
+ *     projectId: projectId,
+ *     instanceName: example.instanceName,
+ *     processorName: "clusterProcessorName",
+ *     pipeline: JSON.stringify([
+ *         {
+ *             $source: {
+ *                 connectionName: mongodbatlasStreamConnection["example-cluster"].connectionName,
+ *             },
+ *         },
+ *         {
+ *             $emit: {
+ *                 connectionName: mongodbatlasStreamConnection["example-kafka"].connectionName,
+ *                 topic: "topic_from_cluster",
+ *             },
+ *         },
+ *     ]),
+ *     state: "CREATED",
+ * });
+ * const stream_processor_kafka_to_cluster_example = new mongodbatlas.StreamProcessor("stream-processor-kafka-to-cluster-example", {
+ *     projectId: projectId,
+ *     instanceName: example.instanceName,
+ *     processorName: "kafkaProcessorName",
+ *     pipeline: JSON.stringify([
+ *         {
+ *             $source: {
+ *                 connectionName: mongodbatlasStreamConnection["example-kafka"].connectionName,
+ *                 topic: "topic_source",
+ *             },
+ *         },
+ *         {
+ *             $emit: {
+ *                 connectionName: mongodbatlasStreamConnection["example-cluster"].connectionName,
+ *                 db: "kafka",
+ *                 coll: "topic_source",
+ *                 timeseries: {
+ *                     timeField: "ts",
+ *                 },
+ *             },
+ *         },
+ *     ]),
+ *     state: "CREATED",
+ *     options: {
+ *         dlq: {
+ *             coll: "exampleColumn",
+ *             connectionName: mongodbatlasStreamConnection["example-cluster"].connectionName,
+ *             db: "exampleDb",
+ *         },
+ *     },
+ * });
+ * const example_stream_processors = example.instanceName.apply(instanceName => mongodbatlas.getStreamProcessorsOutput({
+ *     projectId: projectId,
+ *     instanceName: instanceName,
+ * }));
+ * const example_stream_processor = pulumi.all([example.instanceName, stream_processor_sample_example.processorName]).apply(([instanceName, processorName]) => mongodbatlas.getStreamProcessorOutput({
+ *     projectId: projectId,
+ *     instanceName: instanceName,
+ *     processorName: processorName,
+ * }));
+ * export const streamProcessorsState = example_stream_processor.apply(example_stream_processor => example_stream_processor.state);
+ * export const streamProcessorsResults = example_stream_processors.apply(example_stream_processors => example_stream_processors.results);
+ * ```
  */
 export declare function getStreamProcessor(args: GetStreamProcessorArgs, opts?: pulumi.InvokeOptions): Promise<GetStreamProcessorResult>;
 /**
@@ -57,6 +189,138 @@ export interface GetStreamProcessorResult {
  * ## Example Usage
  *
  * ### S
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const example = new mongodbatlas.StreamInstance("example", {
+ *     projectId: projectId,
+ *     instanceName: "InstanceName",
+ *     dataProcessRegion: {
+ *         region: "VIRGINIA_USA",
+ *         cloudProvider: "AWS",
+ *     },
+ * });
+ * const example_sample = new mongodbatlas.StreamConnection("example-sample", {
+ *     projectId: projectId,
+ *     instanceName: example.instanceName,
+ *     connectionName: "sample_stream_solar",
+ *     type: "Sample",
+ * });
+ * const example_cluster = new mongodbatlas.StreamConnection("example-cluster", {
+ *     projectId: projectId,
+ *     instanceName: example.instanceName,
+ *     connectionName: "ClusterConnection",
+ *     type: "Cluster",
+ *     clusterName: clusterName,
+ *     dbRoleToExecute: {
+ *         role: "atlasAdmin",
+ *         type: "BUILT_IN",
+ *     },
+ * });
+ * const example_kafka = new mongodbatlas.StreamConnection("example-kafka", {
+ *     projectId: projectId,
+ *     instanceName: example.instanceName,
+ *     connectionName: "KafkaPlaintextConnection",
+ *     type: "Kafka",
+ *     authentication: {
+ *         mechanism: "PLAIN",
+ *         username: kafkaUsername,
+ *         password: kafkaPassword,
+ *     },
+ *     bootstrapServers: "localhost:9092,localhost:9092",
+ *     config: {
+ *         "auto.offset.reset": "earliest",
+ *     },
+ *     security: {
+ *         protocol: "SASL_PLAINTEXT",
+ *     },
+ * });
+ * const stream_processor_sample_example = new mongodbatlas.StreamProcessor("stream-processor-sample-example", {
+ *     projectId: projectId,
+ *     instanceName: example.instanceName,
+ *     processorName: "sampleProcessorName",
+ *     pipeline: JSON.stringify([
+ *         {
+ *             $source: {
+ *                 connectionName: mongodbatlasStreamConnection["example-sample"].connectionName,
+ *             },
+ *         },
+ *         {
+ *             $emit: {
+ *                 connectionName: mongodbatlasStreamConnection["example-cluster"].connectionName,
+ *                 db: "sample",
+ *                 coll: "solar",
+ *                 timeseries: {
+ *                     timeField: "_ts",
+ *                 },
+ *             },
+ *         },
+ *     ]),
+ *     state: "STARTED",
+ * });
+ * const stream_processor_cluster_to_kafka_example = new mongodbatlas.StreamProcessor("stream-processor-cluster-to-kafka-example", {
+ *     projectId: projectId,
+ *     instanceName: example.instanceName,
+ *     processorName: "clusterProcessorName",
+ *     pipeline: JSON.stringify([
+ *         {
+ *             $source: {
+ *                 connectionName: mongodbatlasStreamConnection["example-cluster"].connectionName,
+ *             },
+ *         },
+ *         {
+ *             $emit: {
+ *                 connectionName: mongodbatlasStreamConnection["example-kafka"].connectionName,
+ *                 topic: "topic_from_cluster",
+ *             },
+ *         },
+ *     ]),
+ *     state: "CREATED",
+ * });
+ * const stream_processor_kafka_to_cluster_example = new mongodbatlas.StreamProcessor("stream-processor-kafka-to-cluster-example", {
+ *     projectId: projectId,
+ *     instanceName: example.instanceName,
+ *     processorName: "kafkaProcessorName",
+ *     pipeline: JSON.stringify([
+ *         {
+ *             $source: {
+ *                 connectionName: mongodbatlasStreamConnection["example-kafka"].connectionName,
+ *                 topic: "topic_source",
+ *             },
+ *         },
+ *         {
+ *             $emit: {
+ *                 connectionName: mongodbatlasStreamConnection["example-cluster"].connectionName,
+ *                 db: "kafka",
+ *                 coll: "topic_source",
+ *                 timeseries: {
+ *                     timeField: "ts",
+ *                 },
+ *             },
+ *         },
+ *     ]),
+ *     state: "CREATED",
+ *     options: {
+ *         dlq: {
+ *             coll: "exampleColumn",
+ *             connectionName: mongodbatlasStreamConnection["example-cluster"].connectionName,
+ *             db: "exampleDb",
+ *         },
+ *     },
+ * });
+ * const example_stream_processors = example.instanceName.apply(instanceName => mongodbatlas.getStreamProcessorsOutput({
+ *     projectId: projectId,
+ *     instanceName: instanceName,
+ * }));
+ * const example_stream_processor = pulumi.all([example.instanceName, stream_processor_sample_example.processorName]).apply(([instanceName, processorName]) => mongodbatlas.getStreamProcessorOutput({
+ *     projectId: projectId,
+ *     instanceName: instanceName,
+ *     processorName: processorName,
+ * }));
+ * export const streamProcessorsState = example_stream_processor.apply(example_stream_processor => example_stream_processor.state);
+ * export const streamProcessorsResults = example_stream_processors.apply(example_stream_processors => example_stream_processors.results);
+ * ```
  */
 export declare function getStreamProcessorOutput(args: GetStreamProcessorOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output<GetStreamProcessorResult>;
 /**