easyproctor-hml 2.3.2 → 2.4.0

package/new-flow/checkers/DeviceCheckerUI.d.ts

@@ -1,51 +1,51 @@
-import { ProctoringSessionOptions } from "../../proctoring/options/ProctoringOptions";
-import { ProctoringVideoOptions } from "../../proctoring/options/ProctoringVideoOptions";
-import { CameraRecorder } from "../recorders/CameraRecorder";
-import { VolumeMeter } from "../recorders/VolumeMeter";
-export interface checkDevicesInterfaceReturn {
-    cameraId: string;
-    microphoneId: string;
-    result: boolean;
-}
-export declare class DeviceCheckerUI {
-    options: ProctoringSessionOptions;
-    videoOptions: ProctoringVideoOptions;
-    cameraRecorder: CameraRecorder;
-    volumeMeter: VolumeMeter | undefined;
-    constructor(options: ProctoringSessionOptions | undefined, _videoOptions: ProctoringVideoOptions);
-    checkDevicesInterface(): void;
-    setSelectOption(options: ProctoringSessionOptions, changeSelectedDevice: (arg0: {
-        cameras: any;
-        microphones: any;
-    } | {
-        cameras: HTMLSelectElement | null;
-        microphones: HTMLSelectElement | null;
-    }) => any): Promise<void>;
-    onSelectOptionChange(changeSelectedDevice: {
-        (e: any): any;
-        (arg0: {
-            cameraId: string | undefined;
-            microphoneId: string | undefined;
-        }): any;
-    }): Promise<void>;
-    closeModal(): void;
-    modalActions(closeCheckDevices: {
-        (): Promise<void>;
-        (): void;
-    }): Promise<checkDevicesInterfaceReturn>;
-    realtimeAlertsUI(response: {
-        status: string;
-        description: string;
-        type?: string;
-    }): void;
-    waitingSpyDevices(waiting: boolean): void;
-    isSpyDevicesUI(allowedDevices: boolean): void;
-    isUnderResolutionUI(allowedResolution: boolean): void;
-    videoDeviceInterfaceUI(stream: MediaStream): void;
-    audioDeviceInterfaceUIAllowedAmbient(allowedAmbient: boolean): void;
-    audioDeviceInterfaceUIMicrophoneWorks(microphoneWorks: boolean): void;
-    audioDeviceInterfaceUIErrorExec(): void;
-    audioDeviceInterfaceUIPills(value: number): void;
-    addStyleMask(): Promise<void>;
-    applyStyles(element: any, styles: any): void;
-}
+import { ProctoringSessionOptions } from "../../proctoring/options/ProctoringOptions";
+import { ProctoringVideoOptions } from "../../proctoring/options/ProctoringVideoOptions";
+import { CameraRecorder } from "../recorders/CameraRecorder";
+import { VolumeMeter } from "../recorders/VolumeMeter";
+export interface checkDevicesInterfaceReturn {
+    cameraId: string;
+    microphoneId: string;
+    result: boolean;
+}
+export declare class DeviceCheckerUI {
+    options: ProctoringSessionOptions;
+    videoOptions: ProctoringVideoOptions;
+    cameraRecorder: CameraRecorder;
+    volumeMeter: VolumeMeter | undefined;
+    constructor(options: ProctoringSessionOptions | undefined, _videoOptions: ProctoringVideoOptions);
+    checkDevicesInterface(): void;
+    setSelectOption(options: ProctoringSessionOptions, changeSelectedDevice: (arg0: {
+        cameras: any;
+        microphones: any;
+    } | {
+        cameras: HTMLSelectElement | null;
+        microphones: HTMLSelectElement | null;
+    }) => any): Promise<void>;
+    onSelectOptionChange(changeSelectedDevice: {
+        (e: any): any;
+        (arg0: {
+            cameraId: string | undefined;
+            microphoneId: string | undefined;
+        }): any;
+    }): Promise<void>;
+    closeModal(): void;
+    modalActions(closeCheckDevices: {
+        (): Promise<void>;
+        (): void;
+    }): Promise<checkDevicesInterfaceReturn>;
+    realtimeAlertsUI(response: {
+        status: string;
+        description: string;
+        type?: string;
+    }): void;
+    waitingSpyDevices(waiting: boolean): void;
+    isSpyDevicesUI(allowedDevices: boolean): void;
+    isUnderResolutionUI(allowedResolution: boolean): void;
+    videoDeviceInterfaceUI(stream: MediaStream): void;
+    audioDeviceInterfaceUIAllowedAmbient(allowedAmbient: boolean): void;
+    audioDeviceInterfaceUIMicrophoneWorks(microphoneWorks: boolean): void;
+    audioDeviceInterfaceUIErrorExec(): void;
+    audioDeviceInterfaceUIPills(value: number): void;
+    addStyleMask(): Promise<void>;
+    applyStyles(element: any, styles: any): void;
+}

package/new-flow/download/IDownloadService.d.ts

@@ -1,4 +1,4 @@
-import UploadDataDTO from "../../dtos/UploadDataDTO";
-export interface IDownloadService {
-    upload(data: UploadDataDTO, token: string): any;
-}
+import UploadDataDTO from "../../dtos/UploadDataDTO";
+export interface IDownloadService {
+    upload(data: UploadDataDTO, token: string): any;
+}

package/new-flow/download/downloadService.d.ts

@@ -1,9 +1,9 @@
-import UploadDataDTO from "../../dtos/UploadDataDTO";
-import { IDownloadService } from "./IDownloadService";
-export declare class DownloadService implements IDownloadService {
-    private readonly proctoringId;
-    constructor(proctoringId: string);
-    loadingBoolean: boolean;
-    loadingInterval: any;
-    upload(data: UploadDataDTO, token: string): Promise<void>;
-}
+import UploadDataDTO from "../../dtos/UploadDataDTO";
+import { IDownloadService } from "./IDownloadService";
+export declare class DownloadService implements IDownloadService {
+    private readonly proctoringId;
+    constructor(proctoringId: string);
+    loadingBoolean: boolean;
+    loadingInterval: any;
+    upload(data: UploadDataDTO, token: string): Promise<void>;
+}

package/new-flow/proctoring/ProctoringRecorder.d.ts

@@ -1,12 +1,12 @@
-import { IRecorder } from "../recorders/IRecorder";
-import { ProctoringSession } from "./ProctoringSession";
-export declare class ProctoringRecorder {
-    private session;
-    private recorders;
-    constructor(session: ProctoringSession, recorders: IRecorder[]);
-    startAll(): Promise<void>;
-    pauseAll(): Promise<void>;
-    resumeAll(): Promise<void>;
-    stopAll(): Promise<void>;
-    saveAllOnSession(): Promise<void>;
-}
+import { IRecorder } from "../recorders/IRecorder";
+import { ProctoringSession } from "./ProctoringSession";
+export declare class ProctoringRecorder {
+    private session;
+    private recorders;
+    constructor(session: ProctoringSession, recorders: IRecorder[]);
+    startAll(): Promise<void>;
+    pauseAll(): Promise<void>;
+    resumeAll(): Promise<void>;
+    stopAll(): Promise<void>;
+    saveAllOnSession(): Promise<void>;
+}

package/new-flow/proctoring/ProctoringSession.d.ts

@@ -1,65 +1,66 @@
-export declare enum SessionState {
-    Created = "Created",
-    Recording = "Recording",
-    Paused = "Paused",
-    Ended = "Ended",
-    EndConfirmed = "EndConfirmed",
-    Uploaded = "Uploaded",
-    UploadConfirmed = "UploadConfirmed"
-}
-export declare enum StorageService {
-    none = "upload"
-}
-export declare enum RecordingOrigin {
-    Screen = "Screen",
-    Mic = "Mic",
-    Camera = "Camera"
-}
-export declare enum AlertCategory {
-    LostFocus = 25,
-    PotentialCamera = 32,
-    SpyDeviceDisconnected = 33
-}
-export declare enum AlertType {
-    Audio = 1,
-    Video = 2,
-    Screen = 3,
-    Image = 4,
-    Environment = 5
-}
-export interface Alert {
-    begin: number;
-    end: number;
-    alert: AlertCategory;
-    type: AlertType;
-}
-export interface Recording {
-    origin: RecordingOrigin;
-    file: File;
-    device: string;
-    upload?: {
-        storage: StorageService;
-        azureUrl: string;
-        awsUrl: string;
-    };
-}
-export declare class ProctoringSession {
-    id: string;
-    state: SessionState;
-    startedAt: Date;
-    sessionDuration: number;
-    alerts: Alert[];
-    recordings: Recording[];
-    get hasSomethingToUpload(): boolean;
-    constructor();
-    start(): void;
-    pause(): void;
-    resume(): void;
-    stop(): void;
-    setProctoringId(proctoringId: string): void;
-    setEndConfirmed(): void;
-    setUploaded(): void;
-    setUploadConfirmed(): void;
-    addAlert(alert: Alert): void;
-    addRecording(rec: Recording): void;
-}
+export declare enum SessionState {
+    Created = "Created",
+    Recording = "Recording",
+    Paused = "Paused",
+    Ended = "Ended",
+    EndConfirmed = "EndConfirmed",
+    Uploaded = "Uploaded",
+    UploadConfirmed = "UploadConfirmed"
+}
+export declare enum StorageService {
+    none = "upload"
+}
+export declare enum RecordingOrigin {
+    Screen = "Screen",
+    Mic = "Mic",
+    Camera = "Camera"
+}
+export declare enum AlertCategory {
+    LostFocus = 25,
+    PotentialCamera = 32,
+    SpyDeviceDisconnected = 33,
+    StopSharingScreen = 34
+}
+export declare enum AlertType {
+    Audio = 1,
+    Video = 2,
+    Screen = 3,
+    Image = 4,
+    Environment = 5
+}
+export interface Alert {
+    begin: number;
+    end: number;
+    alert: AlertCategory;
+    type: AlertType;
+}
+export interface Recording {
+    origin: RecordingOrigin;
+    file: File;
+    device: string;
+    upload?: {
+        storage: StorageService;
+        azureUrl: string;
+        awsUrl: string;
+    };
+}
+export declare class ProctoringSession {
+    id: string;
+    state: SessionState;
+    startedAt: Date;
+    sessionDuration: number;
+    alerts: Alert[];
+    recordings: Recording[];
+    get hasSomethingToUpload(): boolean;
+    constructor();
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    setProctoringId(proctoringId: string): void;
+    setEndConfirmed(): void;
+    setUploaded(): void;
+    setUploadConfirmed(): void;
+    addAlert(alert: Alert): void;
+    addRecording(rec: Recording): void;
+}

package/new-flow/proctoring/ProctoringUploader.d.ts

@@ -1,14 +1,14 @@
-import { IDownloadService } from "../download/IDownloadService";
-import { IUploadService } from "../upload/IUploadService";
-import { ProgressCallback } from "../upload/uploadCalback";
-import { ProctoringSession } from "./ProctoringSession";
-export declare class ProctoringUploader {
-    private session;
-    private proctoringId;
-    private uploadServices;
-    constructor(session: ProctoringSession, proctoringId: string, uploadServices: IUploadService[] | IDownloadService[]);
-    upload(token: string, progress?: ProgressCallback): Promise<void>;
-    private uploadRecordings;
-    private uploadAllFiles;
-    private uploadFile;
-}
+import { IDownloadService } from "../download/IDownloadService";
+import { IUploadService } from "../upload/IUploadService";
+import { ProgressCallback } from "../upload/uploadCalback";
+import { ProctoringSession } from "./ProctoringSession";
+export declare class ProctoringUploader {
+    private session;
+    private proctoringId;
+    private uploadServices;
+    constructor(session: ProctoringSession, proctoringId: string, uploadServices: IUploadService[] | IDownloadService[]);
+    upload(token: string, progress?: ProgressCallback): Promise<void>;
+    private uploadRecordings;
+    private uploadAllFiles;
+    private uploadFile;
+}

package/new-flow/recorders/AlertRecorder.d.ts

@@ -1,21 +1,25 @@
-import { ProctoringSessionOptions } from "../../proctoring/options/ProctoringOptions";
-import { ProctoringSession } from "../proctoring/ProctoringSession";
-import { IRecorder } from "./IRecorder";
-export declare class AlertRecorder implements IRecorder {
-    private alerts;
-    private startTime;
-    private onLostFocusCallback;
-    private onFocusCallback;
-    private optionsProctoring;
-    constructor(options: {
-        onLostFocusCallback: () => void;
-        onFocusCallback: () => void;
-    }, optionsProctoring: ProctoringSessionOptions);
-    startRecording(): Promise<void>;
-    pauseRecording(): Promise<void>;
-    resumeRecording(): Promise<void>;
-    stopRecording(): Promise<void>;
-    saveOnSession(session: ProctoringSession): Promise<void>;
-    private onLostFocus;
-    private onReturnFocus;
-}
+import { ProctoringSessionOptions } from "../../proctoring/options/ProctoringOptions";
+import { AlertCategory, AlertType, ProctoringSession } from "../proctoring/ProctoringSession";
+import { IRecorder } from "./IRecorder";
+export declare class AlertRecorder implements IRecorder {
+    private alerts;
+    private startTime;
+    private onLostFocusCallback;
+    private onFocusCallback;
+    private optionsProctoring;
+    constructor(options: {
+        onLostFocusCallback: () => void;
+        onFocusCallback: () => void;
+    }, optionsProctoring: ProctoringSessionOptions);
+    startRecording(): Promise<void>;
+    pauseRecording(): Promise<void>;
+    resumeRecording(): Promise<void>;
+    stopRecording(): Promise<void>;
+    saveOnSession(session: ProctoringSession): Promise<void>;
+    private onLostFocus;
+    private onReturnFocus;
+    addAlert({ alert, type }: {
+        alert: AlertCategory;
+        type: AlertType;
+    }): void;
+}

package/new-flow/recorders/AudioRecorder.d.ts

@@ -1,24 +1,24 @@
-import { ProctoringSession } from "../proctoring/ProctoringSession";
-import { IRecorder } from "./IRecorder";
-import { AudioBehaviourParameters } from "../../interfaces/ParamsConfig";
-export declare class AudioRecorder implements IRecorder {
-    blobs: Blob[];
-    recorder?: any;
-    audioStream: MediaStream;
-    private options;
-    private audioParams;
-    constructor(options?: {
-        cameraId?: string;
-        microphoneId?: string;
-    }, audioParams?: AudioBehaviourParameters);
-    recordingStart: () => any;
-    recordingStop: () => any;
-    recordingPause: () => any;
-    recordingResume: () => any;
-    file?: File;
-    startRecording(): Promise<void>;
-    pauseRecording(): Promise<void>;
-    resumeRecording(): Promise<void>;
-    stopRecording(): Promise<void>;
-    saveOnSession(session: ProctoringSession, start?: number, end?: number): Promise<void>;
-}
+import { ProctoringSession } from "../proctoring/ProctoringSession";
+import { IRecorder } from "./IRecorder";
+import { AudioBehaviourParameters } from "../../interfaces/ParamsConfig";
+export declare class AudioRecorder implements IRecorder {
+    blobs: Blob[];
+    recorder?: any;
+    audioStream: MediaStream;
+    private options;
+    private audioParams;
+    constructor(options?: {
+        cameraId?: string;
+        microphoneId?: string;
+    }, audioParams?: AudioBehaviourParameters);
+    recordingStart: () => any;
+    recordingStop: () => any;
+    recordingPause: () => any;
+    recordingResume: () => any;
+    file?: File;
+    startRecording(): Promise<void>;
+    pauseRecording(): Promise<void>;
+    resumeRecording(): Promise<void>;
+    stopRecording(): Promise<void>;
+    saveOnSession(session: ProctoringSession, start?: number, end?: number): Promise<void>;
+}

package/new-flow/recorders/CameraRecorder.d.ts

@@ -1,69 +1,69 @@
-import { RecordRTCPromisesHandler } from "recordrtc";
-import { ProctoringSession } from "../proctoring/ProctoringSession";
-import { IRecorder } from "./IRecorder";
-import { BackendService } from "../backend/BackendService";
-import { UploadService } from "../upload/UploadService";
-import IParamsConfig from "../../interfaces/ParamsConfig";
-import { ProctoringVideoOptions } from "../../proctoring/options/ProctoringVideoOptions";
-import { DevicesChanged } from "../../interfaces/Devices";
-import { ObjectDetection } from "../../modules/objectDetection";
-import { FaceDetection } from "../../modules/faceDetection";
-export declare class CameraRecorder implements IRecorder {
-    private blobs;
-    private paramsConfig;
-    private options;
-    private videoOptions;
-    private blobsRTC;
-    recorder: RecordRTCPromisesHandler;
-    cameraStream: MediaStream;
-    imageCount: number;
-    imageCapture: any;
-    imageInterval: any;
-    sendFrameInterval: any;
-    backend: BackendService | undefined;
-    backendToken: string | undefined;
-    proctoringId: string | undefined;
-    private recorderOptions;
-    upload: UploadService | undefined;
-    video: HTMLVideoElement;
-    canvas: HTMLCanvasElement;
-    faceDetection: FaceDetection;
-    objectDetection: ObjectDetection;
-    filesToUpload: File[];
-    private intervalNoiseDetection;
-    private volumeMeter;
-    constructor(options: {
-        cameraId?: string;
-        microphoneId?: string;
-        onBufferSizeError?: boolean;
-        onBufferSizeErrorCallback: (cameraStream?: any) => void;
-        proctoringType?: "VIDEO" | "IMAGE" | "REALTIME";
-        onChangeDevicesCallback?: (devices: DevicesChanged) => void;
-        onRealtimeAlertsCallback?: (response: any) => void;
-    }, videoOptions: ProctoringVideoOptions, paramsConfig?: IParamsConfig, backend?: BackendService, backendToken?: string);
-    file?: File;
-    recordingStart: () => any;
-    recordingStop: () => any;
-    recordingPause: () => any;
-    recordingResume: () => any;
-    getBufferSize: () => any;
-    setProctoringId(proctoringId: string): void;
-    initializeDetectors(): Promise<void>;
-    configImageCapture(): void;
-    currentRetries: number;
-    bufferError(e: any): Promise<void>;
-    startRecording(options?: {
-        retry?: boolean;
-    }): Promise<void>;
-    stopRecording(): Promise<void>;
-    pauseRecording(): Promise<void>;
-    resumeRecording(): Promise<void>;
-    photoShotsCycle(): void;
-    captureFrame(): void;
-    sendFrame(): void;
-    download(file: File): void;
-    saveOnSession(session: ProctoringSession): Promise<void>;
-    getFile(file: string, name: string, type: string): Promise<File>;
-    noiseWait: number;
-    private onNoiseDetected;
-}
+import { RecordRTCPromisesHandler } from "recordrtc";
+import { ProctoringSession } from "../proctoring/ProctoringSession";
+import { IRecorder } from "./IRecorder";
+import { BackendService } from "../backend/BackendService";
+import { UploadService } from "../upload/UploadService";
+import IParamsConfig from "../../interfaces/ParamsConfig";
+import { ProctoringVideoOptions } from "../../proctoring/options/ProctoringVideoOptions";
+import { DevicesChanged } from "../../interfaces/Devices";
+import { ObjectDetection } from "../../modules/objectDetection";
+import { FaceDetection } from "../../modules/faceDetection";
+export declare class CameraRecorder implements IRecorder {
+    private blobs;
+    private paramsConfig;
+    private options;
+    private videoOptions;
+    private blobsRTC;
+    recorder: RecordRTCPromisesHandler;
+    cameraStream: MediaStream;
+    imageCount: number;
+    imageCapture: any;
+    imageInterval: any;
+    sendFrameInterval: any;
+    backend: BackendService | undefined;
+    backendToken: string | undefined;
+    proctoringId: string | undefined;
+    private recorderOptions;
+    upload: UploadService | undefined;
+    video: HTMLVideoElement;
+    canvas: HTMLCanvasElement;
+    faceDetection: FaceDetection;
+    objectDetection: ObjectDetection;
+    filesToUpload: File[];
+    private intervalNoiseDetection;
+    private volumeMeter;
+    constructor(options: {
+        cameraId?: string;
+        microphoneId?: string;
+        onBufferSizeError?: boolean;
+        onBufferSizeErrorCallback: (cameraStream?: any) => void;
+        proctoringType?: "VIDEO" | "IMAGE" | "REALTIME";
+        onChangeDevicesCallback?: (devices: DevicesChanged) => void;
+        onRealtimeAlertsCallback?: (response: any) => void;
+    }, videoOptions: ProctoringVideoOptions, paramsConfig?: IParamsConfig, backend?: BackendService, backendToken?: string);
+    file?: File;
+    recordingStart: () => any;
+    recordingStop: () => any;
+    recordingPause: () => any;
+    recordingResume: () => any;
+    getBufferSize: () => any;
+    setProctoringId(proctoringId: string): void;
+    initializeDetectors(): Promise<void>;
+    configImageCapture(): void;
+    currentRetries: number;
+    bufferError(e: any): Promise<void>;
+    startRecording(options?: {
+        retry?: boolean;
+    }): Promise<void>;
+    stopRecording(): Promise<void>;
+    pauseRecording(): Promise<void>;
+    resumeRecording(): Promise<void>;
+    photoShotsCycle(): void;
+    captureFrame(): void;
+    sendFrame(): void;
+    download(file: File): void;
+    saveOnSession(session: ProctoringSession): Promise<void>;
+    getFile(file: string, name: string, type: string): Promise<File>;
+    noiseWait: number;
+    private onNoiseDetected;
+}

package/new-flow/recorders/IRecorder.d.ts

@@ -1,12 +1,12 @@
-import { ProctoringSession } from "../proctoring/ProctoringSession";
-export declare enum RecordingType {
-}
-export interface IRecorder {
-    startRecording(options?: {
-        retry?: boolean;
-    }): Promise<void>;
-    pauseRecording(): Promise<void>;
-    resumeRecording(): Promise<void>;
-    stopRecording(): Promise<void>;
-    saveOnSession(session: ProctoringSession): Promise<void>;
-}
+import { ProctoringSession } from "../proctoring/ProctoringSession";
+export declare enum RecordingType {
+}
+export interface IRecorder {
+    startRecording(options?: {
+        retry?: boolean;
+    }): Promise<void>;
+    pauseRecording(): Promise<void>;
+    resumeRecording(): Promise<void>;
+    stopRecording(): Promise<void>;
+    saveOnSession(session: ProctoringSession): Promise<void>;
+}