@incodetech/core 0.0.0-dev-20260304-fb1914c → 0.0.0-dev-20260306-aac8dd3

package/dist/document-capture.d.ts

@@ -0,0 +1,660 @@
+import { t as Manager } from "./Manager-CVog-etk.js";
+import { t as CameraStream } from "./camera-HI2fNiV5.js";
+import * as xstate0 from "xstate";
+
+//#region src/modules/document-capture/types.d.ts
+type DocumentType = 'addressStatement' | 'otherDocument1' | 'otherDocument2' | 'otherDocument3' | 'v5cMultiPageLogbook' | 'circulationCard' | 'financeSettlement' | 'carInvoice' | 'capture' | 'processPoaOcr' | 'processLoaOcr' | 'processAsylumSeekerVisaZaf' | 'processBankStatementOCR' | 'processBankCheck' | 'processV5CLogbook' | 'processCarInvoice' | 'processCirculationCard' | 'processFinanceSettlement';
+declare const DOCUMENT_CAPTURE_ERROR_CODES: {
+  readonly FILE_TOO_LARGE: "FILE_TOO_LARGE";
+  readonly UPLOAD_FAILED: "UPLOAD_FAILED";
+};
+type DocumentCaptureErrorCode = (typeof DOCUMENT_CAPTURE_ERROR_CODES)[keyof typeof DOCUMENT_CAPTURE_ERROR_CODES];
+/**
+ * Configuration for the document capture module.
+ * Parameterized to support both DOCUMENT_CAPTURE and ADDRESS flows.
+ */
+type DocumentCaptureConfig = {
+  /** Processing type for API endpoint routing. @default 'addressStatement' */
+  processingType?: DocumentType;
+  /** Capture mode. 'camera' shows bottom sheet with camera+file options. 'file' opens file picker directly. @default 'camera' */
+  captureMode?: 'file' | 'camera';
+  /** Allow user to skip this step. @default false */
+  allowSkipDocumentCapture?: boolean;
+  /** Tutorial screen title override */
+  title?: string;
+  /** Tutorial screen text override */
+  text?: string;
+  /** Title override for the second-page tutorial (multi-page flows). Falls back to `title`. */
+  step2Title?: string;
+  /** Text override for the second-page tutorial (multi-page flows). Falls back to `text`. */
+  step2Text?: string;
+  /** Number of capture/upload attempts before auto-advancing. @default 3 */
+  captureAttempts?: number;
+  /** Send image as base64 instead of raw file. @default false */
+  sendBase64?: boolean;
+  /** Maximum file size in bytes. @default 10485760 (10MB) */
+  maxFileSize?: number;
+};
+type CapturedDocument = {
+  imageBase64: string;
+  file: File;
+  fileType: string;
+};
+type DocumentUploadResponse = {
+  success: boolean;
+  status?: 'ADD_NEXT_PAGE' | 'SUCCESS';
+};
+type DocumentCaptureResolvedConfig = {
+  processingType: DocumentType;
+  captureMode: 'file' | 'camera';
+  allowSkipDocumentCapture: boolean;
+  captureAttempts: number;
+  sendBase64: boolean;
+  maxFileSize: number;
+  title: string | undefined;
+  text: string | undefined;
+  step2Title: string | undefined;
+  step2Text: string | undefined;
+};
+type DocumentCaptureContext = {
+  config: DocumentCaptureResolvedConfig;
+  stream: CameraStream | undefined;
+  capturedDocument: CapturedDocument | undefined;
+  captureMethod: 'camera' | 'file' | undefined;
+  progress: number;
+  error: DocumentCaptureErrorCode | undefined;
+  attemptsRemaining: number;
+  pageNumber: number;
+  pendingNextPage: boolean;
+};
+type DocumentCaptureInput = {
+  config: DocumentCaptureConfig;
+};
+//#endregion
+//#region src/modules/document-capture/documentCaptureStateMachine.d.ts
+declare const documentCaptureMachine: xstate0.StateMachine<DocumentCaptureContext, {
+  type: "CAPTURE";
+} | {
+  type: "FILE_SELECTED";
+  file: File;
+  imageBase64: string;
+  fileType: string;
+} | {
+  type: "ACCEPT";
+} | {
+  type: "RETAKE";
+} | {
+  type: "UPLOAD_PROGRESS";
+  progress: number;
+} | {
+  type: "RETRY";
+} | {
+  type: "CONTINUE";
+} | {
+  type: "SKIP";
+} | {
+  type: "CLOSE";
+}, {
+  [x: string]: xstate0.ActorRefFromLogic<xstate0.PromiseActorLogic<MediaStream, void, xstate0.EventObject>> | xstate0.ActorRefFromLogic<xstate0.PromiseActorLogic<DocumentUploadResponse, {
+    capturedDocument: NonNullable<DocumentCaptureContext["capturedDocument"]>;
+    processingType: string;
+    onProgress: (progress: number) => void;
+  }, xstate0.EventObject>> | undefined;
+}, xstate0.Values<{
+  initCamera: {
+    src: "initCamera";
+    logic: xstate0.PromiseActorLogic<MediaStream, void, xstate0.EventObject>;
+    id: string | undefined;
+  };
+  uploadDocument: {
+    src: "uploadDocument";
+    logic: xstate0.PromiseActorLogic<DocumentUploadResponse, {
+      capturedDocument: NonNullable<DocumentCaptureContext["capturedDocument"]>;
+      processingType: string;
+      onProgress: (progress: number) => void;
+    }, xstate0.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate0.Values<{
+  setStream: {
+    type: "setStream";
+    params: unknown;
+  };
+  setCapturedDocument: {
+    type: "setCapturedDocument";
+    params: unknown;
+  };
+  setFileTooLargeError: {
+    type: "setFileTooLargeError";
+    params: unknown;
+  };
+  setProgress: {
+    type: "setProgress";
+    params: unknown;
+  };
+  setUploadError: {
+    type: "setUploadError";
+    params: unknown;
+  };
+  decrementAttemptsRemaining: {
+    type: "decrementAttemptsRemaining";
+    params: unknown;
+  };
+  setCaptureMethodFile: {
+    type: "setCaptureMethodFile";
+    params: unknown;
+  };
+  setCaptureMethodCamera: {
+    type: "setCaptureMethodCamera";
+    params: unknown;
+  };
+  clearCapturedDocument: {
+    type: "clearCapturedDocument";
+    params: unknown;
+  };
+  setPendingNextPage: {
+    type: "setPendingNextPage";
+    params: unknown;
+  };
+  clearForNextPage: {
+    type: "clearForNextPage";
+    params: unknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: unknown;
+  };
+  resetProgress: {
+    type: "resetProgress";
+    params: unknown;
+  };
+  stopStream: {
+    type: "stopStream";
+    params: unknown;
+  };
+  trackTutorial: {
+    type: "trackTutorial";
+    params: unknown;
+  };
+  trackCapture: {
+    type: "trackCapture";
+    params: unknown;
+  };
+  trackPreview: {
+    type: "trackPreview";
+    params: unknown;
+  };
+  trackUploading: {
+    type: "trackUploading";
+    params: unknown;
+  };
+  trackSuccess: {
+    type: "trackSuccess";
+    params: unknown;
+  };
+  trackFailure: {
+    type: "trackFailure";
+    params: unknown;
+  };
+}>, xstate0.Values<{
+  allowSkip: {
+    type: "allowSkip";
+    params: unknown;
+  };
+  fileSizeOk: {
+    type: "fileSizeOk";
+    params: unknown;
+  };
+  hasAttemptsRemaining: {
+    type: "hasAttemptsRemaining";
+    params: unknown;
+  };
+  canRetryCamera: {
+    type: "canRetryCamera";
+    params: unknown;
+  };
+  canRetryFile: {
+    type: "canRetryFile";
+    params: unknown;
+  };
+  attemptsExhausted: {
+    type: "attemptsExhausted";
+    params: unknown;
+  };
+  isCameraMode: {
+    type: "isCameraMode";
+    params: unknown;
+  };
+  isPendingNextPage: {
+    type: "isPendingNextPage";
+    params: unknown;
+  };
+}>, never, "initCamera" | "tutorial" | "capturing" | "preview" | "finished" | "closed" | "failure" | "uploading" | "success", string, DocumentCaptureInput, xstate0.NonReducibleUnknown, xstate0.EventObject, xstate0.MetaObject, {
+  readonly id: "documentCapture";
+  readonly initial: "tutorial";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "initCamera" | "uploadDocument">(logic: TSrc, ...[options]: ({
+        src: "initCamera";
+        logic: xstate0.PromiseActorLogic<MediaStream, void, xstate0.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "initCamera";
+        logic: xstate0.PromiseActorLogic<MediaStream, void, xstate0.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate0.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate0.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate0.RequiredActorOptions<T>]: unknown }) | undefined], xstate0.IsNotNever<xstate0.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "uploadDocument";
+        logic: xstate0.PromiseActorLogic<DocumentUploadResponse, {
+          capturedDocument: NonNullable<DocumentCaptureContext["capturedDocument"]>;
+          processingType: string;
+          onProgress: (progress: number) => void;
+        }, xstate0.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "uploadDocument";
+        logic: xstate0.PromiseActorLogic<DocumentUploadResponse, {
+          capturedDocument: NonNullable<DocumentCaptureContext["capturedDocument"]>;
+          processingType: string;
+          onProgress: (progress: number) => void;
+        }, xstate0.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate0.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate0.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [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: xstate0.PromiseActorLogic<MediaStream, void, xstate0.EventObject>;
+          id: string | undefined;
+        };
+        uploadDocument: {
+          src: "uploadDocument";
+          logic: xstate0.PromiseActorLogic<DocumentUploadResponse, {
+            capturedDocument: NonNullable<DocumentCaptureContext["capturedDocument"]>;
+            processingType: string;
+            onProgress: (progress: number) => void;
+          }, xstate0.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate0.AnyActorLogic>(src: TLogic, ...[options]: xstate0.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate0.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate0.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate0.IsNotNever<xstate0.RequiredLogicInput<TLogic>>>): xstate0.ActorRefFromLogic<TLogic>;
+    };
+    input: DocumentCaptureInput;
+    self: xstate0.ActorRef<xstate0.MachineSnapshot<DocumentCaptureContext, {
+      type: "CAPTURE";
+    } | {
+      type: "FILE_SELECTED";
+      file: File;
+      imageBase64: string;
+      fileType: string;
+    } | {
+      type: "ACCEPT";
+    } | {
+      type: "RETAKE";
+    } | {
+      type: "UPLOAD_PROGRESS";
+      progress: number;
+    } | {
+      type: "RETRY";
+    } | {
+      type: "CONTINUE";
+    } | {
+      type: "SKIP";
+    } | {
+      type: "CLOSE";
+    }, Record<string, xstate0.AnyActorRef | undefined>, xstate0.StateValue, string, unknown, any, any>, {
+      type: "CAPTURE";
+    } | {
+      type: "FILE_SELECTED";
+      file: File;
+      imageBase64: string;
+      fileType: string;
+    } | {
+      type: "ACCEPT";
+    } | {
+      type: "RETAKE";
+    } | {
+      type: "UPLOAD_PROGRESS";
+      progress: number;
+    } | {
+      type: "RETRY";
+    } | {
+      type: "CONTINUE";
+    } | {
+      type: "SKIP";
+    } | {
+      type: "CLOSE";
+    }, xstate0.AnyEventObject>;
+  }) => {
+    config: {
+      processingType: DocumentType;
+      captureMode: "file" | "camera";
+      allowSkipDocumentCapture: boolean;
+      captureAttempts: number;
+      sendBase64: boolean;
+      maxFileSize: number;
+      title: string | undefined;
+      text: string | undefined;
+      step2Title: string | undefined;
+      step2Text: string | undefined;
+    };
+    stream: undefined;
+    capturedDocument: undefined;
+    captureMethod: undefined;
+    progress: number;
+    error: undefined;
+    attemptsRemaining: number;
+    pageNumber: number;
+    pendingNextPage: false;
+  };
+  readonly states: {
+    readonly tutorial: {
+      readonly entry: "trackTutorial";
+      readonly on: {
+        readonly CAPTURE: readonly [{
+          readonly target: "initCamera";
+          readonly guard: "isCameraMode";
+        }, {
+          readonly target: "capturing";
+        }];
+        readonly FILE_SELECTED: readonly [{
+          readonly target: "preview";
+          readonly guard: "fileSizeOk";
+          readonly actions: readonly ["setCapturedDocument", "setCaptureMethodFile"];
+        }, {
+          readonly target: "tutorial";
+          readonly actions: "setFileTooLargeError";
+        }];
+        readonly SKIP: {
+          readonly target: "finished";
+          readonly guard: "allowSkip";
+        };
+        readonly CLOSE: {
+          readonly target: "closed";
+        };
+      };
+    };
+    readonly initCamera: {
+      readonly invoke: {
+        readonly id: "initCamera";
+        readonly src: "initCamera";
+        readonly input: undefined;
+        readonly onDone: {
+          readonly target: "capturing";
+          readonly actions: "setStream";
+        };
+        readonly onError: {
+          readonly target: "failure";
+          readonly actions: "setUploadError";
+        };
+      };
+      readonly on: {
+        readonly CLOSE: {
+          readonly target: "closed";
+        };
+      };
+    };
+    readonly capturing: {
+      readonly entry: "trackCapture";
+      readonly on: {
+        readonly FILE_SELECTED: readonly [{
+          readonly target: "preview";
+          readonly guard: "fileSizeOk";
+          readonly actions: readonly ["setCapturedDocument", "setCaptureMethodCamera"];
+        }, {
+          readonly target: "capturing";
+          readonly actions: "setFileTooLargeError";
+        }];
+        readonly CLOSE: {
+          readonly target: "closed";
+          readonly actions: "stopStream";
+        };
+      };
+    };
+    readonly preview: {
+      readonly entry: "trackPreview";
+      readonly on: {
+        readonly ACCEPT: {
+          readonly target: "uploading";
+          readonly actions: "resetProgress";
+        };
+        readonly RETAKE: {
+          readonly target: "capturing";
+          readonly actions: "clearCapturedDocument";
+        };
+        readonly CLOSE: {
+          readonly target: "closed";
+          readonly actions: "stopStream";
+        };
+      };
+    };
+    readonly uploading: {
+      readonly entry: "trackUploading";
+      readonly invoke: {
+        readonly id: "uploadDocument";
+        readonly src: "uploadDocument";
+        readonly input: ({
+          context,
+          self
+        }: {
+          context: DocumentCaptureContext;
+          event: {
+            type: "CAPTURE";
+          } | {
+            type: "FILE_SELECTED";
+            file: File;
+            imageBase64: string;
+            fileType: string;
+          } | {
+            type: "ACCEPT";
+          } | {
+            type: "RETAKE";
+          } | {
+            type: "UPLOAD_PROGRESS";
+            progress: number;
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "SKIP";
+          } | {
+            type: "CLOSE";
+          };
+          self: xstate0.ActorRef<xstate0.MachineSnapshot<DocumentCaptureContext, {
+            type: "CAPTURE";
+          } | {
+            type: "FILE_SELECTED";
+            file: File;
+            imageBase64: string;
+            fileType: string;
+          } | {
+            type: "ACCEPT";
+          } | {
+            type: "RETAKE";
+          } | {
+            type: "UPLOAD_PROGRESS";
+            progress: number;
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "SKIP";
+          } | {
+            type: "CLOSE";
+          }, Record<string, xstate0.AnyActorRef>, xstate0.StateValue, string, unknown, any, any>, {
+            type: "CAPTURE";
+          } | {
+            type: "FILE_SELECTED";
+            file: File;
+            imageBase64: string;
+            fileType: string;
+          } | {
+            type: "ACCEPT";
+          } | {
+            type: "RETAKE";
+          } | {
+            type: "UPLOAD_PROGRESS";
+            progress: number;
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "SKIP";
+          } | {
+            type: "CLOSE";
+          }, xstate0.AnyEventObject>;
+        }) => {
+          capturedDocument: CapturedDocument;
+          processingType: DocumentType;
+          onProgress: (progress: number) => void;
+        };
+        readonly onDone: {
+          readonly target: "success";
+          readonly actions: readonly ["setPendingNextPage", "stopStream"];
+        };
+        readonly onError: {
+          readonly target: "failure";
+          readonly actions: readonly ["setUploadError", "decrementAttemptsRemaining", "stopStream"];
+        };
+      };
+      readonly on: {
+        readonly UPLOAD_PROGRESS: {
+          readonly actions: "setProgress";
+        };
+      };
+    };
+    readonly success: {
+      readonly entry: "trackSuccess";
+      readonly on: {
+        readonly CONTINUE: readonly [{
+          readonly target: "tutorial";
+          readonly guard: "isPendingNextPage";
+          readonly actions: "clearForNextPage";
+        }, {
+          readonly target: "finished";
+        }];
+      };
+    };
+    readonly failure: {
+      readonly entry: "trackFailure";
+      readonly on: {
+        readonly RETRY: readonly [{
+          readonly target: "initCamera";
+          readonly guard: "canRetryCamera";
+          readonly actions: readonly ["clearError", "clearCapturedDocument"];
+        }, {
+          readonly target: "tutorial";
+          readonly guard: "canRetryFile";
+          readonly actions: readonly ["clearError", "clearCapturedDocument"];
+        }];
+        readonly CLOSE: {
+          readonly target: "closed";
+        };
+      };
+      readonly after: {
+        readonly 3000: {
+          readonly target: "finished";
+          readonly guard: "attemptsExhausted";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+    readonly closed: {
+      readonly type: "final";
+    };
+  };
+}>;
+//#endregion
+//#region src/modules/document-capture/documentCaptureActor.d.ts
+type CreateDocumentCaptureActorOptions = {
+  config: DocumentCaptureConfig;
+};
+//#endregion
+//#region src/modules/document-capture/documentCaptureManager.d.ts
+type DocumentCaptureTutorialState = {
+  status: 'tutorial';
+  title: string | undefined;
+  text: string | undefined;
+  allowSkipDocumentCapture: boolean;
+  captureMode: 'file' | 'camera';
+  error: DocumentCaptureErrorCode | undefined;
+  pageNumber: number;
+};
+type DocumentCaptureInitializingCameraState = {
+  status: 'initializingCamera';
+};
+type DocumentCaptureCapturingState = {
+  status: 'capturing';
+  stream: MediaStream | undefined;
+  captureMode: 'file' | 'camera';
+  error: DocumentCaptureErrorCode | undefined;
+  pageNumber: number;
+};
+type DocumentCapturePreviewState = {
+  status: 'preview';
+  imageBase64: string;
+  fileType: string;
+  fileName: string;
+};
+type DocumentCaptureUploadingState = {
+  status: 'uploading';
+  progress: number;
+  imageBase64: string;
+  fileType: string;
+  fileName: string;
+};
+type DocumentCaptureSuccessState = {
+  status: 'success';
+  imageBase64: string;
+  fileType: string;
+  fileName: string;
+  pendingNextPage: boolean;
+};
+type DocumentCaptureFailureState = {
+  status: 'failure';
+  error: DocumentCaptureErrorCode;
+  attemptsRemaining: number;
+};
+type DocumentCaptureFinishedState = {
+  status: 'finished';
+};
+type DocumentCaptureClosedState = {
+  status: 'closed';
+};
+type DocumentCaptureState = DocumentCaptureTutorialState | DocumentCaptureInitializingCameraState | DocumentCaptureCapturingState | DocumentCapturePreviewState | DocumentCaptureUploadingState | DocumentCaptureSuccessState | DocumentCaptureFailureState | DocumentCaptureFinishedState | DocumentCaptureClosedState;
+declare function createDocumentCaptureManager(options: CreateDocumentCaptureActorOptions): Manager<DocumentCaptureState> & {
+  capture(): void;
+  setFile(file: File, imageBase64: string): void;
+  accept(): void;
+  retake(): void;
+  retry(): void;
+  continue(): void;
+  skip(): void;
+  close(): void;
+};
+type DocumentCaptureManager = ReturnType<typeof createDocumentCaptureManager>;
+//#endregion
+export { DOCUMENT_CAPTURE_ERROR_CODES, type DocumentCaptureConfig, type DocumentCaptureErrorCode, type DocumentCaptureManager, type DocumentCaptureState, type DocumentType, createDocumentCaptureManager, documentCaptureMachine };