@huaweicloud/huaweicloud-sdk-cbr 3.1.36

package/v1/model/PolicyTriggerReq.js

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

package/v1/model/PolicyTriggerResp.d.ts

@@ -0,0 +1,19 @@
+import { PolicyTriggerPropertiesResp } from './PolicyTriggerPropertiesResp';
+export declare class PolicyTriggerResp {
+    id: string;
+    name?: string;
+    properties: PolicyTriggerPropertiesResp;
+    type?: PolicyTriggerRespTypeEnum;
+    constructor(id?: any, properties?: any);
+    withId(id: string): PolicyTriggerResp;
+    withName(name: string): PolicyTriggerResp;
+    withProperties(properties: PolicyTriggerPropertiesResp): PolicyTriggerResp;
+    withType(type: PolicyTriggerRespTypeEnum): PolicyTriggerResp;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum PolicyTriggerRespTypeEnum {
+    TIME = "time"
+}

package/v1/model/PolicyTriggerResp.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyTriggerRespTypeEnum = exports.PolicyTriggerResp = void 0;
+var PolicyTriggerResp = /** @class */ (function () {
+    function PolicyTriggerResp(id, properties) {
+        this['id'] = id;
+        this['properties'] = properties;
+    }
+    PolicyTriggerResp.prototype.withId = function (id) {
+        this['id'] = id;
+        return this;
+    };
+    PolicyTriggerResp.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    PolicyTriggerResp.prototype.withProperties = function (properties) {
+        this['properties'] = properties;
+        return this;
+    };
+    PolicyTriggerResp.prototype.withType = function (type) {
+        this['type'] = type;
+        return this;
+    };
+    return PolicyTriggerResp;
+}());
+exports.PolicyTriggerResp = PolicyTriggerResp;
+/**
+    * @export
+    * @enum {string}
+    */
+var PolicyTriggerRespTypeEnum;
+(function (PolicyTriggerRespTypeEnum) {
+    PolicyTriggerRespTypeEnum["TIME"] = "time";
+})(PolicyTriggerRespTypeEnum = exports.PolicyTriggerRespTypeEnum || (exports.PolicyTriggerRespTypeEnum = {}));

package/v1/model/PolicyUpdate.d.ts

@@ -0,0 +1,15 @@
+import { PolicyTriggerReq } from './PolicyTriggerReq';
+import { PolicyoODCreate } from './PolicyoODCreate';
+export declare class PolicyUpdate {
+    enabled?: boolean;
+    name?: string;
+    private 'operation_definition'?;
+    trigger?: PolicyTriggerReq;
+    constructor();
+    withEnabled(enabled: boolean): PolicyUpdate;
+    withName(name: string): PolicyUpdate;
+    withOperationDefinition(operationDefinition: PolicyoODCreate): PolicyUpdate;
+    set operationDefinition(operationDefinition: PolicyoODCreate | undefined);
+    get operationDefinition(): PolicyoODCreate | undefined;
+    withTrigger(trigger: PolicyTriggerReq): PolicyUpdate;
+}

package/v1/model/PolicyUpdate.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyUpdate = void 0;
+var PolicyUpdate = /** @class */ (function () {
+    function PolicyUpdate() {
+    }
+    PolicyUpdate.prototype.withEnabled = function (enabled) {
+        this['enabled'] = enabled;
+        return this;
+    };
+    PolicyUpdate.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    PolicyUpdate.prototype.withOperationDefinition = function (operationDefinition) {
+        this['operation_definition'] = operationDefinition;
+        return this;
+    };
+    Object.defineProperty(PolicyUpdate.prototype, "operationDefinition", {
+        get: function () {
+            return this['operation_definition'];
+        },
+        set: function (operationDefinition) {
+            this['operation_definition'] = operationDefinition;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PolicyUpdate.prototype.withTrigger = function (trigger) {
+        this['trigger'] = trigger;
+        return this;
+    };
+    return PolicyUpdate;
+}());
+exports.PolicyUpdate = PolicyUpdate;

package/v1/model/PolicyUpdateReq.d.ts

@@ -0,0 +1,6 @@
+import { PolicyUpdate } from './PolicyUpdate';
+export declare class PolicyUpdateReq {
+    policy: PolicyUpdate;
+    constructor(policy?: any);
+    withPolicy(policy: PolicyUpdate): PolicyUpdateReq;
+}

package/v1/model/PolicyUpdateReq.js

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

package/v1/model/PolicyoODCreate.d.ts

@@ -0,0 +1,41 @@
+export declare class PolicyoODCreate {
+    private 'day_backups'?;
+    private 'destination_project_id'?;
+    private 'destination_region'?;
+    private 'enable_acceleration'?;
+    private 'max_backups'?;
+    private 'month_backups'?;
+    private 'retention_duration_days'?;
+    timezone?: string;
+    private 'week_backups'?;
+    private 'year_backups'?;
+    constructor();
+    withDayBackups(dayBackups: number): PolicyoODCreate;
+    set dayBackups(dayBackups: number | undefined);
+    get dayBackups(): number | undefined;
+    withDestinationProjectId(destinationProjectId: string): PolicyoODCreate;
+    set destinationProjectId(destinationProjectId: string | undefined);
+    get destinationProjectId(): string | undefined;
+    withDestinationRegion(destinationRegion: string): PolicyoODCreate;
+    set destinationRegion(destinationRegion: string | undefined);
+    get destinationRegion(): string | undefined;
+    withEnableAcceleration(enableAcceleration: boolean): PolicyoODCreate;
+    set enableAcceleration(enableAcceleration: boolean | undefined);
+    get enableAcceleration(): boolean | undefined;
+    withMaxBackups(maxBackups: number): PolicyoODCreate;
+    set maxBackups(maxBackups: number | undefined);
+    get maxBackups(): number | undefined;
+    withMonthBackups(monthBackups: number): PolicyoODCreate;
+    set monthBackups(monthBackups: number | undefined);
+    get monthBackups(): number | undefined;
+    withRetentionDurationDays(retentionDurationDays: number): PolicyoODCreate;
+    set retentionDurationDays(retentionDurationDays: number | undefined);
+    get retentionDurationDays(): number | undefined;
+    withTimezone(timezone: string): PolicyoODCreate;
+    withWeekBackups(weekBackups: number): PolicyoODCreate;
+    set weekBackups(weekBackups: number | undefined);
+    get weekBackups(): number | undefined;
+    withYearBackups(yearBackups: number): PolicyoODCreate;
+    set yearBackups(yearBackups: number | undefined);
+    get yearBackups(): number | undefined;
+}

package/v1/model/PolicyoODCreate.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyoODCreate = void 0;
+var PolicyoODCreate = /** @class */ (function () {
+    function PolicyoODCreate() {
+    }
+    PolicyoODCreate.prototype.withDayBackups = function (dayBackups) {
+        this['day_backups'] = dayBackups;
+        return this;
+    };
+    Object.defineProperty(PolicyoODCreate.prototype, "dayBackups", {
+        get: function () {
+            return this['day_backups'];
+        },
+        set: function (dayBackups) {
+            this['day_backups'] = dayBackups;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PolicyoODCreate.prototype.withDestinationProjectId = function (destinationProjectId) {
+        this['destination_project_id'] = destinationProjectId;
+        return this;
+    };
+    Object.defineProperty(PolicyoODCreate.prototype, "destinationProjectId", {
+        get: function () {
+            return this['destination_project_id'];
+        },
+        set: function (destinationProjectId) {
+            this['destination_project_id'] = destinationProjectId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PolicyoODCreate.prototype.withDestinationRegion = function (destinationRegion) {
+        this['destination_region'] = destinationRegion;
+        return this;
+    };
+    Object.defineProperty(PolicyoODCreate.prototype, "destinationRegion", {
+        get: function () {
+            return this['destination_region'];
+        },
+        set: function (destinationRegion) {
+            this['destination_region'] = destinationRegion;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PolicyoODCreate.prototype.withEnableAcceleration = function (enableAcceleration) {
+        this['enable_acceleration'] = enableAcceleration;
+        return this;
+    };
+    Object.defineProperty(PolicyoODCreate.prototype, "enableAcceleration", {
+        get: function () {
+            return this['enable_acceleration'];
+        },
+        set: function (enableAcceleration) {
+            this['enable_acceleration'] = enableAcceleration;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PolicyoODCreate.prototype.withMaxBackups = function (maxBackups) {
+        this['max_backups'] = maxBackups;
+        return this;
+    };
+    Object.defineProperty(PolicyoODCreate.prototype, "maxBackups", {
+        get: function () {
+            return this['max_backups'];
+        },
+        set: function (maxBackups) {
+            this['max_backups'] = maxBackups;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PolicyoODCreate.prototype.withMonthBackups = function (monthBackups) {
+        this['month_backups'] = monthBackups;
+        return this;
+    };
+    Object.defineProperty(PolicyoODCreate.prototype, "monthBackups", {
+        get: function () {
+            return this['month_backups'];
+        },
+        set: function (monthBackups) {
+            this['month_backups'] = monthBackups;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PolicyoODCreate.prototype.withRetentionDurationDays = function (retentionDurationDays) {
+        this['retention_duration_days'] = retentionDurationDays;
+        return this;
+    };
+    Object.defineProperty(PolicyoODCreate.prototype, "retentionDurationDays", {
+        get: function () {
+            return this['retention_duration_days'];
+        },
+        set: function (retentionDurationDays) {
+            this['retention_duration_days'] = retentionDurationDays;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PolicyoODCreate.prototype.withTimezone = function (timezone) {
+        this['timezone'] = timezone;
+        return this;
+    };
+    PolicyoODCreate.prototype.withWeekBackups = function (weekBackups) {
+        this['week_backups'] = weekBackups;
+        return this;
+    };
+    Object.defineProperty(PolicyoODCreate.prototype, "weekBackups", {
+        get: function () {
+            return this['week_backups'];
+        },
+        set: function (weekBackups) {
+            this['week_backups'] = weekBackups;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PolicyoODCreate.prototype.withYearBackups = function (yearBackups) {
+        this['year_backups'] = yearBackups;
+        return this;
+    };
+    Object.defineProperty(PolicyoODCreate.prototype, "yearBackups", {
+        get: function () {
+            return this['year_backups'];
+        },
+        set: function (yearBackups) {
+            this['year_backups'] = yearBackups;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return PolicyoODCreate;
+}());
+exports.PolicyoODCreate = PolicyoODCreate;

package/v1/model/ProtectableReplicationCapabilitiesRespRegion.d.ts

@@ -0,0 +1,9 @@
+export declare class ProtectableReplicationCapabilitiesRespRegion {
+    name: string;
+    private 'replication_destinations';
+    constructor(name?: any, replicationDestinations?: any);
+    withName(name: string): ProtectableReplicationCapabilitiesRespRegion;
+    withReplicationDestinations(replicationDestinations: Array<string>): ProtectableReplicationCapabilitiesRespRegion;
+    set replicationDestinations(replicationDestinations: Array<string> | undefined);
+    get replicationDestinations(): Array<string> | undefined;
+}

package/v1/model/ProtectableReplicationCapabilitiesRespRegion.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtectableReplicationCapabilitiesRespRegion = void 0;
+var ProtectableReplicationCapabilitiesRespRegion = /** @class */ (function () {
+    function ProtectableReplicationCapabilitiesRespRegion(name, replicationDestinations) {
+        this['name'] = name;
+        this['replication_destinations'] = replicationDestinations;
+    }
+    ProtectableReplicationCapabilitiesRespRegion.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    ProtectableReplicationCapabilitiesRespRegion.prototype.withReplicationDestinations = function (replicationDestinations) {
+        this['replication_destinations'] = replicationDestinations;
+        return this;
+    };
+    Object.defineProperty(ProtectableReplicationCapabilitiesRespRegion.prototype, "replicationDestinations", {
+        get: function () {
+            return this['replication_destinations'];
+        },
+        set: function (replicationDestinations) {
+            this['replication_destinations'] = replicationDestinations;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ProtectableReplicationCapabilitiesRespRegion;
+}());
+exports.ProtectableReplicationCapabilitiesRespRegion = ProtectableReplicationCapabilitiesRespRegion;

package/v1/model/ProtectableResult.d.ts

@@ -0,0 +1,14 @@
+import { VaultGet } from './VaultGet';
+export declare class ProtectableResult {
+    code?: string;
+    reason?: string;
+    result: boolean;
+    vault?: VaultGet;
+    message?: string;
+    constructor(result?: any);
+    withCode(code: string): ProtectableResult;
+    withReason(reason: string): ProtectableResult;
+    withResult(result: boolean): ProtectableResult;
+    withVault(vault: VaultGet): ProtectableResult;
+    withMessage(message: string): ProtectableResult;
+}

package/v1/model/ProtectableResult.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtectableResult = void 0;
+var ProtectableResult = /** @class */ (function () {
+    function ProtectableResult(result) {
+        this['result'] = result;
+    }
+    ProtectableResult.prototype.withCode = function (code) {
+        this['code'] = code;
+        return this;
+    };
+    ProtectableResult.prototype.withReason = function (reason) {
+        this['reason'] = reason;
+        return this;
+    };
+    ProtectableResult.prototype.withResult = function (result) {
+        this['result'] = result;
+        return this;
+    };
+    ProtectableResult.prototype.withVault = function (vault) {
+        this['vault'] = vault;
+        return this;
+    };
+    ProtectableResult.prototype.withMessage = function (message) {
+        this['message'] = message;
+        return this;
+    };
+    return ProtectableResult;
+}());
+exports.ProtectableResult = ProtectableResult;

package/v1/model/ProtectablesResp.d.ts

@@ -0,0 +1,29 @@
+import { ProtectableResult } from './ProtectableResult';
+export declare class ProtectablesResp {
+    children: Array<object>;
+    detail?: object;
+    id: string;
+    name: string;
+    protectable: ProtectableResult;
+    size?: number;
+    status?: ProtectablesRespStatusEnum;
+    type: string;
+    constructor(children?: any, id?: any, name?: any, protectable?: any, type?: any);
+    withChildren(children: Array<object>): ProtectablesResp;
+    withDetail(detail: object): ProtectablesResp;
+    withId(id: string): ProtectablesResp;
+    withName(name: string): ProtectablesResp;
+    withProtectable(protectable: ProtectableResult): ProtectablesResp;
+    withSize(size: number): ProtectablesResp;
+    withStatus(status: ProtectablesRespStatusEnum): ProtectablesResp;
+    withType(type: string): ProtectablesResp;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum ProtectablesRespStatusEnum {
+    ACTIVE = "active",
+    DELETED = "deleted",
+    ERROR = "error"
+}

package/v1/model/ProtectablesResp.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtectablesRespStatusEnum = exports.ProtectablesResp = void 0;
+var ProtectablesResp = /** @class */ (function () {
+    function ProtectablesResp(children, id, name, protectable, type) {
+        this['children'] = children;
+        this['id'] = id;
+        this['name'] = name;
+        this['protectable'] = protectable;
+        this['type'] = type;
+    }
+    ProtectablesResp.prototype.withChildren = function (children) {
+        this['children'] = children;
+        return this;
+    };
+    ProtectablesResp.prototype.withDetail = function (detail) {
+        this['detail'] = detail;
+        return this;
+    };
+    ProtectablesResp.prototype.withId = function (id) {
+        this['id'] = id;
+        return this;
+    };
+    ProtectablesResp.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    ProtectablesResp.prototype.withProtectable = function (protectable) {
+        this['protectable'] = protectable;
+        return this;
+    };
+    ProtectablesResp.prototype.withSize = function (size) {
+        this['size'] = size;
+        return this;
+    };
+    ProtectablesResp.prototype.withStatus = function (status) {
+        this['status'] = status;
+        return this;
+    };
+    ProtectablesResp.prototype.withType = function (type) {
+        this['type'] = type;
+        return this;
+    };
+    return ProtectablesResp;
+}());
+exports.ProtectablesResp = ProtectablesResp;
+/**
+    * @export
+    * @enum {string}
+    */
+var ProtectablesRespStatusEnum;
+(function (ProtectablesRespStatusEnum) {
+    ProtectablesRespStatusEnum["ACTIVE"] = "active";
+    ProtectablesRespStatusEnum["DELETED"] = "deleted";
+    ProtectablesRespStatusEnum["ERROR"] = "error";
+})(ProtectablesRespStatusEnum = exports.ProtectablesRespStatusEnum || (exports.ProtectablesRespStatusEnum = {}));

package/v1/model/RemoveVaultResourceRequest.d.ts

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

package/v1/model/RemoveVaultResourceRequest.js

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

package/v1/model/RemoveVaultResourceResponse.d.ts

@@ -0,0 +1,8 @@
+import { SdkResponse } from "@huaweicloud/huaweicloud-sdk-core/SdkResponse";
+export declare class RemoveVaultResourceResponse extends SdkResponse {
+    private 'remove_resource_ids'?;
+    constructor();
+    withRemoveResourceIds(removeResourceIds: Array<string>): RemoveVaultResourceResponse;
+    set removeResourceIds(removeResourceIds: Array<string> | undefined);
+    get removeResourceIds(): Array<string> | undefined;
+}

package/v1/model/RemoveVaultResourceResponse.js

@@ -0,0 +1,41 @@
+"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.RemoveVaultResourceResponse = void 0;
+var SdkResponse_1 = require("@huaweicloud/huaweicloud-sdk-core/SdkResponse");
+var RemoveVaultResourceResponse = /** @class */ (function (_super) {
+    __extends(RemoveVaultResourceResponse, _super);
+    function RemoveVaultResourceResponse() {
+        return _super.call(this) || this;
+    }
+    RemoveVaultResourceResponse.prototype.withRemoveResourceIds = function (removeResourceIds) {
+        this['remove_resource_ids'] = removeResourceIds;
+        return this;
+    };
+    Object.defineProperty(RemoveVaultResourceResponse.prototype, "removeResourceIds", {
+        get: function () {
+            return this['remove_resource_ids'];
+        },
+        set: function (removeResourceIds) {
+            this['remove_resource_ids'] = removeResourceIds;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return RemoveVaultResourceResponse;
+}(SdkResponse_1.SdkResponse));
+exports.RemoveVaultResourceResponse = RemoveVaultResourceResponse;

package/v1/model/ReplicationRecordGet.d.ts

@@ -0,0 +1,67 @@
+import { ReplicationRecordsExtraInfo } from './ReplicationRecordsExtraInfo';
+export declare class ReplicationRecordGet {
+    private 'created_at'?;
+    private 'destination_backup_id'?;
+    private 'destination_checkpoint_id'?;
+    private 'destination_project_id'?;
+    private 'destination_region'?;
+    private 'destination_vault_id'?;
+    private 'extra_info'?;
+    id: string;
+    private 'source_backup_id'?;
+    private 'source_checkpoint_id'?;
+    private 'source_project_id'?;
+    private 'source_region'?;
+    status?: ReplicationRecordGetStatusEnum;
+    private 'vault_id'?;
+    constructor(id?: any);
+    withCreatedAt(createdAt: string): ReplicationRecordGet;
+    set createdAt(createdAt: string | undefined);
+    get createdAt(): string | undefined;
+    withDestinationBackupId(destinationBackupId: string): ReplicationRecordGet;
+    set destinationBackupId(destinationBackupId: string | undefined);
+    get destinationBackupId(): string | undefined;
+    withDestinationCheckpointId(destinationCheckpointId: string): ReplicationRecordGet;
+    set destinationCheckpointId(destinationCheckpointId: string | undefined);
+    get destinationCheckpointId(): string | undefined;
+    withDestinationProjectId(destinationProjectId: string): ReplicationRecordGet;
+    set destinationProjectId(destinationProjectId: string | undefined);
+    get destinationProjectId(): string | undefined;
+    withDestinationRegion(destinationRegion: string): ReplicationRecordGet;
+    set destinationRegion(destinationRegion: string | undefined);
+    get destinationRegion(): string | undefined;
+    withDestinationVaultId(destinationVaultId: string): ReplicationRecordGet;
+    set destinationVaultId(destinationVaultId: string | undefined);
+    get destinationVaultId(): string | undefined;
+    withExtraInfo(extraInfo: ReplicationRecordsExtraInfo): ReplicationRecordGet;
+    set extraInfo(extraInfo: ReplicationRecordsExtraInfo | undefined);
+    get extraInfo(): ReplicationRecordsExtraInfo | undefined;
+    withId(id: string): ReplicationRecordGet;
+    withSourceBackupId(sourceBackupId: string): ReplicationRecordGet;
+    set sourceBackupId(sourceBackupId: string | undefined);
+    get sourceBackupId(): string | undefined;
+    withSourceCheckpointId(sourceCheckpointId: string): ReplicationRecordGet;
+    set sourceCheckpointId(sourceCheckpointId: string | undefined);
+    get sourceCheckpointId(): string | undefined;
+    withSourceProjectId(sourceProjectId: string): ReplicationRecordGet;
+    set sourceProjectId(sourceProjectId: string | undefined);
+    get sourceProjectId(): string | undefined;
+    withSourceRegion(sourceRegion: string): ReplicationRecordGet;
+    set sourceRegion(sourceRegion: string | undefined);
+    get sourceRegion(): string | undefined;
+    withStatus(status: ReplicationRecordGetStatusEnum): ReplicationRecordGet;
+    withVaultId(vaultId: string): ReplicationRecordGet;
+    set vaultId(vaultId: string | undefined);
+    get vaultId(): string | undefined;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum ReplicationRecordGetStatusEnum {
+    REPLICATING = "replicating",
+    SUCCESS = "success",
+    FAIL = "fail",
+    SKIP = "skip",
+    WAITING_REPLICATE = "waiting_replicate"
+}