@trulioo/docv-capture-web 2.13.1 → 2.14.1

package/README.md

@@ -60,12 +60,18 @@ documentCamera.renderCamera("parent-element-id", cameraProps).then((_) => {
 })
 ```
 
-To remove/unrender the current camera on the screen, call the `removeCamera` function.
+To remove the current camera on the screen, call the `removeCamera` function.
 
 ```javascript showLineNumbers
 documentCamera.removeCamera()
 ```
 
+Additionally, if we want to resume the camera feed again after a successful auto or manual capture, we can call the `resumeCamera` function.
+
+```javascript showLineNumbers
+documentCamera.resumeCamera()
+```
+
 ### Starting the document capture flow
 
 
@@ -77,7 +83,7 @@ currently active/rendered camera component. The promise will only resolve when t
 
 ```javascript showLineNumbers
 truliooCapture.startFeedback(documentCamera.id).then((result: TruliooCaptureResponse) => {
-    console.log(`Succesfully captured a good image: ${result}`)
+    console.log(`Succesfully captured a good image with imageId: ${result.imageId}`)
 })
 ```
 
@@ -87,7 +93,32 @@ We can also stop the feedback by calling the `stopFeedback` function. This will
 truliooCapture.stopFeedback(documentCamera.id)
 
 ```
+Note that if the `stopFeedback` function is called during an ongoing `startFeedback` promise, the `startFeedback` promise is expected to be rejected with the specific `FeedbackStopped` error.
+It is recommended to check this specific error to make sure it is not treated as an unexpected error.
 
+```javascript showLineNumbers
+import { HandledError } from '@trulioo/docv-capture-web'
+
+truliooCapture.startFeedback(documentCamera.id).then((result: TruliooCaptureResponse) => {
+    console.log(`Succesfully captured a good image with imageId: ${result.imageId}`)
+}).catch((error: unknown) => {
+    if (error == HandledError.FeedbackStopped) {
+        console.log("startFeedback is stopped.")
+    } else {
+        // Other error handling
+    }
+})
+```
+
+Additionally, if we want to do a manual capture instead. We can call the `captureLatestFrame` function. This will return a `TruliooManualCaptureResponse` that is similar to the `TruliooCaptureResponse` excluding the auto capture specific fields.
+Note that we would want to make sure the camera feed is currently running before triggering the manual capture, hence we can resume the camera again after a successful auto or manual capture using the `resumeCamera` function if we want to trigger another capture.
+
+```javascript showLineNumbers
+truliooCapture.captureLatestFrame(documentCamera.id).then((result: TruliooManualCaptureResponse) => {
+    console.log(`Succesfully captured an image with manual capture with imageId: ${result.imageId}`)
+})
+
+```
 
 The SDK also provides the `onFeedbackState` function that we can listen to for the ongoing capture state updates that is started by the `startFeedback` function.
 This allows us to add any logic needed or render any necessary custom UI needed based on the current capture state.
@@ -122,16 +153,17 @@ Note that the above flow is the same for the selfie capture type too.
 ### Analysing the captured image result through post capture verify feedback
 
 
-Once we have the resulting `TruliooCaptureResponse` image data, we are able to get a post capture feedback by simply calling the `verifyImage` function that is
+Once we have the resulting `TruliooCaptureResponse` or `TruliooManualCaptureResponse` image data, we are able to get a post capture feedback by simply calling the `verifyImage` function that is
 part of the response data. This will give use more information regarding the captured image and let us decide whether we should submit the captured image for
 verification by calling the `acceptImage` function.
 
 
 
 ```javascript showLineNumbers
-// As an example, we will submit the captured image for document verification if the post capture feedback returns a CAN_BE_PROCESSED status.
-result.verifyImage().then((verifyFeedback: TruliooVerifyResponse) => {
-    if (verifyFeedback.verificationStatus == VerificationStatus.CAN_BE_PROCESSED) {
+// As an example, we will submit the captured image for document verification if the post capture feedback documentVerifyResponse.documentTypeAccepted is not RESULT_CHECK_DECLINED.
+// Note that the documentVerifyResponse will have more than just documentTypeAccepted, the below code is just an example of just checking for documentTypeAccepted.
+result.verifyImage().then((verifyFeedback: TruliooVerifyFeedback) => {
+    if (verifyFeedback.documentVerifyResponse.documentTypeAccepted !== ResultCheck.RESULT_CHECK_DECLINED) {
         // Note that the acceptImage can be called outside of the verifyImage function.
         result.acceptImage().then((status: boolean) => {
             console.log("Successfully submitted the image")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trulioo/docv-capture-web",
-  "version": "2.13.1",
+  "version": "2.14.1",
   "main": "trulioo-docv-capture-web.js",
   "types": "trulioo-docv-capture-web.d.ts",
   "devDependencies": {

package/trulioo-docv-capture-web.d.ts

@@ -40,46 +40,37 @@ export declare namespace com.trulioo.docv.core.workflow {
         equals(other: Nullable<any>): boolean;
     }
 }
-export declare class TruliooCamera /* extends capture.Camera */ {
-    constructor(cameraId: string, cameraDetectionType: DetectionType);
-    get id(): string;
-    get detectionType(): DetectionType;
-    removeCamera(): void;
-    renderCamera(parentElementId: string, cameraProps?: Nullable<CameraProps>): Promise<boolean>;
+export declare class TruliooError extends Error {
+    constructor(code?: number, message?: string);
+    get code(): number;
 }
-export declare class CameraProps {
-    constructor(onCaptureRegionChange: Nullable<(p0: CaptureRegion) => void>);
-    get onCaptureRegionChange(): Nullable<(p0: CaptureRegion) => void>;
-    copy(onCaptureRegionChange?: Nullable<(p0: CaptureRegion) => void>): CameraProps;
-    toString(): string;
-    hashCode(): number;
-    equals(other: Nullable<any>): boolean;
+export declare abstract class NetworkError extends TruliooError {
+    protected constructor();
+    get code(): number;
+    static get NoInternet(): {
+        get code(): number;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    } & NetworkError;
 }
-export declare interface CaptureRegion {
-    readonly bottomRight: PointCoordinates;
-    readonly center: PointCoordinates;
-    readonly selfieRadius: number;
-    readonly topLeft: PointCoordinates;
-    readonly __doNotUseOrImplementIt: {
-        readonly CaptureRegion: unique symbol;
-    };
+export declare class ConfigurationError extends TruliooError {
+    constructor(message: string);
+    get code(): number;
 }
-export declare interface PointCoordinates {
-    readonly x: number;
-    readonly y: number;
-    readonly __doNotUseOrImplementIt: {
-        readonly PointCoordinates: unique symbol;
-    };
+export declare abstract class HandledError extends TruliooError {
+    protected constructor();
+    get code(): number;
+    static get FeedbackStopped(): {
+        get code(): number;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    } & HandledError;
 }
-export declare class TruliooCapture {
-    constructor();
-    initialize(shortCode: string, previewMode?: boolean): Promise<string>;
-    getCameraComponent(config?: Nullable<TruliooCameraConfig>): TruliooCamera;
-    startFeedback(cameraId: string, imageFeedback?: Nullable<(p0: TruliooImageFeedback) => void>): Promise<TruliooCaptureResponse>;
-    stopFeedback(cameraId: string): Promise<boolean>;
-    onFeedbackState(feedback: (p0: TruliooFeedbackState) => void): void;
-    captureLatestFrame(): Promise<TruliooCaptureResponse>;
-    submitTransaction(): Promise<boolean>;
+export declare class GenericError extends TruliooError {
+    constructor(message: string);
+    get code(): number;
 }
 export declare interface TruliooCameraConfig {
     readonly detectionType: DetectionType;
@@ -110,65 +101,57 @@ export declare abstract class DetectionType {
     get name(): "DOCUMENT" | "PASSPORT" | "BIOMETRIC_SELFIE" | "NO_DETECTION";
     get ordinal(): 0 | 1 | 2 | 3;
 }
+export declare interface CaptureResponse {
+    readonly imageId: string;
+    readonly acceptImage: () => Promise<boolean>;
+    readonly verifyImage: () => Promise<TruliooVerifyFeedback>;
+    readonly __doNotUseOrImplementIt: {
+        readonly CaptureResponse: unique symbol;
+    };
+}
 export declare interface TruliooImageFeedback {
     readonly imageId: string;
     readonly detectionType: DetectionType;
     readonly hasAcceptableQuality: boolean;
     readonly hasBlur: boolean;
     readonly hasDetection: boolean;
+    readonly requiresBackCapture: boolean;
+    readonly tooClose: boolean;
+    readonly tooFar: boolean;
     readonly __doNotUseOrImplementIt: {
         readonly TruliooImageFeedback: unique symbol;
     };
 }
-export declare interface TruliooCaptureResponse extends TruliooImageFeedback {
+export declare interface TruliooCaptureResponse extends CaptureResponse, TruliooImageFeedback {
+    readonly imageId: string;
     readonly acceptImage: () => Promise<boolean>;
-    readonly requiresBackCapture: boolean;
-    readonly tooClose: boolean;
-    readonly tooFar: boolean;
     readonly verifyImage: () => Promise<TruliooVerifyFeedback>;
-    readonly imageId: string;
     readonly detectionType: DetectionType;
     readonly hasAcceptableQuality: boolean;
     readonly hasBlur: boolean;
     readonly hasDetection: boolean;
+    readonly requiresBackCapture: boolean;
+    readonly tooClose: boolean;
+    readonly tooFar: boolean;
     readonly __doNotUseOrImplementIt: {
         readonly TruliooCaptureResponse: unique symbol;
-    } & TruliooImageFeedback["__doNotUseOrImplementIt"];
+    } & CaptureResponse["__doNotUseOrImplementIt"] & TruliooImageFeedback["__doNotUseOrImplementIt"];
+}
+export declare interface TruliooManualCaptureResponse extends CaptureResponse {
+    readonly imageId: string;
+    readonly acceptImage: () => Promise<boolean>;
+    readonly verifyImage: () => Promise<TruliooVerifyFeedback>;
+    readonly __doNotUseOrImplementIt: {
+        readonly TruliooManualCaptureResponse: unique symbol;
+    } & CaptureResponse["__doNotUseOrImplementIt"];
 }
 export declare interface TruliooVerifyFeedback {
     readonly isVerifyAttemptAvailable: boolean;
-    readonly verificationStatus: VerificationStatus;
+    readonly documentVerifyResponse: DocumentVerifyResponse;
     readonly __doNotUseOrImplementIt: {
         readonly TruliooVerifyFeedback: unique symbol;
     };
 }
-export declare abstract class VerificationStatus {
-    private constructor();
-    static get CAN_BE_PROCESSED(): VerificationStatus & {
-        get name(): "CAN_BE_PROCESSED";
-        get ordinal(): 0;
-    };
-    static get CANNOT_BE_CLASSIFIED(): VerificationStatus & {
-        get name(): "CANNOT_BE_CLASSIFIED";
-        get ordinal(): 1;
-    };
-    static get UNSUPPORTED_DOCUMENT(): VerificationStatus & {
-        get name(): "UNSUPPORTED_DOCUMENT";
-        get ordinal(): 2;
-    };
-    static get EXPIRED_DOCUMENT(): VerificationStatus & {
-        get name(): "EXPIRED_DOCUMENT";
-        get ordinal(): 3;
-    };
-    static get ERROR(): VerificationStatus & {
-        get name(): "ERROR";
-        get ordinal(): 4;
-    };
-    static values(): Array<VerificationStatus>;
-    static valueOf(value: string): VerificationStatus;
-    get name(): "CAN_BE_PROCESSED" | "CANNOT_BE_CLASSIFIED" | "UNSUPPORTED_DOCUMENT" | "EXPIRED_DOCUMENT" | "ERROR";
-    get ordinal(): 0 | 1 | 2 | 3 | 4;
-}
 export declare abstract class TruliooFeedbackState {
     private constructor();
     static get NONE(): TruliooFeedbackState & {
@@ -204,4 +187,121 @@ export declare abstract class TruliooFeedbackState {
     get name(): "NONE" | "CAPTURING" | "BLUR" | "SUCCESS" | "ERROR" | "TOO_CLOSE" | "TOO_FAR";
     get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
 }
+export declare abstract class ResultCheck {
+    private constructor();
+    static get RESULT_CHECK_UNSPECIFIED(): ResultCheck & {
+        get name(): "RESULT_CHECK_UNSPECIFIED";
+        get ordinal(): 0;
+    };
+    static get RESULT_CHECK_DECLINED(): ResultCheck & {
+        get name(): "RESULT_CHECK_DECLINED";
+        get ordinal(): 1;
+    };
+    static get RESULT_CHECK_ACCEPTED(): ResultCheck & {
+        get name(): "RESULT_CHECK_ACCEPTED";
+        get ordinal(): 2;
+    };
+    static values(): Array<ResultCheck>;
+    static valueOf(value: string): ResultCheck;
+    get name(): "RESULT_CHECK_UNSPECIFIED" | "RESULT_CHECK_DECLINED" | "RESULT_CHECK_ACCEPTED";
+    get ordinal(): 0 | 1 | 2;
+}
+export declare abstract class DocumentExpirationCheck {
+    private constructor();
+    static get DOCUMENT_EXPIRATION_CHECK_UNSPECIFIED(): DocumentExpirationCheck & {
+        get name(): "DOCUMENT_EXPIRATION_CHECK_UNSPECIFIED";
+        get ordinal(): 0;
+    };
+    static get DOCUMENT_EXPIRATION_CHECK_EXPIRED(): DocumentExpirationCheck & {
+        get name(): "DOCUMENT_EXPIRATION_CHECK_EXPIRED";
+        get ordinal(): 1;
+    };
+    static get DOCUMENT_EXPIRATION_CHECK_VALID(): DocumentExpirationCheck & {
+        get name(): "DOCUMENT_EXPIRATION_CHECK_VALID";
+        get ordinal(): 2;
+    };
+    static values(): Array<DocumentExpirationCheck>;
+    static valueOf(value: string): DocumentExpirationCheck;
+    get name(): "DOCUMENT_EXPIRATION_CHECK_UNSPECIFIED" | "DOCUMENT_EXPIRATION_CHECK_EXPIRED" | "DOCUMENT_EXPIRATION_CHECK_VALID";
+    get ordinal(): 0 | 1 | 2;
+}
+export declare abstract class BackImageRequirement {
+    private constructor();
+    static get BACK_IMAGE_REQUIREMENT_UNSPECIFIED(): BackImageRequirement & {
+        get name(): "BACK_IMAGE_REQUIREMENT_UNSPECIFIED";
+        get ordinal(): 0;
+    };
+    static get BACK_IMAGE_REQUIREMENT_NOT_REQUIRED(): BackImageRequirement & {
+        get name(): "BACK_IMAGE_REQUIREMENT_NOT_REQUIRED";
+        get ordinal(): 1;
+    };
+    static get BACK_IMAGE_REQUIREMENT_REQUIRED(): BackImageRequirement & {
+        get name(): "BACK_IMAGE_REQUIREMENT_REQUIRED";
+        get ordinal(): 2;
+    };
+    static values(): Array<BackImageRequirement>;
+    static valueOf(value: string): BackImageRequirement;
+    get name(): "BACK_IMAGE_REQUIREMENT_UNSPECIFIED" | "BACK_IMAGE_REQUIREMENT_NOT_REQUIRED" | "BACK_IMAGE_REQUIREMENT_REQUIRED";
+    get ordinal(): 0 | 1 | 2;
+}
+export declare class DocumentVerifyResponse {
+    constructor(documentDetected: ResultCheck, documentTypeAccepted: ResultCheck, documentCountryAccepted: ResultCheck, documentJurisdictionAccepted: ResultCheck, blur: ResultCheck, glare: ResultCheck, skewed: ResultCheck, bright: ResultCheck, documentExpirationCheck: DocumentExpirationCheck, backImageRequirement: BackImageRequirement);
+    get documentDetected(): ResultCheck;
+    get documentTypeAccepted(): ResultCheck;
+    get documentCountryAccepted(): ResultCheck;
+    get documentJurisdictionAccepted(): ResultCheck;
+    get blur(): ResultCheck;
+    get glare(): ResultCheck;
+    get skewed(): ResultCheck;
+    get bright(): ResultCheck;
+    get documentExpirationCheck(): DocumentExpirationCheck;
+    get backImageRequirement(): BackImageRequirement;
+    copy(documentDetected?: ResultCheck, documentTypeAccepted?: ResultCheck, documentCountryAccepted?: ResultCheck, documentJurisdictionAccepted?: ResultCheck, blur?: ResultCheck, glare?: ResultCheck, skewed?: ResultCheck, bright?: ResultCheck, documentExpirationCheck?: DocumentExpirationCheck, backImageRequirement?: BackImageRequirement): DocumentVerifyResponse;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare class TruliooCamera /* extends capture.Camera */ {
+    constructor(cameraId: string, cameraDetectionType: DetectionType);
+    get id(): string;
+    get detectionType(): DetectionType;
+    removeCamera(): void;
+    renderCamera(parentElementId: string, cameraProps?: Nullable<CameraProps>): Promise<boolean>;
+    resumeCamera(): void;
+}
+export declare class CameraProps {
+    constructor(onCaptureRegionChange: Nullable<(p0: CaptureRegion) => void>);
+    get onCaptureRegionChange(): Nullable<(p0: CaptureRegion) => void>;
+    copy(onCaptureRegionChange?: Nullable<(p0: CaptureRegion) => void>): CameraProps;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare interface CaptureRegion {
+    readonly bottomRight: PointCoordinates;
+    readonly center: PointCoordinates;
+    readonly selfieRadius: number;
+    readonly topLeft: PointCoordinates;
+    readonly __doNotUseOrImplementIt: {
+        readonly CaptureRegion: unique symbol;
+    };
+}
+export declare interface PointCoordinates {
+    readonly x: number;
+    readonly y: number;
+    readonly __doNotUseOrImplementIt: {
+        readonly PointCoordinates: unique symbol;
+    };
+}
+export declare class TruliooCapture {
+    constructor();
+    initialize(shortCode: string, previewMode?: boolean): Promise<string>;
+    getCameraComponent(config?: Nullable<TruliooCameraConfig>): TruliooCamera;
+    startFeedback(cameraId: string, imageFeedback?: Nullable<(p0: TruliooImageFeedback) => void>): Promise<TruliooCaptureResponse>;
+    stopFeedback(cameraId: string): Promise<boolean>;
+    onFeedbackState(feedback: (p0: TruliooFeedbackState) => void): void;
+    captureLatestFrame(cameraId: string): Promise<TruliooManualCaptureResponse>;
+    submitTransaction(): Promise<boolean>;
+    static stopOngoingCaptureProcess$default($this: TruliooCapture, cameraController: any/* capture.CameraController */, isManual?: boolean): void;
+}
 export as namespace trulioo_docv_capture_web;