@idscan/idvc2 2.5.6 → 2.5.7

package/dist/types/modules/ui/Modal.d.ts

@@ -0,0 +1,20 @@
+interface DestructedOptions {
+    isMobile: boolean;
+    background: HTMLDivElement;
+    containerId: string;
+    mainId?: string;
+    doneBtnId: string;
+    cancelBtnId: string;
+}
+declare class Modal {
+    private background;
+    container: HTMLDivElement;
+    doneBtn: HTMLButtonElement;
+    cancelBtn: HTMLButtonElement;
+    constructor(opts: DestructedOptions);
+    addDoneHandler(handler: (e?: Event) => void): void;
+    addCancelHandler(handler: (e?: Event) => void): void;
+    hide(): void;
+    show(): void;
+}
+export default Modal;

package/dist/types/modules/ui/SelectDocumentType.d.ts

@@ -0,0 +1,37 @@
+import Modal from './Modal';
+import { DocumentRecord, DocumentTypeIndex, DocumentTypeName, HumanName } from '../../environment/documentTypes';
+import { ModalPositionKeys } from '../../environment/modalPosition';
+interface DocumentTypeElement {
+    name: DocumentTypeName;
+    element: HTMLLabelElement;
+    id: DocumentTypeIndex;
+    nName?: string;
+}
+interface ISpinner {
+    addSpinnerState: () => void;
+    showSpinner: () => void;
+    removeSpinnerState: () => void;
+    clearState: () => void;
+    hideSpinner: () => void;
+}
+declare class SelectDocumentType extends Modal {
+    private list;
+    elementsList: DocumentTypeElement[];
+    private cancelButtonContainer;
+    private doneButtonContainer;
+    private spinner;
+    constructor(isMobile: boolean, background: HTMLDivElement, spinner: ISpinner, modalPositionClass: ModalPositionKeys);
+    show(): void;
+    hide(): void;
+    showCancelButton(): void;
+    hideCancelButton(): void;
+    addDoneHandler(handler: (e?: Event) => void): void;
+    addCancelHandler(handler: (e?: Event) => void): void;
+    createElement: (docType: DocumentTypeName, humanName: HumanName) => HTMLLabelElement;
+    hasElement(docType: DocumentTypeName): boolean;
+    addElement(docType: DocumentTypeName, element: HTMLLabelElement, id: DocumentTypeIndex): void;
+    clearList(): void;
+    addType({ name: docType, humanName, id }: DocumentRecord): void;
+    render(): void;
+}
+export default SelectDocumentType;

package/dist/types/modules/ui/canvas.d.ts

@@ -0,0 +1,48 @@
+import { IOffset, ISize } from '../../helpers/image';
+import { Bbox } from '../../types/geometry';
+export default class CanvasUi {
+    canvasNames: Set<string>;
+    canvasCtxNames: Set<string>;
+    videoCanvas: HTMLCanvasElement;
+    resizedCanvas: HTMLCanvasElement;
+    mrzCanvas: HTMLCanvasElement;
+    borderCanvas: HTMLCanvasElement;
+    faceCanvas: HTMLCanvasElement;
+    classLocalCanvas: HTMLCanvasElement;
+    blazeFaceCanvas: HTMLCanvasElement;
+    meshFaceCanvas: HTMLCanvasElement;
+    mrzCtx: CanvasRenderingContext2D;
+    videoCtx: CanvasRenderingContext2D;
+    resizedCtx: CanvasRenderingContext2D;
+    borderCtx: CanvasRenderingContext2D;
+    faceCtx: CanvasRenderingContext2D;
+    classLocalCtx: CanvasRenderingContext2D;
+    blazeFaceCtx: CanvasRenderingContext2D;
+    meshFaceCtx: CanvasRenderingContext2D;
+    video: HTMLVideoElement;
+    faceOffset: IOffset;
+    constructor(video: HTMLVideoElement);
+    saveCanvas(): void;
+    restoreCanvas(): void;
+    toggleBorderCanvas(): void;
+    clearBorderCtx(): void;
+    setVideoCanvasSizes({ width, height }: ISize): void;
+    getBaseSizes(coefficient?: number): {
+        baseHeight: number;
+        baseWidth: number;
+    };
+    setResizedCanvas(): void;
+    setBorderCanvas(width: number, height: number): void;
+    recreateCanvas(canvas: HTMLCanvasElement): {
+        canvas: HTMLCanvasElement;
+        ctx: CanvasRenderingContext2D;
+    };
+    rectreateDistinctCanvas(canvasName: string): void;
+    prepareFaceCanvas(width: number, height: number): void;
+    drawVideo(): void;
+    drawResized(): void;
+    drawFace(): void;
+    recreateWorkingCanvas(): void;
+    drawResizedVideo(): void;
+    drawBbox(bbox: Bbox): void;
+}

package/dist/types/modules/ui/forceCaptruringBtn.d.ts

@@ -0,0 +1,12 @@
+type EventCallback = (e?: Event) => void;
+declare class ForceCapturingButton {
+    private isShowing;
+    private el;
+    private callback;
+    constructor();
+    get state(): boolean;
+    set state(val: boolean);
+    addClickCallback(cbl: EventCallback): void;
+    setAvailable(status: boolean): void;
+}
+export default ForceCapturingButton;

package/dist/types/modules/ui/hints.d.ts

@@ -0,0 +1,17 @@
+import { RealFaceTurnSide } from '../../types/enums/realFace';
+declare class UiHints {
+    static holdText: HTMLSpanElement;
+    static arrowUpHintContainer: HTMLDivElement;
+    static arrowLeftHintContainer: HTMLDivElement;
+    static arrowRightHintContainer: HTMLDivElement;
+    static arrowLeftFaceTheCameraContainer: HTMLDivElement;
+    static arrowRightFaceTheCameraContainer: HTMLDivElement;
+    static currentArrowContainer: HTMLDivElement | null;
+    static init(): void;
+    static showFaceTheCameraArrows(): void;
+    static hideFaceTheCameraArrows(): void;
+    static showArrow(arrowNumber: RealFaceTurnSide, data: any, isCorrectDirection: any): void;
+    static hideArrows(): void;
+    static updateHoldText(data?: number, isCorrectDirection?: boolean): string;
+}
+export default UiHints;

package/dist/types/modules/ui/limitations.d.ts

@@ -0,0 +1,2 @@
+export declare const showLimitations: (errorText: any) => void;
+export declare const hideLimitations: () => void;

package/dist/types/modules/ui/manualSwitchBtn.d.ts

@@ -0,0 +1,30 @@
+import { IStepModeKeys } from '../../defaultConfig';
+type EventCallback = (e?: Event) => void;
+export interface IManualSwitchBtn {
+    el: HTMLButtonElement | null;
+    loadingEl: HTMLDivElement | null;
+    containerEl: HTMLDivElement | null;
+    state: IStepModeKeys | null;
+    callback: EventCallback | null;
+    setLoading(status: boolean): void;
+    setEnabled(status: boolean): void;
+    setAvailable(status: boolean): void;
+    setState(state: IStepModeKeys): void;
+    addClickCallback(cbl: EventCallback): void;
+    setText(): void;
+}
+declare class ManualSwitchBtn implements IManualSwitchBtn {
+    el: any;
+    loadingEl: any;
+    containerEl: any;
+    state: any;
+    callback: any;
+    constructor(cameraSupported: boolean);
+    setLoading(status: boolean): void;
+    setEnabled(status: boolean): void;
+    setAvailable(status: boolean): void;
+    setText(): void;
+    setState(state: IStepModeKeys): void;
+    addClickCallback(cbl: EventCallback): void;
+}
+export default ManualSwitchBtn;

package/dist/types/modules/ui/selectDocumentType/documentSelectedEvent.d.ts

@@ -0,0 +1,7 @@
+import { DocumentTypeIndex, DocumentTypeName } from '../../../environment/documentTypes';
+export interface DocumentSelectEvent {
+    docType: DocumentTypeName;
+    id: 0 | DocumentTypeIndex;
+}
+declare const _default: ({ docType, id }: DocumentSelectEvent) => CustomEvent<DocumentSelectEvent>;
+export default _default;

package/dist/types/modules/ui/spinner.d.ts

@@ -0,0 +1,13 @@
+export declare const addSpinnerState: (bottomText?: string, topText?: string) => void;
+export declare const removeSpinnerState: () => void;
+export declare const clearState: () => void;
+export declare const showSpinner: () => void;
+export declare const hideSpinner: () => void;
+declare const _default: {
+    addSpinnerState: (bottomText?: string, topText?: string) => void;
+    removeSpinnerState: () => void;
+    clearState: () => void;
+    showSpinner: () => void;
+    hideSpinner: () => void;
+};
+export default _default;

package/dist/types/modules/ui/swiper.d.ts

@@ -0,0 +1,3 @@
+import { SwiperCallback } from '../../types/modules/ui/swiper';
+declare const init: (el: HTMLElement, cbk: SwiperCallback) => void;
+export default init;

package/dist/types/modules/uploader.d.ts

@@ -0,0 +1,58 @@
+import { StepType } from '../environment/stepsDescription';
+import { Base64Image } from '../helpers/image';
+type SubmitHandler = (base64Obj: Base64Object) => Promise<void>;
+interface Base64Object {
+    data: ImageData | Base64Image | null;
+    err: boolean;
+}
+interface ISmallStep {
+    type: StepType;
+    img: Base64Image | null;
+    name?: string;
+    errorCode?: string | null | undefined;
+}
+declare class Uploader {
+    private onsubmit;
+    private onHandle;
+    private states;
+    private readonly types;
+    private dropArea;
+    private dropAreaBackground;
+    private fileInput;
+    private stepName;
+    private errorTextEl;
+    private pressToUpdate;
+    private readonly translation;
+    protected textFront: HTMLElement;
+    protected textBack: HTMLElement;
+    protected textFace: HTMLElement;
+    protected textPdf: HTMLElement;
+    protected textMrz: HTMLElement;
+    protected textFrontBack: HTMLElement;
+    protected textPass: HTMLElement;
+    protected textFacePosition: HTMLElement;
+    private moduleController;
+    private addedFileTypes;
+    constructor(uploaderId: string, type: ISmallStep, onsubmit: SubmitHandler, onHandle: () => void, moduleController: any, addedFileTypes: string[]);
+    checkType(typeForCheck: string): string | false;
+    handleFiles(data: {
+        target: {
+            files: FileList;
+        };
+    } | Event): void;
+    setText(): void;
+    /**
+     *
+     * @param {string} errorCode
+     */
+    showError(errorCode: string): void;
+    clearStates(): void;
+    resetInput(): void;
+    highlight(): void;
+    unhighlight(): void;
+    handleDrop(e: DragEvent): void;
+    changeType(step: ISmallStep): void;
+    transition(): void;
+    setDisabled(val: boolean): void;
+}
+export default Uploader;

package/dist/types/modules/validation/ValidateBool.d.ts

@@ -0,0 +1,5 @@
+import { IValidator } from '../validator';
+declare class ValidateBool implements IValidator<boolean> {
+    validate(val: any, fallback: boolean, configName: string): boolean;
+}
+export default ValidateBool;

package/dist/types/modules/validation/ValidateDocumentTypes.d.ts

@@ -0,0 +1,20 @@
+import { IDocumentType } from '../../defaultConfig';
+import { DocumentTypeName } from '../../environment/documentTypes';
+import { StepType } from '../../environment/stepsDescription';
+import { IDocumentTypeConfig, IValidator } from '../validator';
+declare class ValidateDocumentTypes implements IValidator<IDocumentType[]> {
+    types: any[];
+    steps: any[];
+    commonStepTypes: Set<StepType>;
+    documentTypes: IDocumentTypeConfig;
+    validate(val: IDocumentType[], fallback: IDocumentType[], configName: 'documentTypes'): {
+        types: any[];
+        steps: any[];
+        commonStepTypes: Set<StepType>;
+        documentTypes: IDocumentTypeConfig;
+    };
+    validateTypes(types: string[]): DocumentTypeName[];
+    transformDocType({ type, steps }: IDocumentType): void;
+    setCommonStepTypes(): void;
+}
+export default ValidateDocumentTypes;

package/dist/types/modules/validation/ValidateElement.d.ts

@@ -0,0 +1,5 @@
+import { IValidator } from '../validator';
+declare class ValidateElement implements IValidator<string> {
+    validate(elId: string, defaultValue: string): string;
+}
+export default ValidateElement;

package/dist/types/modules/validation/ValidateFunction.d.ts

@@ -0,0 +1,5 @@
+import { IValidator } from '../validator';
+declare class ValidateFunction implements IValidator<(arg?: undefined) => boolean> {
+    validate(val: any, fallback: (arg?: undefined) => boolean, configName: string): any;
+}
+export default ValidateFunction;

package/dist/types/modules/validation/ValidateNumber.d.ts

@@ -0,0 +1,5 @@
+import { IValidator } from '../validator';
+declare class ValidateNumber implements IValidator<number> {
+    validate(val: number, fallback: number, configName: string): number;
+}
+export default ValidateNumber;

package/dist/types/modules/validation/ValidateString.d.ts

@@ -0,0 +1,5 @@
+import { IValidator } from '../validator';
+declare class ValidateString implements IValidator<string> {
+    validate(val: string, fallback: string, configName: string): string;
+}
+export default ValidateString;

package/dist/types/modules/validation/ValidateStringInArray.d.ts

@@ -0,0 +1,12 @@
+import { IValidator } from '../validator';
+declare class ValidateDistinctStringInArray implements IValidator<string> {
+    /**
+     * validates string in given array and set its value
+     * @param {String} valueToSet - value that should be set
+     * @param {String} defaultValue - fallback if value is not in given array
+     * @param {String} configName - name of config
+     * @param {String[]} availableValues - array of available values
+     */
+    validate(valueToSet: string, defaultValue: string, configName: string, availableValues: string[]): string;
+}
+export default ValidateDistinctStringInArray;

package/dist/types/modules/validation/showValidationError.d.ts

@@ -0,0 +1,2 @@
+declare const showError: (configName: string, fallback: any) => void;
+export default showError;

package/dist/types/modules/validation/validatorFactory.d.ts

@@ -0,0 +1,10 @@
+import { ValidationFn } from '../../defaultConfig';
+import ValidateElement from './ValidateElement';
+import ValidateBool from './ValidateBool';
+import ValidateDistinctStringInArray from './ValidateStringInArray';
+import ValidateDocumentTypes from './ValidateDocumentTypes';
+import ValidateFunction from './ValidateFunction';
+import ValidateNumber from './ValidateNumber';
+import ValidateString from './ValidateString';
+declare const validatorFactory: (name: ValidationFn) => false | ValidateElement | ValidateBool | ValidateDistinctStringInArray | ValidateDocumentTypes | ValidateFunction | ValidateNumber | ValidateString;
+export default validatorFactory;

package/dist/types/modules/validator.d.ts

@@ -0,0 +1,12 @@
+import { DocumentTypeName } from '../environment/documentTypes';
+import { DefaultConfigName, IStepConfig } from '../defaultConfig';
+export type IDocumentTypeConfig = {
+    type: DocumentTypeName;
+    steps: IStepConfig[];
+}[];
+type SimpleValidate<T> = (val: T, fallback: T, configName: DefaultConfigName) => any;
+type OneOfArray<T> = (valueToSet: T, defaultValue: T, configName: DefaultConfigName, availableValues: T[]) => any;
+export interface IValidator<T> {
+    validate: SimpleValidate<T> | OneOfArray<T>;
+}
+export {};

package/dist/types/neural models/Provider.d.ts

@@ -0,0 +1,4 @@
+export declare enum Provider {
+    WASM = "wasm",
+    WEBGL = "webgl"
+}

package/dist/types/neural models/anglesModel.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="onnxruntime-web" />
+import { Provider } from './Provider';
+import NeuralModel from './neuralModel';
+import { RGBColor32 } from '../helpers/image';
+interface Prediction {
+    label: string;
+    score: number;
+}
+export default class AnglesModel extends NeuralModel {
+    constructor(url?: string, provider?: Provider, wasmPaths?: string);
+    predict(rgb: RGBColor32): Promise<import("onnxruntime-web").InferenceSession.OnnxValueMapType>;
+    predictFromImage(input: HTMLCanvasElement | HTMLImageElement, dstCanvas?: HTMLCanvasElement): Promise<Prediction[]>;
+    interpret(data: Float32Array): Prediction[];
+}
+export {};

package/dist/types/neural models/blazeFaceModel.d.ts

@@ -0,0 +1,27 @@
+import { Provider } from './Provider';
+import NeuralModel from './neuralModel';
+import { RGBColor32 } from '../helpers/image';
+import { BlazeFaceResult } from '../types/neural models/blazeFace';
+import { ICrop } from '../helpers/ts/common';
+export declare const ELEMENT_NUM_OF_ANCHOR = 16;
+export declare const ANCHOR_GRID_SIZE: readonly [readonly [16, 16], readonly [8, 8]];
+export declare const ANCHOR_NUM: readonly [2, 6];
+export default class BlazeFaceModel extends NeuralModel {
+    private anchorList;
+    private scoreList;
+    private regressorList;
+    private thresholdLogit;
+    private bBoxList;
+    private keyPoints;
+    private origSize;
+    constructor(url?: string, provider?: Provider, wasmPaths?: string);
+    createAnchor(): void;
+    processImage(crop: ICrop): BlazeFaceResult;
+    predict(rgb: RGBColor32): Promise<void>;
+    predictFromImage(input: HTMLCanvasElement | HTMLImageElement | HTMLVideoElement, dstCanvas?: HTMLCanvasElement): Promise<BlazeFaceResult>;
+    private getBoundingBoxes;
+    private calculateIoU;
+    private nms;
+    private fixInScreen;
+    private fillKeyPoints;
+}

package/dist/types/neural models/classLocal/exits.d.ts

@@ -0,0 +1,3 @@
+export type ClassLocalExitType = 'Back' | 'BackWithoutBarcode' | 'Front' | 'None';
+export declare const exits: ClassLocalExitType[];
+export default exits;

package/dist/types/neural models/classLocalModel.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="onnxruntime-web" />
+import NeuralModel from './neuralModel';
+import { Provider } from './Provider';
+import { RGBColor32 } from '../helpers/image';
+import { ClassLocalExitType } from './classLocal/exits';
+import { Bbox } from '../types/geometry';
+import { IOffset, ISize } from '../helpers/ts/common';
+/**
+ * perimeterInPercents: document perimeter in percents
+ */
+export interface InterpretClassLocalRes {
+    side: ClassLocalExitType;
+    bbox: Bbox;
+    perimeterInPercents: ISize;
+}
+interface Prediction {
+    label: ClassLocalExitType;
+    score: number;
+}
+export type PredictionList = Prediction[];
+export default class ClassLocalModel extends NeuralModel {
+    private canvasSize;
+    constructor(url?: string, provider?: Provider, wasmPaths?: string);
+    setSizes({ height, width }: ISize): void;
+    predict(rgb: RGBColor32): Promise<import("onnxruntime-web").InferenceSession.OnnxValueMapType>;
+    predictFromImage(input: HTMLCanvasElement | HTMLImageElement, dstCanvas?: HTMLCanvasElement, offsets?: IOffset, cropSizes?: ISize): Promise<any[] | InterpretClassLocalRes>;
+    interpret(classifierData: Float32Array, bboxData: Float32Array): InterpretClassLocalRes;
+}
+export {};

package/dist/types/neural models/meshFaceModel.d.ts

@@ -0,0 +1,17 @@
+import NeuralModel from './neuralModel';
+import { Provider } from './Provider';
+import { RGBColor32 } from '../helpers/image';
+import { IBoundingBbox, KeyPointList } from '../types/neural models/blazeFace';
+import { FaceMeshPrediction } from '../types/neural models/meshFace';
+import { ICrop, ISize } from '../helpers/ts/common';
+export default class MeshFaceModel extends NeuralModel {
+    origSize: ISize;
+    crop: ICrop;
+    landmarkList: Float32Array;
+    keypointList: KeyPointList;
+    constructor(url?: string, provider?: Provider, wasmPaths?: string);
+    preProcess(bbox: IBoundingBbox): void;
+    predict(rgb: RGBColor32): Promise<FaceMeshPrediction>;
+    prepareMesh(src: HTMLCanvasElement, dst: HTMLCanvasElement): ImageData;
+    predictFromImage(input: HTMLCanvasElement | HTMLImageElement, dstCanvas?: HTMLCanvasElement): Promise<FaceMeshPrediction>;
+}

package/dist/types/neural models/mrzModel.d.ts

@@ -0,0 +1,20 @@
+import { InferenceSession } from 'onnxruntime-web';
+import NeuralModel from './neuralModel';
+import { Provider } from './Provider';
+import { RGBColor32 } from '../helpers/image';
+interface Prediction {
+    value: string;
+    confidence: number;
+}
+export type PredictionList = Prediction[];
+export default class MrzModel extends NeuralModel {
+    promiseList: Promise<InferenceSession.OnnxValueMapType>[];
+    predictionList: PredictionList[];
+    constructor(url?: string, provider?: Provider, wasmPaths?: string);
+    predict(rgb: RGBColor32): Promise<InferenceSession.OnnxValueMapType>;
+    predictFromArray(input: Float32Array, batchSize: number): Promise<PredictionList[]>;
+    interpret(data: Float32Array): PredictionList;
+    get isLoading(): boolean;
+    predictFromImage(input: any, dstCanvas: any): void;
+}
+export {};

package/dist/types/neural models/neuralModel.d.ts

@@ -0,0 +1,18 @@
+import { InferenceSession } from 'onnxruntime-web';
+import { Provider } from './Provider';
+import { RGBColor32 } from '../helpers/image';
+declare abstract class NeuralModel {
+    private readonly model;
+    private readonly provider;
+    protected loading: boolean;
+    protected session: InferenceSession;
+    protected uri: string;
+    constructor(model?: string, provider?: Provider, url?: string);
+    prepareUri(url: string): void;
+    initWasmPath(): void;
+    initWasm(): Promise<void>;
+    init(): Promise<void>;
+    abstract predict(rgb: RGBColor32): any;
+    abstract predictFromImage(input: HTMLCanvasElement | HTMLImageElement, dstCanvas?: HTMLCanvasElement): unknown;
+}
+export default NeuralModel;

package/dist/types/neural models/preload.d.ts

@@ -0,0 +1,7 @@
+import NeuralModel from './neuralModel';
+import { RGBColor32 } from '../helpers/image';
+export default class Preload extends NeuralModel {
+    constructor(wasmPaths: any);
+    predict(rgb: RGBColor32): void;
+    predictFromImage(input: HTMLCanvasElement | HTMLImageElement, dstCanvas?: HTMLCanvasElement): unknown;
+}

package/dist/types/stepProcessing.d.ts

@@ -0,0 +1,27 @@
+export declare const generateSteps: () => void;
+export declare const updateSteps: () => void;
+export declare const changeStep: (nextStepNumber: number) => void;
+export declare const getNextStep: () => number;
+export declare const changeStepAuto: () => void;
+export declare const updateStepImgCallback: () => void;
+export declare const submitIfFullSteps: (payload?: {}) => void;
+export declare const resetStepResults: (stepIndex?: number) => void;
+export declare const again: () => void;
+export declare const setStepImage: () => Promise<void>;
+/**
+ * emits change function,
+ * emit change step function and
+ * emit submit function if all steps filled with image
+ * @param {Boolean} isNeedToChangeStep - is need to change step
+ */
+export declare const emitCurrentStepChangeImage: (isNeedToChangeStep?: boolean) => void;
+declare const _default: {
+    changeStepAuto: () => void;
+    updateStepImgCallback: () => void;
+    generateSteps: () => void;
+    submitIfFullSteps: (payload?: {}) => void;
+    again: () => void;
+    resetStepResults: (stepIndex?: number) => void;
+    updateSteps: () => void;
+};
+export default _default;

package/dist/types/types/enums/realFace.d.ts

@@ -0,0 +1,4 @@
+export declare enum RealFaceTurnSide {
+    LEFT = 0,
+    RIGHT = 1
+}

package/dist/types/types/modules/camera.enum.d.ts

@@ -0,0 +1,18 @@
+export declare enum CameraType {
+    Back = "environment",
+    Front = "user"
+}
+export declare enum CameraNotSupportedReason {
+    /** navigator.mediaDevices.getUserMedia
+     * is not supported by current browser for current context.
+    * */
+    MediaDevicesNotSupported = "MediaDevicesNotSupported",
+    /** Camera with requested features is not available on current device. */
+    CameraNotFound = "CameraNotFound",
+    /** Camera access was not granted by the user. */
+    CameraNotAllowed = "CameraNotAllowed",
+    /** Unable to start playing because camera is already in use. */
+    CameraInUse = "CameraInUse",
+    /** Camera is currently not available due to a OS or hardware error. */
+    CameraNotAvailable = "CameraNotAvailable"
+}