@3deye-toolkit/react-camera 0.0.1-alpha.26 → 0.0.1-alpha.29

package/dist/react-camera.d.ts

@@ -0,0 +1,972 @@
+/// <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 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 type ArchiveChunk = Chunk & {
+    isLive: false;
+};
+
+declare class ArchiveChunk_2 implements Chunk_2 {
+    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_2>;
+    chunksByCameraId: crossfilter.Dimension<ArchiveChunk_2, number>;
+    chunksByStart: crossfilter.Dimension<ArchiveChunk_2, number>;
+    chunksByEnd: crossfilter.Dimension<ArchiveChunk_2, number>;
+    chunksById: Map<number, ArchiveChunk_2>;
+    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_2[]>;
+    extendKnownInterval(cameraId: number, startTime: Date, chunks: ArchiveChunk_2[]): void;
+    add(chunks: ArchiveChunk_2[]): void;
+    getChunks({ cameraId, from, to }: ChunksQuery): ArchiveChunk_2[];
+    /**
+     * 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_2;
+    /**
+     * 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_2;
+    fetchNextChunk: ({ cameraId, time }: {
+        cameraId: number;
+        time: Date;
+    }) => Observable<ArchiveChunk_2 | undefined>;
+    fetchPrevChunk: ({ cameraId, time }: {
+        cameraId: number;
+        time: Date;
+    }) => Observable<ArchiveChunk_2 | 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 type BehaviorFactory = (controller: PlayerController) => PlayerBehavior;
+
+declare interface Box {
+    Top: number;
+    Left: number;
+    Bottom: number;
+    Right: number;
+}
+
+export declare const BoxSelector: (({ onSelect, onRequestCancel, onClose }: Props_2) => JSX.Element) & {
+    displayName: string;
+};
+
+export 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 const Camera_2: React_2.MemoExoticComponent<React_2.ForwardRefExoticComponent<Pick<Props & React_2.RefAttributes<HTMLDivElement>, "key" | keyof Props> & React_2.RefAttributes<HTMLDivElement>>>;
+export default Camera_2;
+
+declare interface Camera_3 {
+    id: number;
+    name: string;
+    streamUrl: string;
+    dashStreamUrl: string;
+    webRtcUrl: string;
+    pin: string;
+    dvrWindowLength: number;
+    enabled: boolean;
+    isOnline: boolean;
+    isPtz: boolean;
+    isMicEnabled: boolean;
+    address?: {
+        Lat: number;
+        Lng: number;
+    } | null;
+    archiveDuration: number;
+    permissions: number;
+    raw: RawCamera;
+}
+
+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 {
+    startTime: Date;
+    endTime: Date;
+    streamUrl: string;
+    duration?: number;
+    cameraId: number;
+}
+
+declare interface Chunk_2 {
+    json?: string;
+    startTime: Date;
+    endTime: Date;
+    streamUrl: string;
+    duration?: number;
+}
+
+declare interface ChunksQuery {
+    cameraId: number;
+    from: Date;
+    to: Date;
+}
+
+declare interface Clip {
+    id: number;
+    cameraId: number;
+    startTime: Date;
+    endTime: Date;
+    isTimelapse: boolean;
+    duration: number;
+    clipUrl?: string;
+    name: string;
+}
+
+export declare const CloseControl: {
+    ({ onClick }: Props_3): JSX.Element | null;
+    displayName: string;
+};
+
+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 Control: React_2.FC<Props_4>;
+
+export declare class Controls extends React_2.Component<Props_5> {
+    get player(): PlayerController;
+    static contextType: React_2.Context<PlayerController>;
+    static Spacer: React_2.FC;
+    containerRef: React_2.RefObject<HTMLDivElement>;
+    mutationObserver: MutationObserver;
+    resizeReactionDisposer: IReactionDisposer;
+    componentDidUpdate(): void;
+    componentDidMount(): void;
+    reflow: () => void;
+    componentWillUnmount(): void;
+    render(): JSX.Element;
+}
+
+declare type DeepPartial<T> = {
+    [K in keyof T]?: DeepPartial<T[K]>;
+};
+
+export declare const DefaultControls: (({ onRequestClose, fullscreenControl }: Props_7) => JSX.Element) & {
+    displayName: string;
+};
+
+declare const events: {
+    [P in keyof PartialApi]: {
+        name: string;
+        explicit?: boolean;
+    }[];
+};
+
+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 const FULL_API_CONFIG: IApi;
+
+export declare const FullscreenControl: {
+    ({ toggle: toggle, active }: Props_6): JSX.Element;
+    displayName: string;
+};
+
+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>>;
+        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 class LiveChunk {
+    cameraId: number;
+    streamUrl: string;
+    dashStreamUrl: string;
+    startTime: Date;
+    endTime: Date;
+    length: number;
+    isLive: boolean;
+    isDvr: boolean;
+    hasDvr: boolean;
+    rtmpStreamUrl: string;
+    managed: boolean;
+    constructor(data: {
+        cameraId: number;
+        endTime: Date;
+        startTime: Date;
+        streamUrl: string;
+        dashStreamUrl: string;
+        length: number;
+    });
+    setBounds: (range: [Date, Date]) => 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>;
+
+export declare const PlaybackRateControl: (() => JSX.Element | null) & {
+    displayName: string;
+};
+
+declare interface PlayerBehavior {
+    player: PlayerController;
+    delay?: number;
+    live?: boolean;
+    seek?: (time: Date) => void;
+    goLive?: () => void;
+    getCurrentTime: () => Date | null;
+    getDateRange?: () => [Date, Date] | null;
+    dispose: () => Promise<void> | void;
+}
+
+export declare const PlayerContext: React_2.Context<PlayerController>;
+
+export declare class PlayerController {
+    id: number;
+    disposables: (IReactionDisposer | Subscription)[];
+    liveChunk?: LiveChunk | null;
+    currentTime: Date | null;
+    targetTime: Date | null;
+    chunk: ArchiveChunk | LiveChunk | null;
+    paused: boolean;
+    loading: boolean;
+    error: any;
+    playbackRate: number;
+    volume: number;
+    muted: boolean;
+    videoResizeMode: VideoResizeMode;
+    camera: Camera_3;
+    stats: any;
+    mode: 'archive' | 'DVR' | 'WebRTC' | null;
+    behavior: PlayerBehavior | null;
+    transform: string | null;
+    width: number;
+    height: number;
+    chunkRequest: {
+        time: Date;
+        backward: boolean;
+    } | null;
+    video: HTMLVideoElement;
+    clip?: Clip;
+    startTime: Date | null;
+    endTime: Date | null;
+    stream: MediaStream | null;
+    canSeek: boolean;
+    canSeek$: Observable<any>;
+    progress$: Observable<any>;
+    muted$: Observable<boolean>;
+    volume$: Observable<number>;
+    ended$: Observable<any>;
+    archivesStore: ArchivesStore;
+    behaviors: {
+        archive: BehaviorFactory;
+        DVR: BehaviorFactory;
+        WebRTC: BehaviorFactory | null;
+    };
+    seekTime?: Date | null;
+    constructor({ camera, startTime, endTime, clip, archivesStore, behaviors }: {
+        camera: Camera_3;
+        clip?: Clip;
+        startTime?: Date | null;
+        endTime?: Date;
+        archivesStore: ArchivesStore;
+        behaviors: {
+            archive: BehaviorFactory;
+            DVR: BehaviorFactory;
+            WebRTC: BehaviorFactory | null;
+        };
+    });
+    attach(video: HTMLVideoElement, { canSeek$, progress$, muted$, volume$, ended$ }: PlayerEventStreams): void;
+    seek: (time: Date) => void;
+    seekAfterReady(): void;
+    stopLoadingOnError(): void;
+    replaceErrorMessageOnOffline(): void;
+    changeMedia: ({ time, chunk, backward }: {
+        time: Date;
+        chunk?: LiveChunk | ArchiveChunk | undefined;
+        backward?: boolean | undefined;
+    }) => void;
+    initCurrentTime(): void;
+    /**
+     * If the chunk after chunk request is the same as the current chunk,
+     * then we can dismiss loading indicator and seek.
+     */
+    initSameChunkRequestFix(): void;
+    initLiveChunkUpdate(): void;
+    initChunkRequest(): void;
+    setupLiveChunk(): void;
+    /**
+     * Inits correct behavior for current player mode
+     */
+    initPlayerBehavior(): void;
+    /**
+     * Rewind by given amount of milliseconds
+     * @param value milliseconds
+     * @returns
+     */
+    seekBackward: (value: number) => void;
+    /**
+     * Seek forward by given amount of milliseconds
+     * @param value
+     * @returns
+     */
+    seekForward: (value: number) => void;
+    goLive: () => void;
+    fallbackToDVR: () => void;
+    setCamera: (camera: Camera_3) => void;
+    setCameraAndStartTime: (camera: Camera_3, startTime: Date | null) => void;
+    toggleResizeMode: () => void;
+    setVideoResizeMode: (mode: VideoResizeMode) => void;
+    toggleMute: () => void;
+    setStartTime: (time: Date | null) => void;
+    setVolume: (volume: number) => void;
+    setPlaybackRate: (rate: number) => void;
+    reactToVolumeChange(): void;
+    togglePlayback: () => void;
+    setTransform(transform: string | null): void;
+    play: () => void;
+    pause: () => void;
+    detach: () => void;
+    private initUpgradeToWebRtc;
+}
+
+declare interface PlayerEventStreams {
+    canSeek$: Observable<any>;
+    progress$: Observable<any>;
+    ended$: Observable<any>;
+    volume$: Observable<number>;
+    muted$: Observable<boolean>;
+}
+
+export declare const PlayPauseControl: (() => JSX.Element) & {
+    displayName: string;
+};
+
+declare interface Props extends Omit<React_2.HTMLAttributes<HTMLDivElement>, 'onMouseDown'> {
+    cameraId: number;
+    startTime?: Date | null;
+    controls?: React_2.ReactNode;
+    onMouseDown?: (e: MouseEvent) => void;
+    onRequestClose?: () => void;
+}
+
+declare interface Props_2 {
+    onSelect: (box: Box) => void;
+    onClose: () => void;
+    onRequestCancel: () => void;
+}
+
+declare interface Props_3 {
+    onClick?: () => void;
+}
+
+declare type Props_4 = React_2.HTMLAttributes<HTMLButtonElement> & {
+    ref?: React_2.Ref<HTMLButtonElement>;
+};
+
+declare interface Props_5 {
+    children: React_2.ReactNode;
+    style?: React_2.CSSProperties;
+}
+
+declare interface Props_6 {
+    toggle: (() => void) | null;
+    active: boolean;
+}
+
+declare interface Props_7 {
+    onRequestClose?: () => void;
+    fullscreenControl?: React_2.ReactNode;
+}
+
+export declare const PtzControls: ((props: PtzControlsProps) => JSX.Element) & {
+    displayName: string;
+};
+
+declare interface PtzControlsProps {
+    cameraId: number;
+    style?: React_2.CSSProperties;
+    initialZoomSpeed?: number;
+    initialMovementSpeed?: number;
+    disabled?: boolean;
+    disallowHomePositionUpdate?: boolean;
+    disallowGoHome?: boolean;
+}
+
+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;
+    permissions: number;
+    version: string;
+}
+
+export declare const ResizeModeControl: (() => JSX.Element) & {
+    displayName: 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
+}
+
+export declare class SnapshotControl extends React_2.Component {
+    static contextType: React_2.Context<PlayerController>;
+    get player(): PlayerController;
+    getSnapshot: () => void;
+    render(): JSX.Element;
+}
+
+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 declare function useFullscreen(): {
+    ref: (node: HTMLElement | null) => void;
+    toggle: () => undefined;
+    enabled: boolean;
+    active: boolean;
+};
+
+declare enum VideoResizeMode {
+    Fit = "contain",
+    Stretch = "fill"
+}
+
+export declare const VolumeControl: (() => JSX.Element) & {
+    displayName: string;
+};
+
+export { }