@3deye-toolkit/react-event-list 0.0.2 → 0.0.3-alpha.1

package/dist/react-event-list.d.ts

@@ -1,56 +1,496 @@
+import { BehaviorSubject } from 'rxjs';
+import crossfilter from 'crossfilter2';
+import type { IReactionDisposer } from 'mobx';
+import { Observable } from 'rxjs';
 import { default as React_2 } from 'react';
+import { Subject } from 'rxjs';
+import { Subscription } from 'rxjs';
+
+declare class AllEventsLoaderFilters implements EventsLoaderFilters {
+    from: Date | null;
+    to: Date | null;
+    probabilityThreshold: number | null;
+    cameras: number[];
+    detectedObjects: string[];
+    colors: Set<string>;
+    regions: {
+        x: number;
+        y: number;
+    }[][] | null;
+    eventTypes: SensorEventType[];
+    sortDirection: 'ASC' | 'DESC';
+    updated$: Subject<null>;
+    get regionsWkt(): string[];
+    constructor();
+    apply(data: CameraEvent[]): CameraEvent[];
+    get filterJson(): string | null;
+    /**
+     * given region as array of vertices in normalized coordinates
+     * returns its representation in WKT: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry
+     * @param region
+     */
+    private regionToWktPolygon;
+}
+
+export declare class AllEventsStore extends ApiStore {
+    api: ExtendedApi;
+    cameraFilters: Camera[];
+    objectFilters: DetectedObjectOption[];
+    eventTypeFilters: EventTypeOption[];
+    date: Date | null;
+    setDate: (date: Date) => Date;
+    clearDate: () => void;
+    sortDirection: 'ASC' | 'DESC';
+    probabilityThreshold: number;
+    colors: Set<string>;
+    disposables: (IReactionDisposer | Subscription)[];
+    loader: EventsLoader;
+    loaderFilters: AllEventsLoaderFilters;
+    get someAnalyticsFilterSelected(): boolean;
+    get filters(): OptionType[];
+    constructor(eventsStore: EventsStore);
+    toggleSorting: () => void;
+    load(): void;
+    applyFilters: () => void;
+    setFilters(filters: OptionType[] | null): void;
+    getProbabilityThreshold: () => number;
+    setProbabilityThreshold: (value: number) => void;
+    toggleColor: (color: string) => void;
+    clearColors: () => void;
+    afterInit(): void;
+    dispose(): void;
+}
+
+declare class Api<T extends DeepPartial<IApi>> {
+    [key: string]: any;
+    static create<T extends PartialApi>(apiConfig: T | null, authStore: Auth, createConnection: (accessToken: string) => Connection): Api<T> & ExtractHubs<IApi, T>;
+    connectionShutdown$: Subject<null>;
+    connection$: BehaviorSubject<Connection | null>;
+    events: Subject<{
+        hub: keyof typeof events;
+        event: string;
+        data: any;
+    }>;
+    logging: boolean;
+    authStore: Auth;
+    createConnection: (accessToken: string) => Connection;
+    apiConfig: PartialApi;
+    constructor(apiConfig: T, authStore: Auth, createConnection: (accessToken: string) => Connection);
+    connect(token: Token): void;
+    shutdownConnection(): void;
+    private init;
+    private createHubMethod;
+    private subscribeToEvents;
+}
+
+declare type ApiPageResult<T> = {
+    success: true;
+    resultItems: T[];
+    pageInfo: PageInfo;
+} | {
+    success: false;
+    error: {
+        code: number;
+        message: string;
+    };
+};
+
+declare type ApiResult<T> = {
+    success: true;
+    resultItems: T[];
+} | {
+    success: false;
+    error: {
+        code: number;
+        message: string;
+    };
+};
+
+declare abstract class ApiStore {
+    api: Api<IApi> & IApi;
+    disposables: (IReactionDisposer | Subscription)[];
+    protected afterInit?(): void;
+    initWith(api: Api<IApi> & IApi): void;
+    dispose(): void;
+}
+
+declare class Auth {
+    token: Token | null;
+    isAuthenticating: boolean;
+    storage: Storage_2;
+    tokenServiceUrl: string;
+    tokenStorageKey: string;
+    deviceInfo: string | null;
+    clientId: string;
+    private pendingUpdateTokenRequest;
+    get isAuthenticated(): boolean;
+    constructor({ tokenServiceUrl, storage, tokenStorageKey, deviceInfo, clientId }: AuthStoreOptions);
+    signOut: () => void;
+    signIn: (options: {
+        username: string;
+        password: string;
+        replaceToken?: string;
+        agreedWithTerms?: boolean;
+        code?: string;
+    }) => Promise<Token> | undefined;
+    signInWithToken: (token: RawToken) => void;
+    invalidateToken: () => void;
+    getTokenFromStorage(): Promise<Token | null>;
+    private storeToken;
+    private getInitialToken;
+    private fetchToken;
+    private updateToken;
+    private fetchWidgetToken;
+}
+
+declare interface AuthStoreOptions {
+    tokenServiceUrl: string;
+    storage: Storage_2;
+    tokenStorageKey: string;
+    deviceInfo: any;
+    clientId: string;
+}
+
+declare interface BoundingBox {
+    Left: number;
+    Top: number;
+    Right: number;
+    Bottom: number;
+}
+
+declare interface Box {
+    Top: number;
+    Left: number;
+    Bottom: number;
+    Right: number;
+}
+
+declare class Camera {
+    id: number;
+    name: string;
+    imageUrl: string;
+    streamUrl: string;
+    dashStreamUrl: string;
+    address: CameraAddress | null;
+    archiveDuration: number;
+    dvrWindowLength: number;
+    stateUpdatedAt: Date;
+    raw: RawCamera;
+    enabled: boolean;
+    isMicEnabled: boolean;
+    state: string;
+    pin: string;
+    webRtcUrl: string;
+    isPtz: boolean;
+    permissions: number;
+    get isOnline(): boolean;
+    get supportsWebRTC(): boolean;
+    constructor(raw: RawCamera);
+    update: (raw: RawCamera) => void;
+    can: (permission: CameraPermissions) => number;
+}
+
+declare interface CameraAddress {
+    Lat: number;
+    Lng: number;
+    Country: string;
+    State: string;
+    City: string;
+    Address: string;
+}
 
 declare class CameraEvent {
+    id: number;
     cameraId: number;
     type: EventType;
     raw: RawSensorEvent;
     thumbnailUrl: string;
+    thumbnailWidth: number;
+    thumbnailHeight: number;
     detectedObjects: DetectedObject[];
     faces: Face[];
     instant: boolean;
-    get id(): number;
     get startTime(): Date;
     get endTime(): Date;
     get isLive(): boolean;
     get acknowledged(): boolean;
+    update: (raw: RawSensorEvent) => void;
     constructor(raw: RawSensorEvent);
 }
 
-declare type DetectedObject = {
-    Type: string;
-    Value?: string;
-    Number?: string;
-    Box: {
-        Left: number;
-        Top: number;
-        Right: number;
-        Bottom: number;
-    };
+declare const enum CameraPermissions {
+    View = 1,
+    SaveClip = 2,
+    Share = 4,
+    Ptz = 8,
+    EditSettings = 16,
+    Timelapse = 32,
+    Delete = 64
+}
+
+declare class CamerasStore extends ApiStore {
+    camerasById: Map<number, Camera>;
+    data: Camera[];
+    loading: boolean;
+    loaded: boolean;
+    pendingLoadRequest?: Observable<RawCamera[]>;
+    requestsCanceler: Subject<void>;
+    constructor();
+    load: () => Observable<RawCamera[]>;
+    add: (cameras: RawCamera[]) => void;
+    sync: () => Observable<RawCamera[]>;
+    protected afterInit(): void;
+    dispose(): void;
+}
+
+declare interface CameraStatistics {
+    id: number;
+    month: number;
+    trafficOutMBytes: number;
+    archiveStorageMBytes: number;
+    clipStorageMBytes: number;
+}
+
+declare interface CamgroupItem {
+    id: number;
+    order: number;
+}
+
+declare interface Car {
+    Type: 'Car';
+    BodyType?: string;
+    Box: BoundingBox;
     Probability: number;
     Colors?: {
         Color: string;
     }[];
-} | {
-    Type: 'Car';
-    BodyType?: string;
-    Value?: string;
-    Number?: string;
-    Box: {
-        Left: number;
-        Top: number;
-        Right: number;
-        Bottom: number;
+}
+
+declare interface Connection {
+    state: CONNECTION_STATE;
+    stop: () => void;
+    start: () => Connection;
+    done: (callback: () => void) => Connection;
+    fail: (callback: (err: any) => void) => Connection;
+    error: (callback: (err: any) => void) => Connection;
+    disconnected: (callback: () => void) => Connection;
+    reconnecting: (callback: () => void) => Connection;
+    reconnected: (callback: () => void) => Connection;
+    proxies: {
+        [P in keyof typeof FULL_API_CONFIG]: {
+            on: (eventName: string, callback: (data: any) => void) => void;
+            invoke: any;
+        };
     };
+    createHubProxy: (hubName: string) => void;
+    lastError: any;
+    qs: {
+        access_token: string;
+    };
+}
+
+declare enum CONNECTION_STATE {
+    CONNECTING = 0,
+    CONNECTED = 1,
+    RECONNECTING = 2,
+    DISCONNECTED = 3
+}
+
+declare type DeepPartial<T> = {
+    [K in keyof T]?: DeepPartial<T[K]>;
+};
+
+declare type DetectedObject = Car | LicensePlate | {
+    Type: 'Person' | 'Animal' | 'Bicycle' | 'Luggage' | 'Boat' | 'HardHat' | 'NoHardHat' | 'Fire' | 'Smoke' | 'Face';
+    Box: BoundingBox;
     Probability: number;
     Colors?: {
         Color: string;
     }[];
 };
 
+declare interface DetectedObjectOption {
+    id: string;
+    name: string;
+    color: string;
+    highlightColor: string;
+    type: 'detectedObject';
+}
+
 declare const EventList: React_2.FC<Props>;
 export default EventList;
 
-declare type EventType = 'Motion' | 'Tampering' | 'PanTiltZoom' | 'CrossLine' | 'Intrusion' | 'LicensePlate' | 'FaceDetection' | 'Audio' | 'Analytic' | 'SpeedDetection' | 'PeopleCounter' | 'Temperature' | 'PoS' | 'GPS' | 'DigitalInput' | 'Normal' | 'Suspicious' | 'Loitering' | 'Vandalism' | 'Trespass' | 'Emergency' | 'LifeInDanger' | 'ErroneousAlert' | 'Misidentification' | 'Fire' | 'MedicalDuress' | 'HoldUp' | 'CheckIn' | 'CheckOut' | 'ClockIn' | 'ClockOut' | 'ParkingStart' | 'ParkingEnd' | 'ParkingViolation' | 'GateAccess' | 'DoorAccess' | 'TemperatureCheck' | 'IDCheck' | 'PPECheck' | 'WelfareCheck' | 'Uncategorized' | 'Unknown';
+declare const events: {
+    [P in keyof PartialApi]: {
+        name: string;
+        explicit?: boolean;
+    }[];
+};
+
+declare class EventsLoader extends ApiStore {
+    private eventsStore;
+    filters: EventsLoaderFilters;
+    fetcher: (api: Api<IApi> & IApi, pageToken?: number) => Observable<ApiPageResult<RawSensorEvent>>;
+    transformData: (data: CameraEvent) => {
+        data: CameraEvent;
+        objectIdx: number;
+    }[];
+    data: {
+        data: CameraEvent;
+        objectIdx: number;
+    }[];
+    pendingData: {
+        data: CameraEvent;
+        objectIdx: number;
+    }[];
+    liveUpdateMode: 'manual' | 'auto' | 'disabled';
+    disposables: (IReactionDisposer | Subscription)[];
+    pageInfo: PageInfo_2 | null;
+    loading: boolean;
+    loadMoreTrigger: number;
+    retryTrigger: number;
+    error: Error | null;
+    private loadingInitiated;
+    get isLive(): boolean;
+    constructor(eventsStore: EventsStore, filters: EventsLoaderFilters, fetcher: (api: Api<IApi> & IApi, pageToken?: number) => Observable<ApiPageResult<RawSensorEvent>>, transformData?: (data: CameraEvent) => {
+        data: CameraEvent;
+        objectIdx: number;
+    }[]);
+    flushUpdates: () => void;
+    setLiveUpdateMode: (mode: 'manual' | 'auto' | 'disabled') => void;
+    load: () => void;
+    reload: () => void;
+    loadMore: () => void;
+    private queryEvents;
+    private initDataLoading;
+    private initLiveUpdates;
+    /**
+     * Joins two arrays leaving only unique events
+     * TODO: check if using map only on joint is more efficient
+     *
+     * requested events        current data
+     * [              ]        [          ]
+     *              [common events]
+     * @param arr1
+     * @param arr2
+     */
+    uniquelyConcat(arr1: CameraEvent[], arr2: CameraEvent[]): CameraEvent[];
+    dispose(): void;
+}
+
+declare interface EventsLoaderFilters {
+    updated$: Observable<null>;
+    sortDirection: 'ASC' | 'DESC';
+    cameras: number[];
+    from: Date | null;
+    to: Date | null;
+    probabilityThreshold: number | null;
+    apply: (events: CameraEvent[]) => CameraEvent[];
+}
+
+declare interface EventsQuery {
+    cameraIds?: number[];
+    eventTypes?: EventType[];
+    from: Date;
+    to: Date | null;
+    detectedObjectTypes?: string[];
+    colors?: Set<string>;
+    probability?: number;
+}
+
+declare class EventsStore extends ApiStore {
+    private camerasStore;
+    data: crossfilter.Crossfilter<CameraEvent>;
+    eventsByCameraId: crossfilter.Dimension<CameraEvent, number>;
+    eventsByStart: crossfilter.Dimension<CameraEvent, number>;
+    eventsByEnd: crossfilter.Dimension<CameraEvent, number>;
+    eventsByType: crossfilter.Dimension<CameraEvent, EventType>;
+    eventsByFoundObjects: crossfilter.Dimension<CameraEvent, string>;
+    eventsByColor: crossfilter.Dimension<CameraEvent, string>;
+    eventsByLiveliness: crossfilter.Dimension<CameraEvent, boolean>;
+    pendingRequests: crossfilter.Crossfilter<PendingRequest>;
+    pendingRequestsByEnd: crossfilter.Dimension<PendingRequest, number>;
+    pendingRequestsByStart: crossfilter.Dimension<PendingRequest, number>;
+    pendingRequestsByCameraId: crossfilter.Dimension<PendingRequest, number>;
+    knownIntervals: crossfilter.Crossfilter<Interval>;
+    knownIntervalsByCameraId: crossfilter.Dimension<Interval, number>;
+    knownIntervalsByStart: crossfilter.Dimension<Interval, number>;
+    knownIntervalsByEnd: crossfilter.Dimension<Interval, number>;
+    eventsById: Map<number, CameraEvent>;
+    updates: number;
+    /**
+     * Contains recent additions to the store as list of event ids
+     * NOTE: do not update several times in single action as we lose info about intermediate additions that way
+     */
+    recentAdditions: number[];
+    constructor(camerasStore: CamerasStore);
+    /**
+     * Populates store with the events for given camera and period
+     * @param cameraId - camera id or -1 to fetch all available events for given period
+     * @param startTime - start of the period
+     * @param endTime - end of the period
+     */
+    populateEvents(cameraId: number, startTime: Date, endTime: Date): void;
+    update: (data: CameraEvent[]) => void;
+    add: (data: CameraEvent[]) => void;
+    getEvents({ cameraIds, from, to, detectedObjectTypes, eventTypes, colors, probability }: EventsQuery): CameraEvent[];
+    getOverlappedEvents({ cameraId, from, to }: {
+        cameraId: number;
+        from: Date;
+        to: Date;
+    }): CameraEvent[];
+    getLastNonAnalyticEventBefore({ cameraId, date }: {
+        cameraId: number;
+        date: Date;
+    }): CameraEvent;
+    getLastObjectBefore({ cameraId, date, objectFilters }: {
+        cameraId: number;
+        date: Date;
+        objectFilters: {
+            people: boolean;
+            cars: boolean;
+            misc: boolean;
+        };
+    }): CameraEvent;
+    getFirstNonAnalyticEventAfter({ cameraId, date }: {
+        cameraId: number;
+        date: Date;
+    }): CameraEvent;
+    getFirstObjectAfter({ cameraId, date, objectFilters }: {
+        cameraId: number;
+        date: Date;
+        objectFilters: {
+            people: boolean;
+            cars: boolean;
+            misc: boolean;
+        };
+    }): CameraEvent;
+    protected afterInit(): void;
+    processNewEvents: ({ data }: {
+        data: RawSensorEvent[];
+    }) => void;
+    dispose(): void;
+}
+
+declare type EventType = 'Motion' | 'Tampering' | 'PanTiltZoom' | 'CrossLine' | 'Intrusion' | 'LicensePlate' | 'FaceDetection' | 'Audio' | 'Analytic' | 'SpeedDetection' | 'PeopleCounter' | 'Temperature' | 'PoS' | 'GPS' | 'DigitalInput' | 'Normal' | 'Suspicious' | 'Loitering' | 'Vandalism' | 'Trespass' | 'Emergency' | 'LifeInDanger' | 'ErroneousAlert' | 'Misidentification' | 'Fire' | 'MedicalDuress' | 'HoldUp' | 'CheckIn' | 'CheckOut' | 'ClockIn' | 'ClockOut' | 'ParkingStart' | 'ParkingEnd' | 'ParkingViolation' | 'GateAccess' | 'DoorAccess' | 'TemperatureCheck' | 'IDCheck' | 'PPECheck' | 'WelfareCheck' | 'VehicleBreakIn' | 'DrugTrafficking' | 'Assault' | 'PackageDelivery' | 'Uncategorized';
+
+declare interface EventTypeOption {
+    id: SensorEventType;
+    name: string;
+    type: 'eventType';
+}
+
+declare type ExtendedApi = Api<IApi> & IApi & {
+    archives: {
+        GetLongLastingTimeLaps: (cameraId: number) => Observable<any>;
+    };
+};
+
+declare type ExtractHubs<T, K> = {
+    [P in keyof ExtractMethods<T, K>]: ExtractMethods<T[P], K[P]>;
+};
+
+declare type ExtractMethods<T, K> = Pick<T, Extract<keyof T, keyof K>>;
 
 declare interface Face {
     PersonId: number;
@@ -64,10 +504,245 @@ declare interface Face {
     Probability: number;
 }
 
+declare const FULL_API_CONFIG: IApi;
+
+declare interface IApi {
+    archives: {
+        PopulateArchive: (params: {
+            cameraId: number;
+            endTime: Date;
+            startTime: Date;
+        }) => Observable<any>;
+        GetArchives: (params: Record<string, never>) => Observable<ApiResult<RawClip>>;
+        GetClips: () => Observable<any>;
+        UpdateClip: (params: any) => Observable<any>;
+        DeleteClip: (params: any) => Observable<any>;
+        SaveClip: (params: any) => Observable<any>;
+        SaveTimelaps: (params: any) => Observable<any>;
+        SaveArchive: (params: any) => Observable<ApiResult<RawClip>>;
+        DeleteArchive: (params: {
+            id: number;
+            cameraId: number;
+            version: string;
+        }) => Observable<ApiResult<RawClip>>;
+        ShareClip: (sharedClip: PartialExcept<RawSharedClip, 'name' | 'description' | 'recordId' | 'validTo'>) => Observable<ApiResult<RawSharedClip>>;
+        GetSharedClips: (recordId: number | null) => Observable<ApiResult<RawSharedClip>>;
+        UpdateSharedClip: (sharedClip: RawSharedClip) => Observable<ApiResult<RawSharedClip>>;
+        DeleteSharedClip: (recordId: number) => Observable<ApiResult<RawSharedClip>>;
+    };
+    cameras: {
+        GetCameras: (camera: {
+            id?: number;
+        } | null, since: Date | null) => Observable<ApiResult<RawCamera>>;
+        UpdateCamera: (camera: RawCamera) => Observable<ApiResult<RawCamera>>;
+        GetSensorDataSchema: (eventType: EventType) => Observable<any>;
+        GetSensorEvents: (params: SensorEventsParams, filter: string, box: Box) => Observable<ApiResult<RawSensorEvent>>;
+        GetSensorEventsPage: (request: SensorEventsRequest, filter: string | null, searchPolygons: string[]) => Observable<ApiPageResult<RawSensorEvent>>;
+        GetPeopleCountingData: (cameraId: number, startTime: Date, endTime: Date, box: Box) => Observable<ApiResult<RawPeopleCountingData>>;
+        GetLicensePlateLookUp: (value: string, limit: number) => Observable<ApiResult<string>>;
+        GetSensorEventsLprPage: (query: object, plates: string[]) => Observable<ApiPageResult<RawSensorEvent>>;
+        AddUserSensorEvent: (event: PartialExcept<RawSensorEvent, 'id' | 'eventType' | 'message'>) => Observable<ApiResult<RawSensorEvent>>;
+        AcknowledgeSensorEvent: (event: PartialExcept<RawSensorEvent, 'id' | 'ackEventType' | 'message'>) => Observable<ApiResult<RawSensorEvent>>;
+        MoveCamera: (camera: {
+            id: number;
+        }, x: number, y: number, zoom: number, moveSpeed: number, zoomSpeed: number) => Observable<any>;
+        MoveCameraContinuousStart: ({ id }: {
+            id: number;
+        }, x: number, y: number, zoom: number, timeout: number) => Observable<any>;
+        MoveCameraContinuousStop: ({ id }: {
+            id: number;
+        }) => Observable<any>;
+        GoHomePtzCamera: ({ id }: {
+            id: number;
+        }) => Observable<any>;
+        SetHomePtzCamera: ({ id }: {
+            id: number;
+        }) => Observable<any>;
+    };
+    camgroups: {
+        GetCamgroups: () => Observable<ApiResult<RawCamgroup>>;
+        DeleteCamgroup: (params: any) => Observable<ApiResult<RawCamgroup>>;
+        AddCamgroup: (params: any) => Observable<ApiResult<RawCamgroup>>;
+        UpdateCamgroup: (params: any) => Observable<ApiResult<RawCamgroup>>;
+    };
+    sound: {
+        GetPushSoundServiceUrl: (id: number) => Observable<any>;
+    };
+    thumbnails: {
+        GetThumbnailsInfo: (params: {
+            cameraId: number;
+            from: Date;
+            to: Date;
+            count: number;
+        }) => Observable<ApiResult<RawThumbnail>>;
+        GetThumbnailInfo: (params: {
+            cameraId: number;
+            from: Date;
+            to: Date;
+        }) => Observable<ApiResult<RawThumbnail>>;
+        GetHeatMapsInfo: (params: {
+            cameraId: number;
+            from: Date;
+            to: Date;
+            count: number;
+        }) => Observable<ApiResult<RawHeatmap>>;
+    };
+    users: {
+        GetUser: () => Observable<ApiResult<RawUser>>;
+        UserUpdateProfile: (user: Partial<RawUser>) => Observable<ApiResult<RawUser>>;
+    };
+}
+
+declare interface Interval {
+    cameraId: number;
+    from: Date;
+    to: Date;
+}
+
+declare interface LicensePlate {
+    Type: 'LicensePlate';
+    Value: string;
+    Number: string;
+    ParentIndex: number;
+    Box: BoundingBox;
+    Probability: number;
+}
+
+declare type OptionType = Camera | EventTypeOption | DetectedObjectOption;
+
+declare interface PageInfo {
+    isDescending: boolean;
+    nextPageToken: number;
+    haveMore: boolean;
+}
+
+declare interface PageInfo_2 {
+    isDescending: boolean;
+    nextPageToken: number;
+    haveMore: boolean;
+}
+
+declare type PartialApi = DeepPartial<IApi>;
+
+declare type PartialExcept<T, K extends keyof T> = Pick<T, K> & Partial<T>;
+
+declare interface PendingRequest {
+    cameraId: number;
+    startTime: Date;
+    endTime: Date;
+    request: Observable<any>;
+}
+
 declare interface Props extends React_2.HTMLAttributes<HTMLDivElement> {
     onEventClick: (event: CameraEvent) => void;
 }
 
+declare interface RawCamera {
+    id: number;
+    customerId: number;
+    name: string;
+    description: string;
+    cameraBrand: string;
+    cameraModel: string;
+    enabled: boolean;
+    cameraUserName: string;
+    cameraPassword: null;
+    serialNum: string;
+    isOnvif: boolean;
+    isP2P: boolean;
+    p2pRegistrationCode: null;
+    planId: null;
+    p2pState: string;
+    cameraVideoFormat: string;
+    cameraState: string;
+    cameraStateChangedTime: string;
+    cameraError: null;
+    cameraAddress: string;
+    isMicEnabled: boolean;
+    imageQuality: number;
+    cameraSourceChannel: string;
+    pin: string;
+    streamUrl: string;
+    dashStreamUrl: string;
+    rtmpUrl: string;
+    webRtcStreamHost: string;
+    webRtcUrl: string;
+    cameraHttpSourceUrl: string;
+    cameraRtspSourceUrl: string;
+    supportedResolutions: string;
+    cameraType: string;
+    isCloud: boolean;
+    generateImageUrl: null;
+    imageUrl: string;
+    qualityProfile: string;
+    encodingProfile: null;
+    width: number;
+    height: number;
+    bitRate: number;
+    frameRate: number;
+    archiveDuration: number;
+    isArchiveByMotionEvent: boolean;
+    isAnalyticsEnabled: boolean;
+    isTimelapseAvailable: boolean;
+    motionEnabled: boolean;
+    isPTZ: boolean;
+    motionDuration: number;
+    dvrWindowLength: number;
+    jsonField: string;
+    dtUpdUtc: string;
+    version: string;
+    statistics: CameraStatistics;
+}
+
+declare interface RawCamgroup {
+    id: number;
+    name: string | null;
+    description: string | null;
+    imageUrl: string | null;
+    layoutId: string | null;
+    layout_id: string | null;
+    cameras: CamgroupItem[];
+    camgroups: CamgroupItem[];
+    version: string;
+}
+
+declare interface RawClip {
+    id: number;
+    recordType: 'Archive' | 'Timelaps' | 'Timelaps to do';
+    isReady: boolean;
+    name: string;
+    description: string;
+    tagName: null;
+    cameraId: number;
+    clipUrl: string;
+    thumbnailUrl: string;
+    startTime: string;
+    endTime: string;
+    duration: number;
+    validTo: string;
+    timeCreated: string;
+    timeUpdated: string;
+    version: string;
+}
+
+declare interface RawHeatmap {
+    url: string;
+    timestamp: string;
+    minMotion: number;
+    maxMotion: number;
+}
+
+declare interface RawPeopleCountingData {
+    EventId: number;
+    TimeStamp: Date;
+    Motions: number;
+    Left: number;
+    Top: number;
+    Right: number;
+    Bottom: number;
+    timestamp: Date;
+}
+
 declare interface RawSensorEvent {
     message: string;
     data: string | null;
@@ -85,4 +760,166 @@ declare interface RawSensorEvent {
     userId: string;
 }
 
+declare interface RawSharedClip {
+    id: number;
+    recordId: number;
+    creatorUserId: number;
+    cameraId: number;
+    startTime: string | Date;
+    endTime: string | Date;
+    duration: number;
+    fileSize: number;
+    password: string;
+    name: string;
+    description: string;
+    url: string;
+    validTo: string | Date;
+}
+
+declare interface RawThumbnail {
+    timestamp: string;
+    realtimestamp: string;
+    url: string;
+}
+
+declare type RawToken = {
+    accessToken: string;
+    accessTokenExpires: string;
+    accessTokenIssued: string;
+    clientId: string;
+    expiresIn: number;
+    refreshToken: string;
+    refreshTokenExpires: string;
+    refreshTokenIssued: string;
+    tokenType: string;
+    userName: string;
+} & {
+    access_token: string;
+    access_token_expires: string;
+    access_token_issued: string;
+    client_id: string;
+    expires_in: number;
+    refresh_token: string;
+    refresh_token_expires: string;
+    refresh_token_issued: string;
+    token_type: string;
+    userName: string;
+} & {
+    widgetId?: string;
+    widgetToken?: string;
+};
+
+declare interface RawUser {
+    id: number;
+    customerId: number;
+    userName: string;
+    firstName?: string;
+    lastName?: string;
+    email: string;
+    languageCode: string;
+    layoutStartId: number | null;
+    layoutStartType: 'camera' | 'camgroup' | '';
+    timeZoneOffset: string;
+    connectionId: string;
+    ipAddress: string;
+    userRoles: string[];
+    lastLoginAt: Date;
+    createdAt: Date;
+    jsonField: string;
+    imageUrl: null;
+    uiPermissions: string[];
+    version: string;
+}
+
+declare interface SensorEventsParams {
+    sensorId: number;
+    sensorType: 'CameraSensor' | 'MotionSensor' | 'IntrusionSensor' | 'AudioSensor' | 'TemperatureSensor' | 'SpeedSensor' | 'Unknown';
+    startTime: Date;
+    endTime: Date;
+    eventType: EventType;
+}
+
+declare interface SensorEventsRequest {
+    sensorIds: number[];
+    sensorType: string;
+    sensorEventTypes: SensorEventType[];
+    startTime?: Date;
+    endTime?: Date;
+    isDescending: boolean;
+    rowsLimit: number;
+    pageToken?: number;
+}
+
+declare enum SensorEventType {
+    Motion = 0,
+    Tampering = 1,
+    PanTiltZoom = 2,
+    CrossLine = 3,
+    Intrusion = 4,
+    LicensePlate = 5,
+    FaceDetection = 6,
+    Audio = 7,
+    Analytic = 8,
+    SpeedDetection = 9,
+    PeopleCounter = 10,
+    Temperature = 11,
+    PoS = 12,
+    GPS = 13,
+    DigitalInput = 14,
+    Normal = 15,
+    Suspicious = 16,
+    Loitering = 17,
+    Vandalism = 18,
+    Trespass = 19,
+    Emergency = 20,
+    LifeInDanger = 21,
+    ErroneousAlert = 22,
+    Misidentification = 23,
+    Fire = 24,
+    MedicalDuress = 25,
+    HoldUp = 26,
+    CheckIn = 27,
+    CheckOut = 28,
+    ClockIn = 29,
+    ClockOut = 30,
+    ParkingStart = 31,
+    ParkingEnd = 32,
+    ParkingViolation = 33,
+    GateAccess = 34,
+    DoorAccess = 35,
+    TemperatureCheck = 36,
+    IDCheck = 37,
+    PPECheck = 38,
+    WelfareCheck = 39,
+    VehicleBreakIn = 40,
+    DrugTrafficking = 41,
+    Assault = 42,
+    PackageDelivery = 43,
+    Uncategorized = 999
+}
+
+declare interface Storage_2 {
+    setItem: (key: string, value: string) => void | Promise<undefined>;
+    getItem: (key: string) => (string | null) | Promise<string | null>;
+    removeItem: (key: string) => void | Promise<undefined>;
+}
+
+declare class Token {
+    accessToken: string;
+    accessTokenExpires: Date;
+    accessTokenIssued: Date;
+    clientId: string;
+    expiresIn: number;
+    refreshToken: string;
+    refreshTokenExpires: Date;
+    refreshTokenIssued: Date;
+    tokenType: string;
+    userName: string;
+    invalid: boolean;
+    widgetId?: string;
+    widgetToken?: string;
+    json: RawToken;
+    constructor(raw: RawToken);
+}
+
 export { }