@shieldiot/ngx-pulseiot-lib 1.0.0

package/lib/services/UsrDevicesService.d.ts

@@ -0,0 +1,124 @@
+import { RestUtils } from '../../rest-utils';
+import { AppConfig } from '../../config';
+import { DevicesMap } from '../model';
+import { DeviceWithEvents } from '../model';
+import { NetworkMapTypeCode } from '../model';
+import { TimeSeriesConsumption } from '../model';
+import { Device } from '../model';
+import { EntityResponse } from '../model';
+import { ActionResponse } from '../model';
+import { DeviceStatusCode } from '../model';
+import { DeviceReport } from '../model';
+import { TimeSeries } from '../model';
+import { Distribution } from '../model';
+import { NetworkMap } from '../model';
+import { Entities } from '../model';
+import { EntitiesResponse } from '../model';
+import { DeviceTypeCode } from '../model';
+import { DeviceActionCode } from '../model';
+import { MapBounds } from '../model';
+import * as i0 from "@angular/core";
+export declare class UsrDevicesService {
+    private config;
+    private rest;
+    private baseUrl;
+    constructor(config: AppConfig, rest: RestUtils);
+    /**
+     * Create new device
+     */
+    create(body?: Device): import("rxjs").Observable<EntityResponse<Device>>;
+    /**
+     * Create bulk of new devices
+     */
+    bulkCreate(body?: Entities<Device>): import("rxjs").Observable<EntitiesResponse<Device>>;
+    /**
+     * Update existing device
+     */
+    update(body?: Device): import("rxjs").Observable<EntityResponse<Device>>;
+    /**
+     * Create bulk of new devices
+     */
+    bulkUpdate(body?: Entities<Device>): import("rxjs").Observable<EntitiesResponse<Device>>;
+    /**
+     * Delete device
+     */
+    delete(id?: string): import("rxjs").Observable<ActionResponse>;
+    /**
+     * Get a single device by id
+     */
+    get(id?: string): import("rxjs").Observable<EntityResponse<Device>>;
+    /**
+     * Find devices by query
+     */
+    find(streamId?: string, search?: string, from?: number, to?: number, type?: DeviceTypeCode[], status?: DeviceStatusCode[], risk?: number, sort?: string, page?: number, size?: number, ids?: string[]): import("rxjs").Observable<EntitiesResponse<Device>>;
+    /**
+     * Export devices by query to a file as a stream of CSV | JSON | XML | XLSX
+     */
+    export(format?: string, streamId?: string, search?: string, from?: number, to?: number, type?: DeviceTypeCode[], status?: DeviceStatusCode[], risk?: number, sort?: string, page?: number, size?: number): import("rxjs").Observable<import("@angular/common/http").HttpEvent<Blob>>;
+    /**
+     * Upload device list from csv file
+     */
+    upload(streamId?: string, ip?: string[], iccid?: string[], imsi?: string[], msisdn?: string[], imei?: string, name?: string, operator?: string, label?: string[], tag?: string[], country?: string, city?: string, street?: string, postal?: string, lon?: string, lat?: string): import("rxjs").Observable<ActionResponse>;
+    /**
+     * Add tag to a device
+     */
+    addTag(id?: string, tag?: string): import("rxjs").Observable<EntityResponse<Device>>;
+    /**
+     * Delete tag from a device
+     */
+    deleteTag(id?: string, tag?: string): import("rxjs").Observable<EntityResponse<Device>>;
+    /**
+     * Apply action on a device
+     */
+    applyAction(id?: string, action?: DeviceActionCode): import("rxjs").Observable<ActionResponse>;
+    /**
+     * Find top 10 devices by their score and filter criteria
+     */
+    findTop(streamId?: string, search?: string, type?: DeviceTypeCode[], status?: DeviceStatusCode[], risk?: number, sort?: string, page?: number, size?: number): import("rxjs").Observable<EntityResponse<DeviceWithEvents>>;
+    /**
+     * Get device distribution by type filtered by query
+     */
+    countByType(streamId?: string, search?: string, from?: number, to?: number, type?: DeviceTypeCode[], status?: DeviceStatusCode[], risk?: number): import("rxjs").Observable<EntityResponse<Distribution<number>>>;
+    /**
+     * Get device distribution by status filtered by query
+     */
+    countByStatus(streamId?: string, search?: string, from?: number, to?: number, type?: DeviceTypeCode[], status?: DeviceStatusCode[], risk?: number): import("rxjs").Observable<EntityResponse<Distribution<number>>>;
+    /**
+     * Get device distribution by action filtered by query
+     */
+    countByAction(streamId?: string, search?: string, from?: number, to?: number, type?: DeviceTypeCode[], status?: DeviceStatusCode[], risk?: number): import("rxjs").Observable<EntityResponse<Distribution<number>>>;
+    /**
+     * Get network map of devices
+     */
+    getNetworkMap(streamId?: string, from?: number, to?: number, type?: DeviceTypeCode[], tag?: string[], id?: string[], mapType?: NetworkMapTypeCode, ips?: string[], limit?: number): import("rxjs").Observable<EntityResponse<NetworkMap>>;
+    /**
+     * Get latest device report, the Key contains latest devices at risk number (works in account level)
+     */
+    getLatestDeviceReport(): import("rxjs").Observable<EntityResponse<DeviceReport>>;
+    /**
+     * Get devicesAtRisk histogram over the provided time period
+     */
+    getDeviceReportTimeline(streamId?: string, from?: number, to?: number): import("rxjs").Observable<EntityResponse<TimeSeries<DeviceReport>>>;
+    /**
+     * Get device / group of devices consumption over time
+     */
+    getConsumptionTimeline(streamId?: string, from?: number, to?: number, type?: DeviceTypeCode[], tag?: string[], id?: string[]): import("rxjs").Observable<EntityResponse<TimeSeriesConsumption>>;
+    /**
+     * Get device / group of devices consumption trend: 7 days consumption compared to the average of the previous weeks
+     */
+    getConsumptionTrend(streamId?: string, type?: DeviceTypeCode[], tag?: string[], id?: string[]): import("rxjs").Observable<ActionResponse>;
+    /**
+     * Find devices by insight id query
+     */
+    findByInsightContext(streamId?: string, insightId?: string, from?: number, to?: number, sort?: string, page?: number, size?: number): import("rxjs").Observable<EntitiesResponse<Device>>;
+    /**
+     * Find devices by query
+     */
+    findDevicesMap(streamId?: string, search?: string, type?: DeviceTypeCode[], status?: DeviceStatusCode[], risk?: number, sort?: string, page?: number, size?: number, mapBounds?: MapBounds): import("rxjs").Observable<EntityResponse<DevicesMap>>;
+    /**
+     * Get device distribution by risk filtered by query
+     */
+    countByRisk(streamId?: string, search?: string, from?: number, to?: number, type?: DeviceTypeCode[], status?: DeviceStatusCode[], risk?: number): import("rxjs").Observable<EntityResponse<Distribution<number>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsrDevicesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UsrDevicesService>;
+}

package/lib/services/UsrEventsService.d.ts

@@ -0,0 +1,97 @@
+import { RestUtils } from '../../rest-utils';
+import { AppConfig } from '../../config';
+import { EventTypeCode } from '../model';
+import { SeverityTypeCode } from '../model';
+import { Device } from '../model';
+import { Tuple } from '../model';
+import { SimpleEntity } from '../model';
+import { EntityResponse } from '../model';
+import { EntitiesResponse } from '../model';
+import { EventWithDevice } from '../model';
+import { MaliciousIPData } from '../model';
+import { Distribution } from '../model';
+import { ActionResponse } from '../model';
+import { TimeSeries } from '../model';
+import { MaliciousIpCard } from '../model';
+import { Event } from '../model';
+import * as i0 from "@angular/core";
+export declare class UsrEventsService {
+    private config;
+    private rest;
+    private baseUrl;
+    constructor(config: AppConfig, rest: RestUtils);
+    /**
+     * Get a single event by id
+     */
+    get(id?: string): import("rxjs").Observable<EntityResponse<Event>>;
+    /**
+     * Find events by query
+     */
+    find(streamId?: string, deviceId?: string, alertId?: string, search?: string, from?: number, to?: number, type?: EventTypeCode[], severity?: SeverityTypeCode[], sort?: string, page?: number, size?: number): import("rxjs").Observable<EntitiesResponse<Device>>;
+    /**
+     * Export events by query to a file in a stream of CSV | JSON | XML | XLSX
+     */
+    export(format?: string, streamId?: string, deviceId?: string, alertId?: string, search?: string, from?: number, to?: number, type?: EventTypeCode[], severity?: SeverityTypeCode[], sort?: string, page?: number, size?: number): import("rxjs").Observable<import("@angular/common/http").HttpEvent<Blob>>;
+    /**
+     * Export event source file as a stream of source file (pcap)
+     */
+    exportSource(id?: string): import("rxjs").Observable<import("@angular/common/http").HttpEvent<Blob>>;
+    /**
+     * Get top 10 events by their severity and time
+     */
+    findTop(streamId?: string, deviceId?: string, search?: string, from?: number, to?: number, type?: EventTypeCode[], severity?: SeverityTypeCode[], sort?: string, page?: number, size?: number): import("rxjs").Observable<EntityResponse<EventWithDevice>>;
+    /**
+     * Get top 10 events by their severity and time
+     */
+    findTopMaliciousIPs(streamId?: string, top?: number): import("rxjs").Observable<EntityResponse<MaliciousIPData>>;
+    /**
+     * Get events distribution by type filtered by query
+     */
+    countByType(streamId?: string, deviceId?: string, alertId?: string, search?: string, from?: number, to?: number, type?: EventTypeCode[], severity?: SeverityTypeCode[]): import("rxjs").Observable<EntityResponse<Distribution<number>>>;
+    /**
+     * Get events distribution by status filtered by query
+     */
+    countByStatus(streamId?: string, deviceId?: string, alertId?: string, search?: string, from?: number, to?: number, type?: EventTypeCode[], severity?: SeverityTypeCode[]): import("rxjs").Observable<EntityResponse<Distribution<number>>>;
+    /**
+     * Get events distribution by severity filtered by query
+     */
+    countBySeverity(streamId?: string, deviceId?: string, alertId?: string, search?: string, from?: number, to?: number, type?: EventTypeCode[], severity?: SeverityTypeCode[]): import("rxjs").Observable<EntityResponse<Distribution<number>>>;
+    /**
+     * Get events distribution by rule filtered by query
+     */
+    countByRule(streamId?: string, deviceId?: string, alertId?: string, search?: string, from?: number, to?: number, type?: EventTypeCode[], severity?: SeverityTypeCode[]): import("rxjs").Observable<EntityResponse<Distribution<number>>>;
+    /**
+     * Get events distribution by category filtered by query
+     */
+    countByCategory(streamId?: string, deviceId?: string, alertId?: string, search?: string, from?: number, to?: number, type?: EventTypeCode[], severity?: SeverityTypeCode[]): import("rxjs").Observable<EntityResponse<Distribution<number>>>;
+    /**
+     * Get current shield as ActionResponse, the Key contains the shield index and the data includes the trend
+     */
+    getShieldex(): import("rxjs").Observable<ActionResponse>;
+    /**
+     * Get events histogram over the provided time period
+     */
+    eventsTimeline(streamId?: string, deviceId?: string, alertId?: string, dimension?: string, search?: string, from?: number, to?: number, type?: EventTypeCode[], severity?: SeverityTypeCode[]): import("rxjs").Observable<EntityResponse<TimeSeries<Tuple<number, number>[]>>>;
+    /**
+     * Get shieldex histogram over the provided time period
+     */
+    shieldexTimeline(streamId?: string): import("rxjs").Observable<EntityResponse<TimeSeries<number>>>;
+    /**
+     * Get devices at risk number for specific events criteria
+     */
+    getDevicesAtRisk(streamId?: string, search?: string, from?: number, to?: number, type?: EventTypeCode[], severity?: SeverityTypeCode[]): import("rxjs").Observable<ActionResponse>;
+    /**
+     * Get malicious IP data card for specific malicious IP
+     */
+    getMaliciousIpCard(streamId?: string, targetIp?: string, from?: number, to?: number): import("rxjs").Observable<EntityResponse<MaliciousIpCard>>;
+    /**
+     * Apply DNS lookup for each IP in the list
+     */
+    getIpLookup(ip?: string): import("rxjs").Observable<EntitiesResponse<SimpleEntity<Tuple<string, string>>>>;
+    /**
+     * Find events by query
+     */
+    findByInsightContext(streamId?: string, insightId?: string, sort?: string, page?: number, size?: number): import("rxjs").Observable<EntitiesResponse<Device>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsrEventsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UsrEventsService>;
+}

package/lib/services/UsrInsightsService.d.ts

@@ -0,0 +1,33 @@
+import { RestUtils } from '../../rest-utils';
+import { AppConfig } from '../../config';
+import { EntitiesResponse } from '../model';
+import { Insight } from '../model';
+import { InsightTypeCode } from '../model';
+import { SeverityTypeCode } from '../model';
+import { EntityResponse } from '../model';
+import { Distribution } from '../model';
+import * as i0 from "@angular/core";
+export declare class UsrInsightsService {
+    private config;
+    private rest;
+    private baseUrl;
+    constructor(config: AppConfig, rest: RestUtils);
+    /**
+     * Find daily insights
+     */
+    getDailyInsights(dayId?: number): import("rxjs").Observable<EntitiesResponse<Insight>>;
+    /**
+     * Find insights by query
+     */
+    find(streamId?: string, search?: string, from?: number, to?: number, sort?: string, page?: number, size?: number, type?: InsightTypeCode[], severity?: SeverityTypeCode[]): import("rxjs").Observable<EntitiesResponse<Insight>>;
+    /**
+     * Get a single insight by id
+     */
+    get(id?: string): import("rxjs").Observable<EntityResponse<Insight>>;
+    /**
+     * Get alerts distribution by severity filtered by query
+     */
+    countAlertsBySeverity(streamId?: string, search?: string, from?: number, to?: number, type?: InsightTypeCode[]): import("rxjs").Observable<EntityResponse<Distribution<number>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsrInsightsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UsrInsightsService>;
+}

package/lib/services/UsrIntegrationsService.d.ts

@@ -0,0 +1,44 @@
+import { RestUtils } from '../../rest-utils';
+import { AppConfig } from '../../config';
+import { Integration } from '../model';
+import { EntityResponse } from '../model';
+import { ActionResponse } from '../model';
+import { EntitiesResponse } from '../model';
+import * as i0 from "@angular/core";
+export declare class UsrIntegrationsService {
+    private config;
+    private rest;
+    private baseUrl;
+    constructor(config: AppConfig, rest: RestUtils);
+    /**
+     * region Endpoint REST handlers ---------------------------------------------------------------------------------------
+     * Create new integration configuration
+     */
+    create(body?: Integration): import("rxjs").Observable<EntityResponse<Integration>>;
+    /**
+     * Update existing integration configuration
+     */
+    update(body?: Integration): import("rxjs").Observable<EntityResponse<Integration>>;
+    /**
+     * Delete integration configuration
+     */
+    delete(id?: string): import("rxjs").Observable<ActionResponse>;
+    /**
+     * Get a single Integration by id
+     */
+    get(id?: string): import("rxjs").Observable<EntityResponse<Integration>>;
+    /**
+     * Find integrations by query
+     */
+    find(accountId?: string, streamId?: string, search?: string, sort?: string, page?: number, size?: number): import("rxjs").Observable<EntitiesResponse<Integration>>;
+    /**
+     * Validate format of the templates in the fields
+     */
+    validate(body?: Integration): import("rxjs").Observable<EntityResponse<Integration>>;
+    /**
+     * Test the integration with pseudo data
+     */
+    test(body?: Integration): import("rxjs").Observable<EntityResponse<Integration>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsrIntegrationsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UsrIntegrationsService>;
+}

package/lib/services/UsrMembersService.d.ts

@@ -0,0 +1,40 @@
+import { RestUtils } from '../../rest-utils';
+import { AppConfig } from '../../config';
+import { EntitiesResponse } from '../model';
+import { Member } from '../model';
+import { EntityResponse } from '../model';
+import { ActionResponse } from '../model';
+import { MemberRoleCode } from '../model';
+import * as i0 from "@angular/core";
+export declare class UsrMembersService {
+    private config;
+    private rest;
+    private baseUrl;
+    constructor(config: AppConfig, rest: RestUtils);
+    /**
+     * Create new account member
+     */
+    create(body?: Member): import("rxjs").Observable<EntityResponse<Member>>;
+    /**
+     * Update existing member
+     */
+    update(body?: Member): import("rxjs").Observable<EntityResponse<Member>>;
+    /**
+     * Delete member
+     */
+    delete(id?: string): import("rxjs").Observable<ActionResponse>;
+    /**
+     * Get a single member by id
+     */
+    get(id?: string): import("rxjs").Observable<EntityResponse<Member>>;
+    /**
+     * Find members by query
+     */
+    find(userId?: string, role?: MemberRoleCode[], sort?: string, page?: number, size?: number): import("rxjs").Observable<EntitiesResponse<Member>>;
+    /**
+     * Find registered emails in the system (for auto complete)
+     */
+    findEmails(search?: string, page?: number, size?: number): import("rxjs").Observable<EntitiesResponse<Member>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsrMembersService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UsrMembersService>;
+}

package/lib/services/UsrNetworkService.d.ts

@@ -0,0 +1,49 @@
+import { RestUtils } from '../../rest-utils';
+import { AppConfig } from '../../config';
+import { Distribution } from '../model';
+import { FlowRecord } from '../model';
+import { BoolTypeCode } from '../model';
+import { NetworkTopologyRecord } from '../model';
+import { SessionRecord } from '../model';
+import { EntityResponse } from '../model';
+import { NetworkTopologyReport } from '../model';
+import { EntitiesResponse } from '../model';
+import { UsageRecord } from '../model';
+import * as i0 from "@angular/core";
+export declare class UsrNetworkService {
+    private config;
+    private rest;
+    private baseUrl;
+    constructor(config: AppConfig, rest: RestUtils);
+    /**
+     * Find usage entities by query
+     */
+    findUsage(streamId?: string, deviceId?: string, simId?: string, from?: number, to?: number, include?: number, sort?: string, page?: number, size?: number): import("rxjs").Observable<EntitiesResponse<UsageRecord>>;
+    /**
+     * Find session entities by query
+     */
+    findSession(streamId?: string, deviceId?: string, simId?: string, from?: number, to?: number, include?: number, sort?: string, page?: number, size?: number): import("rxjs").Observable<EntitiesResponse<SessionRecord>>;
+    /**
+     * Find most common ports by query
+     */
+    getMostCommonPorts(streamId?: string, deviceId?: string, from?: number, to?: number, limit?: number): import("rxjs").Observable<EntitiesResponse<Distribution<number>>>;
+    /**
+     * Find most common IPs by query
+     */
+    getMostCommonIPs(streamId?: string, deviceId?: string, from?: number, to?: number, limit?: number): import("rxjs").Observable<EntitiesResponse<Distribution<string>>>;
+    /**
+     * Find flow data records
+     */
+    findTraffic(streamId?: string, deviceId?: string, simId?: string, from?: number, to?: number, include?: number, sort?: string, page?: number, size?: number, search?: string): import("rxjs").Observable<EntitiesResponse<FlowRecord>>;
+    /**
+     * Get network topology report with KPIs and distributions for stream (without endpoint records)
+     * Use /topology-records endpoint for paginated endpoint records
+     */
+    getTopologyReport(streamId?: string, dstIp?: string[], dstDns?: string[], dstPort?: number[], protocol?: string[], appProtocol?: string[], name?: string[], country?: string[], malicious?: BoolTypeCode, blocked?: BoolTypeCode): import("rxjs").Observable<EntityResponse<NetworkTopologyReport>>;
+    /**
+     * Get network topology records for stream
+     */
+    getTopologyRecords(streamId?: string, dstIp?: string[], dstDns?: string[], dstPort?: number[], protocol?: string[], appProtocol?: string[], name?: string[], country?: string[], malicious?: BoolTypeCode, blocked?: BoolTypeCode, sort?: string, page?: number, size?: number): import("rxjs").Observable<EntitiesResponse<NetworkTopologyRecord>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsrNetworkService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UsrNetworkService>;
+}

package/lib/services/UsrNotificationMessagesService.d.ts

@@ -0,0 +1,31 @@
+import { RestUtils } from '../../rest-utils';
+import { AppConfig } from '../../config';
+import { EntityResponse } from '../model';
+import { NotificationMessageDTO } from '../model';
+import { EntitiesResponse } from '../model';
+import { ActionResponse } from '../model';
+import * as i0 from "@angular/core";
+export declare class UsrNotificationMessagesService {
+    private config;
+    private rest;
+    private baseUrl;
+    constructor(config: AppConfig, rest: RestUtils);
+    /**
+     * Get a single notification message by id
+     */
+    get(id?: string): import("rxjs").Observable<EntityResponse<NotificationMessageDTO>>;
+    /**
+     * Find notification messages for the current user
+     */
+    find(isRead?: boolean, sort?: string, page?: number, size?: number): import("rxjs").Observable<EntitiesResponse<NotificationMessageDTO>>;
+    /**
+     * Mark a specific notification as read
+     */
+    markAsRead(id?: string): import("rxjs").Observable<ActionResponse>;
+    /**
+     * Mark all notifications as read for the current user
+     */
+    markAllAsRead(): import("rxjs").Observable<ActionResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsrNotificationMessagesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UsrNotificationMessagesService>;
+}

package/lib/services/UsrReportsInstanceService.d.ts

@@ -0,0 +1,36 @@
+import { RestUtils } from '../../rest-utils';
+import { AppConfig } from '../../config';
+import { EntitiesResponse } from '../model';
+import { ReportInstance } from '../model';
+import { EntityResponse } from '../model';
+import { ActionResponse } from '../model';
+import { ReportSourceCode } from '../model';
+import * as i0 from "@angular/core";
+export declare class UsrReportsInstanceService {
+    private config;
+    private rest;
+    private baseUrl;
+    constructor(config: AppConfig, rest: RestUtils);
+    /**
+     * Update existing report
+     */
+    update(body?: ReportInstance): import("rxjs").Observable<EntityResponse<ReportInstance>>;
+    /**
+     * Delete report
+     */
+    delete(id?: string): import("rxjs").Observable<ActionResponse>;
+    /**
+     * Get a single report by id
+     */
+    get(id?: string): import("rxjs").Observable<EntityResponse<ReportInstance>>;
+    /**
+     * Find reports by query
+     */
+    find(accountId?: string, search?: string, sort?: string, page?: number, size?: number, from?: number, to?: number, reportTriggerSource?: ReportSourceCode): import("rxjs").Observable<EntitiesResponse<ReportInstance>>;
+    /**
+     * Download report file as stream of PDF
+     */
+    downloadReport(id?: string): import("rxjs").Observable<import("@angular/common/http").HttpEvent<Blob>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsrReportsInstanceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UsrReportsInstanceService>;
+}

package/lib/services/UsrReportsService.d.ts

@@ -0,0 +1,57 @@
+import { RestUtils } from '../../rest-utils';
+import { AppConfig } from '../../config';
+import { GraphSeries } from '../model';
+import { Report } from '../model';
+import { EntityResponse } from '../model';
+import { ActionResponse } from '../model';
+import { EntitiesResponse } from '../model';
+import { TimeSeries } from '../model';
+import * as i0 from "@angular/core";
+export declare class UsrReportsService {
+    private config;
+    private rest;
+    private baseUrl;
+    constructor(config: AppConfig, rest: RestUtils);
+    /**
+     * Create new report
+     */
+    create(body?: Report): import("rxjs").Observable<EntityResponse<Report>>;
+    /**
+     * Update existing report
+     */
+    update(body?: Report): import("rxjs").Observable<EntityResponse<Report>>;
+    /**
+     * Delete report
+     */
+    delete(id?: string): import("rxjs").Observable<ActionResponse>;
+    /**
+     * Get a single report by id
+     */
+    get(id?: string): import("rxjs").Observable<EntityResponse<Report>>;
+    /**
+     * Find reports by query
+     */
+    find(accountId?: string, search?: string, sort?: string, page?: number, size?: number): import("rxjs").Observable<EntitiesResponse<Report>>;
+    /**
+     * Create PDF compliance report
+     */
+    getComplianceReport(streamId?: string, from?: number, to?: number): import("rxjs").Observable<import("@angular/common/http").HttpEvent<Blob>>;
+    /**
+     * Create PDF compliance report and send it by mail to the user's email
+     */
+    getComplianceReportByMail(streamId?: string, from?: number, to?: number, addressee?: string[]): import("rxjs").Observable<ActionResponse>;
+    /**
+     * Get network activity over time histogram over the provided time period
+     */
+    getNetworkActivityOverTime(streamId?: string, from?: number, to?: number): import("rxjs").Observable<EntityResponse<TimeSeries<number>>>;
+    /**
+     * Get device groups by communication frequency over the provided time period
+     */
+    getDeviceGroupsByCommunicationFrequency(streamId?: string, from?: number, to?: number): import("rxjs").Observable<EntityResponse<GraphSeries<string, number>>>;
+    /**
+     * Get device distribution by number of destinations over the provided time period
+     */
+    getDeviceDistributionByNumberOfDestinations(streamId?: string, from?: number, to?: number): import("rxjs").Observable<EntityResponse<GraphSeries<string, number>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsrReportsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UsrReportsService>;
+}

package/lib/services/UsrRulesService.d.ts

@@ -0,0 +1,62 @@
+import { RestUtils } from '../../rest-utils';
+import { AppConfig } from '../../config';
+import { EntitiesResponse } from '../model';
+import { SeverityTypeCode } from '../model';
+import { RuleActivityStatusCode } from '../model';
+import { TimeSeries } from '../model';
+import { Distribution } from '../model';
+import { EntityResponse } from '../model';
+import { ActionResponse } from '../model';
+import { EventTypeCode } from '../model';
+import { Rule } from '../model';
+import { RuleWithSQL } from '../model';
+import * as i0 from "@angular/core";
+export declare class UsrRulesService {
+    private config;
+    private rest;
+    private baseUrl;
+    constructor(config: AppConfig, rest: RestUtils);
+    /**
+     * region Endpoint REST handlers ---------------------------------------------------------------------------------------
+     * Create new rule configuration
+     */
+    create(body?: Rule): import("rxjs").Observable<EntityResponse<Rule>>;
+    /**
+     * Update existing rule configuration
+     */
+    update(body?: Rule): import("rxjs").Observable<EntityResponse<Rule>>;
+    /**
+     * Delete rule configuration
+     */
+    delete(id?: string): import("rxjs").Observable<ActionResponse>;
+    /**
+     * Get a single rule by id
+     */
+    get(id?: string): import("rxjs").Observable<EntityResponse<Rule>>;
+    /**
+     * Get a single rule with computed SQL statement by rule's id
+     */
+    getWithSQL(id?: string): import("rxjs").Observable<EntityResponse<RuleWithSQL>>;
+    /**
+     * Get a all active rules fro stream id  with computed SQL statement
+     */
+    getWithSQLByStreamId(id?: string): import("rxjs").Observable<EntitiesResponse<RuleWithSQL>>;
+    /**
+     * Find rules by query
+     */
+    find(streamId?: string, search?: string, eventSeverity?: SeverityTypeCode[], activityStatus?: RuleActivityStatusCode[], eventType?: EventTypeCode[], includeSysRules?: boolean, sort?: string, page?: number, size?: number): import("rxjs").Observable<EntitiesResponse<Rule>>;
+    /**
+     * Analyze rule configuration against historic data
+     */
+    analyze(from?: number, to?: number, interval?: number, size?: number, body?: Rule): import("rxjs").Observable<EntityResponse<TimeSeries<number>>>;
+    /**
+     * Get rules distribution by severity filtered by query
+     */
+    countBySeverity(streamId?: string, search?: string, eventSeverity?: SeverityTypeCode[], activityStatus?: RuleActivityStatusCode[], eventType?: EventTypeCode[], includeSysRules?: boolean): import("rxjs").Observable<EntityResponse<Distribution<number>>>;
+    /**
+     * Get alerts count by rule filtered by query
+     */
+    countAlertsByRule(streamId?: string, search?: string, eventSeverity?: SeverityTypeCode[], activityStatus?: RuleActivityStatusCode[], eventType?: EventTypeCode[], includeSysRules?: boolean): import("rxjs").Observable<EntityResponse<Distribution<number>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsrRulesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UsrRulesService>;
+}