@huaweicloud/huaweicloud-sdk-cbr 3.1.36

package/v1/model/BillingUpdate.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingUpdateConsistentLevelEnum = exports.BillingUpdate = void 0;
+var BillingUpdate = /** @class */ (function () {
+    function BillingUpdate() {
+    }
+    BillingUpdate.prototype.withConsistentLevel = function (consistentLevel) {
+        this['consistent_level'] = consistentLevel;
+        return this;
+    };
+    Object.defineProperty(BillingUpdate.prototype, "consistentLevel", {
+        get: function () {
+            return this['consistent_level'];
+        },
+        set: function (consistentLevel) {
+            this['consistent_level'] = consistentLevel;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BillingUpdate.prototype.withSize = function (size) {
+        this['size'] = size;
+        return this;
+    };
+    return BillingUpdate;
+}());
+exports.BillingUpdate = BillingUpdate;
+/**
+    * @export
+    * @enum {string}
+    */
+var BillingUpdateConsistentLevelEnum;
+(function (BillingUpdateConsistentLevelEnum) {
+    BillingUpdateConsistentLevelEnum["APP_CONSISTENT"] = "app_consistent";
+    BillingUpdateConsistentLevelEnum["CRASH_CONSISTENT"] = "crash_consistent";
+})(BillingUpdateConsistentLevelEnum = exports.BillingUpdateConsistentLevelEnum || (exports.BillingUpdateConsistentLevelEnum = {}));

package/v1/model/BindRulesTags.d.ts

@@ -0,0 +1,7 @@
+export declare class BindRulesTags {
+    key: string;
+    value: string;
+    constructor(key?: any, value?: any);
+    withKey(key: string): BindRulesTags;
+    withValue(value: string): BindRulesTags;
+}

package/v1/model/BindRulesTags.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BindRulesTags = void 0;
+var BindRulesTags = /** @class */ (function () {
+    function BindRulesTags(key, value) {
+        this['key'] = key;
+        this['value'] = value;
+    }
+    BindRulesTags.prototype.withKey = function (key) {
+        this['key'] = key;
+        return this;
+    };
+    BindRulesTags.prototype.withValue = function (value) {
+        this['value'] = value;
+        return this;
+    };
+    return BindRulesTags;
+}());
+exports.BindRulesTags = BindRulesTags;

package/v1/model/BulkCreateAndDeleteVaultTagsReq.d.ts

@@ -0,0 +1,21 @@
+import { SysTag } from './SysTag';
+import { Tag } from './Tag';
+export declare class BulkCreateAndDeleteVaultTagsReq {
+    tags?: Array<Tag>;
+    private 'sys_tags'?;
+    action: BulkCreateAndDeleteVaultTagsReqActionEnum;
+    constructor(action?: any);
+    withTags(tags: Array<Tag>): BulkCreateAndDeleteVaultTagsReq;
+    withSysTags(sysTags: Array<SysTag>): BulkCreateAndDeleteVaultTagsReq;
+    set sysTags(sysTags: Array<SysTag> | undefined);
+    get sysTags(): Array<SysTag> | undefined;
+    withAction(action: BulkCreateAndDeleteVaultTagsReqActionEnum): BulkCreateAndDeleteVaultTagsReq;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum BulkCreateAndDeleteVaultTagsReqActionEnum {
+    CREATE = "create",
+    DELETE = " delete"
+}

package/v1/model/BulkCreateAndDeleteVaultTagsReq.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkCreateAndDeleteVaultTagsReqActionEnum = exports.BulkCreateAndDeleteVaultTagsReq = void 0;
+var BulkCreateAndDeleteVaultTagsReq = /** @class */ (function () {
+    function BulkCreateAndDeleteVaultTagsReq(action) {
+        this['action'] = action;
+    }
+    BulkCreateAndDeleteVaultTagsReq.prototype.withTags = function (tags) {
+        this['tags'] = tags;
+        return this;
+    };
+    BulkCreateAndDeleteVaultTagsReq.prototype.withSysTags = function (sysTags) {
+        this['sys_tags'] = sysTags;
+        return this;
+    };
+    Object.defineProperty(BulkCreateAndDeleteVaultTagsReq.prototype, "sysTags", {
+        get: function () {
+            return this['sys_tags'];
+        },
+        set: function (sysTags) {
+            this['sys_tags'] = sysTags;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BulkCreateAndDeleteVaultTagsReq.prototype.withAction = function (action) {
+        this['action'] = action;
+        return this;
+    };
+    return BulkCreateAndDeleteVaultTagsReq;
+}());
+exports.BulkCreateAndDeleteVaultTagsReq = BulkCreateAndDeleteVaultTagsReq;
+/**
+    * @export
+    * @enum {string}
+    */
+var BulkCreateAndDeleteVaultTagsReqActionEnum;
+(function (BulkCreateAndDeleteVaultTagsReqActionEnum) {
+    BulkCreateAndDeleteVaultTagsReqActionEnum["CREATE"] = "create";
+    BulkCreateAndDeleteVaultTagsReqActionEnum["DELETE"] = " delete";
+})(BulkCreateAndDeleteVaultTagsReqActionEnum = exports.BulkCreateAndDeleteVaultTagsReqActionEnum || (exports.BulkCreateAndDeleteVaultTagsReqActionEnum = {}));

package/v1/model/CbcOrderResult.d.ts

@@ -0,0 +1,11 @@
+export declare class CbcOrderResult {
+    cloudServiceId?: string;
+    orderId: string;
+    subscribeResult: number;
+    resourceId?: string;
+    constructor(orderId?: any, subscribeResult?: any);
+    withCloudServiceId(cloudServiceId: string): CbcOrderResult;
+    withOrderId(orderId: string): CbcOrderResult;
+    withSubscribeResult(subscribeResult: number): CbcOrderResult;
+    withResourceId(resourceId: string): CbcOrderResult;
+}

package/v1/model/CbcOrderResult.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CbcOrderResult = void 0;
+var CbcOrderResult = /** @class */ (function () {
+    function CbcOrderResult(orderId, subscribeResult) {
+        this['orderId'] = orderId;
+        this['subscribeResult'] = subscribeResult;
+    }
+    CbcOrderResult.prototype.withCloudServiceId = function (cloudServiceId) {
+        this['cloudServiceId'] = cloudServiceId;
+        return this;
+    };
+    CbcOrderResult.prototype.withOrderId = function (orderId) {
+        this['orderId'] = orderId;
+        return this;
+    };
+    CbcOrderResult.prototype.withSubscribeResult = function (subscribeResult) {
+        this['subscribeResult'] = subscribeResult;
+        return this;
+    };
+    CbcOrderResult.prototype.withResourceId = function (resourceId) {
+        this['resourceId'] = resourceId;
+        return this;
+    };
+    return CbcOrderResult;
+}());
+exports.CbcOrderResult = CbcOrderResult;

package/v1/model/CheckpointCreate.d.ts

@@ -0,0 +1,35 @@
+import { CheckpointExtraInfoResp } from './CheckpointExtraInfoResp';
+import { CheckpointPlanCreate } from './CheckpointPlanCreate';
+export declare class CheckpointCreate {
+    private 'created_at';
+    id: string;
+    private 'project_id';
+    status: CheckpointCreateStatusEnum;
+    vault?: CheckpointPlanCreate;
+    private 'extra_info'?;
+    constructor(createdAt?: any, id?: any, projectId?: any, status?: any);
+    withCreatedAt(createdAt: string): CheckpointCreate;
+    set createdAt(createdAt: string | undefined);
+    get createdAt(): string | undefined;
+    withId(id: string): CheckpointCreate;
+    withProjectId(projectId: string): CheckpointCreate;
+    set projectId(projectId: string | undefined);
+    get projectId(): string | undefined;
+    withStatus(status: CheckpointCreateStatusEnum): CheckpointCreate;
+    withVault(vault: CheckpointPlanCreate): CheckpointCreate;
+    withExtraInfo(extraInfo: CheckpointExtraInfoResp): CheckpointCreate;
+    set extraInfo(extraInfo: CheckpointExtraInfoResp | undefined);
+    get extraInfo(): CheckpointExtraInfoResp | undefined;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum CheckpointCreateStatusEnum {
+    AVAILABLE = "available",
+    DELETING = "deleting",
+    PROTECTING = "protecting",
+    DELETED = "deleted",
+    ERROR_DELETING = "error-deleting",
+    ERROR = "error"
+}

package/v1/model/CheckpointCreate.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckpointCreateStatusEnum = exports.CheckpointCreate = void 0;
+var CheckpointCreate = /** @class */ (function () {
+    function CheckpointCreate(createdAt, id, projectId, status) {
+        this['created_at'] = createdAt;
+        this['id'] = id;
+        this['project_id'] = projectId;
+        this['status'] = status;
+    }
+    CheckpointCreate.prototype.withCreatedAt = function (createdAt) {
+        this['created_at'] = createdAt;
+        return this;
+    };
+    Object.defineProperty(CheckpointCreate.prototype, "createdAt", {
+        get: function () {
+            return this['created_at'];
+        },
+        set: function (createdAt) {
+            this['created_at'] = createdAt;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CheckpointCreate.prototype.withId = function (id) {
+        this['id'] = id;
+        return this;
+    };
+    CheckpointCreate.prototype.withProjectId = function (projectId) {
+        this['project_id'] = projectId;
+        return this;
+    };
+    Object.defineProperty(CheckpointCreate.prototype, "projectId", {
+        get: function () {
+            return this['project_id'];
+        },
+        set: function (projectId) {
+            this['project_id'] = projectId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CheckpointCreate.prototype.withStatus = function (status) {
+        this['status'] = status;
+        return this;
+    };
+    CheckpointCreate.prototype.withVault = function (vault) {
+        this['vault'] = vault;
+        return this;
+    };
+    CheckpointCreate.prototype.withExtraInfo = function (extraInfo) {
+        this['extra_info'] = extraInfo;
+        return this;
+    };
+    Object.defineProperty(CheckpointCreate.prototype, "extraInfo", {
+        get: function () {
+            return this['extra_info'];
+        },
+        set: function (extraInfo) {
+            this['extra_info'] = extraInfo;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return CheckpointCreate;
+}());
+exports.CheckpointCreate = CheckpointCreate;
+/**
+    * @export
+    * @enum {string}
+    */
+var CheckpointCreateStatusEnum;
+(function (CheckpointCreateStatusEnum) {
+    CheckpointCreateStatusEnum["AVAILABLE"] = "available";
+    CheckpointCreateStatusEnum["DELETING"] = "deleting";
+    CheckpointCreateStatusEnum["PROTECTING"] = "protecting";
+    CheckpointCreateStatusEnum["DELETED"] = "deleted";
+    CheckpointCreateStatusEnum["ERROR_DELETING"] = "error-deleting";
+    CheckpointCreateStatusEnum["ERROR"] = "error";
+})(CheckpointCreateStatusEnum = exports.CheckpointCreateStatusEnum || (exports.CheckpointCreateStatusEnum = {}));

package/v1/model/CheckpointCreateSkippedResource.d.ts

@@ -0,0 +1,13 @@
+export declare class CheckpointCreateSkippedResource {
+    id?: string;
+    type?: string;
+    name?: string;
+    code?: string;
+    reason?: string;
+    constructor();
+    withId(id: string): CheckpointCreateSkippedResource;
+    withType(type: string): CheckpointCreateSkippedResource;
+    withName(name: string): CheckpointCreateSkippedResource;
+    withCode(code: string): CheckpointCreateSkippedResource;
+    withReason(reason: string): CheckpointCreateSkippedResource;
+}

package/v1/model/CheckpointCreateSkippedResource.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckpointCreateSkippedResource = void 0;
+var CheckpointCreateSkippedResource = /** @class */ (function () {
+    function CheckpointCreateSkippedResource() {
+    }
+    CheckpointCreateSkippedResource.prototype.withId = function (id) {
+        this['id'] = id;
+        return this;
+    };
+    CheckpointCreateSkippedResource.prototype.withType = function (type) {
+        this['type'] = type;
+        return this;
+    };
+    CheckpointCreateSkippedResource.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    CheckpointCreateSkippedResource.prototype.withCode = function (code) {
+        this['code'] = code;
+        return this;
+    };
+    CheckpointCreateSkippedResource.prototype.withReason = function (reason) {
+        this['reason'] = reason;
+        return this;
+    };
+    return CheckpointCreateSkippedResource;
+}());
+exports.CheckpointCreateSkippedResource = CheckpointCreateSkippedResource;

package/v1/model/CheckpointExtraInfoResp.d.ts

@@ -0,0 +1,11 @@
+export declare class CheckpointExtraInfoResp {
+    name?: string;
+    description?: string;
+    private 'retention_duration'?;
+    constructor();
+    withName(name: string): CheckpointExtraInfoResp;
+    withDescription(description: string): CheckpointExtraInfoResp;
+    withRetentionDuration(retentionDuration: number): CheckpointExtraInfoResp;
+    set retentionDuration(retentionDuration: number | undefined);
+    get retentionDuration(): number | undefined;
+}

package/v1/model/CheckpointExtraInfoResp.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckpointExtraInfoResp = void 0;
+var CheckpointExtraInfoResp = /** @class */ (function () {
+    function CheckpointExtraInfoResp() {
+    }
+    CheckpointExtraInfoResp.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    CheckpointExtraInfoResp.prototype.withDescription = function (description) {
+        this['description'] = description;
+        return this;
+    };
+    CheckpointExtraInfoResp.prototype.withRetentionDuration = function (retentionDuration) {
+        this['retention_duration'] = retentionDuration;
+        return this;
+    };
+    Object.defineProperty(CheckpointExtraInfoResp.prototype, "retentionDuration", {
+        get: function () {
+            return this['retention_duration'];
+        },
+        set: function (retentionDuration) {
+            this['retention_duration'] = retentionDuration;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return CheckpointExtraInfoResp;
+}());
+exports.CheckpointExtraInfoResp = CheckpointExtraInfoResp;

package/v1/model/CheckpointParam.d.ts

@@ -0,0 +1,24 @@
+import { Resource } from './Resource';
+export declare class CheckpointParam {
+    private 'auto_trigger'?;
+    description?: string;
+    incremental?: boolean;
+    name?: string;
+    resources?: Array<string>;
+    private 'resource_details'?;
+    private 'policy_id'?;
+    constructor();
+    withAutoTrigger(autoTrigger: boolean): CheckpointParam;
+    set autoTrigger(autoTrigger: boolean | undefined);
+    get autoTrigger(): boolean | undefined;
+    withDescription(description: string): CheckpointParam;
+    withIncremental(incremental: boolean): CheckpointParam;
+    withName(name: string): CheckpointParam;
+    withResources(resources: Array<string>): CheckpointParam;
+    withResourceDetails(resourceDetails: Array<Resource>): CheckpointParam;
+    set resourceDetails(resourceDetails: Array<Resource> | undefined);
+    get resourceDetails(): Array<Resource> | undefined;
+    withPolicyId(policyId: string): CheckpointParam;
+    set policyId(policyId: string | undefined);
+    get policyId(): string | undefined;
+}

package/v1/model/CheckpointParam.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckpointParam = void 0;
+var CheckpointParam = /** @class */ (function () {
+    function CheckpointParam() {
+    }
+    CheckpointParam.prototype.withAutoTrigger = function (autoTrigger) {
+        this['auto_trigger'] = autoTrigger;
+        return this;
+    };
+    Object.defineProperty(CheckpointParam.prototype, "autoTrigger", {
+        get: function () {
+            return this['auto_trigger'];
+        },
+        set: function (autoTrigger) {
+            this['auto_trigger'] = autoTrigger;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CheckpointParam.prototype.withDescription = function (description) {
+        this['description'] = description;
+        return this;
+    };
+    CheckpointParam.prototype.withIncremental = function (incremental) {
+        this['incremental'] = incremental;
+        return this;
+    };
+    CheckpointParam.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    CheckpointParam.prototype.withResources = function (resources) {
+        this['resources'] = resources;
+        return this;
+    };
+    CheckpointParam.prototype.withResourceDetails = function (resourceDetails) {
+        this['resource_details'] = resourceDetails;
+        return this;
+    };
+    Object.defineProperty(CheckpointParam.prototype, "resourceDetails", {
+        get: function () {
+            return this['resource_details'];
+        },
+        set: function (resourceDetails) {
+            this['resource_details'] = resourceDetails;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CheckpointParam.prototype.withPolicyId = function (policyId) {
+        this['policy_id'] = policyId;
+        return this;
+    };
+    Object.defineProperty(CheckpointParam.prototype, "policyId", {
+        get: function () {
+            return this['policy_id'];
+        },
+        set: function (policyId) {
+            this['policy_id'] = policyId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return CheckpointParam;
+}());
+exports.CheckpointParam = CheckpointParam;

package/v1/model/CheckpointPlanCreate.d.ts

@@ -0,0 +1,15 @@
+import { CheckpointCreateSkippedResource } from './CheckpointCreateSkippedResource';
+import { CheckpointResourceResp } from './CheckpointResourceResp';
+export declare class CheckpointPlanCreate {
+    id: string;
+    name: string;
+    resources?: Array<CheckpointResourceResp>;
+    private 'skipped_resources'?;
+    constructor(id?: any, name?: any);
+    withId(id: string): CheckpointPlanCreate;
+    withName(name: string): CheckpointPlanCreate;
+    withResources(resources: Array<CheckpointResourceResp>): CheckpointPlanCreate;
+    withSkippedResources(skippedResources: Array<CheckpointCreateSkippedResource>): CheckpointPlanCreate;
+    set skippedResources(skippedResources: Array<CheckpointCreateSkippedResource> | undefined);
+    get skippedResources(): Array<CheckpointCreateSkippedResource> | undefined;
+}

package/v1/model/CheckpointPlanCreate.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckpointPlanCreate = void 0;
+var CheckpointPlanCreate = /** @class */ (function () {
+    function CheckpointPlanCreate(id, name) {
+        this['id'] = id;
+        this['name'] = name;
+    }
+    CheckpointPlanCreate.prototype.withId = function (id) {
+        this['id'] = id;
+        return this;
+    };
+    CheckpointPlanCreate.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    CheckpointPlanCreate.prototype.withResources = function (resources) {
+        this['resources'] = resources;
+        return this;
+    };
+    CheckpointPlanCreate.prototype.withSkippedResources = function (skippedResources) {
+        this['skipped_resources'] = skippedResources;
+        return this;
+    };
+    Object.defineProperty(CheckpointPlanCreate.prototype, "skippedResources", {
+        get: function () {
+            return this['skipped_resources'];
+        },
+        set: function (skippedResources) {
+            this['skipped_resources'] = skippedResources;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return CheckpointPlanCreate;
+}());
+exports.CheckpointPlanCreate = CheckpointPlanCreate;

package/v1/model/CheckpointReplicateParam.d.ts

@@ -0,0 +1,27 @@
+export declare class CheckpointReplicateParam {
+    private 'auto_trigger'?;
+    private 'destination_project_id';
+    private 'destination_region';
+    private 'destination_vault_id';
+    private 'enable_acceleration'?;
+    private 'vault_id';
+    constructor(destinationProjectId?: any, destinationRegion?: any, destinationVaultId?: any, vaultId?: any);
+    withAutoTrigger(autoTrigger: boolean): CheckpointReplicateParam;
+    set autoTrigger(autoTrigger: boolean | undefined);
+    get autoTrigger(): boolean | undefined;
+    withDestinationProjectId(destinationProjectId: string): CheckpointReplicateParam;
+    set destinationProjectId(destinationProjectId: string | undefined);
+    get destinationProjectId(): string | undefined;
+    withDestinationRegion(destinationRegion: string): CheckpointReplicateParam;
+    set destinationRegion(destinationRegion: string | undefined);
+    get destinationRegion(): string | undefined;
+    withDestinationVaultId(destinationVaultId: string): CheckpointReplicateParam;
+    set destinationVaultId(destinationVaultId: string | undefined);
+    get destinationVaultId(): string | undefined;
+    withEnableAcceleration(enableAcceleration: boolean): CheckpointReplicateParam;
+    set enableAcceleration(enableAcceleration: boolean | undefined);
+    get enableAcceleration(): boolean | undefined;
+    withVaultId(vaultId: string): CheckpointReplicateParam;
+    set vaultId(vaultId: string | undefined);
+    get vaultId(): string | undefined;
+}

package/v1/model/CheckpointReplicateParam.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckpointReplicateParam = void 0;
+var CheckpointReplicateParam = /** @class */ (function () {
+    function CheckpointReplicateParam(destinationProjectId, destinationRegion, destinationVaultId, vaultId) {
+        this['destination_project_id'] = destinationProjectId;
+        this['destination_region'] = destinationRegion;
+        this['destination_vault_id'] = destinationVaultId;
+        this['vault_id'] = vaultId;
+    }
+    CheckpointReplicateParam.prototype.withAutoTrigger = function (autoTrigger) {
+        this['auto_trigger'] = autoTrigger;
+        return this;
+    };
+    Object.defineProperty(CheckpointReplicateParam.prototype, "autoTrigger", {
+        get: function () {
+            return this['auto_trigger'];
+        },
+        set: function (autoTrigger) {
+            this['auto_trigger'] = autoTrigger;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CheckpointReplicateParam.prototype.withDestinationProjectId = function (destinationProjectId) {
+        this['destination_project_id'] = destinationProjectId;
+        return this;
+    };
+    Object.defineProperty(CheckpointReplicateParam.prototype, "destinationProjectId", {
+        get: function () {
+            return this['destination_project_id'];
+        },
+        set: function (destinationProjectId) {
+            this['destination_project_id'] = destinationProjectId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CheckpointReplicateParam.prototype.withDestinationRegion = function (destinationRegion) {
+        this['destination_region'] = destinationRegion;
+        return this;
+    };
+    Object.defineProperty(CheckpointReplicateParam.prototype, "destinationRegion", {
+        get: function () {
+            return this['destination_region'];
+        },
+        set: function (destinationRegion) {
+            this['destination_region'] = destinationRegion;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CheckpointReplicateParam.prototype.withDestinationVaultId = function (destinationVaultId) {
+        this['destination_vault_id'] = destinationVaultId;
+        return this;
+    };
+    Object.defineProperty(CheckpointReplicateParam.prototype, "destinationVaultId", {
+        get: function () {
+            return this['destination_vault_id'];
+        },
+        set: function (destinationVaultId) {
+            this['destination_vault_id'] = destinationVaultId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CheckpointReplicateParam.prototype.withEnableAcceleration = function (enableAcceleration) {
+        this['enable_acceleration'] = enableAcceleration;
+        return this;
+    };
+    Object.defineProperty(CheckpointReplicateParam.prototype, "enableAcceleration", {
+        get: function () {
+            return this['enable_acceleration'];
+        },
+        set: function (enableAcceleration) {
+            this['enable_acceleration'] = enableAcceleration;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CheckpointReplicateParam.prototype.withVaultId = function (vaultId) {
+        this['vault_id'] = vaultId;
+        return this;
+    };
+    Object.defineProperty(CheckpointReplicateParam.prototype, "vaultId", {
+        get: function () {
+            return this['vault_id'];
+        },
+        set: function (vaultId) {
+            this['vault_id'] = vaultId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return CheckpointReplicateParam;
+}());
+exports.CheckpointReplicateParam = CheckpointReplicateParam;

package/v1/model/CheckpointReplicateReq.d.ts

@@ -0,0 +1,6 @@
+import { CheckpointReplicateParam } from './CheckpointReplicateParam';
+export declare class CheckpointReplicateReq {
+    replicate: CheckpointReplicateParam;
+    constructor(replicate?: any);
+    withReplicate(replicate: CheckpointReplicateParam): CheckpointReplicateReq;
+}

package/v1/model/CheckpointReplicateReq.js

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