idmission-web-sdk 0.0.1

package/dist/components/customer_verification/CustomerVerificationWizard.d.ts

@@ -0,0 +1,33 @@
+import { ReactElement } from 'react';
+import { SubmissionResponse } from '../../contexts/SubmissionContext';
+import { SelfieCaptureVerbiage } from '../selfie_capture/SelfieCapture';
+export type CustomerVerificationAssets = {
+    instructionImageUrl?: string;
+    failureImageUrl?: string;
+};
+export type CustomerVerificationVerbiage = SelfieCaptureVerbiage & {
+    loadingOverlayHeadingText?: string;
+    loadingOverlayRemoveEyeCoveringsText?: string;
+    loadingOverlayAvoidExcessiveBacklightingText?: string;
+    loadingOverlayContinueText?: string;
+    loadingOverlayCameraInitializingText?: string;
+    loadingOverlayModelsWarmingUpText?: string;
+    successHeadingText?: string;
+    successRetryBtnText?: string;
+    successDoneBtnText?: string;
+    failureHeadingText?: string;
+    failureRetryBtnText?: string;
+    failureExitBtnText?: string;
+};
+export type CustomerVerificationWizardProps = {
+    onComplete?: (response: SubmissionResponse) => void;
+    onCustomerMatched?: (response: SubmissionResponse) => void;
+    onCustomerNotMatched?: (response: SubmissionResponse) => void;
+    onExitAfterFailure?: () => void;
+    onCaptureGuidanceTimeout?: () => void;
+    captureGuidanceTimeoutDurationMs?: number;
+    assets?: CustomerVerificationAssets;
+    verbiage?: CustomerVerificationVerbiage;
+    debugMode?: boolean;
+};
+export declare const CustomerVerificationWizard: ({ onComplete, onCustomerMatched, onCustomerNotMatched, onExitAfterFailure, onCaptureGuidanceTimeout, captureGuidanceTimeoutDurationMs, assets, verbiage, debugMode, }: CustomerVerificationWizardProps) => ReactElement;

package/dist/components/face_liveness/FaceCaptureGuideOverlay.d.ts

@@ -0,0 +1,6 @@
+import { ReactElement } from 'react';
+export type FaceCaptureGuideOverlayProps = {
+    borderWidth?: number;
+    borderColor?: string;
+};
+export declare const FaceCaptureGuideOverlay: ({ borderWidth, borderColor, }: FaceCaptureGuideOverlayProps) => ReactElement;

package/dist/components/face_liveness/FaceLivenessCapture.d.ts

@@ -0,0 +1,16 @@
+import { ReactElement } from 'react';
+import { SelfieCaptureVerbiage } from '../selfie_capture/SelfieCapture';
+export type FaceLivenessCaptureVerbiage = SelfieCaptureVerbiage & {
+    guidanceRemoveEyeCoveringsText?: string;
+    guidanceRemoveHeadCoveringsText?: string;
+    guidanceRemoveMaskText?: string;
+};
+export type FaceLivenessCaptureProps = {
+    onCapture?: () => void;
+    onSuccess?: (faceCropImageUrl: string) => void;
+    onTimeout?: () => void;
+    timeoutDurationMs?: number;
+    verbiage?: FaceLivenessCaptureVerbiage;
+    debugMode?: boolean;
+};
+export declare const FaceLivenessCapture: ({ onCapture, onSuccess, onTimeout, timeoutDurationMs, verbiage, debugMode, }: FaceLivenessCaptureProps) => ReactElement;

package/dist/components/face_liveness/FaceLivenessFailure.d.ts

@@ -0,0 +1,11 @@
+import { ReactElement } from 'react';
+export type FaceLivenessFailureProps = {
+    headingText?: string;
+    retryBtnText?: string;
+    exitBtnText?: string;
+    imageUrl?: string;
+    canRetry?: boolean;
+    onRetryClick?: () => void;
+    onExitClick?: () => void;
+};
+export declare const FaceLivenessFailure: ({ headingText, retryBtnText, exitBtnText, imageUrl, canRetry, onRetryClick, onExitClick, }: FaceLivenessFailureProps) => ReactElement;

package/dist/components/face_liveness/FaceLivenessSuccess.d.ts

@@ -0,0 +1,10 @@
+import { ReactElement } from 'react';
+export type FaceLivenessSuccessProps = {
+    headingText?: string;
+    retryBtnText?: string;
+    doneBtnText?: string;
+    imageUrl: string;
+    onDoneClick?: () => void;
+    onRetryClick?: () => void;
+};
+export declare const FaceLivenessSuccess: ({ headingText, retryBtnText, doneBtnText, imageUrl, onDoneClick, onRetryClick, }: FaceLivenessSuccessProps) => ReactElement;

package/dist/components/face_liveness/FaceLivenessWizard.d.ts

@@ -0,0 +1,33 @@
+import { ReactElement } from 'react';
+import { FaceLivenessCaptureVerbiage } from './FaceLivenessCapture';
+import { SubmissionResponse } from '../../contexts/SubmissionContext';
+export type FaceLivenessAssets = {
+    instructionImageUrl?: string;
+    failureImageUrl?: string;
+};
+export type FaceLivenessVerbiage = FaceLivenessCaptureVerbiage & {
+    loadingOverlayHeadingText?: string;
+    loadingOverlayRemoveEyeCoveringsText?: string;
+    loadingOverlayAvoidExcessiveBacklightingText?: string;
+    loadingOverlayContinueText?: string;
+    loadingOverlayCameraInitializingText?: string;
+    loadingOverlayModelsWarmingUpText?: string;
+    successHeadingText?: string;
+    successRetryBtnText?: string;
+    successDoneBtnText?: string;
+    failureHeadingText?: string;
+    failureRetryBtnText?: string;
+    failureExitBtnText?: string;
+};
+export type FaceLivenessWizardProps = {
+    onComplete?: (submissionResponse: SubmissionResponse | null) => void;
+    onSuccess?: (submissionResponse: SubmissionResponse | null) => void;
+    onTimeout?: (submissionResponse: SubmissionResponse | null) => void;
+    onExitAfterFailure?: (submissionResponse: SubmissionResponse | null) => void;
+    timeoutDurationMs?: number;
+    maxRetries?: number;
+    assets?: FaceLivenessAssets;
+    verbiage?: FaceLivenessVerbiage;
+    debugMode?: boolean;
+};
+export declare const FaceLivenessWizard: ({ onComplete, onSuccess, onTimeout, onExitAfterFailure, timeoutDurationMs, maxRetries, debugMode, verbiage, assets, }: FaceLivenessWizardProps) => ReactElement;

package/dist/components/id_capture/DocumentCaptureGuideOverlay.d.ts

@@ -0,0 +1,14 @@
+import { ReactElement } from 'react';
+export type DocumentCaptureGuideOverlayProps = {
+    width?: number;
+    height?: number;
+    padding?: number;
+    borderWidth?: number;
+    borderColor?: string;
+    isMirrored?: boolean;
+    instruction?: string;
+    portraitGuidesImageUrl?: string;
+    landscapeGuidesImageUrl?: string;
+    onClick?: () => void;
+};
+export declare const DocumentCaptureGuideOverlay: ({ width, height, padding, borderWidth, borderColor, isMirrored, instruction, portraitGuidesImageUrl, landscapeGuidesImageUrl, onClick, }: DocumentCaptureGuideOverlayProps) => ReactElement;

package/dist/components/id_capture/FlipIdPrompt.d.ts

@@ -0,0 +1,9 @@
+import { ReactElement } from 'react';
+export type FlipIdPromptProps = {
+    instructionText?: string;
+    frontPortraitGuidesImage?: string;
+    frontLandscapeGuidesImage?: string;
+    backPortraitGuidesImage?: string;
+    backLandscapeGuidesImage?: string;
+};
+export declare const FlipIdPrompt: ({ instructionText, frontPortraitGuidesImage, frontLandscapeGuidesImage, backPortraitGuidesImage, backLandscapeGuidesImage, }: FlipIdPromptProps) => ReactElement;

package/dist/components/id_capture/IdCapture.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import '../../lib/utils/OffscreenCanvasPolyfill';
+import { DocumentType } from '../../lib/models/DocumentDetection';
+import { PDF417DetectionResult } from '../../lib/barcode/Native';
+import { CaptureAttemptMetadata } from '../../contexts/SubmissionContext';
+export type IdDocumentPrediction = {
+    documentDetected: boolean;
+    documentType: DocumentType;
+    documentScore: number;
+    mrzDetected: boolean;
+    mrzScore: number;
+    focusThresholdMet: boolean;
+    focusScore: number;
+};
+export type IdCaptureAssets = {
+    portraitGuidesImageUrl?: string;
+    landscapeGuidesImageUrl?: string;
+};
+export type IdCaptureVerbiage = {
+    instructionText?: string;
+    capturingText?: string;
+    captureFailedText?: string;
+};
+export type IdCaptureProps = {
+    documentDetectionNonMaxSuppressionEnabled: boolean;
+    requiredDocumentType?: DocumentType;
+    autoCaptureEnabled?: boolean;
+    autoCaptureScoreThreshold?: number;
+    autoCaptureGoodFramesRequired?: number;
+    autoCaptureBarcodeRequired?: boolean | 'mobile';
+    mrzDetectionScoreThreshold?: number;
+    passportPageDetectionThreshold?: number;
+    pdf417DetectionThreshold?: number;
+    barcodeScanningEnabled?: boolean;
+    maxBarcodeScanAttempts?: number;
+    focusScoreThreshold?: number;
+    onPrediction?: (prediction: IdDocumentPrediction) => void;
+    onBarcodeScanned?: (result: PDF417DetectionResult) => void;
+    onCapture?: (frame: string, width: number, height: number, metadata: CaptureAttemptMetadata) => void;
+    processingScreen?: React.ReactElement;
+    processingDelay?: number;
+    assets?: IdCaptureAssets;
+    verbiage?: IdCaptureVerbiage;
+    debugMode?: boolean;
+};
+export declare const IdCapture: ({ documentDetectionNonMaxSuppressionEnabled, requiredDocumentType, autoCaptureEnabled, autoCaptureScoreThreshold, autoCaptureGoodFramesRequired, autoCaptureBarcodeRequired, mrzDetectionScoreThreshold, passportPageDetectionThreshold, pdf417DetectionThreshold, focusScoreThreshold, barcodeScanningEnabled, maxBarcodeScanAttempts, onPrediction, onBarcodeScanned, onCapture, processingScreen, processingDelay, assets, verbiage, debugMode, }: IdCaptureProps) => React.ReactElement;

package/dist/components/id_capture/IdCaptureLoadingOverlay.d.ts

@@ -0,0 +1,13 @@
+import { ReactElement } from 'react';
+export type IdCaptureLoadingOverlayProps = {
+    headingText?: string;
+    useContinuityCameraText?: string;
+    modelsWarmingUpText?: string;
+    cameraInitializingText?: string;
+    cameraAccessBlockedText?: string;
+    continueText?: string;
+    instructionImageUrl?: string;
+    accessBlockedImageUrl?: string;
+    onDismissed?: () => void;
+};
+export declare const IdCaptureLoadingOverlay: ({ headingText, useContinuityCameraText, modelsWarmingUpText, cameraInitializingText, cameraAccessBlockedText, continueText, instructionImageUrl, accessBlockedImageUrl, onDismissed, }: IdCaptureLoadingOverlayProps) => ReactElement;

package/dist/components/id_capture/IdCaptureModelsProvider.d.ts

@@ -0,0 +1,7 @@
+import { ReactElement, ReactNode } from 'react';
+export type IdCaptureModelsProviderProps = {
+    children: ReactNode;
+    documentDetectionModelUrl?: string | undefined;
+    focusModelUrl?: string | undefined;
+};
+export declare const IdCaptureModelsProvider: ({ children, documentDetectionModelUrl, focusModelUrl, }: IdCaptureModelsProviderProps) => ReactElement;

package/dist/components/id_capture/IdCaptureSubmitBtn.d.ts

@@ -0,0 +1,7 @@
+import { ReactElement, ReactNode } from 'react';
+export type IdCaptureSubmitBtnProps = {
+    disabled?: boolean;
+    onClick?: () => void;
+    children: ReactNode;
+};
+export declare const IdCaptureSubmitBtn: ({ disabled, onClick, children, }: IdCaptureSubmitBtnProps) => ReactElement;

package/dist/components/id_capture/IdCaptureSuccess.d.ts

@@ -0,0 +1,18 @@
+import { ReactElement } from 'react';
+import { CapturedDocuments } from '../additional_document_capture/CapturedDocuments';
+import { PDF417DetectionResult } from '../../lib/barcode/Native';
+export type IdCaptureSuccessProps = {
+    capturedDocuments: CapturedDocuments;
+    barcodeResult?: PDF417DetectionResult | null;
+    onSubmitClick?: () => void;
+    onRetryClick?: () => void;
+    headingText?: string;
+    idCardFrontText?: string;
+    idCardBackText?: string;
+    passportText?: string;
+    instructionText?: string;
+    retryText?: string;
+    submittingText?: string;
+    submitText?: string;
+};
+export declare const IdCaptureSuccess: ({ capturedDocuments, onSubmitClick, onRetryClick, headingText, idCardFrontText, idCardBackText, passportText, instructionText, retryText, submittingText, submitText, }: IdCaptureSuccessProps) => ReactElement;

package/dist/components/id_capture/IdCaptureWizard.d.ts

@@ -0,0 +1,56 @@
+import { ReactElement } from 'react';
+export type IdCaptureAssets = {
+    documentDetectionModelUrl?: string;
+    focusModelUrl?: string;
+    loadingOverlayInstructionImageUrl?: string;
+    idCardFrontPortraitGuidesImageUrl?: string;
+    idCardFrontLandscapeGuidesImageUrl?: string;
+    idCardBackPortraitGuidesImageUrl?: string;
+    idCardBackLandscapeGuidesImageUrl?: string;
+    passportPortraitGuidesImageUrl?: string;
+    passportLandscapeGuidesImageUrl?: string;
+};
+export type IdCaptureVerbiage = {
+    loadingOverlayHeadingText?: string;
+    loadingOverlayUseContinuityCameraText?: string;
+    loadingOverlayModelsWarmingUpText?: string;
+    loadingOverlayCameraInitializingText?: string;
+    loadingOverlayCameraAccessBlockedText?: string;
+    loadingOverlayContinueText?: string;
+    idCardFrontInstructionText?: string;
+    idCardBackInstructionText?: string;
+    passportInstructionText?: string;
+    flipIdInstructionText?: string;
+    capturingText?: string;
+    captureFailedText?: string;
+    successHeadingText?: string;
+    successIdCardFrontText?: string;
+    successIdCardBackText?: string;
+    successPassportText?: string;
+    successInstructionText?: string;
+    successRetryText?: string;
+    successSubmittingText?: string;
+    successSubmitText?: string;
+};
+export type IdCaptureSubmission = {
+    idFrontImage: string | null;
+    idBackImage: string | null;
+    passportImage: string | null;
+};
+export type IdCaptureWizardProps = {
+    onSuccess?: (submission: IdCaptureSubmission) => void;
+    documentDetectionNonMaxSuppressionEnabled?: boolean;
+    autoCaptureEnabled?: boolean;
+    autoCaptureGoodFramesRequired?: number;
+    autoCaptureBarcodeRequired?: 'mobile' | boolean;
+    barcodeScanningEnabled?: boolean;
+    idCardAutoCaptureScoreThreshold?: number;
+    passportAutoCaptureScoreThreshold?: number;
+    mrzDetectionScoreThreshold?: number;
+    idCardFocusScoreThreshold?: number;
+    passportFocusScoreThreshold?: number;
+    verbiage?: IdCaptureVerbiage;
+    assets?: IdCaptureAssets;
+    debugMode?: boolean;
+};
+export declare const IdCaptureWizard: ({ onSuccess, documentDetectionNonMaxSuppressionEnabled, autoCaptureEnabled, autoCaptureGoodFramesRequired, autoCaptureBarcodeRequired, barcodeScanningEnabled, idCardAutoCaptureScoreThreshold, passportAutoCaptureScoreThreshold, mrzDetectionScoreThreshold, idCardFocusScoreThreshold, passportFocusScoreThreshold, assets, verbiage, debugMode, }: IdCaptureWizardProps) => ReactElement;

package/dist/components/selfie_capture/HighPerformanceSelfieGuidanceModelsProvider.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import { MutableRefObject, ReactElement, ReactNode } from 'react';
+import { FaceDetector } from '@mediapipe/tasks-vision';
+export type Face = {
+    keypoints: {
+        x: number;
+        y: number;
+        name: string;
+    }[];
+    box: {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+        width: number;
+        height: number;
+    };
+};
+export declare function loadHighPerformanceFaceDetector(): Promise<FaceDetector>;
+type PredictionHandler = (prediction: Face[]) => void;
+type HighPerformanceSelfieGuidanceModelsState = {
+    start: () => void;
+    stop: () => void;
+    onPredictionMade: (handler: PredictionHandler) => void;
+    canvasRef: MutableRefObject<HTMLCanvasElement | null>;
+    ready: boolean;
+};
+export declare const HighPerformanceSelfieGuidanceModelsContext: React.Context<HighPerformanceSelfieGuidanceModelsState>;
+export declare const HighPerformanceSelfieGuidanceModelsProvider: ({ autoStart, children, throttleMs, }: {
+    autoStart?: boolean | undefined;
+    children: ReactNode;
+    throttleMs?: number | undefined;
+}) => ReactElement;
+export {};

package/dist/components/selfie_capture/SelfieCapture.d.ts

@@ -0,0 +1,20 @@
+import { ReactElement } from 'react';
+import { Face } from './HighPerformanceSelfieGuidanceModelsProvider';
+export type SelfieCaptureVerbiage = {
+    guidanceHoldStillText?: string;
+    guidanceLookStraightText?: string;
+    guidanceMoveBackText?: string;
+    guidanceMoveForwardText?: string;
+    guidanceMoveToCenterText?: string;
+};
+export type SelfieCaptureProps = {
+    onGuidanceSatisfied?: () => void;
+    onGuidanceNotSatisfied?: () => void;
+    onSelfieCaptured?: (frame: ImageBitmap, face: Face) => void;
+    onTimeout?: () => void;
+    timeoutDurationMs?: number;
+    guidanceMessage?: string;
+    verbiage?: SelfieCaptureVerbiage;
+    debugMode?: boolean;
+};
+export declare const SelfieCapture: ({ onGuidanceSatisfied, onGuidanceNotSatisfied, onSelfieCaptured, onTimeout, timeoutDurationMs, guidanceMessage, verbiage, debugMode, }: SelfieCaptureProps) => ReactElement;

package/dist/components/selfie_capture/SelfieCaptureLoadingOverlay.d.ts

@@ -0,0 +1,12 @@
+import { ReactElement } from 'react';
+export type SelfieCaptureLoadingOverlayProps = {
+    headingText?: string;
+    removeEyeCoveringsText?: string;
+    avoidExcessiveBacklightingText?: string;
+    continueText?: string;
+    cameraInitializingText?: string;
+    modelsWarmingUpText?: string;
+    instructionImageUrl?: string;
+    onDismissed?: () => void;
+};
+export declare const SelfieCaptureLoadingOverlay: ({ headingText, removeEyeCoveringsText, avoidExcessiveBacklightingText, continueText, cameraInitializingText, modelsWarmingUpText, instructionImageUrl, onDismissed, }: SelfieCaptureLoadingOverlayProps) => ReactElement;

package/dist/components/selfie_capture/SelfieGuidanceModelsProvider.d.ts

@@ -0,0 +1,5 @@
+import { ReactElement } from 'react';
+export type SelfieGuidanceModelsProviderProps = {
+    children: ReactElement;
+};
+export declare const SelfieGuidanceModelsProvider: ({ children, }: SelfieGuidanceModelsProviderProps) => ReactElement;

package/dist/components/signature_capture/SignatureCapture.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { SignatureData } from './data';
+export type NamespacedSignatureCaptureVerbiage = {
+    signatureCaptureHeadingText?: string;
+    signatureCaptureAcceptBtnText?: string;
+    signatureCaptureClearBtnText?: string;
+};
+export type SignatureCaptureVerbiage = {
+    headingText?: string;
+    acceptBtnText?: string;
+    clearBtnText?: string;
+};
+export type SignatureCaptureProps = {
+    onAccept?: (signatureData: SignatureData, imageData: string) => void;
+    background?: string;
+    verbiage?: SignatureCaptureVerbiage;
+};
+export declare const SignatureCapture: ({ onAccept, background, verbiage, }: SignatureCaptureProps) => React.ReactElement;

package/dist/components/signature_capture/VideoSignatureCapture.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { SignatureData } from './data';
+import { SignatureCaptureVerbiage } from './SignatureCapture';
+export type VideoSignatureCaptureProps = {
+    onComplete?: (signatureData: SignatureData, imageData: string) => void;
+    onFaceNotDetected?: () => void;
+    verbiage?: SignatureCaptureVerbiage;
+};
+export declare const VideoSignatureCapture: ({ onComplete, onFaceNotDetected, verbiage, }: VideoSignatureCaptureProps) => React.ReactElement;

package/dist/components/signature_capture/data.d.ts

@@ -0,0 +1,9 @@
+import ReactSignatureCanvas from 'react-signature-canvas';
+export type SignatureData = {
+    clickX_simple: number[][];
+    clickY_simple: number[][];
+    time_simple: string[][];
+    pressure: string;
+    fileContent: string;
+};
+export declare function signatureDataToIdmissionFormat(signatureCanvas: ReactSignatureCanvas): SignatureData;

package/dist/components/signature_kyc/SignatureKYCLoadingOverlay.d.ts

@@ -0,0 +1,12 @@
+import { ReactElement } from 'react';
+export type SignatureKYCLoadingOverlayProps = {
+    headingText?: string;
+    removeEyeCoveringsText?: string;
+    avoidExcessiveBacklightingText?: string;
+    continueText?: string;
+    cameraInitializingText?: string;
+    modelsWarmingUpText?: string;
+    instructionImageUrl?: string;
+    onDismissed?: () => void;
+};
+export declare const SignatureKYCLoadingOverlay: ({ headingText, removeEyeCoveringsText, avoidExcessiveBacklightingText, continueText, cameraInitializingText, modelsWarmingUpText, instructionImageUrl, onDismissed, }: SignatureKYCLoadingOverlayProps) => ReactElement;

package/dist/components/signature_kyc/SignatureKYCWizard.d.ts

@@ -0,0 +1,5 @@
+import { ReactElement } from 'react';
+export type SignatureKYCWizardProps = {
+    onComplete?: () => void;
+};
+export declare const SignatureKYCWizard: ({ onComplete, }: SignatureKYCWizardProps) => ReactElement;

package/dist/components/submission/GeolocationAccessDeniedOverlay.d.ts

@@ -0,0 +1,5 @@
+import { ReactElement } from 'react';
+export type GeolocationAccessDeniedOverlayProps = {
+    accessBlockedImageUrl?: string;
+};
+export declare const GeolocationAccessDeniedOverlay: ({ accessBlockedImageUrl, }: GeolocationAccessDeniedOverlayProps) => ReactElement;

package/dist/components/submission/SubmissionProvider.d.ts

@@ -0,0 +1,16 @@
+import { ReactElement } from 'react';
+import { SubmissionAction, SubmissionEnvironment, SubmissionRequest, SubmissionResponse } from '../../contexts/SubmissionContext';
+export type SubmissionProviderProps = {
+    action: SubmissionAction;
+    children: ReactElement;
+    token: string;
+    url?: string;
+    environment?: SubmissionEnvironment;
+    enrollmentId?: string;
+    geolocationEnabled?: boolean;
+    geolocationRequired?: boolean;
+    onBeforeSubmit?: (request: SubmissionRequest) => Promise<SubmissionRequest>;
+    onResponseReceived?: (response: SubmissionResponse) => void;
+    onRequestFailure?: (err: Error) => void;
+};
+export declare const SubmissionProvider: ({ action, children, url, environment, token, enrollmentId, geolocationEnabled, geolocationRequired, onBeforeSubmit, onResponseReceived, onRequestFailure, }: SubmissionProviderProps) => ReactElement;

package/dist/components/submission/SubmissionSuccess.d.ts

@@ -0,0 +1,2 @@
+import { ReactElement } from 'react';
+export declare const SubmissionSuccess: () => ReactElement;

package/dist/contexts/CameraStateContext.d.ts

@@ -0,0 +1,18 @@
+import { MutableRefObject } from 'react';
+import { Camera } from '../lib/camera/Camera';
+export type CameraState = {
+    videoRef: MutableRefObject<HTMLVideoElement | null>;
+    videoLoaded: boolean;
+    setVideoLoaded: (value: boolean) => void;
+    cameraRef: MutableRefObject<Camera | null>;
+    cameraReady: boolean;
+    cameraAccessDenied: boolean;
+    retryCameraAccess: () => void;
+    releaseCameraAccess: () => void;
+    iphoneContinuityCameraAvailable: boolean;
+    iphoneContinuityCameraAllowed: boolean;
+    setIphoneContinuityCameraAllowed: (value: boolean) => void;
+    grabFrame: () => Promise<ImageBitmap | null>;
+    takePhoto: () => Promise<Blob | null>;
+};
+export declare const CameraStateContext: import("react").Context<CameraState>;

package/dist/contexts/GuideOrientationContext.d.ts

@@ -0,0 +1,15 @@
+import { RefCallback, SyntheticEvent } from 'react';
+export type GuideOrientationState = {
+    orientation: 'portrait' | 'landscape';
+    wrapperWidth: number;
+    wrapperHeight: number;
+    wrapperAspectRatio: number;
+    imageAspectRatio: number;
+    wrapperRef: RefCallback<HTMLDivElement>;
+    setDimensions: (dimensions: {
+        width: number;
+        height: number;
+    }) => void;
+    onImageLoaded: (e: SyntheticEvent) => void;
+};
+export declare const GuideOrientationContext: import("react").Context<GuideOrientationState>;

package/dist/contexts/IdCaptureModelsContext.d.ts

@@ -0,0 +1,11 @@
+import { MutableRefObject } from 'react';
+import { Prediction } from '../lib/tfworker/Actions';
+export type IdCaptureModelsState = {
+    ready: boolean;
+    working: MutableRefObject<boolean>;
+    makePrediction: (frame: ImageBitmap | Blob | HTMLVideoElement | HTMLImageElement) => void;
+    onPredictionMade: (handler: (prediction: Prediction) => void) => void;
+    documentDetectionPredictionTime: number;
+    focusPredictionTime: number;
+};
+export declare const IdCaptureModelsContext: import("react").Context<IdCaptureModelsState>;

package/dist/contexts/SelfieGuidanceModelsContext.d.ts

@@ -0,0 +1,14 @@
+import { MutableRefObject } from 'react';
+import { Face } from '@tensorflow-models/face-detection';
+export type FacesPrediction = {
+    image: ImageBitmap;
+    faces: Face[];
+};
+export type SelfieGuidanceModelsState = {
+    ready: boolean;
+    working: MutableRefObject<boolean>;
+    makePrediction: (frame: ImageBitmap | Blob | HTMLVideoElement | HTMLImageElement) => void;
+    onPredictionMade: (handler: (prediction: FacesPrediction) => void) => void;
+    faceDetectionTime: number;
+};
+export declare const SelfieGuidanceModelsContext: import("react").Context<SelfieGuidanceModelsState>;