@shieldiot/pulse-lib 1.0.10 → 1.0.12

package/dist/cjs/lib/enums/DataSourceCode.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSourceCode = void 0;
+exports.GetDataSourceCodes = GetDataSourceCodes;
+// DataSourceCode represents the sources (indices) of data to apply rules or insights
+var DataSourceCode;
+(function (DataSourceCode) {
+    // Undefined [0] 
+    DataSourceCode[DataSourceCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Data source based on Events [1] 
+    DataSourceCode[DataSourceCode["EVENT"] = 1] = "EVENT";
+    // Data source based on usage records [2] 
+    DataSourceCode[DataSourceCode["USAGE"] = 2] = "USAGE";
+    // Data source based on Session records [3] 
+    DataSourceCode[DataSourceCode["SESSION"] = 3] = "SESSION";
+})(DataSourceCode || (exports.DataSourceCode = DataSourceCode = {}));
+// Return list of DataSourceCode values and their display names
+function GetDataSourceCodes() {
+    let result = new Map();
+    result.set(DataSourceCode.UNDEFINED, 'Undefined');
+    result.set(DataSourceCode.EVENT, 'Event');
+    result.set(DataSourceCode.USAGE, 'Usage');
+    result.set(DataSourceCode.SESSION, 'Session');
+    return result;
+}

package/dist/cjs/lib/enums/DeviceActionCode.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceActionCode = void 0;
+exports.GetDeviceActionCodes = GetDeviceActionCodes;
+// Device action code
+var DeviceActionCode;
+(function (DeviceActionCode) {
+    // Undefined [0] 
+    DeviceActionCode[DeviceActionCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Redirect all traffic to an alternative endpoint [1] 
+    DeviceActionCode[DeviceActionCode["REDIRECT"] = 1] = "REDIRECT";
+    // Suspend device (make it inactive) [2] 
+    DeviceActionCode[DeviceActionCode["SUSPEND"] = 2] = "SUSPEND";
+    // Throttle traffic from/to the device [3] 
+    DeviceActionCode[DeviceActionCode["THROTTLE"] = 3] = "THROTTLE";
+    // Block specific external IP [4] 
+    DeviceActionCode[DeviceActionCode["BLOCK_IP"] = 4] = "BLOCK_IP";
+})(DeviceActionCode || (exports.DeviceActionCode = DeviceActionCode = {}));
+// Return list of DeviceActionCode values and their display names
+function GetDeviceActionCodes() {
+    let result = new Map();
+    result.set(DeviceActionCode.UNDEFINED, 'Undefined');
+    result.set(DeviceActionCode.REDIRECT, 'Redirect');
+    result.set(DeviceActionCode.SUSPEND, 'Suspend');
+    result.set(DeviceActionCode.THROTTLE, 'Throttle');
+    result.set(DeviceActionCode.BLOCK_IP, 'Block Ip');
+    return result;
+}

package/dist/cjs/lib/enums/DeviceCreationCode.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceCreationCode = void 0;
+exports.GetDeviceCreationCodes = GetDeviceCreationCodes;
+// Device creation policy code
+var DeviceCreationCode;
+(function (DeviceCreationCode) {
+    // Undefined [0] 
+    DeviceCreationCode[DeviceCreationCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Do not create device [1] 
+    DeviceCreationCode[DeviceCreationCode["NONE"] = 1] = "NONE";
+    // Create Device based on static IP [2] 
+    DeviceCreationCode[DeviceCreationCode["IP"] = 2] = "IP";
+    // Create Device based on Subscriber Id - IMSI [3] 
+    DeviceCreationCode[DeviceCreationCode["SID"] = 3] = "SID";
+    // Create Device based on Equipment Id - IMEI [4] 
+    DeviceCreationCode[DeviceCreationCode["EID"] = 4] = "EID";
+})(DeviceCreationCode || (exports.DeviceCreationCode = DeviceCreationCode = {}));
+// Return list of DeviceCreationCode values and their display names
+function GetDeviceCreationCodes() {
+    let result = new Map();
+    result.set(DeviceCreationCode.UNDEFINED, 'Undefined');
+    result.set(DeviceCreationCode.NONE, 'None');
+    result.set(DeviceCreationCode.IP, 'Ip');
+    result.set(DeviceCreationCode.SID, 'Sid');
+    result.set(DeviceCreationCode.EID, 'Eid');
+    return result;
+}

package/dist/cjs/lib/enums/DeviceIdentityCode.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceIdentityCode = void 0;
+exports.GetDeviceIdentityCodes = GetDeviceIdentityCodes;
+// Set the device unique identity policy
+var DeviceIdentityCode;
+(function (DeviceIdentityCode) {
+    // Undefined [0] 
+    DeviceIdentityCode[DeviceIdentityCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Device Identity is provided by the system [1] 
+    DeviceIdentityCode[DeviceIdentityCode["AUTO"] = 1] = "AUTO";
+    // Device Identity is based on static IP: ip@stream_id [2] 
+    DeviceIdentityCode[DeviceIdentityCode["IP"] = 2] = "IP";
+    // Device Identity is based on Subscriber Id: imsi@stream_id [3] 
+    DeviceIdentityCode[DeviceIdentityCode["IMSI"] = 3] = "IMSI";
+    // Device Identity is based on SIM ICCID: iccid@stream_id [4] 
+    DeviceIdentityCode[DeviceIdentityCode["ICCID"] = 4] = "ICCID";
+    // Device Identity is based on MSISDN: msisdn@stream_id [5] 
+    DeviceIdentityCode[DeviceIdentityCode["MSISDN"] = 5] = "MSISDN";
+    // Device Identity is based on Equipment Id: imei@stream_id [6] 
+    DeviceIdentityCode[DeviceIdentityCode["IMEI"] = 6] = "IMEI";
+    // Device Identity is based on MAC address: mac@stream_id [7] 
+    DeviceIdentityCode[DeviceIdentityCode["MAC"] = 7] = "MAC";
+})(DeviceIdentityCode || (exports.DeviceIdentityCode = DeviceIdentityCode = {}));
+// Return list of DeviceIdentityCode values and their display names
+function GetDeviceIdentityCodes() {
+    let result = new Map();
+    result.set(DeviceIdentityCode.UNDEFINED, 'Undefined');
+    result.set(DeviceIdentityCode.AUTO, 'Auto');
+    result.set(DeviceIdentityCode.IP, 'Ip');
+    result.set(DeviceIdentityCode.IMSI, 'Imsi');
+    result.set(DeviceIdentityCode.ICCID, 'Iccid');
+    result.set(DeviceIdentityCode.MSISDN, 'Msisdn');
+    result.set(DeviceIdentityCode.IMEI, 'Imei');
+    result.set(DeviceIdentityCode.MAC, 'Mac');
+    return result;
+}

package/dist/cjs/lib/enums/DeviceStatusCode.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceStatusCode = void 0;
+exports.GetDeviceStatusCodes = GetDeviceStatusCodes;
+// Device status code
+var DeviceStatusCode;
+(function (DeviceStatusCode) {
+    // Undefined [0] 
+    DeviceStatusCode[DeviceStatusCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Device is registered and pending verification [1] 
+    DeviceStatusCode[DeviceStatusCode["PENDING"] = 1] = "PENDING";
+    // Active device in the system [2] 
+    DeviceStatusCode[DeviceStatusCode["ACTIVE"] = 2] = "ACTIVE";
+    // Inactive device [3] 
+    DeviceStatusCode[DeviceStatusCode["INACTIVE"] = 3] = "INACTIVE";
+    // Blocked device [4] 
+    DeviceStatusCode[DeviceStatusCode["BLOCKED"] = 4] = "BLOCKED";
+})(DeviceStatusCode || (exports.DeviceStatusCode = DeviceStatusCode = {}));
+// Return list of DeviceStatusCode values and their display names
+function GetDeviceStatusCodes() {
+    let result = new Map();
+    result.set(DeviceStatusCode.UNDEFINED, 'Undefined');
+    result.set(DeviceStatusCode.PENDING, 'Pending');
+    result.set(DeviceStatusCode.ACTIVE, 'Active');
+    result.set(DeviceStatusCode.INACTIVE, 'Inactive');
+    result.set(DeviceStatusCode.BLOCKED, 'Blocked');
+    return result;
+}

package/dist/cjs/lib/enums/DeviceTypeCode.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceTypeCode = void 0;
+exports.GetDeviceTypeCodes = GetDeviceTypeCodes;
+// Device type code
+var DeviceTypeCode;
+(function (DeviceTypeCode) {
+    // Undefined [0] 
+    DeviceTypeCode[DeviceTypeCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Other (Unknown Device) [1] 
+    DeviceTypeCode[DeviceTypeCode["OTHER"] = 1] = "OTHER";
+    // Industrial Controller [2] 
+    DeviceTypeCode[DeviceTypeCode["CONTROLLER"] = 2] = "CONTROLLER";
+    // General smart meter [3] 
+    DeviceTypeCode[DeviceTypeCode["METER"] = 3] = "METER";
+    // General sensor [4] 
+    DeviceTypeCode[DeviceTypeCode["SENSOR"] = 4] = "SENSOR";
+    // General camera [5] 
+    DeviceTypeCode[DeviceTypeCode["CAMERA"] = 5] = "CAMERA";
+    // Point of sale [6] 
+    DeviceTypeCode[DeviceTypeCode["POS"] = 6] = "POS";
+    // Pump [7] 
+    DeviceTypeCode[DeviceTypeCode["PUMP"] = 7] = "PUMP";
+    // EV charging station [8] 
+    DeviceTypeCode[DeviceTypeCode["CHARGING_STATION"] = 8] = "CHARGING_STATION";
+    // Smart lightning [9] 
+    DeviceTypeCode[DeviceTypeCode["LIGHTNING"] = 9] = "LIGHTNING";
+    // Temperature sensor [10] 
+    DeviceTypeCode[DeviceTypeCode["TEMPERATURE_SENSOR"] = 10] = "TEMPERATURE_SENSOR";
+    // Air Quality sensor [11] 
+    DeviceTypeCode[DeviceTypeCode["AIR_QUALITY_SENSOR"] = 11] = "AIR_QUALITY_SENSOR";
+    // Valve [12] 
+    DeviceTypeCode[DeviceTypeCode["VALVE"] = 12] = "VALVE";
+    // Gateway [13] 
+    DeviceTypeCode[DeviceTypeCode["GATEWAY"] = 13] = "GATEWAY";
+    // ATM [14] 
+    DeviceTypeCode[DeviceTypeCode["ATM"] = 14] = "ATM";
+})(DeviceTypeCode || (exports.DeviceTypeCode = DeviceTypeCode = {}));
+// Return list of DeviceTypeCode values and their display names
+function GetDeviceTypeCodes() {
+    let result = new Map();
+    result.set(DeviceTypeCode.UNDEFINED, 'Undefined');
+    result.set(DeviceTypeCode.OTHER, 'Other');
+    result.set(DeviceTypeCode.CONTROLLER, 'Controller');
+    result.set(DeviceTypeCode.METER, 'Meter');
+    result.set(DeviceTypeCode.SENSOR, 'Sensor');
+    result.set(DeviceTypeCode.CAMERA, 'Camera');
+    result.set(DeviceTypeCode.POS, 'Pos');
+    result.set(DeviceTypeCode.PUMP, 'Pump');
+    result.set(DeviceTypeCode.CHARGING_STATION, 'Charging Station');
+    result.set(DeviceTypeCode.LIGHTNING, 'Lightning');
+    result.set(DeviceTypeCode.TEMPERATURE_SENSOR, 'Temperature Sensor');
+    result.set(DeviceTypeCode.AIR_QUALITY_SENSOR, 'Air Quality Sensor');
+    result.set(DeviceTypeCode.VALVE, 'Valve');
+    result.set(DeviceTypeCode.GATEWAY, 'Gateway');
+    result.set(DeviceTypeCode.ATM, 'Atm');
+    return result;
+}

package/dist/cjs/lib/enums/DirectionContextCode.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectionContextCode = void 0;
+exports.GetDirectionContextCodes = GetDirectionContextCodes;
+// Direction context code
+var DirectionContextCode;
+(function (DirectionContextCode) {
+    // Undefined [0] 
+    DirectionContextCode[DirectionContextCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Event list context [1] 
+    DirectionContextCode[DirectionContextCode["EVENT_LIST"] = 1] = "EVENT_LIST";
+    // Device list context  [2] 
+    DirectionContextCode[DirectionContextCode["DEVICE_LIST"] = 2] = "DEVICE_LIST";
+    // Event details context [3] 
+    DirectionContextCode[DirectionContextCode["EVENT_DETAILS"] = 3] = "EVENT_DETAILS";
+    // Device details context [4] 
+    DirectionContextCode[DirectionContextCode["DEVICE_DETAILS"] = 4] = "DEVICE_DETAILS";
+})(DirectionContextCode || (exports.DirectionContextCode = DirectionContextCode = {}));
+// Return list of DirectionContextCode values and their display names
+function GetDirectionContextCodes() {
+    let result = new Map();
+    result.set(DirectionContextCode.UNDEFINED, 'Undefined');
+    result.set(DirectionContextCode.EVENT_LIST, 'Event List');
+    result.set(DirectionContextCode.DEVICE_LIST, 'Device List');
+    result.set(DirectionContextCode.EVENT_DETAILS, 'Event Details');
+    result.set(DirectionContextCode.DEVICE_DETAILS, 'Device Details');
+    return result;
+}

package/dist/cjs/lib/enums/EventCategoryCode.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventCategoryCode = void 0;
+exports.GetEventCategoryCodes = GetEventCategoryCodes;
+// Event category code
+var EventCategoryCode;
+(function (EventCategoryCode) {
+    // Undefined [0] 
+    EventCategoryCode[EventCategoryCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Cyber-Security event [1] 
+    EventCategoryCode[EventCategoryCode["SECURITY"] = 1] = "SECURITY";
+    // Operational event [2] 
+    EventCategoryCode[EventCategoryCode["OPERATIONS"] = 2] = "OPERATIONS";
+})(EventCategoryCode || (exports.EventCategoryCode = EventCategoryCode = {}));
+// Return list of EventCategoryCode values and their display names
+function GetEventCategoryCodes() {
+    let result = new Map();
+    result.set(EventCategoryCode.UNDEFINED, 'Undefined');
+    result.set(EventCategoryCode.SECURITY, 'Security');
+    result.set(EventCategoryCode.OPERATIONS, 'Operations');
+    return result;
+}

package/dist/cjs/lib/enums/EventStatusCode.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventStatusCode = void 0;
+exports.GetEventStatusCodes = GetEventStatusCodes;
+// Event workflow status code
+var EventStatusCode;
+(function (EventStatusCode) {
+    // Undefined [0] 
+    EventStatusCode[EventStatusCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // New event [1] 
+    EventStatusCode[EventStatusCode["NEW"] = 1] = "NEW";
+    // Open event, handled by the operator [2] 
+    EventStatusCode[EventStatusCode["OPEN"] = 2] = "OPEN";
+    // Closed event (tagged as True event) [3] 
+    EventStatusCode[EventStatusCode["CLOSED_TRUE"] = 3] = "CLOSED_TRUE";
+    // Closed event (tagged as False event) [4] 
+    EventStatusCode[EventStatusCode["CLOSED_FALSE"] = 4] = "CLOSED_FALSE";
+})(EventStatusCode || (exports.EventStatusCode = EventStatusCode = {}));
+// Return list of EventStatusCode values and their display names
+function GetEventStatusCodes() {
+    let result = new Map();
+    result.set(EventStatusCode.UNDEFINED, 'Undefined');
+    result.set(EventStatusCode.NEW, 'New');
+    result.set(EventStatusCode.OPEN, 'Open');
+    result.set(EventStatusCode.CLOSED_TRUE, 'Closed True');
+    result.set(EventStatusCode.CLOSED_FALSE, 'Closed False');
+    return result;
+}

package/dist/cjs/lib/enums/EventTypeCode.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventTypeCode = void 0;
+exports.GetEventTypeCodes = GetEventTypeCodes;
+// Event type code
+var EventTypeCode;
+(function (EventTypeCode) {
+    // Undefined [0] 
+    EventTypeCode[EventTypeCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Other (Unknown Event) [1] 
+    EventTypeCode[EventTypeCode["OTHER"] = 1] = "OTHER";
+    // Device Takeover [2] 
+    EventTypeCode[EventTypeCode["DEVICE_TAKEOVER"] = 2] = "DEVICE_TAKEOVER";
+    // DDoS [3] 
+    EventTypeCode[EventTypeCode["DDOS"] = 3] = "DDOS";
+    // Unknown Malware [4] 
+    EventTypeCode[EventTypeCode["UNKNOWN_MALWARE"] = 4] = "UNKNOWN_MALWARE";
+    // Man-in-the-Middle [5] 
+    EventTypeCode[EventTypeCode["MAN_IN_THE_MIDDLE"] = 5] = "MAN_IN_THE_MIDDLE";
+    // Data Theft [6] 
+    EventTypeCode[EventTypeCode["DATA_THEFT"] = 6] = "DATA_THEFT";
+    // Port Scanning [7] 
+    EventTypeCode[EventTypeCode["PORT_SCANNING"] = 7] = "PORT_SCANNING";
+    // Abnormal Download [8] 
+    EventTypeCode[EventTypeCode["ABNORMAL_DOWNLOAD"] = 8] = "ABNORMAL_DOWNLOAD";
+    // Abnormal Incoming Connection [9] 
+    EventTypeCode[EventTypeCode["ABNORMAL_INCOMING_CONNECTION"] = 9] = "ABNORMAL_INCOMING_CONNECTION";
+    // Unsuccessful Connection Attempts [10] 
+    EventTypeCode[EventTypeCode["UNSUCCESSFUL_CONNECTION_ATTEMPTS"] = 10] = "UNSUCCESSFUL_CONNECTION_ATTEMPTS";
+    // High Volume Transmit [11] 
+    EventTypeCode[EventTypeCode["HIGH_VOLUME_TRANSIT"] = 11] = "HIGH_VOLUME_TRANSIT";
+    // Device Level Attack [12] 
+    EventTypeCode[EventTypeCode["DEVICE_LEVEL_ATTACK"] = 12] = "DEVICE_LEVEL_ATTACK";
+    // Replay Attack [13] 
+    EventTypeCode[EventTypeCode["REPLAY_ATTACK"] = 13] = "REPLAY_ATTACK";
+    // Attempted Device Takeover [14] 
+    EventTypeCode[EventTypeCode["DEVICE_TAKEOVER_ATTEMPT"] = 14] = "DEVICE_TAKEOVER_ATTEMPT";
+    // Unknown Operation [15] 
+    EventTypeCode[EventTypeCode["UNKNOWN_OPERATION"] = 15] = "UNKNOWN_OPERATION";
+    // Crypto Mining [16] 
+    EventTypeCode[EventTypeCode["CRYPTO_MINING"] = 16] = "CRYPTO_MINING";
+    // Suspicious IP [17] 
+    EventTypeCode[EventTypeCode["SUSPICIOUS_IP"] = 17] = "SUSPICIOUS_IP";
+    // Abnormal number of outbound ports [18] 
+    EventTypeCode[EventTypeCode["ABNORMAL_OUTBOUND_PORTS"] = 18] = "ABNORMAL_OUTBOUND_PORTS";
+    // Abnormal number of outbound endpoints (destinations) [19] 
+    EventTypeCode[EventTypeCode["ABNORMAL_OUTBOUND_ENDPOINTS"] = 19] = "ABNORMAL_OUTBOUND_ENDPOINTS";
+})(EventTypeCode || (exports.EventTypeCode = EventTypeCode = {}));
+// Return list of EventTypeCode values and their display names
+function GetEventTypeCodes() {
+    let result = new Map();
+    result.set(EventTypeCode.UNDEFINED, 'Undefined');
+    result.set(EventTypeCode.OTHER, 'Other');
+    result.set(EventTypeCode.DEVICE_TAKEOVER, 'Device Takeover');
+    result.set(EventTypeCode.DDOS, 'Ddos');
+    result.set(EventTypeCode.UNKNOWN_MALWARE, 'Unknown Malware');
+    result.set(EventTypeCode.MAN_IN_THE_MIDDLE, 'Man In The Middle');
+    result.set(EventTypeCode.DATA_THEFT, 'Data Theft');
+    result.set(EventTypeCode.PORT_SCANNING, 'Port Scanning');
+    result.set(EventTypeCode.ABNORMAL_DOWNLOAD, 'Abnormal Download');
+    result.set(EventTypeCode.ABNORMAL_INCOMING_CONNECTION, 'Abnormal Incoming Connection');
+    result.set(EventTypeCode.UNSUCCESSFUL_CONNECTION_ATTEMPTS, 'Unsuccessful Connection Attempts');
+    result.set(EventTypeCode.HIGH_VOLUME_TRANSIT, 'High Volume Transit');
+    result.set(EventTypeCode.DEVICE_LEVEL_ATTACK, 'Device Level Attack');
+    result.set(EventTypeCode.REPLAY_ATTACK, 'Replay Attack');
+    result.set(EventTypeCode.DEVICE_TAKEOVER_ATTEMPT, 'Device Takeover Attempt');
+    result.set(EventTypeCode.UNKNOWN_OPERATION, 'Unknown Operation');
+    result.set(EventTypeCode.CRYPTO_MINING, 'Crypto Mining');
+    result.set(EventTypeCode.SUSPICIOUS_IP, 'Suspicious Ip');
+    result.set(EventTypeCode.ABNORMAL_OUTBOUND_PORTS, 'Abnormal Outbound Ports');
+    result.set(EventTypeCode.ABNORMAL_OUTBOUND_ENDPOINTS, 'Abnormal Outbound Endpoints');
+    return result;
+}

package/dist/cjs/lib/enums/FeatureCode.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureCode = void 0;
+exports.GetFeatureCodes = GetFeatureCodes;
+// Feature code
+var FeatureCode;
+(function (FeatureCode) {
+    // Undefined [0] 
+    FeatureCode[FeatureCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Export events to CSV file [1] 
+    FeatureCode[FeatureCode["EVENTS_EXPORT"] = 1] = "EVENTS_EXPORT";
+    // Download pcap files to analyze the event[2] 
+    FeatureCode[FeatureCode["EVENT_SOURCE_FILES"] = 2] = "EVENT_SOURCE_FILES";
+    // Apply preventive action on the event [3] 
+    FeatureCode[FeatureCode["EVENT_ACTION"] = 3] = "EVENT_ACTION";
+    // Export devices to CSV file [4] 
+    FeatureCode[FeatureCode["DEVICES_EXPORT"] = 4] = "DEVICES_EXPORT";
+    // Device network map [5] 
+    FeatureCode[FeatureCode["DEVICE_NETWORK_MAP"] = 5] = "DEVICE_NETWORK_MAP";
+    // Apply preventive action on the device [6] 
+    FeatureCode[FeatureCode["DEVICE_ACTIONS"] = 6] = "DEVICE_ACTIONS";
+    // Apply preventive action on the device [7] 
+    FeatureCode[FeatureCode["NETWORK_MAP"] = 7] = "NETWORK_MAP";
+    // Create and download compliance report 
+    FeatureCode[FeatureCode["COMPLIANCE_REPORTS"] = 8] = "COMPLIANCE_REPORTS";
+    // Configure user-defined rules 
+    FeatureCode[FeatureCode["CUSTOM_RULES"] = 9] = "CUSTOM_RULES";
+    // Enable push integrations 
+    FeatureCode[FeatureCode["INTEGRATIONS"] = 10] = "INTEGRATIONS";
+})(FeatureCode || (exports.FeatureCode = FeatureCode = {}));
+// Return list of FeatureCode values and their display names
+function GetFeatureCodes() {
+    let result = new Map();
+    result.set(FeatureCode.UNDEFINED, 'Undefined');
+    result.set(FeatureCode.EVENTS_EXPORT, 'Events Export');
+    result.set(FeatureCode.EVENT_SOURCE_FILES, 'Event Source Files');
+    result.set(FeatureCode.EVENT_ACTION, 'Event Action');
+    result.set(FeatureCode.DEVICES_EXPORT, 'Devices Export');
+    result.set(FeatureCode.DEVICE_NETWORK_MAP, 'Device Network Map');
+    result.set(FeatureCode.DEVICE_ACTIONS, 'Device Actions');
+    result.set(FeatureCode.NETWORK_MAP, 'Network Map');
+    result.set(FeatureCode.COMPLIANCE_REPORTS, 'Compliance Reports');
+    result.set(FeatureCode.CUSTOM_RULES, 'Custom Rules');
+    result.set(FeatureCode.INTEGRATIONS, 'Integrations');
+    return result;
+}

package/dist/cjs/lib/enums/HomePageViewCode.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HomePageViewCode = void 0;
+exports.GetHomePageViewCodes = GetHomePageViewCodes;
+// Home Page View code
+var HomePageViewCode;
+(function (HomePageViewCode) {
+    // Undefined [0] 
+    HomePageViewCode[HomePageViewCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // System view [1] 
+    HomePageViewCode[HomePageViewCode["SYSTEM"] = 1] = "SYSTEM";
+    // Devices View [2] 
+    HomePageViewCode[HomePageViewCode["DEVICES"] = 2] = "DEVICES";
+    // Malicious IP view [3] 
+    HomePageViewCode[HomePageViewCode["MALICIOUS"] = 3] = "MALICIOUS";
+})(HomePageViewCode || (exports.HomePageViewCode = HomePageViewCode = {}));
+// Return list of HomePageViewCode values and their display names
+function GetHomePageViewCodes() {
+    let result = new Map();
+    result.set(HomePageViewCode.UNDEFINED, 'Undefined');
+    result.set(HomePageViewCode.SYSTEM, 'System');
+    result.set(HomePageViewCode.DEVICES, 'Devices');
+    result.set(HomePageViewCode.MALICIOUS, 'Malicious');
+    return result;
+}

package/dist/cjs/lib/enums/HttpMethodCode.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpMethodCode = void 0;
+exports.GetHttpMethodCodes = GetHttpMethodCodes;
+// HTTP method code
+var HttpMethodCode;
+(function (HttpMethodCode) {
+    // Undefined [0] 
+    HttpMethodCode[HttpMethodCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // HTTP GET (read) [1] 
+    HttpMethodCode[HttpMethodCode["GET"] = 1] = "GET";
+    // HTTP POST (create) [2] 
+    HttpMethodCode[HttpMethodCode["POST"] = 2] = "POST";
+    // HTTP PUT (update/replace) [3] 
+    HttpMethodCode[HttpMethodCode["PUT"] = 3] = "PUT";
+    // HTTP PATCH (update/modify) [4] 
+    HttpMethodCode[HttpMethodCode["PATCH"] = 4] = "PATCH";
+    // HTTP DELETE (delete) [5] 
+    HttpMethodCode[HttpMethodCode["DELETE"] = 5] = "DELETE";
+})(HttpMethodCode || (exports.HttpMethodCode = HttpMethodCode = {}));
+// Return list of HttpMethodCode values and their display names
+function GetHttpMethodCodes() {
+    let result = new Map();
+    result.set(HttpMethodCode.UNDEFINED, 'Undefined');
+    result.set(HttpMethodCode.GET, 'Get');
+    result.set(HttpMethodCode.POST, 'Post');
+    result.set(HttpMethodCode.PUT, 'Put');
+    result.set(HttpMethodCode.PATCH, 'Patch');
+    result.set(HttpMethodCode.DELETE, 'Delete');
+    return result;
+}

package/dist/cjs/lib/enums/InsightStatusCode.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsightStatusCode = void 0;
+exports.GetInsightStatusCodes = GetInsightStatusCodes;
+// Insight status code
+var InsightStatusCode;
+(function (InsightStatusCode) {
+    // Undefined [0] 
+    InsightStatusCode[InsightStatusCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Inactive (muted) insight [1] 
+    InsightStatusCode[InsightStatusCode["INACTIVE"] = 1] = "INACTIVE";
+    // Pending insight (not visible yet - for testing only) [2] 
+    InsightStatusCode[InsightStatusCode["PENDING"] = 2] = "PENDING";
+    // Active insight [3] 
+    InsightStatusCode[InsightStatusCode["ACTIVE"] = 3] = "ACTIVE";
+})(InsightStatusCode || (exports.InsightStatusCode = InsightStatusCode = {}));
+// Return list of InsightStatusCode values and their display names
+function GetInsightStatusCodes() {
+    let result = new Map();
+    result.set(InsightStatusCode.UNDEFINED, 'Undefined');
+    result.set(InsightStatusCode.INACTIVE, 'Inactive');
+    result.set(InsightStatusCode.PENDING, 'Pending');
+    result.set(InsightStatusCode.ACTIVE, 'Active');
+    return result;
+}

package/dist/cjs/lib/enums/InsightTypeCode.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsightTypeCode = void 0;
+exports.GetInsightTypeCodes = GetInsightTypeCodes;
+// Insight type code
+var InsightTypeCode;
+(function (InsightTypeCode) {
+    // Undefined [0] 
+    InsightTypeCode[InsightTypeCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Event Group insight [1] 
+    InsightTypeCode[InsightTypeCode["EVENTS"] = 1] = "EVENTS";
+    // Statistical insight [2] 
+    InsightTypeCode[InsightTypeCode["STATISTICS"] = 2] = "STATISTICS";
+})(InsightTypeCode || (exports.InsightTypeCode = InsightTypeCode = {}));
+// Return list of InsightTypeCode values and their display names
+function GetInsightTypeCodes() {
+    let result = new Map();
+    result.set(InsightTypeCode.UNDEFINED, 'Undefined');
+    result.set(InsightTypeCode.EVENTS, 'Events');
+    result.set(InsightTypeCode.STATISTICS, 'Statistics');
+    return result;
+}

package/dist/cjs/lib/enums/IntegrationTriggerCode.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationTriggerCode = void 0;
+exports.GetIntegrationTriggerCodes = GetIntegrationTriggerCodes;
+// Integration trigger code
+var IntegrationTriggerCode;
+(function (IntegrationTriggerCode) {
+    // Undefined [0] 
+    IntegrationTriggerCode[IntegrationTriggerCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // EVENT based integration [1] 
+    IntegrationTriggerCode[IntegrationTriggerCode["EVENT"] = 1] = "EVENT";
+    // ACTION based integration [2] 
+    IntegrationTriggerCode[IntegrationTriggerCode["ACTION"] = 2] = "ACTION";
+})(IntegrationTriggerCode || (exports.IntegrationTriggerCode = IntegrationTriggerCode = {}));
+// Return list of IntegrationTriggerCode values and their display names
+function GetIntegrationTriggerCodes() {
+    let result = new Map();
+    result.set(IntegrationTriggerCode.UNDEFINED, 'Undefined');
+    result.set(IntegrationTriggerCode.EVENT, 'Event');
+    result.set(IntegrationTriggerCode.ACTION, 'Action');
+    return result;
+}

package/dist/cjs/lib/enums/IntegrationTypeCode.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationTypeCode = void 0;
+exports.GetIntegrationTypeCodes = GetIntegrationTypeCodes;
+// Integration type code
+var IntegrationTypeCode;
+(function (IntegrationTypeCode) {
+    // Undefined [0] 
+    IntegrationTypeCode[IntegrationTypeCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // General HTTP(S) based integration [1] 
+    IntegrationTypeCode[IntegrationTypeCode["HTTP"] = 1] = "HTTP";
+    // General SMTP based integration [2] 
+    IntegrationTypeCode[IntegrationTypeCode["SMTP"] = 2] = "SMTP";
+    // Internal email service integration [3] 
+    IntegrationTypeCode[IntegrationTypeCode["EMAIL"] = 3] = "EMAIL";
+    // Internal SMS service integration  [4] 
+    IntegrationTypeCode[IntegrationTypeCode["SMS"] = 4] = "SMS";
+})(IntegrationTypeCode || (exports.IntegrationTypeCode = IntegrationTypeCode = {}));
+// Return list of IntegrationTypeCode values and their display names
+function GetIntegrationTypeCodes() {
+    let result = new Map();
+    result.set(IntegrationTypeCode.UNDEFINED, 'Undefined');
+    result.set(IntegrationTypeCode.HTTP, 'Http');
+    result.set(IntegrationTypeCode.SMTP, 'Smtp');
+    result.set(IntegrationTypeCode.EMAIL, 'Email');
+    result.set(IntegrationTypeCode.SMS, 'Sms');
+    return result;
+}

package/dist/cjs/lib/enums/MemberRoleCode.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberRoleCode = void 0;
+exports.GetMemberRoleCodes = GetMemberRoleCodes;
+// Member role code (represent role of user in the account)
+var MemberRoleCode;
+(function (MemberRoleCode) {
+    // Undefined [0] 
+    MemberRoleCode[MemberRoleCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Account administrator can perform all operations [1] 
+    MemberRoleCode[MemberRoleCode["ADMIN"] = 1] = "ADMIN";
+    // Supervisor can perform operations on events and generate reports [2] 
+    MemberRoleCode[MemberRoleCode["SUPERVISOR"] = 2] = "SUPERVISOR";
+    // Account operator can perform operations on events only [3] 
+    MemberRoleCode[MemberRoleCode["OPERATOR"] = 3] = "OPERATOR";
+    // Viewer has read-only permissions [4] 
+    MemberRoleCode[MemberRoleCode["VIEWER"] = 4] = "VIEWER";
+})(MemberRoleCode || (exports.MemberRoleCode = MemberRoleCode = {}));
+// Return list of MemberRoleCode values and their display names
+function GetMemberRoleCodes() {
+    let result = new Map();
+    result.set(MemberRoleCode.UNDEFINED, 'Undefined');
+    result.set(MemberRoleCode.ADMIN, 'Admin');
+    result.set(MemberRoleCode.SUPERVISOR, 'Supervisor');
+    result.set(MemberRoleCode.OPERATOR, 'Operator');
+    result.set(MemberRoleCode.VIEWER, 'Viewer');
+    return result;
+}

package/dist/cjs/lib/enums/NetworkMapTypeCode.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkMapTypeCode = void 0;
+exports.GetNetworkMapTypeCodes = GetNetworkMapTypeCodes;
+// NetworkMapTypeCode represents the type of network maps
+var NetworkMapTypeCode;
+(function (NetworkMapTypeCode) {
+    // Undefined [0] 
+    NetworkMapTypeCode[NetworkMapTypeCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Top devices network map [1] 
+    NetworkMapTypeCode[NetworkMapTypeCode["TOP_DEVICES"] = 1] = "TOP_DEVICES";
+    // Top malicious IP network map [2] 
+    NetworkMapTypeCode[NetworkMapTypeCode["TOP_MALICIOUS_IPS"] = 2] = "TOP_MALICIOUS_IPS";
+    // Network devices network map [3] 
+    NetworkMapTypeCode[NetworkMapTypeCode["NETWORK"] = 3] = "NETWORK";
+})(NetworkMapTypeCode || (exports.NetworkMapTypeCode = NetworkMapTypeCode = {}));
+// Return list of NetworkMapTypeCode values and their display names
+function GetNetworkMapTypeCodes() {
+    let result = new Map();
+    result.set(NetworkMapTypeCode.UNDEFINED, 'Undefined');
+    result.set(NetworkMapTypeCode.TOP_DEVICES, 'Top Devices');
+    result.set(NetworkMapTypeCode.TOP_MALICIOUS_IPS, 'Top Malicious Ips');
+    result.set(NetworkMapTypeCode.NETWORK, 'Network');
+    return result;
+}