@incodetech/core 2.3.2 → 2.4.0-rc.0

package/dist/{idOcrManager-CFlDwUvN.d.ts → idOcrManager-BTdHlJ9D.d.ts}

@@ -1,7 +1,6 @@
 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";
+import { t as Manager } from "./Manager-C9T5amUN.js";
+import "./Actor-DpTj5PFb.js";
 import { a as UpdateOcrResponse, i as UpdateOcrDataParams, n as OcrData, t as IdOcrConfig } from "./types-CJ7Yl9K-.js";
 //#region src/modules/id-ocr/idOcrStateMachine.d.ts
 type IdOcrOcrDocument = 'first' | 'second';

package/dist/{idOcrManager-ByWuQ4ej.esm.js → idOcrManager-DxoCesYP.esm.js}

@@ -1,6 +1,6 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
-import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { t as idOcrStateMachine } from "./idOcrStateMachine-Bt_abXQQ.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CAgFE-k3.esm.js";
+import { s as createActor, u as createManager } from "./xstate.esm-DSajW7CJ.esm.js";
+import { t as idOcrStateMachine } from "./idOcrStateMachine-kPn7DB2I.esm.js";
 //#region src/modules/id-ocr/idOcrActor.ts
 function createIdOcrActor(options) {
 	return createActor(idOcrStateMachine, { input: { config: options.config } }).start();

package/dist/{idOcrStateMachine-Bt_abXQQ.esm.js → idOcrStateMachine-kPn7DB2I.esm.js}

@@ -1,8 +1,8 @@
 import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
-import { i as assign, t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
-import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
+import { t as endpoints } from "./endpoints-DHzlkQNe.esm.js";
+import { i as assign, t as setup } from "./xstate.esm-DSajW7CJ.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-8Gzepa_A.esm.js";
 import { n as DateFormattingProvider, t as validateCPF } from "./cpf-uAZTPUBy.esm.js";
 //#region src/modules/id-ocr/idOcrUtils.ts
 const dateFormattingInstance$1 = new DateFormattingProvider();

package/dist/{idVerificationManager-BB4Pj_N6.d.ts → idVerificationManager-BJapZfpy.d.ts}

@@ -1,7 +1,6 @@
 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";
+import { t as Manager } from "./Manager-C9T5amUN.js";
+import "./Actor-DpTj5PFb.js";
 //#region src/modules/id-verification/types.d.ts
 type IdVerificationConfig = {
   /** When true, verify the second captured ID via `/omni/process/second-id`. */

package/dist/{idVerificationManager-DT42c77H.esm.js → idVerificationManager-CDhRUU5n.esm.js}

@@ -1,6 +1,6 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
-import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { t as idVerificationMachine } from "./idVerificationStateMachine-DbDVIh9t.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CAgFE-k3.esm.js";
+import { s as createActor, u as createManager } from "./xstate.esm-DSajW7CJ.esm.js";
+import { t as idVerificationMachine } from "./idVerificationStateMachine-0HTVVxse.esm.js";
 //#region src/modules/id-verification/idVerificationActor.ts
 function createIdVerificationActor(options) {
 	return createActor(idVerificationMachine, { input: { config: options.config } }).start();

package/dist/{idVerificationStateMachine-DbDVIh9t.esm.js → idVerificationStateMachine-0HTVVxse.esm.js}

@@ -1,7 +1,7 @@
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
-import { t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
-import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
+import { t as endpoints } from "./endpoints-DHzlkQNe.esm.js";
+import { t as setup } from "./xstate.esm-DSajW7CJ.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-8Gzepa_A.esm.js";
 //#region src/modules/id-verification/idVerificationServices.ts
 /**
 * Submits the captured ID for backend verification. Wraps `POST /omni/process/id`

package/dist/identity-reuse.d.ts

@@ -1,2 +1,2 @@
-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-BXEBBI3N.js";
-export { type FetchDocumentsResponse, type IdentityReuseConfig, type IdentityReuseManager, type IdentityReuseState, type ReusableDocument, SCAN_NEW_DOCUMENT, type SelectedDocumentId, type SubmitResponse, createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };
+import { c as identityReuseMachine, d as IdentityReuseConfig, f as ReusableDocument, i as createIdentityReuseManagerFromActor, l as FetchCompanyNameResponse, n as IdentityReuseState, o as SCAN_NEW_DOCUMENT, p as SubmitResponse, r as createIdentityReuseManager, s as SelectedDocumentId, t as IdentityReuseManager, u as FetchDocumentsResponse } from "./identityReuseManager-ooAbp6Kc.js";
+export { type FetchCompanyNameResponse, 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,3 +1,3 @@
-import { n as identityReuseMachine, t as SCAN_NEW_DOCUMENT } from "./identityReuseStateMachine-BhAkuIra.esm.js";
-import { n as createIdentityReuseManagerFromActor, t as createIdentityReuseManager } from "./identityReuseManager-yG3acUrQ.esm.js";
+import { n as identityReuseMachine, t as SCAN_NEW_DOCUMENT } from "./identityReuseStateMachine-BrBUpfn5.esm.js";
+import { n as createIdentityReuseManagerFromActor, t as createIdentityReuseManager } from "./identityReuseManager-BleUi6TK.esm.js";
 export { SCAN_NEW_DOCUMENT, createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };

package/dist/{identityReuseManager-yG3acUrQ.esm.js → identityReuseManager-BleUi6TK.esm.js}

@@ -1,6 +1,6 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
-import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { n as identityReuseMachine } from "./identityReuseStateMachine-BhAkuIra.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CAgFE-k3.esm.js";
+import { s as createActor, u as createManager } from "./xstate.esm-DSajW7CJ.esm.js";
+import { n as identityReuseMachine } from "./identityReuseStateMachine-BrBUpfn5.esm.js";
 //#region src/modules/identity-reuse/identityReuseActor.ts
 /**
 * Creates and starts an IdentityReuse actor.
@@ -19,7 +19,8 @@ function mapState(snapshot) {
 	if (snapshot.matches("documentsFound")) return {
 		status: "documentsFound",
 		documents: context.documents,
-		selectedDocumentId: context.selectedDocumentId
+		selectedDocumentId: context.selectedDocumentId,
+		...context.companyName !== void 0 && { companyName: context.companyName }
 	};
 	if (snapshot.matches("submitting")) return { status: "submitting" };
 	if (snapshot.matches("finished")) return { status: "finished" };
@@ -40,7 +41,9 @@ function createApi({ actor, trackElementClicked }) {
 		},
 		/**
 		* Selects a document by id, or the `'scanNew'` sentinel to indicate the
-		* user prefers to scan a new document instead of reusing one.
+		* user prefers to scan a new document instead of reusing one. Only needed
+		* for two-step UIs; `submit(documentId)` selects and submits in one call.
+		* Ids that are not among the offered documents are ignored.
 		*/
 		chooseDocument(documentId) {
 			trackElementClicked?.("chooseDocument");
@@ -50,13 +53,18 @@ function createApi({ actor, trackElementClicked }) {
 			});
 		},
 		/**
-		* 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).
+		* Submits a document for reuse. Pass a document id (or `'scanNew'`) to
+		* select and submit in one step; omit it to submit the current selection.
+		* A document is submitted with `{ accepted: true }`; scan-new submits
+		* `{ accepted: false }` so orchestration loads the next node. Ids that are
+		* not among the offered documents are ignored.
 		*/
-		submit() {
+		submit(documentId) {
 			trackElementClicked?.("submit");
-			actor.send({ type: "SUBMIT" });
+			actor.send({
+				type: "SUBMIT",
+				documentId
+			});
 		},
 		/**
 		* Skips identity reuse entirely. Finishes the module without submitting;
@@ -75,6 +83,9 @@ function createApi({ actor, trackElementClicked }) {
 		}
 	};
 }
+function createInstrumentation() {
+	return createManagerInstrumentation(eventModuleNames.identityReuse, { getScreenName: (snapshot) => snapshot.matches("loading") ? "loading" : void 0 });
+}
 /**
 * Creates an IdentityReuse manager for headless or UI-driven usage.
 *
@@ -82,7 +93,9 @@ function createApi({ actor, trackElementClicked }) {
 * ```typescript
 * const manager = createIdentityReuseManager({ config: {} });
 * manager.subscribe((state) => {
-*   if (state.status === 'documentsFound') manager.submit();
+*   if (state.status === 'documentsFound') {
+*     manager.submit(state.documents[0].id);
+*   }
 *   if (state.status === 'finished') console.log('Done!');
 * });
 * manager.load();
@@ -93,7 +106,7 @@ function createIdentityReuseManager(options) {
 		actor: createIdentityReuseActor(options),
 		mapState,
 		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.identityReuse)
+		instrumentation: createInstrumentation()
 	});
 }
 /**
@@ -105,7 +118,7 @@ function createIdentityReuseManagerFromActor(actor) {
 		actor,
 		mapState,
 		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.identityReuse)
+		instrumentation: createInstrumentation()
 	});
 }
 //#endregion

package/dist/{identityReuseManager-BXEBBI3N.d.ts → identityReuseManager-ooAbp6Kc.d.ts}

@@ -1,7 +1,6 @@
 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";
+import { t as Manager } from "./Manager-C9T5amUN.js";
+import "./Actor-DpTj5PFb.js";
 //#region src/modules/identity-reuse/types.d.ts
 /**
  * Configuration options for the IdentityReuse module.
@@ -44,6 +43,12 @@ type ReusableDocument = {
  * Always an array; ordered by backend with the best match first.
  */
 type FetchDocumentsResponse = ReusableDocument[];
+/**
+ * Name of the organization receiving the reused document, as resolved by the
+ * `fetchCompanyName` actor, or `undefined` when the backend does not provide
+ * one. Use it to type a `fetchCompanyName` override passed to `.provide()`.
+ */
+type FetchCompanyNameResponse = string | undefined;
 /**
  * @internal Request body for POST /omni/identity-reuse/submit.
  *
@@ -70,6 +75,7 @@ type IdentityReuseContext = {
   config: IdentityReuseConfig;
   documents: ReusableDocument[];
   selectedDocumentId: SelectedDocumentId | undefined;
+  companyName: string | undefined;
   error: string | undefined;
 };
 type IdentityReuseInput = {
@@ -82,18 +88,24 @@ declare const identityReuseMachine: StateMachine<IdentityReuseContext, {
   documentId: SelectedDocumentId;
 } | {
   type: "SUBMIT";
+  documentId?: SelectedDocumentId;
 } | {
   type: "SKIP";
 } | {
   type: "RETRY";
 }, {
-  [x: string]: ActorRefFromLogic<PromiseActorLogic<FetchDocumentsResponse, void, EventObject>> | ActorRefFromLogic<PromiseActorLogic<SubmitResponse, SubmitParams, EventObject>> | undefined;
+  [x: string]: ActorRefFromLogic<PromiseActorLogic<FetchDocumentsResponse, void, EventObject>> | ActorRefFromLogic<PromiseActorLogic<FetchCompanyNameResponse, void, EventObject>> | ActorRefFromLogic<PromiseActorLogic<SubmitResponse, SubmitParams, EventObject>> | undefined;
 }, Values<{
   fetchDocuments: {
     src: "fetchDocuments";
     logic: PromiseActorLogic<FetchDocumentsResponse, void, EventObject>;
     id: string | undefined;
   };
+  fetchCompanyName: {
+    src: "fetchCompanyName";
+    logic: PromiseActorLogic<FetchCompanyNameResponse, void, EventObject>;
+    id: string | undefined;
+  };
   submitDocument: {
     src: "submitDocument";
     logic: PromiseActorLogic<SubmitResponse, SubmitParams, EventObject>;
@@ -108,12 +120,16 @@ declare const identityReuseMachine: StateMachine<IdentityReuseContext, {
     type: "setError";
     params: NonReducibleUnknown;
   };
+  clearError: {
+    type: "clearError";
+    params: NonReducibleUnknown;
+  };
   setSelectedDocument: {
     type: "setSelectedDocument";
     params: NonReducibleUnknown;
   };
-  clearError: {
-    type: "clearError";
+  setCompanyName: {
+    type: "setCompanyName";
     params: NonReducibleUnknown;
   };
 }>, Values<{
@@ -121,16 +137,25 @@ declare const identityReuseMachine: StateMachine<IdentityReuseContext, {
     type: "hasDocuments";
     params: unknown;
   };
-  hasSelection: {
-    type: "hasSelection";
+  hasCompanyName: {
+    type: "hasCompanyName";
     params: unknown;
   };
-}>, never, "error" | "idle" | "finished" | "loading" | "submitting" | "documentsFound", string, IdentityReuseInput, NonReducibleUnknown, EventObject, MetaObject, {
+  isKnownSelection: {
+    type: "isKnownSelection";
+    params: unknown;
+  };
+}>, "companyNameTimeout", "error" | "idle" | "finished" | "submitting" | "documentsFound" | {
+  loading: {
+    documents: "done" | "fetching";
+    company: "done" | "fetching" | "check";
+  };
+}, string, IdentityReuseInput, NonReducibleUnknown, EventObject, MetaObject, {
   readonly id: "identityReuse";
   readonly initial: "idle";
   readonly context: ({ input }: {
     spawn: {
-      <TSrc extends "fetchDocuments" | "submitDocument">(logic: TSrc, ...[options]: ({
+      <TSrc extends "fetchDocuments" | "fetchCompanyName" | "submitDocument">(logic: TSrc, ...[options]: ({
         src: "fetchDocuments";
         logic: PromiseActorLogic<FetchDocumentsResponse, void, EventObject>;
         id: string | undefined;
@@ -146,12 +171,12 @@ declare const identityReuseMachine: StateMachine<IdentityReuseContext, {
         input?: InputFrom<T["logic"]> | undefined;
         syncSnapshot?: boolean;
       } & { [K in RequiredActorOptions<T>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T>>> : never : never : never) | ({
-        src: "submitDocument";
-        logic: PromiseActorLogic<SubmitResponse, SubmitParams, EventObject>;
+        src: "fetchCompanyName";
+        logic: PromiseActorLogic<FetchCompanyNameResponse, void, EventObject>;
         id: string | undefined;
       } extends (infer T_1) ? T_1 extends {
-        src: "submitDocument";
-        logic: PromiseActorLogic<SubmitResponse, SubmitParams, EventObject>;
+        src: "fetchCompanyName";
+        logic: PromiseActorLogic<FetchCompanyNameResponse, void, EventObject>;
         id: string | undefined;
       } ? T_1 extends {
         src: TSrc;
@@ -160,12 +185,32 @@ declare const identityReuseMachine: StateMachine<IdentityReuseContext, {
         systemId?: string;
         input?: InputFrom<T_1["logic"]> | undefined;
         syncSnapshot?: boolean;
-      } & { [K_1 in RequiredActorOptions<T_1>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T_1>>> : never : never : never)): ActorRefFromLogic<GetConcreteByKey<Values<{
+      } & { [K_1 in RequiredActorOptions<T_1>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T_1>>> : never : never : never) | ({
+        src: "submitDocument";
+        logic: PromiseActorLogic<SubmitResponse, SubmitParams, EventObject>;
+        id: string | undefined;
+      } extends (infer T_2) ? T_2 extends {
+        src: "submitDocument";
+        logic: PromiseActorLogic<SubmitResponse, SubmitParams, EventObject>;
+        id: string | undefined;
+      } ? T_2 extends {
+        src: TSrc;
+      } ? ConditionalRequired<[options?: ({
+        id?: T_2["id"] | undefined;
+        systemId?: string;
+        input?: InputFrom<T_2["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_2 in RequiredActorOptions<T_2>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T_2>>> : never : never : never)): ActorRefFromLogic<GetConcreteByKey<Values<{
         fetchDocuments: {
           src: "fetchDocuments";
           logic: PromiseActorLogic<FetchDocumentsResponse, void, EventObject>;
           id: string | undefined;
         };
+        fetchCompanyName: {
+          src: "fetchCompanyName";
+          logic: PromiseActorLogic<FetchCompanyNameResponse, void, EventObject>;
+          id: string | undefined;
+        };
         submitDocument: {
           src: "submitDocument";
           logic: PromiseActorLogic<SubmitResponse, SubmitParams, EventObject>;
@@ -187,6 +232,7 @@ declare const identityReuseMachine: StateMachine<IdentityReuseContext, {
       documentId: SelectedDocumentId;
     } | {
       type: "SUBMIT";
+      documentId?: SelectedDocumentId;
     } | {
       type: "SKIP";
     } | {
@@ -198,6 +244,7 @@ declare const identityReuseMachine: StateMachine<IdentityReuseContext, {
       documentId: SelectedDocumentId;
     } | {
       type: "SUBMIT";
+      documentId?: SelectedDocumentId;
     } | {
       type: "SKIP";
     } | {
@@ -207,6 +254,7 @@ declare const identityReuseMachine: StateMachine<IdentityReuseContext, {
     config: IdentityReuseConfig;
     documents: never[];
     selectedDocumentId: undefined;
+    companyName: undefined;
     error: undefined;
   };
   readonly states: {
@@ -218,30 +266,82 @@ declare const identityReuseMachine: StateMachine<IdentityReuseContext, {
       };
     };
     readonly loading: {
-      readonly invoke: {
-        readonly id: "fetchDocuments";
-        readonly src: "fetchDocuments";
-        readonly onDone: readonly [{
-          readonly target: "documentsFound";
-          readonly guard: "hasDocuments";
-          readonly actions: "setDocuments";
-        }, {
-          readonly target: "finished";
-        }];
-        readonly onError: {
-          readonly target: "error";
-          readonly actions: "setError";
+      readonly type: "parallel";
+      readonly states: {
+        readonly documents: {
+          readonly initial: "fetching";
+          readonly states: {
+            readonly fetching: {
+              readonly invoke: {
+                readonly id: "fetchDocuments";
+                readonly src: "fetchDocuments";
+                readonly onDone: {
+                  readonly target: "done";
+                  readonly actions: "setDocuments";
+                };
+                readonly onError: {
+                  readonly target: "#identityReuse.error";
+                  readonly actions: "setError";
+                };
+              };
+            };
+            readonly done: {
+              readonly type: "final";
+            };
+          };
+        };
+        readonly company: {
+          readonly initial: "check";
+          readonly states: {
+            readonly check: {
+              readonly always: readonly [{
+                readonly target: "done";
+                readonly guard: "hasCompanyName";
+              }, {
+                readonly target: "fetching";
+              }];
+            };
+            readonly fetching: {
+              readonly invoke: {
+                readonly id: "fetchCompanyName";
+                readonly src: "fetchCompanyName";
+                readonly onDone: {
+                  readonly target: "done";
+                  readonly actions: "setCompanyName";
+                };
+                readonly onError: {
+                  readonly target: "done";
+                };
+              };
+              readonly after: {
+                readonly companyNameTimeout: {
+                  readonly target: "done";
+                };
+              };
+            };
+            readonly done: {
+              readonly type: "final";
+            };
+          };
         };
       };
+      readonly onDone: readonly [{
+        readonly target: "documentsFound";
+        readonly guard: "hasDocuments";
+      }, {
+        readonly target: "finished";
+      }];
     };
     readonly documentsFound: {
       readonly on: {
         readonly DOCUMENT_CHOSEN: {
+          readonly guard: "isKnownSelection";
           readonly actions: "setSelectedDocument";
         };
         readonly SUBMIT: {
           readonly target: "submitting";
-          readonly guard: "hasSelection";
+          readonly guard: "isKnownSelection";
+          readonly actions: "setSelectedDocument";
         };
         readonly SKIP: {
           readonly target: "finished";
@@ -300,24 +400,32 @@ type IdentityReuseActor = ActorRefFrom<IdentityReuseMachine>;
 type IdentityReuseIdleState = {
   status: 'idle';
 };
-/** Fetching reusable documents from the backend */
+/**
+ * Fetching reusable documents and, in parallel, the name of the organization
+ * receiving them. The name lookup is non-fatal and never keeps this state
+ * longer than one second after loading starts, unless the documents
+ * themselves take longer.
+ */
 type IdentityReuseLoadingState = {
   status: 'loading';
 };
 /**
- * Documents are available — user picks one (or "scan new") and confirms.
- * The first document in the list is the recommended one; the UI surfaces a
- * "Recommended" tag based on position alone.
+ * Documents are available — user picks one (or "scan new"), which submits
+ * immediately via `submit(documentId)`. The first document in the list is the
+ * recommended one; the UI surfaces a "Recommended" tag based on position alone.
  *
  * @property documents - Ordered documents; index 0 is the best match.
  * @property selectedDocumentId - Currently selected document id, or
  *   `'scanNew'` if the user picked the scan-new row. Auto-populated to
- *   `documents[0].id` on entry.
+ *   `documents[0].id` on entry, so a bare `submit()` reuses the best match.
+ * @property companyName - Name of the organization receiving the reused
+ *   document. Absent when the backend does not provide one.
  */
 type IdentityReuseDocumentsFoundState = {
   status: 'documentsFound';
   documents: ReusableDocument[];
   selectedDocumentId: SelectedDocumentId | undefined;
+  companyName?: string;
 };
 /** Submitting the chosen document for reuse */
 type IdentityReuseSubmittingState = {
@@ -354,7 +462,9 @@ type IdentityReuseState = IdentityReuseIdleState | IdentityReuseLoadingState | I
  * ```typescript
  * const manager = createIdentityReuseManager({ config: {} });
  * manager.subscribe((state) => {
- *   if (state.status === 'documentsFound') manager.submit();
+ *   if (state.status === 'documentsFound') {
+ *     manager.submit(state.documents[0].id);
+ *   }
  *   if (state.status === 'finished') console.log('Done!');
  * });
  * manager.load();
@@ -368,15 +478,19 @@ declare function createIdentityReuseManager(options: CreateIdentityReuseActorOpt
   load(): void;
   /**
    * Selects a document by id, or the `'scanNew'` sentinel to indicate the
-   * user prefers to scan a new document instead of reusing one.
+   * user prefers to scan a new document instead of reusing one. Only needed
+   * for two-step UIs; `submit(documentId)` selects and submits in one call.
+   * Ids that are not among the offered documents are ignored.
    */
   chooseDocument(documentId: SelectedDocumentId): void;
   /**
-   * 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).
+   * Submits a document for reuse. Pass a document id (or `'scanNew'`) to
+   * select and submit in one step; omit it to submit the current selection.
+   * A document is submitted with `{ accepted: true }`; scan-new submits
+   * `{ accepted: false }` so orchestration loads the next node. Ids that are
+   * not among the offered documents are ignored.
    */
-  submit(): void;
+  submit(documentId?: SelectedDocumentId): void;
   /**
    * Skips identity reuse entirely. Finishes the module without submitting;
    * orchestration moves on to the next node.
@@ -399,15 +513,19 @@ declare function createIdentityReuseManagerFromActor(actor: IdentityReuseActor):
   load(): void;
   /**
    * Selects a document by id, or the `'scanNew'` sentinel to indicate the
-   * user prefers to scan a new document instead of reusing one.
+   * user prefers to scan a new document instead of reusing one. Only needed
+   * for two-step UIs; `submit(documentId)` selects and submits in one call.
+   * Ids that are not among the offered documents are ignored.
    */
   chooseDocument(documentId: SelectedDocumentId): void;
   /**
-   * 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).
+   * Submits a document for reuse. Pass a document id (or `'scanNew'`) to
+   * select and submit in one step; omit it to submit the current selection.
+   * A document is submitted with `{ accepted: true }`; scan-new submits
+   * `{ accepted: false }` so orchestration loads the next node. Ids that are
+   * not among the offered documents are ignored.
    */
-  submit(): void;
+  submit(documentId?: SelectedDocumentId): void;
   /**
    * Skips identity reuse entirely. Finishes the module without submitting;
    * orchestration moves on to the next node.
@@ -420,4 +538,4 @@ declare function createIdentityReuseManagerFromActor(actor: IdentityReuseActor):
 };
 type IdentityReuseManager = ReturnType<typeof createIdentityReuseManager>;
 //#endregion
-export { IdentityReuseActor as a, identityReuseMachine as c, ReusableDocument as d, SubmitResponse as f, createIdentityReuseManagerFromActor as i, FetchDocumentsResponse as l, IdentityReuseState as n, SCAN_NEW_DOCUMENT as o, createIdentityReuseManager as r, SelectedDocumentId as s, IdentityReuseManager as t, IdentityReuseConfig as u };
+export { IdentityReuseActor as a, identityReuseMachine as c, IdentityReuseConfig as d, ReusableDocument as f, createIdentityReuseManagerFromActor as i, FetchCompanyNameResponse as l, IdentityReuseState as n, SCAN_NEW_DOCUMENT as o, SubmitResponse as p, createIdentityReuseManager as r, SelectedDocumentId as s, IdentityReuseManager as t, FetchDocumentsResponse as u };