@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/idVerificationManager-BB4Pj_N6.d.ts

@@ -0,0 +1,197 @@
+import { A as StateMachine, C as StateValue, D as PromiseActorLogic, a as ActorRefFromLogic, b as RequiredActorOptions, c as AnyEventObject, g as IsNotNever, h as InputFrom, i as ActorRefFrom, k as MachineSnapshot, m as GetConcreteByKey, o as AnyActorLogic, p as EventObject, r as ActorRef, s as AnyActorRef, u as ConditionalRequired, v as MetaObject, x as RequiredLogicInput, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
+import "./StateMachine-EDpYWy0i.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.js";
+//#region src/modules/id-verification/types.d.ts
+type IdVerificationConfig = {
+  /** When true, verify the second captured ID via `/omni/process/second-id`. */
+  isSecondId?: boolean;
+  /**
+   * Queue name forwarded as a query parameter. Always sent (default empty
+   * string) so the request shape matches the legacy `/omni/process/id?queueName=`
+   * call that returns 200 today.
+   */
+  queueName?: string;
+  /**
+   * Workflow engine writes the rank into the module configuration when one
+   * `ID` node represents the second ID. When set to `'SECOND_ID'` the
+   * verification routes to the second-id endpoint even without an explicit
+   * `isSecondId` flag.
+   */
+  idRank?: 'FIRST_ID' | 'SECOND_ID' | 'THIRD_ID';
+};
+type ProcessIdResponse = {
+  isDocumentExpired: boolean;
+};
+//#endregion
+//#region src/modules/id-verification/idVerificationStateMachine.d.ts
+type IdVerificationContext = {
+  config: IdVerificationConfig;
+  isSecondId: boolean;
+};
+type IdVerificationInput = {
+  config: IdVerificationConfig;
+};
+declare const idVerificationMachine: StateMachine<IdVerificationContext, {
+  type: "LOAD";
+} | {
+  type: "CONTINUE";
+}, {
+  [x: string]: ActorRefFromLogic<PromiseActorLogic<ProcessIdResponse, {
+    isSecondId: boolean;
+    queueName: string;
+  }, EventObject>> | undefined;
+}, {
+  src: "processId";
+  logic: PromiseActorLogic<ProcessIdResponse, {
+    isSecondId: boolean;
+    queueName: string;
+  }, EventObject>;
+  id: string | undefined;
+}, never, {
+  type: "isDocumentExpired";
+  params: unknown;
+}, never, "idle" | "processing" | "finished" | "expired", string, IdVerificationInput, NonReducibleUnknown, EventObject, MetaObject, {
+  readonly id: "idVerification";
+  readonly initial: "idle";
+  readonly context: ({ input }: {
+    spawn: {
+      <TSrc extends "processId">(logic: TSrc, ...[options]: {
+        src: "processId";
+        logic: PromiseActorLogic<ProcessIdResponse, {
+          isSecondId: boolean;
+          queueName: string;
+        }, EventObject>;
+        id: string | undefined;
+      } extends (infer T) ? T extends {
+        src: "processId";
+        logic: PromiseActorLogic<ProcessIdResponse, {
+          isSecondId: boolean;
+          queueName: string;
+        }, EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in RequiredActorOptions<T>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T>>> : never : never : never): ActorRefFromLogic<GetConcreteByKey<{
+        src: "processId";
+        logic: PromiseActorLogic<ProcessIdResponse, {
+          isSecondId: boolean;
+          queueName: string;
+        }, EventObject>;
+        id: string | undefined;
+      }, "src", TSrc>["logic"]>;
+      <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in RequiredLogicInput<TLogic>]: unknown; }) | undefined], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
+    };
+    input: IdVerificationInput;
+    self: ActorRef<MachineSnapshot<IdVerificationContext, {
+      type: "LOAD";
+    } | {
+      type: "CONTINUE";
+    }, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "CONTINUE";
+    }, AnyEventObject>;
+  }) => {
+    config: IdVerificationConfig;
+    isSecondId: boolean;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: "processing";
+      };
+    };
+    readonly processing: {
+      readonly invoke: {
+        readonly id: "processId";
+        readonly src: "processId";
+        readonly input: ({ context }: {
+          context: IdVerificationContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "CONTINUE";
+          };
+          self: ActorRef<MachineSnapshot<IdVerificationContext, {
+            type: "LOAD";
+          } | {
+            type: "CONTINUE";
+          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "CONTINUE";
+          }, AnyEventObject>;
+        }) => {
+          isSecondId: boolean;
+          queueName: string;
+        };
+        readonly onDone: readonly [{
+          readonly target: "expired";
+          readonly guard: "isDocumentExpired";
+        }, {
+          readonly target: "finished";
+        }];
+        readonly onError: {
+          readonly target: "finished";
+        };
+      };
+    };
+    readonly expired: {
+      readonly on: {
+        readonly CONTINUE: "finished";
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+  };
+}>;
+type IdVerificationMachine = typeof idVerificationMachine;
+//#endregion
+//#region src/modules/id-verification/idVerificationActor.d.ts
+type CreateIdVerificationActorOptions = {
+  config: IdVerificationConfig;
+};
+type IdVerificationActor = ActorRefFrom<IdVerificationMachine>;
+//#endregion
+//#region src/modules/id-verification/idVerificationManager.d.ts
+type IdVerificationIdleState = {
+  status: 'idle';
+};
+type IdVerificationProcessingState = {
+  status: 'processing';
+};
+type IdVerificationExpiredState = {
+  status: 'expired';
+};
+type IdVerificationFinishedState = {
+  status: 'finished';
+};
+type IdVerificationState = IdVerificationIdleState | IdVerificationProcessingState | IdVerificationExpiredState | IdVerificationFinishedState;
+declare function createIdVerificationManager(options: CreateIdVerificationActorOptions): Manager<IdVerificationState> & {
+  load(): void;
+  continue(): void;
+};
+/**
+ * Creates an id-verification manager from a pre-built actor.
+ * Use this when overriding the machine via `.provide()` for custom backends
+ * or for story-isolation testing.
+ */
+declare function createIdVerificationManagerFromActor(actor: IdVerificationActor): Manager<IdVerificationState> & {
+  load(): void;
+  continue(): void;
+};
+type IdVerificationManager = ReturnType<typeof createIdVerificationManager>;
+//#endregion
+export { IdVerificationActor as a, createIdVerificationManagerFromActor as i, IdVerificationState as n, idVerificationMachine as o, createIdVerificationManager as r, IdVerificationConfig as s, IdVerificationManager as t };

package/dist/idVerificationManager-CduNXhWd.esm.js

@@ -0,0 +1,51 @@
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CxfNJVZW.esm.js";
+import { c as createManager, o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { t as idVerificationMachine } from "./idVerificationStateMachine-GEQWUPU2.esm.js";
+//#region src/modules/id-verification/idVerificationActor.ts
+function createIdVerificationActor(options) {
+	return createActor(idVerificationMachine, { input: { config: options.config } }).start();
+}
+//#endregion
+//#region src/modules/id-verification/idVerificationManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("processing")) return { status: "processing" };
+	if (typedSnapshot.matches("expired")) return { status: "expired" };
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		continue() {
+			trackElementClicked?.("continue");
+			actor.send({ type: "CONTINUE" });
+		}
+	};
+}
+function createIdVerificationManager(options) {
+	return createManager({
+		actor: createIdVerificationActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.idVerification)
+	});
+}
+/**
+* Creates an id-verification manager from a pre-built actor.
+* Use this when overriding the machine via `.provide()` for custom backends
+* or for story-isolation testing.
+*/
+function createIdVerificationManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.idVerification)
+	});
+}
+//#endregion
+export { createIdVerificationManagerFromActor as n, createIdVerificationManager as t };

package/dist/{idVerificationStateMachine-DXN9WcdM.esm.js → idVerificationStateMachine-GEQWUPU2.esm.js}

@@ -1,7 +1,7 @@
-import { t as api } from "./api-DsbUi7TO.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import { a as fromPromise, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
-
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
 //#region src/modules/id-verification/idVerificationServices.ts
 /**
 * Submits the captured ID for backend verification. Wraps `POST /omni/process/id`
@@ -19,7 +19,6 @@ async function processId(input = {}, signal) {
 	if (!res.ok) throw new Error(`POST ${endpoint} failed: ${res.status} ${res.statusText}`);
 	return { isDocumentExpired: res.data?.isDocumentExpired ?? false };
 }
-
 //#endregion
 //#region src/modules/id-verification/idVerificationStateMachine.ts
 function deriveIsSecondId(config) {
@@ -66,6 +65,5 @@ const idVerificationMachine = setup({
 		finished: { type: "final" }
 	}
 });
-
 //#endregion
-export { idVerificationMachine as t };
+export { idVerificationMachine as t };

package/dist/identity-reuse.d.ts

@@ -1,5 +1,2 @@
-import "./StateMachine-D5WO6lHS.js";
-import "./Manager-goNPc_h_.js";
-import "./Actor-BwgmOPkb.js";
-import { c as identityReuseMachine, d as ReusableDocument, f as SubmitResponse, i as createIdentityReuseManagerFromActor, l as FetchDocumentsResponse, n as IdentityReuseState, o as SCAN_NEW_DOCUMENT, r as createIdentityReuseManager, s as SelectedDocumentId, t as IdentityReuseManager, u as IdentityReuseConfig } from "./identityReuseManager-CLVOYxcp.js";
+import { c as identityReuseMachine, d as ReusableDocument, f as SubmitResponse, i as createIdentityReuseManagerFromActor, l as FetchDocumentsResponse, n as IdentityReuseState, o as SCAN_NEW_DOCUMENT, r as createIdentityReuseManager, s as SelectedDocumentId, t as IdentityReuseManager, u as IdentityReuseConfig } from "./identityReuseManager-v2TH5g7e.js";
 export { type FetchDocumentsResponse, type IdentityReuseConfig, type IdentityReuseManager, type IdentityReuseState, type ReusableDocument, SCAN_NEW_DOCUMENT, type SelectedDocumentId, type SubmitResponse, createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };

package/dist/identity-reuse.esm.js

@@ -1,8 +1,3 @@
-import "./api-DsbUi7TO.esm.js";
-import "./events-1wxZ97yf.esm.js";
-import "./endpoints-CwrFQfW7.esm.js";
-import "./xstate.esm-nY3M5UYm.esm.js";
-import { n as identityReuseMachine, t as SCAN_NEW_DOCUMENT } from "./identityReuseStateMachine-Bp-zONoV.esm.js";
-import { n as createIdentityReuseManagerFromActor, t as createIdentityReuseManager } from "./identityReuseManager-LjkPvSQN.esm.js";
-
-export { SCAN_NEW_DOCUMENT, createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };
+import { n as identityReuseMachine, t as SCAN_NEW_DOCUMENT } from "./identityReuseStateMachine-AubRPhIi.esm.js";
+import { n as createIdentityReuseManagerFromActor, t as createIdentityReuseManager } from "./identityReuseManager-D5vXknnJ.esm.js";
+export { SCAN_NEW_DOCUMENT, createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };

package/dist/{identityReuseManager-LjkPvSQN.esm.js → identityReuseManager-D5vXknnJ.esm.js}

@@ -1,7 +1,6 @@
-import { n as eventModuleNames, s as createManagerInstrumentation } from "./events-1wxZ97yf.esm.js";
-import { l as createManager, s as createActor } from "./xstate.esm-nY3M5UYm.esm.js";
-import { n as identityReuseMachine } from "./identityReuseStateMachine-Bp-zONoV.esm.js";
-
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CxfNJVZW.esm.js";
+import { c as createManager, o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as identityReuseMachine } from "./identityReuseStateMachine-AubRPhIi.esm.js";
 //#region src/modules/identity-reuse/identityReuseActor.ts
 /**
 * Creates and starts an IdentityReuse actor.
@@ -11,7 +10,6 @@ import { n as identityReuseMachine } from "./identityReuseStateMachine-Bp-zONoV.
 function createIdentityReuseActor(options) {
 	return createActor(identityReuseMachine, { input: { config: options.config } }).start();
 }
-
 //#endregion
 //#region src/modules/identity-reuse/identityReuseManager.ts
 function mapState(snapshot) {
@@ -33,9 +31,17 @@ function mapState(snapshot) {
 }
 function createApi({ actor, trackElementClicked }) {
 	return {
+		/**
+		* Fetches reusable documents from the backend.
+		* Transitions from 'idle' to 'loading'.
+		*/
 		load() {
 			actor.send({ type: "LOAD" });
 		},
+		/**
+		* Selects a document by id, or the `'scanNew'` sentinel to indicate the
+		* user prefers to scan a new document instead of reusing one.
+		*/
 		chooseDocument(documentId) {
 			trackElementClicked?.("chooseDocument");
 			actor.send({
@@ -43,14 +49,26 @@ function createApi({ actor, trackElementClicked }) {
 				documentId
 			});
 		},
+		/**
+		* Confirms the current selection. If a document is selected, submits it
+		* for reuse; if the scan-new row is selected, finishes the module without
+		* submitting (orchestration will load the next node).
+		*/
 		submit() {
 			trackElementClicked?.("submit");
 			actor.send({ type: "SUBMIT" });
 		},
+		/**
+		* Skips identity reuse entirely. Finishes the module without submitting;
+		* orchestration moves on to the next node.
+		*/
 		skip() {
 			trackElementClicked?.("skip");
 			actor.send({ type: "SKIP" });
 		},
+		/**
+		* Retries loading documents after an error.
+		*/
 		retry() {
 			trackElementClicked?.("retry");
 			actor.send({ type: "RETRY" });
@@ -90,6 +108,5 @@ function createIdentityReuseManagerFromActor(actor) {
 		instrumentation: createManagerInstrumentation(eventModuleNames.identityReuse)
 	});
 }
-
 //#endregion
-export { createIdentityReuseManagerFromActor as n, createIdentityReuseManager as t };
+export { createIdentityReuseManagerFromActor as n, createIdentityReuseManager as t };

package/dist/{identityReuseManager-CLVOYxcp.d.ts → identityReuseManager-v2TH5g7e.d.ts}

@@ -1,9 +1,8 @@
-import { t as Manager } from "./Manager-goNPc_h_.js";
-import { t as ActorRefFrom } from "./Actor-BwgmOPkb.js";
-import * as xstate122 from "xstate";
-
+import { A as StateMachine, C as StateValue, D as PromiseActorLogic, a as ActorRefFromLogic, b as RequiredActorOptions, c as AnyEventObject, g as IsNotNever, h as InputFrom, i as ActorRefFrom, k as MachineSnapshot, m as GetConcreteByKey, o as AnyActorLogic, p as EventObject, r as ActorRef, s as AnyActorRef, u as ConditionalRequired, v as MetaObject, w as Values, x as RequiredLogicInput, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
+import "./StateMachine-EDpYWy0i.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.js";
 //#region src/modules/identity-reuse/types.d.ts
-
 /**
  * Configuration options for the IdentityReuse module.
  *
@@ -76,7 +75,7 @@ type IdentityReuseContext = {
 type IdentityReuseInput = {
   config: IdentityReuseConfig;
 };
-declare const identityReuseMachine: xstate122.StateMachine<IdentityReuseContext, {
+declare const identityReuseMachine: StateMachine<IdentityReuseContext, {
   type: "LOAD";
 } | {
   type: "DOCUMENT_CHOSEN";
@@ -88,36 +87,36 @@ declare const identityReuseMachine: xstate122.StateMachine<IdentityReuseContext,
 } | {
   type: "RETRY";
 }, {
-  [x: string]: xstate122.ActorRefFromLogic<xstate122.PromiseActorLogic<FetchDocumentsResponse, void, xstate122.EventObject>> | xstate122.ActorRefFromLogic<xstate122.PromiseActorLogic<SubmitResponse, SubmitParams, xstate122.EventObject>> | undefined;
-}, xstate122.Values<{
+  [x: string]: ActorRefFromLogic<PromiseActorLogic<FetchDocumentsResponse, void, EventObject>> | ActorRefFromLogic<PromiseActorLogic<SubmitResponse, SubmitParams, EventObject>> | undefined;
+}, Values<{
   fetchDocuments: {
     src: "fetchDocuments";
-    logic: xstate122.PromiseActorLogic<FetchDocumentsResponse, void, xstate122.EventObject>;
+    logic: PromiseActorLogic<FetchDocumentsResponse, void, EventObject>;
     id: string | undefined;
   };
   submitDocument: {
     src: "submitDocument";
-    logic: xstate122.PromiseActorLogic<SubmitResponse, SubmitParams, xstate122.EventObject>;
+    logic: PromiseActorLogic<SubmitResponse, SubmitParams, EventObject>;
     id: string | undefined;
   };
-}>, xstate122.Values<{
+}>, Values<{
   setDocuments: {
     type: "setDocuments";
-    params: xstate122.NonReducibleUnknown;
+    params: NonReducibleUnknown;
   };
   setError: {
     type: "setError";
-    params: xstate122.NonReducibleUnknown;
+    params: NonReducibleUnknown;
   };
   clearError: {
     type: "clearError";
-    params: xstate122.NonReducibleUnknown;
+    params: NonReducibleUnknown;
   };
   setSelectedDocument: {
     type: "setSelectedDocument";
-    params: xstate122.NonReducibleUnknown;
+    params: NonReducibleUnknown;
   };
-}>, xstate122.Values<{
+}>, Values<{
   hasDocuments: {
     type: "hasDocuments";
     params: unknown;
@@ -126,64 +125,62 @@ declare const identityReuseMachine: xstate122.StateMachine<IdentityReuseContext,
     type: "hasSelection";
     params: unknown;
   };
-}>, never, "error" | "idle" | "finished" | "loading" | "documentsFound" | "submitting", string, IdentityReuseInput, xstate122.NonReducibleUnknown, xstate122.EventObject, xstate122.MetaObject, {
+}>, never, "error" | "idle" | "finished" | "submitting" | "loading" | "documentsFound", string, IdentityReuseInput, NonReducibleUnknown, EventObject, MetaObject, {
   readonly id: "identityReuse";
   readonly initial: "idle";
-  readonly context: ({
-    input
-  }: {
+  readonly context: ({ input }: {
     spawn: {
       <TSrc extends "fetchDocuments" | "submitDocument">(logic: TSrc, ...[options]: ({
         src: "fetchDocuments";
-        logic: xstate122.PromiseActorLogic<FetchDocumentsResponse, void, xstate122.EventObject>;
+        logic: PromiseActorLogic<FetchDocumentsResponse, void, EventObject>;
         id: string | undefined;
-      } extends infer T ? T extends {
+      } extends (infer T) ? T extends {
         src: "fetchDocuments";
-        logic: xstate122.PromiseActorLogic<FetchDocumentsResponse, void, xstate122.EventObject>;
+        logic: PromiseActorLogic<FetchDocumentsResponse, void, EventObject>;
         id: string | undefined;
       } ? T extends {
         src: TSrc;
-      } ? xstate122.ConditionalRequired<[options?: ({
+      } ? ConditionalRequired<[options?: ({
         id?: T["id"] | undefined;
         systemId?: string;
-        input?: xstate122.InputFrom<T["logic"]> | undefined;
+        input?: InputFrom<T["logic"]> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate122.RequiredActorOptions<T>]: unknown }) | undefined], xstate122.IsNotNever<xstate122.RequiredActorOptions<T>>> : never : never : never) | ({
+      } & { [K in RequiredActorOptions<T>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T>>> : never : never : never) | ({
         src: "submitDocument";
-        logic: xstate122.PromiseActorLogic<SubmitResponse, SubmitParams, xstate122.EventObject>;
+        logic: PromiseActorLogic<SubmitResponse, SubmitParams, EventObject>;
         id: string | undefined;
-      } extends infer T_1 ? T_1 extends {
+      } extends (infer T_1) ? T_1 extends {
         src: "submitDocument";
-        logic: xstate122.PromiseActorLogic<SubmitResponse, SubmitParams, xstate122.EventObject>;
+        logic: PromiseActorLogic<SubmitResponse, SubmitParams, EventObject>;
         id: string | undefined;
       } ? T_1 extends {
         src: TSrc;
-      } ? xstate122.ConditionalRequired<[options?: ({
+      } ? ConditionalRequired<[options?: ({
         id?: T_1["id"] | undefined;
         systemId?: string;
-        input?: xstate122.InputFrom<T_1["logic"]> | undefined;
+        input?: InputFrom<T_1["logic"]> | undefined;
         syncSnapshot?: boolean;
-      } & { [K_1 in xstate122.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate122.IsNotNever<xstate122.RequiredActorOptions<T_1>>> : never : never : never)): xstate122.ActorRefFromLogic<xstate122.GetConcreteByKey<xstate122.Values<{
+      } & { [K_1 in RequiredActorOptions<T_1>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T_1>>> : never : never : never)): ActorRefFromLogic<GetConcreteByKey<Values<{
         fetchDocuments: {
           src: "fetchDocuments";
-          logic: xstate122.PromiseActorLogic<FetchDocumentsResponse, void, xstate122.EventObject>;
+          logic: PromiseActorLogic<FetchDocumentsResponse, void, EventObject>;
           id: string | undefined;
         };
         submitDocument: {
           src: "submitDocument";
-          logic: xstate122.PromiseActorLogic<SubmitResponse, SubmitParams, xstate122.EventObject>;
+          logic: PromiseActorLogic<SubmitResponse, SubmitParams, EventObject>;
           id: string | undefined;
         };
       }>, "src", TSrc>["logic"]>;
-      <TLogic extends xstate122.AnyActorLogic>(src: TLogic, ...[options]: xstate122.ConditionalRequired<[options?: ({
+      <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: ({
         id?: never;
         systemId?: string;
-        input?: xstate122.InputFrom<TLogic> | undefined;
+        input?: InputFrom<TLogic> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate122.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate122.IsNotNever<xstate122.RequiredLogicInput<TLogic>>>): xstate122.ActorRefFromLogic<TLogic>;
+      } & { [K in RequiredLogicInput<TLogic>]: unknown; }) | undefined], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
     };
     input: IdentityReuseInput;
-    self: xstate122.ActorRef<xstate122.MachineSnapshot<IdentityReuseContext, {
+    self: ActorRef<MachineSnapshot<IdentityReuseContext, {
       type: "LOAD";
     } | {
       type: "DOCUMENT_CHOSEN";
@@ -194,7 +191,7 @@ declare const identityReuseMachine: xstate122.StateMachine<IdentityReuseContext,
       type: "SKIP";
     } | {
       type: "RETRY";
-    }, Record<string, xstate122.AnyActorRef | undefined>, xstate122.StateValue, string, unknown, any, any>, {
+    }, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, {
       type: "LOAD";
     } | {
       type: "DOCUMENT_CHOSEN";
@@ -205,7 +202,7 @@ declare const identityReuseMachine: xstate122.StateMachine<IdentityReuseContext,
       type: "SKIP";
     } | {
       type: "RETRY";
-    }, xstate122.AnyEventObject>;
+    }, AnyEventObject>;
   }) => {
     config: IdentityReuseConfig;
     documents: never[];
@@ -255,9 +252,7 @@ declare const identityReuseMachine: xstate122.StateMachine<IdentityReuseContext,
       readonly invoke: {
         readonly id: "submitDocument";
         readonly src: "submitDocument";
-        readonly input: ({
-          context
-        }: {
+        readonly input: ({ context }: {
           context: IdentityReuseContext;
         }) => SubmitParams;
         readonly onDone: {

package/dist/{identityReuseStateMachine-Bp-zONoV.esm.js → identityReuseStateMachine-AubRPhIi.esm.js}

@@ -1,7 +1,7 @@
-import { t as api } from "./api-DsbUi7TO.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
-
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
 //#region src/modules/identity-reuse/identityReuseServices.ts
 function lowerFirstLetter(value) {
 	if (!value) return value;
@@ -42,7 +42,6 @@ async function submitDocument(params, signal) {
 	if (!res.ok) throw new Error(`POST ${endpoints.identityReuseSubmit} failed: ${res.status} ${res.statusText} — ${JSON.stringify(res.data)}`);
 	return res.data;
 }
-
 //#endregion
 //#region src/modules/identity-reuse/identityReuseStateMachine.ts
 /**
@@ -51,7 +50,7 @@ async function submitDocument(params, signal) {
 */
 const SCAN_NEW_DOCUMENT = "scanNew";
 function deriveSubmitParams(selectedDocumentId) {
-	if (selectedDocumentId === SCAN_NEW_DOCUMENT || !selectedDocumentId) return { accepted: false };
+	if (selectedDocumentId === "scanNew" || !selectedDocumentId) return { accepted: false };
 	return {
 		accepted: true,
 		documentId: selectedDocumentId
@@ -143,6 +142,5 @@ const identityReuseMachine = setup({
 		} }
 	}
 });
-
 //#endregion
-export { identityReuseMachine as n, SCAN_NEW_DOCUMENT as t };
+export { identityReuseMachine as n, SCAN_NEW_DOCUMENT as t };

package/dist/index-B8weJxmL.d.ts

@@ -0,0 +1 @@
+import "./Manager-CQQ99QOI.js";