idmission-web-sdk 2.1.40 → 2.1.41

package/dist/components/common/LoaderButton.d.ts

@@ -1,5 +1,5 @@
 import React, { CSSProperties, ReactNode } from 'react';
-export type LoaderButtonVariant = 'primary' | 'secondary' | 'positive' | 'negative' | 'warning';
+export type LoaderButtonVariant = 'primary' | 'secondary' | 'positive' | 'negative' | 'warning' | 'outline';
 export type LoaderButtonColors = {
     backgroundColor?: string;
     textColor?: string;

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

@@ -1,13 +1,17 @@
-import { ReactElement } from 'react';
+import React, { ReactElement } from 'react';
 export type FaceCaptureGuideOverlayVariant = 'satisfied' | 'unsatisfied';
+export declare const FaceCaptureGuideContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export type FaceCaptureGuideOverlayClassNames = {
     container?: string;
     oval?: string;
 };
+export type FaceGuideStatus = 'ready' | 'processing' | 'success' | 'failure';
 export type FaceCaptureGuideOverlayProps = {
     classNames?: FaceCaptureGuideOverlayClassNames;
     variant?: FaceCaptureGuideOverlayVariant;
+    status?: FaceGuideStatus;
     borderWidth?: number;
     borderColor?: string;
+    borderOpacity?: number;
 };
-export declare const FaceCaptureGuideOverlay: ({ classNames, variant, borderWidth, borderColor, }: FaceCaptureGuideOverlayProps) => ReactElement;
+export declare const FaceCaptureGuideOverlay: ({ classNames, status, borderWidth, borderColor, borderOpacity, }: FaceCaptureGuideOverlayProps) => ReactElement;

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

@@ -1,7 +1,8 @@
-import { ReactElement } from 'react';
+import { ComponentType, ReactElement } from 'react';
 import { SelfieCaptureClassNames, SelfieCaptureColors, SelfieCaptureVerbiage } from '../selfie_capture/SelfieCapture';
 import { SelfieProgressPreviewClassNames } from '../common/SelfieProgressPreview';
 import { CustomerSuppliedVerbiage } from '../../lib/locales';
+import { FaceCaptureGuideOverlayProps } from './FaceCaptureGuideOverlay';
 export type FaceLivenessCaptureClassNames = SelfieCaptureClassNames & {
     imagePreview?: SelfieProgressPreviewClassNames;
 };
@@ -11,6 +12,8 @@ export type FaceLivenessCaptureVerbiage = SelfieCaptureVerbiage & {
     guidanceRemoveHeadCoveringsText?: CustomerSuppliedVerbiage;
     guidanceRemoveMaskText?: CustomerSuppliedVerbiage;
     progressPreviewText?: CustomerSuppliedVerbiage;
+    guidanceLivenessCheckFailedText?: CustomerSuppliedVerbiage;
+    guidanceLivenessCheckErrorText?: CustomerSuppliedVerbiage;
 };
 export type FaceLivenessCaptureProps = {
     onCapture?: () => void;
@@ -19,9 +22,12 @@ export type FaceLivenessCaptureProps = {
     onExit?: () => void;
     timeoutDurationMs?: number;
     silentFallback?: boolean;
+    guidesComponent?: ComponentType<FaceCaptureGuideOverlayProps>;
+    disableCapturePreview?: boolean;
+    requireVerticalFaceCentering?: boolean;
     classNames?: FaceLivenessCaptureClassNames;
     colors?: FaceLivenessCaptureColors;
     verbiage?: FaceLivenessCaptureVerbiage;
     debugMode?: boolean;
 };
-export declare const FaceLivenessCapture: ({ onCapture, onSuccess, onTimeout, onExit, timeoutDurationMs, silentFallback, classNames, colors, verbiage: rawVerbiage, debugMode, }: FaceLivenessCaptureProps) => ReactElement;
+export declare const FaceLivenessCapture: ({ onCapture, onSuccess, onTimeout, onExit, timeoutDurationMs, silentFallback, guidesComponent, disableCapturePreview, requireVerticalFaceCentering, classNames, colors, verbiage: rawVerbiage, debugMode, }: FaceLivenessCaptureProps) => ReactElement;

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

@@ -1,4 +1,4 @@
-import { ReactElement } from 'react';
+import React, { ReactElement } from 'react';
 import { LoaderButtonColors } from '../common/LoaderButton';
 import { CustomerSuppliedVerbiage } from '../../lib/locales';
 export type FaceLivenessFailureAssets = {
@@ -33,3 +33,4 @@ export type FaceLivenessFailureProps = {
     verbiage?: FaceLivenessFailureVerbiage;
 };
 export declare const FaceLivenessFailure: ({ canRetry, onRetryClick, onExitClick, assets, classNames, colors, verbiage: rawVerbiage, }: FaceLivenessFailureProps) => ReactElement;
+export declare const ButtonsRow: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

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

@@ -1,9 +1,10 @@
-import { ReactElement } from 'react';
+import { ComponentType, ReactElement } from 'react';
 import { FaceLivenessCaptureClassNames, FaceLivenessCaptureColors, FaceLivenessCaptureVerbiage } from './FaceLivenessCapture';
 import { FaceLivenessSuccessClassNames, FaceLivenessSuccessColors, FaceLivenessSuccessVerbiage } from './FaceLivenessSuccess';
 import { FaceLivenessFailureAssets, FaceLivenessFailureClassNames, FaceLivenessFailureColors, FaceLivenessFailureVerbiage } from './FaceLivenessFailure';
 import { LivenessCheckRequest, SubmissionResponse } from '../../contexts/SubmissionContext';
 import { SelfieCaptureLoadingOverlayMode, SelfieCaptureLoadingOverlayAssets, SelfieCaptureLoadingOverlayClassNames, SelfieCaptureLoadingOverlayColors, SelfieCaptureLoadingOverlayVerbiage } from '../selfie_capture/SelfieCaptureLoadingOverlay';
+import { FaceCaptureGuideOverlayProps } from './FaceCaptureGuideOverlay';
 export type FaceLivenessAssets = {
     loadingOverlay?: SelfieCaptureLoadingOverlayAssets;
     failure?: FaceLivenessFailureAssets;
@@ -40,10 +41,13 @@ export type FaceLivenessWizardProps = {
     renderCameraFeed?: boolean;
     releaseCameraAccessOnExit?: boolean;
     silentFallback?: boolean;
+    guidesComponent?: ComponentType<FaceCaptureGuideOverlayProps>;
+    disableCapturePreview?: boolean;
+    requireVerticalFaceCentering?: boolean;
     assets?: FaceLivenessAssets;
     classNames?: FaceLivenessClassNames;
     colors?: FaceLivenessColors;
     verbiage?: FaceLivenessVerbiage;
     debugMode?: boolean;
 };
-export declare const FaceLivenessWizard: ({ onComplete, onSuccess, onTimeout, onExitCapture, onExitAfterFailure, onUserCancel, loadingOverlayMode, timeoutDurationMs, maxRetries, skipSuccessScreen, renderCameraFeed, releaseCameraAccessOnExit, silentFallback, assets, classNames, colors, verbiage, debugMode, }: FaceLivenessWizardProps) => ReactElement;
+export declare const FaceLivenessWizard: ({ onComplete, onSuccess, onTimeout, onExitCapture, onExitAfterFailure, onUserCancel, loadingOverlayMode, timeoutDurationMs, maxRetries, skipSuccessScreen, renderCameraFeed, releaseCameraAccessOnExit, silentFallback, guidesComponent, disableCapturePreview, requireVerticalFaceCentering, assets, classNames, colors, verbiage, debugMode, }: FaceLivenessWizardProps) => ReactElement;

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

@@ -1,23 +1,16 @@
 import { ReactElement } from 'react';
 import { CustomerSuppliedVerbiage } from '../../lib/locales';
 export type FlipIdPromptAssets = {
-    frontPortraitGuidesImageUrl?: string;
-    frontLandscapeGuidesImageUrl?: string;
-    backPortraitGuidesImageUrl?: string;
-    backLandscapeGuidesImageUrl?: string;
+    idCardFrontPortraitImageUrl?: string;
+    idCardFrontLandscapeImageUrl?: string;
+    idCardBackPortraitImageUrl?: string;
+    idCardBackLandscapeImageUrl?: string;
 };
 export type FlipIdPromptClassNames = {
-    container?: string;
-    inner?: string;
-    dimmingRegion?: string;
-    dimmingRegionTop?: string;
-    dimmingRegionLeft?: string;
-    dimmingRegionRight?: string;
-    dimmingRegionBottom?: string;
-    centerRow?: string;
-    centerRegion?: string;
-    image?: string;
-    guideText?: string;
+    frontImageContainer?: string;
+    backImageContainer?: string;
+    frontImage?: string;
+    backImage?: string;
 };
 export type FlipIdPromptVerbiage = {
     instructionText?: CustomerSuppliedVerbiage;
@@ -27,9 +20,11 @@ export type FlipIdPromptProps = {
     imagePadding?: number;
     borderWidth?: number;
     borderColor?: string;
-    maskColor?: string;
+    borderRadius?: number;
+    isMirrored?: boolean;
+    portraitGuidesOnMobile?: boolean;
     assets?: FlipIdPromptAssets;
     classNames?: FlipIdPromptClassNames;
     verbiage?: FlipIdPromptVerbiage;
 };
-export declare const FlipIdPrompt: ({ padding: userSuppliedPadding, imagePadding: userSuppliedImagePadding, borderWidth, borderColor, maskColor, assets, classNames, verbiage, }: FlipIdPromptProps) => ReactElement;
+export declare const FlipIdPrompt: ({ borderWidth, borderColor, borderRadius, isMirrored, portraitGuidesOnMobile, assets, classNames, }: FlipIdPromptProps) => ReactElement;

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

@@ -1,5 +1,7 @@
 import React from 'react';
-import { IdCaptureGuideOverlayClassNames } from './IdCaptureGuideOverlay';
+import { IdCaptureGuideAction, IdCaptureGuideOverlayAssets, IdCaptureGuideOverlayClassNames } from './IdCaptureGuideOverlay';
+import { IdCardGuideStatus } from '../video_id/IdVideoCaptureGuidesCommon';
+export type IdCaptureFitGuideAssets = IdCaptureGuideOverlayAssets;
 export type IdCaptureFitGuideClassNames = IdCaptureGuideOverlayClassNames & {
     canvasWrapper?: string;
     canvas?: string;
@@ -11,13 +13,15 @@ export type IdCaptureFitGuideProps = {
     borderColor?: string;
     borderWidth?: number;
     padding?: number;
-    imageUrl?: string;
     imageVisible?: boolean;
-    frontImageUrl?: string;
-    backImageUrl?: string;
     isMirrored?: boolean;
+    isBackToFront?: boolean;
+    portraitGuidesOnMobile?: boolean;
     instruction?: string;
-    requestingFlip?: boolean;
+    requestedAction?: IdCaptureGuideAction;
+    status?: IdCardGuideStatus;
+    progress?: number;
+    assets?: IdCaptureFitGuideAssets;
     classNames?: IdCaptureFitGuideClassNames;
 };
-export declare const IdCaptureFitGuide: ({ aspectRatio, maskColor, borderRadius, borderColor, borderWidth, padding, imageUrl, imageVisible, frontImageUrl, backImageUrl, isMirrored, instruction, requestingFlip, classNames, }: IdCaptureFitGuideProps) => React.JSX.Element;
+export declare const IdCaptureFitGuide: ({ aspectRatio, maskColor, borderRadius, borderColor, borderWidth, padding, imageVisible, isMirrored, isBackToFront, portraitGuidesOnMobile, instruction, requestedAction, status, progress, assets, classNames, }: IdCaptureFitGuideProps) => React.JSX.Element;

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

@@ -1,33 +1,15 @@
 import React, { ReactElement } from 'react';
-export declare const GuidesContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const GuideCenterRow: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const GuideRegion: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
-    $minWidth?: number;
-    $minHeight?: number;
-    $maskColor?: string;
-}>> & string;
-export declare const Spacer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "$minWidth" | "$minHeight" | "$maskColor"> & {
-    $minWidth?: number;
-    $minHeight?: number;
-    $maskColor?: string;
-}, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void | React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | React.RefObject<HTMLDivElement> | null | undefined;
-}, never>> & string;
-export declare const GuideCenterRegion: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
-    $minWidth?: number;
-    $isMirrored?: boolean;
-}>> & string;
-export declare const GuideCenterBorder: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
-    $borderWidth: number;
-    $borderColor?: string;
-}>> & string;
-export declare const GuideText: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
-export declare const GuideImage: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, {
-    $width?: number;
-    $height?: number;
-    $padding: number;
-    $visible?: boolean;
-}>> & string;
+import { IdCardGuideStatus } from '../video_id/IdVideoCaptureGuidesCommon';
+import { FlipIdPromptAssets, FlipIdPromptClassNames } from './FlipIdPrompt';
+export type IdCaptureGuideOverlayAssets = {
+    idCardFrontPortraitImageUrl?: string;
+    idCardFrontLandscapeImageUrl?: string;
+    idCardBackPortraitImageUrl?: string;
+    idCardBackLandscapeImageUrl?: string;
+    passportPortraitImageUrl?: string;
+    passportLandscapeImageUrl?: string;
+    flipIdPrompt?: FlipIdPromptAssets;
+};
 export type IdCaptureGuideOverlayClassNames = {
     container?: string;
     inner?: string;
@@ -38,11 +20,14 @@ export type IdCaptureGuideOverlayClassNames = {
     dimmingRegionBottom?: string;
     centerRow?: string;
     centerRegion?: string;
+    centerRegionBorder?: string;
     centerRegionInner?: string;
     image?: string;
     guideText?: string;
+    flipIdPrompt?: FlipIdPromptClassNames;
 };
 export type IdCaptureGuideOverlayProps = {
+    assets?: IdCaptureGuideOverlayAssets;
     classNames?: IdCaptureGuideOverlayClassNames;
     width?: number;
     height?: number;
@@ -51,11 +36,42 @@ export type IdCaptureGuideOverlayProps = {
     imageVisible?: boolean;
     borderWidth?: number;
     borderColor?: string;
+    idCardBorderWidth?: number;
+    idCardBorderColor?: string;
     maskColor?: string;
     isMirrored?: boolean;
+    isBackToFront?: boolean;
+    portraitGuidesOnMobile?: boolean;
     instruction?: string;
-    portraitGuidesImageUrl?: string;
-    landscapeGuidesImageUrl?: string;
+    requestedAction?: IdCaptureGuideAction;
+    status?: IdCardGuideStatus;
+    progress?: number;
     onClick?: () => void;
 };
-export declare const IdCaptureGuideOverlay: ({ classNames, width, height, padding: userSuppliedPadding, imagePadding: userSuppliedImagePadding, imageVisible, borderWidth, borderColor, maskColor, isMirrored, instruction, portraitGuidesImageUrl, landscapeGuidesImageUrl, onClick, }: IdCaptureGuideOverlayProps) => ReactElement;
+export type IdCaptureGuideAction = 'SHOW_ID_FRONT' | 'FLIP_ID' | 'SHOW_ID_BACK' | 'SHOW_PASSPORT';
+export declare const IdCaptureGuideOverlay: ({ assets, classNames, width, height, padding: userSuppliedPadding, imagePadding: userSuppliedImagePadding, imageVisible, borderWidth, borderColor, idCardBorderWidth, idCardBorderColor, maskColor, isMirrored, isBackToFront, portraitGuidesOnMobile, instruction, requestedAction, progress, status, onClick, }: IdCaptureGuideOverlayProps) => ReactElement;
+export declare const GuidesContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const GuideCenterRow: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const GuideRegion: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    $minWidth?: number;
+    $minHeight?: number;
+    $maskColor?: string;
+}>> & string;
+export declare const Spacer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "$minWidth" | "$minHeight" | "$maskColor"> & {
+    $minWidth?: number;
+    $minHeight?: number;
+    $maskColor?: string;
+}, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | React.RefObject<HTMLDivElement> | null | undefined;
+}, never>> & string;
+export declare const GuideCenterRegion: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    $minWidth?: number;
+    $isMirrored?: boolean;
+}>> & string;
+export declare const GuideCenterBorder: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    $borderWidth: number;
+    $borderColor?: string;
+    $padding?: number;
+}>> & string;
+export declare const GuideText: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
+export declare const GuideCenterInner: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

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

@@ -1,16 +1,23 @@
-import { IdCaptureFitGuideClassNames } from './IdCaptureFitGuide';
+import { IdCaptureFitGuideAssets, IdCaptureFitGuideClassNames } from './IdCaptureFitGuide';
 import React from 'react';
-import { IdCaptureAssets, IdCaptureColors, IdCaptureVerbiage } from './IdCapture';
+import { IdCaptureGuideAction } from './IdCaptureGuideOverlay';
+import { IdCaptureColors, IdCaptureVerbiage } from './IdCapture';
 import { FlipIdPromptAssets } from './FlipIdPrompt';
+import { IdCardGuideStatus } from '../video_id/IdVideoCaptureGuidesCommon';
+export type IdCaptureGuidesAssets = IdCaptureFitGuideAssets;
+export type IdCaptureGuidesClassNames = IdCaptureFitGuideClassNames;
 export type IdCaptureGuideType = 'fit' | 'overlay';
-export declare function IdCaptureGuides({ guideType, portraitGuidesOnMobile, requestingFlip, isBackToFront, flipIdPromptAssets, classNames, assets, colors, verbiage: rawVerbiage, }: {
+export type IdCaptureGuidesProps = {
     guideType?: IdCaptureGuideType;
+    status?: IdCardGuideStatus;
+    progress?: number;
     portraitGuidesOnMobile?: boolean;
-    requestingFlip?: boolean;
+    requestedAction?: IdCaptureGuideAction;
     isBackToFront?: boolean;
     flipIdPromptAssets?: FlipIdPromptAssets;
-    classNames?: IdCaptureFitGuideClassNames;
-    assets?: IdCaptureAssets;
+    assets?: IdCaptureGuidesAssets;
+    classNames?: IdCaptureGuidesClassNames;
     colors?: IdCaptureColors;
     verbiage?: IdCaptureVerbiage;
-}): React.JSX.Element;
+};
+export declare function IdCaptureGuides({ guideType, status, progress, portraitGuidesOnMobile, requestedAction, isBackToFront, assets, classNames, colors, verbiage: rawVerbiage, }: IdCaptureGuidesProps): React.JSX.Element;

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

@@ -38,8 +38,6 @@ export type IdCaptureState = {
     idCardBackDetectionThresholdMet: boolean;
     passportDetectionScore: number;
     passportDetectionThresholdMet: boolean;
-    singlePageDetectionScore: number;
-    singlePageDetectionThresholdMet: boolean;
     focusScore: number;
     focusThresholdMet: boolean;
     isGoodFrame: boolean;

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

@@ -1,28 +1,28 @@
 import { ReactElement, ReactNode } from 'react';
 import { IdCaptureAssets, IdCaptureClassNames, IdCaptureColors, IdCaptureVerbiage } from './IdCapture';
 import { IdCaptureLoadingOverlayAssets, IdCaptureLoadingOverlayClassNames, IdCaptureLoadingOverlayColors, IdCaptureLoadingOverlayMode, IdCaptureLoadingOverlayVerbiage } from './IdCaptureLoadingOverlay';
-import { FlipIdPromptAssets, FlipIdPromptClassNames, FlipIdPromptVerbiage } from './FlipIdPrompt';
+import { FlipIdPromptVerbiage } from './FlipIdPrompt';
 import { CapturedDocuments } from './CapturedDocuments';
 import { IdCaptureSuccessClassNames, IdCaptureSuccessColors, IdCaptureSuccessVerbiage } from './IdCaptureSuccess';
 import { IdCaptureThresholds } from './IdCaptureModelsProvider';
 import { IdCaptureRequirementOption } from './IdCaptureRequirementOption';
-import { IdCaptureGuideType } from './IdCaptureGuides';
+import { IdCaptureGuidesAssets, IdCaptureGuidesClassNames, IdCaptureGuideType } from './IdCaptureGuides';
 import { IdCaptureFallbackClassNames, IdCaptureFallbackColors, IdCaptureFallbackVerbiage } from '../fallback_flows/IdCapture';
 export type IdCaptureWizardAssets = {
     documentDetectionModelUrl?: string;
     focusModelUrl?: string;
     loadingOverlay?: IdCaptureLoadingOverlayAssets;
+    guides?: IdCaptureGuidesAssets;
     idCardFront?: IdCaptureAssets;
     idCardBack?: IdCaptureAssets;
     passport?: IdCaptureAssets;
-    flipIdPrompt?: FlipIdPromptAssets;
 };
 export type IdCaptureWizardClassNames = {
     container?: string;
     cameraFeed?: string;
     loadingOverlay?: IdCaptureLoadingOverlayClassNames;
     capture?: IdCaptureClassNames;
-    flipIdPrompt?: FlipIdPromptClassNames;
+    guides?: IdCaptureGuidesClassNames;
     success?: IdCaptureSuccessClassNames;
     fallback?: IdCaptureFallbackClassNames;
 };

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

@@ -1,5 +1,5 @@
-import { ReactElement } from 'react';
-import { FaceCaptureGuideOverlayClassNames } from '../face_liveness/FaceCaptureGuideOverlay';
+import { ComponentType, ReactElement } from 'react';
+import { FaceCaptureGuideOverlayClassNames, FaceCaptureGuideOverlayProps } from '../face_liveness/FaceCaptureGuideOverlay';
 import { CustomerSuppliedVerbiage } from '../../lib/locales';
 import { SelfieCaptureFallbackClassNames } from '../fallback_flows/SelfieCapture';
 import { Face } from '../../lib/models/FaceDetection';
@@ -26,19 +26,24 @@ export type SelfieCaptureVerbiage = {
     guidanceMoveBackText?: CustomerSuppliedVerbiage;
     guidanceMoveForwardText?: CustomerSuppliedVerbiage;
     guidanceMoveToCenterText?: CustomerSuppliedVerbiage;
+    guidanceNoFaceDetectedText?: CustomerSuppliedVerbiage;
 };
 export type SelfieCaptureProps = {
     onGuidanceSatisfied?: () => void;
     onGuidanceNotSatisfied?: () => void;
+    onSelfieCaptureStarted?: () => void;
     onSelfieCaptured?: (frame: ImageData, face: Face) => void;
     onTimeout?: () => void;
     onExit?: () => void;
     timeoutDurationMs?: number;
     guidanceMessage?: string;
     guidanceSatisfied?: boolean;
+    guidesComponent?: ComponentType<FaceCaptureGuideOverlayProps>;
+    requireVerticalFaceCentering?: boolean;
+    shouldCapture?: boolean;
     classNames?: SelfieCaptureClassNames;
     colors?: SelfieCaptureColors;
     verbiage?: SelfieCaptureVerbiage;
     debugMode?: boolean;
 };
-export declare const SelfieCapture: ({ onGuidanceSatisfied, onGuidanceNotSatisfied, onSelfieCaptured, onTimeout, onExit, timeoutDurationMs, guidanceMessage, guidanceSatisfied, classNames, colors, verbiage: rawVerbiage, debugMode, }: SelfieCaptureProps) => ReactElement;
+export declare const SelfieCapture: ({ onGuidanceSatisfied, onGuidanceNotSatisfied, onSelfieCaptureStarted, onSelfieCaptured, onTimeout, onExit, timeoutDurationMs, guidanceMessage, guidanceSatisfied, guidesComponent, requireVerticalFaceCentering, shouldCapture, classNames, colors, verbiage: rawVerbiage, debugMode, }: SelfieCaptureProps) => ReactElement;

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

@@ -1,6 +1,19 @@
-import React from 'react';
+import React, { SVGProps } from 'react';
+import { FaceGuideStatus } from '../face_liveness/FaceCaptureGuideOverlay';
 export declare function SelfieCaptureLoadingGraphic({ width, height, className, }: {
     width?: number;
     height?: number;
     className?: string;
 }): React.JSX.Element;
+export type SelfieCaptureAnimatedMaskProps = SVGProps<SVGSVGElement> & {
+    frame?: number;
+    borderWidth?: number;
+    borderColor?: string;
+    borderOpacity?: number;
+    verticalAlign?: 'center' | 'bottom';
+    status?: FaceGuideStatus;
+};
+export declare function SelfieCaptureAnimatedMask({ frame, borderWidth, borderColor, borderOpacity, verticalAlign, status, ...props }: SelfieCaptureAnimatedMaskProps): React.JSX.Element;
+export declare function SelfieCaptureAnimatedMaskWithStatus({ status, ...props }: SelfieCaptureAnimatedMaskProps & {
+    status?: FaceGuideStatus;
+}): React.JSX.Element;

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

@@ -1,11 +1,11 @@
 import * as React from 'react';
 import { MutableRefObject, ReactElement, ReactNode } from 'react';
 import { Face } from '../../lib/models/FaceDetection';
-type PredictionHandler = (prediction: Face[]) => void;
+export type SelfieGuidancePredictionHandler = (prediction: Face[]) => Promise<void> | void;
 type SelfieGuidanceModelsState = {
     start: () => void;
     stop: () => void;
-    onPredictionMade: (handler: PredictionHandler) => void;
+    onPredictionMade: (handler: SelfieGuidancePredictionHandler) => void;
     canvasRef: MutableRefObject<HTMLCanvasElement | null>;
     ready: boolean;
     error: Error | null;

package/dist/components/video_id/IdVideoCaptureFlipIdPrompt.d.ts

@@ -1,13 +1,32 @@
-import { ReactElement } from 'react';
+import React, { CSSProperties, ReactElement } from 'react';
 export type IdVideoCaptureFlipIdPromptAssets = {
     frontImageUrl?: string;
     backImageUrl?: string;
 };
+export type IdVideoCaptureFlipIdPromptClassNames = {
+    frontImageContainer?: string;
+    backImageContainer?: string;
+    frontImage?: string;
+    backImage?: string;
+};
 export type IdVideoCaptureFlipIdPromptProps = {
-    className?: string;
-    imageWidth?: number;
-    imageHeight?: number;
-    borderWidth?: number;
+    classNames?: IdVideoCaptureFlipIdPromptClassNames;
     assets?: IdVideoCaptureFlipIdPromptAssets;
+    borderWidth?: number;
+    borderColor?: string;
+    borderRadius?: number;
+    imageStyle?: CSSProperties;
 };
-export declare const IdVideoCaptureFlipIdPrompt: ({ className, imageWidth, imageHeight, borderWidth, assets, }: IdVideoCaptureFlipIdPromptProps) => ReactElement;
+export declare const IdVideoCaptureFlipIdPrompt: ({ assets, classNames, borderWidth, borderColor, borderRadius, imageStyle, }: IdVideoCaptureFlipIdPromptProps) => ReactElement;
+export declare const FlipImageContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("styled-components").FastOmit<React.HTMLAttributes<HTMLDivElement> & {
+    status?: import("./IdVideoCaptureGuidesCommon").IdCardGuideStatus;
+    borderWidth?: number;
+    borderRadius?: number;
+    borderColor?: string;
+    progress?: number;
+}, "$isVisible"> & {
+    $isVisible?: boolean;
+}, {
+    $transforms: string;
+    $transitionTime: number;
+}>> & string;

package/dist/components/video_id/IdVideoCaptureGuides.d.ts

@@ -1,37 +1,46 @@
 import React, { ReactElement } from 'react';
+import { IdVideoCaptureFlipIdPromptClassNames } from './IdVideoCaptureFlipIdPrompt';
 import { CustomerSuppliedVerbiage } from '../../lib/locales';
-export type Action = 'SHOW_ID_FRONT' | 'FLIP_ID' | 'SHOW_ID_BACK' | 'READ_TEXT';
+import { IdCardGuideStatus } from './IdVideoCaptureGuidesCommon';
+import { FaceGuideStatus } from '../face_liveness/FaceCaptureGuideOverlay';
+export type Action = 'SHOW_ID_FRONT' | 'FLIP_ID' | 'SHOW_ID_BACK' | 'VERIFY_LIVENESS';
 export type IdVideoCaptureGuidesAssets = {
     frontImageUrl?: string;
     backImageUrl?: string;
 };
 export type IdVideoCaptureGuidesClassNames = {
     container?: string;
+    faceGuideContainer?: string;
     faceGuide?: string;
     idCardGuideContainer?: string;
+    idCardGuideInner?: string;
     idCardGuideInstructionsContainer?: string;
     idCardGuideInstructions?: string;
     idCardGuideImageContainer?: string;
     idCardGuideImage?: string;
-    flipIdPromptImage?: string;
+    flipIdPrompt?: IdVideoCaptureFlipIdPromptClassNames;
 };
 export type IdVideoCaptureGuidesVerbiage = {
     idFrontInstructionText?: CustomerSuppliedVerbiage;
     idBackInstructionText?: CustomerSuppliedVerbiage;
     flipIdInstructionText?: CustomerSuppliedVerbiage;
+    verifyLivenessInstructionText?: CustomerSuppliedVerbiage;
 };
 export type IdVideoCaptureGuidesProps = {
     requestedAction?: Action;
     satisfied?: boolean;
+    faceGuideStatus?: FaceGuideStatus;
     faceGuideBorderWidth?: number;
     faceGuideBorderColor?: string;
+    idCardGuideStatus?: IdCardGuideStatus;
     idCardGuideBorderWidth?: number;
     idCardGuideBorderColor?: string;
+    idCardCaptureProgress?: number;
     assets?: IdVideoCaptureGuidesAssets;
     classNames?: IdVideoCaptureGuidesClassNames;
     verbiage?: IdVideoCaptureGuidesVerbiage;
 };
-export declare const IdVideoCaptureGuides: ({ requestedAction, satisfied, faceGuideBorderWidth, faceGuideBorderColor, idCardGuideBorderWidth, idCardGuideBorderColor, assets, classNames, verbiage: rawVerbiage, }: IdVideoCaptureGuidesProps) => ReactElement;
+export declare const IdVideoCaptureGuides: ({ requestedAction, satisfied, faceGuideStatus, faceGuideBorderWidth, faceGuideBorderColor, idCardGuideStatus, idCardGuideBorderWidth, idCardGuideBorderColor, idCardCaptureProgress, assets, classNames, verbiage: rawVerbiage, }: IdVideoCaptureGuidesProps) => ReactElement;
 export declare const IdCardGuideInstructionsContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const IdCardGuideInstructions: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "$textColor" | "$variant" | "$background"> & {
     $background?: string;

package/dist/components/video_id/IdVideoCaptureGuidesCommon.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+export declare const IdCardGuideImageContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<React.HTMLAttributes<HTMLDivElement> & {
+    status?: IdCardGuideStatus;
+    borderWidth?: number;
+    borderRadius?: number;
+    borderColor?: string;
+    progress?: number;
+}, {
+    $isVisible?: boolean;
+}>> & string & Omit<typeof IdCardBorder, keyof React.Component<any, {}, any>>;
+export declare const IdCardGuideImage: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, {
+    $isMirrored?: boolean;
+    $isInvisible?: boolean;
+}>> & string;
+export type IdCardGuideStatus = 'disabled' | 'ready' | 'capturing';
+declare function IdCardBorder({ children, status, borderWidth, borderRadius, borderColor, progress, ...props }: React.HTMLAttributes<HTMLDivElement> & {
+    status?: IdCardGuideStatus;
+    borderWidth?: number;
+    borderRadius?: number;
+    borderColor?: string;
+    progress?: number;
+}): React.JSX.Element;
+export {};

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

@@ -30,7 +30,6 @@ declare const _default: {
     'ID card front detected, hold still...': string;
     'ID card back detected, hold still...': string;
     'Passport detected, hold still...': string;
-    'Single page ID document detected, hold still...': string;
     'Capturing...': string;
     'Capture failed!': string;
     'Please flip your ID card...': string;
@@ -55,6 +54,8 @@ declare const _default: {
     Exit: string;
     'Face liveness has been verified!': string;
     Done: string;
+    'Could not verify your face.': string;
+    'An error occurred while verifying your face.': string;
     'Customer has been identified!': string;
     'Customer not found': string;
     'Additional document capture': string;

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

@@ -38,7 +38,6 @@ export declare const resources: {
             'ID card front detected, hold still...': string;
             'ID card back detected, hold still...': string;
             'Passport detected, hold still...': string;
-            'Single page ID document detected, hold still...': string;
             'Capturing...': string;
             'Capture failed!': string;
             'Please flip your ID card...': string;
@@ -63,6 +62,8 @@ export declare const resources: {
             Exit: string;
             'Face liveness has been verified!': string;
             Done: string;
+            'Could not verify your face.': string;
+            'An error occurred while verifying your face.': string;
             'Customer has been identified!': string;
             'Customer not found': string;
             'Additional document capture': string;

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

@@ -1,17 +1,16 @@
 import { ObjectDetector, ObjectDetectorResult } from '@mediapipe/tasks-vision';
-export declare const defaultDocumentDetectorModelPath = "https://websdk-cdn-dev.idmission.com/assets/models/docdetectmp20240909/model_fp16.tflite";
+export declare const defaultDocumentDetectorModelPath = "https://websdk-cdn-dev.idmission.com/assets/models/docdetectmp20240825/model_fp16.tflite";
 export declare const defaultDocumentDetectionScoreThreshold = 0.1;
 export declare const defaultDocumentDetectionModelLoadTimeoutMs = 45000;
 export declare const defaultDocumentDetectionThresholds: DocumentDetectionThresholds;
-export type DocumentType = 'none' | 'idCardFront' | 'idCardBack' | 'passport' | 'singlePage';
+export type DocumentType = 'none' | 'idCardFront' | 'idCardBack' | 'passport';
 export declare const documentTypeDisplayNames: {
     idCardFront: string;
     idCardBack: string;
     passport: string;
-    singlePage: string;
     none: string;
 };
-export type Label = 'Document' | 'Document back' | 'MRZ' | 'PDF417' | 'Primary face' | 'Secondary face' | 'Glare' | 'Punch Hole' | 'Passport page' | 'Single page';
+export type Label = 'Document' | 'Document back' | 'MRZ' | 'PDF417' | 'Primary face' | 'Secondary face' | 'Glare' | 'Punch Hole' | 'Passport page';
 export type DetectedObjectBox = {
     xMin: number;
     xMax: number;
@@ -29,7 +28,6 @@ export type DocumentDetectionThresholds = {
     idCardFront?: number;
     idCardBack?: number;
     passport?: number;
-    singlePage?: number;
 };
 export declare function loadDocumentDetector(modelAssetPath?: string, scoreThreshold?: number): Promise<ObjectDetector>;
 export declare function useLoadDocumentDetector({ modelPath, modelLoadTimeoutMs, scoreThreshold, onModelError, }: {
@@ -56,8 +54,6 @@ export type DocumentDetectionPrediction = {
     idCardBackDetectionThresholdMet: boolean;
     passportDetectionScore: number;
     passportDetectionThresholdMet: boolean;
-    singlePageDetectionScore: number;
-    singlePageDetectionThresholdMet: boolean;
     bestDocument: DetectedObject | undefined;
     documentInBounds: boolean;
     documentTooClose: boolean;