@3deye-toolkit/core 0.0.1-alpha.8 → 0.0.1

package/dist/core.d.ts

@@ -0,0 +1,1001 @@
+/// <reference types="react" />
+
+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 AccountStore extends ApiStore {
+    private notification?;
+    user: User | null;
+    auth: Auth;
+    constructor(notification?: NotificationService | undefined);
+    get userDisplayName(): string | null;
+    protected afterInit(): void;
+    loadUser$(): Observable<RawUser | null>;
+    setUser: (user: User | null) => void;
+    setAuthStore(auth: Auth): void;
+    updateUserPassword(passwordData: {
+        previous: string;
+        new: string;
+    }): Promise<void>;
+    updateUserSettings({ firstName, lastName }: {
+        firstName: string;
+        lastName: string;
+    }): Observable<RawUser>;
+    updateCustomPreferences: (preferences: Record<string, any>) => Observable<RawUser>;
+    setDefaultGroup(groupId: number): Observable<RawUser> | undefined;
+    getPreference: (key: string) => any;
+    private retryOnVersionMismatch;
+}
+
+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;
+}
+
+/**
+ * @alpha
+ */
+export declare const app: ToolkitApp;
+
+export declare const AppContext: React_2.Context<ToolkitApp | null>;
+
+declare class ArchiveChunk implements Chunk {
+    json?: string;
+    startTime: Date;
+    endTime: Date;
+    streamUrl: string;
+    duration?: number;
+    isLive: false;
+    cameraId: number;
+    id: number;
+    constructor(raw: any);
+}
+
+declare class ArchivesStore extends ApiStore {
+    private camerasStore;
+    data: crossfilter.Crossfilter<ArchiveChunk>;
+    chunksByCameraId: crossfilter.Dimension<ArchiveChunk, number>;
+    chunksByStart: crossfilter.Dimension<ArchiveChunk, number>;
+    chunksByEnd: crossfilter.Dimension<ArchiveChunk, number>;
+    chunksById: Map<number, ArchiveChunk>;
+    private pendingRequests;
+    private pendingRequestsByEnd;
+    private pendingRequestsByStart;
+    private pendingRequestsByCameraId;
+    knownIntervals: Map<number, [Date, Date]>;
+    updates: number;
+    constructor(camerasStore: CamerasStore);
+    /**
+     * Fetches archive chunks for given camera and period
+     * @param cameraId - camera id
+     * @param startTime - start of the period
+     * @param endTime - end of the period
+     * TODO: add support for null endTime in order to remove requestedArchivesSince logic from player controller
+     * TODO: add error handling
+     */
+    fetch(cameraId: number, startTime: Date, endTime: Date): Observable<ArchiveChunk[]>;
+    extendKnownInterval(cameraId: number, startTime: Date, chunks: ArchiveChunk[]): void;
+    add(chunks: ArchiveChunk[]): void;
+    getChunks({ cameraId, from, to }: ChunksQuery): ArchiveChunk[];
+    /**
+     * Returns chunk that either contain the given time or is right adjacent to it
+     * @param camera - camera id
+     * @param time - time to search for
+     * @returns ArchiveChunk or undefined if there is no such chunk in the current archive
+     */
+    getClosestChunkRight: ({ cameraId, time }: {
+        cameraId: number;
+        time: Date;
+    }) => ArchiveChunk;
+    /**
+     * Return chunks that either contain the given time or is left adjacent to it
+     * @param camera - camera id
+     * @param time - time to search for
+     * @returns ArchiveChunk or undefined if there is no such chunk in the current archive
+     */
+    getClosestChunkLeft: ({ cameraId, time }: {
+        cameraId: number;
+        time: Date;
+    }) => ArchiveChunk;
+    fetchNextChunk: ({ cameraId, time }: {
+        cameraId: number;
+        time: Date;
+    }) => Observable<ArchiveChunk | undefined>;
+    fetchPrevChunk: ({ cameraId, time }: {
+        cameraId: number;
+        time: Date;
+    }) => Observable<ArchiveChunk | undefined>;
+    protected afterInit(): 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;
+    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 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: () => 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 Chunk {
+    json?: string;
+    startTime: Date;
+    endTime: Date;
+    streamUrl: string;
+    duration?: number;
+}
+
+declare interface ChunksQuery {
+    cameraId: number;
+    from: Date;
+    to: Date;
+}
+
+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 interface DetectedObject {
+    Type: string;
+    Value?: string;
+    Number?: string;
+    Box: {
+        Left: number;
+        Top: number;
+        Right: number;
+        Bottom: number;
+    };
+    Probability: number;
+    Colors?: {
+        Color: string;
+    }[];
+}
+
+declare interface DetectedObjectOption {
+    id: string;
+    name: string;
+    color: string;
+    highlightColor: string;
+    type: 'detectedObject';
+}
+
+declare const events: {
+    [P in keyof PartialApi]: {
+        name: string;
+        explicit?: boolean;
+    }[];
+};
+
+declare class EventSchemaStore extends ApiStore {
+    schemaDescription: SchemaDescriptionParameter[];
+    constructor();
+    get foundObjectTypes(): string[];
+    get foundObjectTypesForSelect(): DetectedObjectOption[];
+    get colorsByFoundObjectType(): Map<string, string>;
+    fetchAnalyticEventSchema: () => void;
+    protected afterInit(): void;
+    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 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 interface GetThumbnailParams {
+    cameraId: number;
+    from: Date;
+    to: Date;
+    size?: {
+        width: number;
+        height: number;
+    };
+}
+
+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<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>>;
+        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>>;
+        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 InitParams {
+    token?: RawToken | {
+        widgetId: string;
+        widgetToken: string;
+    };
+    tokenStorage?: Storage_2;
+    tokenStorageKey?: string;
+    apiUrl?: string;
+    tokenServiceUrl?: string;
+}
+
+declare interface Interval_2 {
+    cameraId: number;
+    from: Date;
+    to: Date;
+}
+
+declare type IntervalState = {
+    state: 'fullfilled';
+    data: Thumbnail;
+} | {
+    state: 'pending';
+    request: Observable<any>;
+};
+
+declare interface NotificationOptions_2 {
+    autoClose: number | false | undefined;
+}
+
+declare class NotificationService implements Notifier {
+    private notifier;
+    constructor(notifier: Notifier);
+    error(message: string | {
+        title: string;
+        text: string;
+    }): void;
+    success(message: string | {
+        title: string;
+        text: string;
+    }, options?: NotificationOptions_2): void;
+    warn(message: string | {
+        title: string;
+        text: string;
+    }): void;
+}
+
+declare interface Notifier {
+    success: (message: string | {
+        title: string;
+        text: string;
+    }, options?: NotificationOptions_2) => void;
+    warn: (message: string | {
+        title: string;
+        text: string;
+    }) => void;
+    error: (message: string | {
+        title: string;
+        text: string;
+    }) => void;
+}
+
+declare interface PageInfo {
+    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 PendingRequest_2 {
+    cameraId: number;
+    from: Date;
+    to: Date;
+    count: number;
+    request: Observable<any>;
+}
+
+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;
+    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 RawClip {
+    id: number;
+    recordType: string;
+    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 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 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 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 interface Thumbnail {
+    cameraId: number;
+    timestamp: Date;
+    realTimestamp: Date;
+    url: string;
+    width: number;
+    height: number;
+}
+
+declare class ThumbnailsStore extends ApiStore {
+    thumbnails: crossfilter.Crossfilter<Thumbnail>;
+    thumbnailsByCameraId: crossfilter.Dimension<Thumbnail, number>;
+    thumbnailsByDate: crossfilter.Dimension<Thumbnail, number>;
+    pendingRequests: crossfilter.Crossfilter<PendingRequest_2>;
+    pendingRequestsByEnd: crossfilter.Dimension<PendingRequest_2, number>;
+    pendingRequestsByStart: crossfilter.Dimension<PendingRequest_2, number>;
+    pendingRequestsByCameraId: crossfilter.Dimension<PendingRequest_2, number>;
+    pendingRequestsByCount: crossfilter.Dimension<PendingRequest_2, number>;
+    constructor();
+    /**
+     * Fetches thumbnails for given camera and period.
+     * Given period is evenly divided by number of smaller periods that equals to `count`.
+     * Server returns first available thumbnail in each period
+     * @param cameraId - camera id
+     * @param from - start of the period
+     * @param to - end of the period
+     * @param count - number of thumbnails
+     */
+    fetchThumbnails(cameraId: number, from: Date, to: Date, count: number): Observable<any>;
+    getIntervalState(cameraId: number, from: Date, to: Date): IntervalState | null;
+    fetchThumbnail(cameraId: number, from: Date, to: Date): Observable<Thumbnail>;
+    /**
+     * Returns first available thumbnail for given camera within period
+     */
+    getThumbnail({ cameraId, from, to }: GetThumbnailParams): Thumbnail;
+    /**
+     * Returns previously obtained thumbnails for given camera within period
+     */
+    getThumbnails({ cameraId, from, to }: GetThumbnailParams): Thumbnail[];
+    toThumbnail: (cameraId: number) => ({ realtimestamp, url, width, height }: {
+        realtimestamp: string;
+        url: string;
+        width: number;
+        height: number;
+    }) => Thumbnail;
+}
+
+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);
+}
+
+declare class ToolkitApp {
+    readonly name: string;
+    initialized: boolean;
+    cameras: CamerasStore;
+    archives: ArchivesStore;
+    events: EventsStore;
+    eventSchema: EventSchemaStore;
+    thumbnails: ThumbnailsStore;
+    account: AccountStore;
+    notification: NotificationService;
+    auth: Auth;
+    api: Api<IApi> & IApi;
+    private disposables;
+    private tokenUpdateReactions;
+    constructor(name: string);
+    init({ token, tokenStorage: storage, tokenStorageKey, apiUrl, tokenServiceUrl }: InitParams, name?: string): ToolkitApp;
+    dispose: () => void;
+    /**
+     * Adds a reaction to token changes
+     * If token passed to the callback is null, then the user is signed out
+     * and you should react accordingly
+     * @param cb
+     */
+    onTokenUpdate: (cb: (token: RawToken | null) => void) => () => void;
+}
+
+declare type User = RawUser;
+
+export { }