@huaweicloud/huaweicloud-sdk-cfw 3.1.11

package/v1/model/ProtectObjectVO.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtectObjectVOTypeEnum = exports.ProtectObjectVO = void 0;
+var ProtectObjectVO = /** @class */ (function () {
+    function ProtectObjectVO() {
+    }
+    ProtectObjectVO.prototype.withObjectId = function (objectId) {
+        this['object_id'] = objectId;
+        return this;
+    };
+    Object.defineProperty(ProtectObjectVO.prototype, "objectId", {
+        get: function () {
+            return this['object_id'];
+        },
+        set: function (objectId) {
+            this['object_id'] = objectId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ProtectObjectVO.prototype.withObjectName = function (objectName) {
+        this['object_name'] = objectName;
+        return this;
+    };
+    Object.defineProperty(ProtectObjectVO.prototype, "objectName", {
+        get: function () {
+            return this['object_name'];
+        },
+        set: function (objectName) {
+            this['object_name'] = objectName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ProtectObjectVO.prototype.withType = function (type) {
+        this['type'] = type;
+        return this;
+    };
+    return ProtectObjectVO;
+}());
+exports.ProtectObjectVO = ProtectObjectVO;
+/**
+    * @export
+    * @enum {string}
+    */
+var ProtectObjectVOTypeEnum;
+(function (ProtectObjectVOTypeEnum) {
+    ProtectObjectVOTypeEnum[ProtectObjectVOTypeEnum["NUMBER_0"] = 0] = "NUMBER_0";
+    ProtectObjectVOTypeEnum[ProtectObjectVOTypeEnum["NUMBER_1"] = 1] = "NUMBER_1";
+})(ProtectObjectVOTypeEnum = exports.ProtectObjectVOTypeEnum || (exports.ProtectObjectVOTypeEnum = {}));

package/v1/model/RuleAclListResponseDTOData.d.ts

@@ -0,0 +1,16 @@
+import { RuleAclListResponseDTODataRecords } from './RuleAclListResponseDTODataRecords';
+export declare class RuleAclListResponseDTOData {
+    offset?: number;
+    limit?: number;
+    total?: number;
+    private 'object_id'?;
+    records?: Array<RuleAclListResponseDTODataRecords>;
+    constructor();
+    withOffset(offset: number): RuleAclListResponseDTOData;
+    withLimit(limit: number): RuleAclListResponseDTOData;
+    withTotal(total: number): RuleAclListResponseDTOData;
+    withObjectId(objectId: string): RuleAclListResponseDTOData;
+    set objectId(objectId: string | undefined);
+    get objectId(): string | undefined;
+    withRecords(records: Array<RuleAclListResponseDTODataRecords>): RuleAclListResponseDTOData;
+}

package/v1/model/RuleAclListResponseDTOData.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleAclListResponseDTOData = void 0;
+var RuleAclListResponseDTOData = /** @class */ (function () {
+    function RuleAclListResponseDTOData() {
+    }
+    RuleAclListResponseDTOData.prototype.withOffset = function (offset) {
+        this['offset'] = offset;
+        return this;
+    };
+    RuleAclListResponseDTOData.prototype.withLimit = function (limit) {
+        this['limit'] = limit;
+        return this;
+    };
+    RuleAclListResponseDTOData.prototype.withTotal = function (total) {
+        this['total'] = total;
+        return this;
+    };
+    RuleAclListResponseDTOData.prototype.withObjectId = function (objectId) {
+        this['object_id'] = objectId;
+        return this;
+    };
+    Object.defineProperty(RuleAclListResponseDTOData.prototype, "objectId", {
+        get: function () {
+            return this['object_id'];
+        },
+        set: function (objectId) {
+            this['object_id'] = objectId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleAclListResponseDTOData.prototype.withRecords = function (records) {
+        this['records'] = records;
+        return this;
+    };
+    return RuleAclListResponseDTOData;
+}());
+exports.RuleAclListResponseDTOData = RuleAclListResponseDTOData;

package/v1/model/RuleAclListResponseDTODataRecords.d.ts

@@ -0,0 +1,62 @@
+import { OrderRuleAclDto } from './OrderRuleAclDto';
+import { RuleAddressDto } from './RuleAddressDto';
+import { RuleServiceDto } from './RuleServiceDto';
+export declare class RuleAclListResponseDTODataRecords {
+    private 'rule_id'?;
+    private 'address_type'?;
+    name?: string;
+    sequence?: OrderRuleAclDto;
+    direction?: RuleAclListResponseDTODataRecordsDirectionEnum;
+    private 'action_type'?;
+    status?: number;
+    description?: string;
+    private 'long_connect_time_hour'?;
+    private 'long_connect_time_minute'?;
+    private 'long_connect_time_second'?;
+    private 'long_connect_time'?;
+    private 'long_connect_enable'?;
+    source?: RuleAddressDto;
+    destination?: RuleAddressDto;
+    service?: RuleServiceDto;
+    constructor();
+    withRuleId(ruleId: string): RuleAclListResponseDTODataRecords;
+    set ruleId(ruleId: string | undefined);
+    get ruleId(): string | undefined;
+    withAddressType(addressType: number): RuleAclListResponseDTODataRecords;
+    set addressType(addressType: number | undefined);
+    get addressType(): number | undefined;
+    withName(name: string): RuleAclListResponseDTODataRecords;
+    withSequence(sequence: OrderRuleAclDto): RuleAclListResponseDTODataRecords;
+    withDirection(direction: RuleAclListResponseDTODataRecordsDirectionEnum): RuleAclListResponseDTODataRecords;
+    withActionType(actionType: number): RuleAclListResponseDTODataRecords;
+    set actionType(actionType: number | undefined);
+    get actionType(): number | undefined;
+    withStatus(status: number): RuleAclListResponseDTODataRecords;
+    withDescription(description: string): RuleAclListResponseDTODataRecords;
+    withLongConnectTimeHour(longConnectTimeHour: number): RuleAclListResponseDTODataRecords;
+    set longConnectTimeHour(longConnectTimeHour: number | undefined);
+    get longConnectTimeHour(): number | undefined;
+    withLongConnectTimeMinute(longConnectTimeMinute: number): RuleAclListResponseDTODataRecords;
+    set longConnectTimeMinute(longConnectTimeMinute: number | undefined);
+    get longConnectTimeMinute(): number | undefined;
+    withLongConnectTimeSecond(longConnectTimeSecond: number): RuleAclListResponseDTODataRecords;
+    set longConnectTimeSecond(longConnectTimeSecond: number | undefined);
+    get longConnectTimeSecond(): number | undefined;
+    withLongConnectTime(longConnectTime: number): RuleAclListResponseDTODataRecords;
+    set longConnectTime(longConnectTime: number | undefined);
+    get longConnectTime(): number | undefined;
+    withLongConnectEnable(longConnectEnable: number): RuleAclListResponseDTODataRecords;
+    set longConnectEnable(longConnectEnable: number | undefined);
+    get longConnectEnable(): number | undefined;
+    withSource(source: RuleAddressDto): RuleAclListResponseDTODataRecords;
+    withDestination(destination: RuleAddressDto): RuleAclListResponseDTODataRecords;
+    withService(service: RuleServiceDto): RuleAclListResponseDTODataRecords;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum RuleAclListResponseDTODataRecordsDirectionEnum {
+    NUMBER_0 = 0,
+    NUMBER_1 = 1
+}

package/v1/model/RuleAclListResponseDTODataRecords.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleAclListResponseDTODataRecordsDirectionEnum = exports.RuleAclListResponseDTODataRecords = void 0;
+var RuleAclListResponseDTODataRecords = /** @class */ (function () {
+    function RuleAclListResponseDTODataRecords() {
+    }
+    RuleAclListResponseDTODataRecords.prototype.withRuleId = function (ruleId) {
+        this['rule_id'] = ruleId;
+        return this;
+    };
+    Object.defineProperty(RuleAclListResponseDTODataRecords.prototype, "ruleId", {
+        get: function () {
+            return this['rule_id'];
+        },
+        set: function (ruleId) {
+            this['rule_id'] = ruleId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleAclListResponseDTODataRecords.prototype.withAddressType = function (addressType) {
+        this['address_type'] = addressType;
+        return this;
+    };
+    Object.defineProperty(RuleAclListResponseDTODataRecords.prototype, "addressType", {
+        get: function () {
+            return this['address_type'];
+        },
+        set: function (addressType) {
+            this['address_type'] = addressType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleAclListResponseDTODataRecords.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    RuleAclListResponseDTODataRecords.prototype.withSequence = function (sequence) {
+        this['sequence'] = sequence;
+        return this;
+    };
+    RuleAclListResponseDTODataRecords.prototype.withDirection = function (direction) {
+        this['direction'] = direction;
+        return this;
+    };
+    RuleAclListResponseDTODataRecords.prototype.withActionType = function (actionType) {
+        this['action_type'] = actionType;
+        return this;
+    };
+    Object.defineProperty(RuleAclListResponseDTODataRecords.prototype, "actionType", {
+        get: function () {
+            return this['action_type'];
+        },
+        set: function (actionType) {
+            this['action_type'] = actionType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleAclListResponseDTODataRecords.prototype.withStatus = function (status) {
+        this['status'] = status;
+        return this;
+    };
+    RuleAclListResponseDTODataRecords.prototype.withDescription = function (description) {
+        this['description'] = description;
+        return this;
+    };
+    RuleAclListResponseDTODataRecords.prototype.withLongConnectTimeHour = function (longConnectTimeHour) {
+        this['long_connect_time_hour'] = longConnectTimeHour;
+        return this;
+    };
+    Object.defineProperty(RuleAclListResponseDTODataRecords.prototype, "longConnectTimeHour", {
+        get: function () {
+            return this['long_connect_time_hour'];
+        },
+        set: function (longConnectTimeHour) {
+            this['long_connect_time_hour'] = longConnectTimeHour;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleAclListResponseDTODataRecords.prototype.withLongConnectTimeMinute = function (longConnectTimeMinute) {
+        this['long_connect_time_minute'] = longConnectTimeMinute;
+        return this;
+    };
+    Object.defineProperty(RuleAclListResponseDTODataRecords.prototype, "longConnectTimeMinute", {
+        get: function () {
+            return this['long_connect_time_minute'];
+        },
+        set: function (longConnectTimeMinute) {
+            this['long_connect_time_minute'] = longConnectTimeMinute;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleAclListResponseDTODataRecords.prototype.withLongConnectTimeSecond = function (longConnectTimeSecond) {
+        this['long_connect_time_second'] = longConnectTimeSecond;
+        return this;
+    };
+    Object.defineProperty(RuleAclListResponseDTODataRecords.prototype, "longConnectTimeSecond", {
+        get: function () {
+            return this['long_connect_time_second'];
+        },
+        set: function (longConnectTimeSecond) {
+            this['long_connect_time_second'] = longConnectTimeSecond;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleAclListResponseDTODataRecords.prototype.withLongConnectTime = function (longConnectTime) {
+        this['long_connect_time'] = longConnectTime;
+        return this;
+    };
+    Object.defineProperty(RuleAclListResponseDTODataRecords.prototype, "longConnectTime", {
+        get: function () {
+            return this['long_connect_time'];
+        },
+        set: function (longConnectTime) {
+            this['long_connect_time'] = longConnectTime;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleAclListResponseDTODataRecords.prototype.withLongConnectEnable = function (longConnectEnable) {
+        this['long_connect_enable'] = longConnectEnable;
+        return this;
+    };
+    Object.defineProperty(RuleAclListResponseDTODataRecords.prototype, "longConnectEnable", {
+        get: function () {
+            return this['long_connect_enable'];
+        },
+        set: function (longConnectEnable) {
+            this['long_connect_enable'] = longConnectEnable;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleAclListResponseDTODataRecords.prototype.withSource = function (source) {
+        this['source'] = source;
+        return this;
+    };
+    RuleAclListResponseDTODataRecords.prototype.withDestination = function (destination) {
+        this['destination'] = destination;
+        return this;
+    };
+    RuleAclListResponseDTODataRecords.prototype.withService = function (service) {
+        this['service'] = service;
+        return this;
+    };
+    return RuleAclListResponseDTODataRecords;
+}());
+exports.RuleAclListResponseDTODataRecords = RuleAclListResponseDTODataRecords;
+/**
+    * @export
+    * @enum {string}
+    */
+var RuleAclListResponseDTODataRecordsDirectionEnum;
+(function (RuleAclListResponseDTODataRecordsDirectionEnum) {
+    RuleAclListResponseDTODataRecordsDirectionEnum[RuleAclListResponseDTODataRecordsDirectionEnum["NUMBER_0"] = 0] = "NUMBER_0";
+    RuleAclListResponseDTODataRecordsDirectionEnum[RuleAclListResponseDTODataRecordsDirectionEnum["NUMBER_1"] = 1] = "NUMBER_1";
+})(RuleAclListResponseDTODataRecordsDirectionEnum = exports.RuleAclListResponseDTODataRecordsDirectionEnum || (exports.RuleAclListResponseDTODataRecordsDirectionEnum = {}));

package/v1/model/RuleAddressDto.d.ts

@@ -0,0 +1,23 @@
+export declare class RuleAddressDto {
+    type: number;
+    private 'address_type'?;
+    address?: string;
+    private 'address_set_id'?;
+    private 'address_set_name'?;
+    private 'domain_address_name'?;
+    constructor(type?: any);
+    withType(type: number): RuleAddressDto;
+    withAddressType(addressType: number): RuleAddressDto;
+    set addressType(addressType: number | undefined);
+    get addressType(): number | undefined;
+    withAddress(address: string): RuleAddressDto;
+    withAddressSetId(addressSetId: string): RuleAddressDto;
+    set addressSetId(addressSetId: string | undefined);
+    get addressSetId(): string | undefined;
+    withAddressSetName(addressSetName: string): RuleAddressDto;
+    set addressSetName(addressSetName: string | undefined);
+    get addressSetName(): string | undefined;
+    withDomainAddressName(domainAddressName: string): RuleAddressDto;
+    set domainAddressName(domainAddressName: string | undefined);
+    get domainAddressName(): string | undefined;
+}

package/v1/model/RuleAddressDto.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleAddressDto = void 0;
+var RuleAddressDto = /** @class */ (function () {
+    function RuleAddressDto(type) {
+        this['type'] = type;
+    }
+    RuleAddressDto.prototype.withType = function (type) {
+        this['type'] = type;
+        return this;
+    };
+    RuleAddressDto.prototype.withAddressType = function (addressType) {
+        this['address_type'] = addressType;
+        return this;
+    };
+    Object.defineProperty(RuleAddressDto.prototype, "addressType", {
+        get: function () {
+            return this['address_type'];
+        },
+        set: function (addressType) {
+            this['address_type'] = addressType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleAddressDto.prototype.withAddress = function (address) {
+        this['address'] = address;
+        return this;
+    };
+    RuleAddressDto.prototype.withAddressSetId = function (addressSetId) {
+        this['address_set_id'] = addressSetId;
+        return this;
+    };
+    Object.defineProperty(RuleAddressDto.prototype, "addressSetId", {
+        get: function () {
+            return this['address_set_id'];
+        },
+        set: function (addressSetId) {
+            this['address_set_id'] = addressSetId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleAddressDto.prototype.withAddressSetName = function (addressSetName) {
+        this['address_set_name'] = addressSetName;
+        return this;
+    };
+    Object.defineProperty(RuleAddressDto.prototype, "addressSetName", {
+        get: function () {
+            return this['address_set_name'];
+        },
+        set: function (addressSetName) {
+            this['address_set_name'] = addressSetName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleAddressDto.prototype.withDomainAddressName = function (domainAddressName) {
+        this['domain_address_name'] = domainAddressName;
+        return this;
+    };
+    Object.defineProperty(RuleAddressDto.prototype, "domainAddressName", {
+        get: function () {
+            return this['domain_address_name'];
+        },
+        set: function (domainAddressName) {
+            this['domain_address_name'] = domainAddressName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return RuleAddressDto;
+}());
+exports.RuleAddressDto = RuleAddressDto;

package/v1/model/RuleHitCountObject.d.ts

@@ -0,0 +1,11 @@
+export declare class RuleHitCountObject {
+    private 'rule_id'?;
+    private 'rule_hit_count'?;
+    constructor();
+    withRuleId(ruleId: string): RuleHitCountObject;
+    set ruleId(ruleId: string | undefined);
+    get ruleId(): string | undefined;
+    withRuleHitCount(ruleHitCount: number): RuleHitCountObject;
+    set ruleHitCount(ruleHitCount: number | undefined);
+    get ruleHitCount(): number | undefined;
+}

package/v1/model/RuleHitCountObject.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleHitCountObject = void 0;
+var RuleHitCountObject = /** @class */ (function () {
+    function RuleHitCountObject() {
+    }
+    RuleHitCountObject.prototype.withRuleId = function (ruleId) {
+        this['rule_id'] = ruleId;
+        return this;
+    };
+    Object.defineProperty(RuleHitCountObject.prototype, "ruleId", {
+        get: function () {
+            return this['rule_id'];
+        },
+        set: function (ruleId) {
+            this['rule_id'] = ruleId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleHitCountObject.prototype.withRuleHitCount = function (ruleHitCount) {
+        this['rule_hit_count'] = ruleHitCount;
+        return this;
+    };
+    Object.defineProperty(RuleHitCountObject.prototype, "ruleHitCount", {
+        get: function () {
+            return this['rule_hit_count'];
+        },
+        set: function (ruleHitCount) {
+            this['rule_hit_count'] = ruleHitCount;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return RuleHitCountObject;
+}());
+exports.RuleHitCountObject = RuleHitCountObject;

package/v1/model/RuleHitCountRecords.d.ts

@@ -0,0 +1,12 @@
+import { RuleHitCountObject } from './RuleHitCountObject';
+export declare class RuleHitCountRecords {
+    limit?: number;
+    offset?: number;
+    total?: number;
+    records?: Array<RuleHitCountObject>;
+    constructor();
+    withLimit(limit: number): RuleHitCountRecords;
+    withOffset(offset: number): RuleHitCountRecords;
+    withTotal(total: number): RuleHitCountRecords;
+    withRecords(records: Array<RuleHitCountObject>): RuleHitCountRecords;
+}

package/v1/model/RuleHitCountRecords.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleHitCountRecords = void 0;
+var RuleHitCountRecords = /** @class */ (function () {
+    function RuleHitCountRecords() {
+    }
+    RuleHitCountRecords.prototype.withLimit = function (limit) {
+        this['limit'] = limit;
+        return this;
+    };
+    RuleHitCountRecords.prototype.withOffset = function (offset) {
+        this['offset'] = offset;
+        return this;
+    };
+    RuleHitCountRecords.prototype.withTotal = function (total) {
+        this['total'] = total;
+        return this;
+    };
+    RuleHitCountRecords.prototype.withRecords = function (records) {
+        this['records'] = records;
+        return this;
+    };
+    return RuleHitCountRecords;
+}());
+exports.RuleHitCountRecords = RuleHitCountRecords;

package/v1/model/RuleId.d.ts

@@ -0,0 +1,5 @@
+export declare class RuleId {
+    id?: string;
+    constructor();
+    withId(id: string): RuleId;
+}

package/v1/model/RuleId.js

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

package/v1/model/RuleIdList.d.ts

@@ -0,0 +1,6 @@
+import { RuleId } from './RuleId';
+export declare class RuleIdList {
+    rules?: Array<RuleId>;
+    constructor();
+    withRules(rules: Array<RuleId>): RuleIdList;
+}

package/v1/model/RuleIdList.js

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

package/v1/model/RuleServiceDto.d.ts

@@ -0,0 +1,23 @@
+export declare class RuleServiceDto {
+    type: number;
+    protocol?: number;
+    private 'source_port'?;
+    private 'dest_port'?;
+    private 'service_set_id'?;
+    private 'service_set_name'?;
+    constructor(type?: any);
+    withType(type: number): RuleServiceDto;
+    withProtocol(protocol: number): RuleServiceDto;
+    withSourcePort(sourcePort: string): RuleServiceDto;
+    set sourcePort(sourcePort: string | undefined);
+    get sourcePort(): string | undefined;
+    withDestPort(destPort: string): RuleServiceDto;
+    set destPort(destPort: string | undefined);
+    get destPort(): string | undefined;
+    withServiceSetId(serviceSetId: string): RuleServiceDto;
+    set serviceSetId(serviceSetId: string | undefined);
+    get serviceSetId(): string | undefined;
+    withServiceSetName(serviceSetName: string): RuleServiceDto;
+    set serviceSetName(serviceSetName: string | undefined);
+    get serviceSetName(): string | undefined;
+}

package/v1/model/RuleServiceDto.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleServiceDto = void 0;
+var RuleServiceDto = /** @class */ (function () {
+    function RuleServiceDto(type) {
+        this['type'] = type;
+    }
+    RuleServiceDto.prototype.withType = function (type) {
+        this['type'] = type;
+        return this;
+    };
+    RuleServiceDto.prototype.withProtocol = function (protocol) {
+        this['protocol'] = protocol;
+        return this;
+    };
+    RuleServiceDto.prototype.withSourcePort = function (sourcePort) {
+        this['source_port'] = sourcePort;
+        return this;
+    };
+    Object.defineProperty(RuleServiceDto.prototype, "sourcePort", {
+        get: function () {
+            return this['source_port'];
+        },
+        set: function (sourcePort) {
+            this['source_port'] = sourcePort;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleServiceDto.prototype.withDestPort = function (destPort) {
+        this['dest_port'] = destPort;
+        return this;
+    };
+    Object.defineProperty(RuleServiceDto.prototype, "destPort", {
+        get: function () {
+            return this['dest_port'];
+        },
+        set: function (destPort) {
+            this['dest_port'] = destPort;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleServiceDto.prototype.withServiceSetId = function (serviceSetId) {
+        this['service_set_id'] = serviceSetId;
+        return this;
+    };
+    Object.defineProperty(RuleServiceDto.prototype, "serviceSetId", {
+        get: function () {
+            return this['service_set_id'];
+        },
+        set: function (serviceSetId) {
+            this['service_set_id'] = serviceSetId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RuleServiceDto.prototype.withServiceSetName = function (serviceSetName) {
+        this['service_set_name'] = serviceSetName;
+        return this;
+    };
+    Object.defineProperty(RuleServiceDto.prototype, "serviceSetName", {
+        get: function () {
+            return this['service_set_name'];
+        },
+        set: function (serviceSetName) {
+            this['service_set_name'] = serviceSetName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return RuleServiceDto;
+}());
+exports.RuleServiceDto = RuleServiceDto;

package/v1/model/ServiceItemIds.d.ts

@@ -0,0 +1,6 @@
+import { IdObject } from './IdObject';
+export declare class ServiceItemIds {
+    items?: Array<IdObject>;
+    constructor();
+    withItems(items: Array<IdObject>): ServiceItemIds;
+}