alicloud.hbr.RestoreJob

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

const default = alicloud.hbr.getEcsBackupPlans({
    nameRegex: "plan-tf-used-dont-delete",
});
const defaultGetOssBackupPlans = alicloud.hbr.getOssBackupPlans({
    nameRegex: "plan-tf-used-dont-delete",
});
const defaultGetNasBackupPlans = alicloud.hbr.getNasBackupPlans({
    nameRegex: "plan-tf-used-dont-delete",
});
const ecsSnapshots = Promise.all([_default, _default]).then(([_default, _default1]) => alicloud.hbr.getSnapshots({
    sourceType: "ECS_FILE",
    vaultId: _default.plans?.[0]?.vaultId,
    instanceId: _default1.plans?.[0]?.instanceId,
}));
const ossSnapshots = Promise.all([defaultGetOssBackupPlans, defaultGetOssBackupPlans]).then(([defaultGetOssBackupPlans, defaultGetOssBackupPlans1]) => alicloud.hbr.getSnapshots({
    sourceType: "OSS",
    vaultId: defaultGetOssBackupPlans.plans?.[0]?.vaultId,
    bucket: defaultGetOssBackupPlans1.plans?.[0]?.bucket,
}));
const nasSnapshots = Promise.all([defaultGetNasBackupPlans, defaultGetNasBackupPlans, defaultGetNasBackupPlans]).then(([defaultGetNasBackupPlans, defaultGetNasBackupPlans1, defaultGetNasBackupPlans2]) => alicloud.hbr.getSnapshots({
    sourceType: "NAS",
    vaultId: defaultGetNasBackupPlans.plans?.[0]?.vaultId,
    fileSystemId: defaultGetNasBackupPlans1.plans?.[0]?.fileSystemId,
    createTime: defaultGetNasBackupPlans2.plans?.[0]?.createTime,
}));
const nasJob = new alicloud.hbr.RestoreJob("nasJob", {
    snapshotHash: nasSnapshots.then(nasSnapshots => nasSnapshots.snapshots?.[0]?.snapshotHash),
    vaultId: defaultGetNasBackupPlans.then(defaultGetNasBackupPlans => defaultGetNasBackupPlans.plans?.[0]?.vaultId),
    sourceType: "NAS",
    restoreType: "NAS",
    snapshotId: nasSnapshots.then(nasSnapshots => nasSnapshots.snapshots?.[0]?.snapshotId),
    targetFileSystemId: defaultGetNasBackupPlans.then(defaultGetNasBackupPlans => defaultGetNasBackupPlans.plans?.[0]?.fileSystemId),
    targetCreateTime: defaultGetNasBackupPlans.then(defaultGetNasBackupPlans => defaultGetNasBackupPlans.plans?.[0]?.createTime),
    targetPath: "/",
    options: "    {\"includes\":[], \"excludes\":[]}\n",
});
const ossJob = new alicloud.hbr.RestoreJob("ossJob", {
    snapshotHash: ossSnapshots.then(ossSnapshots => ossSnapshots.snapshots?.[0]?.snapshotHash),
    vaultId: defaultGetOssBackupPlans.then(defaultGetOssBackupPlans => defaultGetOssBackupPlans.plans?.[0]?.vaultId),
    sourceType: "OSS",
    restoreType: "OSS",
    snapshotId: ossSnapshots.then(ossSnapshots => ossSnapshots.snapshots?.[0]?.snapshotId),
    targetBucket: defaultGetOssBackupPlans.then(defaultGetOssBackupPlans => defaultGetOssBackupPlans.plans?.[0]?.bucket),
    targetPrefix: "",
    options: "    {\"includes\":[], \"excludes\":[]}\n",
});
const ecsJob = new alicloud.hbr.RestoreJob("ecsJob", {
    snapshotHash: ecsSnapshots.then(ecsSnapshots => ecsSnapshots.snapshots?.[0]?.snapshotHash),
    vaultId: _default.then(_default => _default.plans?.[0]?.vaultId),
    sourceType: "ECS_FILE",
    restoreType: "ECS_FILE",
    snapshotId: ecsSnapshots.then(ecsSnapshots => ecsSnapshots.snapshots?.[0]?.snapshotId),
    targetInstanceId: _default.then(_default => _default.plans?.[0]?.instanceId),
    targetPath: "/",
});

import pulumi
import pulumi_alicloud as alicloud

default = alicloud.hbr.get_ecs_backup_plans(name_regex="plan-tf-used-dont-delete")
default_get_oss_backup_plans = alicloud.hbr.get_oss_backup_plans(name_regex="plan-tf-used-dont-delete")
default_get_nas_backup_plans = alicloud.hbr.get_nas_backup_plans(name_regex="plan-tf-used-dont-delete")
ecs_snapshots = alicloud.hbr.get_snapshots(source_type="ECS_FILE",
    vault_id=default.plans[0].vault_id,
    instance_id=default.plans[0].instance_id)
oss_snapshots = alicloud.hbr.get_snapshots(source_type="OSS",
    vault_id=default_get_oss_backup_plans.plans[0].vault_id,
    bucket=default_get_oss_backup_plans.plans[0].bucket)
nas_snapshots = alicloud.hbr.get_snapshots(source_type="NAS",
    vault_id=default_get_nas_backup_plans.plans[0].vault_id,
    file_system_id=default_get_nas_backup_plans.plans[0].file_system_id,
    create_time=default_get_nas_backup_plans.plans[0].create_time)
nas_job = alicloud.hbr.RestoreJob("nasJob",
    snapshot_hash=nas_snapshots.snapshots[0].snapshot_hash,
    vault_id=default_get_nas_backup_plans.plans[0].vault_id,
    source_type="NAS",
    restore_type="NAS",
    snapshot_id=nas_snapshots.snapshots[0].snapshot_id,
    target_file_system_id=default_get_nas_backup_plans.plans[0].file_system_id,
    target_create_time=default_get_nas_backup_plans.plans[0].create_time,
    target_path="/",
    options="    {\"includes\":[], \"excludes\":[]}\n")
oss_job = alicloud.hbr.RestoreJob("ossJob",
    snapshot_hash=oss_snapshots.snapshots[0].snapshot_hash,
    vault_id=default_get_oss_backup_plans.plans[0].vault_id,
    source_type="OSS",
    restore_type="OSS",
    snapshot_id=oss_snapshots.snapshots[0].snapshot_id,
    target_bucket=default_get_oss_backup_plans.plans[0].bucket,
    target_prefix="",
    options="    {\"includes\":[], \"excludes\":[]}\n")
ecs_job = alicloud.hbr.RestoreJob("ecsJob",
    snapshot_hash=ecs_snapshots.snapshots[0].snapshot_hash,
    vault_id=default.plans[0].vault_id,
    source_type="ECS_FILE",
    restore_type="ECS_FILE",
    snapshot_id=ecs_snapshots.snapshots[0].snapshot_id,
    target_instance_id=default.plans[0].instance_id,
    target_path="/")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_default, err := hbr.GetEcsBackupPlans(ctx, &hbr.GetEcsBackupPlansArgs{
			NameRegex: pulumi.StringRef("plan-tf-used-dont-delete"),
		}, nil)
		if err != nil {
			return err
		}
		defaultGetOssBackupPlans, err := hbr.GetOssBackupPlans(ctx, &hbr.GetOssBackupPlansArgs{
			NameRegex: pulumi.StringRef("plan-tf-used-dont-delete"),
		}, nil)
		if err != nil {
			return err
		}
		defaultGetNasBackupPlans, err := hbr.GetNasBackupPlans(ctx, &hbr.GetNasBackupPlansArgs{
			NameRegex: pulumi.StringRef("plan-tf-used-dont-delete"),
		}, nil)
		if err != nil {
			return err
		}
		ecsSnapshots, err := hbr.GetSnapshots(ctx, &hbr.GetSnapshotsArgs{
			SourceType: "ECS_FILE",
			VaultId:    _default.Plans[0].VaultId,
			InstanceId: pulumi.StringRef(_default.Plans[0].InstanceId),
		}, nil)
		if err != nil {
			return err
		}
		ossSnapshots, err := hbr.GetSnapshots(ctx, &hbr.GetSnapshotsArgs{
			SourceType: "OSS",
			VaultId:    defaultGetOssBackupPlans.Plans[0].VaultId,
			Bucket:     pulumi.StringRef(defaultGetOssBackupPlans.Plans[0].Bucket),
		}, nil)
		if err != nil {
			return err
		}
		nasSnapshots, err := hbr.GetSnapshots(ctx, &hbr.GetSnapshotsArgs{
			SourceType:   "NAS",
			VaultId:      defaultGetNasBackupPlans.Plans[0].VaultId,
			FileSystemId: pulumi.StringRef(defaultGetNasBackupPlans.Plans[0].FileSystemId),
			CreateTime:   pulumi.StringRef(defaultGetNasBackupPlans.Plans[0].CreateTime),
		}, nil)
		if err != nil {
			return err
		}
		_, err = hbr.NewRestoreJob(ctx, "nasJob", &hbr.RestoreJobArgs{
			SnapshotHash:       pulumi.String(nasSnapshots.Snapshots[0].SnapshotHash),
			VaultId:            pulumi.String(defaultGetNasBackupPlans.Plans[0].VaultId),
			SourceType:         pulumi.String("NAS"),
			RestoreType:        pulumi.String("NAS"),
			SnapshotId:         pulumi.String(nasSnapshots.Snapshots[0].SnapshotId),
			TargetFileSystemId: pulumi.String(defaultGetNasBackupPlans.Plans[0].FileSystemId),
			TargetCreateTime:   pulumi.String(defaultGetNasBackupPlans.Plans[0].CreateTime),
			TargetPath:         pulumi.String("/"),
			Options:            pulumi.String("    {\"includes\":[], \"excludes\":[]}\n"),
		})
		if err != nil {
			return err
		}
		_, err = hbr.NewRestoreJob(ctx, "ossJob", &hbr.RestoreJobArgs{
			SnapshotHash: pulumi.String(ossSnapshots.Snapshots[0].SnapshotHash),
			VaultId:      pulumi.String(defaultGetOssBackupPlans.Plans[0].VaultId),
			SourceType:   pulumi.String("OSS"),
			RestoreType:  pulumi.String("OSS"),
			SnapshotId:   pulumi.String(ossSnapshots.Snapshots[0].SnapshotId),
			TargetBucket: pulumi.String(defaultGetOssBackupPlans.Plans[0].Bucket),
			TargetPrefix: pulumi.String(""),
			Options:      pulumi.String("    {\"includes\":[], \"excludes\":[]}\n"),
		})
		if err != nil {
			return err
		}
		_, err = hbr.NewRestoreJob(ctx, "ecsJob", &hbr.RestoreJobArgs{
			SnapshotHash:     pulumi.String(ecsSnapshots.Snapshots[0].SnapshotHash),
			VaultId:          pulumi.String(_default.Plans[0].VaultId),
			SourceType:       pulumi.String("ECS_FILE"),
			RestoreType:      pulumi.String("ECS_FILE"),
			SnapshotId:       pulumi.String(ecsSnapshots.Snapshots[0].SnapshotId),
			TargetInstanceId: pulumi.String(_default.Plans[0].InstanceId),
			TargetPath:       pulumi.String("/"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var @default = AliCloud.Hbr.GetEcsBackupPlans.Invoke(new()
    {
        NameRegex = "plan-tf-used-dont-delete",
    });

    var defaultGetOssBackupPlans = AliCloud.Hbr.GetOssBackupPlans.Invoke(new()
    {
        NameRegex = "plan-tf-used-dont-delete",
    });

    var defaultGetNasBackupPlans = AliCloud.Hbr.GetNasBackupPlans.Invoke(new()
    {
        NameRegex = "plan-tf-used-dont-delete",
    });

    var ecsSnapshots = AliCloud.Hbr.GetSnapshots.Invoke(new()
    {
        SourceType = "ECS_FILE",
        VaultId = @default.Apply(getEcsBackupPlansResult => getEcsBackupPlansResult.Plans[0]?.VaultId),
        InstanceId = @default.Apply(getEcsBackupPlansResult => getEcsBackupPlansResult.Plans[0]?.InstanceId),
    });

    var ossSnapshots = AliCloud.Hbr.GetSnapshots.Invoke(new()
    {
        SourceType = "OSS",
        VaultId = defaultGetOssBackupPlans.Apply(getOssBackupPlansResult => getOssBackupPlansResult.Plans[0]?.VaultId),
        Bucket = defaultGetOssBackupPlans.Apply(getOssBackupPlansResult => getOssBackupPlansResult.Plans[0]?.Bucket),
    });

    var nasSnapshots = AliCloud.Hbr.GetSnapshots.Invoke(new()
    {
        SourceType = "NAS",
        VaultId = defaultGetNasBackupPlans.Apply(getNasBackupPlansResult => getNasBackupPlansResult.Plans[0]?.VaultId),
        FileSystemId = defaultGetNasBackupPlans.Apply(getNasBackupPlansResult => getNasBackupPlansResult.Plans[0]?.FileSystemId),
        CreateTime = defaultGetNasBackupPlans.Apply(getNasBackupPlansResult => getNasBackupPlansResult.Plans[0]?.CreateTime),
    });

    var nasJob = new AliCloud.Hbr.RestoreJob("nasJob", new()
    {
        SnapshotHash = nasSnapshots.Apply(getSnapshotsResult => getSnapshotsResult.Snapshots[0]?.SnapshotHash),
        VaultId = defaultGetNasBackupPlans.Apply(getNasBackupPlansResult => getNasBackupPlansResult.Plans[0]?.VaultId),
        SourceType = "NAS",
        RestoreType = "NAS",
        SnapshotId = nasSnapshots.Apply(getSnapshotsResult => getSnapshotsResult.Snapshots[0]?.SnapshotId),
        TargetFileSystemId = defaultGetNasBackupPlans.Apply(getNasBackupPlansResult => getNasBackupPlansResult.Plans[0]?.FileSystemId),
        TargetCreateTime = defaultGetNasBackupPlans.Apply(getNasBackupPlansResult => getNasBackupPlansResult.Plans[0]?.CreateTime),
        TargetPath = "/",
        Options = @"    {""includes"":[], ""excludes"":[]}
",
    });

    var ossJob = new AliCloud.Hbr.RestoreJob("ossJob", new()
    {
        SnapshotHash = ossSnapshots.Apply(getSnapshotsResult => getSnapshotsResult.Snapshots[0]?.SnapshotHash),
        VaultId = defaultGetOssBackupPlans.Apply(getOssBackupPlansResult => getOssBackupPlansResult.Plans[0]?.VaultId),
        SourceType = "OSS",
        RestoreType = "OSS",
        SnapshotId = ossSnapshots.Apply(getSnapshotsResult => getSnapshotsResult.Snapshots[0]?.SnapshotId),
        TargetBucket = defaultGetOssBackupPlans.Apply(getOssBackupPlansResult => getOssBackupPlansResult.Plans[0]?.Bucket),
        TargetPrefix = "",
        Options = @"    {""includes"":[], ""excludes"":[]}
",
    });

    var ecsJob = new AliCloud.Hbr.RestoreJob("ecsJob", new()
    {
        SnapshotHash = ecsSnapshots.Apply(getSnapshotsResult => getSnapshotsResult.Snapshots[0]?.SnapshotHash),
        VaultId = @default.Apply(@default => @default.Apply(getEcsBackupPlansResult => getEcsBackupPlansResult.Plans[0]?.VaultId)),
        SourceType = "ECS_FILE",
        RestoreType = "ECS_FILE",
        SnapshotId = ecsSnapshots.Apply(getSnapshotsResult => getSnapshotsResult.Snapshots[0]?.SnapshotId),
        TargetInstanceId = @default.Apply(@default => @default.Apply(getEcsBackupPlansResult => getEcsBackupPlansResult.Plans[0]?.InstanceId)),
        TargetPath = "/",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.hbr.HbrFunctions;
import com.pulumi.alicloud.hbr.inputs.GetEcsBackupPlansArgs;
import com.pulumi.alicloud.hbr.inputs.GetOssBackupPlansArgs;
import com.pulumi.alicloud.hbr.inputs.GetNasBackupPlansArgs;
import com.pulumi.alicloud.hbr.inputs.GetSnapshotsArgs;
import com.pulumi.alicloud.hbr.RestoreJob;
import com.pulumi.alicloud.hbr.RestoreJobArgs;
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 default = HbrFunctions.getEcsBackupPlans(GetEcsBackupPlansArgs.builder()
            .nameRegex("plan-tf-used-dont-delete")
            .build());

        final var defaultGetOssBackupPlans = HbrFunctions.getOssBackupPlans(GetOssBackupPlansArgs.builder()
            .nameRegex("plan-tf-used-dont-delete")
            .build());

        final var defaultGetNasBackupPlans = HbrFunctions.getNasBackupPlans(GetNasBackupPlansArgs.builder()
            .nameRegex("plan-tf-used-dont-delete")
            .build());

        final var ecsSnapshots = HbrFunctions.getSnapshots(GetSnapshotsArgs.builder()
            .sourceType("ECS_FILE")
            .vaultId(default_.plans()[0].vaultId())
            .instanceId(default_.plans()[0].instanceId())
            .build());

        final var ossSnapshots = HbrFunctions.getSnapshots(GetSnapshotsArgs.builder()
            .sourceType("OSS")
            .vaultId(defaultGetOssBackupPlans.applyValue(getOssBackupPlansResult -> getOssBackupPlansResult.plans()[0].vaultId()))
            .bucket(defaultGetOssBackupPlans.applyValue(getOssBackupPlansResult -> getOssBackupPlansResult.plans()[0].bucket()))
            .build());

        final var nasSnapshots = HbrFunctions.getSnapshots(GetSnapshotsArgs.builder()
            .sourceType("NAS")
            .vaultId(defaultGetNasBackupPlans.applyValue(getNasBackupPlansResult -> getNasBackupPlansResult.plans()[0].vaultId()))
            .fileSystemId(defaultGetNasBackupPlans.applyValue(getNasBackupPlansResult -> getNasBackupPlansResult.plans()[0].fileSystemId()))
            .createTime(defaultGetNasBackupPlans.applyValue(getNasBackupPlansResult -> getNasBackupPlansResult.plans()[0].createTime()))
            .build());

        var nasJob = new RestoreJob("nasJob", RestoreJobArgs.builder()        
            .snapshotHash(nasSnapshots.applyValue(getSnapshotsResult -> getSnapshotsResult.snapshots()[0].snapshotHash()))
            .vaultId(defaultGetNasBackupPlans.applyValue(getNasBackupPlansResult -> getNasBackupPlansResult.plans()[0].vaultId()))
            .sourceType("NAS")
            .restoreType("NAS")
            .snapshotId(nasSnapshots.applyValue(getSnapshotsResult -> getSnapshotsResult.snapshots()[0].snapshotId()))
            .targetFileSystemId(defaultGetNasBackupPlans.applyValue(getNasBackupPlansResult -> getNasBackupPlansResult.plans()[0].fileSystemId()))
            .targetCreateTime(defaultGetNasBackupPlans.applyValue(getNasBackupPlansResult -> getNasBackupPlansResult.plans()[0].createTime()))
            .targetPath("/")
            .options("""
    {"includes":[], "excludes":[]}
            """)
            .build());

        var ossJob = new RestoreJob("ossJob", RestoreJobArgs.builder()        
            .snapshotHash(ossSnapshots.applyValue(getSnapshotsResult -> getSnapshotsResult.snapshots()[0].snapshotHash()))
            .vaultId(defaultGetOssBackupPlans.applyValue(getOssBackupPlansResult -> getOssBackupPlansResult.plans()[0].vaultId()))
            .sourceType("OSS")
            .restoreType("OSS")
            .snapshotId(ossSnapshots.applyValue(getSnapshotsResult -> getSnapshotsResult.snapshots()[0].snapshotId()))
            .targetBucket(defaultGetOssBackupPlans.applyValue(getOssBackupPlansResult -> getOssBackupPlansResult.plans()[0].bucket()))
            .targetPrefix("")
            .options("""
    {"includes":[], "excludes":[]}
            """)
            .build());

        var ecsJob = new RestoreJob("ecsJob", RestoreJobArgs.builder()        
            .snapshotHash(ecsSnapshots.applyValue(getSnapshotsResult -> getSnapshotsResult.snapshots()[0].snapshotHash()))
            .vaultId(default_.plans()[0].vaultId())
            .sourceType("ECS_FILE")
            .restoreType("ECS_FILE")
            .snapshotId(ecsSnapshots.applyValue(getSnapshotsResult -> getSnapshotsResult.snapshots()[0].snapshotId()))
            .targetInstanceId(default_.plans()[0].instanceId())
            .targetPath("/")
            .build());

    }
}

resources:
  nasJob:
    type: alicloud:hbr:RestoreJob
    properties:
      snapshotHash: ${nasSnapshots.snapshots[0].snapshotHash}
      vaultId: ${defaultGetNasBackupPlans.plans[0].vaultId}
      sourceType: NAS
      restoreType: NAS
      snapshotId: ${nasSnapshots.snapshots[0].snapshotId}
      targetFileSystemId: ${defaultGetNasBackupPlans.plans[0].fileSystemId}
      targetCreateTime: ${defaultGetNasBackupPlans.plans[0].createTime}
      targetPath: /
      options: |2
            {"includes":[], "excludes":[]}
  ossJob:
    type: alicloud:hbr:RestoreJob
    properties:
      snapshotHash: ${ossSnapshots.snapshots[0].snapshotHash}
      vaultId: ${defaultGetOssBackupPlans.plans[0].vaultId}
      sourceType: OSS
      restoreType: OSS
      snapshotId: ${ossSnapshots.snapshots[0].snapshotId}
      targetBucket: ${defaultGetOssBackupPlans.plans[0].bucket}
      targetPrefix:
      options: |2
            {"includes":[], "excludes":[]}
  ecsJob:
    type: alicloud:hbr:RestoreJob
    properties:
      snapshotHash: ${ecsSnapshots.snapshots[0].snapshotHash}
      vaultId: ${default.plans[0].vaultId}
      sourceType: ECS_FILE
      restoreType: ECS_FILE
      snapshotId: ${ecsSnapshots.snapshots[0].snapshotId}
      targetInstanceId: ${default.plans[0].instanceId}
      targetPath: /
variables:
  default:
    fn::invoke:
      Function: alicloud:hbr:getEcsBackupPlans
      Arguments:
        nameRegex: plan-tf-used-dont-delete
  defaultGetOssBackupPlans:
    fn::invoke:
      Function: alicloud:hbr:getOssBackupPlans
      Arguments:
        nameRegex: plan-tf-used-dont-delete
  defaultGetNasBackupPlans:
    fn::invoke:
      Function: alicloud:hbr:getNasBackupPlans
      Arguments:
        nameRegex: plan-tf-used-dont-delete
  ecsSnapshots:
    fn::invoke:
      Function: alicloud:hbr:getSnapshots
      Arguments:
        sourceType: ECS_FILE
        vaultId: ${default.plans[0].vaultId}
        instanceId: ${default.plans[0].instanceId}
  ossSnapshots:
    fn::invoke:
      Function: alicloud:hbr:getSnapshots
      Arguments:
        sourceType: OSS
        vaultId: ${defaultGetOssBackupPlans.plans[0].vaultId}
        bucket: ${defaultGetOssBackupPlans.plans[0].bucket}
  nasSnapshots:
    fn::invoke:
      Function: alicloud:hbr:getSnapshots
      Arguments:
        sourceType: NAS
        vaultId: ${defaultGetNasBackupPlans.plans[0].vaultId}
        fileSystemId: ${defaultGetNasBackupPlans.plans[0].fileSystemId}
        createTime: ${defaultGetNasBackupPlans.plans[0].createTime}

var restoreJobResource = new AliCloud.Hbr.RestoreJob("restoreJobResource", new()
{
    RestoreType = "string",
    VaultId = "string",
    SourceType = "string",
    SnapshotId = "string",
    SnapshotHash = "string",
    TargetBucket = "string",
    TargetCreateTime = "string",
    RestoreJobId = "string",
    Options = "string",
    Include = "string",
    Exclude = "string",
    CrossAccountUserId = 0,
    CrossAccountRoleName = "string",
    TargetClientId = "string",
    OtsDetail = new AliCloud.Hbr.Inputs.RestoreJobOtsDetailArgs
    {
        OverwriteExisting = false,
    },
    TargetDataSourceId = "string",
    TargetFileSystemId = "string",
    TargetInstanceId = "string",
    TargetInstanceName = "string",
    TargetPath = "string",
    TargetPrefix = "string",
    TargetTableName = "string",
    TargetTime = "string",
    UdmDetail = "string",
    CrossAccountType = "string",
});

example, err := hbr.NewRestoreJob(ctx, "restoreJobResource", &hbr.RestoreJobArgs{
	RestoreType:          pulumi.String("string"),
	VaultId:              pulumi.String("string"),
	SourceType:           pulumi.String("string"),
	SnapshotId:           pulumi.String("string"),
	SnapshotHash:         pulumi.String("string"),
	TargetBucket:         pulumi.String("string"),
	TargetCreateTime:     pulumi.String("string"),
	RestoreJobId:         pulumi.String("string"),
	Options:              pulumi.String("string"),
	Include:              pulumi.String("string"),
	Exclude:              pulumi.String("string"),
	CrossAccountUserId:   pulumi.Int(0),
	CrossAccountRoleName: pulumi.String("string"),
	TargetClientId:       pulumi.String("string"),
	OtsDetail: &hbr.RestoreJobOtsDetailArgs{
		OverwriteExisting: pulumi.Bool(false),
	},
	TargetDataSourceId: pulumi.String("string"),
	TargetFileSystemId: pulumi.String("string"),
	TargetInstanceId:   pulumi.String("string"),
	TargetInstanceName: pulumi.String("string"),
	TargetPath:         pulumi.String("string"),
	TargetPrefix:       pulumi.String("string"),
	TargetTableName:    pulumi.String("string"),
	TargetTime:         pulumi.String("string"),
	UdmDetail:          pulumi.String("string"),
	CrossAccountType:   pulumi.String("string"),
})

var restoreJobResource = new RestoreJob("restoreJobResource", RestoreJobArgs.builder()        
    .restoreType("string")
    .vaultId("string")
    .sourceType("string")
    .snapshotId("string")
    .snapshotHash("string")
    .targetBucket("string")
    .targetCreateTime("string")
    .restoreJobId("string")
    .options("string")
    .include("string")
    .exclude("string")
    .crossAccountUserId(0)
    .crossAccountRoleName("string")
    .targetClientId("string")
    .otsDetail(RestoreJobOtsDetailArgs.builder()
        .overwriteExisting(false)
        .build())
    .targetDataSourceId("string")
    .targetFileSystemId("string")
    .targetInstanceId("string")
    .targetInstanceName("string")
    .targetPath("string")
    .targetPrefix("string")
    .targetTableName("string")
    .targetTime("string")
    .udmDetail("string")
    .crossAccountType("string")
    .build());

restore_job_resource = alicloud.hbr.RestoreJob("restoreJobResource",
    restore_type="string",
    vault_id="string",
    source_type="string",
    snapshot_id="string",
    snapshot_hash="string",
    target_bucket="string",
    target_create_time="string",
    restore_job_id="string",
    options="string",
    include="string",
    exclude="string",
    cross_account_user_id=0,
    cross_account_role_name="string",
    target_client_id="string",
    ots_detail=alicloud.hbr.RestoreJobOtsDetailArgs(
        overwrite_existing=False,
    ),
    target_data_source_id="string",
    target_file_system_id="string",
    target_instance_id="string",
    target_instance_name="string",
    target_path="string",
    target_prefix="string",
    target_table_name="string",
    target_time="string",
    udm_detail="string",
    cross_account_type="string")

const restoreJobResource = new alicloud.hbr.RestoreJob("restoreJobResource", {
    restoreType: "string",
    vaultId: "string",
    sourceType: "string",
    snapshotId: "string",
    snapshotHash: "string",
    targetBucket: "string",
    targetCreateTime: "string",
    restoreJobId: "string",
    options: "string",
    include: "string",
    exclude: "string",
    crossAccountUserId: 0,
    crossAccountRoleName: "string",
    targetClientId: "string",
    otsDetail: {
        overwriteExisting: false,
    },
    targetDataSourceId: "string",
    targetFileSystemId: "string",
    targetInstanceId: "string",
    targetInstanceName: "string",
    targetPath: "string",
    targetPrefix: "string",
    targetTableName: "string",
    targetTime: "string",
    udmDetail: "string",
    crossAccountType: "string",
});

type: alicloud:hbr:RestoreJob
properties:
    crossAccountRoleName: string
    crossAccountType: string
    crossAccountUserId: 0
    exclude: string
    include: string
    options: string
    otsDetail:
        overwriteExisting: false
    restoreJobId: string
    restoreType: string
    snapshotHash: string
    snapshotId: string
    sourceType: string
    targetBucket: string
    targetClientId: string
    targetCreateTime: string
    targetDataSourceId: string
    targetFileSystemId: string
    targetInstanceId: string
    targetInstanceName: string
    targetPath: string
    targetPrefix: string
    targetTableName: string
    targetTime: string
    udmDetail: string
    vaultId: string