mongodbatlas.BackupCompliancePolicy

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: region,
            electableSpecs: {
                instanceSize: "M10",
                nodeCount: 3,
            },
        }],
    }],
});
const testCloudBackupSchedule = new mongodbatlas.CloudBackupSchedule("test", {
    projectId: myCluster.projectId,
    clusterName: myCluster.name,
    referenceHourOfDay: 3,
    referenceMinuteOfHour: 45,
    restoreWindowDays: 4,
    policyItemHourly: {
        frequencyInterval: 1,
        retentionUnit: "days",
        retentionValue: 7,
    },
    policyItemDaily: {
        frequencyInterval: 1,
        retentionUnit: "days",
        retentionValue: 7,
    },
    policyItemWeeklies: [{
        frequencyInterval: 1,
        retentionUnit: "weeks",
        retentionValue: 4,
    }],
    policyItemMonthlies: [{
        frequencyInterval: 1,
        retentionUnit: "months",
        retentionValue: 12,
    }],
    policyItemYearlies: [{
        frequencyInterval: 1,
        retentionUnit: "years",
        retentionValue: 1,
    }],
});
const test = mongodbatlas.getCloudBackupScheduleOutput({
    projectId: testCloudBackupSchedule.projectId,
    clusterName: testCloudBackupSchedule.clusterName,
});
const backupPolicy = mongodbatlas.getBackupCompliancePolicyOutput({
    projectId: testCloudBackupSchedule.projectId,
});
const backupPolicyBackupCompliancePolicy = new mongodbatlas.BackupCompliancePolicy("backup_policy", {
    projectId: "<PROJECT-ID>",
    authorizedEmail: "user@email.com",
    authorizedUserFirstName: "First",
    authorizedUserLastName: "Last",
    copyProtectionEnabled: false,
    pitEnabled: false,
    encryptionAtRestEnabled: false,
    restoreWindowDays: 7,
    onDemandPolicyItem: {
        frequencyInterval: 1,
        retentionUnit: "days",
        retentionValue: 3,
    },
    policyItemHourly: {
        frequencyInterval: 1,
        retentionUnit: "days",
        retentionValue: 7,
    },
    policyItemDaily: {
        frequencyInterval: 1,
        retentionUnit: "days",
        retentionValue: 7,
    },
    policyItemWeeklies: [{
        frequencyInterval: 1,
        retentionUnit: "weeks",
        retentionValue: 4,
    }],
    policyItemMonthlies: [{
        frequencyInterval: 1,
        retentionUnit: "months",
        retentionValue: 12,
    }],
    policyItemYearlies: [{
        frequencyInterval: 1,
        retentionUnit: "years",
        retentionValue: 1,
    }],
});

import pulumi
import pulumi_mongodbatlas as mongodbatlas

my_cluster = mongodbatlas.AdvancedCluster("my_cluster",
    project_id="<PROJECT-ID>",
    name="clusterTest",
    cluster_type="REPLICASET",
    backup_enabled=True,
    replication_specs=[{
        "region_configs": [{
            "priority": 7,
            "provider_name": "AWS",
            "region_name": region,
            "electable_specs": {
                "instance_size": "M10",
                "node_count": 3,
            },
        }],
    }])
test_cloud_backup_schedule = mongodbatlas.CloudBackupSchedule("test",
    project_id=my_cluster.project_id,
    cluster_name=my_cluster.name,
    reference_hour_of_day=3,
    reference_minute_of_hour=45,
    restore_window_days=4,
    policy_item_hourly={
        "frequency_interval": 1,
        "retention_unit": "days",
        "retention_value": 7,
    },
    policy_item_daily={
        "frequency_interval": 1,
        "retention_unit": "days",
        "retention_value": 7,
    },
    policy_item_weeklies=[{
        "frequency_interval": 1,
        "retention_unit": "weeks",
        "retention_value": 4,
    }],
    policy_item_monthlies=[{
        "frequency_interval": 1,
        "retention_unit": "months",
        "retention_value": 12,
    }],
    policy_item_yearlies=[{
        "frequency_interval": 1,
        "retention_unit": "years",
        "retention_value": 1,
    }])
test = mongodbatlas.get_cloud_backup_schedule_output(project_id=test_cloud_backup_schedule.project_id,
    cluster_name=test_cloud_backup_schedule.cluster_name)
backup_policy = mongodbatlas.get_backup_compliance_policy_output(project_id=test_cloud_backup_schedule.project_id)
backup_policy_backup_compliance_policy = mongodbatlas.BackupCompliancePolicy("backup_policy",
    project_id="<PROJECT-ID>",
    authorized_email="user@email.com",
    authorized_user_first_name="First",
    authorized_user_last_name="Last",
    copy_protection_enabled=False,
    pit_enabled=False,
    encryption_at_rest_enabled=False,
    restore_window_days=7,
    on_demand_policy_item={
        "frequency_interval": 1,
        "retention_unit": "days",
        "retention_value": 3,
    },
    policy_item_hourly={
        "frequency_interval": 1,
        "retention_unit": "days",
        "retention_value": 7,
    },
    policy_item_daily={
        "frequency_interval": 1,
        "retention_unit": "days",
        "retention_value": 7,
    },
    policy_item_weeklies=[{
        "frequency_interval": 1,
        "retention_unit": "weeks",
        "retention_value": 4,
    }],
    policy_item_monthlies=[{
        "frequency_interval": 1,
        "retention_unit": "months",
        "retention_value": 12,
    }],
    policy_item_yearlies=[{
        "frequency_interval": 1,
        "retention_unit": "years",
        "retention_value": 1,
    }])

package main

import (
	"github.com/pulumi/pulumi-mongodbatlas/sdk/v3/go/mongodbatlas"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myCluster, err := mongodbatlas.NewAdvancedCluster(ctx, "my_cluster", &mongodbatlas.AdvancedClusterArgs{
			ProjectId:     pulumi.String("<PROJECT-ID>"),
			Name:          pulumi.String("clusterTest"),
			ClusterType:   pulumi.String("REPLICASET"),
			BackupEnabled: pulumi.Bool(true),
			ReplicationSpecs: mongodbatlas.AdvancedClusterReplicationSpecArray{
				&mongodbatlas.AdvancedClusterReplicationSpecArgs{
					RegionConfigs: mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArray{
						&mongodbatlas.AdvancedClusterReplicationSpecRegionConfigArgs{
							Priority:     pulumi.Int(7),
							ProviderName: pulumi.String("AWS"),
							RegionName:   pulumi.Any(region),
							ElectableSpecs: &mongodbatlas.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs{
								InstanceSize: pulumi.String("M10"),
								NodeCount:    pulumi.Int(3),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		testCloudBackupSchedule, err := mongodbatlas.NewCloudBackupSchedule(ctx, "test", &mongodbatlas.CloudBackupScheduleArgs{
			ProjectId:             myCluster.ProjectId,
			ClusterName:           myCluster.Name,
			ReferenceHourOfDay:    pulumi.Int(3),
			ReferenceMinuteOfHour: pulumi.Int(45),
			RestoreWindowDays:     pulumi.Int(4),
			PolicyItemHourly: &mongodbatlas.CloudBackupSchedulePolicyItemHourlyArgs{
				FrequencyInterval: pulumi.Int(1),
				RetentionUnit:     pulumi.String("days"),
				RetentionValue:    pulumi.Int(7),
			},
			PolicyItemDaily: &mongodbatlas.CloudBackupSchedulePolicyItemDailyArgs{
				FrequencyInterval: pulumi.Int(1),
				RetentionUnit:     pulumi.String("days"),
				RetentionValue:    pulumi.Int(7),
			},
			PolicyItemWeeklies: mongodbatlas.CloudBackupSchedulePolicyItemWeeklyArray{
				&mongodbatlas.CloudBackupSchedulePolicyItemWeeklyArgs{
					FrequencyInterval: pulumi.Int(1),
					RetentionUnit:     pulumi.String("weeks"),
					RetentionValue:    pulumi.Int(4),
				},
			},
			PolicyItemMonthlies: mongodbatlas.CloudBackupSchedulePolicyItemMonthlyArray{
				&mongodbatlas.CloudBackupSchedulePolicyItemMonthlyArgs{
					FrequencyInterval: pulumi.Int(1),
					RetentionUnit:     pulumi.String("months"),
					RetentionValue:    pulumi.Int(12),
				},
			},
			PolicyItemYearlies: mongodbatlas.CloudBackupSchedulePolicyItemYearlyArray{
				&mongodbatlas.CloudBackupSchedulePolicyItemYearlyArgs{
					FrequencyInterval: pulumi.Int(1),
					RetentionUnit:     pulumi.String("years"),
					RetentionValue:    pulumi.Int(1),
				},
			},
		})
		if err != nil {
			return err
		}
		_ = mongodbatlas.LookupCloudBackupScheduleOutput(ctx, mongodbatlas.GetCloudBackupScheduleOutputArgs{
			ProjectId:   testCloudBackupSchedule.ProjectId,
			ClusterName: testCloudBackupSchedule.ClusterName,
		}, nil)
		_ = mongodbatlas.LookupBackupCompliancePolicyOutput(ctx, mongodbatlas.GetBackupCompliancePolicyOutputArgs{
			ProjectId: testCloudBackupSchedule.ProjectId,
		}, nil)
		_, err = mongodbatlas.NewBackupCompliancePolicy(ctx, "backup_policy", &mongodbatlas.BackupCompliancePolicyArgs{
			ProjectId:               pulumi.String("<PROJECT-ID>"),
			AuthorizedEmail:         pulumi.String("user@email.com"),
			AuthorizedUserFirstName: pulumi.String("First"),
			AuthorizedUserLastName:  pulumi.String("Last"),
			CopyProtectionEnabled:   pulumi.Bool(false),
			PitEnabled:              pulumi.Bool(false),
			EncryptionAtRestEnabled: pulumi.Bool(false),
			RestoreWindowDays:       pulumi.Int(7),
			OnDemandPolicyItem: &mongodbatlas.BackupCompliancePolicyOnDemandPolicyItemArgs{
				FrequencyInterval: pulumi.Int(1),
				RetentionUnit:     pulumi.String("days"),
				RetentionValue:    pulumi.Int(3),
			},
			PolicyItemHourly: &mongodbatlas.BackupCompliancePolicyPolicyItemHourlyArgs{
				FrequencyInterval: pulumi.Int(1),
				RetentionUnit:     pulumi.String("days"),
				RetentionValue:    pulumi.Int(7),
			},
			PolicyItemDaily: &mongodbatlas.BackupCompliancePolicyPolicyItemDailyArgs{
				FrequencyInterval: pulumi.Int(1),
				RetentionUnit:     pulumi.String("days"),
				RetentionValue:    pulumi.Int(7),
			},
			PolicyItemWeeklies: mongodbatlas.BackupCompliancePolicyPolicyItemWeeklyArray{
				&mongodbatlas.BackupCompliancePolicyPolicyItemWeeklyArgs{
					FrequencyInterval: pulumi.Int(1),
					RetentionUnit:     pulumi.String("weeks"),
					RetentionValue:    pulumi.Int(4),
				},
			},
			PolicyItemMonthlies: mongodbatlas.BackupCompliancePolicyPolicyItemMonthlyArray{
				&mongodbatlas.BackupCompliancePolicyPolicyItemMonthlyArgs{
					FrequencyInterval: pulumi.Int(1),
					RetentionUnit:     pulumi.String("months"),
					RetentionValue:    pulumi.Int(12),
				},
			},
			PolicyItemYearlies: mongodbatlas.BackupCompliancePolicyPolicyItemYearlyArray{
				&mongodbatlas.BackupCompliancePolicyPolicyItemYearlyArgs{
					FrequencyInterval: pulumi.Int(1),
					RetentionUnit:     pulumi.String("years"),
					RetentionValue:    pulumi.Int(1),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Mongodbatlas = Pulumi.Mongodbatlas;

return await Deployment.RunAsync(() => 
{
    var myCluster = new Mongodbatlas.AdvancedCluster("my_cluster", new()
    {
        ProjectId = "<PROJECT-ID>",
        Name = "clusterTest",
        ClusterType = "REPLICASET",
        BackupEnabled = true,
        ReplicationSpecs = new[]
        {
            new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecArgs
            {
                RegionConfigs = new[]
                {
                    new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigArgs
                    {
                        Priority = 7,
                        ProviderName = "AWS",
                        RegionName = region,
                        ElectableSpecs = new Mongodbatlas.Inputs.AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs
                        {
                            InstanceSize = "M10",
                            NodeCount = 3,
                        },
                    },
                },
            },
        },
    });

    var testCloudBackupSchedule = new Mongodbatlas.CloudBackupSchedule("test", new()
    {
        ProjectId = myCluster.ProjectId,
        ClusterName = myCluster.Name,
        ReferenceHourOfDay = 3,
        ReferenceMinuteOfHour = 45,
        RestoreWindowDays = 4,
        PolicyItemHourly = new Mongodbatlas.Inputs.CloudBackupSchedulePolicyItemHourlyArgs
        {
            FrequencyInterval = 1,
            RetentionUnit = "days",
            RetentionValue = 7,
        },
        PolicyItemDaily = new Mongodbatlas.Inputs.CloudBackupSchedulePolicyItemDailyArgs
        {
            FrequencyInterval = 1,
            RetentionUnit = "days",
            RetentionValue = 7,
        },
        PolicyItemWeeklies = new[]
        {
            new Mongodbatlas.Inputs.CloudBackupSchedulePolicyItemWeeklyArgs
            {
                FrequencyInterval = 1,
                RetentionUnit = "weeks",
                RetentionValue = 4,
            },
        },
        PolicyItemMonthlies = new[]
        {
            new Mongodbatlas.Inputs.CloudBackupSchedulePolicyItemMonthlyArgs
            {
                FrequencyInterval = 1,
                RetentionUnit = "months",
                RetentionValue = 12,
            },
        },
        PolicyItemYearlies = new[]
        {
            new Mongodbatlas.Inputs.CloudBackupSchedulePolicyItemYearlyArgs
            {
                FrequencyInterval = 1,
                RetentionUnit = "years",
                RetentionValue = 1,
            },
        },
    });

    var test = Mongodbatlas.GetCloudBackupSchedule.Invoke(new()
    {
        ProjectId = testCloudBackupSchedule.ProjectId,
        ClusterName = testCloudBackupSchedule.ClusterName,
    });

    var backupPolicy = Mongodbatlas.GetBackupCompliancePolicy.Invoke(new()
    {
        ProjectId = testCloudBackupSchedule.ProjectId,
    });

    var backupPolicyBackupCompliancePolicy = new Mongodbatlas.BackupCompliancePolicy("backup_policy", new()
    {
        ProjectId = "<PROJECT-ID>",
        AuthorizedEmail = "user@email.com",
        AuthorizedUserFirstName = "First",
        AuthorizedUserLastName = "Last",
        CopyProtectionEnabled = false,
        PitEnabled = false,
        EncryptionAtRestEnabled = false,
        RestoreWindowDays = 7,
        OnDemandPolicyItem = new Mongodbatlas.Inputs.BackupCompliancePolicyOnDemandPolicyItemArgs
        {
            FrequencyInterval = 1,
            RetentionUnit = "days",
            RetentionValue = 3,
        },
        PolicyItemHourly = new Mongodbatlas.Inputs.BackupCompliancePolicyPolicyItemHourlyArgs
        {
            FrequencyInterval = 1,
            RetentionUnit = "days",
            RetentionValue = 7,
        },
        PolicyItemDaily = new Mongodbatlas.Inputs.BackupCompliancePolicyPolicyItemDailyArgs
        {
            FrequencyInterval = 1,
            RetentionUnit = "days",
            RetentionValue = 7,
        },
        PolicyItemWeeklies = new[]
        {
            new Mongodbatlas.Inputs.BackupCompliancePolicyPolicyItemWeeklyArgs
            {
                FrequencyInterval = 1,
                RetentionUnit = "weeks",
                RetentionValue = 4,
            },
        },
        PolicyItemMonthlies = new[]
        {
            new Mongodbatlas.Inputs.BackupCompliancePolicyPolicyItemMonthlyArgs
            {
                FrequencyInterval = 1,
                RetentionUnit = "months",
                RetentionValue = 12,
            },
        },
        PolicyItemYearlies = new[]
        {
            new Mongodbatlas.Inputs.BackupCompliancePolicyPolicyItemYearlyArgs
            {
                FrequencyInterval = 1,
                RetentionUnit = "years",
                RetentionValue = 1,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.AdvancedCluster;
import com.pulumi.mongodbatlas.AdvancedClusterArgs;
import com.pulumi.mongodbatlas.inputs.AdvancedClusterReplicationSpecArgs;
import com.pulumi.mongodbatlas.CloudBackupSchedule;
import com.pulumi.mongodbatlas.CloudBackupScheduleArgs;
import com.pulumi.mongodbatlas.inputs.CloudBackupSchedulePolicyItemHourlyArgs;
import com.pulumi.mongodbatlas.inputs.CloudBackupSchedulePolicyItemDailyArgs;
import com.pulumi.mongodbatlas.inputs.CloudBackupSchedulePolicyItemWeeklyArgs;
import com.pulumi.mongodbatlas.inputs.CloudBackupSchedulePolicyItemMonthlyArgs;
import com.pulumi.mongodbatlas.inputs.CloudBackupSchedulePolicyItemYearlyArgs;
import com.pulumi.mongodbatlas.MongodbatlasFunctions;
import com.pulumi.mongodbatlas.inputs.GetCloudBackupScheduleArgs;
import com.pulumi.mongodbatlas.inputs.GetBackupCompliancePolicyArgs;
import com.pulumi.mongodbatlas.BackupCompliancePolicy;
import com.pulumi.mongodbatlas.BackupCompliancePolicyArgs;
import com.pulumi.mongodbatlas.inputs.BackupCompliancePolicyOnDemandPolicyItemArgs;
import com.pulumi.mongodbatlas.inputs.BackupCompliancePolicyPolicyItemHourlyArgs;
import com.pulumi.mongodbatlas.inputs.BackupCompliancePolicyPolicyItemDailyArgs;
import com.pulumi.mongodbatlas.inputs.BackupCompliancePolicyPolicyItemWeeklyArgs;
import com.pulumi.mongodbatlas.inputs.BackupCompliancePolicyPolicyItemMonthlyArgs;
import com.pulumi.mongodbatlas.inputs.BackupCompliancePolicyPolicyItemYearlyArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var myCluster = new AdvancedCluster("myCluster", AdvancedClusterArgs.builder()
            .projectId("<PROJECT-ID>")
            .name("clusterTest")
            .clusterType("REPLICASET")
            .backupEnabled(true)
            .replicationSpecs(AdvancedClusterReplicationSpecArgs.builder()
                .regionConfigs(AdvancedClusterReplicationSpecRegionConfigArgs.builder()
                    .priority(7)
                    .providerName("AWS")
                    .regionName(region)
                    .electableSpecs(AdvancedClusterReplicationSpecRegionConfigElectableSpecsArgs.builder()
                        .instanceSize("M10")
                        .nodeCount(3)
                        .build())
                    .build())
                .build())
            .build());

        var testCloudBackupSchedule = new CloudBackupSchedule("testCloudBackupSchedule", CloudBackupScheduleArgs.builder()
            .projectId(myCluster.projectId())
            .clusterName(myCluster.name())
            .referenceHourOfDay(3)
            .referenceMinuteOfHour(45)
            .restoreWindowDays(4)
            .policyItemHourly(CloudBackupSchedulePolicyItemHourlyArgs.builder()
                .frequencyInterval(1)
                .retentionUnit("days")
                .retentionValue(7)
                .build())
            .policyItemDaily(CloudBackupSchedulePolicyItemDailyArgs.builder()
                .frequencyInterval(1)
                .retentionUnit("days")
                .retentionValue(7)
                .build())
            .policyItemWeeklies(CloudBackupSchedulePolicyItemWeeklyArgs.builder()
                .frequencyInterval(1)
                .retentionUnit("weeks")
                .retentionValue(4)
                .build())
            .policyItemMonthlies(CloudBackupSchedulePolicyItemMonthlyArgs.builder()
                .frequencyInterval(1)
                .retentionUnit("months")
                .retentionValue(12)
                .build())
            .policyItemYearlies(CloudBackupSchedulePolicyItemYearlyArgs.builder()
                .frequencyInterval(1)
                .retentionUnit("years")
                .retentionValue(1)
                .build())
            .build());

        final var test = MongodbatlasFunctions.getCloudBackupSchedule(GetCloudBackupScheduleArgs.builder()
            .projectId(testCloudBackupSchedule.projectId())
            .clusterName(testCloudBackupSchedule.clusterName())
            .build());

        final var backupPolicy = MongodbatlasFunctions.getBackupCompliancePolicy(GetBackupCompliancePolicyArgs.builder()
            .projectId(testCloudBackupSchedule.projectId())
            .build());

        var backupPolicyBackupCompliancePolicy = new BackupCompliancePolicy("backupPolicyBackupCompliancePolicy", BackupCompliancePolicyArgs.builder()
            .projectId("<PROJECT-ID>")
            .authorizedEmail("user@email.com")
            .authorizedUserFirstName("First")
            .authorizedUserLastName("Last")
            .copyProtectionEnabled(false)
            .pitEnabled(false)
            .encryptionAtRestEnabled(false)
            .restoreWindowDays(7)
            .onDemandPolicyItem(BackupCompliancePolicyOnDemandPolicyItemArgs.builder()
                .frequencyInterval(1)
                .retentionUnit("days")
                .retentionValue(3)
                .build())
            .policyItemHourly(BackupCompliancePolicyPolicyItemHourlyArgs.builder()
                .frequencyInterval(1)
                .retentionUnit("days")
                .retentionValue(7)
                .build())
            .policyItemDaily(BackupCompliancePolicyPolicyItemDailyArgs.builder()
                .frequencyInterval(1)
                .retentionUnit("days")
                .retentionValue(7)
                .build())
            .policyItemWeeklies(BackupCompliancePolicyPolicyItemWeeklyArgs.builder()
                .frequencyInterval(1)
                .retentionUnit("weeks")
                .retentionValue(4)
                .build())
            .policyItemMonthlies(BackupCompliancePolicyPolicyItemMonthlyArgs.builder()
                .frequencyInterval(1)
                .retentionUnit("months")
                .retentionValue(12)
                .build())
            .policyItemYearlies(BackupCompliancePolicyPolicyItemYearlyArgs.builder()
                .frequencyInterval(1)
                .retentionUnit("years")
                .retentionValue(1)
                .build())
            .build());

    }
}

resources:
  myCluster:
    type: mongodbatlas:AdvancedCluster
    name: my_cluster
    properties:
      projectId: <PROJECT-ID>
      name: clusterTest
      clusterType: REPLICASET
      backupEnabled: true # enable cloud backup snapshots
      replicationSpecs:
        - regionConfigs:
            - priority: 7
              providerName: AWS
              regionName: ${region}
              electableSpecs:
                instanceSize: M10
                nodeCount: 3
  testCloudBackupSchedule:
    type: mongodbatlas:CloudBackupSchedule
    name: test
    properties:
      projectId: ${myCluster.projectId}
      clusterName: ${myCluster.name}
      referenceHourOfDay: 3
      referenceMinuteOfHour: 45
      restoreWindowDays: 4 # This will now add the desired policy items to the existing mongodbatlas_cloud_backup_schedule resource
      policyItemHourly:
        frequencyInterval: 1
        retentionUnit: days
        retentionValue: 7
      policyItemDaily:
        frequencyInterval: 1
        retentionUnit: days
        retentionValue: 7
      policyItemWeeklies:
        - frequencyInterval: 1
          retentionUnit: weeks
          retentionValue: 4
      policyItemMonthlies:
        - frequencyInterval: 1
          retentionUnit: months
          retentionValue: 12
      policyItemYearlies:
        - frequencyInterval: 1
          retentionUnit: years
          retentionValue: 1
  backupPolicyBackupCompliancePolicy:
    type: mongodbatlas:BackupCompliancePolicy
    name: backup_policy
    properties:
      projectId: <PROJECT-ID>
      authorizedEmail: user@email.com
      authorizedUserFirstName: First
      authorizedUserLastName: Last
      copyProtectionEnabled: false
      pitEnabled: false
      encryptionAtRestEnabled: false
      restoreWindowDays: 7
      onDemandPolicyItem:
        frequencyInterval: 1
        retentionUnit: days
        retentionValue: 3
      policyItemHourly:
        frequencyInterval: 1
        retentionUnit: days
        retentionValue: 7
      policyItemDaily:
        frequencyInterval: 1
        retentionUnit: days
        retentionValue: 7
      policyItemWeeklies:
        - frequencyInterval: 1
          retentionUnit: weeks
          retentionValue: 4
      policyItemMonthlies:
        - frequencyInterval: 1
          retentionUnit: months
          retentionValue: 12
      policyItemYearlies:
        - frequencyInterval: 1
          retentionUnit: years
          retentionValue: 1
variables:
  test:
    fn::invoke:
      Function: mongodbatlas:getCloudBackupSchedule
      Arguments:
        projectId: ${testCloudBackupSchedule.projectId}
        clusterName: ${testCloudBackupSchedule.clusterName}
  backupPolicy:
    fn::invoke:
      Function: mongodbatlas:getBackupCompliancePolicy
      Arguments:
        projectId: ${testCloudBackupSchedule.projectId}

var backupCompliancePolicyResource = new Mongodbatlas.BackupCompliancePolicy("backupCompliancePolicyResource", new()
{
    OnDemandPolicyItem = new Mongodbatlas.Inputs.BackupCompliancePolicyOnDemandPolicyItemArgs
    {
        FrequencyInterval = 0,
        RetentionUnit = "string",
        RetentionValue = 0,
        FrequencyType = "string",
        Id = "string",
    },
    AuthorizedUserFirstName = "string",
    AuthorizedUserLastName = "string",
    ProjectId = "string",
    AuthorizedEmail = "string",
    PitEnabled = false,
    EncryptionAtRestEnabled = false,
    PolicyItemDaily = new Mongodbatlas.Inputs.BackupCompliancePolicyPolicyItemDailyArgs
    {
        FrequencyInterval = 0,
        RetentionUnit = "string",
        RetentionValue = 0,
        FrequencyType = "string",
        Id = "string",
    },
    PolicyItemHourly = new Mongodbatlas.Inputs.BackupCompliancePolicyPolicyItemHourlyArgs
    {
        FrequencyInterval = 0,
        RetentionUnit = "string",
        RetentionValue = 0,
        FrequencyType = "string",
        Id = "string",
    },
    PolicyItemMonthlies = new[]
    {
        new Mongodbatlas.Inputs.BackupCompliancePolicyPolicyItemMonthlyArgs
        {
            FrequencyInterval = 0,
            RetentionUnit = "string",
            RetentionValue = 0,
            FrequencyType = "string",
            Id = "string",
        },
    },
    PolicyItemWeeklies = new[]
    {
        new Mongodbatlas.Inputs.BackupCompliancePolicyPolicyItemWeeklyArgs
        {
            FrequencyInterval = 0,
            RetentionUnit = "string",
            RetentionValue = 0,
            FrequencyType = "string",
            Id = "string",
        },
    },
    PolicyItemYearlies = new[]
    {
        new Mongodbatlas.Inputs.BackupCompliancePolicyPolicyItemYearlyArgs
        {
            FrequencyInterval = 0,
            RetentionUnit = "string",
            RetentionValue = 0,
            FrequencyType = "string",
            Id = "string",
        },
    },
    CopyProtectionEnabled = false,
    RestoreWindowDays = 0,
});

example, err := mongodbatlas.NewBackupCompliancePolicy(ctx, "backupCompliancePolicyResource", &mongodbatlas.BackupCompliancePolicyArgs{
	OnDemandPolicyItem: &mongodbatlas.BackupCompliancePolicyOnDemandPolicyItemArgs{
		FrequencyInterval: pulumi.Int(0),
		RetentionUnit:     pulumi.String("string"),
		RetentionValue:    pulumi.Int(0),
		FrequencyType:     pulumi.String("string"),
		Id:                pulumi.String("string"),
	},
	AuthorizedUserFirstName: pulumi.String("string"),
	AuthorizedUserLastName:  pulumi.String("string"),
	ProjectId:               pulumi.String("string"),
	AuthorizedEmail:         pulumi.String("string"),
	PitEnabled:              pulumi.Bool(false),
	EncryptionAtRestEnabled: pulumi.Bool(false),
	PolicyItemDaily: &mongodbatlas.BackupCompliancePolicyPolicyItemDailyArgs{
		FrequencyInterval: pulumi.Int(0),
		RetentionUnit:     pulumi.String("string"),
		RetentionValue:    pulumi.Int(0),
		FrequencyType:     pulumi.String("string"),
		Id:                pulumi.String("string"),
	},
	PolicyItemHourly: &mongodbatlas.BackupCompliancePolicyPolicyItemHourlyArgs{
		FrequencyInterval: pulumi.Int(0),
		RetentionUnit:     pulumi.String("string"),
		RetentionValue:    pulumi.Int(0),
		FrequencyType:     pulumi.String("string"),
		Id:                pulumi.String("string"),
	},
	PolicyItemMonthlies: mongodbatlas.BackupCompliancePolicyPolicyItemMonthlyArray{
		&mongodbatlas.BackupCompliancePolicyPolicyItemMonthlyArgs{
			FrequencyInterval: pulumi.Int(0),
			RetentionUnit:     pulumi.String("string"),
			RetentionValue:    pulumi.Int(0),
			FrequencyType:     pulumi.String("string"),
			Id:                pulumi.String("string"),
		},
	},
	PolicyItemWeeklies: mongodbatlas.BackupCompliancePolicyPolicyItemWeeklyArray{
		&mongodbatlas.BackupCompliancePolicyPolicyItemWeeklyArgs{
			FrequencyInterval: pulumi.Int(0),
			RetentionUnit:     pulumi.String("string"),
			RetentionValue:    pulumi.Int(0),
			FrequencyType:     pulumi.String("string"),
			Id:                pulumi.String("string"),
		},
	},
	PolicyItemYearlies: mongodbatlas.BackupCompliancePolicyPolicyItemYearlyArray{
		&mongodbatlas.BackupCompliancePolicyPolicyItemYearlyArgs{
			FrequencyInterval: pulumi.Int(0),
			RetentionUnit:     pulumi.String("string"),
			RetentionValue:    pulumi.Int(0),
			FrequencyType:     pulumi.String("string"),
			Id:                pulumi.String("string"),
		},
	},
	CopyProtectionEnabled: pulumi.Bool(false),
	RestoreWindowDays:     pulumi.Int(0),
})

var backupCompliancePolicyResource = new BackupCompliancePolicy("backupCompliancePolicyResource", BackupCompliancePolicyArgs.builder()
    .onDemandPolicyItem(BackupCompliancePolicyOnDemandPolicyItemArgs.builder()
        .frequencyInterval(0)
        .retentionUnit("string")
        .retentionValue(0)
        .frequencyType("string")
        .id("string")
        .build())
    .authorizedUserFirstName("string")
    .authorizedUserLastName("string")
    .projectId("string")
    .authorizedEmail("string")
    .pitEnabled(false)
    .encryptionAtRestEnabled(false)
    .policyItemDaily(BackupCompliancePolicyPolicyItemDailyArgs.builder()
        .frequencyInterval(0)
        .retentionUnit("string")
        .retentionValue(0)
        .frequencyType("string")
        .id("string")
        .build())
    .policyItemHourly(BackupCompliancePolicyPolicyItemHourlyArgs.builder()
        .frequencyInterval(0)
        .retentionUnit("string")
        .retentionValue(0)
        .frequencyType("string")
        .id("string")
        .build())
    .policyItemMonthlies(BackupCompliancePolicyPolicyItemMonthlyArgs.builder()
        .frequencyInterval(0)
        .retentionUnit("string")
        .retentionValue(0)
        .frequencyType("string")
        .id("string")
        .build())
    .policyItemWeeklies(BackupCompliancePolicyPolicyItemWeeklyArgs.builder()
        .frequencyInterval(0)
        .retentionUnit("string")
        .retentionValue(0)
        .frequencyType("string")
        .id("string")
        .build())
    .policyItemYearlies(BackupCompliancePolicyPolicyItemYearlyArgs.builder()
        .frequencyInterval(0)
        .retentionUnit("string")
        .retentionValue(0)
        .frequencyType("string")
        .id("string")
        .build())
    .copyProtectionEnabled(false)
    .restoreWindowDays(0)
    .build());

backup_compliance_policy_resource = mongodbatlas.BackupCompliancePolicy("backupCompliancePolicyResource",
    on_demand_policy_item={
        "frequency_interval": 0,
        "retention_unit": "string",
        "retention_value": 0,
        "frequency_type": "string",
        "id": "string",
    },
    authorized_user_first_name="string",
    authorized_user_last_name="string",
    project_id="string",
    authorized_email="string",
    pit_enabled=False,
    encryption_at_rest_enabled=False,
    policy_item_daily={
        "frequency_interval": 0,
        "retention_unit": "string",
        "retention_value": 0,
        "frequency_type": "string",
        "id": "string",
    },
    policy_item_hourly={
        "frequency_interval": 0,
        "retention_unit": "string",
        "retention_value": 0,
        "frequency_type": "string",
        "id": "string",
    },
    policy_item_monthlies=[{
        "frequency_interval": 0,
        "retention_unit": "string",
        "retention_value": 0,
        "frequency_type": "string",
        "id": "string",
    }],
    policy_item_weeklies=[{
        "frequency_interval": 0,
        "retention_unit": "string",
        "retention_value": 0,
        "frequency_type": "string",
        "id": "string",
    }],
    policy_item_yearlies=[{
        "frequency_interval": 0,
        "retention_unit": "string",
        "retention_value": 0,
        "frequency_type": "string",
        "id": "string",
    }],
    copy_protection_enabled=False,
    restore_window_days=0)

const backupCompliancePolicyResource = new mongodbatlas.BackupCompliancePolicy("backupCompliancePolicyResource", {
    onDemandPolicyItem: {
        frequencyInterval: 0,
        retentionUnit: "string",
        retentionValue: 0,
        frequencyType: "string",
        id: "string",
    },
    authorizedUserFirstName: "string",
    authorizedUserLastName: "string",
    projectId: "string",
    authorizedEmail: "string",
    pitEnabled: false,
    encryptionAtRestEnabled: false,
    policyItemDaily: {
        frequencyInterval: 0,
        retentionUnit: "string",
        retentionValue: 0,
        frequencyType: "string",
        id: "string",
    },
    policyItemHourly: {
        frequencyInterval: 0,
        retentionUnit: "string",
        retentionValue: 0,
        frequencyType: "string",
        id: "string",
    },
    policyItemMonthlies: [{
        frequencyInterval: 0,
        retentionUnit: "string",
        retentionValue: 0,
        frequencyType: "string",
        id: "string",
    }],
    policyItemWeeklies: [{
        frequencyInterval: 0,
        retentionUnit: "string",
        retentionValue: 0,
        frequencyType: "string",
        id: "string",
    }],
    policyItemYearlies: [{
        frequencyInterval: 0,
        retentionUnit: "string",
        retentionValue: 0,
        frequencyType: "string",
        id: "string",
    }],
    copyProtectionEnabled: false,
    restoreWindowDays: 0,
});

type: mongodbatlas:BackupCompliancePolicy
properties:
    authorizedEmail: string
    authorizedUserFirstName: string
    authorizedUserLastName: string
    copyProtectionEnabled: false
    encryptionAtRestEnabled: false
    onDemandPolicyItem:
        frequencyInterval: 0
        frequencyType: string
        id: string
        retentionUnit: string
        retentionValue: 0
    pitEnabled: false
    policyItemDaily:
        frequencyInterval: 0
        frequencyType: string
        id: string
        retentionUnit: string
        retentionValue: 0
    policyItemHourly:
        frequencyInterval: 0
        frequencyType: string
        id: string
        retentionUnit: string
        retentionValue: 0
    policyItemMonthlies:
        - frequencyInterval: 0
          frequencyType: string
          id: string
          retentionUnit: string
          retentionValue: 0
    policyItemWeeklies:
        - frequencyInterval: 0
          frequencyType: string
          id: string
          retentionUnit: string
          retentionValue: 0
    policyItemYearlies:
        - frequencyInterval: 0
          frequencyType: string
          id: string
          retentionUnit: string
          retentionValue: 0
    projectId: string
    restoreWindowDays: 0