@regulaforensics/vp-frontend-document-components 2.0.1 → 2.2.0

package/lib/common/Message.d.ts

@@ -1,7 +1,8 @@
 import * as React from 'react';
 declare type MessageProps = {
     children: string;
+    isLivenessDetection?: boolean;
 };
-declare function Message({ children }: MessageProps): JSX.Element;
+declare function Message({ children, isLivenessDetection }: MessageProps): JSX.Element;
 declare const _default: React.MemoExoticComponent<typeof Message>;
 export default _default;

package/lib/common/NoGlareIconLivenessDetection.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+declare function NoGlareIconLivenessDetection({ size }: {
+    size?: number;
+}): JSX.Element;
+export default NoGlareIconLivenessDetection;

package/lib/common/NoSmilingIconLivenessDetection.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+declare function NoSmilingIconLivenessDetection({ size }: {
+    size?: number;
+}): JSX.Element;
+export default NoSmilingIconLivenessDetection;

package/lib/common/PortraitOrientationOnlyIcon.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare function PortraitOrientationOnlyIcon({ size, color }: {
+    size?: number;
+    color?: string;
+}): JSX.Element;
+export default PortraitOrientationOnlyIcon;

package/lib/common/RegulaLogoLivenessDetection.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+declare function RegulaLogoLivenessDetection({ color }: {
+    color?: string;
+}): JSX.Element;
+export default RegulaLogoLivenessDetection;

package/lib/components/ButtonFaceLiveness.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+declare type ButtonLivenessDetectionProps = {
+    children: React.ReactNode | string;
+    onClick: () => void;
+};
+declare function ButtonFaceLiveness({ children, onClick, ...rest }: ButtonLivenessDetectionProps): JSX.Element;
+export default ButtonFaceLiveness;

package/lib/components/DocumentCapture.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { DocumentCompletionStatus } from '../constants';
-import { Response as DocumentReaderResponseType } from '@regulaforensics/document-reader-webclient/src/ext/process-response';
+import { Response as DocumentReaderResponseType } from '../models/DocReaderWebclient/ext';
 declare type DocumentCaptureProps = {
     onResponse: (res: DocumentReaderResponseType) => void;
     onStatusChange: (statusData: DocumentCompletionStatus) => void;

package/lib/components/DocumentReaderFileCapture.d.ts

@@ -1,11 +1,11 @@
 /// <reference types="react" />
-import { DocumentCompletionStatus } from '../constants';
-import { Response as DocumentReaderResponseType } from '@regulaforensics/document-reader-webclient/src/ext/process-response';
+import { DocumentCompletionStatus, InternalScenarios } from '../constants';
+import { Response as DocumentReaderResponseType } from '../models/DocReaderWebclient/ext';
 declare type DocumentReaderFileCaptureProps = {
     onStatusChange: (completionStatus: DocumentCompletionStatus) => void;
     onResponse: (response: DocumentReaderResponseType) => void;
     images: FileList | null;
-    scenario?: string;
+    scenario?: InternalScenarios;
     license?: string;
 };
 declare function DocumentReaderFileCapture({ onStatusChange, onResponse, images, scenario, license, }: DocumentReaderFileCaptureProps): JSX.Element;

package/lib/components/DocumentReaderLayout.d.ts

@@ -1,22 +1,20 @@
 import * as React from 'react';
-import { DocumentCaptureStatus, StreamStatus } from '../constants';
-import { FrameParamsType, VideoParamsType } from '../types';
+import { DocumentCaptureStatus } from '../constants';
+import { FrameParamsType, VideoParamsType, VideoStatusParamsType } from '../types';
 declare type DocumentReaderLayoutProps = {
     status: DocumentCaptureStatus;
-    videoStatus: StreamStatus;
     isServiceInitialized: boolean;
     children: JSX.Element | null;
     mirroring: boolean;
     onChangeMirroring: () => void;
     onChangeCamera: () => void;
-    isChangeCameraAvailable: boolean;
-    facingMode?: string;
+    videoStatusParams: VideoStatusParamsType;
     onCameraSnapshot?: () => void;
     onSkip?: () => void;
     frameParams?: FrameParamsType;
     videoElementParams?: VideoParamsType;
     showChangeCameraButton?: boolean;
 };
-declare function DocumentReaderLayout({ status, videoStatus, isServiceInitialized, children, mirroring, onChangeMirroring, onChangeCamera, isChangeCameraAvailable, facingMode, onCameraSnapshot, onSkip, frameParams, videoElementParams, showChangeCameraButton, }: DocumentReaderLayoutProps): JSX.Element;
+declare function DocumentReaderLayout({ status, isServiceInitialized, children, mirroring, onChangeMirroring, onChangeCamera, videoStatusParams, onCameraSnapshot, onSkip, frameParams, videoElementParams, showChangeCameraButton, }: DocumentReaderLayoutProps): JSX.Element;
 declare const _default: React.MemoExoticComponent<typeof DocumentReaderLayout>;
 export default _default;

package/lib/components/FaceCapture.d.ts

@@ -1,15 +1,24 @@
-/// <reference types="react" />
-import { FaceCompletionStatus } from '../constants';
-declare type FaceCaptureProps = {
+import * as React from 'react';
+import { FaceAbortSessionStatus, FaceCompletionStatus } from '../constants';
+declare type FaceCapturePropsLivenessDetection = {
     onStatusChange: (completionStatus: FaceCompletionStatus) => void;
     onImagesCapture: (images: Array<string>) => void;
     onReset: () => void;
-    uuid?: string;
-    tryCount?: number;
+    sessionId?: string;
+    setSessionId?: (id: string) => void;
+    setTransactionId?: (id: string) => void;
+    setPublicKey?: (id: string) => void;
     onRequestChange?: (request: Uint8Array | null) => void;
     faceSnapshot?: boolean;
     debug?: boolean;
     showChangeCameraButton?: boolean;
+    backendUrl?: string;
+    userCameraId?: string;
+    setUserCameraId: React.Dispatch<React.SetStateAction<string | undefined>>;
+    onRestart: (forceCapture?: boolean) => void;
+    abortProcess?: boolean;
+    setAbortProcess?: React.Dispatch<React.SetStateAction<boolean>>;
+    setAbortSessionStatus?: React.Dispatch<React.SetStateAction<FaceAbortSessionStatus | null>>;
 };
-declare function FaceCapture({ onStatusChange, onImagesCapture, onReset, tryCount, uuid, onRequestChange, faceSnapshot, debug, showChangeCameraButton, }: FaceCaptureProps): JSX.Element;
+declare function FaceCapture({ onStatusChange, onImagesCapture, onReset, sessionId, setSessionId, onRequestChange, faceSnapshot, debug, showChangeCameraButton, setTransactionId, setPublicKey, backendUrl, userCameraId, setUserCameraId, onRestart, abortProcess, setAbortProcess, setAbortSessionStatus, }: FaceCapturePropsLivenessDetection): JSX.Element;
 export default FaceCapture;

package/lib/components/FaceFullScreenOverlay.d.ts

@@ -1,11 +1,10 @@
 /// <reference types="react" />
-import { DirectionType, FaceCompletionStatus } from '../constants';
+import { DirectionType } from '../constants';
 declare type FaceFullScreenOverlayProps = {
     onClose: () => void;
     children: JSX.Element;
-    completionStatus: FaceCompletionStatus;
     copyright?: boolean;
     direction: DirectionType;
 };
-declare function FaceFullScreenOverlay({ onClose, children, completionStatus, copyright, direction, }: FaceFullScreenOverlayProps): JSX.Element;
+declare function FaceFullScreenOverlay({ onClose, children, copyright, direction }: FaceFullScreenOverlayProps): JSX.Element;
 export default FaceFullScreenOverlay;

package/lib/components/FaceHintAnimaition.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { FacePositionLivenessDetection } from '../types';
+declare type FaceHintAnimaitionProps = {
+    targetSector: number;
+    roundRadiusX?: number;
+    roundRadiusY: number;
+    isFaceAnimation: boolean;
+    setCameraBlur: (toggle: boolean) => void;
+    isSectorMode: boolean;
+    message: number;
+    facePosition: FacePositionLivenessDetection;
+    centerX: number;
+    centerY: number;
+};
+export declare const FaceHintAnimaition: React.FC<FaceHintAnimaitionProps>;
+export {};

package/lib/components/FaceLayout.d.ts

@@ -1,18 +1,23 @@
 import * as React from 'react';
-import { FaceMessage, StreamStatus } from '../constants';
-import { FrameObject } from '../types';
+import { FaceMessage } from '../constants';
+import { FacePositionLivenessDetection, FrameObject, VideoStatusParamsType } from '../types';
 declare type FaceLayoutProps = {
     children: JSX.Element | null;
     captureFrame: FrameObject;
-    videoStatus: StreamStatus;
+    videoStatusParams: VideoStatusParamsType;
     message: FaceMessage;
     prepared: boolean;
     onChangeCamera: () => void;
-    isChangeCameraAvailable: boolean;
     readiness: number;
+    step: number;
+    numSectors: number;
+    currSector: number;
+    targetSector: number | undefined;
     breakpoint?: string;
     showChangeCameraButton?: boolean;
+    facePosition: FacePositionLivenessDetection;
+    faceSnapshot: boolean | undefined;
 };
-declare function FaceLayout({ children, videoStatus, captureFrame, message, prepared, onChangeCamera, isChangeCameraAvailable, readiness, showChangeCameraButton, }: FaceLayoutProps): JSX.Element;
+declare function FaceLayout({ children, captureFrame, videoStatusParams, message, prepared, onChangeCamera, readiness, numSectors, currSector, targetSector, step, showChangeCameraButton, facePosition, faceSnapshot, }: FaceLayoutProps): JSX.Element;
 declare const _default: React.MemoExoticComponent<typeof FaceLayout>;
 export default _default;

package/lib/components/InfoScreenFaceLiveness.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+declare type InfoScreenFaceLivenessProps = {
+    title: string;
+    type: string;
+    subtitle?: string;
+    onReset?: () => void;
+    size?: number;
+    iconColor?: string;
+};
+declare function InfoScreenFaceLiveness({ title, type, subtitle, onReset, size, iconColor, }: InfoScreenFaceLivenessProps): JSX.Element;
+export default InfoScreenFaceLiveness;

package/lib/components/InstructionVideoScreen.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+declare type InstructionVideoScreenProps = {
+    onStart: () => void;
+    title: string;
+    subtitle: string;
+    videoSrc: string;
+};
+declare function InstructionVideoScreen({ onStart, title, subtitle, videoSrc }: InstructionVideoScreenProps): JSX.Element;
+export default InstructionVideoScreen;

package/lib/components/ProcessScreenFaceLiveness.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare type ProcessScreenFaceLivenessProps = {
+    title: string;
+};
+declare function ProcessScreenFaceLiveness({ title }: ProcessScreenFaceLivenessProps): JSX.Element;
+export default ProcessScreenFaceLiveness;

package/lib/components/RetryScreenFaceLiveness.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+declare type RetryScreenFaceLivenessProps = {
+    errorCode: number;
+    onReset: () => void;
+};
+declare function RetryScreenFaceLiveness({ errorCode, onReset }: RetryScreenFaceLivenessProps): JSX.Element;
+export default RetryScreenFaceLiveness;

package/lib/components/SectorAnimationSvg.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+interface SectorAnimationSvgProps {
+    numSectors: number;
+    targetSector: number;
+    currSector: number;
+    centerX: number;
+    centerY: number;
+    sectorRadius: number;
+}
+export declare const SectorAnimationSvg: React.FC<SectorAnimationSvgProps>;
+export {};

package/lib/constants.d.ts

@@ -5,21 +5,19 @@ export declare enum FaceMessage {
     MoveCloser = 3,
     MoveAway = 4,
     HoldStill = 5,
-    ShowOnlyOneFace = 6
+    ShowOnlyOneFace = 6,
+    TurnHead = 7
 }
 export declare enum FaceProcessingStage {
     Far = 0,
     Near = 1
 }
-export declare enum FaceMessageStyle {
-    Normal = 0,
-    Alarm = 1
-}
 export declare enum FaceStatus {
     Finished = 0,
     InProcess = 1,
     Timeout = 2,
-    Failed = 3
+    Failed = 3,
+    Stop_Session = 4
 }
 export declare enum ImageOutputType {
     UINT = "UINT",
@@ -41,6 +39,8 @@ export declare enum DocumentEventActions {
     PRESS_RETRY_BUTTON = "PRESS_RETRY_BUTTON",
     PRESS_SKIP_BUTTON = "PRESS_SKIP_BUTTON",
     CLOSE = "CLOSE",
+    CAMERA_PROCESS_STARTED = "CAMERA_PROCESS_STARTED",
+    FILE_PROCESS_STARTED = "FILE_PROCESS_STARTED",
     PROCESS_FINISHED = "PROCESS_FINISHED",
     SERVICE_INITIALIZED = "SERVICE_INITIALIZED"
 }
@@ -89,7 +89,16 @@ export declare enum StreamStatus {
     NO_CAMERA = "StreamStatus.NO_CAMERA",
     INCORRECT_CAMERA_ID = "StreamStatus.INCORRECT_CAMERA_ID"
 }
+export declare enum FaceAbortSessionStatus {
+    CHANGE_CAMERA = "FaceAbortSessionStatus.CHANGE_CAMERA",
+    DEVICE_ROTATE = "FaceAbortSessionStatus.DEVICE_ROTATE",
+    SESSION_TIMEOUT = "FaceAbortSessionStatus.TIMEOUT",
+    CLOSE_BUTTON = "FaceAbortSessionStatus.CLOSE_BUTTON",
+    UNKNOWN = "FaceAbortSessionStatus.UNKNOWN"
+}
 export declare enum FaceCompletionStatus {
+    RESTART = "FaceCompletionStatus.RESTART",
+    ABORT_PROCESSING = "FaceCompletionStatus.ABORT_PROCESSING",
     INSTRUCTION = "FaceCompletionStatus.INSTRUCTION",
     SUCCESS = "FaceCompletionStatus.SUCCESS",
     FAILED = "FaceCompletionStatus.FAILED",
@@ -214,7 +223,7 @@ export declare const DOCUMENT_READER_EVENT = "document-reader";
 export declare const CAMERA_SNAPSHOT_EVENT = "camera-snapshot";
 export declare const PERCENT_FRAME_OFFSET = 10;
 export declare const FLIP_TIMEOUT = 3000;
-export declare const FRAME_STROKE_WIDTH = 3;
+export declare const FRAME_STROKE_WIDTH_LIVENESS_DETECTION = 3;
 export declare const RESULT_TIMEOUT_MS = 2000;
 export declare const NEW_INDEX = 1;
 export declare const MAX_FILES_SIZE = 25000000;
@@ -226,6 +235,8 @@ export declare const DEFAULT_COMPONENT_LANGUAGE = "en";
 export declare const RTL_LANGUAGES: string[];
 export declare const DEFAULT_CAMERA_ID = 0;
 export declare const OVAL_TRANSITION_TIME = 200;
+export declare const CAMERAS_COUNT = 1;
+export declare const FIREFOX_SWITCH_CAMERA_DELAY = 500;
 export declare const CameraResolution: {
     VGA: {
         width: number;
@@ -246,15 +257,39 @@ export declare const CameraResolution: {
 };
 export declare const BackCameraKeywords: string[];
 export declare const FaceErrorCodes: {
-    231: {
+    199: {
         name: string;
         type: number;
     };
-    232: {
+    200: {
         name: string;
         type: number;
     };
-    245: {
+    201: {
+        name: string;
+        type: number;
+    };
+    202: {
+        name: string;
+        type: number;
+    };
+    203: {
+        name: string;
+        type: number;
+    };
+    224: {
+        name: string;
+        type: number;
+    };
+    227: {
+        name: string;
+        type: number;
+    };
+    228: {
+        name: string;
+        type: number;
+    };
+    229: {
         name: string;
         type: number;
     };
@@ -262,6 +297,14 @@ export declare const FaceErrorCodes: {
         name: string;
         type: number;
     };
+    231: {
+        name: string;
+        type: number;
+    };
+    232: {
+        name: string;
+        type: number;
+    };
     233: {
         name: string;
         type: number;
@@ -278,6 +321,14 @@ export declare const FaceErrorCodes: {
         name: string;
         type: number;
     };
+    237: {
+        name: string;
+        type: number;
+    };
+    238: {
+        name: string;
+        type: number;
+    };
     239: {
         name: string;
         type: number;
@@ -298,6 +349,26 @@ export declare const FaceErrorCodes: {
         name: string;
         type: number;
     };
+    245: {
+        name: string;
+        type: number;
+    };
+    246: {
+        name: string;
+        type: number;
+    };
+    247: {
+        name: string;
+        type: number;
+    };
+    248: {
+        name: string;
+        type: number;
+    };
+    249: {
+        name: string;
+        type: number;
+    };
 };
 export declare const WebComponentErrorByStreamStatus: {
     "StreamStatus.UNKNOWN_ERROR": ErrorTypes;
@@ -312,7 +383,7 @@ export declare const DocumentReaderStatusByError: {
     WASM_LICENSE: DocumentCompletionStatus;
     INCORRECT_FILE: DocumentCompletionStatus;
 };
-export declare const DocumentReaderStatusByCaptureStatus: {
+export declare const DocumentReaderFinishStatusByCaptureStatus: {
     "DocumentCaptureStatus.SUCCESS": DocumentCompletionStatus;
     "DocumentCaptureStatus.TIMEOUT": DocumentCompletionStatus;
     "DocumentCaptureStatus.FAILED": DocumentCompletionStatus;
@@ -566,3 +637,47 @@ export declare const DocumentScenarioFrameParams: {
         manualCrop?: undefined;
     })[];
 };
+export declare const CIRCLE_ROTATE_SHIFT = 22.5;
+export declare const MIRROR_ANIMATION_TARGETS: number[];
+export declare const ANIMATION_TIMEOUT = 1000;
+export declare const ANIMATION_MESSAGE: FaceMessage[];
+export declare const STATIC_ANIMATION_MESSAGE: FaceMessage[];
+export declare const DocumentReaderRecognizerDefaultRequest: {
+    processParam: {
+        scenario: InternalScenarios;
+        returnUncroppedImage: boolean;
+        multipageProcessing: boolean;
+        timeoutFromFirstDetect: number;
+        timeoutFromFirstDocType: number;
+        imageQa: {
+            expectedPass: string[];
+            dpiThreshold: number;
+            glaresCheck: boolean;
+            glaresCheckParams: {
+                imgMarginPart: number;
+                maxGlaringPart: number;
+            };
+        };
+    };
+};
+export declare const DocumentReaderImageDefaultRequest: {
+    processParam: {
+        scenario: InternalScenarios;
+        returnUncroppedImage: boolean;
+    };
+};
+export declare const SDKDocumentReaderRecognizerDefaultRequest: {
+    processParam: {
+        scenario: InternalScenarios;
+        returnUncroppedImage: boolean;
+        timeoutFromFirstDetect: number;
+        timeoutFromFirstDocType: number;
+    };
+};
+export declare const SDKDocumentReaderImageDefaultRequest: {
+    processParam: {
+        scenario: InternalScenarios;
+        returnUncroppedImage: boolean;
+    };
+};
+export declare const AcceptedFiles: string[];

package/lib/contexts/DocumentAttributesContext.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { CameraSnapshotResponseType, DocumentReaderResponseType } from '../types';
+import { CameraSnapshotResponseType, DocumentDictionaries, DocumentReaderResponseType, Locales } from '../types';
 import { DocumentEventActions, InternalScenarios, ObjectFit, ErrorTypes } from '../constants';
 declare type DocumentCallbackArgTypes = DocumentReaderResponseType | CameraSnapshotResponseType;
 export declare type DocumentAttributesContextType = {
@@ -9,7 +9,7 @@ export declare type DocumentAttributesContextType = {
     }) => void;
     onResponse: (response: DocumentCallbackArgTypes) => void;
     onFail: (reason: ErrorTypes) => void;
-    locale?: string;
+    locale?: Locales;
     internalScenario?: InternalScenarios;
     multipageProcessing?: boolean;
     startScreen?: boolean;
@@ -19,6 +19,8 @@ export declare type DocumentAttributesContextType = {
     cameraId?: string;
     objectFit?: ObjectFit;
     changeCamera?: boolean;
+    translations?: DocumentDictionaries;
 };
 export declare const DocumentAttributesContext: React.Context<DocumentAttributesContextType>;
+export declare const useDocumentContext: () => DocumentAttributesContextType;
 export {};

package/lib/contexts/DocumentSDKContext.d.ts

@@ -1,6 +1,8 @@
 import React from 'react';
 import DocumentReaderService from '../services/DocumentReaderService';
-export declare type DocumentSDKContextType = {
+declare type DocumentSDKContextType = {
     service: DocumentReaderService | null;
 };
 export declare const DocumentSDKContext: React.Context<DocumentSDKContextType>;
+export declare const useDocumentSDKContext: () => DocumentSDKContextType;
+export {};

package/lib/contexts/FaceAttributesContext.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
-import { FaceDetectionResponseType, FaceLivenessResponseType } from '../types';
+import { FaceDetectionResponseType, Locales, FaceLivenessResponseType } from '../types';
 import { FaceEventActions, ErrorTypes } from '../constants';
-declare type FaceCallbackArgTypes = FaceLivenessResponseType | FaceDetectionResponseType;
+declare type FaceCallbackArgTypes = FaceDetectionResponseType | FaceLivenessResponseType;
 export declare type FaceAttributesContextType = {
     onAction: ({ manual, action }: {
         manual: boolean;
@@ -9,13 +9,16 @@ export declare type FaceAttributesContextType = {
     }) => void;
     onResponse: (response: FaceCallbackArgTypes) => void;
     onFail: (reason: ErrorTypes) => void;
-    locale?: string;
+    locale?: Locales;
     url?: string;
     debug?: boolean;
     headers?: Record<string, string>;
+    sessionId?: string;
     copyright?: boolean;
     cameraId?: string;
     changeCamera?: boolean;
+    startScreen?: boolean;
 };
 export declare const FaceAttributesContext: React.Context<FaceAttributesContextType>;
+export declare const useFaceContext: () => FaceAttributesContextType;
 export {};

package/lib/hoc/withLocalize.d.ts

@@ -1,7 +1,8 @@
 import * as React from 'react';
-import { DirectionType } from '../constants';
-interface Locale {
-    locale: string | undefined;
+import { DocumentDictionaries, Locales } from '../types';
+interface LocalizedProps {
+    locale?: Locales;
+    translations?: DocumentDictionaries;
 }
-declare function withLocalize<T>(Component: React.ComponentType<T>): React.ComponentType<T & Locale & DirectionType>;
+declare function withLocalize<T>(Component: React.ComponentType<T>): React.ComponentType<T & LocalizedProps>;
 export default withLocalize;

package/lib/hooks/useDocumentReaderSeries.d.ts

@@ -1,5 +1,5 @@
-import { Response } from '@regulaforensics/document-reader-webclient';
-import { DocumentCaptureStatus, DocumentEventActions, InternalScenarios, ObjectFit, StreamStatus } from '../constants';
+import { Response } from '../models/DocReaderWebclient/ext';
+import { DocumentCaptureStatus, InternalScenarios, ObjectFit, StreamStatus } from '../constants';
 import { FrameParamsType, VideoParamsType } from '../types';
 import CustomError from '../models/CustomError';
 declare type ResponseType = {
@@ -18,8 +18,5 @@ declare function useDocumentReaderSeries(options: {
     multipageProcessing?: boolean;
     license?: string;
     objectFit?: ObjectFit;
-}, onAction: ({ manual, action }: {
-    manual: boolean;
-    action: DocumentEventActions;
-}) => void): useDocumentReaderSeriesInterface;
+}): useDocumentReaderSeriesInterface;
 export default useDocumentReaderSeries;

package/lib/hooks/useDocumentReaderSingle.d.ts

@@ -1,5 +1,5 @@
-import { DocumentCaptureStatus } from '../constants';
-import { Response } from '@regulaforensics/document-reader-webclient';
+import { DocumentCaptureStatus, InternalScenarios } from '../constants';
+import { Response } from '../models/DocReaderWebclient/ext';
 import CustomError from '../models/CustomError';
 declare type ResponseType = {
     status: DocumentCaptureStatus;
@@ -9,7 +9,7 @@ declare type ResponseType = {
     prepared: boolean;
 };
 declare function useDocumentReaderSingle(imageDataArray: Array<ImageData>, options: {
-    scenario?: string;
+    scenario?: InternalScenarios;
     license?: string;
 }): ResponseType;
 export default useDocumentReaderSingle;

package/lib/hooks/useFaceLiveness.d.ts

@@ -1,5 +1,5 @@
 import { FaceMessage, FaceProcessingStage, FaceStatus, FaceEventActions, StreamStatus } from '../constants';
-import { CameraTypes, FaceDebugOutput, Oval, VideoParamsType } from '../types';
+import { CameraTypes, FaceDebugOutput, FacePositionLivenessDetection, Oval, VideoParamsType } from '../types';
 import CustomError from '../models/CustomError';
 declare type ResponseType = {
     message: FaceMessage;
@@ -12,17 +12,27 @@ declare type ResponseType = {
     prepared: boolean;
     images: Array<string>;
     ovals: Array<Oval>;
+    step: number;
+    currSector: number;
+    numSectors: number;
+    targetSector: number | undefined;
     readiness: number;
+    publicKey: string | null;
     error: CustomError | null;
+    facePosition: FacePositionLivenessDetection;
 };
 declare function useFaceLiveness(options: {
     videoStatus: StreamStatus;
     videoElementParams: VideoParamsType;
     cameraInfo: CameraTypes;
-    uuid?: string;
+    setSessionId?: (id: string) => void;
+    setTransactionId?: (id: string) => void;
+    sessionId?: string;
     url?: string;
-    tryCount?: number;
     debug?: boolean;
+    faceSnapshot?: boolean;
+    backendUrl?: string;
+    abortProcess?: boolean;
 }, onAction: ({ manual, action }: {
     manual: boolean;
     action: FaceEventActions;

package/lib/hooks/useStateCallback.d.ts

@@ -0,0 +1 @@
+export declare function useStateCallback<T>(initialState: T): [T, (state: T, cb?: (state: T) => void) => void];