@incodetech/core 0.0.0-dev-20260409-a38d5e8 → 0.0.0-dev-20260409-09dfd52

package/dist/governmentValidationStateMachine-C_iPX9VE.esm.js

@@ -0,0 +1,271 @@
+import { t as api } from "./api-aa9Mx20l.esm.js";
+import { _ as endpoints } from "./events-W91zLpx4.esm.js";
+import { i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-B7FPE6br.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-v7bpbrAk.esm.js";
+
+//#region src/modules/government-validation/governmentValidationServices.ts
+async function processGovernmentValidation(signal) {
+	const res = await api.post(endpoints.governmentValidation, {}, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.governmentValidation} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function submitGovernmentValidationOtp(params, signal) {
+	const res = await api.post(endpoints.governmentValidation, { otpCode: params.code }, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.governmentValidation} (OTP) failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/government-validation/governmentValidationStateMachine.ts
+const RESEND_TIMER_SECONDS = 30;
+const POLL_INTERVAL_MS = 2e3;
+const MAX_POLL_COUNT = 60;
+const AUTO_PROCEED_DELAY_MS = 3e3;
+const governmentValidationMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	delays: { AUTO_PROCEED: AUTO_PROCEED_DELAY_MS },
+	actors: {
+		processValidation: fromPromise(async ({ signal }) => {
+			return processGovernmentValidation(signal);
+		}),
+		submitOtp: fromPromise(async ({ input, signal }) => {
+			return submitGovernmentValidationOtp({ code: input.code }, signal);
+		}),
+		pollingTimer: fromCallback(({ sendBack }) => {
+			const timer = BrowserTimerProvider.getInstance();
+			const interval = timer.setInterval(() => {
+				sendBack({ type: "POLL" });
+			}, POLL_INTERVAL_MS);
+			return () => timer.clearInterval(interval);
+		}),
+		resendTimer: fromCallback(({ sendBack }) => {
+			const timer = BrowserTimerProvider.getInstance();
+			let seconds = RESEND_TIMER_SECONDS;
+			const interval = timer.setInterval(() => {
+				seconds -= 1;
+				sendBack({ type: "TICK" });
+				if (seconds <= 0) timer.clearInterval(interval);
+			}, 1e3);
+			return () => timer.clearInterval(interval);
+		})
+	},
+	actions: {
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		setErrorFromResponse: assign({ error: () => "Government validation failed" }),
+		setUnknownError: assign({ error: () => "Unknown validation status" }),
+		clearError: assign({ error: () => void 0 }),
+		setOtpCode: assign(({ event }) => ({
+			otpCode: event.code,
+			otpError: void 0
+		})),
+		setOtpError: assign(({ context }) => ({
+			otpError: "Invalid OTP code",
+			attemptsRemaining: context.attemptsRemaining - 1
+		})),
+		clearOtpError: assign({
+			otpError: () => void 0,
+			otpCode: () => ""
+		}),
+		startResendTimer: assign({
+			resendTimer: () => RESEND_TIMER_SECONDS,
+			resendTimerActive: () => true
+		}),
+		tickResendTimer: assign(({ context }) => {
+			const newTimer = Math.max(0, context.resendTimer - 1);
+			return {
+				resendTimer: newTimer,
+				resendTimerActive: newTimer > 0
+			};
+		}),
+		incrementPollCount: assign(({ context }) => ({ pollCount: context.pollCount + 1 })),
+		resetPollCount: assign({ pollCount: () => 0 }),
+		resetContext: assign(({ context }) => ({
+			config: context.config,
+			error: void 0,
+			otpCode: "",
+			otpError: void 0,
+			attemptsRemaining: context.config.maxOtpAttempts ?? 3,
+			resendTimer: 0,
+			resendTimerActive: false,
+			pollCount: 0
+		}))
+	},
+	guards: {
+		isProcessing: (_, params) => params.response.statusCode === -1,
+		isSuccess: (_, params) => params.response.statusCode === 0 && params.response.validationStatus?.status !== "UNKNOWN",
+		isError: (_, params) => params.response.statusCode > 0,
+		isOtpRequested: (_, params) => params.response.otpResponse?.authBridge?.otpCodeRequested === true,
+		isUnknown: (_, params) => params.response.validationStatus?.status === "UNKNOWN",
+		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
+		canResend: ({ context }) => !context.resendTimerActive,
+		hasReachedMaxPolls: ({ context }) => context.pollCount >= MAX_POLL_COUNT
+	}
+}).createMachine({
+	id: "governmentValidation",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		error: void 0,
+		otpCode: "",
+		otpError: void 0,
+		attemptsRemaining: input.config.maxOtpAttempts ?? 3,
+		resendTimer: 0,
+		resendTimerActive: false,
+		pollCount: 0
+	}),
+	states: {
+		idle: { on: { LOAD: { target: "loading" } } },
+		loading: { invoke: {
+			id: "processValidation",
+			src: "processValidation",
+			onDone: [
+				{
+					target: "awaitingOtp",
+					guard: {
+						type: "isOtpRequested",
+						params: ({ event }) => ({ response: event.output })
+					}
+				},
+				{
+					target: "displaySuccess",
+					guard: {
+						type: "isSuccess",
+						params: ({ event }) => ({ response: event.output })
+					}
+				},
+				{
+					target: "polling",
+					guard: {
+						type: "isProcessing",
+						params: ({ event }) => ({ response: event.output })
+					}
+				},
+				{
+					target: "displayUnknown",
+					guard: {
+						type: "isUnknown",
+						params: ({ event }) => ({ response: event.output })
+					},
+					actions: "setUnknownError"
+				},
+				{
+					target: "displayError",
+					actions: "setErrorFromResponse"
+				}
+			],
+			onError: {
+				target: "displayError",
+				actions: "setError"
+			}
+		} },
+		polling: {
+			invoke: {
+				id: "pollingTimer",
+				src: "pollingTimer"
+			},
+			on: { POLL: [{
+				target: "displayError",
+				guard: "hasReachedMaxPolls",
+				actions: assign({ error: () => "Validation timed out" })
+			}, {
+				target: "pollingRequest",
+				actions: "incrementPollCount"
+			}] }
+		},
+		pollingRequest: { invoke: {
+			id: "pollValidation",
+			src: "processValidation",
+			onDone: [
+				{
+					target: "displaySuccess",
+					guard: {
+						type: "isSuccess",
+						params: ({ event }) => ({ response: event.output })
+					}
+				},
+				{
+					target: "polling",
+					guard: {
+						type: "isProcessing",
+						params: ({ event }) => ({ response: event.output })
+					}
+				},
+				{
+					target: "displayUnknown",
+					guard: {
+						type: "isUnknown",
+						params: ({ event }) => ({ response: event.output })
+					},
+					actions: "setUnknownError"
+				},
+				{
+					target: "displayError",
+					actions: "setErrorFromResponse"
+				}
+			],
+			onError: {
+				target: "displayError",
+				actions: "setError"
+			}
+		} },
+		awaitingOtp: {
+			entry: "startResendTimer",
+			invoke: {
+				id: "resendTimer",
+				src: "resendTimer"
+			},
+			on: {
+				TICK: { actions: "tickResendTimer" },
+				OTP_CHANGED: { actions: "setOtpCode" },
+				SUBMIT_OTP: { target: "verifyingOtp" },
+				RESEND_OTP: {
+					target: "loading",
+					guard: "canResend"
+				}
+			}
+		},
+		verifyingOtp: { invoke: {
+			id: "submitOtp",
+			src: "submitOtp",
+			input: ({ context }) => ({ code: context.otpCode }),
+			onDone: [
+				{
+					target: "displaySuccess",
+					guard: {
+						type: "isSuccess",
+						params: ({ event }) => ({ response: event.output })
+					}
+				},
+				{
+					target: "awaitingOtp",
+					guard: "hasAttemptsRemaining",
+					actions: "setOtpError"
+				},
+				{
+					target: "displayError",
+					actions: assign({ error: () => "Maximum OTP attempts exceeded" })
+				}
+			],
+			onError: [{
+				target: "awaitingOtp",
+				guard: "hasAttemptsRemaining",
+				actions: "setOtpError"
+			}, {
+				target: "displayError",
+				actions: "setError"
+			}]
+		} },
+		displaySuccess: { after: { AUTO_PROCEED: { target: "finished" } } },
+		displayProcessing: { after: { AUTO_PROCEED: { target: "finished" } } },
+		displayError: { after: { AUTO_PROCEED: { target: "finished" } } },
+		displayUnknown: { after: { AUTO_PROCEED: { target: "finished" } } },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+export { governmentValidationMachine as t };

package/dist/http.esm.js

@@ -1,3 +1,3 @@
-import { n as getApi, t as api } from "./api-DzpnV6O7.esm.js";
+import { n as getApi, t as api } from "./api-aa9Mx20l.esm.js";
 
 export { api, getApi };

package/dist/id.d.ts

@@ -1,11 +1,11 @@
-import "./warmup-CIj_wEV_.js";
-import "./Manager-BN2g_I8W.js";
-import "./Actor-Ba71-_30.js";
-import "./StateMachine-BoJsfMvg.js";
-import { t as CameraStream } from "./camera-1eeGnAaL.js";
-import "./types-2OPf1pyv.js";
-import "./types-CVJVQ7fp.js";
-import "./deepsightService-ByD6uIs7.js";
-import { n as PermissionStatus, t as PermissionResult } from "./types-D_QfFKxT.js";
-import { A as IdCaptureDependencies, B as RecordingSession, C as CaptureIdResponse, D as ID_ERROR_CODES, E as DetectionStatus, F as IdCaptureThresholds, H as DetectionOrientation, I as IdDocumentType, L as IdError, M as IdCaptureGeometry, N as IdCaptureInput, O as IdCaptureConfig, P as IdCaptureMode, R as IdErrorCode, S as idCaptureMachine, T as DetectionArea, U as IdCaptureSettings, V as UploadIdResponse, _ as validateUploadResponse, a as IdCaptureInitResult, b as createIdCaptureActor, c as UploadIdImageParams, d as preloadIdRecordingProvider, f as processId, g as uploadIdImage, h as stopStream, j as IdCaptureEvent, k as IdCaptureContext, l as ValidationError, m as stopRecording, n as IdCaptureState, o as InitializeIdCaptureParams, p as startRecordingSession, r as createIdCaptureManager, s as StartRecordingParams, t as IdCaptureManager, u as initializeIdCapture, v as CreateIdCaptureActorOptions, w as CapturedImage, x as IdCaptureMachine, y as IdCaptureActor, z as IdFlowStep } from "./idCaptureManager-CV08v1e3.js";
+import "./warmup-Ckb1hN85.js";
+import "./Manager-DcPMRgTm.js";
+import "./Actor-DbWH1K6E.js";
+import "./StateMachine-BBuIgsHT.js";
+import { t as CameraStream } from "./camera-DATT31my.js";
+import "./types-CYJ0Ish6.js";
+import "./types-DU8HmI5U.js";
+import "./deepsightService-S-tU77m-.js";
+import { n as PermissionStatus, t as PermissionResult } from "./types-CIjb0FKu.js";
+import { A as IdCaptureDependencies, B as RecordingSession, C as CaptureIdResponse, D as ID_ERROR_CODES, E as DetectionStatus, F as IdCaptureThresholds, H as DetectionOrientation, I as IdDocumentType, L as IdError, M as IdCaptureGeometry, N as IdCaptureInput, O as IdCaptureConfig, P as IdCaptureMode, R as IdErrorCode, S as idCaptureMachine, T as DetectionArea, U as IdCaptureSettings, V as UploadIdResponse, _ as validateUploadResponse, a as IdCaptureInitResult, b as createIdCaptureActor, c as UploadIdImageParams, d as preloadIdRecordingProvider, f as processId, g as uploadIdImage, h as stopStream, j as IdCaptureEvent, k as IdCaptureContext, l as ValidationError, m as stopRecording, n as IdCaptureState, o as InitializeIdCaptureParams, p as startRecordingSession, r as createIdCaptureManager, s as StartRecordingParams, t as IdCaptureManager, u as initializeIdCapture, v as CreateIdCaptureActorOptions, w as CapturedImage, x as IdCaptureMachine, y as IdCaptureActor, z as IdFlowStep } from "./idCaptureManager-CbZvdr9y.js";
 export { CameraStream, CaptureIdResponse, CapturedImage, type CreateIdCaptureActorOptions, DetectionArea, DetectionOrientation, DetectionStatus, ID_ERROR_CODES, type IdCaptureActor, IdCaptureConfig, type IdCaptureContext, IdCaptureDependencies, type IdCaptureEvent, IdCaptureGeometry, IdCaptureInitResult, type IdCaptureInput, type IdCaptureMachine, type IdCaptureManager, IdCaptureMode, IdCaptureSettings, type IdCaptureState, IdCaptureThresholds, IdDocumentType, IdError, IdErrorCode, IdFlowStep, InitializeIdCaptureParams, PermissionResult, PermissionStatus, RecordingSession, StartRecordingParams, UploadIdImageParams, UploadIdResponse, ValidationError, createIdCaptureActor, createIdCaptureManager, idCaptureMachine, initializeIdCapture, preloadIdRecordingProvider, processId, startRecordingSession, stopRecording, stopStream, uploadIdImage, validateUploadResponse };

package/dist/id.esm.js

@@ -1,22 +1,24 @@
-import "./BaseWasmProvider-D-s_6M5H.esm.js";
-import "./api-DzpnV6O7.esm.js";
-import "./events-DlHrOIRc.esm.js";
-import "./session-CUh77zj3.esm.js";
-import "./BrowserEnvironmentProvider-DaHeLJQw.esm.js";
-import "./browserSimulation-B4ubb2OL.esm.js";
-import "./xstate.esm-Bv55-lJ4.esm.js";
-import "./recordingService-483wQ6kR.esm.js";
-import "./deepsightService-BjgXl5hs.esm.js";
-import "./camera-DmkFpf5N.esm.js";
-import "./getBrowser-Dtyt9J_h.esm.js";
-import "./stats-DHDoqSBV.esm.js";
-import "./MotionSensorProvider-CodM3e0E.esm.js";
-import "./permissionServices-Cskq32Yd.esm.js";
-import "./platform-Dv7a2fv-.esm.js";
-import "./ITimerCapability-oixwa6nj.esm.js";
-import "./backCameraStream-tabTmwDS.esm.js";
-import "./getDeviceClass-DEzz4cmY.esm.js";
-import "./BrowserTimerProvider-BhD2MlHg.esm.js";
-import { a as initializeIdCapture, c as startRecordingSession, d as uploadIdImage, f as validateUploadResponse, i as idCaptureMachine, l as stopRecording, o as preloadIdRecordingProvider, p as ID_ERROR_CODES, r as createIdCaptureActor, s as processId, t as createIdCaptureManager, u as stopStream } from "./idCaptureManager-dyZzKv8L.esm.js";
+import "./BaseWasmProvider-DoYDYH1z.esm.js";
+import "./api-aa9Mx20l.esm.js";
+import "./events-W91zLpx4.esm.js";
+import "./session-B_rKSRql.esm.js";
+import "./BrowserEnvironmentProvider-BtKLxTx4.esm.js";
+import "./browserSimulation-DFqGKQAD.esm.js";
+import "./xstate.esm-B7FPE6br.esm.js";
+import "./BrowserStorageProvider-CXaS5Ooj.esm.js";
+import "./recordingService-CCfxUY7-.esm.js";
+import "./deepsightService-rPGLH8Xp.esm.js";
+import "./camera-DpPQS_-5.esm.js";
+import "./getBrowser-DCcD7H-M.esm.js";
+import "./stats-gFD2351t.esm.js";
+import "./MotionSensorProvider-D90R4qwV.esm.js";
+import "./permissionServices-Cisv73eQ.esm.js";
+import "./platform-DctkySJU.esm.js";
+import "./ITimerCapability-BZO_FsCo.esm.js";
+import "./backCameraStream-D9g2wyil.esm.js";
+import "./getDeviceClass-DBF-ExLR.esm.js";
+import "./BrowserTimerProvider-v7bpbrAk.esm.js";
+import { a as startRecordingSession, c as uploadIdImage, i as processId, l as validateUploadResponse, n as initializeIdCapture, o as stopRecording, r as preloadIdRecordingProvider, s as stopStream, t as idCaptureMachine, u as ID_ERROR_CODES } from "./idCaptureStateMachine-gf-Q9piu.esm.js";
+import { r as createIdCaptureActor, t as createIdCaptureManager } from "./idCaptureManager-CJfatzuY.esm.js";
 
 export { ID_ERROR_CODES, createIdCaptureActor, createIdCaptureManager, idCaptureMachine, initializeIdCapture, preloadIdRecordingProvider, processId, startRecordingSession, stopRecording, stopStream, uploadIdImage, validateUploadResponse };

package/dist/idCaptureManager-CJfatzuY.esm.js

@@ -0,0 +1,335 @@
+import { n as eventModuleNames, o as createManagerInstrumentation, r as eventScreenNames } from "./events-W91zLpx4.esm.js";
+import { a as createActor, o as createManager } from "./xstate.esm-B7FPE6br.esm.js";
+import { t as BrowserStorageProvider } from "./BrowserStorageProvider-CXaS5Ooj.esm.js";
+import { t as idCaptureMachine } from "./idCaptureStateMachine-gf-Q9piu.esm.js";
+
+//#region src/modules/id/idCaptureActor.ts
+function createIdCaptureActor(options) {
+	const dependencies = options.dependencies ?? { storage: new BrowserStorageProvider() };
+	return createActor(idCaptureMachine, { input: {
+		config: options.config,
+		dependencies
+	} }).start();
+}
+
+//#endregion
+//#region src/modules/id/idCaptureManager.ts
+function getPermissionStatus(snapshot) {
+	if (!snapshot.matches("permissions")) return;
+	if (snapshot.matches({ permissions: "idle" })) return "idle";
+	if (snapshot.matches({ permissions: "waitingForUser" })) return "idle";
+	if (snapshot.matches({ permissions: "learnMore" })) return "learnMore";
+	if (snapshot.matches({ permissions: "requesting" })) return "requesting";
+	if (snapshot.matches({ permissions: "denied" })) return "denied";
+}
+function getCaptureStatus(snapshot) {
+	const matches = {
+		initializing: snapshot.matches({ capture: "initializing" }),
+		detecting: snapshot.matches({ capture: "detecting" }),
+		manualCaptureWaiting: snapshot.matches({ capture: "manualCaptureWaiting" }),
+		capturing: snapshot.matches({ capture: "capturing" }),
+		capturingManual: snapshot.matches({ capture: "capturingManual" }),
+		uploading: snapshot.matches({ capture: "uploading" }),
+		uploadError: snapshot.matches({ capture: "uploadError" }),
+		success: snapshot.matches({ capture: "success" })
+	};
+	if (matches.initializing) return "initializing";
+	if (matches.detecting || matches.manualCaptureWaiting) return "detecting";
+	if (matches.capturing || matches.capturingManual) return "capturing";
+	if (matches.uploading) return "uploading";
+	if (matches.uploadError) return "uploadError";
+	if (matches.success) return "success";
+}
+function getErrorMessage(errorCode) {
+	if (!errorCode) return void 0;
+	return {
+		UPLOAD_ERROR: "Upload failed",
+		CLASSIFICATION_FAILED: "ID classification failed",
+		LOW_SHARPNESS: "Image is not sharp enough",
+		GLARE_DETECTED: "Glare detected on ID",
+		WRONG_DOCUMENT_SIDE: "Wrong side of document",
+		ID_TYPE_UNACCEPTABLE: "ID type is not acceptable",
+		READABILITY_ISSUE: "ID readability issue",
+		RETRY_EXHAUSTED_CONTINUE_TO_BACK: "Retry exhausted",
+		RETRY_EXHAUSTED_SKIP_BACK: "Retry exhausted",
+		NO_MORE_TRIES: "No more tries remaining",
+		UNEXPECTED_ERROR: "An unexpected error occurred",
+		NO_TOKEN: "No token available",
+		PERMISSION_DENIED: "Permission denied",
+		USER_CANCELLED: "User cancelled",
+		SERVER_ERROR: "Server error"
+	}[errorCode];
+}
+function getErrorDescription(errorCode, uploadResponse) {
+	if (!errorCode) return void 0;
+	return {
+		UPLOAD_ERROR: "Please try again",
+		CLASSIFICATION_FAILED: "Please ensure your ID is clearly visible",
+		LOW_SHARPNESS: "Please ensure the image is clear and well-focused",
+		GLARE_DETECTED: "Please avoid bright reflections on your ID",
+		WRONG_DOCUMENT_SIDE: uploadResponse?.side === "back" ? "Please show the back side of your ID" : "Please show the front side of your ID",
+		ID_TYPE_UNACCEPTABLE: "Please use a valid ID type",
+		READABILITY_ISSUE: "Please ensure all text is clearly visible",
+		RETRY_EXHAUSTED_CONTINUE_TO_BACK: "Continuing to back side capture",
+		RETRY_EXHAUSTED_SKIP_BACK: "Skipping back side capture",
+		NO_MORE_TRIES: "Maximum attempts reached",
+		UNEXPECTED_ERROR: "Please try again later",
+		NO_TOKEN: "Session expired",
+		PERMISSION_DENIED: "Camera permission is required",
+		USER_CANCELLED: "Capture was cancelled",
+		SERVER_ERROR: "Please try again later"
+	}[errorCode];
+}
+function mapState(snapshot) {
+	const { context } = snapshot;
+	if (snapshot.matches("idle")) return { status: "idle" };
+	if (snapshot.matches("chooser")) return {
+		status: "chooser",
+		availableDocumentTypes: context.availableDocumentTypes
+	};
+	if (snapshot.matches("loading")) return { status: "loading" };
+	if (snapshot.matches("tutorial")) return {
+		status: "tutorial",
+		selectedDocumentType: context.selectedDocumentType,
+		currentMode: context.currentMode
+	};
+	if (snapshot.matches("closed")) return { status: "closed" };
+	if (snapshot.matches("permissions")) {
+		const permissionStatus = getPermissionStatus(snapshot);
+		if (permissionStatus === void 0) return {
+			status: "permissions",
+			permissionStatus: "idle"
+		};
+		return {
+			status: "permissions",
+			permissionStatus
+		};
+	}
+	if (snapshot.matches("capture")) {
+		const captureStatus = getCaptureStatus(snapshot);
+		const needsBackCapture = (context.currentMode === "front" || context.currentMode === "passport") && !context.config.onlyFront && !context.config.onlyBack && !context.uploadResponse?.skipBackIdCapture && !(context.config.usSmartCapture && context.currentMode === "front");
+		const needsFrontCapture = context.config.usSmartCapture === true && context.currentMode === "back" && context.uploadResponse?.forceFrontIdCapture === true;
+		return {
+			status: "capture",
+			captureStatus: captureStatus ?? "initializing",
+			stream: context.stream,
+			detectionStatus: context.detectionStatus,
+			debugFrame: void 0,
+			attemptsRemaining: context.attemptsRemaining,
+			uploadError: context.uploadError,
+			currentMode: context.currentMode,
+			counterValue: context.counterValue,
+			orientation: context.orientation,
+			idType: context.idType,
+			previewImageUrl: context.previewImageUrl,
+			uploadProgress: context.uploadProgress ?? 0,
+			uploadErrorMessage: context.uploadError ? getErrorMessage(context.uploadError) : void 0,
+			uploadErrorDescription: context.uploadError ? getErrorDescription(context.uploadError, context.uploadResponse) : void 0,
+			needsBackCapture,
+			needsFrontCapture,
+			showCaptureButtonInAuto: context.config.showCaptureButtonInAuto ?? false,
+			canRetry: context.attemptsRemaining > 0
+		};
+	}
+	if (snapshot.matches("mandatoryConsent")) return {
+		status: "mandatoryConsent",
+		regulationType: context.uploadResponse?.regulationType ?? "Other"
+	};
+	if (snapshot.matches("frontFinished")) return { status: "frontFinished" };
+	if (snapshot.matches("backFinished")) return { status: "backFinished" };
+	if (snapshot.matches("processing")) return { status: "processing" };
+	if (snapshot.matches("expired")) return { status: "expired" };
+	if (snapshot.matches("finished")) return { status: "finished" };
+	if (snapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "Unknown error"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked, trackCaptureAttemptFinished }) {
+	const snapshot = actor.getSnapshot();
+	if (snapshot.context.dependencies) snapshot.context.dependencies.trackCaptureAttemptFinished = trackCaptureAttemptFinished;
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		selectDocument(documentType) {
+			trackElementClicked?.(`selectDocument.${documentType}`);
+			actor.send({
+				type: "SELECT_DOCUMENT",
+				documentType
+			});
+		},
+		nextStep() {
+			trackElementClicked?.("nextStep");
+			actor.send({ type: "NEXT_STEP" });
+		},
+		requestPermission() {
+			trackElementClicked?.("requestPermission");
+			actor.send({ type: "REQUEST_PERMISSION" });
+		},
+		goToLearnMore() {
+			trackElementClicked?.("goToLearnMore");
+			actor.send({ type: "GO_TO_LEARN_MORE" });
+		},
+		back() {
+			trackElementClicked?.("back");
+			actor.send({ type: "BACK" });
+		},
+		close() {
+			trackElementClicked?.("close");
+			actor.send({ type: "QUIT" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		},
+		retryCapture() {
+			trackElementClicked?.("retryCapture");
+			actor.send({ type: "RETRY_CAPTURE" });
+		},
+		continueFromError() {
+			trackElementClicked?.("continueFromError");
+			actor.send({ type: "CONTINUE_FROM_ERROR" });
+		},
+		capture() {
+			trackElementClicked?.("capture");
+			actor.send({ type: "MANUAL_CAPTURE" });
+		},
+		switchToManualCapture() {
+			trackElementClicked?.("switchToManualCapture");
+			actor.send({ type: "SWITCH_TO_MANUAL_CAPTURE" });
+		},
+		continueToBack() {
+			trackElementClicked?.("continueToBack");
+			actor.send({ type: "CONTINUE_TO_BACK" });
+		},
+		continueToFront() {
+			trackElementClicked?.("continueToFront");
+			actor.send({ type: "CONTINUE_TO_FRONT" });
+		},
+		skipBack() {
+			trackElementClicked?.("skipBack");
+			actor.send({ type: "SKIP_BACK" });
+		},
+		acceptMandatoryConsent() {
+			trackElementClicked?.("acceptMandatoryConsent");
+			actor.send({ type: "CONSENT_ACCEPT" });
+		},
+		cancelMandatoryConsent() {
+			trackElementClicked?.("cancelMandatoryConsent");
+			actor.send({ type: "CONSENT_CANCEL" });
+		},
+		updateDetectionArea(detectionArea) {
+			actor.send({
+				type: "UPDATE_DETECTION_AREA",
+				detectionArea
+			});
+		}
+	};
+}
+const FRONT_SCREENS = {
+	tutorial: eventScreenNames.frontTutorial,
+	cameraCapture: eventScreenNames.frontCameraCapture,
+	uploadProgress: eventScreenNames.frontUploadProgress,
+	attemptFailed: eventScreenNames.frontAttemptFailed,
+	uploadSuccess: eventScreenNames.frontUploadSuccess,
+	help: eventScreenNames.frontHelp
+};
+const BACK_SCREENS = {
+	tutorial: eventScreenNames.backTutorial,
+	cameraCapture: eventScreenNames.backCameraCapture,
+	uploadProgress: eventScreenNames.backUploadProgress,
+	attemptFailed: eventScreenNames.backAttemptFailed,
+	uploadSuccess: eventScreenNames.backUploadSuccess,
+	help: eventScreenNames.backHelp
+};
+const PASSPORT_SCREENS = { tutorial: eventScreenNames.passportTutorial };
+function getSideScreens(mode) {
+	if (mode === "back") return BACK_SCREENS;
+	if (mode === "passport") return {
+		...FRONT_SCREENS,
+		...PASSPORT_SCREENS
+	};
+	return FRONT_SCREENS;
+}
+function getCaptureSubstateScreen(value, screens) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const captureValue = value.capture;
+	if (captureValue === void 0) return void 0;
+	if (typeof captureValue === "string") switch (captureValue) {
+		case "detecting":
+		case "manualCaptureWaiting":
+		case "capturing":
+		case "capturingManual": return screens.cameraCapture;
+		case "uploading":
+		case "validatingUpload": return screens.uploadProgress;
+		case "uploadError": return screens.attemptFailed;
+		case "success": return screens.uploadSuccess;
+	}
+	if (typeof captureValue === "object" && captureValue !== null) {
+		const substates = Object.keys(captureValue);
+		if (substates.includes("detecting") || substates.includes("capturing")) return screens.cameraCapture;
+		if (substates.includes("uploading")) return screens.uploadProgress;
+		if (substates.includes("uploadError")) return screens.attemptFailed;
+		if (substates.includes("success")) return screens.uploadSuccess;
+	}
+	return screens.cameraCapture;
+}
+function getIdCaptureScreenName(snapshot) {
+	const { value, context } = snapshot;
+	if (value === void 0 || value === null) return void 0;
+	const topLevel = typeof value === "string" ? value : typeof value === "object" ? Object.keys(value)[0] : void 0;
+	if (topLevel === void 0) return void 0;
+	const side = context.currentMode;
+	const screens = getSideScreens(side);
+	switch (topLevel) {
+		case "idle": return "IDLE";
+		case "chooser": return "DOCUMENT_CHOOSER";
+		case "loading": return "LOADING";
+		case "tutorial": return screens.tutorial;
+		case "permissions": return "PERMISSIONS";
+		case "capture": return getCaptureSubstateScreen(value, screens);
+		case "mandatoryConsent": return "MANDATORY_CONSENT";
+		case "frontFinished": return screens.uploadSuccess;
+		case "backFinished": return screens.uploadSuccess;
+		case "processing": return "PROCESSING";
+		case "expired": return "EXPIRED";
+		case "finished": return "FINISHED";
+		case "closed": return "CLOSED";
+		case "error": return "ERROR";
+		default: return topLevel;
+	}
+}
+function mapIdCaptureScreenName(snapshot) {
+	return getIdCaptureScreenName(snapshot);
+}
+function getIdCaptureErrorPayload(snapshot) {
+	const errorCode = snapshot.context.uploadError;
+	if (errorCode === void 0) return;
+	return { errorCode };
+}
+function createIdCaptureManager(options) {
+	return createManager({
+		actor: createIdCaptureActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.id, {
+			getScreenName: mapIdCaptureScreenName,
+			getErrorPayload: getIdCaptureErrorPayload
+		})
+	});
+}
+function createIdCaptureManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.id, {
+			getScreenName: mapIdCaptureScreenName,
+			getErrorPayload: getIdCaptureErrorPayload
+		})
+	});
+}
+
+//#endregion
+export { createIdCaptureManagerFromActor as n, createIdCaptureActor as r, createIdCaptureManager as t };