@huaweicloud/huaweicloud-sdk-cbr 3.1.36

package/v1/model/OperationLog.d.ts

@@ -0,0 +1,87 @@
+import { OpErrorInfo } from './OpErrorInfo';
+import { OpExtraInfo } from './OpExtraInfo';
+export declare class OperationLog {
+    private 'checkpoint_id'?;
+    private 'created_at';
+    private 'ended_at'?;
+    private 'error_info';
+    private 'extra_info'?;
+    id: string;
+    private 'operation_type'?;
+    private 'policy_id'?;
+    private 'project_id';
+    private 'provider_id'?;
+    private 'started_at';
+    status: OperationLogStatusEnum;
+    private 'updated_at';
+    private 'vault_id'?;
+    private 'vault_name'?;
+    constructor(createdAt?: any, errorInfo?: any, id?: any, projectId?: any, startedAt?: any, status?: any, updatedAt?: any);
+    withCheckpointId(checkpointId: string): OperationLog;
+    set checkpointId(checkpointId: string | undefined);
+    get checkpointId(): string | undefined;
+    withCreatedAt(createdAt: string): OperationLog;
+    set createdAt(createdAt: string | undefined);
+    get createdAt(): string | undefined;
+    withEndedAt(endedAt: string): OperationLog;
+    set endedAt(endedAt: string | undefined);
+    get endedAt(): string | undefined;
+    withErrorInfo(errorInfo: OpErrorInfo): OperationLog;
+    set errorInfo(errorInfo: OpErrorInfo | undefined);
+    get errorInfo(): OpErrorInfo | undefined;
+    withExtraInfo(extraInfo: OpExtraInfo): OperationLog;
+    set extraInfo(extraInfo: OpExtraInfo | undefined);
+    get extraInfo(): OpExtraInfo | undefined;
+    withId(id: string): OperationLog;
+    withOperationType(operationType: OperationLogOperationTypeEnum): OperationLog;
+    set operationType(operationType: OperationLogOperationTypeEnum | undefined);
+    get operationType(): OperationLogOperationTypeEnum | undefined;
+    withPolicyId(policyId: string): OperationLog;
+    set policyId(policyId: string | undefined);
+    get policyId(): string | undefined;
+    withProjectId(projectId: string): OperationLog;
+    set projectId(projectId: string | undefined);
+    get projectId(): string | undefined;
+    withProviderId(providerId: string): OperationLog;
+    set providerId(providerId: string | undefined);
+    get providerId(): string | undefined;
+    withStartedAt(startedAt: string): OperationLog;
+    set startedAt(startedAt: string | undefined);
+    get startedAt(): string | undefined;
+    withStatus(status: OperationLogStatusEnum): OperationLog;
+    withUpdatedAt(updatedAt: string): OperationLog;
+    set updatedAt(updatedAt: string | undefined);
+    get updatedAt(): string | undefined;
+    withVaultId(vaultId: string): OperationLog;
+    set vaultId(vaultId: string | undefined);
+    get vaultId(): string | undefined;
+    withVaultName(vaultName: string): OperationLog;
+    set vaultName(vaultName: string | undefined);
+    get vaultName(): string | undefined;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum OperationLogOperationTypeEnum {
+    BACKUP = "backup",
+    COPY = "copy",
+    REPLICATION = "replication",
+    RESTORE = "restore",
+    DELETE = "delete",
+    SYNC = "sync",
+    VAULT_DELETE = "vault_delete",
+    REMOVE_RESOURCE = "remove_resource"
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum OperationLogStatusEnum {
+    SUCCESS = "success",
+    SKIPPED = "skipped",
+    FAILED = "failed",
+    RUNNING = "running",
+    TIMEOUT = "timeout",
+    WAITING = "waiting"
+}

package/v1/model/OperationLog.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationLogStatusEnum = exports.OperationLogOperationTypeEnum = exports.OperationLog = void 0;
+var OperationLog = /** @class */ (function () {
+    function OperationLog(createdAt, errorInfo, id, projectId, startedAt, status, updatedAt) {
+        this['created_at'] = createdAt;
+        this['error_info'] = errorInfo;
+        this['id'] = id;
+        this['project_id'] = projectId;
+        this['started_at'] = startedAt;
+        this['status'] = status;
+        this['updated_at'] = updatedAt;
+    }
+    OperationLog.prototype.withCheckpointId = function (checkpointId) {
+        this['checkpoint_id'] = checkpointId;
+        return this;
+    };
+    Object.defineProperty(OperationLog.prototype, "checkpointId", {
+        get: function () {
+            return this['checkpoint_id'];
+        },
+        set: function (checkpointId) {
+            this['checkpoint_id'] = checkpointId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OperationLog.prototype.withCreatedAt = function (createdAt) {
+        this['created_at'] = createdAt;
+        return this;
+    };
+    Object.defineProperty(OperationLog.prototype, "createdAt", {
+        get: function () {
+            return this['created_at'];
+        },
+        set: function (createdAt) {
+            this['created_at'] = createdAt;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OperationLog.prototype.withEndedAt = function (endedAt) {
+        this['ended_at'] = endedAt;
+        return this;
+    };
+    Object.defineProperty(OperationLog.prototype, "endedAt", {
+        get: function () {
+            return this['ended_at'];
+        },
+        set: function (endedAt) {
+            this['ended_at'] = endedAt;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OperationLog.prototype.withErrorInfo = function (errorInfo) {
+        this['error_info'] = errorInfo;
+        return this;
+    };
+    Object.defineProperty(OperationLog.prototype, "errorInfo", {
+        get: function () {
+            return this['error_info'];
+        },
+        set: function (errorInfo) {
+            this['error_info'] = errorInfo;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OperationLog.prototype.withExtraInfo = function (extraInfo) {
+        this['extra_info'] = extraInfo;
+        return this;
+    };
+    Object.defineProperty(OperationLog.prototype, "extraInfo", {
+        get: function () {
+            return this['extra_info'];
+        },
+        set: function (extraInfo) {
+            this['extra_info'] = extraInfo;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OperationLog.prototype.withId = function (id) {
+        this['id'] = id;
+        return this;
+    };
+    OperationLog.prototype.withOperationType = function (operationType) {
+        this['operation_type'] = operationType;
+        return this;
+    };
+    Object.defineProperty(OperationLog.prototype, "operationType", {
+        get: function () {
+            return this['operation_type'];
+        },
+        set: function (operationType) {
+            this['operation_type'] = operationType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OperationLog.prototype.withPolicyId = function (policyId) {
+        this['policy_id'] = policyId;
+        return this;
+    };
+    Object.defineProperty(OperationLog.prototype, "policyId", {
+        get: function () {
+            return this['policy_id'];
+        },
+        set: function (policyId) {
+            this['policy_id'] = policyId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OperationLog.prototype.withProjectId = function (projectId) {
+        this['project_id'] = projectId;
+        return this;
+    };
+    Object.defineProperty(OperationLog.prototype, "projectId", {
+        get: function () {
+            return this['project_id'];
+        },
+        set: function (projectId) {
+            this['project_id'] = projectId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OperationLog.prototype.withProviderId = function (providerId) {
+        this['provider_id'] = providerId;
+        return this;
+    };
+    Object.defineProperty(OperationLog.prototype, "providerId", {
+        get: function () {
+            return this['provider_id'];
+        },
+        set: function (providerId) {
+            this['provider_id'] = providerId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OperationLog.prototype.withStartedAt = function (startedAt) {
+        this['started_at'] = startedAt;
+        return this;
+    };
+    Object.defineProperty(OperationLog.prototype, "startedAt", {
+        get: function () {
+            return this['started_at'];
+        },
+        set: function (startedAt) {
+            this['started_at'] = startedAt;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OperationLog.prototype.withStatus = function (status) {
+        this['status'] = status;
+        return this;
+    };
+    OperationLog.prototype.withUpdatedAt = function (updatedAt) {
+        this['updated_at'] = updatedAt;
+        return this;
+    };
+    Object.defineProperty(OperationLog.prototype, "updatedAt", {
+        get: function () {
+            return this['updated_at'];
+        },
+        set: function (updatedAt) {
+            this['updated_at'] = updatedAt;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OperationLog.prototype.withVaultId = function (vaultId) {
+        this['vault_id'] = vaultId;
+        return this;
+    };
+    Object.defineProperty(OperationLog.prototype, "vaultId", {
+        get: function () {
+            return this['vault_id'];
+        },
+        set: function (vaultId) {
+            this['vault_id'] = vaultId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OperationLog.prototype.withVaultName = function (vaultName) {
+        this['vault_name'] = vaultName;
+        return this;
+    };
+    Object.defineProperty(OperationLog.prototype, "vaultName", {
+        get: function () {
+            return this['vault_name'];
+        },
+        set: function (vaultName) {
+            this['vault_name'] = vaultName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return OperationLog;
+}());
+exports.OperationLog = OperationLog;
+/**
+    * @export
+    * @enum {string}
+    */
+var OperationLogOperationTypeEnum;
+(function (OperationLogOperationTypeEnum) {
+    OperationLogOperationTypeEnum["BACKUP"] = "backup";
+    OperationLogOperationTypeEnum["COPY"] = "copy";
+    OperationLogOperationTypeEnum["REPLICATION"] = "replication";
+    OperationLogOperationTypeEnum["RESTORE"] = "restore";
+    OperationLogOperationTypeEnum["DELETE"] = "delete";
+    OperationLogOperationTypeEnum["SYNC"] = "sync";
+    OperationLogOperationTypeEnum["VAULT_DELETE"] = "vault_delete";
+    OperationLogOperationTypeEnum["REMOVE_RESOURCE"] = "remove_resource";
+})(OperationLogOperationTypeEnum = exports.OperationLogOperationTypeEnum || (exports.OperationLogOperationTypeEnum = {}));
+/**
+    * @export
+    * @enum {string}
+    */
+var OperationLogStatusEnum;
+(function (OperationLogStatusEnum) {
+    OperationLogStatusEnum["SUCCESS"] = "success";
+    OperationLogStatusEnum["SKIPPED"] = "skipped";
+    OperationLogStatusEnum["FAILED"] = "failed";
+    OperationLogStatusEnum["RUNNING"] = "running";
+    OperationLogStatusEnum["TIMEOUT"] = "timeout";
+    OperationLogStatusEnum["WAITING"] = "waiting";
+})(OperationLogStatusEnum = exports.OperationLogStatusEnum || (exports.OperationLogStatusEnum = {}));

package/v1/model/Policy.d.ts

@@ -0,0 +1,34 @@
+import { PolicyAssociateVault } from './PolicyAssociateVault';
+import { PolicyTriggerResp } from './PolicyTriggerResp';
+import { PolicyoODCreate } from './PolicyoODCreate';
+export declare class Policy {
+    enabled: boolean;
+    id: string;
+    name: string;
+    private 'operation_definition';
+    private 'operation_type';
+    trigger: PolicyTriggerResp;
+    private 'associated_vaults'?;
+    constructor(enabled?: any, id?: any, name?: any, operationDefinition?: any, operationType?: any, trigger?: any);
+    withEnabled(enabled: boolean): Policy;
+    withId(id: string): Policy;
+    withName(name: string): Policy;
+    withOperationDefinition(operationDefinition: PolicyoODCreate): Policy;
+    set operationDefinition(operationDefinition: PolicyoODCreate | undefined);
+    get operationDefinition(): PolicyoODCreate | undefined;
+    withOperationType(operationType: PolicyOperationTypeEnum): Policy;
+    set operationType(operationType: PolicyOperationTypeEnum | undefined);
+    get operationType(): PolicyOperationTypeEnum | undefined;
+    withTrigger(trigger: PolicyTriggerResp): Policy;
+    withAssociatedVaults(associatedVaults: Array<PolicyAssociateVault>): Policy;
+    set associatedVaults(associatedVaults: Array<PolicyAssociateVault> | undefined);
+    get associatedVaults(): Array<PolicyAssociateVault> | undefined;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum PolicyOperationTypeEnum {
+    BACKUP = "backup",
+    REPLICATION = "replication"
+}

package/v1/model/Policy.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyOperationTypeEnum = exports.Policy = void 0;
+var Policy = /** @class */ (function () {
+    function Policy(enabled, id, name, operationDefinition, operationType, trigger) {
+        this['enabled'] = enabled;
+        this['id'] = id;
+        this['name'] = name;
+        this['operation_definition'] = operationDefinition;
+        this['operation_type'] = operationType;
+        this['trigger'] = trigger;
+    }
+    Policy.prototype.withEnabled = function (enabled) {
+        this['enabled'] = enabled;
+        return this;
+    };
+    Policy.prototype.withId = function (id) {
+        this['id'] = id;
+        return this;
+    };
+    Policy.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    Policy.prototype.withOperationDefinition = function (operationDefinition) {
+        this['operation_definition'] = operationDefinition;
+        return this;
+    };
+    Object.defineProperty(Policy.prototype, "operationDefinition", {
+        get: function () {
+            return this['operation_definition'];
+        },
+        set: function (operationDefinition) {
+            this['operation_definition'] = operationDefinition;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Policy.prototype.withOperationType = function (operationType) {
+        this['operation_type'] = operationType;
+        return this;
+    };
+    Object.defineProperty(Policy.prototype, "operationType", {
+        get: function () {
+            return this['operation_type'];
+        },
+        set: function (operationType) {
+            this['operation_type'] = operationType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Policy.prototype.withTrigger = function (trigger) {
+        this['trigger'] = trigger;
+        return this;
+    };
+    Policy.prototype.withAssociatedVaults = function (associatedVaults) {
+        this['associated_vaults'] = associatedVaults;
+        return this;
+    };
+    Object.defineProperty(Policy.prototype, "associatedVaults", {
+        get: function () {
+            return this['associated_vaults'];
+        },
+        set: function (associatedVaults) {
+            this['associated_vaults'] = associatedVaults;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Policy;
+}());
+exports.Policy = Policy;
+/**
+    * @export
+    * @enum {string}
+    */
+var PolicyOperationTypeEnum;
+(function (PolicyOperationTypeEnum) {
+    PolicyOperationTypeEnum["BACKUP"] = "backup";
+    PolicyOperationTypeEnum["REPLICATION"] = "replication";
+})(PolicyOperationTypeEnum = exports.PolicyOperationTypeEnum || (exports.PolicyOperationTypeEnum = {}));

package/v1/model/PolicyAssociateVault.d.ts

@@ -0,0 +1,11 @@
+export declare class PolicyAssociateVault {
+    private 'destination_vault_id'?;
+    private 'vault_id';
+    constructor(vaultId?: any);
+    withDestinationVaultId(destinationVaultId: string): PolicyAssociateVault;
+    set destinationVaultId(destinationVaultId: string | undefined);
+    get destinationVaultId(): string | undefined;
+    withVaultId(vaultId: string): PolicyAssociateVault;
+    set vaultId(vaultId: string | undefined);
+    get vaultId(): string | undefined;
+}

package/v1/model/PolicyAssociateVault.js

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

package/v1/model/PolicyCreate.d.ts

@@ -0,0 +1,27 @@
+import { PolicyTriggerReq } from './PolicyTriggerReq';
+import { PolicyoODCreate } from './PolicyoODCreate';
+export declare class PolicyCreate {
+    enabled?: boolean;
+    name: string;
+    private 'operation_definition';
+    private 'operation_type';
+    trigger: PolicyTriggerReq;
+    constructor(name?: any, operationDefinition?: any, operationType?: any, trigger?: any);
+    withEnabled(enabled: boolean): PolicyCreate;
+    withName(name: string): PolicyCreate;
+    withOperationDefinition(operationDefinition: PolicyoODCreate): PolicyCreate;
+    set operationDefinition(operationDefinition: PolicyoODCreate | undefined);
+    get operationDefinition(): PolicyoODCreate | undefined;
+    withOperationType(operationType: PolicyCreateOperationTypeEnum): PolicyCreate;
+    set operationType(operationType: PolicyCreateOperationTypeEnum | undefined);
+    get operationType(): PolicyCreateOperationTypeEnum | undefined;
+    withTrigger(trigger: PolicyTriggerReq): PolicyCreate;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum PolicyCreateOperationTypeEnum {
+    BACKUP = "backup",
+    REPLICATION = "replication"
+}

package/v1/model/PolicyCreate.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyCreateOperationTypeEnum = exports.PolicyCreate = void 0;
+var PolicyCreate = /** @class */ (function () {
+    function PolicyCreate(name, operationDefinition, operationType, trigger) {
+        this['name'] = name;
+        this['operation_definition'] = operationDefinition;
+        this['operation_type'] = operationType;
+        this['trigger'] = trigger;
+    }
+    PolicyCreate.prototype.withEnabled = function (enabled) {
+        this['enabled'] = enabled;
+        return this;
+    };
+    PolicyCreate.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    PolicyCreate.prototype.withOperationDefinition = function (operationDefinition) {
+        this['operation_definition'] = operationDefinition;
+        return this;
+    };
+    Object.defineProperty(PolicyCreate.prototype, "operationDefinition", {
+        get: function () {
+            return this['operation_definition'];
+        },
+        set: function (operationDefinition) {
+            this['operation_definition'] = operationDefinition;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PolicyCreate.prototype.withOperationType = function (operationType) {
+        this['operation_type'] = operationType;
+        return this;
+    };
+    Object.defineProperty(PolicyCreate.prototype, "operationType", {
+        get: function () {
+            return this['operation_type'];
+        },
+        set: function (operationType) {
+            this['operation_type'] = operationType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PolicyCreate.prototype.withTrigger = function (trigger) {
+        this['trigger'] = trigger;
+        return this;
+    };
+    return PolicyCreate;
+}());
+exports.PolicyCreate = PolicyCreate;
+/**
+    * @export
+    * @enum {string}
+    */
+var PolicyCreateOperationTypeEnum;
+(function (PolicyCreateOperationTypeEnum) {
+    PolicyCreateOperationTypeEnum["BACKUP"] = "backup";
+    PolicyCreateOperationTypeEnum["REPLICATION"] = "replication";
+})(PolicyCreateOperationTypeEnum = exports.PolicyCreateOperationTypeEnum || (exports.PolicyCreateOperationTypeEnum = {}));

package/v1/model/PolicyCreateReq.d.ts

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

package/v1/model/PolicyCreateReq.js

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

package/v1/model/PolicyTriggerPropertiesReq.d.ts

@@ -0,0 +1,5 @@
+export declare class PolicyTriggerPropertiesReq {
+    pattern: Array<string>;
+    constructor(pattern?: any);
+    withPattern(pattern: Array<string>): PolicyTriggerPropertiesReq;
+}

package/v1/model/PolicyTriggerPropertiesReq.js

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

package/v1/model/PolicyTriggerPropertiesResp.d.ts

@@ -0,0 +1,9 @@
+export declare class PolicyTriggerPropertiesResp {
+    pattern: Array<string>;
+    private 'start_time'?;
+    constructor(pattern?: any);
+    withPattern(pattern: Array<string>): PolicyTriggerPropertiesResp;
+    withStartTime(startTime: string): PolicyTriggerPropertiesResp;
+    set startTime(startTime: string | undefined);
+    get startTime(): string | undefined;
+}

package/v1/model/PolicyTriggerPropertiesResp.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyTriggerPropertiesResp = void 0;
+var PolicyTriggerPropertiesResp = /** @class */ (function () {
+    function PolicyTriggerPropertiesResp(pattern) {
+        this['pattern'] = pattern;
+    }
+    PolicyTriggerPropertiesResp.prototype.withPattern = function (pattern) {
+        this['pattern'] = pattern;
+        return this;
+    };
+    PolicyTriggerPropertiesResp.prototype.withStartTime = function (startTime) {
+        this['start_time'] = startTime;
+        return this;
+    };
+    Object.defineProperty(PolicyTriggerPropertiesResp.prototype, "startTime", {
+        get: function () {
+            return this['start_time'];
+        },
+        set: function (startTime) {
+            this['start_time'] = startTime;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return PolicyTriggerPropertiesResp;
+}());
+exports.PolicyTriggerPropertiesResp = PolicyTriggerPropertiesResp;

package/v1/model/PolicyTriggerReq.d.ts

@@ -0,0 +1,6 @@
+import { PolicyTriggerPropertiesReq } from './PolicyTriggerPropertiesReq';
+export declare class PolicyTriggerReq {
+    properties: PolicyTriggerPropertiesReq;
+    constructor(properties?: any);
+    withProperties(properties: PolicyTriggerPropertiesReq): PolicyTriggerReq;
+}