using Pulumi;
using AliCloud = Pulumi.AliCloud;

class MyStack : Stack
{
    public MyStack()
    {
        var config = new Config();
        var name = config.Get("name") ?? "tf-testAccReplicationVault";
        var regionSource = config.Get("regionSource") ?? "you Replication value source region";
        var source = new AliCloud.Provider("source", new AliCloud.ProviderArgs
        {
            Region = regionSource,
        });
        var defaultVault = new AliCloud.Hbr.Vault("defaultVault", new AliCloud.Hbr.VaultArgs
        {
            VaultName = name,
        }, new CustomResourceOptions
        {
            Provider = alicloud.Source,
        });
        var defaultReplicationVaultRegions = Output.Create(AliCloud.Hbr.GetReplicationVaultRegions.InvokeAsync());
        var regionReplication = defaultReplicationVaultRegions.Apply(defaultReplicationVaultRegions => defaultReplicationVaultRegions.Regions?[0]?.ReplicationRegionId);
        var replication = new AliCloud.Provider("replication", new AliCloud.ProviderArgs
        {
            Region = regionReplication,
        });
        var defaultReplicationVault = new AliCloud.Hbr.ReplicationVault("defaultReplicationVault", new AliCloud.Hbr.ReplicationVaultArgs
        {
            ReplicationSourceRegionId = regionReplication,
            ReplicationSourceVaultId = defaultVault.Id,
            VaultName = name,
            VaultStorageClass = "STANDARD",
            Description = name,
        }, new CustomResourceOptions
        {
            Provider = alicloud.Replication,
        });
    }

}

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/hbr"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/providers"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := "tf-testAccReplicationVault"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		regionSource := "you Replication value source region"
		if param := cfg.Get("regionSource"); param != "" {
			regionSource = param
		}
		_, err := providers.Newalicloud(ctx, "source", &providers.alicloudArgs{
			Region: regionSource,
		})
		if err != nil {
			return err
		}
		defaultVault, err := hbr.NewVault(ctx, "defaultVault", &hbr.VaultArgs{
			VaultName: pulumi.String(name),
		}, pulumi.Provider(alicloud.Source))
		if err != nil {
			return err
		}
		defaultReplicationVaultRegions, err := hbr.GetReplicationVaultRegions(ctx, nil, nil)
		if err != nil {
			return err
		}
		regionReplication := defaultReplicationVaultRegions.Regions[0].ReplicationRegionId
		_, err = providers.Newalicloud(ctx, "replication", &providers.alicloudArgs{
			Region: regionReplication,
		})
		if err != nil {
			return err
		}
		_, err = hbr.NewReplicationVault(ctx, "defaultReplicationVault", &hbr.ReplicationVaultArgs{
			ReplicationSourceRegionId: pulumi.String(regionReplication),
			ReplicationSourceVaultId:  defaultVault.ID(),
			VaultName:                 pulumi.String(name),
			VaultStorageClass:         pulumi.String("STANDARD"),
			Description:               pulumi.String(name),
		}, pulumi.Provider(alicloud.Replication))
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.pulumi.providers.alicloud;
import com.pulumi.pulumi.providers.ProviderArgs;
import com.pulumi.alicloud.hbr.Vault;
import com.pulumi.alicloud.hbr.VaultArgs;
import com.pulumi.alicloud.hbr.HbrFunctions;
import com.pulumi.alicloud.hbr.inputs.GetReplicationVaultRegionsArgs;
import com.pulumi.alicloud.hbr.ReplicationVault;
import com.pulumi.alicloud.hbr.ReplicationVaultArgs;
import com.pulumi.resources.CustomResourceOptions;
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) {
        final var config = ctx.config();
        final var name = config.get("name").orElse("tf-testAccReplicationVault");
        final var regionSource = config.get("regionSource").orElse("you Replication value source region");
        var source = new Provider("source", ProviderArgs.builder()        
            .region(regionSource)
            .build());

        var defaultVault = new Vault("defaultVault", VaultArgs.builder()        
            .vaultName(name)
            .build(), CustomResourceOptions.builder()
                .provider(alicloud.source())
                .build());

        final var defaultReplicationVaultRegions = HbrFunctions.getReplicationVaultRegions();

        final var regionReplication = defaultReplicationVaultRegions.applyValue(getReplicationVaultRegionsResult -> getReplicationVaultRegionsResult.regions()[0].replicationRegionId());

        var replication = new Provider("replication", ProviderArgs.builder()        
            .region(regionReplication)
            .build());

        var defaultReplicationVault = new ReplicationVault("defaultReplicationVault", ReplicationVaultArgs.builder()        
            .replicationSourceRegionId(regionReplication)
            .replicationSourceVaultId(defaultVault.id())
            .vaultName(name)
            .vaultStorageClass("STANDARD")
            .description(name)
            .build(), CustomResourceOptions.builder()
                .provider(alicloud.replication())
                .build());

    }
}

import pulumi
import pulumi_alicloud as alicloud
import pulumi_pulumi as pulumi

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "tf-testAccReplicationVault"
region_source = config.get("regionSource")
if region_source is None:
    region_source = "you Replication value source region"
source = pulumi.providers.Alicloud("source", region=region_source)
default_vault = alicloud.hbr.Vault("defaultVault", vault_name=name,
opts=pulumi.ResourceOptions(provider=alicloud["source"]))
default_replication_vault_regions = alicloud.hbr.get_replication_vault_regions()
region_replication = default_replication_vault_regions.regions[0].replication_region_id
replication = pulumi.providers.Alicloud("replication", region=region_replication)
default_replication_vault = alicloud.hbr.ReplicationVault("defaultReplicationVault",
    replication_source_region_id=region_replication,
    replication_source_vault_id=default_vault.id,
    vault_name=name,
    vault_storage_class="STANDARD",
    description=name,
    opts=pulumi.ResourceOptions(provider=alicloud["replication"]))

import * as pulumi from "@pulumi/pulumi";
import * as alicloud from "@pulumi/alicloud";

const config = new pulumi.Config();
const name = config.get("name") || "tf-testAccReplicationVault";
const regionSource = config.get("regionSource") || "you Replication value source region";
const source = new alicloud.Provider("source", {region: regionSource});
const defaultVault = new alicloud.hbr.Vault("defaultVault", {vaultName: name}, {
    provider: alicloud.source,
});
const defaultReplicationVaultRegions = alicloud.hbr.getReplicationVaultRegions({});
const regionReplication = defaultReplicationVaultRegions.then(defaultReplicationVaultRegions => defaultReplicationVaultRegions.regions?[0]?.replicationRegionId);
const replication = new alicloud.Provider("replication", {region: regionReplication});
const defaultReplicationVault = new alicloud.hbr.ReplicationVault("defaultReplicationVault", {
    replicationSourceRegionId: regionReplication,
    replicationSourceVaultId: defaultVault.id,
    vaultName: name,
    vaultStorageClass: "STANDARD",
    description: name,
}, {
    provider: alicloud.replication,
});

configuration:
  name:
    type: string
    default: tf-testAccReplicationVault
  regionSource:
    type: string
    default: you Replication value source region
resources:
  source:
    type: pulumi:providers:alicloud
    properties:
      region: ${regionSource}
  defaultVault:
    type: alicloud:hbr:Vault
    properties:
      vaultName: ${name}
    options:
      provider: ${alicloud.source}
  replication:
    type: pulumi:providers:alicloud
    properties:
      region: ${regionReplication}
  defaultReplicationVault:
    type: alicloud:hbr:ReplicationVault
    properties:
      replicationSourceRegionId: ${regionReplication}
      replicationSourceVaultId: ${defaultVault.id}
      vaultName: ${name}
      vaultStorageClass: STANDARD
      description: ${name}
    options:
      provider: ${alicloud.replication}
variables:
  defaultReplicationVaultRegions:
    Fn::Invoke:
      Function: alicloud:hbr:getReplicationVaultRegions
      Arguments: {}
  regionReplication: ${defaultReplicationVaultRegions.regions[0].replicationRegionId}