@huaweicloud/huaweicloud-sdk-cbr 3.1.38 → 3.1.40

package/v1/model/UpdateOrderRequest.js

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

package/v1/model/UpdateOrderResponse.d.ts

@@ -0,0 +1,10 @@
+import { SdkResponse } from "@huaweicloud/huaweicloud-sdk-core/SdkResponse";
+export declare class UpdateOrderResponse extends SdkResponse {
+    orderId?: string;
+    retCode?: string;
+    retMsg?: string;
+    constructor();
+    withOrderId(orderId: string): UpdateOrderResponse;
+    withRetCode(retCode: string): UpdateOrderResponse;
+    withRetMsg(retMsg: string): UpdateOrderResponse;
+}

package/v1/model/UpdateOrderResponse.js

@@ -0,0 +1,39 @@
+"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.UpdateOrderResponse = void 0;
+var SdkResponse_1 = require("@huaweicloud/huaweicloud-sdk-core/SdkResponse");
+var UpdateOrderResponse = /** @class */ (function (_super) {
+    __extends(UpdateOrderResponse, _super);
+    function UpdateOrderResponse() {
+        return _super.call(this) || this;
+    }
+    UpdateOrderResponse.prototype.withOrderId = function (orderId) {
+        this['orderId'] = orderId;
+        return this;
+    };
+    UpdateOrderResponse.prototype.withRetCode = function (retCode) {
+        this['retCode'] = retCode;
+        return this;
+    };
+    UpdateOrderResponse.prototype.withRetMsg = function (retMsg) {
+        this['retMsg'] = retMsg;
+        return this;
+    };
+    return UpdateOrderResponse;
+}(SdkResponse_1.SdkResponse));
+exports.UpdateOrderResponse = UpdateOrderResponse;

package/v1/model/VaultBatchUpdate.d.ts

@@ -0,0 +1,9 @@
+export declare class VaultBatchUpdate {
+    private 'smn_notify'?;
+    threshold?: number;
+    constructor();
+    withSmnNotify(smnNotify: boolean): VaultBatchUpdate;
+    set smnNotify(smnNotify: boolean | undefined);
+    get smnNotify(): boolean | undefined;
+    withThreshold(threshold: number): VaultBatchUpdate;
+}

package/v1/model/VaultBatchUpdate.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultBatchUpdate = void 0;
+var VaultBatchUpdate = /** @class */ (function () {
+    function VaultBatchUpdate() {
+    }
+    VaultBatchUpdate.prototype.withSmnNotify = function (smnNotify) {
+        this['smn_notify'] = smnNotify;
+        return this;
+    };
+    Object.defineProperty(VaultBatchUpdate.prototype, "smnNotify", {
+        get: function () {
+            return this['smn_notify'];
+        },
+        set: function (smnNotify) {
+            this['smn_notify'] = smnNotify;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultBatchUpdate.prototype.withThreshold = function (threshold) {
+        this['threshold'] = threshold;
+        return this;
+    };
+    return VaultBatchUpdate;
+}());
+exports.VaultBatchUpdate = VaultBatchUpdate;

package/v1/model/VaultCreate.d.ts

@@ -13,6 +13,10 @@ export declare class VaultCreate {
     private 'auto_bind'?;
     private 'bind_rules'?;
     private 'auto_expand'?;
+    threshold?: number;
+    private 'smn_notify'?;
+    private 'backup_name_prefix'?;
+    private 'demand_billing'?;
     constructor(billing?: any, name?: any, resources?: any);
     withBackupPolicyId(backupPolicyId: string): VaultCreate;
     set backupPolicyId(backupPolicyId: string | undefined);
@@ -34,4 +38,14 @@ export declare class VaultCreate {
     withAutoExpand(autoExpand: boolean): VaultCreate;
     set autoExpand(autoExpand: boolean | undefined);
     get autoExpand(): boolean | undefined;
+    withThreshold(threshold: number): VaultCreate;
+    withSmnNotify(smnNotify: boolean): VaultCreate;
+    set smnNotify(smnNotify: boolean | undefined);
+    get smnNotify(): boolean | undefined;
+    withBackupNamePrefix(backupNamePrefix: string): VaultCreate;
+    set backupNamePrefix(backupNamePrefix: string | undefined);
+    get backupNamePrefix(): string | undefined;
+    withDemandBilling(demandBilling: boolean): VaultCreate;
+    set demandBilling(demandBilling: boolean | undefined);
+    get demandBilling(): boolean | undefined;
 }

package/v1/model/VaultCreate.js

@@ -97,6 +97,52 @@ var VaultCreate = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    VaultCreate.prototype.withThreshold = function (threshold) {
+        this['threshold'] = threshold;
+        return this;
+    };
+    VaultCreate.prototype.withSmnNotify = function (smnNotify) {
+        this['smn_notify'] = smnNotify;
+        return this;
+    };
+    Object.defineProperty(VaultCreate.prototype, "smnNotify", {
+        get: function () {
+            return this['smn_notify'];
+        },
+        set: function (smnNotify) {
+            this['smn_notify'] = smnNotify;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultCreate.prototype.withBackupNamePrefix = function (backupNamePrefix) {
+        this['backup_name_prefix'] = backupNamePrefix;
+        return this;
+    };
+    Object.defineProperty(VaultCreate.prototype, "backupNamePrefix", {
+        get: function () {
+            return this['backup_name_prefix'];
+        },
+        set: function (backupNamePrefix) {
+            this['backup_name_prefix'] = backupNamePrefix;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultCreate.prototype.withDemandBilling = function (demandBilling) {
+        this['demand_billing'] = demandBilling;
+        return this;
+    };
+    Object.defineProperty(VaultCreate.prototype, "demandBilling", {
+        get: function () {
+            return this['demand_billing'];
+        },
+        set: function (demandBilling) {
+            this['demand_billing'] = demandBilling;
+        },
+        enumerable: false,
+        configurable: true
+    });
     return VaultCreate;
 }());
 exports.VaultCreate = VaultCreate;

package/v1/model/VaultCreateParameters.d.ts

@@ -0,0 +1,8 @@
+import { CombinedOrder } from './CombinedOrder';
+export declare class VaultCreateParameters {
+    private 'combined_order'?;
+    constructor();
+    withCombinedOrder(combinedOrder: CombinedOrder): VaultCreateParameters;
+    set combinedOrder(combinedOrder: CombinedOrder | undefined);
+    get combinedOrder(): CombinedOrder | undefined;
+}

package/v1/model/VaultCreateParameters.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultCreateParameters = void 0;
+var VaultCreateParameters = /** @class */ (function () {
+    function VaultCreateParameters() {
+    }
+    VaultCreateParameters.prototype.withCombinedOrder = function (combinedOrder) {
+        this['combined_order'] = combinedOrder;
+        return this;
+    };
+    Object.defineProperty(VaultCreateParameters.prototype, "combinedOrder", {
+        get: function () {
+            return this['combined_order'];
+        },
+        set: function (combinedOrder) {
+            this['combined_order'] = combinedOrder;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return VaultCreateParameters;
+}());
+exports.VaultCreateParameters = VaultCreateParameters;

package/v1/model/VaultCreateResource.d.ts

@@ -23,6 +23,10 @@ export declare class VaultCreateResource {
     errText?: string;
     retCode?: string;
     orders?: Array<CbcOrderResult>;
+    private 'backup_name_prefix'?;
+    private 'demand_billing'?;
+    private 'cbc_delete_count'?;
+    frozen?: boolean;
     constructor(billing?: any, id?: any, name?: any, projectId?: any, providerId?: any, resources?: any);
     withBilling(billing: Billing): VaultCreateResource;
     withDescription(description: string): VaultCreateResource;
@@ -61,4 +65,14 @@ export declare class VaultCreateResource {
     withErrText(errText: string): VaultCreateResource;
     withRetCode(retCode: string): VaultCreateResource;
     withOrders(orders: Array<CbcOrderResult>): VaultCreateResource;
+    withBackupNamePrefix(backupNamePrefix: string): VaultCreateResource;
+    set backupNamePrefix(backupNamePrefix: string | undefined);
+    get backupNamePrefix(): string | undefined;
+    withDemandBilling(demandBilling: boolean): VaultCreateResource;
+    set demandBilling(demandBilling: boolean | undefined);
+    get demandBilling(): boolean | undefined;
+    withCbcDeleteCount(cbcDeleteCount: number): VaultCreateResource;
+    set cbcDeleteCount(cbcDeleteCount: number | undefined);
+    get cbcDeleteCount(): number | undefined;
+    withFrozen(frozen: boolean): VaultCreateResource;
 }

package/v1/model/VaultCreateResource.js

@@ -176,6 +176,52 @@ var VaultCreateResource = /** @class */ (function () {
         this['orders'] = orders;
         return this;
     };
+    VaultCreateResource.prototype.withBackupNamePrefix = function (backupNamePrefix) {
+        this['backup_name_prefix'] = backupNamePrefix;
+        return this;
+    };
+    Object.defineProperty(VaultCreateResource.prototype, "backupNamePrefix", {
+        get: function () {
+            return this['backup_name_prefix'];
+        },
+        set: function (backupNamePrefix) {
+            this['backup_name_prefix'] = backupNamePrefix;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultCreateResource.prototype.withDemandBilling = function (demandBilling) {
+        this['demand_billing'] = demandBilling;
+        return this;
+    };
+    Object.defineProperty(VaultCreateResource.prototype, "demandBilling", {
+        get: function () {
+            return this['demand_billing'];
+        },
+        set: function (demandBilling) {
+            this['demand_billing'] = demandBilling;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultCreateResource.prototype.withCbcDeleteCount = function (cbcDeleteCount) {
+        this['cbc_delete_count'] = cbcDeleteCount;
+        return this;
+    };
+    Object.defineProperty(VaultCreateResource.prototype, "cbcDeleteCount", {
+        get: function () {
+            return this['cbc_delete_count'];
+        },
+        set: function (cbcDeleteCount) {
+            this['cbc_delete_count'] = cbcDeleteCount;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultCreateResource.prototype.withFrozen = function (frozen) {
+        this['frozen'] = frozen;
+        return this;
+    };
     return VaultCreateResource;
 }());
 exports.VaultCreateResource = VaultCreateResource;

package/v1/model/VaultOrder.d.ts

@@ -0,0 +1,46 @@
+import { BillingCreate } from './BillingCreate';
+import { ResourceCreate } from './ResourceCreate';
+import { Tag } from './Tag';
+import { VaultBindRules } from './VaultBindRules';
+import { VaultCreateParameters } from './VaultCreateParameters';
+export declare class VaultOrder {
+    name?: string;
+    billing: BillingCreate;
+    resources: Array<ResourceCreate>;
+    description?: string;
+    private 'backup_policy_id'?;
+    tags?: Array<Tag>;
+    private 'enterprise_project_id'?;
+    private 'auto_bind'?;
+    private 'bind_rules'?;
+    threshold?: number;
+    private 'smn_notify'?;
+    parameters?: VaultCreateParameters;
+    private 'auto_expand'?;
+    constructor(billing?: any, resources?: any);
+    withName(name: string): VaultOrder;
+    withBilling(billing: BillingCreate): VaultOrder;
+    withResources(resources: Array<ResourceCreate>): VaultOrder;
+    withDescription(description: string): VaultOrder;
+    withBackupPolicyId(backupPolicyId: string): VaultOrder;
+    set backupPolicyId(backupPolicyId: string | undefined);
+    get backupPolicyId(): string | undefined;
+    withTags(tags: Array<Tag>): VaultOrder;
+    withEnterpriseProjectId(enterpriseProjectId: string): VaultOrder;
+    set enterpriseProjectId(enterpriseProjectId: string | undefined);
+    get enterpriseProjectId(): string | undefined;
+    withAutoBind(autoBind: boolean): VaultOrder;
+    set autoBind(autoBind: boolean | undefined);
+    get autoBind(): boolean | undefined;
+    withBindRules(bindRules: VaultBindRules): VaultOrder;
+    set bindRules(bindRules: VaultBindRules | undefined);
+    get bindRules(): VaultBindRules | undefined;
+    withThreshold(threshold: number): VaultOrder;
+    withSmnNotify(smnNotify: boolean): VaultOrder;
+    set smnNotify(smnNotify: boolean | undefined);
+    get smnNotify(): boolean | undefined;
+    withParameters(parameters: VaultCreateParameters): VaultOrder;
+    withAutoExpand(autoExpand: boolean): VaultOrder;
+    set autoExpand(autoExpand: boolean | undefined);
+    get autoExpand(): boolean | undefined;
+}

package/v1/model/VaultOrder.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultOrder = void 0;
+var VaultOrder = /** @class */ (function () {
+    function VaultOrder(billing, resources) {
+        this['billing'] = billing;
+        this['resources'] = resources;
+    }
+    VaultOrder.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    VaultOrder.prototype.withBilling = function (billing) {
+        this['billing'] = billing;
+        return this;
+    };
+    VaultOrder.prototype.withResources = function (resources) {
+        this['resources'] = resources;
+        return this;
+    };
+    VaultOrder.prototype.withDescription = function (description) {
+        this['description'] = description;
+        return this;
+    };
+    VaultOrder.prototype.withBackupPolicyId = function (backupPolicyId) {
+        this['backup_policy_id'] = backupPolicyId;
+        return this;
+    };
+    Object.defineProperty(VaultOrder.prototype, "backupPolicyId", {
+        get: function () {
+            return this['backup_policy_id'];
+        },
+        set: function (backupPolicyId) {
+            this['backup_policy_id'] = backupPolicyId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultOrder.prototype.withTags = function (tags) {
+        this['tags'] = tags;
+        return this;
+    };
+    VaultOrder.prototype.withEnterpriseProjectId = function (enterpriseProjectId) {
+        this['enterprise_project_id'] = enterpriseProjectId;
+        return this;
+    };
+    Object.defineProperty(VaultOrder.prototype, "enterpriseProjectId", {
+        get: function () {
+            return this['enterprise_project_id'];
+        },
+        set: function (enterpriseProjectId) {
+            this['enterprise_project_id'] = enterpriseProjectId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultOrder.prototype.withAutoBind = function (autoBind) {
+        this['auto_bind'] = autoBind;
+        return this;
+    };
+    Object.defineProperty(VaultOrder.prototype, "autoBind", {
+        get: function () {
+            return this['auto_bind'];
+        },
+        set: function (autoBind) {
+            this['auto_bind'] = autoBind;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultOrder.prototype.withBindRules = function (bindRules) {
+        this['bind_rules'] = bindRules;
+        return this;
+    };
+    Object.defineProperty(VaultOrder.prototype, "bindRules", {
+        get: function () {
+            return this['bind_rules'];
+        },
+        set: function (bindRules) {
+            this['bind_rules'] = bindRules;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultOrder.prototype.withThreshold = function (threshold) {
+        this['threshold'] = threshold;
+        return this;
+    };
+    VaultOrder.prototype.withSmnNotify = function (smnNotify) {
+        this['smn_notify'] = smnNotify;
+        return this;
+    };
+    Object.defineProperty(VaultOrder.prototype, "smnNotify", {
+        get: function () {
+            return this['smn_notify'];
+        },
+        set: function (smnNotify) {
+            this['smn_notify'] = smnNotify;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultOrder.prototype.withParameters = function (parameters) {
+        this['parameters'] = parameters;
+        return this;
+    };
+    VaultOrder.prototype.withAutoExpand = function (autoExpand) {
+        this['auto_expand'] = autoExpand;
+        return this;
+    };
+    Object.defineProperty(VaultOrder.prototype, "autoExpand", {
+        get: function () {
+            return this['auto_expand'];
+        },
+        set: function (autoExpand) {
+            this['auto_expand'] = autoExpand;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return VaultOrder;
+}());
+exports.VaultOrder = VaultOrder;

package/v1/model/VaultOrderCreateReqs.d.ts

@@ -0,0 +1,6 @@
+import { VaultOrder } from './VaultOrder';
+export declare class VaultOrderCreateReqs {
+    vault: VaultOrder;
+    constructor(vault?: any);
+    withVault(vault: VaultOrder): VaultOrderCreateReqs;
+}

package/v1/model/VaultOrderCreateReqs.js

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

package/v1/model/VaultSetResourceReq.d.ts

@@ -0,0 +1,17 @@
+export declare class VaultSetResourceReq {
+    private 'resource_ids';
+    action: VaultSetResourceReqActionEnum;
+    constructor(resourceIds?: any, action?: any);
+    withResourceIds(resourceIds: Array<string>): VaultSetResourceReq;
+    set resourceIds(resourceIds: Array<string> | undefined);
+    get resourceIds(): Array<string> | undefined;
+    withAction(action: VaultSetResourceReqActionEnum): VaultSetResourceReq;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum VaultSetResourceReqActionEnum {
+    SUSPEND = "suspend",
+    UNSUSPEND = "unsuspend"
+}

package/v1/model/VaultSetResourceReq.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultSetResourceReqActionEnum = exports.VaultSetResourceReq = void 0;
+var VaultSetResourceReq = /** @class */ (function () {
+    function VaultSetResourceReq(resourceIds, action) {
+        this['resource_ids'] = resourceIds;
+        this['action'] = action;
+    }
+    VaultSetResourceReq.prototype.withResourceIds = function (resourceIds) {
+        this['resource_ids'] = resourceIds;
+        return this;
+    };
+    Object.defineProperty(VaultSetResourceReq.prototype, "resourceIds", {
+        get: function () {
+            return this['resource_ids'];
+        },
+        set: function (resourceIds) {
+            this['resource_ids'] = resourceIds;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultSetResourceReq.prototype.withAction = function (action) {
+        this['action'] = action;
+        return this;
+    };
+    return VaultSetResourceReq;
+}());
+exports.VaultSetResourceReq = VaultSetResourceReq;
+/**
+    * @export
+    * @enum {string}
+    */
+var VaultSetResourceReqActionEnum;
+(function (VaultSetResourceReqActionEnum) {
+    VaultSetResourceReqActionEnum["SUSPEND"] = "suspend";
+    VaultSetResourceReqActionEnum["UNSUSPEND"] = "unsuspend";
+})(VaultSetResourceReqActionEnum = exports.VaultSetResourceReqActionEnum || (exports.VaultSetResourceReqActionEnum = {}));