@pulumi/mongodbatlas 3.17.0-alpha.1723037969 → 3.17.0-alpha.1723714844

package/getAdvancedCluster.d.ts

@@ -38,6 +38,51 @@ import * as outputs from "./types/output";
  *     name: exampleAdvancedCluster.name,
  * });
  * ```
+ *
+ * ## Example using latest sharding schema with independent shard scaling in the cluster
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const exampleAdvancedCluster = new mongodbatlas.AdvancedCluster("example", {
+ *     projectId: "<YOUR-PROJECT-ID>",
+ *     name: "cluster-test",
+ *     backupEnabled: false,
+ *     clusterType: "SHARDED",
+ *     replicationSpecs: [
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M30",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M40",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *     ],
+ * });
+ * const example = mongodbatlas.getAdvancedClusterOutput({
+ *     projectId: exampleAdvancedCluster.projectId,
+ *     name: exampleAdvancedCluster.name,
+ *     useReplicationSpecPerShard: true,
+ * });
+ * ```
  */
 export declare function getAdvancedCluster(args: GetAdvancedClusterArgs, opts?: pulumi.InvokeOptions): Promise<GetAdvancedClusterResult>;
 /**
@@ -56,6 +101,10 @@ export interface GetAdvancedClusterArgs {
      * The unique ID for the project to create the database user.
      */
     projectId: string;
+    /**
+     * Set this field to true to allow the data source to use the latest schema representing each shard with an individual `replicationSpecs` object. This enables representing clusters with independent shard scaling.
+     */
+    useReplicationSpecPerShard?: boolean;
 }
 /**
  * A collection of values returned by getAdvancedCluster.
@@ -80,7 +129,9 @@ export interface GetAdvancedClusterResult {
     readonly connectionStrings: outputs.GetAdvancedClusterConnectionString[];
     readonly createDate: string;
     /**
-     * Capacity, in gigabytes, of the host's root volume.
+     * Storage capacity that the host's root volume possesses expressed in gigabytes. If disk size specified is below the minimum (10 GB), this parameter defaults to the minimum disk size value. Storage charge calculations depend on whether you choose the default value or a custom value.  The maximum value for disk storage cannot exceed 50 times the maximum RAM for the selected cluster. If you require more storage space, consider upgrading your cluster to a higher tier.
+     *
+     * @deprecated This parameter is deprecated. Please refer to our examples, documentation, and 1.18.0 migration guide for more details at https://registry.terraform.io/providers/mongodb/mongodbatlas/latest/docs/guides/1.18.0-upgrade-guide.html.markdown
      */
     readonly diskSizeGb: number;
     /**
@@ -96,7 +147,7 @@ export interface GetAdvancedClusterResult {
      */
     readonly id: string;
     /**
-     * Set that contains key-value pairs between 1 to 255 characters in length for tagging and categorizing the cluster. See below. **DEPRECATED** Use `tags` instead.
+     * Set that contains key-value pairs between 1 to 255 characters in length for tagging and categorizing the cluster. See below. **(DEPRECATED.)** Use `tags` instead.
      *
      * @deprecated This parameter is deprecated and will be removed by September 2024. Please transition to tags.
      */
@@ -120,7 +171,7 @@ export interface GetAdvancedClusterResult {
     readonly pitEnabled: boolean;
     readonly projectId: string;
     /**
-     * Configuration for cluster regions and the hardware provisioned in them. See below.
+     * List of settings that configure your cluster regions. If `useReplicationSpecPerShard = true`, this array has one object per shard representing node configurations in each shard. For replica sets there is only one object representing node configurations. See below.
      */
     readonly replicationSpecs: outputs.GetAdvancedClusterReplicationSpec[];
     /**
@@ -139,6 +190,7 @@ export interface GetAdvancedClusterResult {
      * Flag that indicates whether termination protection is enabled on the cluster. If set to true, MongoDB Cloud won't delete the cluster. If set to false, MongoDB Cloud will delete the cluster.
      */
     readonly terminationProtectionEnabled: boolean;
+    readonly useReplicationSpecPerShard?: boolean;
     /**
      * Release cadence that Atlas uses for this cluster.
      */
@@ -182,6 +234,51 @@ export interface GetAdvancedClusterResult {
  *     name: exampleAdvancedCluster.name,
  * });
  * ```
+ *
+ * ## Example using latest sharding schema with independent shard scaling in the cluster
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const exampleAdvancedCluster = new mongodbatlas.AdvancedCluster("example", {
+ *     projectId: "<YOUR-PROJECT-ID>",
+ *     name: "cluster-test",
+ *     backupEnabled: false,
+ *     clusterType: "SHARDED",
+ *     replicationSpecs: [
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M30",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M40",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *     ],
+ * });
+ * const example = mongodbatlas.getAdvancedClusterOutput({
+ *     projectId: exampleAdvancedCluster.projectId,
+ *     name: exampleAdvancedCluster.name,
+ *     useReplicationSpecPerShard: true,
+ * });
+ * ```
  */
 export declare function getAdvancedClusterOutput(args: GetAdvancedClusterOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output<GetAdvancedClusterResult>;
 /**
@@ -200,4 +297,8 @@ export interface GetAdvancedClusterOutputArgs {
      * The unique ID for the project to create the database user.
      */
     projectId: pulumi.Input<string>;
+    /**
+     * Set this field to true to allow the data source to use the latest schema representing each shard with an individual `replicationSpecs` object. This enables representing clusters with independent shard scaling.
+     */
+    useReplicationSpecPerShard?: pulumi.Input<boolean>;
 }

package/getAdvancedCluster.js

@@ -43,6 +43,51 @@ const utilities = require("./utilities");
  *     name: exampleAdvancedCluster.name,
  * });
  * ```
+ *
+ * ## Example using latest sharding schema with independent shard scaling in the cluster
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const exampleAdvancedCluster = new mongodbatlas.AdvancedCluster("example", {
+ *     projectId: "<YOUR-PROJECT-ID>",
+ *     name: "cluster-test",
+ *     backupEnabled: false,
+ *     clusterType: "SHARDED",
+ *     replicationSpecs: [
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M30",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M40",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *     ],
+ * });
+ * const example = mongodbatlas.getAdvancedClusterOutput({
+ *     projectId: exampleAdvancedCluster.projectId,
+ *     name: exampleAdvancedCluster.name,
+ *     useReplicationSpecPerShard: true,
+ * });
+ * ```
  */
 function getAdvancedCluster(args, opts) {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
@@ -50,6 +95,7 @@ function getAdvancedCluster(args, opts) {
         "name": args.name,
         "pitEnabled": args.pitEnabled,
         "projectId": args.projectId,
+        "useReplicationSpecPerShard": args.useReplicationSpecPerShard,
     }, opts);
 }
 exports.getAdvancedCluster = getAdvancedCluster;
@@ -91,6 +137,51 @@ exports.getAdvancedCluster = getAdvancedCluster;
  *     name: exampleAdvancedCluster.name,
  * });
  * ```
+ *
+ * ## Example using latest sharding schema with independent shard scaling in the cluster
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const exampleAdvancedCluster = new mongodbatlas.AdvancedCluster("example", {
+ *     projectId: "<YOUR-PROJECT-ID>",
+ *     name: "cluster-test",
+ *     backupEnabled: false,
+ *     clusterType: "SHARDED",
+ *     replicationSpecs: [
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M30",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M40",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *     ],
+ * });
+ * const example = mongodbatlas.getAdvancedClusterOutput({
+ *     projectId: exampleAdvancedCluster.projectId,
+ *     name: exampleAdvancedCluster.name,
+ *     useReplicationSpecPerShard: true,
+ * });
+ * ```
  */
 function getAdvancedClusterOutput(args, opts) {
     return pulumi.output(args).apply((a) => getAdvancedCluster(a, opts));

package/getAdvancedCluster.js.map

@@ -1 +1 @@
-{"version":3,"file":"getAdvancedCluster.js","sourceRoot":"","sources":["../getAdvancedCluster.ts"],"names":[],"mappings":";AAAA,wFAAwF;AACxF,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,SAAgB,kBAAkB,CAAC,IAA4B,EAAE,IAA2B;IAExF,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,0DAA0D,EAAE;QACrF,MAAM,EAAE,IAAI,CAAC,IAAI;QACjB,YAAY,EAAE,IAAI,CAAC,UAAU;QAC7B,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AARD,gDAQC;AA2GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,SAAgB,wBAAwB,CAAC,IAAkC,EAAE,IAA2B;IACpG,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,kBAAkB,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;AAC7E,CAAC;AAFD,4DAEC"}
+{"version":3,"file":"getAdvancedCluster.js","sourceRoot":"","sources":["../getAdvancedCluster.ts"],"names":[],"mappings":";AAAA,wFAAwF;AACxF,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AACH,SAAgB,kBAAkB,CAAC,IAA4B,EAAE,IAA2B;IAExF,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,0DAA0D,EAAE;QACrF,MAAM,EAAE,IAAI,CAAC,IAAI;QACjB,YAAY,EAAE,IAAI,CAAC,UAAU;QAC7B,WAAW,EAAE,IAAI,CAAC,SAAS;QAC3B,4BAA4B,EAAE,IAAI,CAAC,0BAA0B;KAChE,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AATD,gDASC;AAkHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AACH,SAAgB,wBAAwB,CAAC,IAAkC,EAAE,IAA2B;IACpG,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,kBAAkB,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;AAC7E,CAAC;AAFD,4DAEC"}

package/getAdvancedClusters.d.ts

@@ -37,6 +37,51 @@ import * as outputs from "./types/output";
  *     projectId: exampleAdvancedCluster.projectId,
  * });
  * ```
+ *
+ * ## Example using latest sharding schema with independent shard scaling in the cluster
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const example = new mongodbatlas.AdvancedCluster("example", {
+ *     projectId: "<YOUR-PROJECT-ID>",
+ *     name: "cluster-test",
+ *     backupEnabled: false,
+ *     clusterType: "SHARDED",
+ *     replicationSpecs: [
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M30",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M40",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *     ],
+ * });
+ * const example-asym = mongodbatlas.getAdvancedClusterOutput({
+ *     projectId: example.projectId,
+ *     name: example.name,
+ *     useReplicationSpecPerShard: true,
+ * });
+ * ```
  */
 export declare function getAdvancedClusters(args: GetAdvancedClustersArgs, opts?: pulumi.InvokeOptions): Promise<GetAdvancedClustersResult>;
 /**
@@ -47,6 +92,10 @@ export interface GetAdvancedClustersArgs {
      * The unique ID for the project to get the clusters.
      */
     projectId: string;
+    /**
+     * Set this field to true to allow the data source to use the latest schema representing each shard with an individual `replicationSpecs` object. This enables representing clusters with independent shard scaling. **Note:** If not set to true, this data source return all clusters except clusters with asymmetric shards.
+     */
+    useReplicationSpecPerShard?: boolean;
 }
 /**
  * A collection of values returned by getAdvancedClusters.
@@ -61,6 +110,7 @@ export interface GetAdvancedClustersResult {
      * A list where each represents a Cluster. See below for more details.
      */
     readonly results: outputs.GetAdvancedClustersResult[];
+    readonly useReplicationSpecPerShard?: boolean;
 }
 /**
  * ## # Data Source: mongodbatlas.getAdvancedClusters
@@ -99,6 +149,51 @@ export interface GetAdvancedClustersResult {
  *     projectId: exampleAdvancedCluster.projectId,
  * });
  * ```
+ *
+ * ## Example using latest sharding schema with independent shard scaling in the cluster
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const example = new mongodbatlas.AdvancedCluster("example", {
+ *     projectId: "<YOUR-PROJECT-ID>",
+ *     name: "cluster-test",
+ *     backupEnabled: false,
+ *     clusterType: "SHARDED",
+ *     replicationSpecs: [
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M30",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M40",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *     ],
+ * });
+ * const example-asym = mongodbatlas.getAdvancedClusterOutput({
+ *     projectId: example.projectId,
+ *     name: example.name,
+ *     useReplicationSpecPerShard: true,
+ * });
+ * ```
  */
 export declare function getAdvancedClustersOutput(args: GetAdvancedClustersOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output<GetAdvancedClustersResult>;
 /**
@@ -109,4 +204,8 @@ export interface GetAdvancedClustersOutputArgs {
      * The unique ID for the project to get the clusters.
      */
     projectId: pulumi.Input<string>;
+    /**
+     * Set this field to true to allow the data source to use the latest schema representing each shard with an individual `replicationSpecs` object. This enables representing clusters with independent shard scaling. **Note:** If not set to true, this data source return all clusters except clusters with asymmetric shards.
+     */
+    useReplicationSpecPerShard?: pulumi.Input<boolean>;
 }

package/getAdvancedClusters.js

@@ -42,11 +42,57 @@ const utilities = require("./utilities");
  *     projectId: exampleAdvancedCluster.projectId,
  * });
  * ```
+ *
+ * ## Example using latest sharding schema with independent shard scaling in the cluster
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const example = new mongodbatlas.AdvancedCluster("example", {
+ *     projectId: "<YOUR-PROJECT-ID>",
+ *     name: "cluster-test",
+ *     backupEnabled: false,
+ *     clusterType: "SHARDED",
+ *     replicationSpecs: [
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M30",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M40",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *     ],
+ * });
+ * const example-asym = mongodbatlas.getAdvancedClusterOutput({
+ *     projectId: example.projectId,
+ *     name: example.name,
+ *     useReplicationSpecPerShard: true,
+ * });
+ * ```
  */
 function getAdvancedClusters(args, opts) {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
     return pulumi.runtime.invoke("mongodbatlas:index/getAdvancedClusters:getAdvancedClusters", {
         "projectId": args.projectId,
+        "useReplicationSpecPerShard": args.useReplicationSpecPerShard,
     }, opts);
 }
 exports.getAdvancedClusters = getAdvancedClusters;
@@ -87,6 +133,51 @@ exports.getAdvancedClusters = getAdvancedClusters;
  *     projectId: exampleAdvancedCluster.projectId,
  * });
  * ```
+ *
+ * ## Example using latest sharding schema with independent shard scaling in the cluster
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as mongodbatlas from "@pulumi/mongodbatlas";
+ *
+ * const example = new mongodbatlas.AdvancedCluster("example", {
+ *     projectId: "<YOUR-PROJECT-ID>",
+ *     name: "cluster-test",
+ *     backupEnabled: false,
+ *     clusterType: "SHARDED",
+ *     replicationSpecs: [
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M30",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *         {
+ *             regionConfigs: [{
+ *                 electableSpecs: {
+ *                     instanceSize: "M40",
+ *                     diskIops: 3000,
+ *                     nodeCount: 3,
+ *                 },
+ *                 providerName: "AWS",
+ *                 priority: 7,
+ *                 regionName: "EU_WEST_1",
+ *             }],
+ *         },
+ *     ],
+ * });
+ * const example-asym = mongodbatlas.getAdvancedClusterOutput({
+ *     projectId: example.projectId,
+ *     name: example.name,
+ *     useReplicationSpecPerShard: true,
+ * });
+ * ```
  */
 function getAdvancedClustersOutput(args, opts) {
     return pulumi.output(args).apply((a) => getAdvancedClusters(a, opts));

package/getAdvancedClusters.js.map

@@ -1 +1 @@
-{"version":3,"file":"getAdvancedClusters.js","sourceRoot":"","sources":["../getAdvancedClusters.ts"],"names":[],"mappings":";AAAA,wFAAwF;AACxF,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,SAAgB,mBAAmB,CAAC,IAA6B,EAAE,IAA2B;IAE1F,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,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,kDAMC;AA0BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,SAAgB,yBAAyB,CAAC,IAAmC,EAAE,IAA2B;IACtG,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;AAC9E,CAAC;AAFD,8DAEC"}
+{"version":3,"file":"getAdvancedClusters.js","sourceRoot":"","sources":["../getAdvancedClusters.ts"],"names":[],"mappings":";AAAA,wFAAwF;AACxF,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AACH,SAAgB,mBAAmB,CAAC,IAA6B,EAAE,IAA2B;IAE1F,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,WAAW,EAAE,IAAI,CAAC,SAAS;QAC3B,4BAA4B,EAAE,IAAI,CAAC,0BAA0B;KAChE,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAPD,kDAOC;AA+BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AACH,SAAgB,yBAAyB,CAAC,IAAmC,EAAE,IAA2B;IACtG,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;AAC9E,CAAC;AAFD,8DAEC"}

package/getCloudBackupSchedule.d.ts

@@ -6,42 +6,6 @@ import * as outputs from "./types/output";
  * `mongodbatlas.CloudBackupSchedule` provides a Cloud Backup Schedule datasource. An Atlas Cloud Backup Schedule provides the current cloud backup schedule for the cluster.
  *
  * > **NOTE:** Groups and projects are synonymous terms. You may find `groupId` in the official documentation.
- *
- * ## Example Usage
- *
- * ```typescript
- * import * as pulumi from "@pulumi/pulumi";
- * import * as mongodbatlas from "@pulumi/mongodbatlas";
- *
- * const myCluster = new mongodbatlas.AdvancedCluster("my_cluster", {
- *     projectId: "<PROJECT-ID>",
- *     name: "clusterTest",
- *     clusterType: "REPLICASET",
- *     backupEnabled: true,
- *     replicationSpecs: [{
- *         regionConfigs: [{
- *             priority: 7,
- *             providerName: "AWS",
- *             regionName: "EU_CENTRAL_1",
- *             electableSpecs: {
- *                 instanceSize: "M10",
- *                 nodeCount: 3,
- *             },
- *         }],
- *     }],
- * });
- * const testCloudBackupSchedule = new mongodbatlas.CloudBackupSchedule("test", {
- *     projectId: myCluster.projectId,
- *     clusterName: myCluster.name,
- *     referenceHourOfDay: 3,
- *     referenceMinuteOfHour: 45,
- *     restoreWindowDays: 4,
- * });
- * const test = mongodbatlas.getCloudBackupScheduleOutput({
- *     projectId: testCloudBackupSchedule.projectId,
- *     clusterName: testCloudBackupSchedule.clusterName,
- * });
- * ```
  */
 export declare function getCloudBackupSchedule(args: GetCloudBackupScheduleArgs, opts?: pulumi.InvokeOptions): Promise<GetCloudBackupScheduleResult>;
 /**
@@ -56,6 +20,10 @@ export interface GetCloudBackupScheduleArgs {
      * The unique identifier of the project for the Atlas cluster.
      */
     projectId: string;
+    /**
+     * Set this field to `true` to allow the data source to use the latest schema that populates `copy_settings.#.zone_id` instead of the deprecated `copy_settings.#.replication_spec_id`. These fields also enable you to reference cluster zones using independent shard scaling, which no longer supports `replication_spec.*.id`. To learn more, see the 1.18.0 upgrade guide.
+     */
+    useZoneIdForCopySettings?: boolean;
 }
 /**
  * A collection of values returned by getCloudBackupSchedule.
@@ -72,7 +40,13 @@ export interface GetCloudBackupScheduleResult {
      */
     readonly clusterId: string;
     readonly clusterName: string;
+    /**
+     * List that contains a document for each copy setting item in the desired backup policy. See below
+     */
     readonly copySettings: outputs.GetCloudBackupScheduleCopySetting[];
+    /**
+     * Policy for automatically exporting Cloud Backup Snapshots. See below
+     */
     readonly exports: outputs.GetCloudBackupScheduleExport[];
     /**
      * The provider-assigned unique ID for this managed resource.
@@ -87,23 +61,23 @@ export interface GetCloudBackupScheduleResult {
      */
     readonly nextSnapshot: string;
     /**
-     * Daily policy item
+     * (Optional) Daily policy item. See below
      */
     readonly policyItemDailies: outputs.GetCloudBackupSchedulePolicyItemDaily[];
     /**
-     * Hourly policy item
+     * (Optional) Hourly policy item. See below
      */
     readonly policyItemHourlies: outputs.GetCloudBackupSchedulePolicyItemHourly[];
     /**
-     * Monthly policy item
+     * (Optional) Monthly policy item. See below
      */
     readonly policyItemMonthlies: outputs.GetCloudBackupSchedulePolicyItemMonthly[];
     /**
-     * Weekly policy item
+     * (Optional) Weekly policy item. See below
      */
     readonly policyItemWeeklies: outputs.GetCloudBackupSchedulePolicyItemWeekly[];
     /**
-     * Yearly policy item
+     * (Optional) Yearly policy item. See below
      */
     readonly policyItemYearlies: outputs.GetCloudBackupSchedulePolicyItemYearly[];
     readonly projectId: string;
@@ -123,6 +97,7 @@ export interface GetCloudBackupScheduleResult {
      * Specify true to use organization and project names instead of organization and project UUIDs in the path for the metadata files that Atlas uploads to your S3 bucket after it finishes exporting the snapshots. To learn more about the metadata files that Atlas uploads, see [Export Cloud Backup Snapshot](https://www.mongodb.com/docs/atlas/backup/cloud-backup/export/#std-label-cloud-provider-snapshot-export).
      */
     readonly useOrgAndGroupNamesInExportPrefix: boolean;
+    readonly useZoneIdForCopySettings?: boolean;
 }
 /**
  * ## # Data Source: mongodbatlas.CloudBackupSchedule
@@ -130,42 +105,6 @@ export interface GetCloudBackupScheduleResult {
  * `mongodbatlas.CloudBackupSchedule` provides a Cloud Backup Schedule datasource. An Atlas Cloud Backup Schedule provides the current cloud backup schedule for the cluster.
  *
  * > **NOTE:** Groups and projects are synonymous terms. You may find `groupId` in the official documentation.
- *
- * ## Example Usage
- *
- * ```typescript
- * import * as pulumi from "@pulumi/pulumi";
- * import * as mongodbatlas from "@pulumi/mongodbatlas";
- *
- * const myCluster = new mongodbatlas.AdvancedCluster("my_cluster", {
- *     projectId: "<PROJECT-ID>",
- *     name: "clusterTest",
- *     clusterType: "REPLICASET",
- *     backupEnabled: true,
- *     replicationSpecs: [{
- *         regionConfigs: [{
- *             priority: 7,
- *             providerName: "AWS",
- *             regionName: "EU_CENTRAL_1",
- *             electableSpecs: {
- *                 instanceSize: "M10",
- *                 nodeCount: 3,
- *             },
- *         }],
- *     }],
- * });
- * const testCloudBackupSchedule = new mongodbatlas.CloudBackupSchedule("test", {
- *     projectId: myCluster.projectId,
- *     clusterName: myCluster.name,
- *     referenceHourOfDay: 3,
- *     referenceMinuteOfHour: 45,
- *     restoreWindowDays: 4,
- * });
- * const test = mongodbatlas.getCloudBackupScheduleOutput({
- *     projectId: testCloudBackupSchedule.projectId,
- *     clusterName: testCloudBackupSchedule.clusterName,
- * });
- * ```
  */
 export declare function getCloudBackupScheduleOutput(args: GetCloudBackupScheduleOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output<GetCloudBackupScheduleResult>;
 /**
@@ -180,4 +119,8 @@ export interface GetCloudBackupScheduleOutputArgs {
      * The unique identifier of the project for the Atlas cluster.
      */
     projectId: pulumi.Input<string>;
+    /**
+     * Set this field to `true` to allow the data source to use the latest schema that populates `copy_settings.#.zone_id` instead of the deprecated `copy_settings.#.replication_spec_id`. These fields also enable you to reference cluster zones using independent shard scaling, which no longer supports `replication_spec.*.id`. To learn more, see the 1.18.0 upgrade guide.
+     */
+    useZoneIdForCopySettings?: pulumi.Input<boolean>;
 }