Initial commit

.gitignore

@@ -0,0 +1,35 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+
+# IDEs and editors
+/.idea
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+.history/*
+
+# misc
+/.sass-cache
+/connect.lock
+/coverage
+/libpeerconnection.log
+npm-debug.log
+yarn-error.log
+testem.log
+/typings
+
+# System Files
+.DS_Store
+Thumbs.db

package.json

@@ -0,0 +1,18 @@
+{
+    "name": "thingsboard-types",
+    "version": "3.3.3",
+    "description": "TypeScript definitions for ThingsBoard",
+    "homepage": "https://github.com/vvlladd28/thingsboard-types",
+    "license": "MIT",
+    "main": "",
+    "types": "app/app.module.d,ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/jstree"
+    },
+    "scripts": {},
+    "dependencies": {
+    },
+    "typeScriptVersion": "4.3.5"
+}

src/app/app-routing.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export declare class AppRoutingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppRoutingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppRoutingModule, never, [typeof i1.RouterModule], [typeof i1.RouterModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppRoutingModule>;
+}

src/app/app.component.d.ts

@@ -0,0 +1,25 @@
+import 'hammerjs';
+import { OnInit } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { Store } from '@ngrx/store';
+import { AppState } from '@core/core.state';
+import { LocalStorageService } from '@core/local-storage/local-storage.service';
+import { DomSanitizer } from '@angular/platform-browser';
+import { MatIconRegistry } from '@angular/material/icon';
+import { AuthService } from '@core/auth/auth.service';
+import * as i0 from "@angular/core";
+export declare class AppComponent implements OnInit {
+    private store;
+    private storageService;
+    private translate;
+    private matIconRegistry;
+    private domSanitizer;
+    private authService;
+    constructor(store: Store<AppState>, storageService: LocalStorageService, translate: TranslateService, matIconRegistry: MatIconRegistry, domSanitizer: DomSanitizer, authService: AuthService);
+    setupTranslate(): void;
+    setupAuth(): void;
+    ngOnInit(): void;
+    onActivateComponent($event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppComponent, "tb-root", never, {}, {}, never, never>;
+}

src/app/app.module.d.ts

@@ -0,0 +1,20 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "./app.component";
+import * as i3 from "@angular/platform-browser";
+import * as i4 from "@angular/platform-browser/animations";
+import * as i5 from "./app-routing.module";
+import * as i6 from "@core/core.module";
+import * as i7 from "@modules/login/login.module";
+import * as i8 from "@home/home.module";
+import * as i9 from "@modules/dashboard/dashboard-routing.module";
+export declare class PageNotFoundRoutingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageNotFoundRoutingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PageNotFoundRoutingModule, never, [typeof i1.RouterModule], [typeof i1.RouterModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PageNotFoundRoutingModule>;
+}
+export declare class AppModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppModule, [typeof i2.AppComponent], [typeof i3.BrowserModule, typeof i4.BrowserAnimationsModule, typeof i5.AppRoutingModule, typeof i6.CoreModule, typeof i7.LoginModule, typeof i8.HomeModule, typeof i9.DashboardRoutingModule, typeof PageNotFoundRoutingModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppModule>;
+}

src/app/core/api/alarm-data-subscription.d.ts

@@ -0,0 +1,37 @@
+import { DataKeyType, TelemetryService } from '@shared/models/telemetry/telemetry.models';
+import { DatasourceType } from '@shared/models/widget.models';
+import { AlarmDataPageLink, EntityFilter, KeyFilter } from '@shared/models/query/query.models';
+import { SubscriptionTimewindow } from '@shared/models/time/time.models';
+import { AlarmDataListener } from '@core/api/alarm-data.service';
+export interface AlarmSubscriptionDataKey {
+    name: string;
+    type: DataKeyType;
+}
+export interface AlarmDataSubscriptionOptions {
+    datasourceType: DatasourceType;
+    dataKeys: Array<AlarmSubscriptionDataKey>;
+    entityFilter?: EntityFilter;
+    pageLink?: AlarmDataPageLink;
+    keyFilters?: Array<KeyFilter>;
+    additionalKeyFilters?: Array<KeyFilter>;
+    subscriptionTimewindow?: SubscriptionTimewindow;
+}
+export declare class AlarmDataSubscription {
+    private listener;
+    private telemetryService;
+    private alarmDataSubscriptionOptions;
+    private datasourceType;
+    private history;
+    private realtime;
+    private subscriber;
+    private alarmDataCommand;
+    private pageData;
+    private alarmIdToDataIndex;
+    private subsTw;
+    constructor(listener: AlarmDataListener, telemetryService: TelemetryService);
+    unsubscribe(): void;
+    subscribe(): void;
+    private resetData;
+    private onPageData;
+    private onDataUpdate;
+}

src/app/core/api/alarm-data.service.d.ts

@@ -0,0 +1,24 @@
+import { SubscriptionTimewindow } from '@shared/models/time/time.models';
+import { Datasource } from '@shared/models/widget.models';
+import { PageData } from '@shared/models/page/page-data';
+import { AlarmData, AlarmDataPageLink, KeyFilter } from '@shared/models/query/query.models';
+import { TelemetryWebsocketService } from '@core/ws/telemetry-websocket.service';
+import { AlarmDataSubscription, AlarmDataSubscriptionOptions } from '@core/api/alarm-data-subscription';
+import * as i0 from "@angular/core";
+export interface AlarmDataListener {
+    subscriptionTimewindow?: SubscriptionTimewindow;
+    alarmSource: Datasource;
+    alarmsLoaded: (pageData: PageData<AlarmData>, allowedEntities: number, totalEntities: number) => void;
+    alarmsUpdated: (update: Array<AlarmData>, pageData: PageData<AlarmData>) => void;
+    alarmDataSubscriptionOptions?: AlarmDataSubscriptionOptions;
+    subscription?: AlarmDataSubscription;
+}
+export declare class AlarmDataService {
+    private telemetryService;
+    constructor(telemetryService: TelemetryWebsocketService);
+    subscribeForAlarms(listener: AlarmDataListener, pageLink: AlarmDataPageLink, keyFilters: KeyFilter[]): void;
+    stopSubscription(listener: AlarmDataListener): void;
+    private createAlarmSubscriptionOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlarmDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlarmDataService>;
+}

src/app/core/api/alias-controller.d.ts

@@ -0,0 +1,54 @@
+import { AliasInfo, IAliasController, StateControllerHolder, StateEntityInfo } from '@core/api/widget-api.models';
+import { Observable, Subject } from 'rxjs';
+import { Datasource } from '@app/shared/models/widget.models';
+import { EntityService } from '@core/http/entity.service';
+import { UtilsService } from '@core/services/utils.service';
+import { EntityAliases } from '@shared/models/alias.models';
+import { EntityInfo } from '@shared/models/entity.models';
+import { Filter, FilterInfo, Filters, KeyFilter } from '@shared/models/query/query.models';
+import { TranslateService } from '@ngx-translate/core';
+export declare class AliasController implements IAliasController {
+    private utils;
+    private entityService;
+    private translate;
+    private stateControllerHolder;
+    private origEntityAliases;
+    private origFilters;
+    entityAliasesChangedSubject: Subject<string[]>;
+    entityAliasesChanged: Observable<Array<string>>;
+    filtersChangedSubject: Subject<string[]>;
+    filtersChanged: Observable<Array<string>>;
+    private entityAliasResolvedSubject;
+    entityAliasResolved: Observable<string>;
+    entityAliases: EntityAliases;
+    filters: Filters;
+    userFilters: Filters;
+    resolvedAliases: {
+        [aliasId: string]: AliasInfo;
+    };
+    resolvedAliasesObservable: {
+        [aliasId: string]: Observable<AliasInfo>;
+    };
+    resolvedAliasesToStateEntities: {
+        [aliasId: string]: StateEntityInfo;
+    };
+    constructor(utils: UtilsService, entityService: EntityService, translate: TranslateService, stateControllerHolder: StateControllerHolder, origEntityAliases: EntityAliases, origFilters: Filters);
+    updateEntityAliases(newEntityAliases: EntityAliases): void;
+    updateFilters(newFilters: Filters): void;
+    updateAliases(aliasIds?: Array<string>): void;
+    dashboardStateChanged(): void;
+    setAliasUnresolved(aliasId: string): void;
+    getEntityAliases(): EntityAliases;
+    getFilters(): Filters;
+    getFilterInfo(filterId: string): FilterInfo;
+    getKeyFilters(filterId: string): Array<KeyFilter>;
+    getEntityAliasId(aliasName: string): string;
+    getAliasInfo(aliasId: string): Observable<AliasInfo>;
+    resolveSingleEntityInfo(aliasId: string): Observable<EntityInfo>;
+    private resolveDatasource;
+    resolveAlarmSource(alarmSource: Datasource): Observable<Datasource>;
+    resolveDatasources(datasources: Array<Datasource>, singleEntity?: boolean): Observable<Array<Datasource>>;
+    getInstantAliasInfo(aliasId: string): AliasInfo;
+    updateCurrentAliasEntity(aliasId: string, currentEntity: EntityInfo): void;
+    updateUserFilter(filter: Filter): void;
+}

src/app/core/api/data-aggregator.d.ts

@@ -0,0 +1,38 @@
+import { SubscriptionData, SubscriptionDataHolder } from '@app/shared/models/telemetry/telemetry.models';
+import { SubscriptionTimewindow } from '@shared/models/time/time.models';
+import { UtilsService } from '@core/services/utils.service';
+export declare type onAggregatedData = (data: SubscriptionData, detectChanges: boolean) => void;
+export declare class DataAggregator {
+    private onDataCb;
+    private tsKeyNames;
+    private subsTw;
+    private utils;
+    private ignoreDataUpdateOnIntervalTick;
+    private dataBuffer;
+    private data;
+    private readonly lastPrevKvPairData;
+    private aggregationMap;
+    private dataReceived;
+    private resetPending;
+    private updatedData;
+    private noAggregation;
+    private aggregationTimeout;
+    private readonly aggFunction;
+    private intervalTimeoutHandle;
+    private intervalScheduledTime;
+    private startTs;
+    private endTs;
+    private elapsed;
+    constructor(onDataCb: onAggregatedData, tsKeyNames: string[], subsTw: SubscriptionTimewindow, utils: UtilsService, ignoreDataUpdateOnIntervalTick: boolean);
+    updateOnDataCb(newOnDataCb: onAggregatedData): onAggregatedData;
+    reset(subsTw: SubscriptionTimewindow): void;
+    destroy(): void;
+    onData(data: SubscriptionDataHolder, update: boolean, history: boolean, detectChanges: boolean): void;
+    private calculateStartEndTs;
+    private onInterval;
+    private updateData;
+    private updateStateBounds;
+    private processAggregatedData;
+    private updateAggregatedData;
+    private convertValue;
+}

src/app/core/api/entity-data-subscription.d.ts

@@ -0,0 +1,85 @@
+import { DatasourceType, widgetType } from '@shared/models/widget.models';
+import { SubscriptionTimewindow } from '@shared/models/time/time.models';
+import { EntityDataPageLink, EntityFilter, KeyFilter } from '@shared/models/query/query.models';
+import { DataKeyType, TelemetryService } from '@shared/models/telemetry/telemetry.models';
+import { UtilsService } from '@core/services/utils.service';
+import { EntityDataListener, EntityDataLoadResult } from '@core/api/entity-data.service';
+import { Observable } from 'rxjs';
+declare type DataKeyFunction = (time: number, prevValue: any) => any;
+declare type DataKeyPostFunction = (time: number, value: any, prevValue: any, timePrev: number, prevOrigValue: any) => any;
+export interface SubscriptionDataKey {
+    name: string;
+    type: DataKeyType;
+    funcBody: string;
+    func?: DataKeyFunction;
+    postFuncBody: string;
+    postFunc?: DataKeyPostFunction;
+    index?: number;
+    key?: string;
+    lastUpdateTime?: number;
+}
+export interface EntityDataSubscriptionOptions {
+    datasourceType: DatasourceType;
+    dataKeys: Array<SubscriptionDataKey>;
+    type: widgetType;
+    entityFilter?: EntityFilter;
+    isPaginatedDataSubscription?: boolean;
+    ignoreDataUpdateOnIntervalTick?: boolean;
+    pageLink?: EntityDataPageLink;
+    keyFilters?: Array<KeyFilter>;
+    additionalKeyFilters?: Array<KeyFilter>;
+    subscriptionTimewindow?: SubscriptionTimewindow;
+    latestTsOffset?: number;
+}
+export declare class EntityDataSubscription {
+    private listener;
+    private telemetryService;
+    private utils;
+    private entityDataSubscriptionOptions;
+    private datasourceType;
+    private history;
+    private realtime;
+    private subscriber;
+    private dataCommand;
+    private subsCommand;
+    private countCommand;
+    private attrFields;
+    private tsFields;
+    private latestValues;
+    private entityDataResolveSubject;
+    private pageData;
+    private subsTw;
+    private latestTsOffset;
+    private dataAggregators;
+    private dataKeys;
+    private datasourceData;
+    private datasourceOrigData;
+    private entityIdToDataIndex;
+    private frequency;
+    private tickScheduledTime;
+    private tickElapsed;
+    private timer;
+    private dataResolved;
+    private started;
+    constructor(listener: EntityDataListener, telemetryService: TelemetryService, utils: UtilsService);
+    private initializeSubscription;
+    unsubscribe(): void;
+    subscribe(): Observable<EntityDataLoadResult>;
+    start(): void;
+    private prepareSubscriptionCommands;
+    private startFunction;
+    private prepareData;
+    private resetData;
+    private onPageData;
+    private onDataUpdate;
+    private notifyListener;
+    private processEntityData;
+    private onData;
+    private convertValue;
+    private toSubscriptionData;
+    private createRealtimeDataAggregator;
+    private generateSeries;
+    private generateLatest;
+    private onTick;
+}
+export {};

src/app/core/api/entity-data.service.d.ts

@@ -0,0 +1,43 @@
+import { DataSetHolder, Datasource, widgetType } from '@shared/models/widget.models';
+import { SubscriptionTimewindow } from '@shared/models/time/time.models';
+import { EntityData, EntityDataPageLink, KeyFilter } from '@shared/models/query/query.models';
+import { PageData } from '@shared/models/page/page-data';
+import { TelemetryWebsocketService } from '@core/ws/telemetry-websocket.service';
+import { UtilsService } from '@core/services/utils.service';
+import { EntityDataSubscription, EntityDataSubscriptionOptions } from '@core/api/entity-data-subscription';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface EntityDataListener {
+    subscriptionType: widgetType;
+    subscriptionTimewindow?: SubscriptionTimewindow;
+    latestTsOffset?: number;
+    configDatasource: Datasource;
+    configDatasourceIndex: number;
+    dataLoaded: (pageData: PageData<EntityData>, data: Array<Array<DataSetHolder>>, datasourceIndex: number, pageLink: EntityDataPageLink) => void;
+    dataUpdated: (data: DataSetHolder, datasourceIndex: number, dataIndex: number, dataKeyIndex: number, detectChanges: boolean) => void;
+    initialPageDataChanged?: (nextPageData: PageData<EntityData>) => void;
+    forceReInit?: () => void;
+    updateRealtimeSubscription?: () => SubscriptionTimewindow;
+    setRealtimeSubscription?: (subscriptionTimewindow: SubscriptionTimewindow) => void;
+    subscriptionOptions?: EntityDataSubscriptionOptions;
+    subscription?: EntityDataSubscription;
+}
+export interface EntityDataLoadResult {
+    pageData: PageData<EntityData>;
+    data: Array<Array<DataSetHolder>>;
+    datasourceIndex: number;
+    pageLink: EntityDataPageLink;
+}
+export declare class EntityDataService {
+    private telemetryService;
+    private utils;
+    constructor(telemetryService: TelemetryWebsocketService, utils: UtilsService);
+    private static isUnresolvedDatasource;
+    prepareSubscription(listener: EntityDataListener, ignoreDataUpdateOnIntervalTick?: boolean): Observable<EntityDataLoadResult>;
+    startSubscription(listener: EntityDataListener): void;
+    subscribeForPaginatedData(listener: EntityDataListener, pageLink: EntityDataPageLink, keyFilters: KeyFilter[], ignoreDataUpdateOnIntervalTick?: boolean): Observable<EntityDataLoadResult>;
+    stopSubscription(listener: EntityDataListener): void;
+    private createSubscriptionOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityDataService>;
+}