@huaweicloud/huaweicloud-sdk-cbr 3.1.36

package/v1/model/BackupRestore.d.ts

@@ -0,0 +1,22 @@
+import { BackupRestoreServerMapping } from './BackupRestoreServerMapping';
+export declare class BackupRestore {
+    mappings?: Array<BackupRestoreServerMapping>;
+    private 'power_on'?;
+    private 'server_id'?;
+    private 'volume_id'?;
+    private 'resource_id'?;
+    constructor();
+    withMappings(mappings: Array<BackupRestoreServerMapping>): BackupRestore;
+    withPowerOn(powerOn: boolean): BackupRestore;
+    set powerOn(powerOn: boolean | undefined);
+    get powerOn(): boolean | undefined;
+    withServerId(serverId: string): BackupRestore;
+    set serverId(serverId: string | undefined);
+    get serverId(): string | undefined;
+    withVolumeId(volumeId: string): BackupRestore;
+    set volumeId(volumeId: string | undefined);
+    get volumeId(): string | undefined;
+    withResourceId(resourceId: string): BackupRestore;
+    set resourceId(resourceId: string | undefined);
+    get resourceId(): string | undefined;
+}

package/v1/model/BackupRestore.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackupRestore = void 0;
+var BackupRestore = /** @class */ (function () {
+    function BackupRestore() {
+    }
+    BackupRestore.prototype.withMappings = function (mappings) {
+        this['mappings'] = mappings;
+        return this;
+    };
+    BackupRestore.prototype.withPowerOn = function (powerOn) {
+        this['power_on'] = powerOn;
+        return this;
+    };
+    Object.defineProperty(BackupRestore.prototype, "powerOn", {
+        get: function () {
+            return this['power_on'];
+        },
+        set: function (powerOn) {
+            this['power_on'] = powerOn;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BackupRestore.prototype.withServerId = function (serverId) {
+        this['server_id'] = serverId;
+        return this;
+    };
+    Object.defineProperty(BackupRestore.prototype, "serverId", {
+        get: function () {
+            return this['server_id'];
+        },
+        set: function (serverId) {
+            this['server_id'] = serverId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BackupRestore.prototype.withVolumeId = function (volumeId) {
+        this['volume_id'] = volumeId;
+        return this;
+    };
+    Object.defineProperty(BackupRestore.prototype, "volumeId", {
+        get: function () {
+            return this['volume_id'];
+        },
+        set: function (volumeId) {
+            this['volume_id'] = volumeId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BackupRestore.prototype.withResourceId = function (resourceId) {
+        this['resource_id'] = resourceId;
+        return this;
+    };
+    Object.defineProperty(BackupRestore.prototype, "resourceId", {
+        get: function () {
+            return this['resource_id'];
+        },
+        set: function (resourceId) {
+            this['resource_id'] = resourceId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BackupRestore;
+}());
+exports.BackupRestore = BackupRestore;

package/v1/model/BackupRestoreReq.d.ts

@@ -0,0 +1,6 @@
+import { BackupRestore } from './BackupRestore';
+export declare class BackupRestoreReq {
+    restore: BackupRestore;
+    constructor(restore?: any);
+    withRestore(restore: BackupRestore): BackupRestoreReq;
+}

package/v1/model/BackupRestoreReq.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackupRestoreReq = void 0;
+var BackupRestoreReq = /** @class */ (function () {
+    function BackupRestoreReq(restore) {
+        this['restore'] = restore;
+    }
+    BackupRestoreReq.prototype.withRestore = function (restore) {
+        this['restore'] = restore;
+        return this;
+    };
+    return BackupRestoreReq;
+}());
+exports.BackupRestoreReq = BackupRestoreReq;

package/v1/model/BackupRestoreServerMapping.d.ts

@@ -0,0 +1,11 @@
+export declare class BackupRestoreServerMapping {
+    private 'backup_id';
+    private 'volume_id';
+    constructor(backupId?: any, volumeId?: any);
+    withBackupId(backupId: string): BackupRestoreServerMapping;
+    set backupId(backupId: string | undefined);
+    get backupId(): string | undefined;
+    withVolumeId(volumeId: string): BackupRestoreServerMapping;
+    set volumeId(volumeId: string | undefined);
+    get volumeId(): string | undefined;
+}

package/v1/model/BackupRestoreServerMapping.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackupRestoreServerMapping = void 0;
+var BackupRestoreServerMapping = /** @class */ (function () {
+    function BackupRestoreServerMapping(backupId, volumeId) {
+        this['backup_id'] = backupId;
+        this['volume_id'] = volumeId;
+    }
+    BackupRestoreServerMapping.prototype.withBackupId = function (backupId) {
+        this['backup_id'] = backupId;
+        return this;
+    };
+    Object.defineProperty(BackupRestoreServerMapping.prototype, "backupId", {
+        get: function () {
+            return this['backup_id'];
+        },
+        set: function (backupId) {
+            this['backup_id'] = backupId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BackupRestoreServerMapping.prototype.withVolumeId = function (volumeId) {
+        this['volume_id'] = volumeId;
+        return this;
+    };
+    Object.defineProperty(BackupRestoreServerMapping.prototype, "volumeId", {
+        get: function () {
+            return this['volume_id'];
+        },
+        set: function (volumeId) {
+            this['volume_id'] = volumeId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BackupRestoreServerMapping;
+}());
+exports.BackupRestoreServerMapping = BackupRestoreServerMapping;

package/v1/model/BackupSync.d.ts

@@ -0,0 +1,35 @@
+export declare class BackupSync {
+    private 'backup_id';
+    private 'backup_name';
+    private 'bucket_name';
+    private 'image_path';
+    private 'resource_id';
+    private 'resource_name';
+    private 'resource_type';
+    private 'created_at';
+    constructor(backupId?: any, backupName?: any, bucketName?: any, imagePath?: any, resourceId?: any, resourceName?: any, resourceType?: any, createdAt?: any);
+    withBackupId(backupId: string): BackupSync;
+    set backupId(backupId: string | undefined);
+    get backupId(): string | undefined;
+    withBackupName(backupName: string): BackupSync;
+    set backupName(backupName: string | undefined);
+    get backupName(): string | undefined;
+    withBucketName(bucketName: string): BackupSync;
+    set bucketName(bucketName: string | undefined);
+    get bucketName(): string | undefined;
+    withImagePath(imagePath: string): BackupSync;
+    set imagePath(imagePath: string | undefined);
+    get imagePath(): string | undefined;
+    withResourceId(resourceId: string): BackupSync;
+    set resourceId(resourceId: string | undefined);
+    get resourceId(): string | undefined;
+    withResourceName(resourceName: string): BackupSync;
+    set resourceName(resourceName: string | undefined);
+    get resourceName(): string | undefined;
+    withResourceType(resourceType: string): BackupSync;
+    set resourceType(resourceType: string | undefined);
+    get resourceType(): string | undefined;
+    withCreatedAt(createdAt: number): BackupSync;
+    set createdAt(createdAt: number | undefined);
+    get createdAt(): number | undefined;
+}

package/v1/model/BackupSync.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackupSync = void 0;
+var BackupSync = /** @class */ (function () {
+    function BackupSync(backupId, backupName, bucketName, imagePath, resourceId, resourceName, resourceType, createdAt) {
+        this['backup_id'] = backupId;
+        this['backup_name'] = backupName;
+        this['bucket_name'] = bucketName;
+        this['image_path'] = imagePath;
+        this['resource_id'] = resourceId;
+        this['resource_name'] = resourceName;
+        this['resource_type'] = resourceType;
+        this['created_at'] = createdAt;
+    }
+    BackupSync.prototype.withBackupId = function (backupId) {
+        this['backup_id'] = backupId;
+        return this;
+    };
+    Object.defineProperty(BackupSync.prototype, "backupId", {
+        get: function () {
+            return this['backup_id'];
+        },
+        set: function (backupId) {
+            this['backup_id'] = backupId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BackupSync.prototype.withBackupName = function (backupName) {
+        this['backup_name'] = backupName;
+        return this;
+    };
+    Object.defineProperty(BackupSync.prototype, "backupName", {
+        get: function () {
+            return this['backup_name'];
+        },
+        set: function (backupName) {
+            this['backup_name'] = backupName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BackupSync.prototype.withBucketName = function (bucketName) {
+        this['bucket_name'] = bucketName;
+        return this;
+    };
+    Object.defineProperty(BackupSync.prototype, "bucketName", {
+        get: function () {
+            return this['bucket_name'];
+        },
+        set: function (bucketName) {
+            this['bucket_name'] = bucketName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BackupSync.prototype.withImagePath = function (imagePath) {
+        this['image_path'] = imagePath;
+        return this;
+    };
+    Object.defineProperty(BackupSync.prototype, "imagePath", {
+        get: function () {
+            return this['image_path'];
+        },
+        set: function (imagePath) {
+            this['image_path'] = imagePath;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BackupSync.prototype.withResourceId = function (resourceId) {
+        this['resource_id'] = resourceId;
+        return this;
+    };
+    Object.defineProperty(BackupSync.prototype, "resourceId", {
+        get: function () {
+            return this['resource_id'];
+        },
+        set: function (resourceId) {
+            this['resource_id'] = resourceId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BackupSync.prototype.withResourceName = function (resourceName) {
+        this['resource_name'] = resourceName;
+        return this;
+    };
+    Object.defineProperty(BackupSync.prototype, "resourceName", {
+        get: function () {
+            return this['resource_name'];
+        },
+        set: function (resourceName) {
+            this['resource_name'] = resourceName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BackupSync.prototype.withResourceType = function (resourceType) {
+        this['resource_type'] = resourceType;
+        return this;
+    };
+    Object.defineProperty(BackupSync.prototype, "resourceType", {
+        get: function () {
+            return this['resource_type'];
+        },
+        set: function (resourceType) {
+            this['resource_type'] = resourceType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BackupSync.prototype.withCreatedAt = function (createdAt) {
+        this['created_at'] = createdAt;
+        return this;
+    };
+    Object.defineProperty(BackupSync.prototype, "createdAt", {
+        get: function () {
+            return this['created_at'];
+        },
+        set: function (createdAt) {
+            this['created_at'] = createdAt;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BackupSync;
+}());
+exports.BackupSync = BackupSync;

package/v1/model/BackupSyncReq.d.ts

@@ -0,0 +1,6 @@
+import { BackupSync } from './BackupSync';
+export declare class BackupSyncReq {
+    sync: Array<BackupSync>;
+    constructor(sync?: any);
+    withSync(sync: Array<BackupSync>): BackupSyncReq;
+}

package/v1/model/BackupSyncReq.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackupSyncReq = void 0;
+var BackupSyncReq = /** @class */ (function () {
+    function BackupSyncReq(sync) {
+        this['sync'] = sync;
+    }
+    BackupSyncReq.prototype.withSync = function (sync) {
+        this['sync'] = sync;
+        return this;
+    };
+    return BackupSyncReq;
+}());
+exports.BackupSyncReq = BackupSyncReq;

package/v1/model/BackupSyncRespBody.d.ts

@@ -0,0 +1,11 @@
+export declare class BackupSyncRespBody {
+    private 'backup_id';
+    private 'operation_log_id';
+    constructor(backupId?: any, operationLogId?: any);
+    withBackupId(backupId: string): BackupSyncRespBody;
+    set backupId(backupId: string | undefined);
+    get backupId(): string | undefined;
+    withOperationLogId(operationLogId: string): BackupSyncRespBody;
+    set operationLogId(operationLogId: string | undefined);
+    get operationLogId(): string | undefined;
+}

package/v1/model/BackupSyncRespBody.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackupSyncRespBody = void 0;
+var BackupSyncRespBody = /** @class */ (function () {
+    function BackupSyncRespBody(backupId, operationLogId) {
+        this['backup_id'] = backupId;
+        this['operation_log_id'] = operationLogId;
+    }
+    BackupSyncRespBody.prototype.withBackupId = function (backupId) {
+        this['backup_id'] = backupId;
+        return this;
+    };
+    Object.defineProperty(BackupSyncRespBody.prototype, "backupId", {
+        get: function () {
+            return this['backup_id'];
+        },
+        set: function (backupId) {
+            this['backup_id'] = backupId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BackupSyncRespBody.prototype.withOperationLogId = function (operationLogId) {
+        this['operation_log_id'] = operationLogId;
+        return this;
+    };
+    Object.defineProperty(BackupSyncRespBody.prototype, "operationLogId", {
+        get: function () {
+            return this['operation_log_id'];
+        },
+        set: function (operationLogId) {
+            this['operation_log_id'] = operationLogId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BackupSyncRespBody;
+}());
+exports.BackupSyncRespBody = BackupSyncRespBody;

package/v1/model/BatchCreateAndDeleteVaultTagsRequest.d.ts

@@ -0,0 +1,10 @@
+import { BulkCreateAndDeleteVaultTagsReq } from './BulkCreateAndDeleteVaultTagsReq';
+export declare class BatchCreateAndDeleteVaultTagsRequest {
+    private 'vault_id';
+    body?: BulkCreateAndDeleteVaultTagsReq;
+    constructor(vaultId?: any);
+    withVaultId(vaultId: string): BatchCreateAndDeleteVaultTagsRequest;
+    set vaultId(vaultId: string | undefined);
+    get vaultId(): string | undefined;
+    withBody(body: BulkCreateAndDeleteVaultTagsReq): BatchCreateAndDeleteVaultTagsRequest;
+}

package/v1/model/BatchCreateAndDeleteVaultTagsRequest.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchCreateAndDeleteVaultTagsRequest = void 0;
+var BatchCreateAndDeleteVaultTagsRequest = /** @class */ (function () {
+    function BatchCreateAndDeleteVaultTagsRequest(vaultId) {
+        this['vault_id'] = vaultId;
+    }
+    BatchCreateAndDeleteVaultTagsRequest.prototype.withVaultId = function (vaultId) {
+        this['vault_id'] = vaultId;
+        return this;
+    };
+    Object.defineProperty(BatchCreateAndDeleteVaultTagsRequest.prototype, "vaultId", {
+        get: function () {
+            return this['vault_id'];
+        },
+        set: function (vaultId) {
+            this['vault_id'] = vaultId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BatchCreateAndDeleteVaultTagsRequest.prototype.withBody = function (body) {
+        this['body'] = body;
+        return this;
+    };
+    return BatchCreateAndDeleteVaultTagsRequest;
+}());
+exports.BatchCreateAndDeleteVaultTagsRequest = BatchCreateAndDeleteVaultTagsRequest;

package/v1/model/BatchCreateAndDeleteVaultTagsResponse.d.ts

@@ -0,0 +1,4 @@
+import { SdkResponse } from "@huaweicloud/huaweicloud-sdk-core/SdkResponse";
+export declare class BatchCreateAndDeleteVaultTagsResponse extends SdkResponse {
+    constructor();
+}

package/v1/model/BatchCreateAndDeleteVaultTagsResponse.js

@@ -0,0 +1,27 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchCreateAndDeleteVaultTagsResponse = void 0;
+var SdkResponse_1 = require("@huaweicloud/huaweicloud-sdk-core/SdkResponse");
+var BatchCreateAndDeleteVaultTagsResponse = /** @class */ (function (_super) {
+    __extends(BatchCreateAndDeleteVaultTagsResponse, _super);
+    function BatchCreateAndDeleteVaultTagsResponse() {
+        return _super.call(this) || this;
+    }
+    return BatchCreateAndDeleteVaultTagsResponse;
+}(SdkResponse_1.SdkResponse));
+exports.BatchCreateAndDeleteVaultTagsResponse = BatchCreateAndDeleteVaultTagsResponse;

package/v1/model/BillbingCreateExtraInfo.d.ts

@@ -0,0 +1,11 @@
+export declare class BillbingCreateExtraInfo {
+    private 'combined_order_id'?;
+    private 'combined_order_ecs_num'?;
+    constructor();
+    withCombinedOrderId(combinedOrderId: string): BillbingCreateExtraInfo;
+    set combinedOrderId(combinedOrderId: string | undefined);
+    get combinedOrderId(): string | undefined;
+    withCombinedOrderEcsNum(combinedOrderEcsNum: number): BillbingCreateExtraInfo;
+    set combinedOrderEcsNum(combinedOrderEcsNum: number | undefined);
+    get combinedOrderEcsNum(): number | undefined;
+}

package/v1/model/BillbingCreateExtraInfo.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillbingCreateExtraInfo = void 0;
+var BillbingCreateExtraInfo = /** @class */ (function () {
+    function BillbingCreateExtraInfo() {
+    }
+    BillbingCreateExtraInfo.prototype.withCombinedOrderId = function (combinedOrderId) {
+        this['combined_order_id'] = combinedOrderId;
+        return this;
+    };
+    Object.defineProperty(BillbingCreateExtraInfo.prototype, "combinedOrderId", {
+        get: function () {
+            return this['combined_order_id'];
+        },
+        set: function (combinedOrderId) {
+            this['combined_order_id'] = combinedOrderId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BillbingCreateExtraInfo.prototype.withCombinedOrderEcsNum = function (combinedOrderEcsNum) {
+        this['combined_order_ecs_num'] = combinedOrderEcsNum;
+        return this;
+    };
+    Object.defineProperty(BillbingCreateExtraInfo.prototype, "combinedOrderEcsNum", {
+        get: function () {
+            return this['combined_order_ecs_num'];
+        },
+        set: function (combinedOrderEcsNum) {
+            this['combined_order_ecs_num'] = combinedOrderEcsNum;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BillbingCreateExtraInfo;
+}());
+exports.BillbingCreateExtraInfo = BillbingCreateExtraInfo;

package/v1/model/Billing.d.ts

@@ -0,0 +1,119 @@
+export declare class Billing {
+    allocated: number;
+    private 'charging_mode';
+    private 'cloud_type'?;
+    private 'consistent_level';
+    private 'object_type'?;
+    private 'order_id'?;
+    private 'product_id'?;
+    private 'protect_type';
+    size: number;
+    private 'spec_code';
+    status: BillingStatusEnum;
+    private 'storage_unit'?;
+    used: number;
+    private 'frozen_scene'?;
+    private 'is_multi_az'?;
+    constructor(allocated?: any, chargingMode?: any, consistentLevel?: any, protectType?: any, size?: any, specCode?: any, status?: any, used?: any);
+    withAllocated(allocated: number): Billing;
+    withChargingMode(chargingMode: BillingChargingModeEnum): Billing;
+    set chargingMode(chargingMode: BillingChargingModeEnum | undefined);
+    get chargingMode(): BillingChargingModeEnum | undefined;
+    withCloudType(cloudType: BillingCloudTypeEnum): Billing;
+    set cloudType(cloudType: BillingCloudTypeEnum | undefined);
+    get cloudType(): BillingCloudTypeEnum | undefined;
+    withConsistentLevel(consistentLevel: BillingConsistentLevelEnum): Billing;
+    set consistentLevel(consistentLevel: BillingConsistentLevelEnum | undefined);
+    get consistentLevel(): BillingConsistentLevelEnum | undefined;
+    withObjectType(objectType: BillingObjectTypeEnum): Billing;
+    set objectType(objectType: BillingObjectTypeEnum | undefined);
+    get objectType(): BillingObjectTypeEnum | undefined;
+    withOrderId(orderId: string): Billing;
+    set orderId(orderId: string | undefined);
+    get orderId(): string | undefined;
+    withProductId(productId: string): Billing;
+    set productId(productId: string | undefined);
+    get productId(): string | undefined;
+    withProtectType(protectType: BillingProtectTypeEnum): Billing;
+    set protectType(protectType: BillingProtectTypeEnum | undefined);
+    get protectType(): BillingProtectTypeEnum | undefined;
+    withSize(size: number): Billing;
+    withSpecCode(specCode: BillingSpecCodeEnum): Billing;
+    set specCode(specCode: BillingSpecCodeEnum | undefined);
+    get specCode(): BillingSpecCodeEnum | undefined;
+    withStatus(status: BillingStatusEnum): Billing;
+    withStorageUnit(storageUnit: string): Billing;
+    set storageUnit(storageUnit: string | undefined);
+    get storageUnit(): string | undefined;
+    withUsed(used: number): Billing;
+    withFrozenScene(frozenScene: string): Billing;
+    set frozenScene(frozenScene: string | undefined);
+    get frozenScene(): string | undefined;
+    withIsMultiAz(isMultiAz: boolean): Billing;
+    set isMultiAz(isMultiAz: boolean | undefined);
+    get isMultiAz(): boolean | undefined;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum BillingChargingModeEnum {
+    PRE_PAID = "pre_paid",
+    POST_PAID = "post_paid"
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum BillingCloudTypeEnum {
+    PUBLIC = "public",
+    HYBRID = "hybrid"
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum BillingConsistentLevelEnum {
+    APP_CONSISTENT = "app_consistent",
+    CRASH_CONSISTENT = "crash_consistent"
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum BillingObjectTypeEnum {
+    SERVER = "server",
+    DISK = "disk",
+    WORKSPACE = "workspace",
+    VMWARE = "vmware",
+    RDS = "rds",
+    FILE = "file"
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum BillingProtectTypeEnum {
+    BACKUP = "backup",
+    REPLICATION = "replication",
+    HYBRID = "hybrid"
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum BillingSpecCodeEnum {
+    VAULT_BACKUP_SERVER_NORMAL = "vault.backup.server.normal",
+    VAULT_BACKUP_VOLUME_NORMAL = "vault.backup.volume.normal"
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum BillingStatusEnum {
+    AVAILABLE = "available",
+    LOCK = "lock",
+    FROZEN = "frozen",
+    DELETING = "deleting",
+    ERROR = "error"
+}