idmission-web-sdk 0.0.1

package/dist/contexts/SubmissionContext.d.ts

@@ -0,0 +1,156 @@
+/// <reference types="react" />
+import { UploadedDocument } from '../components/additional_document_capture/AdditionalDocumentCapture';
+import { SignatureData } from '../components/signature_capture/data';
+export declare enum SubmissionAction {
+    NONE = "NONE",
+    ENROLL = "ENROLL",
+    IDENTIFY = "IDENTIFY",
+    VALIDATE = "VALIDATE",
+    VERIFY = "VERIFY"
+}
+export declare enum SubmissionStatus {
+    READY = "READY",
+    SUBMITTING = "SUBMITTING",
+    SUBMITTED = "SUBMITTED",
+    FAILED = "FAILED"
+}
+export type SubmissionEnvironment = 'prod' | 'demo';
+export declare const submissionHosts: {
+    prod: string;
+    demo: string;
+};
+export type SubmissionRequest = {
+    securityData: {
+        userName: string;
+        password: string;
+        merchantId: number;
+    };
+    customerData: {
+        idData: {
+            idImageFront?: string;
+            idImageBack?: string;
+            idType: 'NSP';
+            idCountry: 'NSP';
+            idState: '';
+        };
+        personalData?: {
+            uniqueNumber?: string;
+        };
+        biometricData?: {
+            selfie?: string;
+        };
+        signatureData?: {
+            signatureImage?: string;
+        };
+        additionalDocuments?: UploadedDocument[];
+    };
+    biometricData?: {
+        selfie?: string;
+    };
+    additionalData: {
+        uniqueRequestId: string;
+        manualReviewRequired: 'Y' | 'N';
+        bypassAgeValidation: 'Y' | 'N';
+        deDuplicationRequired: 'Y' | 'N';
+        bypassNameMatching: 'Y' | 'N';
+        postDataAPIRequired: 'Y' | 'N';
+        sendInputImagesInPost: 'Y' | 'N';
+        sendProcessedImagesInPost: 'Y' | 'N';
+        needImmediateResponse: 'Y' | 'N';
+        deduplicationSynchronous: 'Y' | 'N';
+        verifyDataWithHost: 'Y' | 'N';
+        idBackImageRequired: 'Y' | 'N';
+        stripSpecialCharacters: 'Y' | 'N';
+        idImageResolutionCheck: 'Y' | 'N';
+        metadata?: string;
+    };
+    employee?: {
+        companyId?: number;
+    };
+};
+export type CaptureAttemptMetadata = {
+    autoCapture: 'Y' | 'N';
+    captureTime: number;
+    operationTime?: number;
+};
+export type SubmissionMetadata = {
+    selfie: CaptureAttemptMetadata[];
+    back: CaptureAttemptMetadata[];
+    front: CaptureAttemptMetadata[];
+    sdkVersion: 'WebSDK_9.5.13.2.0';
+    isRealIDCheckRequired: 'true' | 'false';
+    os?: string;
+    osVersion?: string;
+    browserVersion?: string;
+    Resolution?: string;
+    GeoLocation?: string;
+};
+export type SubmissionResponse = {
+    status: {
+        statusCode: string;
+        statusMessage?: string;
+        errorData?: string;
+    };
+    resultData: Record<string, unknown>;
+};
+export type LivenessCheckRequest = {
+    securityData: {
+        userName: string;
+        password: string;
+        merchantId: number;
+    };
+    customerData: {
+        biometricData: {
+            selfie: string;
+        };
+    };
+    additionalData: {
+        uniqueRequestId: string;
+        stripSpecialCharacters: 'Y' | 'N';
+        estimateAge: 'Y' | 'N';
+        predictGender: 'Y' | 'N';
+    };
+};
+export type LiveCheckResponse = {
+    status: {
+        statusCode: string;
+        statusMessage: string;
+        errorData: string;
+    };
+    resultData: {
+        verificationResult: string;
+        eyeCovering: 'true' | 'false';
+        faceMask: 'true' | 'false';
+        headCovering: 'true' | 'false';
+        cellPhone: 'true' | 'false';
+    };
+};
+export type SubmissionState = {
+    submit: () => Promise<SubmissionResponse | null>;
+    submissionStatus: SubmissionStatus;
+    submissionRequest: SubmissionRequest | null;
+    submissionResponse: SubmissionResponse | null;
+    submissionEnvironment: SubmissionEnvironment;
+    idFrontImage: string | null;
+    idBackImage: string | null;
+    passportImage: string | null;
+    selfieImage: string | null;
+    signatureData: SignatureData | null;
+    additionalDocuments: UploadedDocument[] | null;
+    setIdFrontImage: (image: string) => void;
+    setIdBackImage: (image: string) => void;
+    setPassportImage: (image: string) => void;
+    setSelfieImage: (image: string) => void;
+    setSignatureData: (signatureData: SignatureData) => void;
+    setAdditionalDocuments: (uploadedDocuments: UploadedDocument[]) => void;
+    logIdFrontCaptureAttempt: (attempt: CaptureAttemptMetadata) => void;
+    logIdBackCaptureAttempt: (attempt: CaptureAttemptMetadata) => void;
+    logSelfieCaptureAttempt: (attempt: CaptureAttemptMetadata) => void;
+    checkLiveness: (imageDataUrl: string) => Promise<LiveCheckResponse>;
+    retryLocationAccess: () => void;
+};
+export declare const SubmissionContext: import("react").Context<SubmissionState>;
+export declare function determineSubmissionHost(environment: SubmissionEnvironment, token?: string): string;
+export declare function determineSubmissionEndpoint(action: SubmissionAction, hasId: boolean, hasSelfie: boolean, hasToken: boolean): string;
+export declare function liveCheckEndpoint(hasToken: boolean): string;
+export declare function apiHeaders(token?: string): HeadersInit;

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import { IdValidation, IdValidationProps } from './components/customer_flows/IdValidation';
+import { FaceValidation, FaceValidationProps } from './components/customer_flows/FaceValidation';
+import { IdAndFaceValidation, IdAndFaceValidationProps } from './components/customer_flows/IdAndFaceValidation';
+import { CustomerIdAndBiometricsEnrollment, CustomerEnrollmentProps } from './components/customer_flows/CustomerIdAndBiometricsEnrollment';
+import { CustomerVerification, CustomerVerificationProps } from './components/customer_flows/CustomerVerification';
+import { CustomerIdentification, CustomerIdentificationProps } from './components/customer_flows/CustomerIdentification';
+import { preloadModels } from './lib/models/preloadModels';
+import { CustomerBiometricsEnrollment } from './components/customer_flows/CustomerBiometricsEnrollment';
+import { SignatureKYC, SignatureKYCProps } from './components/customer_flows/SignatureKYC';
+export declare const renderIdValidation: (targetElement: Element | DocumentFragment | string, options: IdValidationProps, fullscreen?: boolean) => void;
+export declare const renderFaceValidation: (targetElement: Element | DocumentFragment | string, options: FaceValidationProps, fullscreen?: boolean) => void;
+export declare const renderIdAndFaceValidation: (targetElement: Element | DocumentFragment | string, options: IdAndFaceValidationProps, fullscreen?: boolean) => void;
+export declare const renderCustomerIdAndBiometricsEnrollment: (targetElement: Element | DocumentFragment | string, options: CustomerEnrollmentProps, fullscreen?: boolean) => void;
+export declare const renderCustomerBiometricsEnrollment: (targetElement: Element | DocumentFragment | string, options: CustomerEnrollmentProps, fullscreen?: boolean) => void;
+export declare const renderCustomerVerification: (targetElement: Element | DocumentFragment | string, options: CustomerVerificationProps, fullscreen?: boolean) => void;
+export declare const renderCustomerIdentification: (targetElement: Element | DocumentFragment | string, options: CustomerIdentificationProps, fullscreen?: boolean) => void;
+export declare const renderSignatureKYC: (targetElement: Element | DocumentFragment | string, options: SignatureKYCProps, fullscreen?: boolean) => void;
+export type IDmissionSDK = {
+    renderIdValidation: typeof renderIdValidation;
+    renderFaceValidation: typeof renderFaceValidation;
+    renderIdAndFaceValidation: typeof renderIdAndFaceValidation;
+    renderCustomerIdAndBiometricsEnrollment: typeof renderCustomerIdAndBiometricsEnrollment;
+    renderCustomerBiometricsEnrollment: typeof renderCustomerBiometricsEnrollment;
+    renderCustomerVerification: typeof renderCustomerVerification;
+    renderCustomerIdentification: typeof renderCustomerIdentification;
+    renderSignatureKYC: typeof renderSignatureKYC;
+    preloadModels: typeof preloadModels;
+};
+declare global {
+    var IDmissionSDK: IDmissionSDK;
+}
+export { preloadModels, IdValidation, FaceValidation, IdAndFaceValidation, CustomerIdAndBiometricsEnrollment, CustomerBiometricsEnrollment, CustomerVerification, CustomerIdentification, SignatureKYC, };

package/dist/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./sdk2.cjs.production.js')
+} else {
+  module.exports = require('./sdk2.cjs.development.js')
+}

package/dist/lib/barcode/Native.d.ts

@@ -0,0 +1 @@
+export function getNativeBarcodeReaderResult(image: any): Promise<any>;

package/dist/lib/barcode/Parse.d.ts

@@ -0,0 +1,53 @@
+declare function processBarcode(rawValue: string): Promise<unknown>;
+declare const companyXSLTData: {
+    code: string;
+    match_pattern: string;
+    xslt_template: string;
+    is_disabled: string;
+    Country: string;
+    State: string;
+    DocumentType: string;
+    Side: string;
+    barcode_type: string;
+}[];
+declare function isBarcodePresentForSelectedCriteria(idSide: string): Promise<{
+    code: string;
+    match_pattern: string;
+    xslt_template: string;
+    is_disabled: string;
+    Country: string;
+    State: string;
+    DocumentType: string;
+    Side: string;
+    barcode_type: string;
+} | null>;
+type XSLTResponse = {
+    data: {
+        data: {
+            response: {
+                status: {
+                    code: string;
+                };
+                listData: {
+                    fieldValues: string[];
+                };
+            };
+        };
+    };
+};
+declare function getCompanyXSLTData(serviceParams: {
+    baseUrl: string;
+    tokenId: string;
+}): Promise<void>;
+declare function getXSLTDataHandler(resp: XSLTResponse | null): void;
+declare function transformBarcodeUsingXSLT(barcodeScanResult: string, xsl: string): Promise<unknown>;
+declare class Transformation {
+    xml: string;
+    xmlDoc: any;
+    xslt: any;
+    xsltDoc: any;
+    setXml(x: string): this;
+    setXslt(x: string): this;
+    transform(): Promise<unknown>;
+}
+declare function browserSupportsXSLT(): boolean;

package/dist/lib/barcode/Scan.d.ts

@@ -0,0 +1,3 @@
+import { PDF417DetectionResult } from './Native';
+export declare function supportsNativeBarcodeScanning(): boolean;
+export declare function scanBarcode(blob: Blob, bbox?: number[]): Promise<PDF417DetectionResult | null>;

package/dist/lib/barcode/ZXing.d.ts

@@ -0,0 +1 @@
+export function getZxingBarcodeReaderResult(image: any, rotate?: boolean): Promise<any>;

package/dist/lib/camera/Camera.d.ts

@@ -0,0 +1,59 @@
+/// <reference types="react" />
+/// <reference types="w3c-image-capture" />
+export type Camera = {
+    stream: MediaStream;
+    isRearFacing: boolean;
+    release: () => void;
+    width: number;
+    height: number;
+};
+export type CameraResolution = 'LOW' | 'MID' | 'MAX';
+export declare function selectAndOpenCamera(resolution?: CameraResolution): Promise<Camera>;
+export declare function drawFrameToCanvas(videoElement: HTMLVideoElement, canvasElement: HTMLCanvasElement): CanvasRenderingContext2D | null;
+export declare function getFrameFromVideo(videoElement: HTMLVideoElement, canvasElement: HTMLCanvasElement | null): ImageData | null;
+export declare function getVideoDeviceMaxDimensions(deviceInfo: MediaDeviceInfo): Promise<{
+    width: number;
+    height: number;
+}>;
+type Resolution = {
+    label: string;
+    width: number;
+    height: number;
+    ratio: string;
+};
+export declare const quickScan: Resolution[];
+export declare const useHighestResCaptureDevice: ({ preferFrontFacingCamera, preferContinuityCamera, requestMicrophoneAccess, }?: {
+    preferFrontFacingCamera: boolean;
+    preferContinuityCamera: boolean;
+    requestMicrophoneAccess: boolean;
+}) => {
+    videoRef: import("react").MutableRefObject<HTMLVideoElement | null>;
+    videoDevice: MediaDeviceInfo | null;
+    videoLoaded: boolean;
+    setVideoLoaded: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    cameraRef: import("react").MutableRefObject<Camera | null>;
+    cameraAccessDenied: boolean;
+    retryCameraAccess: () => void;
+    releaseCameraAccess: () => void;
+    iphoneContinuityCameraAvailable: boolean;
+    iphoneContinuityCameraAllowed: boolean;
+    setIphoneContinuityCameraAllowed: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    captureDevice: ImageCapture | null;
+    grabFrame: () => Promise<ImageBitmap | null>;
+    takePhoto: () => Promise<Blob | null>;
+};
+export declare const useDualResCaptureDevice: () => {
+    minVideoRef: import("react").MutableRefObject<HTMLVideoElement | null>;
+    maxVideoRef: import("react").MutableRefObject<HTMLVideoElement | null>;
+    minCamera: Camera | null;
+    maxCamera: Camera | null;
+    minVideoLoaded: boolean;
+    maxVideoLoaded: boolean;
+    setMinVideoLoaded: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setMaxVideoLoaded: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    minCaptureDevice: ImageCapture | null;
+    maxCaptureDevice: ImageCapture | null;
+    grabLowResFrame: () => Promise<ImageBitmap | undefined>;
+    takeFullResPhoto: () => Promise<Blob | null>;
+};
+export {};

package/dist/lib/camera/hooks.d.ts

@@ -0,0 +1,9 @@
+import { MutableRefObject } from 'react';
+import { Camera, CameraResolution } from './Camera';
+export declare const useCamera: (resolution?: CameraResolution) => {
+    camera: Camera | null;
+    videoRef: MutableRefObject<HTMLVideoElement | null>;
+    videoLoaded: boolean;
+    setVideoLoaded: (is: boolean) => void;
+};
+export declare const useWindowFocus: () => boolean;

package/dist/lib/camera/useVideoRecorder.d.ts

@@ -0,0 +1,7 @@
+import { Camera } from './Camera';
+export declare const useVideoRecorder: (camera: Camera | null) => {
+    isRecording: boolean;
+    startRecording: () => void;
+    stopRecording: () => void;
+    videoUrl: string | null;
+};

package/dist/lib/locales/en/translation.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/lib/locales/es/translation.d.ts

@@ -0,0 +1,50 @@
+declare const _default: {
+    'Use your device camera to capture your ID': string;
+    'Use your iPhone as a webcam': string;
+    'Models warming up...': string;
+    'Camera initializing...': string;
+    'Camera access blocked': string;
+    'Location access blocked': string;
+    Continue: string;
+    'Your camera permission is disabled': string;
+    'This application requires access to your camera to continue. Please accept the permission once prompted by the browser. If the browser does not prompt for camera permissions, you must go to settings and provide camera access to the current browser.': string;
+    'Your location permission is disabled': string;
+    'This application requires access to your location to continue. Please accept the permission once prompted by the browser. If the browser does not prompt for location permissions, you must go to settings and provide location access to the current browser.': string;
+    Retry: string;
+    'Scan the front of ID': string;
+    'Scan the back of ID': string;
+    'Scan the ID page of passport': string;
+    'ID Card Front': string;
+    'ID Card Back': string;
+    Passport: string;
+    'Capturing...': string;
+    'Capture failed!': string;
+    'Please flip your ID card...': string;
+    'ID Capture Successful': string;
+    'Verify the entire ID was captured clearly with no glare.': string;
+    Submit: string;
+    'Submitting...': string;
+    'Use your device camera to capture your face': string;
+    'Remove Sunglasses & Hat': string;
+    'Avoid Excessive Backlighting': string;
+    'Hold still for a few seconds...': string;
+    'Look straight into the camera...': string;
+    'Move back...': string;
+    'Move forward...': string;
+    'Move to the center...': string;
+    'Please remove your eye coverings (sunglasses, eye patch, etc.)...': string;
+    'Please remove your head coverings (hat, scarf, etc.)...': string;
+    'Please remove your mask...': string;
+    'Live face not detected, please try again': string;
+    Exit: string;
+    'Face liveness has been verified!': string;
+    Done: string;
+    'Customer has been identified!': string;
+    'Customer not found': string;
+    'Additional document capture': string;
+    Next: string;
+    'Please sign the box below': string;
+    Accept: string;
+    Clear: string;
+};
+export default _default;

package/dist/lib/locales/index.d.ts

@@ -0,0 +1,60 @@
+export declare const ALL_LANGUAGES: readonly ["auto", "en", "es"];
+export type LangOptions = typeof ALL_LANGUAGES;
+export type LangOption = LangOptions[number];
+export declare const resources: {
+    en: {
+        translation: {};
+    };
+    es: {
+        translation: {
+            'Use your device camera to capture your ID': string;
+            'Use your iPhone as a webcam': string;
+            'Models warming up...': string;
+            'Camera initializing...': string;
+            'Camera access blocked': string;
+            'Location access blocked': string;
+            Continue: string;
+            'Your camera permission is disabled': string;
+            'This application requires access to your camera to continue. Please accept the permission once prompted by the browser. If the browser does not prompt for camera permissions, you must go to settings and provide camera access to the current browser.': string;
+            'Your location permission is disabled': string;
+            'This application requires access to your location to continue. Please accept the permission once prompted by the browser. If the browser does not prompt for location permissions, you must go to settings and provide location access to the current browser.': string;
+            Retry: string;
+            'Scan the front of ID': string;
+            'Scan the back of ID': string;
+            'Scan the ID page of passport': string;
+            'ID Card Front': string;
+            'ID Card Back': string;
+            Passport: string;
+            'Capturing...': string;
+            'Capture failed!': string;
+            'Please flip your ID card...': string;
+            'ID Capture Successful': string;
+            'Verify the entire ID was captured clearly with no glare.': string;
+            Submit: string;
+            'Submitting...': string;
+            'Use your device camera to capture your face': string;
+            'Remove Sunglasses & Hat': string;
+            'Avoid Excessive Backlighting': string;
+            'Hold still for a few seconds...': string;
+            'Look straight into the camera...': string;
+            'Move back...': string;
+            'Move forward...': string;
+            'Move to the center...': string;
+            'Please remove your eye coverings (sunglasses, eye patch, etc.)...': string;
+            'Please remove your head coverings (hat, scarf, etc.)...': string;
+            'Please remove your mask...': string;
+            'Live face not detected, please try again': string;
+            Exit: string;
+            'Face liveness has been verified!': string;
+            Done: string;
+            'Customer has been identified!': string;
+            'Customer not found': string;
+            'Additional document capture': string;
+            Next: string;
+            'Please sign the box below': string;
+            Accept: string;
+            Clear: string;
+        };
+    };
+};
+export declare const useLanguage: (lang: LangOption) => void;

package/dist/lib/models/DocumentDetection.d.ts

@@ -0,0 +1,27 @@
+import * as tf from '@tensorflow/tfjs';
+export declare enum DocumentType {
+    NONE = "NONE",
+    ID_CARD = "ID_CARD",
+    ID_CARD_FRONT = "ID_CARD_FRONT",
+    ID_CARD_BACK = "ID_CARD_BACK",
+    PASSPORT = "PASSPORT"
+}
+export declare function loadDocumentDetectionModel(url: string): Promise<tf.GraphModel>;
+export type RawEdgeDetectionResult = tf.Tensor<tf.Rank>[];
+export declare function makeDocumentDetectionPredictions(model: tf.GraphModel, image: ImageBitmap | ImageData | HTMLImageElement): Promise<[RawEdgeDetectionResult, () => void]>;
+export type DocumentDetectionResults = {
+    boxes: number[][];
+    scores: number[];
+    labels: number[];
+};
+export declare const labelMap: {
+    [id: number]: Label;
+};
+export type Label = 'Document' | 'MRZ' | 'PDF417' | 'Primary face' | 'Secondary face' | 'Glare' | 'Punch Hole' | 'Passport Page';
+export declare function runDocumentDetection(model: tf.GraphModel, image: ImageBitmap | ImageData | HTMLImageElement): Promise<DocumentDetectionResults>;
+export type DetectedObject = {
+    score: number;
+    bbox: number[];
+    label: Label;
+};
+export declare function bboxToDetectedObjectUnscaled(box: number[], score: number, label: number): DetectedObject;

package/dist/lib/models/FaceDetection.d.ts

@@ -0,0 +1,5 @@
+import * as faceDetection from '@tensorflow-models/face-detection';
+import '@mediapipe/face_detection';
+export type FaceDetectionModel = faceDetection.FaceDetector;
+export declare function loadFaceDetectionModel(): Promise<FaceDetectionModel>;
+export declare function makeFaceDetectionPrediction(model: FaceDetectionModel, imageData: ImageBitmap | HTMLCanvasElement): Promise<[faceDetection.Face[], number]>;

package/dist/lib/models/Focus.d.ts

@@ -0,0 +1,7 @@
+import * as tf from '@tensorflow/tfjs';
+export declare function loadFocusModel(url: string): Promise<tf.LayersModel>;
+type BlurScore = number;
+type FocusScore = number;
+export type FocusPrediction = [BlurScore, FocusScore];
+export declare function makeFocusPrediction(model: tf.LayersModel, imageData: ImageBitmap | ImageData): Promise<[FocusPrediction, () => void]>;
+export {};

package/dist/lib/models/preloadModels.d.ts

@@ -0,0 +1,5 @@
+export declare const preloadModels: ({ documentDetectionModel, focusModel, skipFaceDetectionModel, }: {
+    documentDetectionModel?: string | false | undefined;
+    focusModel?: string | false | undefined;
+    skipFaceDetectionModel?: boolean | undefined;
+}) => Promise<void>;

package/dist/lib/tfworker/Actions.d.ts

@@ -0,0 +1,29 @@
+import { DocumentDetectionResults } from '../models/DocumentDetection';
+import { FocusPrediction } from '../models/Focus';
+export type Action = {
+    type: 'loadModel';
+    payload: {
+        name: 'documentDetection' | 'focus';
+        url: string;
+    };
+} | {
+    type: 'modelLoaded';
+    payload: {
+        name: 'documentDetection' | 'focus';
+    };
+} | {
+    type: 'makePrediction';
+    payload: {
+        image: ImageBitmap;
+    };
+} | {
+    type: 'predictionMade';
+    payload: {
+        prediction: Prediction;
+    };
+};
+export type Prediction = {
+    image: ImageBitmap;
+    documentDetection: DocumentDetectionResults;
+    focus: FocusPrediction;
+};

package/dist/lib/tfworker/Client.d.ts

@@ -0,0 +1,14 @@
+import { Action, Prediction } from './Actions';
+export declare class WorkerClient {
+    worker: Worker;
+    documentDetectionModelLoaded: boolean;
+    focusModelLoaded: boolean;
+    constructor();
+    onMessage(handler: (message: MessageEvent) => void): void;
+    postMessage(message: Action): void;
+    loadDocumentDetectionModel(url: string): Promise<void>;
+    loadFocusModel(url: string): Promise<void>;
+    loadModels(documentDetectionModelUrl: string, focusModelUrl: string): Promise<void>;
+    makePrediction(image: ImageBitmap): void;
+    onPrediction(handler: (prediction: Prediction) => void): void;
+}

package/dist/lib/tfworker/TfWorker.d.ts

@@ -0,0 +1,8 @@
+declare function makeDocumentDetectionPredictions(model: any, image: any): Promise<{
+    boxes: any;
+    scores: any;
+    labels: any;
+}>;
+declare function makeFocusPrediction(model: any, imageData: any): Promise<any>;
+declare let documentDetectionModel: any;
+declare let focusModel: any;

package/dist/lib/utils/cropToShoulders.d.ts

@@ -0,0 +1,2 @@
+import { Face } from '@tensorflow-models/face-detection';
+export declare function cropToShoulders(frame: ImageBitmap, face: Face): string;

package/dist/lib/utils/dataUrlToBase64.d.ts

@@ -0,0 +1,3 @@
+export declare function dataUrlToBase64(url: string): Promise<string>;
+export declare function dataUrlToBase64Sync(url: string): string;
+export declare function contentDispositionFromDataUrl(url: string): string;

package/dist/lib/utils/deviceDetection.d.ts

@@ -0,0 +1,2 @@
+export declare function iOS(): boolean;
+export declare function wideAngleIsBetter(): boolean;

package/dist/lib/utils/getBlobDimensions.d.ts

@@ -0,0 +1 @@
+export declare function getBlobDimensions(blob: Blob): Promise<[number, number]>;