@shieldiot/pulse-lib 1.0.10 → 1.0.12

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

@@ -0,0 +1,42 @@
+// Feature code
+export 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 || (FeatureCode = {}));
+// Return list of FeatureCode values and their display names
+export 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/esm/lib/enums/HomePageViewCode.js

@@ -0,0 +1,21 @@
+// Home Page View code
+export 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 || (HomePageViewCode = {}));
+// Return list of HomePageViewCode values and their display names
+export 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/esm/lib/enums/HttpMethodCode.js

@@ -0,0 +1,27 @@
+// HTTP method code
+export 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 || (HttpMethodCode = {}));
+// Return list of HttpMethodCode values and their display names
+export 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/esm/lib/enums/InsightStatusCode.js

@@ -0,0 +1,21 @@
+// Insight status code
+export 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 || (InsightStatusCode = {}));
+// Return list of InsightStatusCode values and their display names
+export 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/esm/lib/enums/InsightTypeCode.js

@@ -0,0 +1,18 @@
+// Insight type code
+export 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 || (InsightTypeCode = {}));
+// Return list of InsightTypeCode values and their display names
+export 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/esm/lib/enums/IntegrationTriggerCode.js

@@ -0,0 +1,18 @@
+// Integration trigger code
+export 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 || (IntegrationTriggerCode = {}));
+// Return list of IntegrationTriggerCode values and their display names
+export 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/esm/lib/enums/IntegrationTypeCode.js

@@ -0,0 +1,24 @@
+// Integration type code
+export 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 || (IntegrationTypeCode = {}));
+// Return list of IntegrationTypeCode values and their display names
+export 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/esm/lib/enums/MemberRoleCode.js

@@ -0,0 +1,24 @@
+// Member role code (represent role of user in the account)
+export 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 || (MemberRoleCode = {}));
+// Return list of MemberRoleCode values and their display names
+export 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/esm/lib/enums/NetworkMapTypeCode.js

@@ -0,0 +1,21 @@
+// NetworkMapTypeCode represents the type of network maps
+export 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 || (NetworkMapTypeCode = {}));
+// Return list of NetworkMapTypeCode values and their display names
+export 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;
+}

package/dist/esm/lib/enums/OperatorCode.js

@@ -0,0 +1,45 @@
+// OperatorCode represents the rule condition operator such as equal, not equal, less than ...
+export var OperatorCode;
+(function (OperatorCode) {
+    // Undefined [0] 
+    OperatorCode[OperatorCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Equal (=) [1] 
+    OperatorCode[OperatorCode["EQ"] = 1] = "EQ";
+    // Not Equal (!=) [2] 
+    OperatorCode[OperatorCode["NEQ"] = 2] = "NEQ";
+    // Greater than (>) [3] 
+    OperatorCode[OperatorCode["GT"] = 3] = "GT";
+    // Greater than or equal (>=) [4] 
+    OperatorCode[OperatorCode["GTE"] = 4] = "GTE";
+    // Less than (<) [5] 
+    OperatorCode[OperatorCode["LT"] = 5] = "LT";
+    // Less than or equal (<=) 
+    OperatorCode[OperatorCode["LTE"] = 6] = "LTE";
+    // Value included in the list (*) [7] 
+    OperatorCode[OperatorCode["IN"] = 7] = "IN";
+    // Value not included in the list (-) [8] 
+    OperatorCode[OperatorCode["NOTIN"] = 8] = "NOTIN";
+    // Value is in the range of 2 elements [9] 
+    OperatorCode[OperatorCode["RANGE"] = 9] = "RANGE";
+    // Partial similarity with wildcards (~) [10] 
+    OperatorCode[OperatorCode["LIKE"] = 10] = "LIKE";
+    // Array field contains one of the values (@) [11] 
+    OperatorCode[OperatorCode["CONTAINS"] = 11] = "CONTAINS";
+})(OperatorCode || (OperatorCode = {}));
+// Return list of OperatorCode values and their display names
+export function GetOperatorCodes() {
+    let result = new Map();
+    result.set(OperatorCode.UNDEFINED, 'Undefined');
+    result.set(OperatorCode.EQ, 'Eq');
+    result.set(OperatorCode.NEQ, 'Neq');
+    result.set(OperatorCode.GT, 'Gt');
+    result.set(OperatorCode.GTE, 'Gte');
+    result.set(OperatorCode.LT, 'Lt');
+    result.set(OperatorCode.LTE, 'Lte');
+    result.set(OperatorCode.IN, 'In');
+    result.set(OperatorCode.NOTIN, 'Notin');
+    result.set(OperatorCode.RANGE, 'Range');
+    result.set(OperatorCode.LIKE, 'Like');
+    result.set(OperatorCode.CONTAINS, 'Contains');
+    return result;
+}

package/dist/esm/lib/enums/PermissionCode.js

@@ -0,0 +1,27 @@
+// Permission flag (it can combine several values)
+export var PermissionCode;
+(function (PermissionCode) {
+    // Undefined [0] 
+    PermissionCode[PermissionCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Read permission [1] 
+    PermissionCode[PermissionCode["READ"] = 1] = "READ";
+    // Create permission [2] 
+    PermissionCode[PermissionCode["CREATE"] = 2] = "CREATE";
+    // Update permission [4] 
+    PermissionCode[PermissionCode["UPDATE"] = 4] = "UPDATE";
+    // Delete permission [8] 
+    PermissionCode[PermissionCode["DELETE"] = 8] = "DELETE";
+    // Action permission [16] 
+    PermissionCode[PermissionCode["ACTION"] = 16] = "ACTION";
+})(PermissionCode || (PermissionCode = {}));
+// Return list of PermissionCode values and their display names
+export function GetPermissionCodes() {
+    let result = new Map();
+    result.set(PermissionCode.UNDEFINED, 'Undefined');
+    result.set(PermissionCode.READ, 'Read');
+    result.set(PermissionCode.CREATE, 'Create');
+    result.set(PermissionCode.UPDATE, 'Update');
+    result.set(PermissionCode.DELETE, 'Delete');
+    result.set(PermissionCode.ACTION, 'Action');
+    return result;
+}

package/dist/esm/lib/enums/ReportTypeCode.js

@@ -0,0 +1,21 @@
+// Report type code
+export var ReportTypeCode;
+(function (ReportTypeCode) {
+    // Undefined [0] 
+    ReportTypeCode[ReportTypeCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Compliance report [1] 
+    ReportTypeCode[ReportTypeCode["COMPLIANCE"] = 1] = "COMPLIANCE";
+    // Devices report [2] 
+    ReportTypeCode[ReportTypeCode["DEVICES"] = 2] = "DEVICES";
+    // Events report [3] 
+    ReportTypeCode[ReportTypeCode["EVENTS"] = 3] = "EVENTS";
+})(ReportTypeCode || (ReportTypeCode = {}));
+// Return list of ReportTypeCode values and their display names
+export function GetReportTypeCodes() {
+    let result = new Map();
+    result.set(ReportTypeCode.UNDEFINED, 'Undefined');
+    result.set(ReportTypeCode.COMPLIANCE, 'Compliance');
+    result.set(ReportTypeCode.DEVICES, 'Devices');
+    result.set(ReportTypeCode.EVENTS, 'Events');
+    return result;
+}

package/dist/esm/lib/enums/RuleActivityStatusCode.js

@@ -0,0 +1,15 @@
+// Rule activity status code
+export var RuleActivityStatusCode;
+(function (RuleActivityStatusCode) {
+    // Active [0] 
+    RuleActivityStatusCode[RuleActivityStatusCode["ACTIVE"] = 0] = "ACTIVE";
+    // Inactive [1] 
+    RuleActivityStatusCode[RuleActivityStatusCode["INACTIVE"] = 1] = "INACTIVE";
+})(RuleActivityStatusCode || (RuleActivityStatusCode = {}));
+// Return list of RuleActivityStatusCode values and their display names
+export function GetRuleActivityStatusCodes() {
+    let result = new Map();
+    result.set(RuleActivityStatusCode.ACTIVE, 'Active');
+    result.set(RuleActivityStatusCode.INACTIVE, 'Inactive');
+    return result;
+}

package/dist/esm/lib/enums/RuleTypeCode.js

@@ -0,0 +1,21 @@
+// RuleTypeCode represents the sources (engines) of rules
+export var RuleTypeCode;
+(function (RuleTypeCode) {
+    // Undefined [0] 
+    RuleTypeCode[RuleTypeCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Suspicious IP based on IP reputation engine [1] 
+    RuleTypeCode[RuleTypeCode["SUSPICIOUS_IP"] = 1] = "SUSPICIOUS_IP";
+    // Static rule based on deterministic rule engine [2] 
+    RuleTypeCode[RuleTypeCode["STATIC"] = 2] = "STATIC";
+    // Rule based on anomaly detection and classification [3] 
+    RuleTypeCode[RuleTypeCode["ANOMALY"] = 3] = "ANOMALY";
+})(RuleTypeCode || (RuleTypeCode = {}));
+// Return list of RuleTypeCode values and their display names
+export function GetRuleTypeCodes() {
+    let result = new Map();
+    result.set(RuleTypeCode.UNDEFINED, 'Undefined');
+    result.set(RuleTypeCode.SUSPICIOUS_IP, 'Suspicious Ip');
+    result.set(RuleTypeCode.STATIC, 'Static');
+    result.set(RuleTypeCode.ANOMALY, 'Anomaly');
+    return result;
+}

package/dist/esm/lib/enums/SeverityTypeCode.js

@@ -0,0 +1,24 @@
+// Severity type (level) code
+export var SeverityTypeCode;
+(function (SeverityTypeCode) {
+    // Undefined [0] 
+    SeverityTypeCode[SeverityTypeCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Low severity [1] 
+    SeverityTypeCode[SeverityTypeCode["LOW"] = 1] = "LOW";
+    // Medium severity [2] 
+    SeverityTypeCode[SeverityTypeCode["MEDIUM"] = 2] = "MEDIUM";
+    // High severity [3] 
+    SeverityTypeCode[SeverityTypeCode["HIGH"] = 3] = "HIGH";
+    // Critical severity [4] 
+    SeverityTypeCode[SeverityTypeCode["CRITICAL"] = 4] = "CRITICAL";
+})(SeverityTypeCode || (SeverityTypeCode = {}));
+// Return list of SeverityTypeCode values and their display names
+export function GetSeverityTypeCodes() {
+    let result = new Map();
+    result.set(SeverityTypeCode.UNDEFINED, 'Undefined');
+    result.set(SeverityTypeCode.LOW, 'Low');
+    result.set(SeverityTypeCode.MEDIUM, 'Medium');
+    result.set(SeverityTypeCode.HIGH, 'High');
+    result.set(SeverityTypeCode.CRITICAL, 'Critical');
+    return result;
+}

package/dist/esm/lib/enums/TrafficDirectionCode.js

@@ -0,0 +1,21 @@
+// Account type code
+export var TrafficDirectionCode;
+(function (TrafficDirectionCode) {
+    // Undefined [0] 
+    TrafficDirectionCode[TrafficDirectionCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // Denotes inbound network traffic  [1] 
+    TrafficDirectionCode[TrafficDirectionCode["INBOUND"] = 1] = "INBOUND";
+    // Denotes outbound network traffic [2] 
+    TrafficDirectionCode[TrafficDirectionCode["OUTBOUND"] = 2] = "OUTBOUND";
+    // Denotes bidirectional network traffic [3] 
+    TrafficDirectionCode[TrafficDirectionCode["INOUT"] = 3] = "INOUT";
+})(TrafficDirectionCode || (TrafficDirectionCode = {}));
+// Return list of TrafficDirectionCode values and their display names
+export function GetTrafficDirectionCodes() {
+    let result = new Map();
+    result.set(TrafficDirectionCode.UNDEFINED, 'Undefined');
+    result.set(TrafficDirectionCode.INBOUND, 'Inbound');
+    result.set(TrafficDirectionCode.OUTBOUND, 'Outbound');
+    result.set(TrafficDirectionCode.INOUT, 'Inout');
+    return result;
+}

package/dist/esm/lib/enums/UserStatusCode.js

@@ -0,0 +1,24 @@
+// User status code
+export var UserStatusCode;
+(function (UserStatusCode) {
+    // Undefined [0] 
+    UserStatusCode[UserStatusCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // User is registered and pending verification [1] 
+    UserStatusCode[UserStatusCode["PENDING"] = 1] = "PENDING";
+    // Active user in the system [2] 
+    UserStatusCode[UserStatusCode["ACTIVE"] = 2] = "ACTIVE";
+    // Blocked user (only account system can unblock the user) [4] 
+    UserStatusCode[UserStatusCode["BLOCKED"] = 3] = "BLOCKED";
+    // Suspended user (about to be deleted) [8] 
+    UserStatusCode[UserStatusCode["SUSPENDED"] = 4] = "SUSPENDED";
+})(UserStatusCode || (UserStatusCode = {}));
+// Return list of UserStatusCode values and their display names
+export function GetUserStatusCodes() {
+    let result = new Map();
+    result.set(UserStatusCode.UNDEFINED, 'Undefined');
+    result.set(UserStatusCode.PENDING, 'Pending');
+    result.set(UserStatusCode.ACTIVE, 'Active');
+    result.set(UserStatusCode.BLOCKED, 'Blocked');
+    result.set(UserStatusCode.SUSPENDED, 'Suspended');
+    return result;
+}

package/dist/esm/lib/enums/UserTypeCode.js

@@ -0,0 +1,24 @@
+// User type code
+export var UserTypeCode;
+(function (UserTypeCode) {
+    // Undefined [0] 
+    UserTypeCode[UserTypeCode["UNDEFINED"] = 0] = "UNDEFINED";
+    // System administrator has access to all accounts and permissions to perform all actions [1] 
+    UserTypeCode[UserTypeCode["SYSADMIN"] = 1] = "SYSADMIN";
+    // Support user has view permissions only for all accounts that enabled option Enable Support [2] 
+    UserTypeCode[UserTypeCode["SUPPORT"] = 2] = "SUPPORT";
+    // Account user - has access to specific accounts with role based access control [3] 
+    UserTypeCode[UserTypeCode["USER"] = 3] = "USER";
+    // Account service - to be used by other systems to perform actions using the API (can't login as a user to the portal)' [4]` 
+    UserTypeCode[UserTypeCode["SERVICE"] = 4] = "SERVICE";
+})(UserTypeCode || (UserTypeCode = {}));
+// Return list of UserTypeCode values and their display names
+export function GetUserTypeCodes() {
+    let result = new Map();
+    result.set(UserTypeCode.UNDEFINED, 'Undefined');
+    result.set(UserTypeCode.SYSADMIN, 'Sysadmin');
+    result.set(UserTypeCode.SUPPORT, 'Support');
+    result.set(UserTypeCode.USER, 'User');
+    result.set(UserTypeCode.SERVICE, 'Service');
+    return result;
+}

package/dist/esm/lib/enums/index.js

@@ -0,0 +1,30 @@
+export * from './AccountStatusCode';
+export * from './AccountTypeCode';
+export * from './DataSourceCode';
+export * from './DeviceActionCode';
+export * from './DeviceCreationCode';
+export * from './DeviceIdentityCode';
+export * from './DeviceStatusCode';
+export * from './DeviceTypeCode';
+export * from './DirectionContextCode';
+export * from './EventCategoryCode';
+export * from './EventStatusCode';
+export * from './EventTypeCode';
+export * from './FeatureCode';
+export * from './HomePageViewCode';
+export * from './HttpMethodCode';
+export * from './InsightStatusCode';
+export * from './InsightTypeCode';
+export * from './IntegrationTriggerCode';
+export * from './IntegrationTypeCode';
+export * from './MemberRoleCode';
+export * from './NetworkMapTypeCode';
+export * from './OperatorCode';
+export * from './PermissionCode';
+export * from './ReportTypeCode';
+export * from './RuleActivityStatusCode';
+export * from './RuleTypeCode';
+export * from './SeverityTypeCode';
+export * from './TrafficDirectionCode';
+export * from './UserStatusCode';
+export * from './UserTypeCode';

package/dist/esm/lib/index.js

@@ -0,0 +1,5 @@
+export * from './base';
+export * from './common';
+export * from './entities';
+export * from './enums';
+export * from './services';

package/dist/esm/lib/pulse-client.js

@@ -0,0 +1,74 @@
+import axios from 'axios';
+import { RestUtil } from "../utils";
+import { UsrAlertsService } from "./services";
+import { UsrDevicesService } from "./services";
+import { UsrEventsService } from "./services";
+import { UsrNetworkService } from "./services";
+import { UsrReportsService } from "./services";
+import { UsrRulesService } from "./services";
+import { SupportStreamAnalyticsConfig } from "./services";
+import { SysAccountsService } from "./services";
+import { SysAuditLogService } from "./services";
+import { SysCheckpointsService } from "./services";
+import { SysConfigService } from "./services";
+import { SysFeaturesService } from "./services";
+import { SysGroupsService } from "./services";
+import { SysInsightsService } from "./services";
+import { SysKeysService } from "./services";
+import { SysMembersService } from "./services";
+import { SysRuleTemplatesService } from "./services";
+import { SysRulesService } from "./services";
+import { SysStatisticsService } from "./services";
+import { SysStreamsService } from "./services";
+import { SysUsersService } from "./services";
+import { UsrInsightsService } from "./services";
+import { UsrIntegrationsService } from "./services";
+import { UsrMembersService } from "./services";
+import { UsrUserService } from "./services";
+// PulseClient is the main entry point of the client library.
+// Create a single global instance of PulseClient in your application and use
+// Factory methods to get service endpoints
+export class PulseClient {
+    // Constructor
+    constructor(apiUrl, apiKey, accessToken) {
+        // Set axios config
+        let axiosRequestConfiguration = {
+            baseURL: apiUrl,
+            responseType: 'json',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-KEY': apiKey,
+                'X-ACCESS-TOKEN': accessToken,
+            },
+        };
+        // Set axios instance
+        this.axiosInst = axios.create(axiosRequestConfiguration);
+        this.restSvc = new RestUtil(this.axiosInst);
+        // initialize services
+        this.UsrAlertsService = new UsrAlertsService(apiUrl, this.restSvc);
+        this.UsrDevicesService = new UsrDevicesService(apiUrl, this.restSvc);
+        this.UsrEventsService = new UsrEventsService(apiUrl, this.restSvc);
+        this.UsrNetworkService = new UsrNetworkService(apiUrl, this.restSvc);
+        this.UsrReportsService = new UsrReportsService(apiUrl, this.restSvc);
+        this.UsrRulesService = new UsrRulesService(apiUrl, this.restSvc);
+        this.SupportStreamAnalyticsConfig = new SupportStreamAnalyticsConfig(apiUrl, this.restSvc);
+        this.SysAccountsService = new SysAccountsService(apiUrl, this.restSvc);
+        this.SysAuditLogService = new SysAuditLogService(apiUrl, this.restSvc);
+        this.SysCheckpointsService = new SysCheckpointsService(apiUrl, this.restSvc);
+        this.SysConfigService = new SysConfigService(apiUrl, this.restSvc);
+        this.SysFeaturesService = new SysFeaturesService(apiUrl, this.restSvc);
+        this.SysGroupsService = new SysGroupsService(apiUrl, this.restSvc);
+        this.SysInsightsService = new SysInsightsService(apiUrl, this.restSvc);
+        this.SysKeysService = new SysKeysService(apiUrl, this.restSvc);
+        this.SysMembersService = new SysMembersService(apiUrl, this.restSvc);
+        this.SysRuleTemplatesService = new SysRuleTemplatesService(apiUrl, this.restSvc);
+        this.SysRulesService = new SysRulesService(apiUrl, this.restSvc);
+        this.SysStatisticsService = new SysStatisticsService(apiUrl, this.restSvc);
+        this.SysStreamsService = new SysStreamsService(apiUrl, this.restSvc);
+        this.SysUsersService = new SysUsersService(apiUrl, this.restSvc);
+        this.UsrInsightsService = new UsrInsightsService(apiUrl, this.restSvc);
+        this.UsrIntegrationsService = new UsrIntegrationsService(apiUrl, this.restSvc);
+        this.UsrMembersService = new UsrMembersService(apiUrl, this.restSvc);
+        this.UsrUserService = new UsrUserService(apiUrl, this.restSvc);
+    }
+}

package/dist/esm/lib/services/index.js

@@ -0,0 +1,26 @@
+export * from './services.export';
+export * from './supportStreamAnalyticsConfig';
+export * from './sysAccountsService';
+export * from './sysAuditLogService';
+export * from './sysCheckpointsService';
+export * from './sysConfigService';
+export * from './sysFeaturesService';
+export * from './sysGroupsService';
+export * from './sysInsightsService';
+export * from './sysKeysService';
+export * from './sysMembersService';
+export * from './sysRuleTemplatesService';
+export * from './sysRulesService';
+export * from './sysStatisticsService';
+export * from './sysStreamsService';
+export * from './sysUsersService';
+export * from './usrAlertsService';
+export * from './usrDevicesService';
+export * from './usrEventsService';
+export * from './usrInsightsService';
+export * from './usrIntegrationsService';
+export * from './usrMembersService';
+export * from './usrNetworkService';
+export * from './usrReportsService';
+export * from './usrRulesService';
+export * from './usrUserService';