@3deye-toolkit/react-event-search 0.0.2 → 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,12 +25,67 @@ 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 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>;
@@ -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;
@@ -306,7 +400,7 @@ declare class Clip {
     archives?: ArchiveChunk[];
     constructor(raw: RawClip);
     get isTimelapse(): boolean;
-    update(raw: any): void;
+    update(raw: RawClip): void;
 }
 
 declare interface ClipParams {
@@ -359,31 +453,9 @@ declare type DeepPartial<T> = {
     [K in keyof T]?: DeepPartial<T[K]>;
 };
 
-declare type DetectedObject = {
-    Type: string;
-    Value?: string;
-    Number?: string;
-    Box: {
-        Left: number;
-        Top: number;
-        Right: number;
-        Bottom: number;
-    };
-    Probability: number;
-    Colors?: {
-        Color: string;
-    }[];
-} | {
-    Type: 'Car';
-    BodyType?: 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;
@@ -422,6 +494,7 @@ export default EventSearch;
 declare class EventSearchStore extends ApiStore {
     eventSchema: EventSchemaStore;
     events: EventsStore;
+    private account;
     private notification;
     private heatmaps?;
     api: ExtendedApi;
@@ -429,6 +502,7 @@ declare class EventSearchStore extends ApiStore {
     readonly analyticsEnabled: boolean;
     cameraId: number | null;
     date: Date | null;
+    get startTime(): Date | null;
     regions: {
         x: number;
         y: number;
@@ -443,12 +517,13 @@ declare class EventSearchStore extends ApiStore {
     peopleCountingData: RawPeopleCountingData[];
     probabilityThreshold: number;
     brushFilter: null | [Date, Date];
+    loadTrigger: number;
     eventsLoader: EventsLoader;
-    loaderFilters: EventsLoaderFilters;
+    loaderFilters: AllEventsLoaderFilters;
     get params(): SchemaDescriptionParameter[];
     get filteredData(): CameraEvent[];
     get filteredPeopleCountingData(): RawPeopleCountingData[];
-    constructor(eventSchema: EventSchemaStore, events: EventsStore, notification: NotificationService, heatmaps?: HeatmapsStore | undefined);
+    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
@@ -464,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;
@@ -490,15 +565,7 @@ declare class EventSearchStore extends ApiStore {
 
 declare class EventsLoader extends ApiStore {
     private eventsStore;
-    filters: {
-        updated$: Observable<null>;
-        sortDirection: 'ASC' | 'DESC';
-        cameras: number[];
-        from: Date | null;
-        to: Date | null;
-        probabilityThreshold: number | null;
-        apply: (events: CameraEvent[]) => CameraEvent[];
-    };
+    filters: EventsLoaderFilters;
     fetcher: (api: Api<IApi> & IApi, pageToken?: number) => Observable<ApiPageResult<RawSensorEvent>>;
     transformData: (data: CameraEvent) => {
         data: CameraEvent;
@@ -513,7 +580,6 @@ declare class EventsLoader extends ApiStore {
         objectIdx: number;
     }[];
     liveUpdateMode: 'manual' | 'auto' | 'disabled';
-    updateTrigger: number;
     disposables: (IReactionDisposer | Subscription)[];
     pageInfo: PageInfo_2 | null;
     loading: boolean;
@@ -522,15 +588,7 @@ declare class EventsLoader extends ApiStore {
     error: Error | null;
     private loadingInitiated;
     get isLive(): boolean;
-    constructor(eventsStore: EventsStore, filters: {
-        updated$: Observable<null>;
-        sortDirection: 'ASC' | 'DESC';
-        cameras: number[];
-        from: Date | null;
-        to: Date | null;
-        probabilityThreshold: number | null;
-        apply: (events: CameraEvent[]) => CameraEvent[];
-    }, fetcher: (api: Api<IApi> & IApi, pageToken?: number) => Observable<ApiPageResult<RawSensorEvent>>, transformData?: (data: CameraEvent) => {
+    constructor(eventsStore: EventsStore, filters: EventsLoaderFilters, fetcher: (api: Api<IApi> & IApi, pageToken?: number) => Observable<ApiPageResult<RawSensorEvent>>, transformData?: (data: CameraEvent) => {
         data: CameraEvent;
         objectIdx: number;
     }[]);
@@ -556,30 +614,14 @@ declare class EventsLoader extends ApiStore {
     dispose(): void;
 }
 
-declare class EventsLoaderFilters {
+declare interface EventsLoaderFilters {
+    updated$: Observable<null>;
+    sortDirection: 'ASC' | 'DESC';
+    cameras: number[];
     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;
+    apply: (events: CameraEvent[]) => CameraEvent[];
 }
 
 declare interface EventsQuery {
@@ -606,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;
     /**
@@ -666,7 +708,7 @@ 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 & {
     archives: {
@@ -717,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[]>;
 }
 
@@ -789,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>>;
@@ -819,18 +860,18 @@ 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 {
@@ -869,8 +910,17 @@ declare class LibraryStore extends ApiStore {
     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 {
@@ -933,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;
@@ -1012,7 +1230,7 @@ declare interface RawCamgroup {
 
 declare interface RawClip {
     id: number;
-    recordType: string;
+    recordType: 'Archive' | 'Timelaps' | 'Timelaps to do';
     isReady: boolean;
     name: string;
     description: string;
@@ -1080,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;
@@ -1200,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 {
@@ -1215,8 +1442,6 @@ declare interface Thumbnail {
     timestamp: Date;
     realTimestamp: Date;
     url: string;
-    width: number;
-    height: number;
 }
 
 declare class ThumbnailsStore extends ApiStore {
@@ -1238,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>;
     /**
@@ -1249,11 +1474,9 @@ 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;
 }
 
@@ -1308,4 +1531,9 @@ declare class ToolkitApp {
 
 declare type User = RawUser;
 
+declare enum VideoResizeMode {
+    Fit = "contain",
+    Stretch = "fill"
+}
+
 export { }