@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/document-capture.d.ts

@@ -0,0 +1,906 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+import { t as CameraStream } from "./camera-DBSxa6ML.js";
+import * as xstate151 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";
+};
+declare const DOCUMENT_CAPTURE_FINALIZE_ERROR_CODES: {
+  readonly UNEXPECTED_ERROR: "UNEXPECTED_ERROR";
+};
+type DocumentCaptureErrorCode = (typeof DOCUMENT_CAPTURE_ERROR_CODES)[keyof typeof DOCUMENT_CAPTURE_ERROR_CODES];
+type DocumentCaptureFinalizeErrorCode = (typeof DOCUMENT_CAPTURE_FINALIZE_ERROR_CODES)[keyof typeof DOCUMENT_CAPTURE_FINALIZE_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;
+  /** Backend ADDRESS config field. Inverted: `disableSkipPoa: true` → skip disabled. If both are set, `allowSkipDocumentCapture` takes precedence. */
+  disableSkipPoa?: 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' | 'OPTIONAL_PAGE_CAPTURE' | 'SUCCESS';
+};
+type FinalizeDocumentResponse = {
+  status?: string;
+  success?: boolean;
+};
+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 DocumentCaptureNextPageType = 'none' | 'required' | 'optional';
+type DocumentCaptureContext = {
+  config: DocumentCaptureResolvedConfig;
+  stream: CameraStream | undefined;
+  capturedDocument: CapturedDocument | undefined;
+  captureMethod: 'camera' | 'file' | 'gallery' | undefined;
+  progress: number;
+  error: DocumentCaptureErrorCode | DocumentCaptureFinalizeErrorCode | undefined;
+  attemptsRemaining: number;
+  pageNumber: number;
+  nextPageType: DocumentCaptureNextPageType;
+};
+type DocumentCaptureInput = {
+  config: DocumentCaptureConfig;
+};
+//#endregion
+//#region src/modules/document-capture/documentCaptureStateMachine.d.ts
+declare const documentCaptureMachine: xstate151.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: "NEXT_PAGE_CAMERA";
+} | {
+  type: "NEXT_PAGE_PHOTO_LIBRARY";
+} | {
+  type: "ALL_PAGES_CAPTURED";
+} | {
+  type: "SKIP";
+} | {
+  type: "CLOSE";
+}, {
+  [x: string]: xstate151.ActorRefFromLogic<xstate151.PromiseActorLogic<DocumentUploadResponse, {
+    capturedDocument: NonNullable<DocumentCaptureContext["capturedDocument"]>;
+    processingType: string;
+    onProgress: (progress: number) => void;
+  }, xstate151.EventObject>> | xstate151.ActorRefFromLogic<xstate151.PromiseActorLogic<MediaStream, void, xstate151.EventObject>> | xstate151.ActorRefFromLogic<xstate151.PromiseActorLogic<FinalizeDocumentResponse, {
+    processingType: string;
+  }, xstate151.EventObject>> | undefined;
+}, xstate151.Values<{
+  uploadDocument: {
+    src: "uploadDocument";
+    logic: xstate151.PromiseActorLogic<DocumentUploadResponse, {
+      capturedDocument: NonNullable<DocumentCaptureContext["capturedDocument"]>;
+      processingType: string;
+      onProgress: (progress: number) => void;
+    }, xstate151.EventObject>;
+    id: string | undefined;
+  };
+  initCamera: {
+    src: "initCamera";
+    logic: xstate151.PromiseActorLogic<MediaStream, void, xstate151.EventObject>;
+    id: string | undefined;
+  };
+  finalizeDocumentRequest: {
+    src: "finalizeDocumentRequest";
+    logic: xstate151.PromiseActorLogic<FinalizeDocumentResponse, {
+      processingType: string;
+    }, xstate151.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate151.Values<{
+  setStream: {
+    type: "setStream";
+    params: xstate151.NonReducibleUnknown;
+  };
+  setCapturedDocument: {
+    type: "setCapturedDocument";
+    params: xstate151.NonReducibleUnknown;
+  };
+  setFileTooLargeError: {
+    type: "setFileTooLargeError";
+    params: xstate151.NonReducibleUnknown;
+  };
+  setProgress: {
+    type: "setProgress";
+    params: xstate151.NonReducibleUnknown;
+  };
+  setUploadError: {
+    type: "setUploadError";
+    params: xstate151.NonReducibleUnknown;
+  };
+  setFinalizeError: {
+    type: "setFinalizeError";
+    params: xstate151.NonReducibleUnknown;
+  };
+  decrementAttemptsRemaining: {
+    type: "decrementAttemptsRemaining";
+    params: xstate151.NonReducibleUnknown;
+  };
+  setCaptureMethodFile: {
+    type: "setCaptureMethodFile";
+    params: xstate151.NonReducibleUnknown;
+  };
+  setCaptureMethodCamera: {
+    type: "setCaptureMethodCamera";
+    params: xstate151.NonReducibleUnknown;
+  };
+  setCaptureMethodGallery: {
+    type: "setCaptureMethodGallery";
+    params: xstate151.NonReducibleUnknown;
+  };
+  clearCapturedDocument: {
+    type: "clearCapturedDocument";
+    params: xstate151.NonReducibleUnknown;
+  };
+  resetPageNumber: {
+    type: "resetPageNumber";
+    params: xstate151.NonReducibleUnknown;
+  };
+  clearCapturedDocumentGalleryRetake: {
+    type: "clearCapturedDocumentGalleryRetake";
+    params: xstate151.NonReducibleUnknown;
+  };
+  setNextPageType: {
+    type: "setNextPageType";
+    params: xstate151.NonReducibleUnknown;
+  };
+  clearForNextPage: {
+    type: "clearForNextPage";
+    params: xstate151.NonReducibleUnknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: xstate151.NonReducibleUnknown;
+  };
+  resetProgress: {
+    type: "resetProgress";
+    params: xstate151.NonReducibleUnknown;
+  };
+  stopStream: {
+    type: "stopStream";
+    params: xstate151.NonReducibleUnknown;
+  };
+}>, xstate151.Values<{
+  allowSkip: {
+    type: "allowSkip";
+    params: unknown;
+  };
+  fileSizeOk: {
+    type: "fileSizeOk";
+    params: unknown;
+  };
+  canRetry: {
+    type: "canRetry";
+    params: unknown;
+  };
+  attemptsExhausted: {
+    type: "attemptsExhausted";
+    params: unknown;
+  };
+  isCameraMode: {
+    type: "isCameraMode";
+    params: unknown;
+  };
+  isCaptureMethodCamera: {
+    type: "isCaptureMethodCamera";
+    params: unknown;
+  };
+  isCaptureMethodGallery: {
+    type: "isCaptureMethodGallery";
+    params: unknown;
+  };
+  isCaptureMethodFile: {
+    type: "isCaptureMethodFile";
+    params: unknown;
+  };
+  isNextPageOptional: {
+    type: "isNextPageOptional";
+    params: unknown;
+  };
+  isNextPageRequired: {
+    type: "isNextPageRequired";
+    params: unknown;
+  };
+  canFinalizeOptionalPages: {
+    type: "canFinalizeOptionalPages";
+    params: unknown;
+  };
+  fileSizeOkForGallery: {
+    type: "fileSizeOkForGallery";
+    params: unknown;
+  };
+  fileSizeOkForNonGallery: {
+    type: "fileSizeOkForNonGallery";
+    params: unknown;
+  };
+}>, never, "uploading" | "closed" | "success" | "finished" | "initCamera" | "tutorial" | "capturing" | "preview" | "failure" | "nextPage" | "finalizing", string, DocumentCaptureInput, xstate151.NonReducibleUnknown, xstate151.EventObject, xstate151.MetaObject, {
+  readonly id: "documentCapture";
+  readonly initial: "tutorial";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "uploadDocument" | "initCamera" | "finalizeDocumentRequest">(logic: TSrc, ...[options]: ({
+        src: "uploadDocument";
+        logic: xstate151.PromiseActorLogic<DocumentUploadResponse, {
+          capturedDocument: NonNullable<DocumentCaptureContext["capturedDocument"]>;
+          processingType: string;
+          onProgress: (progress: number) => void;
+        }, xstate151.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "uploadDocument";
+        logic: xstate151.PromiseActorLogic<DocumentUploadResponse, {
+          capturedDocument: NonNullable<DocumentCaptureContext["capturedDocument"]>;
+          processingType: string;
+          onProgress: (progress: number) => void;
+        }, xstate151.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate151.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate151.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate151.RequiredActorOptions<T>]: unknown }) | undefined], xstate151.IsNotNever<xstate151.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "initCamera";
+        logic: xstate151.PromiseActorLogic<MediaStream, void, xstate151.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "initCamera";
+        logic: xstate151.PromiseActorLogic<MediaStream, void, xstate151.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate151.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate151.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate151.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate151.IsNotNever<xstate151.RequiredActorOptions<T_1>>> : never : never : never) | ({
+        src: "finalizeDocumentRequest";
+        logic: xstate151.PromiseActorLogic<FinalizeDocumentResponse, {
+          processingType: string;
+        }, xstate151.EventObject>;
+        id: string | undefined;
+      } extends infer T_2 ? T_2 extends {
+        src: "finalizeDocumentRequest";
+        logic: xstate151.PromiseActorLogic<FinalizeDocumentResponse, {
+          processingType: string;
+        }, xstate151.EventObject>;
+        id: string | undefined;
+      } ? T_2 extends {
+        src: TSrc;
+      } ? xstate151.ConditionalRequired<[options?: ({
+        id?: T_2["id"] | undefined;
+        systemId?: string;
+        input?: xstate151.InputFrom<T_2["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_2 in xstate151.RequiredActorOptions<T_2>]: unknown }) | undefined], xstate151.IsNotNever<xstate151.RequiredActorOptions<T_2>>> : never : never : never)): xstate151.ActorRefFromLogic<xstate151.GetConcreteByKey<xstate151.Values<{
+        uploadDocument: {
+          src: "uploadDocument";
+          logic: xstate151.PromiseActorLogic<DocumentUploadResponse, {
+            capturedDocument: NonNullable<DocumentCaptureContext["capturedDocument"]>;
+            processingType: string;
+            onProgress: (progress: number) => void;
+          }, xstate151.EventObject>;
+          id: string | undefined;
+        };
+        initCamera: {
+          src: "initCamera";
+          logic: xstate151.PromiseActorLogic<MediaStream, void, xstate151.EventObject>;
+          id: string | undefined;
+        };
+        finalizeDocumentRequest: {
+          src: "finalizeDocumentRequest";
+          logic: xstate151.PromiseActorLogic<FinalizeDocumentResponse, {
+            processingType: string;
+          }, xstate151.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate151.AnyActorLogic>(src: TLogic, ...[options]: xstate151.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate151.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate151.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate151.IsNotNever<xstate151.RequiredLogicInput<TLogic>>>): xstate151.ActorRefFromLogic<TLogic>;
+    };
+    input: DocumentCaptureInput;
+    self: xstate151.ActorRef<xstate151.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: "NEXT_PAGE_CAMERA";
+    } | {
+      type: "NEXT_PAGE_PHOTO_LIBRARY";
+    } | {
+      type: "ALL_PAGES_CAPTURED";
+    } | {
+      type: "SKIP";
+    } | {
+      type: "CLOSE";
+    }, Record<string, xstate151.AnyActorRef | undefined>, xstate151.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: "NEXT_PAGE_CAMERA";
+    } | {
+      type: "NEXT_PAGE_PHOTO_LIBRARY";
+    } | {
+      type: "ALL_PAGES_CAPTURED";
+    } | {
+      type: "SKIP";
+    } | {
+      type: "CLOSE";
+    }, xstate151.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;
+    nextPageType: "none";
+  };
+  readonly states: {
+    readonly tutorial: {
+      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 on: {
+        readonly FILE_SELECTED: readonly [{
+          readonly target: "preview";
+          readonly guard: "fileSizeOkForGallery";
+          readonly actions: "setCapturedDocument";
+        }, {
+          readonly target: "preview";
+          readonly guard: "fileSizeOkForNonGallery";
+          readonly actions: readonly ["setCapturedDocument", "setCaptureMethodCamera"];
+        }, {
+          readonly target: "capturing";
+          readonly actions: "setFileTooLargeError";
+        }];
+        readonly CLOSE: {
+          readonly target: "closed";
+          readonly actions: "stopStream";
+        };
+      };
+    };
+    readonly preview: {
+      readonly on: {
+        readonly ACCEPT: {
+          readonly target: "uploading";
+          readonly actions: "resetProgress";
+        };
+        readonly RETAKE: readonly [{
+          readonly target: "tutorial";
+          readonly guard: "isCaptureMethodFile";
+          readonly actions: "clearCapturedDocument";
+        }, {
+          readonly target: "capturing";
+          readonly guard: "isCaptureMethodGallery";
+          readonly actions: "clearCapturedDocumentGalleryRetake";
+        }, {
+          readonly target: "capturing";
+          readonly actions: "clearCapturedDocument";
+        }];
+        readonly CLOSE: {
+          readonly target: "closed";
+          readonly actions: "stopStream";
+        };
+      };
+    };
+    readonly uploading: {
+      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: "NEXT_PAGE_CAMERA";
+          } | {
+            type: "NEXT_PAGE_PHOTO_LIBRARY";
+          } | {
+            type: "ALL_PAGES_CAPTURED";
+          } | {
+            type: "SKIP";
+          } | {
+            type: "CLOSE";
+          };
+          self: xstate151.ActorRef<xstate151.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: "NEXT_PAGE_CAMERA";
+          } | {
+            type: "NEXT_PAGE_PHOTO_LIBRARY";
+          } | {
+            type: "ALL_PAGES_CAPTURED";
+          } | {
+            type: "SKIP";
+          } | {
+            type: "CLOSE";
+          }, Record<string, xstate151.AnyActorRef>, xstate151.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: "NEXT_PAGE_CAMERA";
+          } | {
+            type: "NEXT_PAGE_PHOTO_LIBRARY";
+          } | {
+            type: "ALL_PAGES_CAPTURED";
+          } | {
+            type: "SKIP";
+          } | {
+            type: "CLOSE";
+          }, xstate151.AnyEventObject>;
+        }) => {
+          capturedDocument: CapturedDocument;
+          processingType: DocumentType;
+          onProgress: (progress: number) => void;
+        };
+        readonly onDone: {
+          readonly target: "success";
+          readonly actions: readonly ["setNextPageType", "stopStream"];
+        };
+        readonly onError: {
+          readonly target: "failure";
+          readonly actions: readonly ["setUploadError", "decrementAttemptsRemaining", "stopStream"];
+        };
+      };
+      readonly on: {
+        readonly UPLOAD_PROGRESS: {
+          readonly actions: "setProgress";
+        };
+      };
+    };
+    readonly success: {
+      readonly on: {
+        readonly CONTINUE: readonly [{
+          readonly target: "nextPage";
+          readonly guard: "isNextPageOptional";
+        }, {
+          readonly target: "nextPage";
+          readonly guard: "isNextPageRequired";
+        }, {
+          readonly target: "finished";
+        }];
+        readonly CLOSE: {
+          readonly target: "closed";
+        };
+      };
+    };
+    readonly nextPage: {
+      readonly on: {
+        readonly NEXT_PAGE_CAMERA: {
+          readonly target: "initCamera";
+          readonly actions: readonly ["clearForNextPage", "setCaptureMethodCamera"];
+        };
+        readonly NEXT_PAGE_PHOTO_LIBRARY: {
+          readonly target: "capturing";
+          readonly actions: readonly ["clearForNextPage", "setCaptureMethodGallery"];
+        };
+        readonly ALL_PAGES_CAPTURED: readonly [{
+          readonly target: "finalizing";
+          readonly guard: "canFinalizeOptionalPages";
+        }, {
+          readonly target: "finished";
+        }];
+        readonly CLOSE: {
+          readonly target: "closed";
+        };
+      };
+    };
+    readonly finalizing: {
+      readonly invoke: {
+        readonly id: "finalizeDocument";
+        readonly src: "finalizeDocumentRequest";
+        readonly input: ({
+          context
+        }: {
+          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: "NEXT_PAGE_CAMERA";
+          } | {
+            type: "NEXT_PAGE_PHOTO_LIBRARY";
+          } | {
+            type: "ALL_PAGES_CAPTURED";
+          } | {
+            type: "SKIP";
+          } | {
+            type: "CLOSE";
+          };
+          self: xstate151.ActorRef<xstate151.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: "NEXT_PAGE_CAMERA";
+          } | {
+            type: "NEXT_PAGE_PHOTO_LIBRARY";
+          } | {
+            type: "ALL_PAGES_CAPTURED";
+          } | {
+            type: "SKIP";
+          } | {
+            type: "CLOSE";
+          }, Record<string, xstate151.AnyActorRef>, xstate151.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: "NEXT_PAGE_CAMERA";
+          } | {
+            type: "NEXT_PAGE_PHOTO_LIBRARY";
+          } | {
+            type: "ALL_PAGES_CAPTURED";
+          } | {
+            type: "SKIP";
+          } | {
+            type: "CLOSE";
+          }, xstate151.AnyEventObject>;
+        }) => {
+          processingType: DocumentType;
+        };
+        readonly onDone: {
+          readonly target: "finished";
+        };
+        readonly onError: {
+          readonly target: "failure";
+          readonly actions: readonly ["setFinalizeError", "decrementAttemptsRemaining"];
+        };
+      };
+    };
+    readonly failure: {
+      readonly on: {
+        readonly RETRY: {
+          readonly target: "tutorial";
+          readonly guard: "canRetry";
+          readonly actions: readonly ["clearError", "clearCapturedDocument", "resetPageNumber"];
+        };
+        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';
+  captureMethod: 'camera' | 'file' | 'gallery' | undefined;
+  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;
+  nextPageType: DocumentCaptureNextPageType;
+};
+type DocumentCaptureFailureState = {
+  status: 'failure';
+  error: DocumentCaptureErrorCode;
+  attemptsRemaining: number;
+};
+type DocumentCaptureFinishedState = {
+  status: 'finished';
+};
+type DocumentCaptureClosedState = {
+  status: 'closed';
+};
+type DocumentCaptureNextPageState = {
+  status: 'nextPage';
+  imageBase64: string;
+  fileType: string;
+  fileName: string;
+  pageNumber: number;
+  nextPageType: Exclude<DocumentCaptureNextPageType, 'none'>;
+  captureMode: 'file' | 'camera';
+};
+/** Confirming optional multi-page capture with the backend (short-lived). */
+type DocumentCaptureFinalizingState = {
+  status: 'finalizing';
+};
+type DocumentCaptureState = DocumentCaptureTutorialState | DocumentCaptureInitializingCameraState | DocumentCaptureCapturingState | DocumentCapturePreviewState | DocumentCaptureUploadingState | DocumentCaptureSuccessState | DocumentCaptureFailureState | DocumentCaptureFinishedState | DocumentCaptureClosedState | DocumentCaptureNextPageState | DocumentCaptureFinalizingState;
+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;
+  captureNextPageFromCamera(): void;
+  captureNextPageFromFile(): void;
+  finishPageCapture(): void;
+};
+type DocumentCaptureManager = ReturnType<typeof createDocumentCaptureManager>;
+//#endregion
+export { DOCUMENT_CAPTURE_ERROR_CODES, type DocumentCaptureConfig, type DocumentCaptureErrorCode, type DocumentCaptureManager, type DocumentCaptureNextPageType, type DocumentCaptureState, type DocumentType, createDocumentCaptureManager, documentCaptureMachine };