@incodetech/core 0.0.0-dev-20260409-09dfd52 → 0.0.0-dev-20260409-089e5c6

package/dist/id.esm.js

@@ -1,24 +1,24 @@
-import "./BaseWasmProvider-DoYDYH1z.esm.js";
-import "./api-aa9Mx20l.esm.js";
-import "./events-W91zLpx4.esm.js";
-import "./session-B_rKSRql.esm.js";
-import "./BrowserEnvironmentProvider-BtKLxTx4.esm.js";
-import "./browserSimulation-DFqGKQAD.esm.js";
-import "./xstate.esm-B7FPE6br.esm.js";
-import "./BrowserStorageProvider-CXaS5Ooj.esm.js";
-import "./recordingService-CCfxUY7-.esm.js";
-import "./deepsightService-rPGLH8Xp.esm.js";
-import "./camera-DpPQS_-5.esm.js";
-import "./getBrowser-DCcD7H-M.esm.js";
-import "./stats-gFD2351t.esm.js";
-import "./MotionSensorProvider-D90R4qwV.esm.js";
-import "./permissionServices-Cisv73eQ.esm.js";
-import "./platform-DctkySJU.esm.js";
-import "./ITimerCapability-BZO_FsCo.esm.js";
-import "./backCameraStream-D9g2wyil.esm.js";
-import "./getDeviceClass-DBF-ExLR.esm.js";
-import "./BrowserTimerProvider-v7bpbrAk.esm.js";
-import { a as startRecordingSession, c as uploadIdImage, i as processId, l as validateUploadResponse, n as initializeIdCapture, o as stopRecording, r as preloadIdRecordingProvider, s as stopStream, t as idCaptureMachine, u as ID_ERROR_CODES } from "./idCaptureStateMachine-gf-Q9piu.esm.js";
-import { r as createIdCaptureActor, t as createIdCaptureManager } from "./idCaptureManager-CJfatzuY.esm.js";
+import "./BaseWasmProvider-C73c2nV9.esm.js";
+import "./api-CqKwkjJ3.esm.js";
+import "./events-CZ2ka3pu.esm.js";
+import "./session-DoI-X9FK.esm.js";
+import "./BrowserEnvironmentProvider-lxn4oxXn.esm.js";
+import "./browserSimulation-7W5-A3RV.esm.js";
+import "./xstate.esm-D7D6CGwY.esm.js";
+import "./BrowserStorageProvider-ByxoNfxC.esm.js";
+import "./recordingService-8I_-hhNI.esm.js";
+import "./deepsightService-D4mM8yJ2.esm.js";
+import "./camera-B-5traWf.esm.js";
+import "./getBrowser-DJkbzQ5t.esm.js";
+import "./stats-wkQyDFV3.esm.js";
+import "./MotionSensorProvider-BLnFo6My.esm.js";
+import "./permissionServices-Cj120WaT.esm.js";
+import "./platform-BfoqeM61.esm.js";
+import "./ITimerCapability-DAIaq369.esm.js";
+import "./backCameraStream-BihRmMzc.esm.js";
+import "./getDeviceClass-BoiWvKAc.esm.js";
+import "./BrowserTimerProvider-CSdm7__S.esm.js";
+import { a as startRecordingSession, c as uploadIdImage, i as processId, l as validateUploadResponse, n as initializeIdCapture, o as stopRecording, r as preloadIdRecordingProvider, s as stopStream, t as idCaptureMachine, u as ID_ERROR_CODES } from "./idCaptureStateMachine-MAzfM_2O.esm.js";
+import { r as createIdCaptureActor, t as createIdCaptureManager } from "./idCaptureManager-BcS8fgW4.esm.js";
 
 export { ID_ERROR_CODES, createIdCaptureActor, createIdCaptureManager, idCaptureMachine, initializeIdCapture, preloadIdRecordingProvider, processId, startRecordingSession, stopRecording, stopStream, uploadIdImage, validateUploadResponse };

package/dist/{idCaptureManager-CJfatzuY.esm.js → idCaptureManager-BcS8fgW4.esm.js}

@@ -1,7 +1,7 @@
-import { n as eventModuleNames, o as createManagerInstrumentation, r as eventScreenNames } from "./events-W91zLpx4.esm.js";
-import { a as createActor, o as createManager } from "./xstate.esm-B7FPE6br.esm.js";
-import { t as BrowserStorageProvider } from "./BrowserStorageProvider-CXaS5Ooj.esm.js";
-import { t as idCaptureMachine } from "./idCaptureStateMachine-gf-Q9piu.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation, r as eventScreenNames } from "./events-CZ2ka3pu.esm.js";
+import { a as createActor, o as createManager } from "./xstate.esm-D7D6CGwY.esm.js";
+import { t as BrowserStorageProvider } from "./BrowserStorageProvider-ByxoNfxC.esm.js";
+import { t as idCaptureMachine } from "./idCaptureStateMachine-MAzfM_2O.esm.js";
 
 //#region src/modules/id/idCaptureActor.ts
 function createIdCaptureActor(options) {

package/dist/{idCaptureManager-CbZvdr9y.d.ts → idCaptureManager-oR6YPYHj.d.ts}

@@ -1,10 +1,10 @@
-import { t as Manager } from "./Manager-DcPMRgTm.js";
-import { t as ActorRefFrom } from "./Actor-DbWH1K6E.js";
-import { n as StateMachine, t as AnyStateMachine } from "./StateMachine-BBuIgsHT.js";
-import { t as CameraStream } from "./camera-DATT31my.js";
-import { a as TutorialIdConfig, i as RegulationTypes, t as Flow } from "./types-DU8HmI5U.js";
-import { c as IMLProviderCapability, d as IRecordingCapability, f as RecordingConnection, i as IncodeCanvas, l as MLProviderConfig, n as IMotionSensorCapability, r as StreamCanvasCapture, t as DeepsightService, u as IStorageCapability } from "./deepsightService-S-tU77m-.js";
-import { n as PermissionStatus, t as PermissionResult } from "./types-CIjb0FKu.js";
+import { t as Manager } from "./Manager-Bcnemkyi.js";
+import { t as ActorRefFrom } from "./Actor-BkPcZGke.js";
+import { n as StateMachine, t as AnyStateMachine } from "./StateMachine-DIeoDJ7r.js";
+import { t as CameraStream } from "./camera-CgnuDuxy.js";
+import { a as TutorialIdConfig, i as RegulationTypes, t as Flow } from "./types-m43DfiSx.js";
+import { c as IMLProviderCapability, d as IRecordingCapability, f as RecordingConnection, i as IncodeCanvas, l as MLProviderConfig, n as IMotionSensorCapability, r as StreamCanvasCapture, t as DeepsightService, u as IStorageCapability } from "./deepsightService-DAeakjDd.js";
+import { n as PermissionStatus, t as PermissionResult } from "./types-CxU9jTRl.js";
 
 //#region ../infra/src/capabilities/IIdCaptureCapability.d.ts
 /**

package/dist/{idCaptureStateMachine-gf-Q9piu.esm.js → idCaptureStateMachine-MAzfM_2O.esm.js}

@@ -1,17 +1,17 @@
-import { a as IdCaptureModelType, i as WasmPipelineType, r as mlWasmJSApi_default, t as BaseWasmProvider } from "./BaseWasmProvider-DoYDYH1z.esm.js";
-import { r as getToken, t as api } from "./api-aa9Mx20l.esm.js";
-import { _ as endpoints, v as revokeObjectURL } from "./events-W91zLpx4.esm.js";
-import { t as getDisableIpify } from "./session-B_rKSRql.esm.js";
-import { i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-B7FPE6br.esm.js";
-import { _ as StreamCanvasCapture, d as createRecordingSession, f as startRecording, g as flagIdManualReview, m as StreamCanvasProcessingSession, n as preloadOpenViduProvider, p as stopRecording$1 } from "./recordingService-CCfxUY7-.esm.js";
-import { n as IncodeCanvas } from "./deepsightService-rPGLH8Xp.esm.js";
-import { r as getWindowDimensions } from "./getBrowser-DCcD7H-M.esm.js";
-import { t as addDeviceStats } from "./stats-gFD2351t.esm.js";
-import { n as requestPermission, t as checkPermission } from "./permissionServices-Cisv73eQ.esm.js";
-import { n as isDesktop } from "./platform-DctkySJU.esm.js";
-import { t as getBackCameraStream } from "./backCameraStream-D9g2wyil.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-DBF-ExLR.esm.js";
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-v7bpbrAk.esm.js";
+import { a as IdCaptureModelType, i as WasmPipelineType, r as mlWasmJSApi_default, t as BaseWasmProvider } from "./BaseWasmProvider-C73c2nV9.esm.js";
+import { r as getToken, t as api } from "./api-CqKwkjJ3.esm.js";
+import { _ as endpoints, v as revokeObjectURL } from "./events-CZ2ka3pu.esm.js";
+import { t as getDisableIpify } from "./session-DoI-X9FK.esm.js";
+import { i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-D7D6CGwY.esm.js";
+import { _ as StreamCanvasCapture, d as createRecordingSession, f as startRecording, g as flagIdManualReview, m as StreamCanvasProcessingSession, n as preloadOpenViduProvider, p as stopRecording$1 } from "./recordingService-8I_-hhNI.esm.js";
+import { n as IncodeCanvas } from "./deepsightService-D4mM8yJ2.esm.js";
+import { r as getWindowDimensions } from "./getBrowser-DJkbzQ5t.esm.js";
+import { t as addDeviceStats } from "./stats-wkQyDFV3.esm.js";
+import { n as requestPermission, t as checkPermission } from "./permissionServices-Cj120WaT.esm.js";
+import { n as isDesktop } from "./platform-BfoqeM61.esm.js";
+import { t as getBackCameraStream } from "./backCameraStream-BihRmMzc.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-BoiWvKAc.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CSdm7__S.esm.js";
 
 //#region src/modules/id/idCaptureHelpers.ts
 /**
@@ -426,7 +426,7 @@ function preloadIdRecordingProvider(config) {
 	preloadOpenViduProvider();
 }
 async function createOpenViduRecordingProvider() {
-	const { OpenViduRecordingProvider } = await import("./OpenViduRecordingProvider-D_cVAwYQ.esm.js");
+	const { OpenViduRecordingProvider } = await import("./OpenViduRecordingProvider-JatjSE3h.esm.js");
 	return new OpenViduRecordingProvider();
 }
 async function startRecordingSession(params) {
@@ -799,7 +799,7 @@ const checkMotionSensorActor = fromCallback(({ input, sendBack }) => {
 });
 const initializeDeepsightSessionActor = fromPromise(async ({ input }) => {
 	if (!input.dependencies) return;
-	const { loadDeepsightSession } = await import("./deepsightLoader-CaULV07H.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-jIgoauFK.esm.js");
 	return loadDeepsightSession({
 		ds: input.ds,
 		storage: input.dependencies.storage,

package/dist/identity-reuse.d.ts

@@ -0,0 +1,530 @@
+import { t as Manager } from "./Manager-Bcnemkyi.js";
+import { t as ActorRefFrom } from "./Actor-BkPcZGke.js";
+import * as xstate603 from "xstate";
+
+//#region src/modules/identity-reuse/types.d.ts
+
+/**
+ * Configuration options for the IdentityReuse module.
+ *
+ * @example
+ * ```typescript
+ * const config: IdentityReuseConfig = {};
+ * ```
+ */
+type IdentityReuseConfig = {};
+/** @internal Response from GET /omni/identity-reuse/candidates */
+type FetchCandidatesResponse = {
+  currentOrganizationName: string;
+  candidateOrganizationNames: string[];
+};
+/** @internal Response from POST /omni/identity-reuse/submit — shape TBD */
+type SubmitResponse = {};
+//#endregion
+//#region src/modules/identity-reuse/identityReuseStateMachine.d.ts
+type IdentityReuseContext = {
+  config: IdentityReuseConfig;
+  currentOrganizationName: string | undefined;
+  candidateOrganizationNames: string[];
+  selectedOrganizationName: string | undefined;
+  error: string | undefined;
+};
+type IdentityReuseInput = {
+  config: IdentityReuseConfig;
+};
+declare const identityReuseMachine: xstate603.StateMachine<IdentityReuseContext, {
+  type: "LOAD";
+} | {
+  type: "START_SELECTION";
+} | {
+  type: "CANDIDATE_CHOSEN";
+  organizationName: string;
+} | {
+  type: "CHANGE_CANDIDATE";
+} | {
+  type: "SUBMIT_CANDIDATE";
+} | {
+  type: "SKIP";
+} | {
+  type: "RETRY";
+}, {
+  [x: string]: xstate603.ActorRefFromLogic<xstate603.PromiseActorLogic<FetchCandidatesResponse, void, xstate603.EventObject>> | xstate603.ActorRefFromLogic<xstate603.PromiseActorLogic<SubmitResponse, void, xstate603.EventObject>> | undefined;
+}, xstate603.Values<{
+  fetchCandidates: {
+    src: "fetchCandidates";
+    logic: xstate603.PromiseActorLogic<FetchCandidatesResponse, void, xstate603.EventObject>;
+    id: string | undefined;
+  };
+  submitContinue: {
+    src: "submitContinue";
+    logic: xstate603.PromiseActorLogic<SubmitResponse, void, xstate603.EventObject>;
+    id: string | undefined;
+  };
+  submitSkip: {
+    src: "submitSkip";
+    logic: xstate603.PromiseActorLogic<SubmitResponse, void, xstate603.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate603.Values<{
+  clearError: {
+    type: "clearError";
+    params: xstate603.NonReducibleUnknown;
+  };
+  setError: {
+    type: "setError";
+    params: xstate603.NonReducibleUnknown;
+  };
+  setCandidates: {
+    type: "setCandidates";
+    params: xstate603.NonReducibleUnknown;
+  };
+  setSelectedCandidate: {
+    type: "setSelectedCandidate";
+    params: xstate603.NonReducibleUnknown;
+  };
+  autoSelectSingleCandidate: {
+    type: "autoSelectSingleCandidate";
+    params: xstate603.NonReducibleUnknown;
+  };
+  clearSelection: {
+    type: "clearSelection";
+    params: xstate603.NonReducibleUnknown;
+  };
+}>, xstate603.Values<{
+  hasMultipleCandidates: {
+    type: "hasMultipleCandidates";
+    params: unknown;
+  };
+  hasOneCandidate: {
+    type: "hasOneCandidate";
+    params: unknown;
+  };
+  hasChosenCandidate: {
+    type: "hasChosenCandidate";
+    params: unknown;
+  };
+}>, never, "error" | "finished" | "idle" | "loading" | "submitContinue" | "submitSkip" | "oneCandidateFound" | "noCandidatesFound" | {
+  multiCandidatesFound: "noCandidateSelected" | "choosingCandidate" | "candidateSelected";
+}, string, IdentityReuseInput, xstate603.NonReducibleUnknown, xstate603.EventObject, xstate603.MetaObject, {
+  readonly id: "identityReuse";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "fetchCandidates" | "submitContinue" | "submitSkip">(logic: TSrc, ...[options]: ({
+        src: "fetchCandidates";
+        logic: xstate603.PromiseActorLogic<FetchCandidatesResponse, void, xstate603.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "fetchCandidates";
+        logic: xstate603.PromiseActorLogic<FetchCandidatesResponse, void, xstate603.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate603.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate603.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate603.RequiredActorOptions<T>]: unknown }) | undefined], xstate603.IsNotNever<xstate603.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "submitContinue";
+        logic: xstate603.PromiseActorLogic<SubmitResponse, void, xstate603.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "submitContinue";
+        logic: xstate603.PromiseActorLogic<SubmitResponse, void, xstate603.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate603.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate603.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate603.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate603.IsNotNever<xstate603.RequiredActorOptions<T_1>>> : never : never : never) | ({
+        src: "submitSkip";
+        logic: xstate603.PromiseActorLogic<SubmitResponse, void, xstate603.EventObject>;
+        id: string | undefined;
+      } extends infer T_2 ? T_2 extends {
+        src: "submitSkip";
+        logic: xstate603.PromiseActorLogic<SubmitResponse, void, xstate603.EventObject>;
+        id: string | undefined;
+      } ? T_2 extends {
+        src: TSrc;
+      } ? xstate603.ConditionalRequired<[options?: ({
+        id?: T_2["id"] | undefined;
+        systemId?: string;
+        input?: xstate603.InputFrom<T_2["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_2 in xstate603.RequiredActorOptions<T_2>]: unknown }) | undefined], xstate603.IsNotNever<xstate603.RequiredActorOptions<T_2>>> : never : never : never)): xstate603.ActorRefFromLogic<xstate603.GetConcreteByKey<xstate603.Values<{
+        fetchCandidates: {
+          src: "fetchCandidates";
+          logic: xstate603.PromiseActorLogic<FetchCandidatesResponse, void, xstate603.EventObject>;
+          id: string | undefined;
+        };
+        submitContinue: {
+          src: "submitContinue";
+          logic: xstate603.PromiseActorLogic<SubmitResponse, void, xstate603.EventObject>;
+          id: string | undefined;
+        };
+        submitSkip: {
+          src: "submitSkip";
+          logic: xstate603.PromiseActorLogic<SubmitResponse, void, xstate603.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate603.AnyActorLogic>(src: TLogic, ...[options]: xstate603.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate603.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate603.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate603.IsNotNever<xstate603.RequiredLogicInput<TLogic>>>): xstate603.ActorRefFromLogic<TLogic>;
+    };
+    input: IdentityReuseInput;
+    self: xstate603.ActorRef<xstate603.MachineSnapshot<IdentityReuseContext, {
+      type: "LOAD";
+    } | {
+      type: "START_SELECTION";
+    } | {
+      type: "CANDIDATE_CHOSEN";
+      organizationName: string;
+    } | {
+      type: "CHANGE_CANDIDATE";
+    } | {
+      type: "SUBMIT_CANDIDATE";
+    } | {
+      type: "SKIP";
+    } | {
+      type: "RETRY";
+    }, Record<string, xstate603.AnyActorRef | undefined>, xstate603.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "START_SELECTION";
+    } | {
+      type: "CANDIDATE_CHOSEN";
+      organizationName: string;
+    } | {
+      type: "CHANGE_CANDIDATE";
+    } | {
+      type: "SUBMIT_CANDIDATE";
+    } | {
+      type: "SKIP";
+    } | {
+      type: "RETRY";
+    }, xstate603.AnyEventObject>;
+  }) => {
+    config: IdentityReuseConfig;
+    currentOrganizationName: undefined;
+    candidateOrganizationNames: never[];
+    selectedOrganizationName: undefined;
+    error: undefined;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: {
+          readonly target: "loading";
+        };
+      };
+    };
+    readonly loading: {
+      readonly invoke: {
+        readonly id: "fetchCandidates";
+        readonly src: "fetchCandidates";
+        readonly onDone: readonly [{
+          readonly target: "multiCandidatesFound";
+          readonly guard: "hasMultipleCandidates";
+          readonly actions: "setCandidates";
+        }, {
+          readonly target: "oneCandidateFound";
+          readonly guard: "hasOneCandidate";
+          readonly actions: "setCandidates";
+        }, {
+          readonly target: "noCandidatesFound";
+          readonly actions: "setCandidates";
+        }];
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly multiCandidatesFound: {
+      readonly initial: "noCandidateSelected";
+      readonly states: {
+        readonly noCandidateSelected: {
+          readonly on: {
+            readonly START_SELECTION: {
+              readonly target: "choosingCandidate";
+            };
+          };
+        };
+        readonly choosingCandidate: {
+          readonly on: {
+            readonly CANDIDATE_CHOSEN: {
+              readonly target: "candidateSelected";
+              readonly actions: "setSelectedCandidate";
+            };
+          };
+        };
+        readonly candidateSelected: {
+          readonly on: {
+            readonly CHANGE_CANDIDATE: {
+              readonly target: "choosingCandidate";
+              readonly actions: "clearSelection";
+            };
+          };
+        };
+      };
+      readonly on: {
+        readonly SUBMIT_CANDIDATE: {
+          readonly target: "submitContinue";
+          readonly guard: "hasChosenCandidate";
+        };
+        readonly SKIP: {
+          readonly target: "submitSkip";
+        };
+      };
+    };
+    readonly oneCandidateFound: {
+      readonly entry: "autoSelectSingleCandidate";
+      readonly on: {
+        readonly SUBMIT_CANDIDATE: {
+          readonly target: "submitContinue";
+        };
+        readonly SKIP: {
+          readonly target: "submitSkip";
+        };
+      };
+    };
+    readonly noCandidatesFound: {
+      readonly on: {
+        readonly SKIP: {
+          readonly target: "submitSkip";
+        };
+      };
+    };
+    readonly submitContinue: {
+      readonly invoke: {
+        readonly id: "submitContinue";
+        readonly src: "submitContinue";
+        readonly onDone: {
+          readonly target: "finished";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly submitSkip: {
+      readonly invoke: {
+        readonly id: "submitSkip";
+        readonly src: "submitSkip";
+        readonly onDone: {
+          readonly target: "finished";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+    readonly error: {
+      readonly on: {
+        readonly RETRY: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+        readonly SKIP: {
+          readonly target: "submitSkip";
+        };
+      };
+    };
+  };
+}>;
+type IdentityReuseMachine = typeof identityReuseMachine;
+//#endregion
+//#region src/modules/identity-reuse/identityReuseActor.d.ts
+/**
+ * Options for creating an IdentityReuse actor.
+ */
+type CreateIdentityReuseActorOptions = {
+  /** Module configuration */
+  config: IdentityReuseConfig;
+};
+/**
+ * Type representing a running IdentityReuse actor.
+ */
+type IdentityReuseActor = ActorRefFrom<IdentityReuseMachine>;
+//#endregion
+//#region src/modules/identity-reuse/identityReuseManager.d.ts
+type SelectionPhase = 'noCandidateSelected' | 'choosingCandidate' | 'candidateSelected';
+/** IdentityReuse manager is in initial state, waiting for `load()` */
+type IdentityReuseIdleState = {
+  status: 'idle';
+};
+/** Fetching candidate organizations from the backend */
+type IdentityReuseLoadingState = {
+  status: 'loading';
+};
+/**
+ * Multiple candidates available — user must select one
+ * @property currentOrganizationName - The organization the user is currently onboarding into
+ * @property candidateOrganizationNames - Organizations with reusable identity data
+ * @property selectedOrganizationName - The currently chosen candidate, if any
+ * @property selectionPhase - Which child state the selection is in
+ */
+type IdentityReuseMultiCandidatesState = {
+  status: 'multiCandidatesFound';
+  currentOrganizationName: string;
+  candidateOrganizationNames: string[];
+  selectedOrganizationName: string | undefined;
+  selectionPhase: SelectionPhase;
+};
+/**
+ * Exactly one candidate found — auto-selected on entry
+ * @property currentOrganizationName - The organization the user is currently onboarding into
+ * @property selectedOrganizationName - The single candidate, auto-selected
+ */
+type IdentityReuseOneCandidateState = {
+  status: 'oneCandidateFound';
+  currentOrganizationName: string;
+  selectedOrganizationName: string;
+};
+/**
+ * No candidate organizations found
+ * @property currentOrganizationName - The organization the user is currently onboarding into
+ */
+type IdentityReuseNoCandidatesState = {
+  status: 'noCandidatesFound';
+  currentOrganizationName: string;
+};
+/** Submitting final decision (reuse: true) */
+type IdentityReuseSubmitContinueState = {
+  status: 'submitContinue';
+};
+/** Submitting final decision (reuse: false) */
+type IdentityReuseSubmitSkipState = {
+  status: 'submitSkip';
+};
+/** Module completed successfully */
+type IdentityReuseFinishedState = {
+  status: 'finished';
+};
+/**
+ * A recoverable error occurred — user can retry or skip
+ * @property error - Error message describing what went wrong
+ */
+type IdentityReuseErrorState = {
+  status: 'error';
+  error: string;
+};
+/**
+ * Union of all possible IdentityReuse manager states.
+ *
+ * @example
+ * ```typescript
+ * const state = manager.getState();
+ * if (state.status === 'multiCandidatesFound') {
+ *   console.log(state.candidateOrganizationNames);
+ * }
+ * ```
+ */
+type IdentityReuseState = IdentityReuseIdleState | IdentityReuseLoadingState | IdentityReuseMultiCandidatesState | IdentityReuseOneCandidateState | IdentityReuseNoCandidatesState | IdentityReuseSubmitContinueState | IdentityReuseSubmitSkipState | IdentityReuseFinishedState | IdentityReuseErrorState;
+/**
+ * Creates an IdentityReuse manager for headless or UI-driven usage.
+ *
+ * @example Headless usage
+ * ```typescript
+ * const manager = createIdentityReuseManager({ config: {} });
+ * manager.subscribe((state) => {
+ *   if (state.status === 'oneCandidateFound') manager.submitCandidate();
+ *   if (state.status === 'finished') console.log('Done!');
+ * });
+ * manager.load();
+ * ```
+ */
+declare function createIdentityReuseManager(options: CreateIdentityReuseActorOptions): Manager<IdentityReuseState> & {
+  /**
+   * Fetches candidate organizations from the backend.
+   * Transitions from 'idle' to 'loading'.
+   */
+  load(): void;
+  /**
+   * Begins the candidate selection process.
+   * Transitions from 'noCandidateSelected' to 'choosingCandidate'.
+   */
+  startSelection(): void;
+  /**
+   * Chooses a candidate organization.
+   * Transitions from 'choosingCandidate' to 'candidateSelected'.
+   */
+  chooseCandidate(organizationName: string): void;
+  /**
+   * Goes back to choosing a different candidate.
+   * Transitions from 'candidateSelected' to 'choosingCandidate'.
+   */
+  changeCandidate(): void;
+  /**
+   * Submits the chosen candidate for processing.
+   * Guarded by having a chosen candidate.
+   */
+  submitCandidate(): void;
+  /**
+   * Skips identity reuse and proceeds with fresh onboarding.
+   * Sends /submit with reuse: false.
+   */
+  skip(): void;
+  /**
+   * Retries loading candidates after an error.
+   */
+  retry(): void;
+};
+/**
+ * Creates an IdentityReuse manager from a pre-built actor.
+ * Use this when overriding the machine via `.provide()` for custom backends or testing.
+ */
+declare function createIdentityReuseManagerFromActor(actor: IdentityReuseActor): Manager<IdentityReuseState> & {
+  /**
+   * Fetches candidate organizations from the backend.
+   * Transitions from 'idle' to 'loading'.
+   */
+  load(): void;
+  /**
+   * Begins the candidate selection process.
+   * Transitions from 'noCandidateSelected' to 'choosingCandidate'.
+   */
+  startSelection(): void;
+  /**
+   * Chooses a candidate organization.
+   * Transitions from 'choosingCandidate' to 'candidateSelected'.
+   */
+  chooseCandidate(organizationName: string): void;
+  /**
+   * Goes back to choosing a different candidate.
+   * Transitions from 'candidateSelected' to 'choosingCandidate'.
+   */
+  changeCandidate(): void;
+  /**
+   * Submits the chosen candidate for processing.
+   * Guarded by having a chosen candidate.
+   */
+  submitCandidate(): void;
+  /**
+   * Skips identity reuse and proceeds with fresh onboarding.
+   * Sends /submit with reuse: false.
+   */
+  skip(): void;
+  /**
+   * Retries loading candidates after an error.
+   */
+  retry(): void;
+};
+type IdentityReuseManager = ReturnType<typeof createIdentityReuseManager>;
+//#endregion
+export { type FetchCandidatesResponse, type IdentityReuseConfig, type IdentityReuseManager, type IdentityReuseState, type SubmitResponse, createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };