@smileid/usesmileid 12.0.0 → 12.0.1

package/src/presentation/screen/__tests__/capture_ui_state.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
-import type { ScanState } from "@smileid/usesmileid_bridge";
-import { ScanStateType } from "@smileid/usesmileid_bridge";
+import type { UseSmileIDScanState } from "@smileid/usesmileid_bridge";
+import { UseSmileIDScanStateType } from "@smileid/usesmileid_bridge";
 import { CaptureType } from "../../../core/models/ml_config";
 import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
 import {
@@ -16,7 +16,10 @@ import {
 
 describe("mapSelfieUiState — standard flow", () => {
   it("maps initial to the standard primer", () => {
-    const ui = mapSelfieUiState({ type: ScanStateType.Initial }, false);
+    const ui = mapSelfieUiState(
+      { type: UseSmileIDScanStateType.Initial },
+      false,
+    );
     expect(ui.overlayState).toBe(UseSmileIDOverlayState.INSTRUCTION);
     expect(ui.feedbackKey).toBe("si_capture_initial_instruction");
     expect(ui.captureProgress).toBe(0);
@@ -26,7 +29,7 @@ describe("mapSelfieUiState — standard flow", () => {
   it("passes the analyzer feedback key through on found", () => {
     const ui = mapSelfieUiState(
       {
-        type: ScanStateType.Found,
+        type: UseSmileIDScanStateType.Found,
         feedback: "si_capture_move_left",
         captureProgress: 0.4,
       },
@@ -40,10 +43,13 @@ describe("mapSelfieUiState — standard flow", () => {
   it("shows the in-capture copy on found-default and satisfied", () => {
     // All checks passing means frames are being collected — the
     // guidance reads "Capturing…", never the pre-start instruction.
-    const found = mapSelfieUiState({ type: ScanStateType.Found }, false);
+    const found = mapSelfieUiState(
+      { type: UseSmileIDScanStateType.Found },
+      false,
+    );
     expect(found.feedbackKey).toBe("si_capturing");
     const satisfied = mapSelfieUiState(
-      { type: ScanStateType.Satisfied },
+      { type: UseSmileIDScanStateType.Satisfied },
       false,
     );
     expect(satisfied.feedbackKey).toBe("si_capturing");
@@ -54,14 +60,20 @@ describe("mapSelfieUiState — standard flow", () => {
   });
 
   it("maps finished through the shared terminal snapshot", () => {
-    const ui = mapSelfieUiState({ type: ScanStateType.Finished }, false);
+    const ui = mapSelfieUiState(
+      { type: UseSmileIDScanStateType.Finished },
+      false,
+    );
     expect(ui).toEqual(scannedUiState(false));
     expect(ui.feedbackKey).toBe("si_selfie_capture_complete");
     expect(ui.captureProgress).toBe(1);
   });
 
   it("maps timeout to idle with the timeout copy", () => {
-    const ui = mapSelfieUiState({ type: ScanStateType.Timeout }, false);
+    const ui = mapSelfieUiState(
+      { type: UseSmileIDScanStateType.Timeout },
+      false,
+    );
     expect(ui.overlayState).toBe(UseSmileIDOverlayState.IDLE);
     expect(ui.feedbackKey).toBe("si_capture_timeout");
   });
@@ -69,15 +81,18 @@ describe("mapSelfieUiState — standard flow", () => {
 
 describe("mapSelfieUiState — Enhanced Smart Selfie", () => {
   it("swaps the initial primer for the head-turn instruction", () => {
-    const ui = mapSelfieUiState({ type: ScanStateType.Initial }, true);
+    const ui = mapSelfieUiState(
+      { type: UseSmileIDScanStateType.Initial },
+      true,
+    );
     expect(ui.feedbackKey).toBe("si_ess_capture_initial_instruction");
   });
 
   it("shows hold-still through active capture (found-default / satisfied)", () => {
     for (const scanState of [
-      { type: ScanStateType.Found },
-      { type: ScanStateType.Satisfied },
-    ] satisfies ScanState[]) {
+      { type: UseSmileIDScanStateType.Found },
+      { type: UseSmileIDScanStateType.Satisfied },
+    ] satisfies UseSmileIDScanState[]) {
       expect(mapSelfieUiState(scanState, true).feedbackKey).toBe(
         "si_ess_hold_still",
       );
@@ -85,24 +100,25 @@ describe("mapSelfieUiState — Enhanced Smart Selfie", () => {
     // Finished shows the completion copy in both modes; only the oval
     // fill differs under Enhanced Smart Selfie.
     expect(
-      mapSelfieUiState({ type: ScanStateType.Finished }, true).feedbackKey,
+      mapSelfieUiState({ type: UseSmileIDScanStateType.Finished }, true)
+        .feedbackKey,
     ).toBe("si_selfie_capture_complete");
   });
 
   it("zeroes captureProgress everywhere — the oval never fills under ESS", () => {
     for (const scanState of [
-      { type: ScanStateType.Found, captureProgress: 0.6 },
-      { type: ScanStateType.Satisfied },
-      { type: ScanStateType.Finished },
-      { type: ScanStateType.HeadTurn, currentDirection: "left" },
-    ] satisfies ScanState[]) {
+      { type: UseSmileIDScanStateType.Found, captureProgress: 0.6 },
+      { type: UseSmileIDScanStateType.Satisfied },
+      { type: UseSmileIDScanStateType.Finished },
+      { type: UseSmileIDScanStateType.HeadTurn, currentDirection: "left" },
+    ] satisfies UseSmileIDScanState[]) {
       expect(mapSelfieUiState(scanState, true).captureProgress).toBe(0);
     }
   });
 
   it("keeps explicit guidance keys ahead of hold-still during found", () => {
     const ui = mapSelfieUiState(
-      { type: ScanStateType.Found, feedback: "si_capture_too_close" },
+      { type: UseSmileIDScanStateType.Found, feedback: "si_capture_too_close" },
       true,
     );
     expect(ui.feedbackKey).toBe("si_capture_too_close");
@@ -116,7 +132,7 @@ describe("mapSelfieUiState — Enhanced Smart Selfie", () => {
     ] as const;
     for (const [direction, expectedKey] of directions) {
       const ui = mapSelfieUiState(
-        { type: ScanStateType.HeadTurn, currentDirection: direction },
+        { type: UseSmileIDScanStateType.HeadTurn, currentDirection: direction },
         true,
       );
       expect(ui.overlayState).toBe(UseSmileIDOverlayState.HEAD_TURN);
@@ -127,7 +143,10 @@ describe("mapSelfieUiState — Enhanced Smart Selfie", () => {
   });
 
   it("falls back to hold-steady when headTurn arrives without a direction", () => {
-    const ui = mapSelfieUiState({ type: ScanStateType.HeadTurn }, true);
+    const ui = mapSelfieUiState(
+      { type: UseSmileIDScanStateType.HeadTurn },
+      true,
+    );
     expect(ui.feedbackKey).toBe("si_capture_hold_steady");
     expect(ui.animationDirection).toBeNull();
   });
@@ -135,7 +154,7 @@ describe("mapSelfieUiState — Enhanced Smart Selfie", () => {
   it("threads poseMatched into the head-turn state (drives grey→green)", () => {
     const matched = mapSelfieUiState(
       {
-        type: ScanStateType.HeadTurn,
+        type: UseSmileIDScanStateType.HeadTurn,
         currentDirection: "left",
         poseMatched: true,
       },
@@ -145,7 +164,7 @@ describe("mapSelfieUiState — Enhanced Smart Selfie", () => {
     expect(matched.poseMatched).toBe(true);
 
     const pending = mapSelfieUiState(
-      { type: ScanStateType.HeadTurn, currentDirection: "left" },
+      { type: UseSmileIDScanStateType.HeadTurn, currentDirection: "left" },
       true,
     );
     expect(pending.poseMatched).toBe(false);
@@ -159,7 +178,7 @@ describe("mapSelfieUiState — Enhanced Smart Selfie", () => {
     ] as const) {
       const ui = mapSelfieUiState(
         {
-          type: ScanStateType.HeadTurn,
+          type: UseSmileIDScanStateType.HeadTurn,
           currentDirection: "left",
           feedback,
           poseMatched: true,
@@ -182,7 +201,7 @@ describe("mapSelfieUiState — Enhanced Smart Selfie", () => {
     ] as const) {
       const ui = mapSelfieUiState(
         {
-          type: ScanStateType.HeadTurn,
+          type: UseSmileIDScanStateType.HeadTurn,
           currentDirection: "up",
           feedback,
           poseMatched: true,
@@ -203,7 +222,7 @@ describe("mapSelfieUiState — Enhanced Smart Selfie", () => {
     ] as const) {
       const ui = mapSelfieUiState(
         {
-          type: ScanStateType.HeadTurn,
+          type: UseSmileIDScanStateType.HeadTurn,
           currentDirection: "right",
           feedback,
           poseMatched: true,
@@ -241,7 +260,7 @@ describe("withEnhancedLivenessPolicy", () => {
 
 describe("document mapping", () => {
   it("maps finished through the shared document terminal snapshot", () => {
-    const ui = mapDocumentUiState({ type: ScanStateType.Finished });
+    const ui = mapDocumentUiState({ type: UseSmileIDScanStateType.Finished });
     expect(ui).toEqual(scannedDocumentUiState());
     expect(ui.feedbackKey).toBe("si_document_capture_complete");
     expect(ui.captureProgress).toBe(1);
@@ -249,7 +268,7 @@ describe("document mapping", () => {
 
   it("passes document feedback keys through on found", () => {
     const ui = mapDocumentUiState({
-      type: ScanStateType.Found,
+      type: UseSmileIDScanStateType.Found,
       feedback: "si_document_too_far",
     });
     expect(ui.overlayState).toBe(UseSmileIDOverlayState.DOCUMENT_TOO_FAR);
@@ -257,7 +276,7 @@ describe("document mapping", () => {
   });
 
   it("treats a degenerate headTurn as the pre-capture instruction", () => {
-    const ui = mapDocumentUiState({ type: ScanStateType.HeadTurn });
+    const ui = mapDocumentUiState({ type: UseSmileIDScanStateType.HeadTurn });
     expect(ui.overlayState).toBe(UseSmileIDOverlayState.INSTRUCTION);
     expect(ui.feedbackKey).toBe("si_document_initial_instruction");
   });
@@ -287,14 +306,14 @@ describe("mapCaptureUiState dispatch", () => {
   it("routes by capture type", () => {
     expect(
       mapCaptureUiState(
-        { type: ScanStateType.Initial },
+        { type: UseSmileIDScanStateType.Initial },
         CaptureType.selfie,
         true,
       ).feedbackKey,
     ).toBe("si_ess_capture_initial_instruction");
     expect(
       mapCaptureUiState(
-        { type: ScanStateType.Initial },
+        { type: UseSmileIDScanStateType.Initial },
         CaptureType.document,
         // ESS is a selfie-only concept; the flag must not leak into
         // the document mapping.
@@ -308,8 +327,8 @@ describe("isSessionBoundary", () => {
   it("returns true for unsatisfied → found (leaving unsatisfied is a boundary)", () => {
     expect(
       isSessionBoundary(
-        { type: ScanStateType.Unsatisfied },
-        { type: ScanStateType.Found },
+        { type: UseSmileIDScanStateType.Unsatisfied },
+        { type: UseSmileIDScanStateType.Found },
       ),
     ).toBe(true);
   });
@@ -317,8 +336,8 @@ describe("isSessionBoundary", () => {
   it("returns true for unsatisfied → initial", () => {
     expect(
       isSessionBoundary(
-        { type: ScanStateType.Unsatisfied },
-        { type: ScanStateType.Initial },
+        { type: UseSmileIDScanStateType.Unsatisfied },
+        { type: UseSmileIDScanStateType.Initial },
       ),
     ).toBe(true);
   });
@@ -326,8 +345,8 @@ describe("isSessionBoundary", () => {
   it("returns true for timeout → initial (session restart)", () => {
     expect(
       isSessionBoundary(
-        { type: ScanStateType.Timeout },
-        { type: ScanStateType.Initial },
+        { type: UseSmileIDScanStateType.Timeout },
+        { type: UseSmileIDScanStateType.Initial },
       ),
     ).toBe(true);
   });
@@ -335,8 +354,8 @@ describe("isSessionBoundary", () => {
   it("returns true for finished → initial (session restart)", () => {
     expect(
       isSessionBoundary(
-        { type: ScanStateType.Finished },
-        { type: ScanStateType.Initial },
+        { type: UseSmileIDScanStateType.Finished },
+        { type: UseSmileIDScanStateType.Initial },
       ),
     ).toBe(true);
   });
@@ -344,8 +363,8 @@ describe("isSessionBoundary", () => {
   it("returns false for found → unsatisfied (entering unsatisfied, not leaving)", () => {
     expect(
       isSessionBoundary(
-        { type: ScanStateType.Found },
-        { type: ScanStateType.Unsatisfied },
+        { type: UseSmileIDScanStateType.Found },
+        { type: UseSmileIDScanStateType.Unsatisfied },
       ),
     ).toBe(false);
   });
@@ -353,8 +372,8 @@ describe("isSessionBoundary", () => {
   it("returns false for same-type transition (found → found)", () => {
     expect(
       isSessionBoundary(
-        { type: ScanStateType.Found },
-        { type: ScanStateType.Found },
+        { type: UseSmileIDScanStateType.Found },
+        { type: UseSmileIDScanStateType.Found },
       ),
     ).toBe(false);
   });
@@ -362,8 +381,8 @@ describe("isSessionBoundary", () => {
   it("returns false for initial → found (normal forward progression)", () => {
     expect(
       isSessionBoundary(
-        { type: ScanStateType.Initial },
-        { type: ScanStateType.Found },
+        { type: UseSmileIDScanStateType.Initial },
+        { type: UseSmileIDScanStateType.Found },
       ),
     ).toBe(false);
   });
@@ -371,8 +390,8 @@ describe("isSessionBoundary", () => {
   it("returns false for timeout → found (only initial restarts after a terminal state)", () => {
     expect(
       isSessionBoundary(
-        { type: ScanStateType.Timeout },
-        { type: ScanStateType.Found },
+        { type: UseSmileIDScanStateType.Timeout },
+        { type: UseSmileIDScanStateType.Found },
       ),
     ).toBe(false);
   });

package/src/presentation/screen/__tests__/ess_turn_haptics.test.ts

@@ -1,16 +1,16 @@
 import { describe, expect, it, vi, beforeEach } from "vitest";
 import * as Haptics from "expo-haptics";
-import type { ScanState } from "@smileid/usesmileid_bridge";
-import { ScanStateType } from "@smileid/usesmileid_bridge";
+import type { UseSmileIDScanState } from "@smileid/usesmileid_bridge";
+import { UseSmileIDScanStateType } from "@smileid/usesmileid_bridge";
 import {
   essTurnHaptic,
   triggerEssTurnHaptic,
 } from "../helpers/ess_turn_haptics";
 
-const headTurn = (direction?: "left" | "right" | "up"): ScanState =>
+const headTurn = (direction?: "left" | "right" | "up"): UseSmileIDScanState =>
   direction === undefined
-    ? { type: ScanStateType.HeadTurn }
-    : { type: ScanStateType.HeadTurn, currentDirection: direction };
+    ? { type: UseSmileIDScanStateType.HeadTurn }
+    : { type: UseSmileIDScanStateType.HeadTurn, currentDirection: direction };
 
 describe("essTurnHaptic", () => {
   it("fires intermediate when the requested direction advances", () => {
@@ -24,9 +24,9 @@ describe("essTurnHaptic", () => {
 
   it("fires final when leaving the head-turn phase toward capture", () => {
     for (const next of [
-      ScanStateType.Found,
-      ScanStateType.Satisfied,
-      ScanStateType.Finished,
+      UseSmileIDScanStateType.Found,
+      UseSmileIDScanStateType.Satisfied,
+      UseSmileIDScanStateType.Finished,
     ] as const) {
       expect(essTurnHaptic(headTurn("up"), { type: next })).toBe("final");
     }
@@ -34,10 +34,14 @@ describe("essTurnHaptic", () => {
 
   it("never fires on a reset (head turn abandoned to initial / timeout)", () => {
     expect(
-      essTurnHaptic(headTurn("left"), { type: ScanStateType.Initial }),
+      essTurnHaptic(headTurn("left"), {
+        type: UseSmileIDScanStateType.Initial,
+      }),
     ).toBeNull();
     expect(
-      essTurnHaptic(headTurn("left"), { type: ScanStateType.Timeout }),
+      essTurnHaptic(headTurn("left"), {
+        type: UseSmileIDScanStateType.Timeout,
+      }),
     ).toBeNull();
   });
 
@@ -48,7 +52,7 @@ describe("essTurnHaptic", () => {
   it("does not fire when the previous state was not a directed head turn", () => {
     // Entering a head turn is not completing one.
     expect(
-      essTurnHaptic({ type: ScanStateType.Found }, headTurn("left")),
+      essTurnHaptic({ type: UseSmileIDScanStateType.Found }, headTurn("left")),
     ).toBeNull();
     // A head turn with no direction yet has nothing to complete.
     expect(essTurnHaptic(headTurn(), headTurn("left"))).toBeNull();

package/src/presentation/screen/__tests__/scan_state_to_overlay_state.test.ts

@@ -1,13 +1,13 @@
 import { describe, expect, it } from "vitest";
-import { ScanStateType } from "@smileid/usesmileid_bridge";
-import type { ScanState } from "@smileid/usesmileid_bridge";
+import { UseSmileIDScanStateType } from "@smileid/usesmileid_bridge";
+import type { UseSmileIDScanState } from "@smileid/usesmileid_bridge";
 import { mapScanStateToOverlayState } from "../helpers/scan_state_to_overlay_state";
 import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
 import { CaptureType } from "../../../core/models/ml_config";
 
 /**
  * Pure-logic tests for the helper that translates the analyzer's
- * `ScanState` machine into the SDK's visual overlay enum. These cover
+ * `UseSmileIDScanState` machine into the SDK's visual overlay enum. These cover
  * what the legacy screen tests pinned via the now-removed
  * `overlayState=` prop — the screen now derives overlay state from
  * `scanState` per frame, so testing the mapping in isolation gives the
@@ -15,14 +15,18 @@ import { CaptureType } from "../../../core/models/ml_config";
  */
 describe("mapScanStateToOverlayState", () => {
   it("maps the initial state to INSTRUCTION for selfie", () => {
-    const state: ScanState = { type: ScanStateType.Initial };
+    const state: UseSmileIDScanState = {
+      type: UseSmileIDScanStateType.Initial,
+    };
     expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
       UseSmileIDOverlayState.INSTRUCTION,
     );
   });
 
   it("maps the initial state to INSTRUCTION for document", () => {
-    const state: ScanState = { type: ScanStateType.Initial };
+    const state: UseSmileIDScanState = {
+      type: UseSmileIDScanStateType.Initial,
+    };
     expect(mapScanStateToOverlayState(state, CaptureType.document)).toBe(
       UseSmileIDOverlayState.INSTRUCTION,
     );
@@ -32,7 +36,9 @@ describe("mapScanStateToOverlayState", () => {
     // READY drives the bottom-to-top fill animation on the face oval —
     // the analyzer signalling "satisfied" means the pipeline is about
     // to emit captured frames.
-    const state: ScanState = { type: ScanStateType.Satisfied };
+    const state: UseSmileIDScanState = {
+      type: UseSmileIDScanStateType.Satisfied,
+    };
     expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
       UseSmileIDOverlayState.READY,
     );
@@ -42,21 +48,27 @@ describe("mapScanStateToOverlayState", () => {
     // CAPTURING is the yellow-solid state — the analyzer has emitted
     // its captured artifacts and the orchestrator is about to call
     // flush().
-    const state: ScanState = { type: ScanStateType.Finished };
+    const state: UseSmileIDScanState = {
+      type: UseSmileIDScanStateType.Finished,
+    };
     expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
       UseSmileIDOverlayState.CAPTURING,
     );
   });
 
   it("maps the headTurn state to HEAD_TURN", () => {
-    const state: ScanState = { type: ScanStateType.HeadTurn };
+    const state: UseSmileIDScanState = {
+      type: UseSmileIDScanStateType.HeadTurn,
+    };
     expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
       UseSmileIDOverlayState.HEAD_TURN,
     );
   });
 
   it("maps timeout back to IDLE so the overlay returns to the gray pre-capture state", () => {
-    const state: ScanState = { type: ScanStateType.Timeout };
+    const state: UseSmileIDScanState = {
+      type: UseSmileIDScanStateType.Timeout,
+    };
     expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
       UseSmileIDOverlayState.IDLE,
     );
@@ -87,8 +99,8 @@ describe("mapScanStateToOverlayState", () => {
 
     for (const [feedbackKey, expected] of cases) {
       it(`maps found+${feedbackKey} to ${expected}`, () => {
-        const state: ScanState = {
-          type: ScanStateType.Found,
+        const state: UseSmileIDScanState = {
+          type: UseSmileIDScanStateType.Found,
           feedback: feedbackKey,
         };
         expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
@@ -98,7 +110,9 @@ describe("mapScanStateToOverlayState", () => {
     }
 
     it("falls back to FACE_DETECTED when found has no feedback key", () => {
-      const state: ScanState = { type: ScanStateType.Found };
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Found,
+      };
       expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
         UseSmileIDOverlayState.FACE_DETECTED,
       );
@@ -109,8 +123,8 @@ describe("mapScanStateToOverlayState", () => {
       // si_capture_* key the JS side hasn't been updated for. The
       // overlay should stay alive (green-solid) rather than throwing
       // or rendering an empty state.
-      const state: ScanState = {
-        type: ScanStateType.Found,
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Found,
         feedback: "si_capture_future_feedback_key",
       };
       expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
@@ -121,8 +135,8 @@ describe("mapScanStateToOverlayState", () => {
 
   describe("unsatisfied + reason (selfie)", () => {
     it("uses the reason key to drive the orange-solid overlay", () => {
-      const state: ScanState = {
-        type: ScanStateType.Unsatisfied,
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Unsatisfied,
         reason: "si_capture_too_close",
       };
       expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
@@ -131,7 +145,9 @@ describe("mapScanStateToOverlayState", () => {
     });
 
     it("falls back to FACE_NOT_CENTERED on a missing reason key", () => {
-      const state: ScanState = { type: ScanStateType.Unsatisfied };
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Unsatisfied,
+      };
       expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
         UseSmileIDOverlayState.FACE_NOT_CENTERED,
       );
@@ -140,15 +156,17 @@ describe("mapScanStateToOverlayState", () => {
 
   describe("document capture mappings", () => {
     it("maps found+document key to DOCUMENT_READY by default", () => {
-      const state: ScanState = { type: ScanStateType.Found };
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Found,
+      };
       expect(mapScanStateToOverlayState(state, CaptureType.document)).toBe(
         UseSmileIDOverlayState.DOCUMENT_READY,
       );
     });
 
     it("maps the si_document_too_close key to DOCUMENT_TOO_CLOSE", () => {
-      const state: ScanState = {
-        type: ScanStateType.Found,
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Found,
         feedback: "si_document_too_close",
       };
       expect(mapScanStateToOverlayState(state, CaptureType.document)).toBe(
@@ -161,8 +179,8 @@ describe("mapScanStateToOverlayState", () => {
       // si_document_* key or the shared si_capture_* one. Map both
       // to the document overlay enum so the bottom-feedback bubble
       // stays accurate either way.
-      const state: ScanState = {
-        type: ScanStateType.Found,
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Found,
         feedback: "si_capture_too_close",
       };
       expect(mapScanStateToOverlayState(state, CaptureType.document)).toBe(
@@ -171,15 +189,17 @@ describe("mapScanStateToOverlayState", () => {
     });
 
     it("maps unsatisfied+missing reason to DOCUMENT_NOT_CENTERED", () => {
-      const state: ScanState = { type: ScanStateType.Unsatisfied };
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Unsatisfied,
+      };
       expect(mapScanStateToOverlayState(state, CaptureType.document)).toBe(
         UseSmileIDOverlayState.DOCUMENT_NOT_CENTERED,
       );
     });
 
     it("maps si_document_hold_still to DOCUMENT_HOLD_STILL", () => {
-      const state: ScanState = {
-        type: ScanStateType.Found,
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Found,
         feedback: "si_document_hold_still",
       };
       expect(mapScanStateToOverlayState(state, CaptureType.document)).toBe(
@@ -191,8 +211,8 @@ describe("mapScanStateToOverlayState", () => {
       // `si_document_center` is the key the native side actually emits
       // for an off-centre document (the former `si_document_not_centered`
       // was never emitted).
-      const state: ScanState = {
-        type: ScanStateType.Found,
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Found,
         feedback: "si_document_center",
       };
       expect(mapScanStateToOverlayState(state, CaptureType.document)).toBe(