@3deye-toolkit/react-event-search 0.0.1-alpha.21

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

@@ -0,0 +1,945 @@
+import { app } from '@3deye-toolkit/core';
+import { BehaviorSubject } from 'rxjs';
+import crossfilter from 'crossfilter2';
+import { IReactionDisposer } from 'mobx';
+import { Observable } from 'rxjs';
+import { default as React_2 } from 'react';
+import { Subject } from 'rxjs';
+import { Subscription } from 'rxjs';
+
+declare class Api<T> {
+    [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;
+    widgetTokenServiceUrl?: string;
+    deviceInfo: string | null;
+    clientId: string;
+    private pendingUpdateTokenRequest;
+    get isAuthenticated(): boolean;
+    constructor({ tokenServiceUrl, widgetTokenServiceUrl, storage, tokenStorageKey, deviceInfo, clientId }: AuthStoreOptions);
+    signOut: () => void;
+    signIn: ({ username, password, tokenToKick, agreedWithTerms }: {
+        username: string;
+        password: string;
+        tokenToKick?: string | undefined;
+        agreedWithTerms?: boolean | undefined;
+    }) => Promise<Token> | undefined;
+    invalidateToken: () => void;
+    getTokenFromStorage(): Promise<Token | null>;
+    private storeToken;
+    private getInitialToken;
+    private fetchTokenBy;
+    private updateToken;
+    private fetchWidgetToken;
+}
+
+declare interface AuthStoreOptions {
+    tokenServiceUrl: string;
+    widgetTokenServiceUrl?: string;
+    storage: Storage_2;
+    tokenStorageKey: string;
+    deviceInfo: any;
+    clientId: string;
+}
+
+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: {
+        Lat: number;
+        Lng: number;
+    } | 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;
+}
+
+declare class CameraEvent {
+    cameraId: number;
+    type: EventType;
+    raw: RawSensorEvent;
+    thumbnailUrl: string;
+    detectedObjects: DetectedObject[];
+    faces: Face[];
+    instant: boolean;
+    get id(): number;
+    get startTime(): Date;
+    get endTime(): Date;
+    get isLive(): boolean;
+    get acknowledged(): boolean;
+    constructor(raw: RawSensorEvent);
+}
+
+declare class CamerasStore extends ApiStore {
+    camerasById: Map<number, Camera>;
+    data: Camera[];
+    loading: boolean;
+    loaded: boolean;
+    constructor();
+    load: () => Observable<RawCamera[]> | undefined;
+    add: (cameras: RawCamera[]) => void;
+    sync: () => void;
+    fetchPermissions(): Promise<void>;
+    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 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
+}
+
+export declare const createEventSearchStore: (appInstance?: typeof app) => EventSearchStore;
+
+declare type DeepPartial<T> = {
+    [K in keyof T]?: DeepPartial<T[K]>;
+};
+
+declare interface DetectedObject {
+    Type: string;
+    Box: {
+        Left: number;
+        Top: number;
+        Right: number;
+        Bottom: number;
+    };
+    Probability: number;
+    Colors: {
+        Color: string;
+    }[];
+}
+
+declare interface EventOption {
+    id: string;
+    name: string;
+    color: string;
+    highlightColor: string;
+    isEventType: boolean;
+}
+
+declare const events: {
+    [P in keyof PartialApi]: Array<{
+        name: string;
+        explicit?: boolean;
+    }>;
+};
+
+declare class EventSchemaStore extends ApiStore {
+    schemaDescription: SchemaDescriptionParameter[];
+    constructor();
+    get foundObjectTypes(): string[];
+    get foundObjectTypesForSelect(): {
+        id: EventType;
+        name: string;
+        color: string;
+        highlightColor: any;
+        isEventType: boolean;
+    }[];
+    get colorsByFoundObjectType(): Map<string, string>;
+    fetchAnalyticEventSchema: () => void;
+    protected afterInit(): void;
+    dispose(): void;
+}
+
+declare const EventSearch: React_2.FC<Props>;
+export default EventSearch;
+
+declare class EventSearchStore extends ApiStore {
+    eventSchema: EventSchemaStore;
+    events: EventsStore;
+    private notification;
+    private heatmaps?;
+    api: ExtendedApi;
+    disposables: (IReactionDisposer | Subscription)[];
+    readonly analyticsEnabled: boolean;
+    disposeReactionToCamera: any;
+    cameraId: number | null;
+    date: Date | null;
+    regions: {
+        x: number;
+        y: number;
+    }[][] | null;
+    filters: EventOption[];
+    colors: Set<string>;
+    peopleCountingDataLoading: boolean;
+    heatmapHidden: boolean;
+    heatmapLoading: boolean;
+    data: CameraEvent[];
+    heatmap: Heatmap | null;
+    peopleCountingData: RawPeopleContingData[];
+    probabilityThreshold: number;
+    brushFilter: null | [Date, Date];
+    eventsLoader: EventsLoader;
+    get params(): SchemaDescriptionParameter[];
+    get filteredData(): CameraEvent[];
+    get filteredPeopleCountingData(): RawPeopleContingData[];
+    constructor(eventSchema: EventSchemaStore, events: EventsStore, notification: NotificationService, heatmaps?: HeatmapsStore | undefined);
+    setDate: (value: Date) => void;
+    setFilters: (filters: EventOption[]) => void;
+    getProbabilityThreshold: () => number;
+    setProbabilityThreshold: (value: number) => void;
+    setBrushFilter: (value: [Date, Date] | null) => void;
+    setParams: ({ cameraId, box }: {
+        cameraId: number;
+        box: Box;
+    }) => void;
+    openForPlayer: (cameraId: number) => void;
+    searchFullFrame: (cameraId: number) => void;
+    setRegions: (polies: {
+        x: number;
+        y: number;
+    }[][]) => void;
+    toggleHeatmap: () => void;
+    toggleColor: (color: string) => void;
+    clearColors: () => void;
+    clear: () => void;
+    initDataFetching: () => void;
+    /**
+     * 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
+     */
+    regionToWktPolygon(region: {
+        x: number;
+        y: number;
+    }[]): string;
+    boxRegions(regions: {
+        x: number;
+        y: number;
+    }[][]): {
+        Left: number;
+        Right: number;
+        Top: number;
+        Bottom: number;
+    };
+    afterInit(): void;
+    dispose(): void;
+}
+
+declare class EventsLoader extends ApiStore {
+    private eventsStore;
+    api: ExtendedApi;
+    data: CameraEvent[];
+    pendingData: CameraEvent[];
+    liveUpdateMode: 'manual' | 'auto' | 'disabled';
+    updateTrigger: number;
+    colors: Set<string>;
+    disposables: (IReactionDisposer | Subscription)[];
+    pageInfo: PageInfo_2 | null;
+    loading: boolean;
+    loadMoreTrigger: number;
+    retryTrigger: number;
+    error: Error | null;
+    sortDirection: 'ASC' | 'DESC';
+    probabilityThreshold: null | number;
+    from?: Date;
+    to?: Date;
+    cameras: number[];
+    detectedObjects: string[];
+    polygons: string[];
+    eventTypes: SensorEventType[];
+    private loadingInited;
+    get isLive(): boolean;
+    get totalCount(): number;
+    get filterJson(): string | null;
+    constructor(eventsStore: EventsStore);
+    flushUpdates: () => void;
+    load: () => void;
+    reload: () => void;
+    loadMore: () => void;
+    private requestData;
+    private initDataLoading;
+    private initLiveUpdates;
+    private filter;
+    /**
+     * Joins to 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 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_2>;
+    knownIntervalsByCameraId: crossfilter.Dimension<Interval_2, number>;
+    knownIntervalsByStart: crossfilter.Dimension<Interval_2, number>;
+    knownIntervalsByEnd: crossfilter.Dimension<Interval_2, 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' | 'Uncategorized' | 'Unknown';
+
+declare type ExtendedApi = Api<IApi> & IApi & {
+    cameras: {
+        GetPeopleCountingData: (cameraId: number, startTime: Date, endTime: Date, box: Box) => Observable<ApiResult<RawPeopleContingData>>;
+    };
+    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;
+    Name: string;
+    Box: {
+        Left: number;
+        Top: number;
+        Right: number;
+        Bottom: number;
+    };
+    Probability: number;
+}
+
+declare const FULL_API_CONFIG: IApi;
+
+declare class Heatmap {
+    url: string;
+    startTime: Date;
+    endTime: Date;
+    minMotion: number;
+    maxMotion: number;
+    cameraId: number;
+    constructor(raw: RawHeatmap, cameraId: number, duration: number);
+}
+
+declare class HeatmapsStore extends ApiStore {
+    api: ExtendedApi;
+    fetchHeatmaps(cameraId: number, from: Date, to: Date, count: number): Observable<Heatmap[]>;
+}
+
+declare interface IApi {
+    archives: {
+        PopulateArchive: (params: {
+            cameraId: number;
+            endTime: Date;
+            startTime: Date;
+        }) => Observable<any>;
+        GetArchives: (params: any) => Observable<any>;
+        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<any>;
+        DeleteArchive: (params: any) => Observable<any>;
+        ShareClip: (sharedClip: RawSharedClip) => 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>>;
+        /**
+         * @deprecated
+         */
+        GetMotionEvents: (params: {
+            cameraId: number;
+            endTime: Date | null;
+            startTime: Date;
+        }) => Observable<OBVIOUSLY_NEEDS_TO_BE_FIXED_EventsApiResult<RawEvent>>;
+        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>>;
+        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<any>;
+        GetThumbnailInfo: (params: {
+            cameraId: number;
+            from: Date;
+            to: Date;
+        }) => Observable<any>;
+        GetHeatMapsInfo: (params: {
+            cameraId: number;
+            from: Date;
+            to: Date;
+            count: number;
+        }) => Observable<any>;
+    };
+    users: {
+        GetUser: () => Observable<ApiResult<RawUser>>;
+        UserUpdateProfile: (user: Partial<RawUser>) => Observable<ApiResult<RawUser>>;
+    };
+}
+
+declare interface Interval_2 {
+    cameraId: number;
+    from: Date;
+    to: Date;
+}
+
+declare interface NotificationOptions_2 {
+    autoClose: number | false | undefined;
+}
+
+declare class NotificationService implements Notifier {
+    private notifier;
+    constructor(notifier: Notifier);
+    error(message: string): void;
+    success(message: string, options?: NotificationOptions_2): void;
+    warn(message: string): void;
+}
+
+declare interface Notifier {
+    success: (message: string, options?: NotificationOptions_2) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+}
+
+declare type OBVIOUSLY_NEEDS_TO_BE_FIXED_EventsApiResult<T> = {
+    success: true;
+    motionEventItems: T[];
+} | {
+    success: false;
+    error: {
+        code: number;
+        message: string;
+    };
+};
+
+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 {
+    store: EventSearchStore;
+    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: Date;
+    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: Date;
+    version: string;
+    statistics: CameraStatistics;
+}
+
+declare interface RawCamgroup {
+    id: number;
+    name: string | null;
+    text: null;
+    description: null;
+    iconUrl: null;
+    iconCls: null;
+    dynamic: boolean;
+    allowDuplicates: boolean;
+    allowDrop: boolean;
+    allowNodeDropInView: boolean;
+    visible: boolean;
+    layout_id: string;
+    contentFilter: null;
+    customerWideGroup: boolean;
+    cameras: CamgroupItem[];
+    camgroups: CamgroupItem[];
+    version: string;
+    order: number;
+}
+
+declare interface RawEvent {
+    id: number;
+    startTime: string;
+    endTime?: string;
+    cameraId: number;
+    data: string | null;
+}
+
+declare interface RawHeatmap {
+    url: string;
+    timestamp: string;
+    minMotion: number;
+    maxMotion: number;
+}
+
+declare interface RawPeopleContingData {
+    EventId: number;
+    TimeStamp: Date;
+    Motions: number;
+    Left: number;
+    Top: number;
+    Right: number;
+    Bottom: number;
+    timestamp: Date;
+}
+
+declare interface RawSensorEvent {
+    message: string;
+    data: string | null;
+    id: number;
+    customerId: number;
+    sensorId: number;
+    sensorType: 'CameraSensor' | 'MotionSensor' | 'IntrusionSensor' | 'AudioSensor' | 'TemperatureSensor' | 'SpeedSensor' | 'Unknown';
+    eventType: EventType;
+    ackEventType: string;
+    description?: any;
+    tags?: any;
+    customerData?: any;
+    startTime: string;
+    endTime: string;
+    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 RawToken {
+    access_token: string;
+    accessToken: string;
+    access_token_expires: string;
+    accessTokenExpires: string;
+    access_token_issued: string;
+    accessTokenIssued: string;
+    client_id: string;
+    clientId: string;
+    expires_in: number;
+    expiresIn: number;
+    refresh_token: string;
+    refreshToken: string;
+    refresh_token_expires: string;
+    refreshTokenExpires: string;
+    refresh_token_issued: string;
+    refreshTokenIssued: string;
+    token_type: string;
+    tokenType: 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;
+    permissions: number;
+    version: string;
+}
+
+declare interface SchemaDescriptionParameter {
+    schemaId: number;
+    eventType: string;
+    description: string;
+    fieldName: string;
+    parameterType: string;
+    possibleValues: string;
+    valueSet: string;
+    values?: 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,
+    Uncategorized = 40,
+    Unknown = 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 { }