@incodetech/core 2.1.1 → 2.2.0-rc.1

package/dist/{faceCaptureSetup-BqhqfFHL.esm.js → faceCaptureSetup-BB5KEtbV.esm.js}

@@ -1,13 +1,14 @@
-import { r as getToken } from "./api-DsbUi7TO.esm.js";
-import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
-import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-C_kxhNeo.esm.js";
-import { c as sendLabelInspectionEvent, f as stopStream, l as startDetection, o as initializeCamera, s as initializeDeepsightSession } from "./onDeviceFaceResults-DILtthks.esm.js";
-import { t as FACE_ERROR_CODES } from "./types-BKLb3C42.esm.js";
-import { t as createFaceAvatar } from "./createFaceAvatar-BZSg2MNo.esm.js";
-import { t as StreamCanvasCapture } from "./StreamCanvasCapture-CAqUdVkM.esm.js";
-import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-BNOe4Tnu.esm.js";
-import { n as preloadOpenViduProvider, r as flagFaceManualReview, t as createRecordingService } from "./recordingService-CxaYkITO.esm.js";
-
+import { r as getToken } from "./api-Bx3gKW_y.esm.js";
+import { r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-CtI5S0f4.esm.js";
+import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-UvUcOSRb.esm.js";
+import { c as sendLabelInspectionEvent, f as stopStream, l as startDetection, o as initializeCamera, s as initializeDeepsightSession } from "./onDeviceFaceResults-C6IRJHQB.esm.js";
+import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
+import { n as releaseFaceAvatarWarmup, r as warmFaceAvatar, t as createFaceAvatar } from "./createFaceAvatar-DQKaRise.esm.js";
+import { t as StreamCanvasCapture } from "./StreamCanvasCapture-D2XcXCZ4.esm.js";
+import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-KINpmKtI.esm.js";
+import { t as flagFaceManualReview } from "./manualReviewService-D4IkipnN.esm.js";
+import { n as preloadOpenViduProvider, t as createRecordingService } from "./recordingService-N4RhdyiT.esm.js";
 //#region src/internal/avatar/concealment.ts
 /**
 * Maps a backend concealment option to the internal avatar flags. `OPTION_NONE`
@@ -37,13 +38,12 @@ function concealmentToAvatar(option) {
 		};
 	}
 }
-
 //#endregion
 //#region src/internal/faceCapture/faceCaptureSetup.ts
 const getAttemptsFromConfig = (config) => {
 	return config.captureAttempts ?? config.numberOfAttempts ?? 3;
 };
-const _faceCaptureMachine = setup({
+const faceCaptureMachine = setup({
 	types: {
 		context: {},
 		events: {},
@@ -84,10 +84,6 @@ const _faceCaptureMachine = setup({
 					type: "DETECTION_UPDATE",
 					status
 				}),
-				onFrame: (frame) => sendBack({
-					type: "DETECTION_FRAME",
-					frame
-				}),
 				onSuccess: (canvas, faceCoordinates) => sendBack({
 					type: "DETECTION_SUCCESS",
 					canvas,
@@ -176,7 +172,8 @@ const _faceCaptureMachine = setup({
 				stream: void 0,
 				provider: void 0,
 				frameCapturer: void 0,
-				avatarCanvas: void 0
+				avatarCanvas: void 0,
+				usingBackCamera: false
 			};
 		}),
 		setStreamAndCapturer: assign({
@@ -188,6 +185,10 @@ const _faceCaptureMachine = setup({
 			},
 			frameCapturer: ({ event }) => {
 				if ("output" in event) return new StreamCanvasCapture(event.output.stream);
+			},
+			usingBackCamera: ({ event }) => {
+				if ("output" in event) return event.output.usingBackCamera;
+				return false;
 			}
 		}),
 		trackTutorial: () => void 0,
@@ -196,9 +197,9 @@ const _faceCaptureMachine = setup({
 			stream: void 0,
 			provider: void 0,
 			frameCapturer: void 0,
+			usingBackCamera: false,
 			error: void 0,
 			detectionStatus: "idle",
-			debugFrame: void 0,
 			capturedImage: void 0,
 			faceCoordinates: void 0,
 			uploadResponse: void 0,
@@ -236,7 +237,8 @@ const _faceCaptureMachine = setup({
 				stream: void 0,
 				provider: void 0,
 				frameCapturer: void 0,
-				avatarCanvas: void 0
+				avatarCanvas: void 0,
+				usingBackCamera: false
 			};
 		}),
 		decrementAttemptsRemaining: assign(({ context }) => ({ attemptsRemaining: context.attemptsRemaining - 1 })),
@@ -261,7 +263,6 @@ const _faceCaptureMachine = setup({
 			const status = event.status;
 			return context.manualCaptureTriggered || status === "manualCapture";
 		} }),
-		setDebugFrameFromEvent: assign({ debugFrame: ({ event }) => event.frame }),
 		setAvatarCanvas: assign({ avatarCanvas: ({ event }) => event.canvas }),
 		clearAvatarCanvas: assign({ avatarCanvas: () => void 0 }),
 		setResetDetectionFromEvent: assign({ resetDetection: ({ event }) => event.reset }),
@@ -288,10 +289,22 @@ const _faceCaptureMachine = setup({
 		preloadRecordingProvider: ({ context }) => {
 			if (context.config.enableFaceRecording === true && context.config.deepsightLiveness !== "VIDEOLIVENESS") preloadOpenViduProvider();
 		},
+		warmAvatarProvider: ({ context }) => {
+			const { obfuscateWithAvatar, avatarVariant } = concealmentToAvatar(context.config.selfieConcealmentOption);
+			if (!obfuscateWithAvatar || !avatarVariant) return;
+			warmFaceAvatar({
+				variant: avatarVariant,
+				assets: context.config.avatarAssets
+			});
+		},
+		releaseAvatarWarmup: () => {
+			releaseFaceAvatarWarmup();
+		},
 		noOp: () => void 0
 	},
 	guards: {
 		hasShowTutorial: ({ context }) => context.config.showTutorial,
+		hasAgeAssurance: ({ context }) => context.config.ageAssurance === true,
 		isPermissionGranted: ({ event }) => {
 			if ("output" in event) return event.output === "granted";
 			return false;
@@ -327,9 +340,9 @@ const _faceCaptureMachine = setup({
 		stream: void 0,
 		provider: void 0,
 		frameCapturer: void 0,
+		usingBackCamera: false,
 		error: void 0,
 		detectionStatus: "idle",
-		debugFrame: void 0,
 		capturedImage: void 0,
 		faceCoordinates: void 0,
 		uploadResponse: void 0,
@@ -349,12 +362,19 @@ const _faceCaptureMachine = setup({
 	}),
 	on: { QUIT: { target: "#faceCapture.closed" } },
 	states: {
-		idle: { on: { LOAD: [{
-			target: "tutorial",
-			guard: "hasShowTutorial"
-		}, { target: "loading" }] } },
+		idle: { on: { LOAD: [
+			{
+				target: "tutorial",
+				guard: "hasShowTutorial"
+			},
+			{
+				target: "tutorial",
+				guard: "hasAgeAssurance"
+			},
+			{ target: "loading" }
+		] } },
 		loading: {
-			entry: "preloadRecordingProvider",
+			entry: ["preloadRecordingProvider", "warmAvatarProvider"],
 			invoke: [{
 				id: "checkPermissionLoading",
 				src: "checkPermission",
@@ -379,7 +399,11 @@ const _faceCaptureMachine = setup({
 		},
 		tutorial: {
 			initial: "checkingPermission",
-			entry: ["trackTutorial", "preloadRecordingProvider"],
+			entry: [
+				"trackTutorial",
+				"preloadRecordingProvider",
+				"warmAvatarProvider"
+			],
 			states: {
 				checkingPermission: { invoke: {
 					id: "checkPermissionTutorial",
@@ -498,7 +522,7 @@ const _faceCaptureMachine = setup({
 			}
 		},
 		permissions: {
-			entry: "preloadRecordingProvider",
+			entry: ["preloadRecordingProvider", "warmAvatarProvider"],
 			initial: "checkingDeepsight",
 			states: {
 				checkingDeepsight: { always: [{
@@ -591,7 +615,7 @@ const _faceCaptureMachine = setup({
 			}
 		},
 		capture: {
-			entry: "preloadRecordingProvider",
+			entry: ["preloadRecordingProvider", "warmAvatarProvider"],
 			initial: "checkingDeepsight",
 			exit: [
 				"stopMediaStream",
@@ -701,7 +725,6 @@ const _faceCaptureMachine = setup({
 					exit: ["clearAvatarCanvas"],
 					on: {
 						DETECTION_UPDATE: { actions: ["setDetectionStatusFromEvent", "setManualCaptureTriggered"] },
-						DETECTION_FRAME: { actions: "setDebugFrameFromEvent" },
 						AVATAR_READY: { actions: "setAvatarCanvas" },
 						DETECTION_RESET_READY: { actions: "setResetDetectionFromEvent" },
 						DETECTION_SUCCESS: {
@@ -820,15 +843,15 @@ const _faceCaptureMachine = setup({
 			}
 		},
 		finished: {
-			entry: "stopMediaStream",
+			entry: ["stopMediaStream", "releaseAvatarWarmup"],
 			type: "final"
 		},
 		closed: {
-			entry: "stopMediaStream",
+			entry: ["stopMediaStream", "releaseAvatarWarmup"],
 			type: "final"
 		},
 		error: {
-			entry: "stopMediaStream",
+			entry: ["stopMediaStream", "releaseAvatarWarmup"],
 			on: { RESET: {
 				target: "idle",
 				actions: "resetContext"
@@ -836,7 +859,5 @@ const _faceCaptureMachine = setup({
 		}
 	}
 });
-const faceCaptureMachine = _faceCaptureMachine;
-
 //#endregion
-export { concealmentToAvatar as n, faceCaptureMachine as t };
+export { concealmentToAvatar as n, faceCaptureMachine as t };

package/dist/faceMatchManager-BXp2WUT-.esm.js

@@ -0,0 +1,201 @@
+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 faceMatchMachine } from "./faceMatchStateMachine-CJiO2yLO.esm.js";
+//#region src/modules/face-match/faceMatchActor.ts
+function createFaceMatchActor(options) {
+	return createActor(faceMatchMachine, { input: { config: options.config } }).start();
+}
+//#endregion
+//#region src/modules/face-match/faceMatchManager.ts
+/**
+* @module @incodetech/core/face-match
+*
+* Face match module for the Incode Web SDK.
+* Supports both headless (programmatic) and UI-driven usage patterns.
+*
+* ## Headless Usage
+*
+* The face match manager can be used entirely without UI for backend integrations,
+* custom UI implementations, or automated workflows.
+*
+* @example Basic headless face match with auto-skip
+* ```typescript
+* import { createFaceMatchManager } from '@incodetech/core/face-match';
+* import { setup } from '@incodetech/core';
+*
+* // 1. Configure the SDK (required before using any module)
+* setup({ apiURL: 'https://api.example.com', token: 'your-token' });
+*
+* // 2. Create the face match manager
+* const faceMatchManager = createFaceMatchManager({
+*   config: {
+*     matchingType: 'selfieVsId',
+*     disableFaceMatchAnimation: true,
+*   },
+* });
+*
+* // 3. Subscribe to state changes (optional but recommended)
+* faceMatchManager.subscribe((state) => {
+*   console.log('Face match state:', state.status);
+*   if (state.status === 'finished') {
+*     console.log('Face match complete!', state.matched);
+*   }
+*   if (state.status === 'error') {
+*     console.error('Error:', state.error);
+*   }
+* });
+*
+* // 4. Start the flow
+* faceMatchManager.load();
+*
+* // 5. Auto-completes when disableFaceMatchAnimation is true
+* // Or call faceMatchManager.continue() after animation in custom UI
+*
+* // 6. Clean up when done
+* faceMatchManager.stop();
+* ```
+*
+* @example Headless face match with custom UI
+* ```typescript
+* const faceMatchManager = createFaceMatchManager({
+*   config: { matchingType: 'selfieVsId', disableFaceMatchAnimation: false },
+* });
+*
+* faceMatchManager.subscribe((state) => {
+*   if (state.status === 'animating') {
+*     // Render your custom animation
+*     renderAnimation(state.images, state.result);
+*   }
+*   if (state.status === 'result') {
+*     // Show result and wait for user to click continue
+*     showResult(state.matched);
+*   }
+* });
+*
+* faceMatchManager.load();
+* // When animation completes in your UI:
+* faceMatchManager.animationComplete();
+* // When user clicks continue:
+* faceMatchManager.continue();
+* ```
+*/
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("loading")) return { status: "loading" };
+	if (typedSnapshot.matches("animating")) return {
+		status: "animating",
+		images: context.images,
+		result: context.result
+	};
+	if (typedSnapshot.matches("result")) return {
+		status: "result",
+		images: context.images,
+		result: context.result,
+		matched: context.result.matched
+	};
+	if (typedSnapshot.matches("finished")) return {
+		status: "finished",
+		matched: context.result?.matched ?? null
+	};
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "An error occurred"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		/**
+		* Initializes the face match flow.
+		* Transitions from 'idle' to 'loading'.
+		* Must be called before any other method.
+		*/
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		/**
+		* Signals that the animation has completed.
+		* Should be called when state is 'animating' and your UI animation finishes.
+		* Transitions to 'result' state.
+		*/
+		animationComplete() {
+			actor.send({ type: "ANIMATION_COMPLETE" });
+		},
+		/**
+		* User clicked continue button.
+		* Should be called when state is 'result'.
+		* Transitions to 'finished' state.
+		*/
+		continue() {
+			trackElementClicked?.("continue");
+			actor.send({ type: "CONTINUE" });
+		},
+		/**
+		* Resets the manager to initial state.
+		* Can be called from 'error' state to start over.
+		* Clears all stored data including images and result.
+		*/
+		reset() {
+			actor.send({ type: "RESET" });
+		}
+	};
+}
+/**
+* Creates a face match manager for headless or UI-driven usage.
+*
+* The manager provides a state machine-based API for face comparison
+* with optional animation display.
+*
+* @param options - Configuration options
+* @param options.config - Face match configuration
+* @param options.config.matchingType - Which images to compare (default: 'selfieVsId')
+* @param options.config.disableFaceMatchAnimation - Skip animation and auto-complete (default: false)
+*
+* @returns Face match manager with state, API methods, and subscription
+*
+* @example Headless usage
+* ```typescript
+* const manager = createFaceMatchManager({
+*   config: { matchingType: 'selfieVsId', disableFaceMatchAnimation: true },
+* });
+*
+* manager.subscribe((state) => console.log(state.status));
+* manager.load();
+* // Auto-completes when disableFaceMatchAnimation is true
+* manager.stop();
+* ```
+*
+* @example With React/Preact UI hook
+* ```tsx
+* const [state, manager] = useManager(() => createFaceMatchManager({ config }));
+*
+* if (state.status === 'animating') {
+*   return <Animation images={state.images} />;
+* }
+* ```
+*/
+function createFaceMatchManager(options) {
+	return createManager({
+		actor: createFaceMatchActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.faceMatch)
+	});
+}
+/**
+* Creates a face-match manager from a pre-built actor.
+* Use this when overriding the machine via `.provide()` for custom backends
+* or for story-isolation testing.
+*/
+function createFaceMatchManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.faceMatch)
+	});
+}
+//#endregion
+export { createFaceMatchManagerFromActor as n, createFaceMatchManager as t };

package/dist/faceMatchManager-BnvrZM2F.d.ts

@@ -0,0 +1,268 @@
+import { T as Actor } from "./spawn-D9jgw9pW.js";
+import "./StateMachine-EDpYWy0i.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+//#region src/modules/face-match/types.d.ts
+/**
+ * Face match comparison variant.
+ * Determines which images are compared in the face match flow.
+ */
+type FaceMatchVariant = 'selfieVsId' | 'selfieVsNfc' | 'idVsNfc' | 'nfc3Way' | 'secondId';
+/**
+ * Configuration options for face match module.
+ *
+ * @example Standard face match with animation
+ * ```typescript
+ * const config: FaceMatchConfig = {
+ *   matchingType: 'selfieVsId',
+ *   disableFaceMatchAnimation: false,
+ * };
+ * ```
+ *
+ * @example Auto-skip mode (headless)
+ * ```typescript
+ * const config: FaceMatchConfig = {
+ *   matchingType: 'selfieVsId',
+ *   disableFaceMatchAnimation: true,
+ * };
+ * ```
+ */
+type FaceMatchConfig = {
+  /**
+   * Which images to compare in the face match flow.
+   * Backend field name: `matchingType`.
+   * @default 'selfieVsId'
+   */
+  matchingType?: FaceMatchVariant;
+  /**
+   * When true, skips the animation UI and auto-completes immediately after fetching data.
+   * Useful for headless integrations or silent verification flows.
+   * @default false
+   */
+  disableFaceMatchAnimation?: boolean;
+  /**
+   * When true, the module completes immediately on mount WITHOUT fetching data
+   * or rendering any match UI. Set by the Flow orchestrator under US Smart
+   * Capture when the ID was captured without a front image ("no front, no
+   * match") — there is no ID face to compare against. Distinct from (and
+   * complementary to) the reactive backend-4084 skip: this avoids mounting the
+   * module and the failing fetch entirely.
+   * @default false
+   */
+  skipFaceMatch?: boolean;
+};
+/**
+ * Cropped face images fetched from the backend.
+ */
+type FaceMatchImages = {
+  /**
+   * Cropped face from ID document.
+   */
+  idFace: string | null;
+  /**
+   * Cropped selfie image (from face capture).
+   */
+  selfie: string | null;
+  /**
+   * Cropped face from second ID document (only for 'secondId' variant).
+   */
+  secondIdFace?: string | null;
+};
+/**
+ * Face match result parsed from score response.
+ */
+type FaceMatchResult = {
+  /**
+   * Whether faces matched (OK = true, FAIL = false, null = unknown).
+   */
+  matched: boolean | null;
+  /**
+   * Whether liveness check passed.
+   */
+  liveness: boolean | null;
+};
+//#endregion
+//#region src/modules/face-match/faceMatchActor.d.ts
+type CreateFaceMatchActorOptions = {
+  config: FaceMatchConfig;
+};
+declare function createFaceMatchActor(options: CreateFaceMatchActorOptions): Actor<any>;
+type FaceMatchActor = ReturnType<typeof createFaceMatchActor>;
+//#endregion
+//#region src/modules/face-match/faceMatchManager.d.ts
+/** Face match manager is in initial state, waiting for `load()` to be called */
+type FaceMatchIdleState = {
+  status: 'idle';
+};
+/** Fetching images and score from backend */
+type FaceMatchLoadingState = {
+  status: 'loading';
+};
+/**
+ * Animation is playing - images are animating.
+ * @property images - Cropped face images fetched from backend
+ * @property result - Face match result (matched, liveness)
+ */
+type FaceMatchAnimatingState = {
+  status: 'animating';
+  images: {
+    idFace: string | null;
+    selfie: string | null;
+    secondIdFace?: string | null;
+  };
+  result: {
+    matched: boolean | null;
+    liveness: boolean | null;
+  };
+};
+/**
+ * Showing match result - waiting for user to click continue.
+ * @property images - Cropped face images
+ * @property result - Face match result
+ * @property matched - Whether faces matched (true/false/null)
+ */
+type FaceMatchResultState = {
+  status: 'result';
+  images: {
+    idFace: string | null;
+    selfie: string | null;
+    secondIdFace?: string | null;
+  };
+  result: {
+    matched: boolean | null;
+    liveness: boolean | null;
+  };
+  matched: boolean | null;
+};
+/** Face match completed successfully */
+type FaceMatchFinishedState = {
+  status: 'finished';
+  matched: boolean | null;
+};
+/**
+ * Fatal error occurred - call `reset()` to start over
+ * @property error - Error message describing what went wrong
+ */
+type FaceMatchErrorState = {
+  status: 'error';
+  error: string;
+};
+/**
+ * Union of all possible face match manager states.
+ * Use discriminated union pattern to narrow the type:
+ *
+ * @example
+ * ```typescript
+ * const state = faceMatchManager.getState();
+ * if (state.status === 'animating') {
+ *   // TypeScript knows state has images and result
+ *   console.log(state.images.idFace);
+ * }
+ * ```
+ */
+type FaceMatchState = FaceMatchIdleState | FaceMatchLoadingState | FaceMatchAnimatingState | FaceMatchResultState | FaceMatchFinishedState | FaceMatchErrorState;
+/**
+ * Creates a face match manager for headless or UI-driven usage.
+ *
+ * The manager provides a state machine-based API for face comparison
+ * with optional animation display.
+ *
+ * @param options - Configuration options
+ * @param options.config - Face match configuration
+ * @param options.config.matchingType - Which images to compare (default: 'selfieVsId')
+ * @param options.config.disableFaceMatchAnimation - Skip animation and auto-complete (default: false)
+ *
+ * @returns Face match manager with state, API methods, and subscription
+ *
+ * @example Headless usage
+ * ```typescript
+ * const manager = createFaceMatchManager({
+ *   config: { matchingType: 'selfieVsId', disableFaceMatchAnimation: true },
+ * });
+ *
+ * manager.subscribe((state) => console.log(state.status));
+ * manager.load();
+ * // Auto-completes when disableFaceMatchAnimation is true
+ * manager.stop();
+ * ```
+ *
+ * @example With React/Preact UI hook
+ * ```tsx
+ * const [state, manager] = useManager(() => createFaceMatchManager({ config }));
+ *
+ * if (state.status === 'animating') {
+ *   return <Animation images={state.images} />;
+ * }
+ * ```
+ */
+declare function createFaceMatchManager(options: CreateFaceMatchActorOptions): Manager<FaceMatchState> & {
+  /**
+   * Initializes the face match flow.
+   * Transitions from 'idle' to 'loading'.
+   * Must be called before any other method.
+   */
+  load(): void;
+  /**
+   * Signals that the animation has completed.
+   * Should be called when state is 'animating' and your UI animation finishes.
+   * Transitions to 'result' state.
+   */
+  animationComplete(): void;
+  /**
+   * User clicked continue button.
+   * Should be called when state is 'result'.
+   * Transitions to 'finished' state.
+   */
+  continue(): void;
+  /**
+   * Resets the manager to initial state.
+   * Can be called from 'error' state to start over.
+   * Clears all stored data including images and result.
+   */
+  reset(): void;
+};
+/**
+ * Creates a face-match manager from a pre-built actor.
+ * Use this when overriding the machine via `.provide()` for custom backends
+ * or for story-isolation testing.
+ */
+declare function createFaceMatchManagerFromActor(actor: FaceMatchActor): Manager<FaceMatchState> & {
+  /**
+   * Initializes the face match flow.
+   * Transitions from 'idle' to 'loading'.
+   * Must be called before any other method.
+   */
+  load(): void;
+  /**
+   * Signals that the animation has completed.
+   * Should be called when state is 'animating' and your UI animation finishes.
+   * Transitions to 'result' state.
+   */
+  animationComplete(): void;
+  /**
+   * User clicked continue button.
+   * Should be called when state is 'result'.
+   * Transitions to 'finished' state.
+   */
+  continue(): void;
+  /**
+   * Resets the manager to initial state.
+   * Can be called from 'error' state to start over.
+   * Clears all stored data including images and result.
+   */
+  reset(): void;
+};
+/**
+ * Type representing a face match manager instance.
+ * Includes state access, API methods, and lifecycle management.
+ *
+ * @property getState - Returns the current FaceMatchState
+ * @property subscribe - Subscribes to state changes, returns unsubscribe function
+ * @property stop - Stops the manager and cleans up resources
+ * @property load - Initializes the face match flow
+ * @property animationComplete - Signals animation finished
+ * @property continue - User clicked continue button
+ * @property reset - Resets to initial state
+ */
+type FaceMatchManager = ReturnType<typeof createFaceMatchManager>;
+//#endregion
+export { FaceMatchActor as a, FaceMatchResult as c, createFaceMatchManagerFromActor as i, FaceMatchVariant as l, FaceMatchState as n, FaceMatchConfig as o, createFaceMatchManager as r, FaceMatchImages as s, FaceMatchManager as t };