@incodetech/core 0.0.0-dev-20260512-e44bacb → 0.0.0-dev-20260512-cffbe28

package/dist/{idCaptureStateMachine-C94NHeR2.esm.js → idCaptureStateMachine-BuX1-VlB.esm.js}

@@ -1,11 +1,11 @@
-import { a as IdCaptureModelType, i as WasmPipelineType, r as mlWasmJSApi_default, t as BaseWasmProvider } from "./BaseWasmProvider-C2cw9STp.esm.js";
+import { a as WasmPipelineType, o as IdCaptureModelType, r as mlWasmJSApi_default, t as BaseWasmProvider } from "./BaseWasmProvider-IiHnsP8E.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BZGH3sYJ.esm.js";
 import { r as getToken, t as api } from "./api-eqRXuVG-.esm.js";
 import { S as revokeObjectURL } from "./events-Bt1azl2B.esm.js";
 import { t as endpoints } from "./endpoints-B3V1U9Dg.esm.js";
-import { t as getDisableIpify } from "./session-DWFMKdX6.esm.js";
+import { t as getDisableIpify } from "./session-DAspZUCj.esm.js";
 import { a as fromPromise, i as fromCallback, n as sendTo, r as assign, t as setup } from "./xstate.esm-7GmmAwg6.esm.js";
-import { _ as StreamCanvasCapture, d as createRecordingSession, f as startRecording, g as flagIdManualReview, m as StreamCanvasProcessingSession, n as preloadOpenViduProvider, p as stopRecording$1 } from "./recordingService-BsYjkILQ.esm.js";
+import { _ as StreamCanvasCapture, d as createRecordingSession, f as startRecording, g as flagIdManualReview, m as StreamCanvasProcessingSession, n as preloadOpenViduProvider, p as stopRecording$1 } from "./recordingService-DMaVUhWY.esm.js";
 import { n as IncodeCanvas } from "./deepsightService-IxmrmdKl.esm.js";
 import { r as getWindowDimensions } from "./getBrowser-Y88tNVud.esm.js";
 import { t as addDeviceStats } from "./stats-Bqq9IKre.esm.js";
@@ -591,7 +591,7 @@ const uploadManualFileActor = fromPromise(async ({ input, signal }) => {
 		signal
 	});
 });
-const getUploadResponseFromEvent = (event) => {
+const getUploadResponseFromEvent$1 = (event) => {
 	if ("output" in event) return event.output;
 };
 const _manualUploadMachine = setup({
@@ -682,7 +682,7 @@ const _manualUploadMachine = setup({
 		},
 		canContinueFromPassportTab: ({ context }) => context.activeTab === "passport" && context.passportUploaded,
 		manualUploadResponseHasError: ({ context, event }) => {
-			const response = getUploadResponseFromEvent(event);
+			const response = getUploadResponseFromEvent$1(event);
 			if (!response) return false;
 			return mapFailReasonToErrorKey(response, context.activeTab) !== null;
 		}
@@ -835,6 +835,300 @@ const _manualUploadMachine = setup({
 });
 const manualUploadMachine = _manualUploadMachine;
 
+//#endregion
+//#region src/modules/id/digitalUpload/digitalUploadErrors.ts
+const TERMINAL_FAIL_REASONS = new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
+function isKnownFailReason(reason) {
+	return reason === "DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED" || reason === "ID_TYPE_UNACCEPTABLE" || reason === "FILE_CHANGED_ERROR" || reason === "NETWORK_ERROR" || reason === "GENERIC";
+}
+function mapDigitalIdFailReason(response) {
+	const failReason = response?.failReason;
+	if (typeof failReason !== "string" || failReason.length === 0) return null;
+	if (isKnownFailReason(failReason)) return failReason;
+	return "GENERIC";
+}
+function isTerminalDigitalIdFailReason(response) {
+	return typeof response?.failReason === "string" && TERMINAL_FAIL_REASONS.has(response.failReason);
+}
+function classifyNetworkError(err) {
+	const message = err instanceof Error ? err.message : String(err);
+	if (message.includes("ERR_UPLOAD_FILE_CHANGED") || message.includes("file changed") || message.includes("FILE_CHANGED")) return "FILE_CHANGED_ERROR";
+	return "NETWORK_ERROR";
+}
+
+//#endregion
+//#region src/modules/id/digitalUpload/digitalUploadServices.ts
+const DIGITAL_ID_UPLOAD_PATH = "/omni/add/front-id";
+async function uploadDigitalIdFile(params) {
+	const { file, signal, onProgress } = params;
+	const response = await api.post(DIGITAL_ID_UPLOAD_PATH, file, {
+		query: { idType: "DigitalId" },
+		headers: { "Content-Type": file.type || "application/pdf" },
+		onUploadProgress: onProgress,
+		signal
+	});
+	if (!response.ok) throw new Error(`POST ${DIGITAL_ID_UPLOAD_PATH} failed: ${response.status}`);
+	return {
+		...response.data,
+		uploadDurationMs: 0
+	};
+}
+
+//#endregion
+//#region src/modules/id/digitalUpload/types.ts
+const DIGITAL_UPLOAD_MAX_RETRIES = 3;
+const DIGITAL_UPLOAD_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
+const DIGITAL_UPLOAD_HOLDING_TIMEOUT_MS = 8e3;
+const DIGITAL_UPLOAD_ALLOWED_MIME_TYPES = ["application/pdf"];
+
+//#endregion
+//#region src/modules/id/digitalUpload/digitalUploadStateMachine.ts
+const uploadDigitalIdActor = fromPromise(async ({ input, signal }) => {
+	return uploadDigitalIdFile({
+		file: input.file,
+		signal: input.signal ?? signal,
+		onProgress: input.onProgress
+	});
+});
+const getUploadResponseFromEvent = (event) => {
+	if (!("output" in event)) return;
+	return event.output;
+};
+const _digitalUploadMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {},
+		output: {}
+	},
+	actors: { uploadDigitalId: uploadDigitalIdActor },
+	actions: {
+		requestPickerIfPending: assign(({ context }) => {
+			if (!context.pendingPickerAutoOpen) return {};
+			return {
+				pickerRequestId: context.pickerRequestId + 1,
+				pendingPickerAutoOpen: false
+			};
+		}),
+		setPendingPickerAutoOpen: assign(() => ({ pendingPickerAutoOpen: true })),
+		storeSelectedFile: assign(({ event }) => {
+			if (event.type !== "FILE_PICKED") return {};
+			return {
+				file: event.file,
+				failReason: null
+			};
+		}),
+		clearSelectedFile: assign(() => ({
+			file: null,
+			uploadProgress: 0,
+			failReason: null,
+			response: void 0,
+			uploadDurationMs: void 0
+		})),
+		setInvalidFileTypeError: assign(() => ({ failReason: "INVALID_FILE_TYPE" })),
+		setUploadProgressCapped: assign(({ event }) => {
+			if (event.type !== "UPLOAD_PROGRESS") return {};
+			return { uploadProgress: Math.min(90, Math.max(0, event.progress)) };
+		}),
+		setUploadProgressCompleted: assign(() => ({ uploadProgress: 100 })),
+		storeUploadResponse: assign(({ event }) => {
+			if (!("output" in event)) return {};
+			const output = event;
+			return {
+				response: output.output,
+				uploadDurationMs: output.output.uploadDurationMs
+			};
+		}),
+		setFailReasonFromResponse: assign(({ event }) => {
+			if (!("output" in event)) return {};
+			const response = event.output;
+			return { failReason: mapDigitalIdFailReason(response) ?? "GENERIC" };
+		}),
+		setFailReasonFromNetworkError: assign(({ event }) => {
+			if (!("error" in event)) return {};
+			return { failReason: classifyNetworkError(event.error) };
+		}),
+		decrementAttemptOnRetry: assign(({ context }) => {
+			if (!(context.failReason !== "INVALID_FILE_TYPE" && context.failReason !== null && context.failReason !== "DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED" && context.failReason !== "ID_TYPE_UNACCEPTABLE")) return {};
+			return { attemptsRemaining: Math.max(0, context.attemptsRemaining - 1) };
+		})
+	},
+	guards: {
+		isSelectedFileTooLarge: ({ event }) => event.type === "FILE_PICKED" && event.file.size > DIGITAL_UPLOAD_MAX_FILE_SIZE_BYTES,
+		isSelectedFileMimeInvalid: ({ event }) => event.type === "FILE_PICKED" && !DIGITAL_UPLOAD_ALLOWED_MIME_TYPES.includes(event.file.type),
+		hasSelectedFile: ({ context }) => context.file !== null,
+		responseHasFailReason: ({ event }) => mapDigitalIdFailReason(getUploadResponseFromEvent(event)) !== null,
+		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
+		isTerminalFailReason: ({ event }) => {
+			return isTerminalDigitalIdFailReason(getUploadResponseFromEvent(event));
+		},
+		isCurrentFailReasonTerminal: ({ context }) => {
+			const terminalReasons = new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
+			return context.failReason !== null && terminalReasons.has(context.failReason);
+		}
+	}
+}).createMachine({
+	id: "digitalUpload",
+	initial: "decideStart",
+	context: ({ input }) => ({
+		showTutorial: input.showTutorial,
+		file: null,
+		uploadProgress: 0,
+		attemptsRemaining: DIGITAL_UPLOAD_MAX_RETRIES,
+		failReason: null,
+		response: void 0,
+		uploadDurationMs: void 0,
+		pickerRequestId: 0,
+		pendingPickerAutoOpen: !input.showTutorial,
+		resultType: null
+	}),
+	output: ({ context }) => ({ result: context.resultType ?? "exhausted" }),
+	states: {
+		decideStart: { always: [{
+			guard: ({ context }) => context.showTutorial,
+			target: "tutorial"
+		}, { target: "selecting" }] },
+		tutorial: { on: { NEXT_STEP: {
+			target: "selecting",
+			actions: ["setPendingPickerAutoOpen"]
+		} } },
+		selecting: {
+			entry: ["requestPickerIfPending"],
+			on: { FILE_PICKED: [
+				{
+					guard: "isSelectedFileTooLarge",
+					target: "fileTooLarge",
+					actions: ["clearSelectedFile"]
+				},
+				{
+					guard: "isSelectedFileMimeInvalid",
+					target: "error",
+					actions: ["setInvalidFileTypeError"]
+				},
+				{
+					target: "reviewing",
+					actions: ["storeSelectedFile"]
+				}
+			] }
+		},
+		fileTooLarge: { on: { CHOOSE_ANOTHER: {
+			target: "selecting",
+			actions: ["clearSelectedFile", "setPendingPickerAutoOpen"]
+		} } },
+		reviewing: { on: {
+			CONFIRM: {
+				target: "uploading",
+				guard: "hasSelectedFile"
+			},
+			REPLACE: {
+				target: "selecting",
+				actions: ["setPendingPickerAutoOpen"]
+			}
+		} },
+		uploading: {
+			invoke: {
+				id: "uploadDigitalId",
+				src: "uploadDigitalId",
+				input: ({ context, self }) => ({
+					file: context.file,
+					onProgress: (progress) => {
+						self.send({
+							type: "UPLOAD_PROGRESS",
+							progress
+						});
+					}
+				}),
+				onDone: [
+					{
+						guard: "isTerminalFailReason",
+						target: "retriesExhausted",
+						actions: ["storeUploadResponse", "setFailReasonFromResponse"]
+					},
+					{
+						guard: "responseHasFailReason",
+						target: "checkRetries",
+						actions: ["storeUploadResponse", "setFailReasonFromResponse"]
+					},
+					{
+						target: "success",
+						actions: ["storeUploadResponse", "setUploadProgressCompleted"]
+					}
+				],
+				onError: {
+					target: "checkRetries",
+					actions: ["setFailReasonFromNetworkError"]
+				}
+			},
+			initial: "analyzing",
+			states: {
+				analyzing: { after: { [DIGITAL_UPLOAD_HOLDING_TIMEOUT_MS]: { target: "holding" } } },
+				holding: {}
+			},
+			on: { UPLOAD_PROGRESS: { actions: ["setUploadProgressCapped"] } }
+		},
+		checkRetries: { always: [
+			{
+				guard: "isCurrentFailReasonTerminal",
+				target: "retriesExhausted"
+			},
+			{
+				guard: "hasAttemptsRemaining",
+				target: "error"
+			},
+			{ target: "retriesExhausted" }
+		] },
+		error: { on: {
+			RETRY: {
+				target: "selecting",
+				actions: [
+					"decrementAttemptOnRetry",
+					"setPendingPickerAutoOpen",
+					"clearSelectedFile"
+				]
+			},
+			SCAN_INSTEAD: { target: "closed" }
+		} },
+		retriesExhausted: {
+			type: "final",
+			entry: assign({ resultType: "exhausted" })
+		},
+		closed: {
+			type: "final",
+			entry: assign({ resultType: "closed" })
+		},
+		success: { on: { NEXT_STEP: { target: "completed" } } },
+		completed: {
+			type: "final",
+			entry: assign({ resultType: "success" })
+		}
+	}
+});
+const digitalUploadMachine = _digitalUploadMachine;
+
+//#endregion
+//#region src/modules/id/digitalUpload/instrumentation.ts
+const TERMINAL_REASONS = new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
+function isHoldingState(value) {
+	if (value === "holding") return true;
+	if (typeof value !== "object" || value === null) return false;
+	const uploadingState = value.uploading;
+	if (uploadingState === "holding") return true;
+	if (typeof uploadingState === "object" && uploadingState !== null) return Object.prototype.hasOwnProperty.call(uploadingState, "holding");
+	return false;
+}
+function mapDigitalIdScreenName(value, failReason) {
+	if (value === "tutorial") return "uploadDigitalid.tutorial.default";
+	if (value === "selecting" || value === "reviewing") return "uploadDigitalid.review.default";
+	if (value === "uploading" || isHoldingState(value)) return "uploadDigitalid.analyzing.default";
+	if (value === "success") return "uploadDigitalid.success.default";
+	if (value === "fileTooLarge") return "uploadDigitalid.error.filetoolarge";
+	if (value === "error") {
+		if (failReason !== null && TERMINAL_REASONS.has(failReason)) return "uploadDigitalid.error.notaccepted";
+		return "uploadDigitalid.error.default";
+	}
+	return "uploadDigitalid.review.default";
+}
+
 //#endregion
 //#region ../infra/src/wasm/idCaptureDefaults.ts
 /**
@@ -1175,7 +1469,7 @@ const checkMotionSensorActor = fromCallback(({ input, sendBack }) => {
 });
 const initializeDeepsightSessionActor = fromPromise(async ({ input }) => {
 	if (!input.dependencies) return;
-	const { loadDeepsightSession } = await import("./deepsightLoader-CFNSfs2N.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-BMeAmiNh.esm.js");
 	return loadDeepsightSession({
 		ds: input.ds,
 		storage: input.dependencies.storage,
@@ -1480,6 +1774,7 @@ const isDeepsightReadyGuard = ({ context }) => context.deepsightService !== void
 const needsDeepsightInitGuard = ({ context }) => context.dependencies !== void 0 && context.deepsightService === void 0 && !context.deepsightInitAttempted;
 const hasOnlyManualUploadAvailableGuard = ({ context }) => context.availableDocumentTypes.length === 1 && context.availableDocumentTypes[0] === "manualIdUpload";
 const isManualIdUploadSelectedGuard = ({ event }) => event.type === "SELECT_DOCUMENT" && event.documentType === "manualIdUpload";
+const isDigitalIdUploadSelectedGuard = ({ event }) => event.type === "SELECT_DOCUMENT" && event.documentType === "digitalIdUpload";
 
 //#endregion
 //#region src/modules/id/idCaptureStateMachine.ts
@@ -1506,7 +1801,8 @@ const _idCaptureMachine = setup({
 		checkMotionSensor: checkMotionSensorActor,
 		initializeDeepsightSession: initializeDeepsightSessionActor,
 		checkVirtualCamera: checkVirtualCameraActor,
-		manualUploadMachine
+		manualUploadMachine,
+		digitalUploadMachine
 	},
 	actions: {
 		stopMediaStream: assign(({ context }) => {
@@ -1680,7 +1976,11 @@ const _idCaptureMachine = setup({
 		needsDeepsightInit: needsDeepsightInitGuard,
 		hasOnlyManualUploadAvailable: hasOnlyManualUploadAvailableGuard,
 		isManualIdUploadSelected: isManualIdUploadSelectedGuard,
-		isManualUploadExhausted: ({ event }) => event.output?.result === "exhausted"
+		isDigitalIdUploadSelected: isDigitalIdUploadSelectedGuard,
+		isManualUploadExhausted: ({ event }) => event.output?.result === "exhausted",
+		isDigitalUploadExhausted: ({ event }) => event.output?.result === "exhausted",
+		isDigitalUploadClosed: ({ event }) => event.output?.result === "closed",
+		isDigitalUploadSuccessful: ({ event }) => event.output?.result === "success"
 	}
 }).createMachine({
 	id: "idCapture",
@@ -1749,6 +2049,11 @@ const _idCaptureMachine = setup({
 			{ target: "loading" }
 		] } },
 		chooser: { on: { SELECT_DOCUMENT: [
+			{
+				target: "digitalIdUpload",
+				guard: "isDigitalIdUploadSelected",
+				actions: ["setSelectedDocument"]
+			},
 			{
 				target: "manualIdUpload",
 				guard: "isManualIdUploadSelected",
@@ -2355,10 +2660,7 @@ const _idCaptureMachine = setup({
 				id: "processId",
 				src: "processId",
 				input: ({ context }) => ({ isSecondId: context.config.isSecondId ?? false }),
-				onDone: [{
-					target: "expired",
-					guard: ({ event }) => event.output.isDocumentExpired
-				}, { target: "finished" }],
+				onDone: { target: "finished" },
 				onError: { target: "finished" }
 			}
 		},
@@ -2437,10 +2739,52 @@ const _idCaptureMachine = setup({
 				MANUAL_UPLOAD_RESET: { actions: sendTo("manualIdUpload", ({ event }) => event) }
 			}
 		},
-		digitalIdUpload: { on: { QUIT: { target: "closed" } } }
+		digitalIdUpload: {
+			invoke: {
+				id: "digitalIdUpload",
+				src: "digitalUploadMachine",
+				input: ({ context }) => ({ showTutorial: context.config.showTutorial }),
+				onSnapshot: { actions: () => {} },
+				onDone: [
+					{
+						guard: "isDigitalUploadExhausted",
+						target: "#idCapture.finished"
+					},
+					{
+						guard: "isDigitalUploadClosed",
+						target: "#idCapture.chooser"
+					},
+					{
+						guard: "isDigitalUploadSuccessful",
+						target: "#idCapture.processing"
+					},
+					{
+						target: "#idCapture.error",
+						actions: assign({ error: () => "Digital upload finished without output" })
+					}
+				],
+				onError: {
+					target: "#idCapture.error",
+					actions: assign({ error: ({ event }) => String(event.error) })
+				}
+			},
+			on: {
+				QUIT: { target: "closed" },
+				DIGITAL_UPLOAD_NEXT_STEP: { actions: sendTo("digitalIdUpload", { type: "NEXT_STEP" }) },
+				DIGITAL_UPLOAD_FILE_PICKED: { actions: sendTo("digitalIdUpload", ({ event }) => ({
+					type: "FILE_PICKED",
+					file: event.file
+				})) },
+				DIGITAL_UPLOAD_CONFIRM: { actions: sendTo("digitalIdUpload", { type: "CONFIRM" }) },
+				DIGITAL_UPLOAD_REPLACE: { actions: sendTo("digitalIdUpload", { type: "REPLACE" }) },
+				DIGITAL_UPLOAD_RETRY: { actions: sendTo("digitalIdUpload", { type: "RETRY" }) },
+				DIGITAL_UPLOAD_SCAN_INSTEAD: { actions: sendTo("digitalIdUpload", { type: "SCAN_INSTEAD" }) },
+				DIGITAL_UPLOAD_CHOOSE_ANOTHER: { actions: sendTo("digitalIdUpload", { type: "CHOOSE_ANOTHER" }) }
+			}
+		}
 	}
 });
 const idCaptureMachine = _idCaptureMachine;
 
 //#endregion
-export { startRecordingSession as a, uploadIdImage as c, ID_ERROR_CODES as d, MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS as f, processId as i, uploadManualIdFile as l, MANUAL_UPLOAD_MAX_RETRIES as m, initializeIdCapture as n, stopRecording as o, MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES as p, preloadIdRecordingProvider as r, stopStream as s, idCaptureMachine as t, validateUploadResponse as u };
+export { preloadIdRecordingProvider as a, stopRecording as c, uploadManualIdFile as d, validateUploadResponse as f, MANUAL_UPLOAD_MAX_RETRIES as g, MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES as h, initializeIdCapture as i, stopStream as l, MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS as m, mapDigitalIdScreenName as n, processId as o, ID_ERROR_CODES as p, DIGITAL_UPLOAD_MAX_RETRIES as r, startRecordingSession as s, idCaptureMachine as t, uploadIdImage as u };

package/dist/identity-reuse.d.ts

@@ -1,6 +1,6 @@
 import { t as Manager } from "./Manager-D9pehGyp.js";
 import { t as ActorRefFrom } from "./Actor-YjWTo26u.js";
-import * as xstate157 from "xstate";
+import * as xstate322 from "xstate";
 
 //#region src/modules/identity-reuse/types.d.ts
 
@@ -32,7 +32,7 @@ type IdentityReuseContext = {
 type IdentityReuseInput = {
   config: IdentityReuseConfig;
 };
-declare const identityReuseMachine: xstate157.StateMachine<IdentityReuseContext, {
+declare const identityReuseMachine: xstate322.StateMachine<IdentityReuseContext, {
   type: "LOAD";
 } | {
   type: "START_SELECTION";
@@ -48,49 +48,49 @@ declare const identityReuseMachine: xstate157.StateMachine<IdentityReuseContext,
 } | {
   type: "RETRY";
 }, {
-  [x: string]: xstate157.ActorRefFromLogic<xstate157.PromiseActorLogic<FetchCandidatesResponse, void, xstate157.EventObject>> | xstate157.ActorRefFromLogic<xstate157.PromiseActorLogic<SubmitResponse, void, xstate157.EventObject>> | undefined;
-}, xstate157.Values<{
+  [x: string]: xstate322.ActorRefFromLogic<xstate322.PromiseActorLogic<FetchCandidatesResponse, void, xstate322.EventObject>> | xstate322.ActorRefFromLogic<xstate322.PromiseActorLogic<SubmitResponse, void, xstate322.EventObject>> | undefined;
+}, xstate322.Values<{
   fetchCandidates: {
     src: "fetchCandidates";
-    logic: xstate157.PromiseActorLogic<FetchCandidatesResponse, void, xstate157.EventObject>;
+    logic: xstate322.PromiseActorLogic<FetchCandidatesResponse, void, xstate322.EventObject>;
     id: string | undefined;
   };
   submitContinue: {
     src: "submitContinue";
-    logic: xstate157.PromiseActorLogic<SubmitResponse, void, xstate157.EventObject>;
+    logic: xstate322.PromiseActorLogic<SubmitResponse, void, xstate322.EventObject>;
     id: string | undefined;
   };
   submitSkip: {
     src: "submitSkip";
-    logic: xstate157.PromiseActorLogic<SubmitResponse, void, xstate157.EventObject>;
+    logic: xstate322.PromiseActorLogic<SubmitResponse, void, xstate322.EventObject>;
     id: string | undefined;
   };
-}>, xstate157.Values<{
+}>, xstate322.Values<{
   setError: {
     type: "setError";
-    params: xstate157.NonReducibleUnknown;
+    params: xstate322.NonReducibleUnknown;
   };
   clearError: {
     type: "clearError";
-    params: xstate157.NonReducibleUnknown;
+    params: xstate322.NonReducibleUnknown;
   };
   setCandidates: {
     type: "setCandidates";
-    params: xstate157.NonReducibleUnknown;
+    params: xstate322.NonReducibleUnknown;
   };
   setSelectedCandidate: {
     type: "setSelectedCandidate";
-    params: xstate157.NonReducibleUnknown;
+    params: xstate322.NonReducibleUnknown;
   };
   autoSelectSingleCandidate: {
     type: "autoSelectSingleCandidate";
-    params: xstate157.NonReducibleUnknown;
+    params: xstate322.NonReducibleUnknown;
   };
   clearSelection: {
     type: "clearSelection";
-    params: xstate157.NonReducibleUnknown;
+    params: xstate322.NonReducibleUnknown;
   };
-}>, xstate157.Values<{
+}>, xstate322.Values<{
   hasMultipleCandidates: {
     type: "hasMultipleCandidates";
     params: unknown;
@@ -105,7 +105,7 @@ declare const identityReuseMachine: xstate157.StateMachine<IdentityReuseContext,
   };
 }>, never, "error" | "idle" | "finished" | "loading" | "submitContinue" | "submitSkip" | "oneCandidateFound" | "noCandidatesFound" | {
   multiCandidatesFound: "noCandidateSelected" | "choosingCandidate" | "candidateSelected";
-}, string, IdentityReuseInput, xstate157.NonReducibleUnknown, xstate157.EventObject, xstate157.MetaObject, {
+}, string, IdentityReuseInput, xstate322.NonReducibleUnknown, xstate322.EventObject, xstate322.MetaObject, {
   readonly id: "identityReuse";
   readonly initial: "idle";
   readonly context: ({
@@ -114,75 +114,75 @@ declare const identityReuseMachine: xstate157.StateMachine<IdentityReuseContext,
     spawn: {
       <TSrc extends "fetchCandidates" | "submitContinue" | "submitSkip">(logic: TSrc, ...[options]: ({
         src: "fetchCandidates";
-        logic: xstate157.PromiseActorLogic<FetchCandidatesResponse, void, xstate157.EventObject>;
+        logic: xstate322.PromiseActorLogic<FetchCandidatesResponse, void, xstate322.EventObject>;
         id: string | undefined;
       } extends infer T ? T extends {
         src: "fetchCandidates";
-        logic: xstate157.PromiseActorLogic<FetchCandidatesResponse, void, xstate157.EventObject>;
+        logic: xstate322.PromiseActorLogic<FetchCandidatesResponse, void, xstate322.EventObject>;
         id: string | undefined;
       } ? T extends {
         src: TSrc;
-      } ? xstate157.ConditionalRequired<[options?: ({
+      } ? xstate322.ConditionalRequired<[options?: ({
         id?: T["id"] | undefined;
         systemId?: string;
-        input?: xstate157.InputFrom<T["logic"]> | undefined;
+        input?: xstate322.InputFrom<T["logic"]> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate157.RequiredActorOptions<T>]: unknown }) | undefined], xstate157.IsNotNever<xstate157.RequiredActorOptions<T>>> : never : never : never) | ({
+      } & { [K in xstate322.RequiredActorOptions<T>]: unknown }) | undefined], xstate322.IsNotNever<xstate322.RequiredActorOptions<T>>> : never : never : never) | ({
         src: "submitContinue";
-        logic: xstate157.PromiseActorLogic<SubmitResponse, void, xstate157.EventObject>;
+        logic: xstate322.PromiseActorLogic<SubmitResponse, void, xstate322.EventObject>;
         id: string | undefined;
       } extends infer T_1 ? T_1 extends {
         src: "submitContinue";
-        logic: xstate157.PromiseActorLogic<SubmitResponse, void, xstate157.EventObject>;
+        logic: xstate322.PromiseActorLogic<SubmitResponse, void, xstate322.EventObject>;
         id: string | undefined;
       } ? T_1 extends {
         src: TSrc;
-      } ? xstate157.ConditionalRequired<[options?: ({
+      } ? xstate322.ConditionalRequired<[options?: ({
         id?: T_1["id"] | undefined;
         systemId?: string;
-        input?: xstate157.InputFrom<T_1["logic"]> | undefined;
+        input?: xstate322.InputFrom<T_1["logic"]> | undefined;
         syncSnapshot?: boolean;
-      } & { [K_1 in xstate157.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate157.IsNotNever<xstate157.RequiredActorOptions<T_1>>> : never : never : never) | ({
+      } & { [K_1 in xstate322.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate322.IsNotNever<xstate322.RequiredActorOptions<T_1>>> : never : never : never) | ({
         src: "submitSkip";
-        logic: xstate157.PromiseActorLogic<SubmitResponse, void, xstate157.EventObject>;
+        logic: xstate322.PromiseActorLogic<SubmitResponse, void, xstate322.EventObject>;
         id: string | undefined;
       } extends infer T_2 ? T_2 extends {
         src: "submitSkip";
-        logic: xstate157.PromiseActorLogic<SubmitResponse, void, xstate157.EventObject>;
+        logic: xstate322.PromiseActorLogic<SubmitResponse, void, xstate322.EventObject>;
         id: string | undefined;
       } ? T_2 extends {
         src: TSrc;
-      } ? xstate157.ConditionalRequired<[options?: ({
+      } ? xstate322.ConditionalRequired<[options?: ({
         id?: T_2["id"] | undefined;
         systemId?: string;
-        input?: xstate157.InputFrom<T_2["logic"]> | undefined;
+        input?: xstate322.InputFrom<T_2["logic"]> | undefined;
         syncSnapshot?: boolean;
-      } & { [K_2 in xstate157.RequiredActorOptions<T_2>]: unknown }) | undefined], xstate157.IsNotNever<xstate157.RequiredActorOptions<T_2>>> : never : never : never)): xstate157.ActorRefFromLogic<xstate157.GetConcreteByKey<xstate157.Values<{
+      } & { [K_2 in xstate322.RequiredActorOptions<T_2>]: unknown }) | undefined], xstate322.IsNotNever<xstate322.RequiredActorOptions<T_2>>> : never : never : never)): xstate322.ActorRefFromLogic<xstate322.GetConcreteByKey<xstate322.Values<{
         fetchCandidates: {
           src: "fetchCandidates";
-          logic: xstate157.PromiseActorLogic<FetchCandidatesResponse, void, xstate157.EventObject>;
+          logic: xstate322.PromiseActorLogic<FetchCandidatesResponse, void, xstate322.EventObject>;
           id: string | undefined;
         };
         submitContinue: {
           src: "submitContinue";
-          logic: xstate157.PromiseActorLogic<SubmitResponse, void, xstate157.EventObject>;
+          logic: xstate322.PromiseActorLogic<SubmitResponse, void, xstate322.EventObject>;
           id: string | undefined;
         };
         submitSkip: {
           src: "submitSkip";
-          logic: xstate157.PromiseActorLogic<SubmitResponse, void, xstate157.EventObject>;
+          logic: xstate322.PromiseActorLogic<SubmitResponse, void, xstate322.EventObject>;
           id: string | undefined;
         };
       }>, "src", TSrc>["logic"]>;
-      <TLogic extends xstate157.AnyActorLogic>(src: TLogic, ...[options]: xstate157.ConditionalRequired<[options?: ({
+      <TLogic extends xstate322.AnyActorLogic>(src: TLogic, ...[options]: xstate322.ConditionalRequired<[options?: ({
         id?: never;
         systemId?: string;
-        input?: xstate157.InputFrom<TLogic> | undefined;
+        input?: xstate322.InputFrom<TLogic> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate157.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate157.IsNotNever<xstate157.RequiredLogicInput<TLogic>>>): xstate157.ActorRefFromLogic<TLogic>;
+      } & { [K in xstate322.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate322.IsNotNever<xstate322.RequiredLogicInput<TLogic>>>): xstate322.ActorRefFromLogic<TLogic>;
     };
     input: IdentityReuseInput;
-    self: xstate157.ActorRef<xstate157.MachineSnapshot<IdentityReuseContext, {
+    self: xstate322.ActorRef<xstate322.MachineSnapshot<IdentityReuseContext, {
       type: "LOAD";
     } | {
       type: "START_SELECTION";
@@ -197,7 +197,7 @@ declare const identityReuseMachine: xstate157.StateMachine<IdentityReuseContext,
       type: "SKIP";
     } | {
       type: "RETRY";
-    }, Record<string, xstate157.AnyActorRef | undefined>, xstate157.StateValue, string, unknown, any, any>, {
+    }, Record<string, xstate322.AnyActorRef | undefined>, xstate322.StateValue, string, unknown, any, any>, {
       type: "LOAD";
     } | {
       type: "START_SELECTION";
@@ -212,7 +212,7 @@ declare const identityReuseMachine: xstate157.StateMachine<IdentityReuseContext,
       type: "SKIP";
     } | {
       type: "RETRY";
-    }, xstate157.AnyEventObject>;
+    }, xstate322.AnyEventObject>;
   }) => {
     config: IdentityReuseConfig;
     currentOrganizationName: undefined;