@3deye-toolkit/react-event-search 0.0.1 → 0.0.3-alpha.0

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

@@ -1,5 +1,3 @@
-/// <reference types="react" />
-
 import { BehaviorSubject } from 'rxjs';
 import crossfilter from 'crossfilter2';
 import type { IReactionDisposer } from 'mobx';
@@ -7,6 +5,7 @@ import { Observable } from 'rxjs';
 import { default as React_2 } from 'react';
 import { Subject } from 'rxjs';
 import { Subscription } from 'rxjs';
+import { z } from 'zod';
 
 declare class AccountStore extends ApiStore {
     private notification?;
@@ -26,13 +25,68 @@ declare class AccountStore extends ApiStore {
         firstName: string;
         lastName: string;
     }): Observable<RawUser>;
-    updateCustomPreferences: (preferences: Record<string, any>) => Observable<RawUser>;
+    updateUserLanguage(languageCode: string): Observable<RawUser>;
+    updateCustomPreferences: (preferences: Partial<Preferences>) => Observable<RawUser>;
     setDefaultGroup(groupId: number): Observable<RawUser> | undefined;
-    getPreference: (key: string) => any;
+    get preferences(): Preferences;
+    getPreference: <T extends PREFERENCES>(key: T) => {
+        utc: boolean;
+        hour12: boolean;
+        startOfWeek: "monday" | "sunday";
+        defaultVideoResizeMode?: VideoResizeMode | undefined;
+        camerasResizeMode?: [number, VideoResizeMode][] | undefined;
+        fisheyeCameras?: [number, [number, number, number] | {
+            params: {
+                x: number;
+                y: number;
+                r: number;
+                s: number;
+            };
+            positions?: [{
+                lat: number;
+                lon: number;
+                fov: number;
+            }, {
+                lat: number;
+                lon: number;
+                fov: number;
+            }, {
+                lat: number;
+                lon: number;
+                fov: number;
+            }] | undefined;
+        } | null][] | undefined;
+    }[T];
     private retryOnVersionMismatch;
 }
 
-declare class Api<T> {
+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;
+}
+
+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>;
@@ -178,6 +232,7 @@ declare class Auth {
         agreedWithTerms?: boolean;
         code?: string;
     }) => Promise<Token> | undefined;
+    signInWithToken: (token: RawToken) => void;
     invalidateToken: () => void;
     getTokenFromStorage(): Promise<Token | null>;
     private storeToken;
@@ -195,6 +250,13 @@ declare interface AuthStoreOptions {
     clientId: string;
 }
 
+declare interface BoundingBox {
+    Left: number;
+    Top: number;
+    Right: number;
+    Bottom: number;
+}
+
 declare interface Box {
     Top: number;
     Left: number;
@@ -208,10 +270,7 @@ declare class Camera {
     imageUrl: string;
     streamUrl: string;
     dashStreamUrl: string;
-    address: {
-        Lat: number;
-        Lng: number;
-    } | null;
+    address: CameraAddress | null;
     archiveDuration: number;
     dvrWindowLength: number;
     stateUpdatedAt: Date;
@@ -227,31 +286,56 @@ declare class Camera {
     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 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[]> | undefined;
+    load: () => Observable<RawCamera[]>;
     add: (cameras: RawCamera[]) => void;
     sync: () => Observable<RawCamera[]>;
     protected afterInit(): void;
@@ -271,6 +355,16 @@ declare interface CamgroupItem {
     order: number;
 }
 
+declare interface Car {
+    Type: 'Car';
+    BodyType?: string;
+    Box: BoundingBox;
+    Probability: number;
+    Colors?: {
+        Color: string;
+    }[];
+}
+
 declare interface Chunk {
     json?: string;
     startTime: Date;
@@ -285,6 +379,44 @@ declare interface ChunksQuery {
     to: Date;
 }
 
+declare class Clip {
+    id: number;
+    cameraId: number;
+    name: string;
+    startTime: Date;
+    endTime: Date;
+    type: 'Archive' | 'Timelaps' | 'Timelaps to do';
+    createdAt: Date;
+    /**
+     * clip duration in seconds
+     */
+    duration: number;
+    chunks: ArchiveChunk[];
+    clipUrl?: string;
+    description: string;
+    version: string;
+    raw: RawClip;
+    isDownloading: boolean;
+    archives?: ArchiveChunk[];
+    constructor(raw: RawClip);
+    get isTimelapse(): boolean;
+    update(raw: RawClip): void;
+}
+
+declare interface ClipParams {
+    cameraId: number;
+    startTime: Date;
+    endTime: Date;
+    name: string;
+    description?: string;
+}
+
+declare interface ClipsQuery {
+    cameraId: number;
+    from: Date;
+    to: Date;
+}
+
 declare interface Connection {
     state: CONNECTION_STATE;
     stop: () => void;
@@ -321,21 +453,14 @@ 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;
-    };
+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;
@@ -369,14 +494,15 @@ export default EventSearch;
 declare class EventSearchStore extends ApiStore {
     eventSchema: EventSchemaStore;
     events: EventsStore;
+    private account;
     private notification;
     private heatmaps?;
     api: ExtendedApi;
     disposables: (IReactionDisposer | Subscription)[];
     readonly analyticsEnabled: boolean;
-    disposeReactionToCamera: any;
     cameraId: number | null;
     date: Date | null;
+    get startTime(): Date | null;
     regions: {
         x: number;
         y: number;
@@ -388,14 +514,22 @@ declare class EventSearchStore extends ApiStore {
     heatmapLoading: boolean;
     data: CameraEvent[];
     heatmap: Heatmap | null;
-    peopleCountingData: RawPeopleContingData[];
+    peopleCountingData: RawPeopleCountingData[];
     probabilityThreshold: number;
     brushFilter: null | [Date, Date];
+    loadTrigger: number;
     eventsLoader: EventsLoader;
+    loaderFilters: AllEventsLoaderFilters;
     get params(): SchemaDescriptionParameter[];
     get filteredData(): CameraEvent[];
-    get filteredPeopleCountingData(): RawPeopleContingData[];
-    constructor(eventSchema: EventSchemaStore, events: EventsStore, notification: NotificationService, heatmaps?: HeatmapsStore | undefined);
+    get filteredPeopleCountingData(): RawPeopleCountingData[];
+    constructor(eventSchema: EventSchemaStore, events: EventsStore, account: AccountStore, notification: NotificationService, heatmaps?: HeatmapsStore | undefined);
+    /**
+     * Converts box (Top, Left, Bottom, Right) to axis-aligned bounding box
+     * @param box
+     * @returns
+     */
+    private boxToAabb;
     setDate: (value: Date) => void;
     setFilters: (filters: DetectedObjectOption[]) => void;
     getProbabilityThreshold: () => number;
@@ -405,8 +539,8 @@ declare class EventSearchStore extends ApiStore {
         cameraId: number;
         box: Box;
     }) => void;
-    openForPlayer: (cameraId: number) => void;
     searchFullFrame: (cameraId: number) => void;
+    triggerLoad: () => void;
     setRegions: (polies: {
         x: number;
         y: number;
@@ -431,8 +565,12 @@ declare class EventSearchStore extends ApiStore {
 
 declare class EventsLoader extends ApiStore {
     private eventsStore;
-    readonly mode: 'events' | 'objects';
-    api: ExtendedApi;
+    filters: EventsLoaderFilters;
+    fetcher: (api: Api<IApi> & IApi, pageToken?: number) => Observable<ApiPageResult<RawSensorEvent>>;
+    transformData: (data: CameraEvent) => {
+        data: CameraEvent;
+        objectIdx: number;
+    }[];
     data: {
         data: CameraEvent;
         objectIdx: number;
@@ -442,49 +580,28 @@ declare class EventsLoader extends ApiStore {
         objectIdx: number;
     }[];
     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[];
-    regions: {
-        x: number;
-        y: number;
-    }[][] | null;
-    eventTypes: SensorEventType[];
-    private loadingInited;
+    private loadingInitiated;
     get isLive(): boolean;
-    get totalCount(): number;
-    get filterJson(): string | null;
-    constructor(eventsStore: EventsStore, mode?: 'events' | 'objects');
+    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 requestData;
+    private queryEvents;
     private initDataLoading;
     private initLiveUpdates;
-    private filter;
-    private toObjects;
-    private boxToAabb;
     /**
-     * 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;
-    /**
-     * Joins to arrays leaving only unique events
+     * Joins two arrays leaving only unique events
      * TODO: check if using map only on joint is more efficient
      *
      * requested events        current data
@@ -497,6 +614,16 @@ declare class EventsLoader extends ApiStore {
     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[];
@@ -521,10 +648,10 @@ declare class EventsStore extends ApiStore {
     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>;
+    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;
     /**
@@ -581,14 +708,9 @@ declare class EventsStore extends ApiStore {
     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 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 type ExtendedApi = Api<IApi> & IApi & {
-    cameras: {
-        GetPeopleCountingData: (cameraId: number, startTime: Date, endTime: Date, box: Box) => Observable<ApiResult<RawPeopleContingData>>;
-        GetLicensePlateLookUp: (value: string, limit: number) => Observable<ApiResult<string>>;
-        GetSensorEventsLprPage: (query: object, plates: string[]) => Observable<any>;
-    };
     archives: {
         GetLongLastingTimeLaps: (cameraId: number) => Observable<any>;
     };
@@ -637,7 +759,6 @@ declare class Heatmap {
 declare type HeatmapMode = 'fullframe' | 'selection' | 'none';
 
 declare class HeatmapsStore extends ApiStore {
-    api: ExtendedApi;
     fetchHeatmaps(cameraId: number, from: Date, to: Date, count: number): Observable<Heatmap[]>;
 }
 
@@ -654,9 +775,13 @@ declare interface IApi {
         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>>;
+        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>>;
@@ -669,6 +794,9 @@ declare interface IApi {
         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: {
@@ -702,18 +830,18 @@ declare interface IApi {
             from: Date;
             to: Date;
             count: number;
-        }) => Observable<any>;
+        }) => Observable<ApiResult<RawThumbnail>>;
         GetThumbnailInfo: (params: {
             cameraId: number;
             from: Date;
             to: Date;
-        }) => Observable<any>;
+        }) => Observable<ApiResult<RawThumbnail>>;
         GetHeatMapsInfo: (params: {
             cameraId: number;
             from: Date;
             to: Date;
             count: number;
-        }) => Observable<any>;
+        }) => Observable<ApiResult<RawHeatmap>>;
     };
     users: {
         GetUser: () => Observable<ApiResult<RawUser>>;
@@ -732,22 +860,67 @@ declare interface InitParams {
     tokenServiceUrl?: string;
 }
 
-declare interface Interval_2 {
+declare interface Interval {
     cameraId: number;
     from: Date;
     to: Date;
 }
 
 declare type IntervalState = {
-    state: 'fullfilled';
+    state: 'fulfilled';
     data: Thumbnail;
 } | {
     state: 'pending';
-    request: Observable<any>;
+    request: Observable<Thumbnail[]>;
 };
 
+declare class LibraryStore extends ApiStore {
+    private notification?;
+    data: crossfilter.Crossfilter<Clip>;
+    clipsByCameraId: crossfilter.Dimension<Clip, number>;
+    clipsByCreationDate: crossfilter.Dimension<Clip, number>;
+    clipsByStart: crossfilter.Dimension<Clip, number>;
+    clipsByEnd: crossfilter.Dimension<Clip, number>;
+    clipsByType: crossfilter.Dimension<Clip, string>;
+    clipsById: crossfilter.Dimension<Clip, number>;
+    clipsMap: Map<number, Clip>;
+    loaded: boolean;
+    loading: boolean;
+    updates: number;
+    constructor(notification?: NotificationService | undefined);
+    /**
+     * Fetches all clips from the server and updates the store
+     */
+    fetch(): Observable<Clip[]>;
+    add: (clips: Clip[]) => void;
+    addOrUpdate: (clips: Clip[]) => void;
+    removeFromStore: (clips: {
+        id: number;
+    }[]) => void;
+    getClips({ cameraId, from, to }: ClipsQuery): Clip[];
+    getTimelapses(): Clip[];
+    getRecentlyAdded(): Clip[];
+    all(): Clip[];
+    getOnly(type: 'clips' | 'timelapses' | null, sortDirection?: 'asc' | 'desc'): Clip[];
+    createClip: (data: ClipParams) => void;
+    createTimelapse: (data: TimelapseParams) => void;
+    rename(clip: Clip, name: string): void;
+    delete(clip: Clip): void;
+    protected afterInit(): void;
+    dispose(): void;
+}
+
+declare interface LicensePlate {
+    Type: 'LicensePlate';
+    Value: string;
+    Number: string;
+    ParentIndex: number;
+    Box: BoundingBox;
+    Probability: number;
+}
+
 declare interface NotificationOptions_2 {
-    autoClose: number | false | undefined;
+    duration: number;
 }
 
 declare class NotificationService implements Notifier {
@@ -810,9 +983,177 @@ declare interface PendingRequest_2 {
     from: Date;
     to: Date;
     count: number;
-    request: Observable<any>;
+    request: Observable<Thumbnail[]>;
+}
+
+declare enum PREFERENCES {
+    DEFAULT_VIDEO_RESIZE_MODE = "defaultVideoResizeMode",
+    RESIZE_MODE_PER_CAMERA = "camerasResizeMode",
+    FISHEYE_CAMERAS = "fisheyeCameras",
+    UTC = "utc",
+    HOUR12 = "hour12",
+    START_OF_WEEK = "startOfWeek"
 }
 
+declare type Preferences = z.infer<typeof preferencesSchema>;
+
+declare const preferencesSchema: z.ZodObject<{
+    defaultVideoResizeMode: z.ZodOptional<z.ZodNativeEnum<typeof VideoResizeMode>>;
+    camerasResizeMode: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNativeEnum<typeof VideoResizeMode>], null>, "many">>;
+    fisheyeCameras: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        params: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            r: z.ZodNumber;
+            s: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            x: number;
+            y: number;
+            r: number;
+            s: number;
+        }, {
+            x: number;
+            y: number;
+            r: number;
+            s: number;
+        }>;
+        positions: z.ZodOptional<z.ZodTuple<[z.ZodObject<{
+            lat: z.ZodNumber;
+            lon: z.ZodNumber;
+            fov: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            lat: number;
+            lon: number;
+            fov: number;
+        }, {
+            lat: number;
+            lon: number;
+            fov: number;
+        }>, z.ZodObject<{
+            lat: z.ZodNumber;
+            lon: z.ZodNumber;
+            fov: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            lat: number;
+            lon: number;
+            fov: number;
+        }, {
+            lat: number;
+            lon: number;
+            fov: number;
+        }>, z.ZodObject<{
+            lat: z.ZodNumber;
+            lon: z.ZodNumber;
+            fov: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            lat: number;
+            lon: number;
+            fov: number;
+        }, {
+            lat: number;
+            lon: number;
+            fov: number;
+        }>], null>>;
+    }, "strip", z.ZodTypeAny, {
+        params: {
+            x: number;
+            y: number;
+            r: number;
+            s: number;
+        };
+        positions?: [{
+            lat: number;
+            lon: number;
+            fov: number;
+        }, {
+            lat: number;
+            lon: number;
+            fov: number;
+        }, {
+            lat: number;
+            lon: number;
+            fov: number;
+        }] | undefined;
+    }, {
+        params: {
+            x: number;
+            y: number;
+            r: number;
+            s: number;
+        };
+        positions?: [{
+            lat: number;
+            lon: number;
+            fov: number;
+        }, {
+            lat: number;
+            lon: number;
+            fov: number;
+        }, {
+            lat: number;
+            lon: number;
+            fov: number;
+        }] | undefined;
+    }>, z.ZodNull]>], null>, "many">>;
+    utc: z.ZodDefault<z.ZodBoolean>;
+    hour12: z.ZodDefault<z.ZodBoolean>;
+    startOfWeek: z.ZodDefault<z.ZodEnum<["monday", "sunday"]>>;
+}, "strip", z.ZodTypeAny, {
+    utc: boolean;
+    hour12: boolean;
+    startOfWeek: "monday" | "sunday";
+    defaultVideoResizeMode?: VideoResizeMode | undefined;
+    camerasResizeMode?: [number, VideoResizeMode][] | undefined;
+    fisheyeCameras?: [number, [number, number, number] | {
+        params: {
+            x: number;
+            y: number;
+            r: number;
+            s: number;
+        };
+        positions?: [{
+            lat: number;
+            lon: number;
+            fov: number;
+        }, {
+            lat: number;
+            lon: number;
+            fov: number;
+        }, {
+            lat: number;
+            lon: number;
+            fov: number;
+        }] | undefined;
+    } | null][] | undefined;
+}, {
+    defaultVideoResizeMode?: VideoResizeMode | undefined;
+    camerasResizeMode?: [number, VideoResizeMode][] | undefined;
+    fisheyeCameras?: [number, [number, number, number] | {
+        params: {
+            x: number;
+            y: number;
+            r: number;
+            s: number;
+        };
+        positions?: [{
+            lat: number;
+            lon: number;
+            fov: number;
+        }, {
+            lat: number;
+            lon: number;
+            fov: number;
+        }, {
+            lat: number;
+            lon: number;
+            fov: number;
+        }] | undefined;
+    } | null][] | undefined;
+    utc?: boolean | undefined;
+    hour12?: boolean | undefined;
+    startOfWeek?: "monday" | "sunday" | undefined;
+}>;
+
 declare interface Props {
     store: EventSearchStore;
     onEventClick: (event: CameraEvent) => void;
@@ -878,27 +1219,18 @@ declare interface RawCamera {
 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;
+    description: string | null;
+    imageUrl: string | null;
+    layoutId: string | null;
+    layout_id: string | null;
     cameras: CamgroupItem[];
     camgroups: CamgroupItem[];
     version: string;
-    order: number;
 }
 
 declare interface RawClip {
     id: number;
-    recordType: string;
+    recordType: 'Archive' | 'Timelaps' | 'Timelaps to do';
     isReady: boolean;
     name: string;
     description: string;
@@ -922,7 +1254,7 @@ declare interface RawHeatmap {
     maxMotion: number;
 }
 
-declare interface RawPeopleContingData {
+declare interface RawPeopleCountingData {
     EventId: number;
     TimeStamp: Date;
     Motions: number;
@@ -966,6 +1298,12 @@ declare interface RawSharedClip {
     validTo: string | Date;
 }
 
+declare interface RawThumbnail {
+    timestamp: string;
+    realtimestamp: string;
+    url: string;
+}
+
 declare type RawToken = {
     accessToken: string;
     accessTokenExpires: string;
@@ -1086,8 +1424,11 @@ declare enum SensorEventType {
     IDCheck = 37,
     PPECheck = 38,
     WelfareCheck = 39,
-    Uncategorized = 40,
-    Unknown = 999
+    VehicleBreakIn = 40,
+    DrugTrafficking = 41,
+    Assault = 42,
+    PackageDelivery = 43,
+    Uncategorized = 999
 }
 
 declare interface Storage_2 {
@@ -1101,8 +1442,6 @@ declare interface Thumbnail {
     timestamp: Date;
     realTimestamp: Date;
     url: string;
-    width: number;
-    height: number;
 }
 
 declare class ThumbnailsStore extends ApiStore {
@@ -1124,7 +1463,7 @@ declare class ThumbnailsStore extends ApiStore {
      * @param to - end of the period
      * @param count - number of thumbnails
      */
-    fetchThumbnails(cameraId: number, from: Date, to: Date, count: number): Observable<any>;
+    fetchThumbnails: (cameraId: number, from: Date, to: Date, count: number) => Observable<Thumbnail[]>;
     getIntervalState(cameraId: number, from: Date, to: Date): IntervalState | null;
     fetchThumbnail(cameraId: number, from: Date, to: Date): Observable<Thumbnail>;
     /**
@@ -1135,14 +1474,16 @@ declare class ThumbnailsStore extends ApiStore {
      * Returns previously obtained thumbnails for given camera within period
      */
     getThumbnails({ cameraId, from, to }: GetThumbnailParams): Thumbnail[];
-    toThumbnail: (cameraId: number) => ({ realtimestamp, url, width, height }: {
+    toThumbnail: (cameraId: number) => ({ realtimestamp, url }: {
         realtimestamp: string;
         url: string;
-        width: number;
-        height: number;
     }) => Thumbnail;
 }
 
+declare type TimelapseParams = ClipParams & {
+    duration: number;
+};
+
 declare class Token {
     accessToken: string;
     accessTokenExpires: Date;
@@ -1171,6 +1512,7 @@ declare class ToolkitApp {
     thumbnails: ThumbnailsStore;
     account: AccountStore;
     notification: NotificationService;
+    library: LibraryStore;
     auth: Auth;
     api: Api<IApi> & IApi;
     private disposables;
@@ -1189,4 +1531,9 @@ declare class ToolkitApp {
 
 declare type User = RawUser;
 
+declare enum VideoResizeMode {
+    Fit = "contain",
+    Stretch = "fill"
+}
+
 export { }