@jumio/websdk 0.2.13 → 0.2.14

package/index.d.ts

@@ -173,6 +173,8 @@ export declare const analytics: {
     shownCameraCaptureHints: EventDispatcher<    {
     visible: boolean;
     }>;
+    crateBackMissingEvent: EventCreator<"trace", "back side of ID is missing", EventMetadata>;
+    backMissingEvent: EventDispatcher<EventMetadata>;
     createCameraStreamStartedEvent: EventCreator<"trace", "started camera stream", {
     constraints: {
     advanced?: {
@@ -625,6 +627,8 @@ export declare const analytics: {
     message: string;
     stack?: string;
     }>;
+    createDefaultToDL: EventCreator<"trace", "missing idType - defaulting to DL", EventMetadata>;
+    defaultToDL: EventDispatcher<EventMetadata>;
     createShownStartScreenEvent: EventCreator<"screen", "start", EventMetadata>;
     shownStartScreen: EventDispatcher<EventMetadata>;
     createShownDocumentSelectScreenEvent: EventCreator<"screen", "document select", EventMetadata>;
@@ -1512,6 +1516,8 @@ export declare class BackdropComponent extends BaseComponent {
     render(): TemplateResult<1>;
 }
 
+export declare const backMissingEvent: EventDispatcher<EventMetadata>;
+
 export declare interface BackupEntry {
     backupGuid: string;
     workflowState: WorkflowState;
@@ -2637,7 +2643,7 @@ export declare interface ConstraintsParams {
 declare type ControllerProvider<TWorkflowStepController, TComponentController> = WorkflowStepControllerProvider<TWorkflowStepController> & ComponentControllerProvider<TComponentController>;
 
 declare interface Country {
-    code: CountryCode | undefined;
+    code: CountryCode;
     label: string;
 }
 
@@ -2894,6 +2900,8 @@ export declare enum CountryCode {
     ZWE = "ZWE"
 }
 
+export declare const crateBackMissingEvent: EventCreator<"trace", "back side of ID is missing", EventMetadata>;
+
 export declare function createAnalyticEventCreatorAndDispatcher<ET extends EventType, EN extends string, M extends EventMetadata>(eventBody: Omit<AnalyticEventBody<ET, EN, M>, 'timestamp' | 'value'>): [EventCreator<ET, EN, M>, EventDispatcher<M>];
 
 export declare const createAndAppendSlotFallback: <K extends keyof HTMLElementTagNameMap>({ root, slotName, fallbackContentTagName }: CreateAndAppendSlotParams<K>) => HTMLElementTagNameMap[K] | undefined;
@@ -3394,6 +3402,8 @@ export declare interface CreateDatastoreParams {
     credentialDocumentStoreFactory?: interfaces.SimpleFactory<CredentialDocumentStore, [string]>;
 }
 
+export declare const createDefaultToDL: EventCreator<"trace", "missing idType - defaulting to DL", EventMetadata>;
+
 export declare const createDeviceListChangedEvent: EventCreator<"trace", "device list changed", {
 devices: {
 readonly label?: string | undefined;
@@ -3687,6 +3697,10 @@ export declare interface CredentialFacemapStore {
     setActiveFaceVerificationMethod: (activeVerificationMethod: FacemapVerificationMethod | undefined) => void;
     getActiveFaceVerificationMethod: () => FacemapVerificationMethod | undefined;
     selectActiveFaceVerificationMethod$: () => Observable<FacemapVerificationMethod | undefined>;
+    setJLiveManualCaptureFallbackReason: (reason: ManualCaptureFallbackReason | undefined) => void;
+    selectJLiveManualCaptureFallbackReason$: () => Observable<ManualCaptureFallbackReason | undefined>;
+    selectJLiveFallbackError$: () => Observable<JLiveFallbackError | undefined>;
+    setJLiveFallbackError: (error: JLiveFallbackError | undefined) => void;
     selectLivenessState$: () => Observable<CredentialFacemapState & LivenessState>;
     setLivenessVisibleFaceFinder: (oval: LivenessRefDistance) => void;
     selectLivenessVisibleFaceFinder$: () => Observable<LivenessRefDistance>;
@@ -3713,6 +3727,10 @@ export declare class CredentialFacemapStoreImpl implements CredentialFacemapStor
     constructor(credential: JCredential<Category.Facemap>);
     destroy(): void;
     setActiveFaceVerificationMethod(activeVerificationMethod: FacemapVerificationMethod | undefined): void;
+    setJLiveFallbackError(error: JLiveFallbackError | undefined): void;
+    selectJLiveFallbackError$(): Observable<JLiveFallbackError | undefined>;
+    setJLiveManualCaptureFallbackReason(reason: ManualCaptureFallbackReason | undefined): void;
+    selectJLiveManualCaptureFallbackReason$(): Observable<ManualCaptureFallbackReason | undefined>;
     getActiveFaceVerificationMethod(): FacemapVerificationMethod | undefined;
     selectActiveFaceVerificationMethod$(): Observable<FacemapVerificationMethod | undefined>;
     selectLivenessState$(): Observable<CredentialFacemapState & LivenessState & IproovTokenState>;
@@ -3762,6 +3780,8 @@ export declare interface CredentialIdStore {
     selectIdTypeVariantCollection$: () => Observable<IdTypeVariant[]>;
     selectIdTypeVariant$: () => Observable<IdTypeVariant>;
     getIdUserSelection: () => IdCredentialSelection;
+    are2FilesUploaded: (credentialId: UUID) => boolean;
+    isUsabilityBackMissing: (credentialId: UUID) => IsUsabilityBackMissing;
     selectIdUserSelection$: () => Observable<IdCredentialSelection>;
     isCountryAndDocTypePredefined: () => boolean;
     destroy: () => void;
@@ -3770,6 +3790,8 @@ export declare interface CredentialIdStore {
 export declare class CredentialIdStoreImpl implements CredentialIdStore {
     #private;
     constructor(credential: JCredential<Category.Id>);
+    are2FilesUploaded(credentialId: UUID): boolean;
+    isUsabilityBackMissing(credentialId: UUID): IsUsabilityBackMissing;
     destroy(): void;
     patchIdUserSelection(params: Partial<IdCredentialSelection>, settings?: Settings): void;
     selectSidesForSelectedDocument$(): Observable<IdSide[]>;
@@ -3778,7 +3800,13 @@ export declare class CredentialIdStoreImpl implements CredentialIdStore {
     selectIdTypeVariantCollection$(): Observable<IdTypeVariant[]>;
     selectIdTypeVariant$(): Observable<IdTypeVariant>;
     getIdUserSelection(): IdCredentialSelection;
-    selectIdUserSelection$(): Observable<IdCredentialSelection>;
+    selectIdUserSelection$(): Observable<    {
+    selectedCountry: CountryCode | undefined;
+    selectedDigitalIdentity: DigitalIdentityProps | undefined;
+    selectedIdType: IdTypeUpload | undefined;
+    selectedDocumentVariant: DocumentVariant | undefined;
+    selectedIdFormat: IdFormat | undefined;
+    }>;
     isCountryAndDocTypePredefined(): boolean;
 }
 
@@ -3825,6 +3853,8 @@ export declare enum DecisionType {
     NOT_AVAILABLE = "NOT_AVAILABLE"
 }
 
+export declare const defaultToDL: EventDispatcher<EventMetadata>;
+
 export declare const DEV: boolean;
 
 export declare enum DeviceCategory {
@@ -3951,8 +3981,7 @@ export declare class DropdownComponent extends BaseComponent {
 
 export declare interface DropdownOption {
     label: string;
-    value?: string;
-    code?: string;
+    value: string;
 }
 
 export declare class DropdownSelectionEvent extends CustomEvent<DropdownOption> {
@@ -4173,9 +4202,9 @@ export declare enum ExecutionEnvironment {
 }
 
 export declare interface ExtractedData {
+    country: CountryCode;
+    idType: IdTypeUpload;
     issuingCountry?: CountryCode;
-    country?: CountryCode;
-    idType?: string;
     firstName?: string;
     lastName?: string;
     dateOfBirth?: string;
@@ -4276,7 +4305,7 @@ export declare interface FacingModeConstraint extends MediaStreamConstraints {
         facingMode: {
             ideal: 'user' | 'environment';
         };
-    };
+    } & MediaTrackConstraints;
     audio: false;
 }
 
@@ -4307,8 +4336,6 @@ export declare interface FetchErrorParams {
     publicError?: PublicError;
 }
 
-export declare const fetchWorkerData: () => Promise<DataAcquisitionFetchParameters>;
-
 export declare type FileListFilter = (files: File[]) => File[];
 
 export declare class FileMultiUploadComponent extends BaseComponent {
@@ -4339,6 +4366,14 @@ export declare interface FilePartState extends FilePartResponse {
     filename?: string;
 }
 
+export declare type FilePickerError = 'max-file-size' | 'file-type';
+
+export declare const FilePickerErrorMessage = "filepickererror";
+
+export declare class FilePickerErrorMessageEvent extends CustomEvent<FilePickerError> {
+    constructor(error: FilePickerError);
+}
+
 export declare class FileRemoveEvent extends CustomEvent<unknown> {
     constructor();
 }
@@ -4391,7 +4426,7 @@ export declare type FileStoreKey = FileStoreKeyId | FileStoreKeyFacemap | FileSt
 
 export declare type FileStoreKeyBRA_ID = `${UUID}_${IdTypeUpload.DigitalIdentity}_${UploadType.FrontSide}`;
 
-declare type FileStoreKeyDocument = `${UUID}_${IdTypeUpload}_${UploadType.Document}`;
+declare type FileStoreKeyDocument = `${UUID}_${UploadType.Document}`;
 
 declare type FileStoreKeyFacemap = `${UUID}_${UploadType.Face}` | `${string}_JUMIO_LIVENESS_BLOB` | JLivePartName;
 
@@ -4415,6 +4450,8 @@ export declare enum FileType {
     Dat = "DAT"
 }
 
+export declare const fileTypeMessage: () => string;
+
 export declare class FileUploadComponent extends BaseComponent {
     #private;
     static styles: CSSResult[];
@@ -4488,6 +4525,8 @@ declare const generateAction: (params: Partial<NavigationStep>) => {
     params: Partial<NavigationStep>;
 };
 
+export declare const generateBrazilianIdLink: () => string;
+
 export declare interface GenerateCredentialParams {
     credentialId: UUID;
     previousStep: StepCallback;
@@ -4519,25 +4558,103 @@ readonly "step-navigation-previous-step": `${string}-${string}-${string}-${strin
 };
 };
 readonly start: {
-readonly initial: import("../../../types/src/index.js").StartStep.Consent;
+readonly initial: StartStep.Start;
 readonly states: {
-readonly "start-consent": {
+readonly "start-screen-start": {
 readonly on: {
-readonly "start-screen-proceed": import("../../../types/src/index.js").StartStep.Finish;
+readonly "start-screen-consent-screen": {
+readonly target: StartStep.ConsentScreen;
+readonly actions: {
+readonly type: "setWorkflowStep";
+readonly params: {
+credentialId: `${string}-${string}-${string}-${string}-${string}`;
+step: VirtualStep.Start;
+substep: StartStep.ConsentScreen;
+shouldStoreNavigationState: true;
+activeScreen: ActiveScreen.Workflow;
+};
+};
+};
+readonly "start-screen-finish": {
+readonly target: StartStep.Finish;
+readonly actions: {
+readonly type: "setWorkflowStep";
+readonly params: {
+credentialId: `${string}-${string}-${string}-${string}-${string}`;
+step: VirtualStep.Start;
+substep: StartStep.Finish;
+shouldStoreNavigationState: false;
+activeScreen: ActiveScreen.Workflow;
+};
+};
 };
 };
-readonly "start-finish": {
+};
+readonly "start-screen-consent": {
+readonly on: {
+readonly "start-screen-provide-consent": {
+readonly target: StartStep.Finish;
+readonly actions: {
+readonly type: "setWorkflowStep";
+readonly params: {
+credentialId: undefined;
+step: VirtualStep.Start;
+substep: StartStep.Finish;
+shouldStoreNavigationState: false;
+activeScreen: ActiveScreen.Workflow;
+};
+};
+};
+};
+};
+readonly "start-screen-finish": {
 readonly type: "final";
 };
 };
 readonly on: {
-readonly "step-navigation-next-step": `${string}-${string}-${string}-${string}-${string}`;
+readonly "step-navigation-next-step": {
+readonly target: `${string}-${string}-${string}-${string}-${string}`;
+readonly actions: {
+readonly type: "setWorkflowStep";
+readonly params: {
+credentialId: `${string}-${string}-${string}-${string}-${string}`;
+step: VirtualStep.Start;
+substep: StartStep.Finish;
+shouldStoreNavigationState: false;
+activeScreen: ActiveScreen.Workflow;
+};
+};
+};
+};
+readonly onDone: {
+readonly target: `${string}-${string}-${string}-${string}-${string}`;
+readonly actions: {
+readonly type: "setWorkflowStep";
+readonly params: {
+credentialId: `${string}-${string}-${string}-${string}-${string}`;
+step: VirtualStep.Start;
+substep: StartStep.Finish;
+shouldStoreNavigationState: false;
+activeScreen: ActiveScreen.Workflow;
+};
+};
 };
-readonly onDone: `${string}-${string}-${string}-${string}-${string}`;
 };
 readonly setup: {
 readonly on: {
-readonly "step-navigation-next-step": VirtualStep.Start;
+readonly "step-navigation-next-step": {
+readonly target: VirtualStep.Start;
+readonly actions: {
+readonly type: "setWorkflowStep";
+readonly params: {
+readonly step: VirtualStep.Start;
+readonly substep: StartStep.Start;
+readonly shouldStoreNavigationState: false;
+readonly credentialId: undefined;
+readonly activeScreen: ActiveScreen.Workflow;
+};
+};
+};
 };
 };
 };
@@ -4640,8 +4757,12 @@ export declare type GetImageDataCallback = () => Promise<ImageData | undefined>;
 
 export declare const getIsIdAutoCaptureForMerchantEnabled: () => boolean;
 
+export declare const getJLiveFallbackPolicy: () => JLiveFallbackPolicy;
+
 export declare const getLatestBackupGuid: () => string;
 
+export declare const getMaxFileUploadLimit: () => number;
+
 export declare const getMockedDeviceById: (deviceId: string) => JMediaDeviceInfo | undefined;
 
 export declare const getNavigatorUserAgent: () => string;
@@ -4684,6 +4805,7 @@ export declare const getStateMachineFacemapActions: (credentialId: UUID) => {
     readonly JumioStandardCaptureScreen: `${string}-${string}-${string}-${string}-${string}:identity-jumio-standard-capture-screen`;
     readonly JumioStandardCaptureScreenLiveness: `${string}-${string}-${string}-${string}-${string}:identity-jumio-standard-capture-screen-liveness`;
     readonly JumioStandardCaptureScreenLivenessLoading: `${string}-${string}-${string}-${string}-${string}:identity-jumio-standard-capture-screen-liveness-loading`;
+    readonly JumioStandardCaptureScreenLivenessRetry: `${string}-${string}-${string}-${string}-${string}:identity-jumio-standard-capture-screen-liveness-retry`;
     readonly JumioStandardCaptureScreenSelfie: `${string}-${string}-${string}-${string}-${string}:identity-jumio-standard-capture-screen-selfie`;
     readonly JumioStandardCaptureScreenCaptureFinish: `${string}-${string}-${string}-${string}-${string}:identity-jumio-standard-capture-screen-capture-finish`;
     readonly JumioStandardCaptureScreenUpload: `${string}-${string}-${string}-${string}-${string}:identity-jumio-standard-capture-screen-upload`;
@@ -4709,6 +4831,7 @@ export declare const getStateMachineIdActions: (credentialId: UUID) => {
     readonly CaptureScreenAutoCaptureLoadingSuccess: `${string}-${string}-${string}-${string}-${string}:id-capture-screen-auto-capture-loading-success`;
     readonly CaptureScreenAutoCaptureLoadingFailure: `${string}-${string}-${string}-${string}-${string}:id-capture-screen-auto-capture-loading-failure`;
     readonly CaptureScreenDecision: `${string}-${string}-${string}-${string}-${string}:id-capture-screen-decision`;
+    readonly CaptureScreenPrepareForRecapturingBack: `${string}-${string}-${string}-${string}-${string}:id-capture-prepare-for-recapturing-back`;
     readonly CaptureScreenFrontStart: `${string}-${string}-${string}-${string}-${string}:id-capture-screen-front-start`;
     readonly CaptureScreenFront: `${string}-${string}-${string}-${string}-${string}:id-capture-screen-front`;
     readonly CaptureScreenFrontFinish: `${string}-${string}-${string}-${string}-${string}:id-capture-screen-front-finish`;
@@ -4719,8 +4842,9 @@ export declare const getStateMachineIdActions: (credentialId: UUID) => {
     readonly CaptureScreenUpload: `${string}-${string}-${string}-${string}-${string}:id-capture-screen-upload`;
     readonly CaptureScreenUploadFailed: `${string}-${string}-${string}-${string}-${string}:id-capture-screen-upload-failed`;
     readonly IdUsabilityCheck: `${string}-${string}-${string}-${string}-${string}:id-usability-check`;
-    readonly IdUsabilityCheckSuccess: `${string}-${string}-${string}-${string}-${string}:id-usability-check-success`;
     readonly IdUsabilityCheckFailure: `${string}-${string}-${string}-${string}-${string}:id-usability-check-failure`;
+    readonly IdUsabilityCheckBackMissing: `${string}-${string}-${string}-${string}-${string}:id-usability-check-back-missing`;
+    readonly IdUsabilityCheckSuccess: `${string}-${string}-${string}-${string}-${string}:id-usability-check-success`;
     readonly IdUsabilitySupportedList: `${string}-${string}-${string}-${string}-${string}:id-usability-supported-list`;
     readonly IdUsabilityCheckReset: `${string}-${string}-${string}-${string}-${string}:id-usability-check-reset`;
     readonly Upload: `${string}-${string}-${string}-${string}-${string}:id-upload`;
@@ -4731,7 +4855,9 @@ export declare const getStateMachineInstance: () => Actor<ReturnType<typeof gene
 
 export declare const getStateMachineStartScreenActions: () => {
     readonly Start: "start-screen-start";
-    readonly Proceed: "start-screen-proceed";
+    readonly ConsentScreen: "start-screen-consent-screen";
+    readonly ProvideConsent: "start-screen-provide-consent";
+    readonly Finish: "start-screen-finish";
 };
 
 export declare const getToken: () => TokenState;
@@ -4754,13 +4880,9 @@ usabilityEntities: Record<FileStoreKey, UsabilityCheckState>;
 usabilityIds: FileStoreKey[];
 }, EntitiesRef<"usabilityEntities", "usabilityIds", "idKeyUsability">> | undefined;
 
-export declare const getUsabilityEntitiesByCategory: (credentialId: UUID) => getEntityType<    {
-uploadEntities: Record<FileStoreKey, UploadState>;
-uploadIds: FileStoreKey[];
-} & {
-usabilityEntities: Record<FileStoreKey, UsabilityCheckState>;
-usabilityIds: FileStoreKey[];
-}, EntitiesRef<"usabilityEntities", "usabilityIds", "idKeyUsability">>[];
+export declare const getUsabilityEntitiesByCategory: (credentialId: UUID) => UsabilityCheckState[];
+
+export declare function getWorkerData(): Promise<DataAcquisitionFetchParameters>;
 
 export declare function getWorkflowInstance(): WorkflowController;
 
@@ -4777,7 +4899,7 @@ export declare const getWorkflowState: () => WorkflowState;
 
 export declare const getWorkflowStep: () => Category | VirtualStep;
 
-export declare const getWorkflowSubstep: () => IdStep | FacemapStep | DocumentStep | DataStep | undefined;
+export declare const getWorkflowSubstep: () => StartStep | IdStep | FacemapStep | DocumentStep | DataStep | undefined;
 
 export declare class GuidanceFaceAnimationComponent extends BaseComponent {
     #private;
@@ -4847,6 +4969,7 @@ export declare enum IdStep {
     CaptureScreenDecision = "id-capture-screen-decision",
     CaptureScreenFront = "id-capture-screen-front",
     CaptureScreenFrontFinish = "id-capture-screen-front-finish",
+    CaptureScreenPrepareForRecapturingBack = "id-capture-screen-prepare-for-recapturing-back",
     CaptureScreenFrontStart = "id-capture-screen-front-start",
     CaptureScreenSelectProvider = "id-capture-screen-select-provider",
     CaptureScreenUpload = "id-capture-screen-upload",
@@ -4858,6 +4981,7 @@ export declare enum IdStep {
     Finish = "id-finish",
     IdUsabilityCheck = "id-usability-check",
     IdUsabilityCheckFailure = "id-usability-check-failure",
+    IdUsabilityCheckBackMissing = "id-usability-check-back-missing",
     IdUsabilityCheckReset = "id-usability-check-reset",
     IdUsabilitySupportedList = "id-usability-supported-list",
     Start = "id-start",
@@ -4878,7 +5002,6 @@ export declare enum IdTypeUpload {
     ResidencePermit = "RESIDENCE_PERMIT",
     Visa = "VISA",
     DrivingLicense = "DRIVING_LICENSE",
-    Other = "OTHER",
     DigitalIdentity = "DIGITAL_IDENTITY"
 }
 
@@ -4997,6 +5120,8 @@ export declare const isAndroid: () => boolean | undefined;
 
 export declare const isAutocaptureActive: () => boolean;
 
+export declare const isBackMissingForUsability: (countryCode?: CountryCode, idType?: IdTypeUpload) => boolean;
+
 export declare const isButtonShape: (value: unknown) => value is ButtonShape;
 
 export declare const isButtonSize: (value: unknown) => value is ButtonSize;
@@ -5017,6 +5142,8 @@ export declare const isColorScheme: (value: unknown) => value is ColorScheme;
 
 export declare const isConsentGivenSent$: () => Observable<boolean>;
 
+export declare const isHas2Parts$: (countryCode?: CountryCode, idType?: IdTypeUpload) => Observable<boolean>;
+
 export declare const isIos: () => boolean;
 
 export declare const isLocaleValid: (value: unknown) => value is Locale;
@@ -5029,6 +5156,10 @@ export declare const isTokenExpired$: () => Observable<boolean>;
 
 export declare const isTrackPlaying: (deviceId: string, track: MediaStreamTrack) => boolean;
 
+export declare type IsUsabilityBackMissing = {
+    isBackMissing: boolean;
+} & Partial<Pick<ExtractedData, 'country' | 'idType'>>;
+
 export declare const isValidContainerType: (value: unknown) => value is DsAppContainerLayoutType;
 
 export declare const isWCAGCompliant: (colors: {
@@ -5048,6 +5179,17 @@ export declare interface JCredentialMap {
     [Category.Data]: CredentialData;
 }
 
+export declare interface JLiveFallbackError {
+    type: ManualCaptureFallbackReason;
+    message?: string;
+}
+
+export declare enum JLiveFallbackPolicy {
+    Disabled = "disabled",
+    Soft = "soft",
+    Strict = "strict"
+}
+
 export declare type JLivePartName = `${UUID}_${FacemapVerificationMethod.JumioLiveness}_${number}`;
 
 export declare type JMediaDeviceInfo = Pick<MediaDeviceInfo, 'kind' | 'deviceId' | 'groupId' | 'label'> & {
@@ -5295,6 +5437,22 @@ declare class JumioSdkFileUploadFailedController implements ReactiveController {
     hostConnected(): void;
 }
 
+declare class JumioSdkLocaleSelectionController implements ReactiveController {
+    #private;
+    constructor(host: ReactiveElement);
+    hostDisconnected(): void;
+    updateLocale(locale: Locale): void;
+    getSelectedLocale(): Locale;
+    getLocales(): LocaleLanguageMap[];
+}
+
+export declare class JumioSdkLocalSelectionComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkLocaleSelectionController> {
+    #private;
+    static styles: CSSResult[];
+    get componentController(): JumioSdkLocaleSelectionController;
+    render(): TemplateResult<1>;
+}
+
 export declare class JumioSdkLoggerConsoleComponent extends BaseComponent implements LoggerConsoleConfig {
     readonly type = "LoggerConsole";
     isEnabled: boolean;
@@ -5365,7 +5523,7 @@ export declare type JumioSdkMessage = JumioSdkMessageError | JumioSdkMessageSucc
 export declare interface JumioSdkMessageBase {
     id: JumioSdkMessageId;
     title: string;
-    message: string;
+    message?: string;
     overlay?: boolean;
     closable: boolean;
 }
@@ -5398,12 +5556,14 @@ export declare enum JumioSdkMessageId {
     AcquisitionSuccessful = "acquisition-success",
     UsabilityCheck = "usability-check",
     CameraGenericError = "camera-generic-error",
+    CameraInitialization = "camera-initialization",
     CameraNotAllowedError = "camera-not-allowed-error",
     SessionExpired = "session-expired",
     Uploading = "uploading",
     Finalizing = "finalizing",
     EmbargoedCountry = "embargoed-country",
-    CloseBrowser = "close-browser"
+    CloseBrowser = "close-browser",
+    LivenessFailed = "liveness-failed"
 }
 
 export declare interface JumioSdkMessageProgress extends JumioSdkMessageBase {
@@ -5445,6 +5605,7 @@ export declare enum JumioSdkMessageType {
 
 export declare class JumioSdkNavigationBrowserComponent extends BaseComponent implements NavigationService {
     #private;
+    static isTheSameNavigationStep(a: Pick<WorkflowState, 'credentialId' | 'step' | 'substep'>, b: Pick<WorkflowState, 'credentialId' | 'step' | 'substep'>): boolean;
     static styles: CSSResult[];
     transformUrl: NavigationUrlTransformer;
     baseUrl: string;
@@ -5452,6 +5613,7 @@ export declare class JumioSdkNavigationBrowserComponent extends BaseComponent im
     interceptors: JumioSdkNavigationInterceptor[];
     navigationConfig: NavigationConfig<NavigationType.Browser>[];
     private lastPushedState;
+    private initialWorkflowState;
     disconnectedCallback(): void;
     firstUpdated(changedProperties: PropertyValues): void;
     render(): TemplateResult<1>;
@@ -5471,7 +5633,7 @@ export declare class JumioSdkNavigationButtonComponent extends BaseComponent {
     type: ButtonType;
     shape: ButtonShape;
     readonly navigationService: NavigationService | undefined;
-    render(): TemplateResult<1> | typeof nothing;
+    render(): TemplateResult<1>;
 }
 
 export declare class JumioSdkNavigationComponent extends BaseComponent implements JumioSdkStepNavigationForwardController {
@@ -5660,14 +5822,14 @@ declare class JumioSdkStepDocumentUploadController implements ReactiveController
 
 export declare class JumioSdkStepFacemapCaptureStateComponent extends BaseComponent {
     #private;
-    captureStateController: AsyncController<IdStep | FacemapStep | DocumentStep | DataStep | undefined>;
+    captureStateController: AsyncController<StartStep | IdStep | FacemapStep | DocumentStep | DataStep | undefined>;
     render(): symbol | TemplateResult_2<1>;
 }
 
 export declare class JumioSdkStepFacemapComponent extends BaseComponent implements ControllerProvider<WorkflowStepController<Category.Facemap>, JumioSdkStepFacemapController> {
     #private;
     static styles: CSSResult[];
-    stepInformationController: AsyncController<IdStep | FacemapStep | DocumentStep | DataStep | undefined>;
+    stepInformationController: AsyncController<StartStep | IdStep | FacemapStep | DocumentStep | DataStep | undefined>;
     readonly componentController: JumioSdkStepFacemapController;
     get workflowStepController(): WorkflowStepController<Category.Facemap>;
     render(): TemplateResult<1> | typeof nothing;
@@ -5680,8 +5842,8 @@ declare class JumioSdkStepFacemapController implements ReactiveController {
     hostDisconnected(): void;
     selectVerificationMethods$(): Observable<FacemapVerificationMethod[]>;
     selectActiveVerificationMethod$(): Observable<FacemapVerificationMethod | undefined>;
-    selectFacemapStepInformation$(): Observable<IdStep | FacemapStep | DocumentStep | DataStep | undefined>;
-    getStepChange$(): Observable<[IdStep | FacemapStep | DocumentStep | DataStep | undefined, FacemapVerificationMethod[], FacemapVerificationMethod | undefined]>;
+    selectFacemapStepInformation$(): Observable<StartStep | IdStep | FacemapStep | DocumentStep | DataStep | undefined>;
+    getStepChange$(): Observable<[StartStep | IdStep | FacemapStep | DocumentStep | DataStep | undefined, FacemapVerificationMethod[], FacemapVerificationMethod | undefined]>;
     handleVerificationMethodFailed(verificationMethods: FacemapVerificationMethod[], activeVerificationMethod: FacemapVerificationMethod | undefined): void;
     handleNoVerificationMethodsLeft(): void;
     decideOnVerificationMethod(): void;
@@ -5804,6 +5966,7 @@ declare class JumioSdkStepIdCaptureController implements ReactiveController {
     #private;
     readonly workflowController: WorkflowController;
     readonly stepController: WorkflowStepController<Category.Id>;
+    readonly hasFileUpload$: Observable<boolean>;
     constructor(host: JumioSdkStepIdCaptureComponent);
     hostConnected(): void;
     hostDisconnected(): void;
@@ -5826,7 +5989,7 @@ export declare class JumioSdkStepIdCaptureStateComponent extends BaseComponent i
     #private;
     static styles: CSSResult[];
     idStepAsyncController: AsyncController<{
-        substep: IdStep | FacemapStep | DocumentStep | DataStep | undefined;
+        substep: StartStep | IdStep | FacemapStep | DocumentStep | DataStep | undefined;
         capturing: boolean;
     }>;
     render(): TemplateResult_2<1>;
@@ -5855,7 +6018,7 @@ declare class JumioSdkStepIdController implements ReactiveController {
     isDocumentTypeSelected(selection: IdCredentialSelection): boolean;
     isDocumentVariantSelected(selection: IdCredentialSelection): boolean;
     isDigitalIdentityTypeSelected(selection: IdCredentialSelection): boolean;
-    getStepSelection$(): Observable<IdStep | FacemapStep | DocumentStep | DataStep | undefined>;
+    getStepSelection$(): Observable<StartStep | IdStep | FacemapStep | DocumentStep | DataStep | undefined>;
     handleStart(): void;
     handleDocTypeDecision(): Promise<void>;
 }
@@ -5869,7 +6032,6 @@ export declare class JumioSdkStepIdCountrySelectionComponent extends BaseCompone
 
 declare class JumioSdkStepIdCountrySelectionController implements ReactiveController {
     #private;
-    static getTranslatedCountry(countryCode: CountryCode | undefined): Country;
     readonly countryList$: Observable<Country[]>;
     constructor(host: ReactiveElement);
     hostDisconnected(): void;
@@ -5917,30 +6079,15 @@ declare class JumioSdkStepIdDocumentVariantController implements ReactiveControl
     hostConnected(): void;
 }
 
-declare class JumioSdkStepIdLocaleSelectionController implements ReactiveController {
-    #private;
-    constructor(host: ReactiveElement);
-    hostDisconnected(): void;
-    updateLocale(locale: Locale): void;
-    getSelectedLocale(): Locale;
-    getLocales(): LocaleLanguageMap[];
-}
-
-export declare class JumioSdkStepIdLocalSelectionComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkStepIdLocaleSelectionController> {
-    #private;
-    static styles: CSSResult[];
-    get componentController(): JumioSdkStepIdLocaleSelectionController;
-    render(): TemplateResult<1>;
-}
-
 export declare class JumioSdkStepIdUploadComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkStepIdUploadController> {
     #private;
     static styles: CSSResult[];
+    uploadErrorMessage$: BehaviorSubject<(FilePickerError | undefined)[]>;
     digitalIdentityController: AsyncController<DigitalIdentityProps | undefined>;
     idTypeController: AsyncController<IdTypeUpload | undefined>;
     partsController: AsyncController<UploadState[]>;
+    uploadErrorMessageController: AsyncController<(FilePickerError | undefined)[]>;
     readyController: AsyncController<boolean | undefined>;
-    maxFileSizeController: AsyncController<number | undefined>;
     imageCollectionController: AsyncController<FileWithNameBase64Url[]>;
     brazilianIdImageController: AsyncController<url>;
     constructor();
@@ -5955,7 +6102,6 @@ declare class JumioSdkStepIdUploadController implements ReactiveController {
     readonly idType$: Observable<IdTypeUpload | undefined>;
     readonly parts$: Observable<UploadState[]>;
     readonly ready$: Observable<boolean | undefined>;
-    readonly maxFileUploadSize$: Observable<number | undefined>;
     constructor(host: ReactiveElement);
     hostConnected(): void;
     uploadFile(event: FileUploadEvent, key: FileStoreKey): Promise<UploadResponse>;
@@ -6013,19 +6159,27 @@ export declare class JumioSdkStepSetupComponent extends BaseComponent {
 }
 
 export declare class JumioSdkStepStartComponent extends BaseComponent implements ControllerProvider<WorkflowStepController<VirtualStep.Start>, JumioSdkStepStartController> {
+    #private;
+    static styles: CSSResult[];
+    stepInformationController: AsyncController<StartStep | IdStep | FacemapStep | DocumentStep | DataStep | undefined>;
+    get workflowStepController(): WorkflowStepController<VirtualStep.Start>;
+    get componentController(): JumioSdkStepStartController;
+    render(): TemplateResult<1> | typeof nothing;
+}
+
+export declare class JumioSdkStepStartConsentComponent extends BaseComponent implements ControllerProvider<WorkflowStepController<VirtualStep.Start>, JumioSdkStepStartConsentController> {
     #private;
     static styles: CSSResult[];
     colorScheme: ColorScheme;
     readonly documentCodeController: AsyncController<SupportedDocumentType | undefined>;
     constructor();
     get workflowStepController(): WorkflowStepController<VirtualStep.Start>;
-    get componentController(): JumioSdkStepStartController;
-    connectedCallback(): void;
+    get componentController(): JumioSdkStepStartConsentController;
     render(): TemplateResult<1>;
     renderInstructionsForCategories(params?: RenderInstructionsForCategoriesParams): TemplateResult<1>;
 }
 
-declare class JumioSdkStepStartController implements ReactiveController {
+declare class JumioSdkStepStartConsentController implements ReactiveController {
     #private;
     constructor(host: ReactiveElement, workflow?: WorkflowController);
     getController(): WorkflowStepController<VirtualStep.Start>;
@@ -6040,6 +6194,162 @@ declare class JumioSdkStepStartController implements ReactiveController {
     getCredentials(): JCredential[];
 }
 
+declare class JumioSdkStepStartController implements ReactiveController {
+    #private;
+    readonly dispatchNextScreen$: Observable<unknown>;
+    constructor(host: ReactiveElement, workflow?: WorkflowController);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    navigateToNextScreen(settings: Settings, stateManager?: Actor<StateMachine<MachineContext, AnyEventObject, {}, never, {
+    type: "setWorkflowStep";
+    params: NavigationStep;
+    }, never, never, {
+    step: VirtualStep.Setup | VirtualStep.Finish | {
+    start: StartStep;
+    };
+    activeScreen: ActiveScreen;
+    }, string, NonReducibleUnknown, NonReducibleUnknown, EventObject, MetaObject, {
+    readonly id: "@jumio/websdk workflow state machine";
+    readonly type: "parallel";
+    readonly states: {
+    readonly step: {
+    readonly id: "step";
+    readonly initial: string;
+    readonly states: {
+    readonly finish: {
+    readonly on: {
+    readonly "step-navigation-previous-step": `${string}-${string}-${string}-${string}-${string}`;
+    };
+    };
+    readonly start: {
+    readonly initial: import("../../../../types/src/index.js").StartStep.Start;
+    readonly states: {
+    readonly "start-screen-start": {
+    readonly on: {
+    readonly "start-screen-consent-screen": {
+    readonly target: import("../../../../types/src/index.js").StartStep.ConsentScreen;
+    readonly actions: {
+    readonly type: "setWorkflowStep";
+    readonly params: {
+    credentialId: `${string}-${string}-${string}-${string}-${string}`;
+    step: VirtualStep.Start;
+    substep: import("../../../../types/src/index.js").StartStep.ConsentScreen;
+    shouldStoreNavigationState: true;
+    activeScreen: import("../../../../types/src/index.js").ActiveScreen.Workflow;
+    };
+    };
+    };
+    readonly "start-screen-finish": {
+    readonly target: import("../../../../types/src/index.js").StartStep.Finish;
+    readonly actions: {
+    readonly type: "setWorkflowStep";
+    readonly params: {
+    credentialId: `${string}-${string}-${string}-${string}-${string}`;
+    step: VirtualStep.Start;
+    substep: import("../../../../types/src/index.js").StartStep.Finish;
+    shouldStoreNavigationState: false;
+    activeScreen: import("../../../../types/src/index.js").ActiveScreen.Workflow;
+    };
+    };
+    };
+    };
+    };
+    readonly "start-screen-consent": {
+    readonly on: {
+    readonly "start-screen-provide-consent": {
+    readonly target: import("../../../../types/src/index.js").StartStep.Finish;
+    readonly actions: {
+    readonly type: "setWorkflowStep";
+    readonly params: {
+    credentialId: undefined;
+    step: VirtualStep.Start;
+    substep: import("../../../../types/src/index.js").StartStep.Finish;
+    shouldStoreNavigationState: false;
+    activeScreen: import("../../../../types/src/index.js").ActiveScreen.Workflow;
+    };
+    };
+    };
+    };
+    };
+    readonly "start-screen-finish": {
+    readonly type: "final";
+    };
+    };
+    readonly on: {
+    readonly "step-navigation-next-step": {
+    readonly target: `${string}-${string}-${string}-${string}-${string}`;
+    readonly actions: {
+    readonly type: "setWorkflowStep";
+    readonly params: {
+    credentialId: `${string}-${string}-${string}-${string}-${string}`;
+    step: VirtualStep.Start;
+    substep: import("../../../../types/src/index.js").StartStep.Finish;
+    shouldStoreNavigationState: false;
+    activeScreen: import("../../../../types/src/index.js").ActiveScreen.Workflow;
+    };
+    };
+    };
+    };
+    readonly onDone: {
+    readonly target: `${string}-${string}-${string}-${string}-${string}`;
+    readonly actions: {
+    readonly type: "setWorkflowStep";
+    readonly params: {
+    credentialId: `${string}-${string}-${string}-${string}-${string}`;
+    step: VirtualStep.Start;
+    substep: import("../../../../types/src/index.js").StartStep.Finish;
+    shouldStoreNavigationState: false;
+    activeScreen: import("../../../../types/src/index.js").ActiveScreen.Workflow;
+    };
+    };
+    };
+    };
+    readonly setup: {
+    readonly on: {
+    readonly "step-navigation-next-step": {
+    readonly target: VirtualStep.Start;
+    readonly actions: {
+    readonly type: "setWorkflowStep";
+    readonly params: {
+    readonly step: VirtualStep.Start;
+    readonly substep: import("../../../../types/src/index.js").StartStep.Start;
+    readonly shouldStoreNavigationState: false;
+    readonly credentialId: undefined;
+    readonly activeScreen: import("../../../../types/src/index.js").ActiveScreen.Workflow;
+    };
+    };
+    };
+    };
+    };
+    };
+    readonly entry: ActionFunction<MachineContext, AnyEventObject, AnyEventObject, undefined, never, {
+    type: "setWorkflowStep";
+    params: NavigationStep;
+    }, never, never, EventObject>;
+    };
+    readonly activeScreen: {
+    readonly id: "active screen state machine";
+    readonly initial: import("../../../../types/src/index.js").ActiveScreen.Workflow;
+    readonly states: {
+    readonly workflow: {};
+    readonly "cross-device": {};
+    };
+    readonly on: {
+    readonly "active-screen-navigate-to-cross-device": {
+    readonly target: ".cross-device";
+    readonly actions: any;
+    };
+    readonly "active-screen-navigate-to-workflow": {
+    readonly target: ".workflow";
+    readonly actions: any;
+    };
+    };
+    };
+    };
+    }>>): void;
+    getNavigateToNextScreen$(): Observable<Settings>;
+}
+
 export declare class JumioSdkSupportedIdSearchComponent extends BaseComponent {
     #private;
     static styles: CSSResult[];
@@ -6242,6 +6552,8 @@ export declare interface LivenessState {
     jLiveProgressStepsTotal: number;
     jLiveUiCommand: UXUICommand | undefined;
     jLiveVisibleFaceFinder: LivenessRefDistance;
+    jLiveManualCaptureFallbackReason: ManualCaptureFallbackReason | undefined;
+    jLiveFallbackError: JLiveFallbackError | undefined;
 }
 
 declare type LivenessVisorInfoEvent = LivenessBaseEvent<EventName.VisorInfo>;
@@ -6363,7 +6675,7 @@ export declare enum LogLevel {
     None = "none"
 }
 
-declare enum ManualCaptureFallbackReason {
+export declare enum ManualCaptureFallbackReason {
     ModuleLoadingError = "module-loading-error",
     ModuleInitializationError = "module-initialization-error",
     WorkerCrashed = "worker-crashed",
@@ -6375,6 +6687,8 @@ declare enum ManualCaptureFallbackReason {
     ExcludedDevice = "excluded-device"
 }
 
+export declare const maxFileSizeMessage: (maxFileSize: number) => string;
+
 declare type MediaDeviceMetadata = Partial<Pick<MediaDeviceInfo, 'label' | 'deviceId' | 'groupId' | 'kind'>>;
 
 export declare interface MerchantSettings extends Record<string, unknown> {
@@ -6386,6 +6700,7 @@ export declare interface MerchantSettings extends Record<string, unknown> {
     isExplicitUploadEnabled?: boolean;
     isFileUploadEnabled?: boolean;
     jLiveEnabled?: boolean;
+    jLiveFallbackPolicy: JLiveFallbackPolicy;
 }
 
 export declare interface MerchantSettingsAutocapture {
@@ -6551,7 +6866,7 @@ export declare type NavigationStepVirtualStepFinish = NavigationStepBase<Virtual
 
 export declare type NavigationStepVirtualStepSetup = NavigationStepBase<VirtualStep.Setup, undefined>;
 
-export declare type NavigationStepVirtualStepStart = NavigationStepBase<VirtualStep.Start, undefined>;
+export declare type NavigationStepVirtualStepStart = NavigationStepBase<VirtualStep.Start, StartStep>;
 
 export declare enum NavigationType {
     Browser = "browser",
@@ -6753,25 +7068,103 @@ readonly "step-navigation-previous-step": `${string}-${string}-${string}-${strin
 };
 };
 readonly start: {
-readonly initial: import("../../../types/src/index.js").StartStep.Consent;
+readonly initial: import("../../../types/src/index.js").StartStep.Start;
 readonly states: {
-readonly "start-consent": {
+readonly "start-screen-start": {
+readonly on: {
+readonly "start-screen-consent-screen": {
+readonly target: import("../../../types/src/index.js").StartStep.ConsentScreen;
+readonly actions: {
+readonly type: "setWorkflowStep";
+readonly params: {
+credentialId: `${string}-${string}-${string}-${string}-${string}`;
+step: import("../../../types/src/index.js").VirtualStep.Start;
+substep: import("../../../types/src/index.js").StartStep.ConsentScreen;
+shouldStoreNavigationState: true;
+activeScreen: import("../../../types/src/index.js").ActiveScreen.Workflow;
+};
+};
+};
+readonly "start-screen-finish": {
+readonly target: import("../../../types/src/index.js").StartStep.Finish;
+readonly actions: {
+readonly type: "setWorkflowStep";
+readonly params: {
+credentialId: `${string}-${string}-${string}-${string}-${string}`;
+step: import("../../../types/src/index.js").VirtualStep.Start;
+substep: import("../../../types/src/index.js").StartStep.Finish;
+shouldStoreNavigationState: false;
+activeScreen: import("../../../types/src/index.js").ActiveScreen.Workflow;
+};
+};
+};
+};
+};
+readonly "start-screen-consent": {
 readonly on: {
-readonly "start-screen-proceed": import("../../../types/src/index.js").StartStep.Finish;
+readonly "start-screen-provide-consent": {
+readonly target: import("../../../types/src/index.js").StartStep.Finish;
+readonly actions: {
+readonly type: "setWorkflowStep";
+readonly params: {
+credentialId: undefined;
+step: import("../../../types/src/index.js").VirtualStep.Start;
+substep: import("../../../types/src/index.js").StartStep.Finish;
+shouldStoreNavigationState: false;
+activeScreen: import("../../../types/src/index.js").ActiveScreen.Workflow;
+};
 };
 };
-readonly "start-finish": {
+};
+};
+readonly "start-screen-finish": {
 readonly type: "final";
 };
 };
 readonly on: {
-readonly "step-navigation-next-step": `${string}-${string}-${string}-${string}-${string}`;
+readonly "step-navigation-next-step": {
+readonly target: `${string}-${string}-${string}-${string}-${string}`;
+readonly actions: {
+readonly type: "setWorkflowStep";
+readonly params: {
+credentialId: `${string}-${string}-${string}-${string}-${string}`;
+step: import("../../../types/src/index.js").VirtualStep.Start;
+substep: import("../../../types/src/index.js").StartStep.Finish;
+shouldStoreNavigationState: false;
+activeScreen: import("../../../types/src/index.js").ActiveScreen.Workflow;
+};
+};
+};
+};
+readonly onDone: {
+readonly target: `${string}-${string}-${string}-${string}-${string}`;
+readonly actions: {
+readonly type: "setWorkflowStep";
+readonly params: {
+credentialId: `${string}-${string}-${string}-${string}-${string}`;
+step: import("../../../types/src/index.js").VirtualStep.Start;
+substep: import("../../../types/src/index.js").StartStep.Finish;
+shouldStoreNavigationState: false;
+activeScreen: import("../../../types/src/index.js").ActiveScreen.Workflow;
+};
+};
 };
-readonly onDone: `${string}-${string}-${string}-${string}-${string}`;
 };
 readonly setup: {
 readonly on: {
-readonly "step-navigation-next-step": import("../../../types/src/index.js").VirtualStep.Start;
+readonly "step-navigation-next-step": {
+readonly target: import("../../../types/src/index.js").VirtualStep.Start;
+readonly actions: {
+readonly type: "setWorkflowStep";
+readonly params: {
+readonly step: import("../../../types/src/index.js").VirtualStep.Start;
+readonly substep: import("../../../types/src/index.js").StartStep.Start;
+readonly shouldStoreNavigationState: false;
+readonly credentialId: undefined;
+readonly activeScreen: import("../../../types/src/index.js").ActiveScreen.Workflow;
+};
+};
+};
 };
 };
 };
@@ -7066,7 +7459,7 @@ export declare const selectWorkflowStep$: () => Observable<Category | VirtualSte
 
 export declare const selectWorkflowStepInformation$: () => Observable<NavigationStepVirtualStepSetup | NavigationStepVirtualStepStart | NavigationStepCategoryId | NavigationStepCategoryFacemap | NavigationStepCategoryDocument | NavigationStepCategoryData | NavigationStepVirtualStepFinish>;
 
-export declare const selectWorkflowSubstep$: () => Observable<IdStep | FacemapStep | DocumentStep | DataStep | undefined>;
+export declare const selectWorkflowSubstep$: () => Observable<StartStep | IdStep | FacemapStep | DocumentStep | DataStep | undefined>;
 
 export declare interface SendEventRequest {
     events: EventBody[];
@@ -7159,6 +7552,7 @@ export declare interface Settings extends Record<string, unknown> {
     supportedDocumentTypes: SupportedDocumentType[];
     timestamp: string;
     workflowDefinitionKey: number;
+    skipStartScreen?: boolean;
 }
 
 export declare const settings: EventDispatcher<    {
@@ -7264,8 +7658,9 @@ export declare class StartCaptureEvent extends CustomEvent<void> {
 }
 
 export declare enum StartStep {
-    Consent = "start-consent",
-    Finish = "start-finish"
+    Start = "start-screen-start",
+    ConsentScreen = "start-screen-consent",
+    Finish = "start-screen-finish"
 }
 
 export declare interface StateMachineCredentialIdLike {
@@ -7549,6 +7944,8 @@ stack?: string;
 
 export declare const updateConsent: (item: ConsentData) => void;
 
+export declare const updateFrontFileStoreIds: (newId: FileStoreKey) => void;
+
 export declare interface UpdateMetadataParams {
     countrySelection?: string;
     credentialFileGuidSelection?: string[];
@@ -7572,6 +7969,12 @@ export declare const uploadedFile: EventDispatcher<    {
 source: FileSource;
 }>;
 
+export declare class UploadErrorMessageComponent extends BaseComponent {
+    static styles: CSSResult[];
+    message: string;
+    render(): TemplateResult<1>;
+}
+
 declare enum UploadEvents {
     FilesUploadedRaw = "filesuploadedraw",
     FilesUploaded = "filesuploaded"
@@ -7628,8 +8031,7 @@ export declare enum UploadType {
     Iproov = "IPROOV",
     Video = "VIDEO",
     Screenshot = "SCREENSHOT",
-    MrzImage = "MRZ_IMAGE",
-    Other = "OTHER"
+    MrzImage = "MRZ_IMAGE"
 }
 
 export declare type UploadTypeJumioLiveness = `JUMIO_LIVENESS_${number}` | 'JUMIO_LIVENESS_BLOB';
@@ -7691,6 +8093,8 @@ export declare interface UsabilityNotAvailableResult {
 
 export declare interface UsabilityPassResult {
     decisionType: DecisionType.PASS;
+    extractedData?: ExtractedData;
+    classifier: UploadType;
 }
 
 export declare interface UsabilityRejectResult {
@@ -8064,6 +8468,10 @@ export declare interface WorkflowStepFacemap extends WorkflowStepCredentialLogic
     patchIproovTokenState(tokenData: Partial<IproovTokenState>): void;
     validateIproovToken$(params: ValidateIproovTokenRequest): Observable<ValidateIproovTokenResponse>;
     selectVerificationMethods$(): Observable<FacemapVerificationMethod[]>;
+    setJLiveManualCaptureFallbackReason(reason: ManualCaptureFallbackReason | undefined): void;
+    selectJLiveManualCaptureFallbackReason$(): Observable<ManualCaptureFallbackReason | undefined>;
+    selectJLiveFallbackError$(): Observable<JLiveFallbackError | undefined>;
+    resetJLiveFallbackError(): void;
     setActiveFaceVerificationMethod: (activeVerificationMethod: FacemapVerificationMethod | undefined) => void;
     getActiveFaceVerificationMethod: () => FacemapVerificationMethod | undefined;
     selectActiveFaceVerificationMethod$: () => Observable<FacemapVerificationMethod | undefined>;
@@ -8098,6 +8506,10 @@ export declare interface WorkflowStepFacemapController extends WorkflowStepCrede
     validateIproovTokenAsync(params: ValidateIproovTokenRequest): Promise<ValidateIproovTokenResponse>;
     selectVerificationMethods$(): Observable<FacemapVerificationMethod[]>;
     getVerificationMethodsAsync(): Promise<FacemapVerificationMethod[]>;
+    setJLiveManualCaptureFallbackReason(reason: ManualCaptureFallbackReason): void;
+    selectJLiveManualCaptureFallbackReason$(): Observable<ManualCaptureFallbackReason | undefined>;
+    selectJLiveFallbackError$(): Observable<JLiveFallbackError | undefined>;
+    resetJLiveFallbackError(): void;
     setActiveFaceVerificationMethod: (activeVerificationMethod: FacemapVerificationMethod | undefined) => void;
     getActiveFaceVerificationMethod: () => FacemapVerificationMethod | undefined;
     selectActiveFaceVerificationMethod$: () => Observable<FacemapVerificationMethod | undefined>;
@@ -8140,6 +8552,8 @@ export declare interface WorkflowStepId extends WorkflowStepCredentialLogic<Cate
     patchUserSelection(params: IdCredentialSelection): void;
     getUserSelection(): IdCredentialSelection;
     selectUserSelection$(): Observable<IdCredentialSelection>;
+    isUsabilityBackMissing(credentialId: UUID): IsUsabilityBackMissing;
+    are2FilesUploaded(credentialId: UUID): boolean;
     selectSidesForSelectedDocument$(): Observable<IdSide[]>;
     selectPartsForDocumentType$(params: IdCredentialSelection): Observable<IdTypeVariantPart[]>;
     getPartsForDocumentType(params: IdCredentialSelection): IdTypeVariantPart[];
@@ -8159,6 +8573,8 @@ export declare interface WorkflowStepIdController extends WorkflowStepCredential
     getIdTypeVariantCollectionAsync(): Promise<IdTypeVariant[]>;
     patchUserSelection(params: IdCredentialSelection): void;
     getUserSelection(): IdCredentialSelection;
+    isUsabilityBackMissing(credentialId: UUID): IsUsabilityBackMissing;
+    are2FilesUploaded(credentialId: UUID): boolean;
     selectUserSelection$(): Observable<IdCredentialSelection>;
     selectSidesForSelectedDocument$(): Observable<IdSide[]>;
     getSidesForSelectedDocumentAsync(): Promise<IdSide[]>;