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

package/dist/document-capture.esm.js

@@ -1,407 +1,12 @@
-import { t as api } from "./api-DzpnV6O7.esm.js";
-import { _ as endpoints, n as eventModuleNames, o as createManagerInstrumentation } from "./events-DlHrOIRc.esm.js";
-import { a as createActor, i as fromPromise, n as assign, o as createManager, t as setup } from "./xstate.esm-Bv55-lJ4.esm.js";
-import { i as stopCameraStream } from "./camera-DmkFpf5N.esm.js";
-import "./platform-Dv7a2fv-.esm.js";
-import "./ITimerCapability-oixwa6nj.esm.js";
-import { t as getBackCameraStream } from "./backCameraStream-tabTmwDS.esm.js";
+import "./api-aa9Mx20l.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-W91zLpx4.esm.js";
+import { a as createActor, o as createManager } from "./xstate.esm-B7FPE6br.esm.js";
+import "./camera-DpPQS_-5.esm.js";
+import "./platform-DctkySJU.esm.js";
+import "./ITimerCapability-BZO_FsCo.esm.js";
+import "./backCameraStream-D9g2wyil.esm.js";
+import { n as DOCUMENT_CAPTURE_ERROR_CODES, t as documentCaptureMachine } from "./documentCaptureStateMachine-ByYOCKz5.esm.js";
 
-//#region src/modules/document-capture/types.ts
-const PROCESSING_TYPE_MAP = {
-	processV5CLogbook: "v5cMultiPageLogbook",
-	processCirculationCard: "circulationCard",
-	processFinanceSettlement: "financeSettlement",
-	processCarInvoice: "carInvoice",
-	asyncProcessCarInvoice: "carInvoice",
-	asyncProcessCirculationCard: "circulationCard",
-	capture: "addressStatement"
-};
-const MULTI_PAGE_TYPES = [
-	"v5cMultiPageLogbook",
-	"circulationCard",
-	"financeSettlement"
-];
-const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
-const DEFAULT_CAPTURE_ATTEMPTS = 3;
-const OTHER_DOCUMENT_TYPES = new Set([
-	"otherDocument1",
-	"otherDocument2",
-	"otherDocument3"
-]);
-const DOCUMENT_CAPTURE_ERROR_CODES = {
-	FILE_TOO_LARGE: "FILE_TOO_LARGE",
-	UPLOAD_FAILED: "UPLOAD_FAILED"
-};
-const DOCUMENT_CAPTURE_FINALIZE_ERROR_CODES = { UNEXPECTED_ERROR: "UNEXPECTED_ERROR" };
-
-//#endregion
-//#region src/modules/document-capture/documentCaptureUploadService.ts
-function isMultiPageDocumentType(processingType) {
-	return MULTI_PAGE_TYPES.includes(processingType);
-}
-function normalizeProcessingType(processingType) {
-	return PROCESSING_TYPE_MAP[processingType] ?? processingType;
-}
-function buildUrl(baseUrl, type, format) {
-	return `${baseUrl}?type=${encodeURIComponent(type)}&format=${format}`;
-}
-function resolveUploadUrl(processingType, fileFormat) {
-	const format = fileFormat === "application/pdf" ? "pdf" : "image";
-	const resolvedType = normalizeProcessingType(processingType);
-	if (isMultiPageDocumentType(resolvedType)) return buildUrl(endpoints.documentV3, resolvedType, format);
-	if (resolvedType === "carInvoice") return buildUrl(endpoints.cfdi, resolvedType, format);
-	if (OTHER_DOCUMENT_TYPES.has(resolvedType)) return buildUrl(endpoints.addDocument, resolvedType, format);
-	if (resolvedType === "addressStatement" || !resolvedType) return buildUrl(endpoints.addressStatement, resolvedType || "addressStatement", format);
-	return buildUrl(endpoints.addressStatement, processingType, format);
-}
-async function uploadDocumentCapture({ base64Image, processingType, fileFormat, onProgress, signal }) {
-	const url = resolveUploadUrl(processingType, fileFormat);
-	const rawBase64 = base64Image.includes(",") ? base64Image.split(",")[1] : base64Image;
-	const response = await api.post(url, { base64Image: rawBase64 }, {
-		signal,
-		onUploadProgress: onProgress
-	});
-	if (!response.ok) throw new Error(`Document upload failed: ${response.status}`);
-	if (!(response.data.success || response.data.status === "SUCCESS" || response.data.status === "ADD_NEXT_PAGE" || response.data.status === "OPTIONAL_PAGE_CAPTURE")) throw new Error("Document upload rejected by server");
-	return response.data;
-}
-function resolveMultiPageDocumentType(processingType) {
-	const resolvedType = normalizeProcessingType(processingType);
-	return isMultiPageDocumentType(resolvedType) ? resolvedType : null;
-}
-async function finalizeDocument({ processingType, signal }) {
-	const type = resolveMultiPageDocumentType(processingType);
-	if (!type) throw new Error(`finalizeDocument only supports multi-page types (${MULTI_PAGE_TYPES.join(", ")})`);
-	const response = await api.post(endpoints.finalizeDocument, { type }, { signal });
-	if (!response.ok) throw new Error(`Document finalize failed: ${response.status}`);
-	const data = response.data;
-	if (!data) throw new Error("Document finalize rejected by server");
-	if (!(data.success || data.status === "SUCCESS")) {
-		const serverStatus = typeof data.status === "string" ? data.status : "unknown";
-		throw new Error(`Document finalize rejected by server (status: ${serverStatus})`);
-	}
-	return data;
-}
-
-//#endregion
-//#region src/modules/document-capture/documentCaptureStateMachine.ts
-const documentCaptureMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {}
-	},
-	actors: {
-		initCamera: fromPromise(async () => {
-			const { stream } = await getBackCameraStream(void 0);
-			return stream;
-		}),
-		uploadDocument: fromPromise(async ({ input, signal }) => {
-			return uploadDocumentCapture({
-				base64Image: input.capturedDocument.imageBase64,
-				processingType: input.processingType,
-				fileFormat: input.capturedDocument.fileType,
-				onProgress: input.onProgress,
-				signal
-			});
-		}),
-		finalizeDocumentRequest: fromPromise(async ({ input, signal }) => {
-			return finalizeDocument({
-				processingType: input.processingType,
-				signal
-			});
-		})
-	},
-	actions: {
-		setStream: assign(({ event }) => ({ stream: event.output })),
-		setCapturedDocument: assign(({ event }) => {
-			const e = event;
-			return {
-				capturedDocument: {
-					imageBase64: e.imageBase64,
-					file: e.file,
-					fileType: e.fileType
-				},
-				error: void 0
-			};
-		}),
-		setFileTooLargeError: assign({ error: () => DOCUMENT_CAPTURE_ERROR_CODES.FILE_TOO_LARGE }),
-		setProgress: assign(({ event }) => ({ progress: event.progress })),
-		setUploadError: assign({ error: () => DOCUMENT_CAPTURE_ERROR_CODES.UPLOAD_FAILED }),
-		setFinalizeError: assign({ error: () => DOCUMENT_CAPTURE_FINALIZE_ERROR_CODES.UNEXPECTED_ERROR }),
-		decrementAttemptsRemaining: assign(({ context }) => ({ attemptsRemaining: context.attemptsRemaining - 1 })),
-		setCaptureMethodFile: assign({ captureMethod: () => "file" }),
-		setCaptureMethodCamera: assign({ captureMethod: () => "camera" }),
-		setCaptureMethodGallery: assign({ captureMethod: () => "gallery" }),
-		clearCapturedDocument: assign({
-			capturedDocument: () => void 0,
-			captureMethod: () => void 0,
-			progress: () => 0,
-			error: () => void 0
-		}),
-		clearCapturedDocumentGalleryRetake: assign({
-			capturedDocument: () => void 0,
-			progress: () => 0,
-			error: () => void 0
-		}),
-		setNextPageType: assign(({ context, event }) => {
-			const { status } = event.output;
-			if (context.captureMethod === "file" && context.capturedDocument?.fileType === "application/pdf") return { nextPageType: "none" };
-			return { nextPageType: status === "ADD_NEXT_PAGE" ? "required" : status === "OPTIONAL_PAGE_CAPTURE" ? "optional" : "none" };
-		}),
-		clearForNextPage: assign(({ context }) => ({
-			capturedDocument: void 0,
-			progress: 0,
-			error: void 0,
-			pageNumber: context.pageNumber + 1,
-			nextPageType: "none",
-			captureMethod: void 0
-		})),
-		clearError: assign({ error: () => void 0 }),
-		resetProgress: assign({ progress: () => 0 }),
-		stopStream: assign(({ context }) => {
-			if (context.stream) stopCameraStream(context.stream);
-			return { stream: void 0 };
-		})
-	},
-	guards: {
-		allowSkip: ({ context }) => context.config.allowSkipDocumentCapture && context.pageNumber === 1,
-		fileSizeOk: ({ context, event }) => {
-			return event.file.size <= context.config.maxFileSize;
-		},
-		canRetryCamera: ({ context }) => context.attemptsRemaining > 0 && context.captureMethod === "camera",
-		canRetryFile: ({ context }) => context.attemptsRemaining > 0 && context.captureMethod !== "camera",
-		canRetryNextDocumentCapture: ({ context }) => context.attemptsRemaining > 0 && context.nextPageType === "optional",
-		attemptsExhausted: ({ context }) => context.attemptsRemaining <= 0,
-		isCameraMode: ({ context }) => context.config.captureMode === "camera",
-		isCaptureMethodCamera: ({ context }) => context.captureMethod === "camera",
-		isCaptureMethodGallery: ({ context }) => context.captureMethod === "gallery",
-		isCaptureMethodFile: ({ context }) => context.captureMethod === "file",
-		isNextPageOptional: ({ context }) => context.nextPageType === "optional",
-		isNextPageRequired: ({ context }) => context.nextPageType === "required",
-		canFinalizeOptionalPages: ({ context }) => context.nextPageType === "optional" && resolveMultiPageDocumentType(context.config.processingType) !== null,
-		fileSizeOkForGallery: ({ context, event }) => {
-			return event.file.size <= context.config.maxFileSize && context.captureMethod === "gallery";
-		},
-		fileSizeOkForNonGallery: ({ context, event }) => {
-			return event.file.size <= context.config.maxFileSize && context.captureMethod !== "gallery";
-		}
-	}
-}).createMachine({
-	id: "documentCapture",
-	initial: "tutorial",
-	context: ({ input }) => {
-		const { processingType = "addressStatement", captureMode = "camera", allowSkipDocumentCapture = false, captureAttempts = DEFAULT_CAPTURE_ATTEMPTS, sendBase64 = false, maxFileSize = DEFAULT_MAX_FILE_SIZE, title, text, step2Title, step2Text } = input.config;
-		return {
-			config: {
-				processingType,
-				captureMode,
-				allowSkipDocumentCapture,
-				captureAttempts,
-				sendBase64,
-				maxFileSize,
-				title,
-				text,
-				step2Title,
-				step2Text
-			},
-			stream: void 0,
-			capturedDocument: void 0,
-			captureMethod: void 0,
-			progress: 0,
-			error: void 0,
-			attemptsRemaining: captureAttempts,
-			pageNumber: 1,
-			nextPageType: "none"
-		};
-	},
-	states: {
-		tutorial: { on: {
-			CAPTURE: [{
-				target: "initCamera",
-				guard: "isCameraMode"
-			}, { target: "capturing" }],
-			FILE_SELECTED: [{
-				target: "preview",
-				guard: "fileSizeOk",
-				actions: ["setCapturedDocument", "setCaptureMethodFile"]
-			}, {
-				target: "tutorial",
-				actions: "setFileTooLargeError"
-			}],
-			SKIP: {
-				target: "finished",
-				guard: "allowSkip"
-			},
-			CLOSE: { target: "closed" }
-		} },
-		initCamera: {
-			invoke: {
-				id: "initCamera",
-				src: "initCamera",
-				input: void 0,
-				onDone: {
-					target: "capturing",
-					actions: "setStream"
-				},
-				onError: {
-					target: "failure",
-					actions: "setUploadError"
-				}
-			},
-			on: { CLOSE: { target: "closed" } }
-		},
-		capturing: { on: {
-			FILE_SELECTED: [
-				{
-					target: "preview",
-					guard: "fileSizeOkForGallery",
-					actions: "setCapturedDocument"
-				},
-				{
-					target: "preview",
-					guard: "fileSizeOkForNonGallery",
-					actions: ["setCapturedDocument", "setCaptureMethodCamera"]
-				},
-				{
-					target: "capturing",
-					actions: "setFileTooLargeError"
-				}
-			],
-			CLOSE: {
-				target: "closed",
-				actions: "stopStream"
-			}
-		} },
-		preview: { on: {
-			ACCEPT: {
-				target: "uploading",
-				actions: "resetProgress"
-			},
-			RETAKE: [
-				{
-					target: "tutorial",
-					guard: "isCaptureMethodFile",
-					actions: "clearCapturedDocument"
-				},
-				{
-					target: "capturing",
-					guard: "isCaptureMethodGallery",
-					actions: "clearCapturedDocumentGalleryRetake"
-				},
-				{
-					target: "capturing",
-					actions: "clearCapturedDocument"
-				}
-			],
-			CLOSE: {
-				target: "closed",
-				actions: "stopStream"
-			}
-		} },
-		uploading: {
-			invoke: {
-				id: "uploadDocument",
-				src: "uploadDocument",
-				input: ({ context, self }) => {
-					if (!context.capturedDocument) throw new Error("No captured document to upload");
-					return {
-						capturedDocument: context.capturedDocument,
-						processingType: context.config.processingType,
-						onProgress: (progress) => {
-							self.send({
-								type: "UPLOAD_PROGRESS",
-								progress
-							});
-						}
-					};
-				},
-				onDone: {
-					target: "success",
-					actions: ["setNextPageType", "stopStream"]
-				},
-				onError: {
-					target: "failure",
-					actions: [
-						"setUploadError",
-						"decrementAttemptsRemaining",
-						"stopStream"
-					]
-				}
-			},
-			on: { UPLOAD_PROGRESS: { actions: "setProgress" } }
-		},
-		success: { on: {
-			CONTINUE: [
-				{
-					target: "nextPage",
-					guard: "isNextPageOptional"
-				},
-				{
-					target: "nextPage",
-					guard: "isNextPageRequired"
-				},
-				{ target: "finished" }
-			],
-			CLOSE: { target: "closed" }
-		} },
-		nextPage: { on: {
-			NEXT_PAGE_CAMERA: {
-				target: "initCamera",
-				actions: ["clearForNextPage", "setCaptureMethodCamera"]
-			},
-			NEXT_PAGE_PHOTO_LIBRARY: {
-				target: "capturing",
-				actions: ["clearForNextPage", "setCaptureMethodGallery"]
-			},
-			ALL_PAGES_CAPTURED: [{
-				target: "finalizing",
-				guard: "canFinalizeOptionalPages"
-			}, { target: "finished" }],
-			CLOSE: { target: "closed" }
-		} },
-		finalizing: { invoke: {
-			id: "finalizeDocument",
-			src: "finalizeDocumentRequest",
-			input: ({ context }) => ({ processingType: context.config.processingType }),
-			onDone: { target: "finished" },
-			onError: {
-				target: "failure",
-				actions: ["setFinalizeError", "decrementAttemptsRemaining"]
-			}
-		} },
-		failure: {
-			on: {
-				RETRY: [
-					{
-						target: "nextPage",
-						guard: "canRetryNextDocumentCapture",
-						actions: ["clearError", "clearCapturedDocument"]
-					},
-					{
-						target: "initCamera",
-						guard: "canRetryCamera",
-						actions: ["clearError", "clearCapturedDocument"]
-					},
-					{
-						target: "tutorial",
-						guard: "canRetryFile",
-						actions: ["clearError", "clearCapturedDocument"]
-					}
-				],
-				CLOSE: { target: "closed" }
-			},
-			after: { 3e3: {
-				target: "finished",
-				guard: "attemptsExhausted"
-			} }
-		},
-		finished: { type: "final" },
-		closed: { type: "final" }
-	}
-});
-
-//#endregion
 //#region src/modules/document-capture/documentCaptureActor.ts
 function createDocumentCaptureActor(options) {
 	return createActor(documentCaptureMachine, { input: { config: options.config } }).start();

package/dist/document-upload.d.ts

@@ -1,11 +1,11 @@
-import { t as Manager } from "./Manager-BN2g_I8W.js";
-import "./Actor-Ba71-_30.js";
-import "./camera-1eeGnAaL.js";
-import { n as DocumentUploadContext, r as DocumentUploadInput, t as DocumentUploadConfig } from "./types-2OPf1pyv.js";
-import * as xstate529 from "xstate";
+import { t as Manager } from "./Manager-DcPMRgTm.js";
+import "./Actor-DbWH1K6E.js";
+import "./camera-DATT31my.js";
+import { n as DocumentUploadContext, r as DocumentUploadInput, t as DocumentUploadConfig } from "./types-CYJ0Ish6.js";
+import * as xstate0 from "xstate";
 
 //#region src/modules/document-upload/documentUploadStateMachine.d.ts
-declare const documentUploadMachine: xstate529.StateMachine<DocumentUploadContext, {
+declare const documentUploadMachine: xstate0.StateMachine<DocumentUploadContext, {
   type: "START";
 } | {
   type: "CAPTURE";
@@ -18,52 +18,52 @@ declare const documentUploadMachine: xstate529.StateMachine<DocumentUploadContex
 } | {
   type: "CLOSE";
 }, {
-  [x: string]: xstate529.ActorRefFromLogic<xstate529.PromiseActorLogic<MediaStream, void, xstate529.EventObject>> | xstate529.ActorRefFromLogic<xstate529.PromiseActorLogic<void, {
+  [x: string]: xstate0.ActorRefFromLogic<xstate0.PromiseActorLogic<MediaStream, void, xstate0.EventObject>> | xstate0.ActorRefFromLogic<xstate0.PromiseActorLogic<void, {
     imageBase64: string;
     documentType: string;
     onProgress: (progress: number) => void;
-  }, xstate529.EventObject>> | undefined;
-}, xstate529.Values<{
+  }, xstate0.EventObject>> | undefined;
+}, xstate0.Values<{
   initCamera: {
     src: "initCamera";
-    logic: xstate529.PromiseActorLogic<MediaStream, void, xstate529.EventObject>;
+    logic: xstate0.PromiseActorLogic<MediaStream, void, xstate0.EventObject>;
     id: string | undefined;
   };
   uploadDocument: {
     src: "uploadDocument";
-    logic: xstate529.PromiseActorLogic<void, {
+    logic: xstate0.PromiseActorLogic<void, {
       imageBase64: string;
       documentType: string;
       onProgress: (progress: number) => void;
-    }, xstate529.EventObject>;
+    }, xstate0.EventObject>;
     id: string | undefined;
   };
-}>, xstate529.Values<{
-  setError: {
-    type: "setError";
-    params: xstate529.NonReducibleUnknown;
-  };
-  clearError: {
-    type: "clearError";
-    params: xstate529.NonReducibleUnknown;
-  };
+}>, xstate0.Values<{
   setStream: {
     type: "setStream";
-    params: xstate529.NonReducibleUnknown;
+    params: xstate0.NonReducibleUnknown;
+  };
+  setImageAndClearError: {
+    type: "setImageAndClearError";
+    params: xstate0.NonReducibleUnknown;
   };
   setProgress: {
     type: "setProgress";
-    params: xstate529.NonReducibleUnknown;
+    params: xstate0.NonReducibleUnknown;
+  };
+  setError: {
+    type: "setError";
+    params: xstate0.NonReducibleUnknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: xstate0.NonReducibleUnknown;
   };
   stopStream: {
     type: "stopStream";
-    params: xstate529.NonReducibleUnknown;
-  };
-  setImageAndClearError: {
-    type: "setImageAndClearError";
-    params: xstate529.NonReducibleUnknown;
+    params: xstate0.NonReducibleUnknown;
   };
-}>, never, never, "error" | "idle" | "finished" | "closed" | "initCamera" | "capturing" | "uploading", string, DocumentUploadInput, xstate529.NonReducibleUnknown, xstate529.EventObject, xstate529.MetaObject, {
+}>, never, never, "error" | "initCamera" | "idle" | "capturing" | "closed" | "uploading" | "finished", string, DocumentUploadInput, xstate0.NonReducibleUnknown, xstate0.EventObject, xstate0.MetaObject, {
   readonly id: "documentUpload";
   readonly initial: "idle";
   readonly context: ({
@@ -72,67 +72,67 @@ declare const documentUploadMachine: xstate529.StateMachine<DocumentUploadContex
     spawn: {
       <TSrc extends "initCamera" | "uploadDocument">(logic: TSrc, ...[options]: ({
         src: "initCamera";
-        logic: xstate529.PromiseActorLogic<MediaStream, void, xstate529.EventObject>;
+        logic: xstate0.PromiseActorLogic<MediaStream, void, xstate0.EventObject>;
         id: string | undefined;
       } extends infer T ? T extends {
         src: "initCamera";
-        logic: xstate529.PromiseActorLogic<MediaStream, void, xstate529.EventObject>;
+        logic: xstate0.PromiseActorLogic<MediaStream, void, xstate0.EventObject>;
         id: string | undefined;
       } ? T extends {
         src: TSrc;
-      } ? xstate529.ConditionalRequired<[options?: ({
+      } ? xstate0.ConditionalRequired<[options?: ({
         id?: T["id"] | undefined;
         systemId?: string;
-        input?: xstate529.InputFrom<T["logic"]> | undefined;
+        input?: xstate0.InputFrom<T["logic"]> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate529.RequiredActorOptions<T>]: unknown }) | undefined], xstate529.IsNotNever<xstate529.RequiredActorOptions<T>>> : never : never : never) | ({
+      } & { [K in xstate0.RequiredActorOptions<T>]: unknown }) | undefined], xstate0.IsNotNever<xstate0.RequiredActorOptions<T>>> : never : never : never) | ({
         src: "uploadDocument";
-        logic: xstate529.PromiseActorLogic<void, {
+        logic: xstate0.PromiseActorLogic<void, {
           imageBase64: string;
           documentType: string;
           onProgress: (progress: number) => void;
-        }, xstate529.EventObject>;
+        }, xstate0.EventObject>;
         id: string | undefined;
       } extends infer T_1 ? T_1 extends {
         src: "uploadDocument";
-        logic: xstate529.PromiseActorLogic<void, {
+        logic: xstate0.PromiseActorLogic<void, {
           imageBase64: string;
           documentType: string;
           onProgress: (progress: number) => void;
-        }, xstate529.EventObject>;
+        }, xstate0.EventObject>;
         id: string | undefined;
       } ? T_1 extends {
         src: TSrc;
-      } ? xstate529.ConditionalRequired<[options?: ({
+      } ? xstate0.ConditionalRequired<[options?: ({
         id?: T_1["id"] | undefined;
         systemId?: string;
-        input?: xstate529.InputFrom<T_1["logic"]> | undefined;
+        input?: xstate0.InputFrom<T_1["logic"]> | undefined;
         syncSnapshot?: boolean;
-      } & { [K_1 in xstate529.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate529.IsNotNever<xstate529.RequiredActorOptions<T_1>>> : never : never : never)): xstate529.ActorRefFromLogic<xstate529.GetConcreteByKey<xstate529.Values<{
+      } & { [K_1 in xstate0.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate0.IsNotNever<xstate0.RequiredActorOptions<T_1>>> : never : never : never)): xstate0.ActorRefFromLogic<xstate0.GetConcreteByKey<xstate0.Values<{
         initCamera: {
           src: "initCamera";
-          logic: xstate529.PromiseActorLogic<MediaStream, void, xstate529.EventObject>;
+          logic: xstate0.PromiseActorLogic<MediaStream, void, xstate0.EventObject>;
           id: string | undefined;
         };
         uploadDocument: {
           src: "uploadDocument";
-          logic: xstate529.PromiseActorLogic<void, {
+          logic: xstate0.PromiseActorLogic<void, {
             imageBase64: string;
             documentType: string;
             onProgress: (progress: number) => void;
-          }, xstate529.EventObject>;
+          }, xstate0.EventObject>;
           id: string | undefined;
         };
       }>, "src", TSrc>["logic"]>;
-      <TLogic extends xstate529.AnyActorLogic>(src: TLogic, ...[options]: xstate529.ConditionalRequired<[options?: ({
+      <TLogic extends xstate0.AnyActorLogic>(src: TLogic, ...[options]: xstate0.ConditionalRequired<[options?: ({
         id?: never;
         systemId?: string;
-        input?: xstate529.InputFrom<TLogic> | undefined;
+        input?: xstate0.InputFrom<TLogic> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate529.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate529.IsNotNever<xstate529.RequiredLogicInput<TLogic>>>): xstate529.ActorRefFromLogic<TLogic>;
+      } & { [K in xstate0.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate0.IsNotNever<xstate0.RequiredLogicInput<TLogic>>>): xstate0.ActorRefFromLogic<TLogic>;
     };
     input: DocumentUploadInput;
-    self: xstate529.ActorRef<xstate529.MachineSnapshot<DocumentUploadContext, {
+    self: xstate0.ActorRef<xstate0.MachineSnapshot<DocumentUploadContext, {
       type: "START";
     } | {
       type: "CAPTURE";
@@ -144,7 +144,7 @@ declare const documentUploadMachine: xstate529.StateMachine<DocumentUploadContex
       type: "RETRY";
     } | {
       type: "CLOSE";
-    }, Record<string, xstate529.AnyActorRef | undefined>, xstate529.StateValue, string, unknown, any, any>, {
+    }, Record<string, xstate0.AnyActorRef | undefined>, xstate0.StateValue, string, unknown, any, any>, {
       type: "START";
     } | {
       type: "CAPTURE";
@@ -156,7 +156,7 @@ declare const documentUploadMachine: xstate529.StateMachine<DocumentUploadContex
       type: "RETRY";
     } | {
       type: "CLOSE";
-    }, xstate529.AnyEventObject>;
+    }, xstate0.AnyEventObject>;
   }) => {
     config: DocumentUploadConfig;
     stream: undefined;
@@ -226,7 +226,7 @@ declare const documentUploadMachine: xstate529.StateMachine<DocumentUploadContex
           } | {
             type: "CLOSE";
           };
-          self: xstate529.ActorRef<xstate529.MachineSnapshot<DocumentUploadContext, {
+          self: xstate0.ActorRef<xstate0.MachineSnapshot<DocumentUploadContext, {
             type: "START";
           } | {
             type: "CAPTURE";
@@ -238,7 +238,7 @@ declare const documentUploadMachine: xstate529.StateMachine<DocumentUploadContex
             type: "RETRY";
           } | {
             type: "CLOSE";
-          }, Record<string, xstate529.AnyActorRef>, xstate529.StateValue, string, unknown, any, any>, {
+          }, Record<string, xstate0.AnyActorRef>, xstate0.StateValue, string, unknown, any, any>, {
             type: "START";
           } | {
             type: "CAPTURE";
@@ -250,7 +250,7 @@ declare const documentUploadMachine: xstate529.StateMachine<DocumentUploadContex
             type: "RETRY";
           } | {
             type: "CLOSE";
-          }, xstate529.AnyEventObject>;
+          }, xstate0.AnyEventObject>;
         }) => {
           imageBase64: string;
           documentType: string;

package/dist/document-upload.esm.js

@@ -1,10 +1,10 @@
-import { t as api } from "./api-DzpnV6O7.esm.js";
-import { _ as endpoints, n as eventModuleNames, o as createManagerInstrumentation } from "./events-DlHrOIRc.esm.js";
-import { a as createActor, i as fromPromise, n as assign, o as createManager, t as setup } from "./xstate.esm-Bv55-lJ4.esm.js";
-import { i as stopCameraStream } from "./camera-DmkFpf5N.esm.js";
-import "./platform-Dv7a2fv-.esm.js";
-import "./ITimerCapability-oixwa6nj.esm.js";
-import { t as getBackCameraStream } from "./backCameraStream-tabTmwDS.esm.js";
+import { t as api } from "./api-aa9Mx20l.esm.js";
+import { _ as endpoints, n as eventModuleNames, o as createManagerInstrumentation } from "./events-W91zLpx4.esm.js";
+import { a as createActor, i as fromPromise, n as assign, o as createManager, t as setup } from "./xstate.esm-B7FPE6br.esm.js";
+import { i as stopCameraStream } from "./camera-DpPQS_-5.esm.js";
+import "./platform-DctkySJU.esm.js";
+import "./ITimerCapability-BZO_FsCo.esm.js";
+import { t as getBackCameraStream } from "./backCameraStream-D9g2wyil.esm.js";
 
 //#region src/modules/document-upload/documentUploadServices.ts
 async function uploadDocument({ imageBase64, documentType, onProgress, signal }) {