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

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>;
 }

package/getCloudBackupSchedule.js

@@ -11,48 +11,13 @@ const utilities = require("./utilities");
  * `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,
- * });
- * ```
  */
 function getCloudBackupSchedule(args, opts) {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
     return pulumi.runtime.invoke("mongodbatlas:index/getCloudBackupSchedule:getCloudBackupSchedule", {
         "clusterName": args.clusterName,
         "projectId": args.projectId,
+        "useZoneIdForCopySettings": args.useZoneIdForCopySettings,
     }, opts);
 }
 exports.getCloudBackupSchedule = getCloudBackupSchedule;
@@ -62,42 +27,6 @@ exports.getCloudBackupSchedule = getCloudBackupSchedule;
  * `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,
- * });
- * ```
  */
 function getCloudBackupScheduleOutput(args, opts) {
     return pulumi.output(args).apply((a) => getCloudBackupSchedule(a, opts));

package/getCloudBackupSchedule.js.map

@@ -1 +1 @@
-{"version":3,"file":"getCloudBackupSchedule.js","sourceRoot":"","sources":["../getCloudBackupSchedule.ts"],"names":[],"mappings":";AAAA,wFAAwF;AACxF,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,SAAgB,sBAAsB,CAAC,IAAgC,EAAE,IAA2B;IAEhG,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,kEAAkE,EAAE;QAC7F,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,WAAW,EAAE,IAAI,CAAC,SAAS;KAC9B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAPD,wDAOC;AAmFD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,SAAgB,4BAA4B,CAAC,IAAsC,EAAE,IAA2B;IAC5G,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,sBAAsB,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;AACjF,CAAC;AAFD,oEAEC"}
+{"version":3,"file":"getCloudBackupSchedule.js","sourceRoot":"","sources":["../getCloudBackupSchedule.ts"],"names":[],"mappings":";AAAA,wFAAwF;AACxF,iFAAiF;;;AAEjF,yCAAyC;AAGzC,yCAAyC;AAEzC;;;;;;GAMG;AACH,SAAgB,sBAAsB,CAAC,IAAgC,EAAE,IAA2B;IAEhG,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,kEAAkE,EAAE;QAC7F,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,WAAW,EAAE,IAAI,CAAC,SAAS;QAC3B,0BAA0B,EAAE,IAAI,CAAC,wBAAwB;KAC5D,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AARD,wDAQC;AA8FD;;;;;;GAMG;AACH,SAAgB,4BAA4B,CAAC,IAAsC,EAAE,IAA2B;IAC5G,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,sBAAsB,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;AACjF,CAAC;AAFD,oEAEC"}

package/getCloudBackupSnapshotExportBucket.d.ts

@@ -33,10 +33,6 @@ export interface GetCloudBackupSnapshotExportBucketArgs {
      * Unique identifier of the snapshot export bucket.
      */
     exportBucketId: string;
-    /**
-     * @deprecated This parameter is deprecated and will be removed in version 1.18.0. Will not be an input parameter, only computed.
-     */
-    id?: string;
     /**
      * The unique identifier of the project for the Atlas cluster.
      */
@@ -47,23 +43,32 @@ export interface GetCloudBackupSnapshotExportBucketArgs {
  */
 export interface GetCloudBackupSnapshotExportBucketResult {
     /**
-     * Name of the bucket that the provided role ID is authorized to access. You must also specify the `iamRoleId`.
+     * Name of the bucket that the provided role ID is authorized to access.
      */
     readonly bucketName: string;
     /**
-     * Name of the provider of the cloud service where Atlas can access the S3 bucket. Atlas only supports `AWS`.
+     * Name of the provider of the cloud service where Atlas can access the S3 bucket.
      */
     readonly cloudProvider: string;
     readonly exportBucketId: string;
     /**
-     * Unique identifier of the role that Atlas can use to access the bucket. You must also specify the `bucketName`.
+     * Unique identifier of the role that Atlas can use to access the bucket.
      */
     readonly iamRoleId: string;
-    /**
-     * @deprecated This parameter is deprecated and will be removed in version 1.18.0. Will not be an input parameter, only computed.
-     */
     readonly id: string;
     readonly projectId: string;
+    /**
+     * Unique identifier of the Azure Service Principal that Atlas can use to access the Azure Blob Storage Container.
+     */
+    readonly roleId: string;
+    /**
+     * URL that identifies the blob Endpoint of the Azure Blob Storage Account.
+     */
+    readonly serviceUrl: string;
+    /**
+     * UUID that identifies the Azure Active Directory Tenant ID.
+     */
+    readonly tenantId: string;
 }
 /**
  * ## # Data Source: mongodbatlas.CloudBackupSnapshotExportBucket
@@ -99,10 +104,6 @@ export interface GetCloudBackupSnapshotExportBucketOutputArgs {
      * Unique identifier of the snapshot export bucket.
      */
     exportBucketId: pulumi.Input<string>;
-    /**
-     * @deprecated This parameter is deprecated and will be removed in version 1.18.0. Will not be an input parameter, only computed.
-     */
-    id?: pulumi.Input<string>;
     /**
      * The unique identifier of the project for the Atlas cluster.
      */