@smileid/usesmileid 12.0.0 → 12.0.2

package/src/presentation/screen/__tests__/use_smile_id_permission_screen.test.tsx

@@ -0,0 +1,68 @@
+import { describe, it, expect } from "vitest";
+import * as React from "react";
+import { create as createRenderer, act } from "react-test-renderer";
+import { UseSmileIDPermissionScreen } from "../use_smile_id_permission_screen";
+import { UseSmileIDThemeProvider } from "../../theme/theme_context";
+import { defaultDarkTheme, defaultLightTheme } from "../../theme/theme";
+
+function render(element: React.ReactElement) {
+  let tree!: ReturnType<typeof createRenderer>;
+  act(() => {
+    tree = createRenderer(element);
+  });
+  return tree;
+}
+
+function rootStyle(
+  tree: ReturnType<typeof createRenderer>,
+): Record<string, unknown> {
+  const json = tree.toJSON() as { props: { style: Record<string, unknown> } };
+  return json.props.style;
+}
+
+describe("UseSmileIDPermissionScreen", () => {
+  it("shows a default camera rationale when the partner supplies none", () => {
+    const tree = render(
+      <UseSmileIDPermissionScreen theme={defaultLightTheme} />,
+    );
+
+    expect(JSON.stringify(tree.toJSON())).toContain(
+      "Camera permission required",
+    );
+  });
+
+  it("shows the partner's rationale when one is supplied", () => {
+    const tree = render(
+      <UseSmileIDPermissionScreen
+        theme={defaultLightTheme}
+        cameraRationale="Acme needs your camera to verify your ID"
+      />,
+    );
+
+    const text = JSON.stringify(tree.toJSON());
+    expect(text).toContain("Acme needs your camera to verify your ID");
+    expect(text).not.toContain("Camera permission required");
+  });
+
+  it("paints on the theme background from the theme prop", () => {
+    const tree = render(
+      <UseSmileIDPermissionScreen theme={defaultDarkTheme} />,
+    );
+
+    expect(rootStyle(tree).backgroundColor).toBe(
+      defaultDarkTheme.colors.background,
+    );
+  });
+
+  it("falls back to the theme from context when no theme prop is given", () => {
+    const tree = render(
+      <UseSmileIDThemeProvider value={defaultDarkTheme}>
+        <UseSmileIDPermissionScreen />
+      </UseSmileIDThemeProvider>,
+    );
+
+    expect(rootStyle(tree).backgroundColor).toBe(
+      defaultDarkTheme.colors.background,
+    );
+  });
+});

package/src/presentation/screen/__tests__/use_smile_id_preview_screen.test.tsx

@@ -5,7 +5,7 @@ import {
   act,
   type ReactTestInstance,
 } from "react-test-renderer";
-import { I18nManager, Pressable, StyleSheet, Text } from "react-native";
+import { I18nManager, StyleSheet, Text } from "react-native";
 import { UseSmileIDPreviewScreen } from "../use_smile_id_preview_screen";
 import { defaultLightTheme } from "../../theme/theme";
 
@@ -14,7 +14,7 @@ import { defaultLightTheme } from "../../theme/theme";
  *   - Image at the oval rect (not full-bleed)
  *   - Title + confirmation buttons + optional attribution in card
  *   - Accept / Retake gating from `resolvePreviewState`
- *   - Slot contract (any slot replaces the entire row)
+ *   - The confirm/retake pair is fixed (not customisable)
  */
 
 function render(element: React.ReactElement) {
@@ -164,46 +164,16 @@ describe("UseSmileIDPreviewScreen", () => {
     }
   });
 
-  it("replaces the entire row when any button slot is supplied", () => {
-    // Concrete scenario this test documents: the slot contract is
-    // "all-or-nothing" — providing only continueButton hides the
-    // default Retake. Partners must supply both slots to keep both
-    // affordances.
-    const onAccept = vi.fn();
-    const onReject = vi.fn();
+  it("always renders the fixed confirmation-button pair (not customisable)", () => {
+    // Preview buttons are intentionally not customisable: the screen always
+    // renders the fixed confirm/retake pair. Re-adding a slot API is a product
+    // decision, not a bug fix.
     const { root } = render(
-      <UseSmileIDPreviewScreen
-        capturedSelfiePath={PATH}
-        onAccept={onAccept}
-        onReject={onReject}
-        continueButton={({ onClick }) => (
-          <Pressable testID="si_custom_continue" onPress={onClick}>
-            <Text>Confirm</Text>
-          </Pressable>
-        )}
-        cancelButton={({ onClick }) => (
-          <Pressable testID="si_custom_cancel" onPress={onClick}>
-            <Text>Retake</Text>
-          </Pressable>
-        )}
-      />,
+      <UseSmileIDPreviewScreen capturedSelfiePath={PATH} />,
     );
-
-    expect(findByTestID(root, "si_custom_continue")).not.toBeNull();
-    expect(findByTestID(root, "si_custom_cancel")).not.toBeNull();
-    // Default row must be gone — guards against a future refactor
-    // that double-renders the row alongside the slots.
-    expect(findByTestID(root, "si_preview_confirmation_buttons")).toBeNull();
-
-    act(() => {
-      (findByTestID(root, "si_custom_continue")!.props.onPress as () => void)();
-    });
-    expect(onAccept).toHaveBeenCalledTimes(1);
-
-    act(() => {
-      (findByTestID(root, "si_custom_cancel")!.props.onPress as () => void)();
-    });
-    expect(onReject).toHaveBeenCalledTimes(1);
+    expect(
+      findByTestID(root, "si_preview_confirmation_buttons"),
+    ).not.toBeNull();
   });
 
   it("renders the card title in the theme primary color", () => {

package/src/presentation/screen/helpers/__tests__/use_capture_orientation_lock.test.tsx

@@ -0,0 +1,212 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { create as createRenderer, act } from "react-test-renderer";
+import * as ScreenOrientation from "expo-screen-orientation";
+import { UseSmileIDCrashReporting } from "@smileid/usesmileid_bridge";
+import type { DocumentOrientation } from "../../../../core/models/document_type";
+import {
+  useCaptureOrientationLock,
+  resetUnsupportedLockWarningsForTesting,
+} from "../use_capture_orientation_lock";
+
+/**
+ * Lifecycle tests for `useCaptureOrientationLock`:
+ *   - mount asserts the screen's own orientation
+ *   - unmount applies the configured exit lock (portrait-up by default)
+ *   - a host build that cannot honour the lock is warned about (dev builds,
+ *     once per target) and reported (every build)
+ *
+ * The `expo-screen-orientation` mock lives in `setup_react_native.ts`.
+ * `__DEV__` is bundler-injected and deliberately NOT defined suite-wide —
+ * each test sets exactly the build shape it pins.
+ */
+
+const mockedLockAsync = vi.mocked(ScreenOrientation.lockAsync);
+const mockedSupportsLock = vi.mocked(
+  ScreenOrientation.supportsOrientationLockAsync,
+);
+
+const globalWithDev = globalThis as { __DEV__?: boolean };
+
+function LockHost(props: {
+  readonly orientation: DocumentOrientation;
+  readonly exitLock?: ScreenOrientation.OrientationLock;
+}) {
+  useCaptureOrientationLock(props.orientation, {
+    ...(props.exitLock !== undefined ? { exitLock: props.exitLock } : {}),
+  });
+  return null;
+}
+
+async function flushPromises(): Promise<void> {
+  // A macrotask tick drains every pending microtask chain first, so this stays
+  // correct if the hook gains or loses `await`s.
+  await new Promise<void>((resolve) => setTimeout(resolve, 0));
+}
+
+async function mountHost(
+  props: Parameters<typeof LockHost>[0],
+): Promise<ReturnType<typeof createRenderer>> {
+  let tree!: ReturnType<typeof createRenderer>;
+  act(() => {
+    tree = createRenderer(<LockHost {...props} />);
+  });
+  await act(async () => {
+    await flushPromises();
+  });
+  return tree;
+}
+
+describe("useCaptureOrientationLock", () => {
+  let savedDev: boolean | undefined;
+
+  beforeEach(() => {
+    savedDev = globalWithDev.__DEV__;
+    delete globalWithDev.__DEV__;
+    resetUnsupportedLockWarningsForTesting();
+    mockedLockAsync.mockReset();
+    mockedLockAsync.mockResolvedValue(undefined);
+    mockedSupportsLock.mockReset();
+    mockedSupportsLock.mockResolvedValue(true);
+  });
+
+  afterEach(() => {
+    if (savedDev === undefined) {
+      delete globalWithDev.__DEV__;
+    } else {
+      globalWithDev.__DEV__ = savedDev;
+    }
+    vi.restoreAllMocks();
+  });
+
+  it("locks landscape on mount for a landscape document", async () => {
+    const tree = await mountHost({ orientation: "Landscape" });
+
+    expect(mockedLockAsync).toHaveBeenCalledTimes(1);
+    expect(mockedLockAsync).toHaveBeenCalledWith(
+      ScreenOrientation.OrientationLock.LANDSCAPE,
+    );
+
+    await act(async () => {
+      tree.unmount();
+      await flushPromises();
+    });
+  });
+
+  it("restores portrait-up on unmount when no exit lock is configured", async () => {
+    const tree = await mountHost({ orientation: "Landscape" });
+    mockedLockAsync.mockClear();
+
+    await act(async () => {
+      tree.unmount();
+      await flushPromises();
+    });
+
+    expect(mockedLockAsync).toHaveBeenCalledTimes(1);
+    expect(mockedLockAsync).toHaveBeenCalledWith(
+      ScreenOrientation.OrientationLock.PORTRAIT_UP,
+    );
+  });
+
+  it("applies the configured exit lock on unmount instead of portrait-up", async () => {
+    const tree = await mountHost({
+      orientation: "Landscape",
+      exitLock: ScreenOrientation.OrientationLock.DEFAULT,
+    });
+    mockedLockAsync.mockClear();
+
+    await act(async () => {
+      tree.unmount();
+      await flushPromises();
+    });
+
+    expect(mockedLockAsync).toHaveBeenCalledTimes(1);
+    expect(mockedLockAsync).toHaveBeenCalledWith(
+      ScreenOrientation.OrientationLock.DEFAULT,
+    );
+    expect(mockedLockAsync).not.toHaveBeenCalledWith(
+      ScreenOrientation.OrientationLock.PORTRAIT_UP,
+    );
+  });
+
+  it("warns and reports once when the host build cannot honour the lock", async () => {
+    // Pins the reporting contract for any build where the platform declares
+    // the lock unsupported (lockAsync would resolve without rotating).
+    globalWithDev.__DEV__ = true;
+    mockedSupportsLock.mockResolvedValue(false);
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const captureException = vi
+      .spyOn(UseSmileIDCrashReporting, "captureException")
+      .mockImplementation(() => {});
+
+    const tree = await mountHost({ orientation: "Landscape" });
+
+    expect(captureException).toHaveBeenCalledTimes(1);
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect(warn.mock.calls[0]?.[0]).toContain("orientation");
+
+    await act(async () => {
+      tree.unmount();
+      await flushPromises();
+    });
+  });
+
+  it("reports without warning when __DEV__ is absent (production build)", async () => {
+    mockedSupportsLock.mockResolvedValue(false);
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const captureException = vi
+      .spyOn(UseSmileIDCrashReporting, "captureException")
+      .mockImplementation(() => {});
+
+    const tree = await mountHost({ orientation: "Landscape" });
+
+    expect(captureException).toHaveBeenCalledTimes(1);
+    expect(warn).not.toHaveBeenCalled();
+
+    await act(async () => {
+      tree.unmount();
+      await flushPromises();
+    });
+  });
+
+  it("warns once across capture-screen remounts for the same target", async () => {
+    globalWithDev.__DEV__ = true;
+    mockedSupportsLock.mockResolvedValue(false);
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const captureException = vi
+      .spyOn(UseSmileIDCrashReporting, "captureException")
+      .mockImplementation(() => {});
+
+    const first = await mountHost({ orientation: "Landscape" });
+    await act(async () => {
+      first.unmount();
+      await flushPromises();
+    });
+    const second = await mountHost({ orientation: "Landscape" });
+
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect(captureException).toHaveBeenCalledTimes(2);
+
+    await act(async () => {
+      second.unmount();
+      await flushPromises();
+    });
+  });
+
+  it("stays silent when the host build permits the lock", async () => {
+    globalWithDev.__DEV__ = true;
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const captureException = vi
+      .spyOn(UseSmileIDCrashReporting, "captureException")
+      .mockImplementation(() => {});
+
+    const tree = await mountHost({ orientation: "Portrait" });
+
+    expect(captureException).not.toHaveBeenCalled();
+    expect(warn).not.toHaveBeenCalled();
+
+    await act(async () => {
+      tree.unmount();
+      await flushPromises();
+    });
+  });
+});

package/src/presentation/screen/helpers/capture_screen_helpers.ts

@@ -83,6 +83,7 @@ const FEEDBACK_COPY: Partial<
   si_capture_ready: (loc) => loc.siCaptureReady,
   si_capture_hold_steady: (loc) => loc.siCaptureHoldSteady,
   si_capture_timeout: (loc) => loc.siCaptureTimeout,
+  si_capture_camera_unavailable: (loc) => loc.siCaptureCameraUnavailable,
   si_capturing: (loc) => loc.siCapturing,
   si_selfie_capture_complete: (loc) => loc.siSelfieCaptureComplete,
   si_selfie_capture_timeout: (loc) => loc.siSelfieCaptureTimeout,

package/src/presentation/screen/helpers/capture_ui_state.ts

@@ -1,8 +1,8 @@
 import type {
   ScanHeadTurnDirection,
-  ScanState,
+  UseSmileIDScanState,
 } from "@smileid/usesmileid_bridge";
-import { ScanStateType } 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 type { SiKey } from "../../../l10n/strings_en";
@@ -12,7 +12,7 @@ import {
   selfieFeedbackKeyFor,
 } from "./capture_screen_helpers";
 
-/** Immutable per-frame UI snapshot derived from the native `ScanState`. */
+/** Immutable per-frame UI snapshot derived from the native `UseSmileIDScanState`. */
 export type UseSmileIDCaptureUiState = {
   readonly overlayState: UseSmileIDOverlayState;
   /** Stable si_* key behind the guidance copy and the coaching-animation lookup. */
@@ -128,21 +128,21 @@ export function preCaptureUiState(
  * `unsatisfied`, or `timeout`/`finished` returning to `initial`.
  */
 export function isSessionBoundary(
-  previous: ScanState,
-  next: ScanState,
+  previous: UseSmileIDScanState,
+  next: UseSmileIDScanState,
 ): boolean {
   if (previous.type === next.type) return false;
-  if (previous.type === ScanStateType.Unsatisfied) return true;
+  if (previous.type === UseSmileIDScanStateType.Unsatisfied) return true;
   return (
-    (previous.type === ScanStateType.Timeout ||
-      previous.type === ScanStateType.Finished) &&
-    next.type === ScanStateType.Initial
+    (previous.type === UseSmileIDScanStateType.Timeout ||
+      previous.type === UseSmileIDScanStateType.Finished) &&
+    next.type === UseSmileIDScanStateType.Initial
   );
 }
 
 /** Dispatch on capture type — see {@link mapSelfieUiState} / {@link mapDocumentUiState}. */
 export function mapCaptureUiState(
-  scanState: ScanState,
+  scanState: UseSmileIDScanState,
   captureType: CaptureType,
   enableEnhancedLiveness: boolean,
 ): UseSmileIDCaptureUiState {
@@ -157,7 +157,7 @@ export function mapCaptureUiState(
  * still…") and zeroes the fill.
  */
 export function mapSelfieUiState(
-  scanState: ScanState,
+  scanState: UseSmileIDScanState,
   enableEnhancedLiveness: boolean,
 ): UseSmileIDCaptureUiState {
   return withEnhancedLivenessPolicy(
@@ -167,11 +167,11 @@ export function mapSelfieUiState(
 }
 
 function selfieUiState(
-  scanState: ScanState,
+  scanState: UseSmileIDScanState,
   enableEnhancedLiveness: boolean,
 ): UseSmileIDCaptureUiState {
   switch (scanState.type) {
-    case ScanStateType.Initial:
+    case UseSmileIDScanStateType.Initial:
       return uiState(
         UseSmileIDOverlayState.INSTRUCTION,
         enableEnhancedLiveness
@@ -180,7 +180,7 @@ function selfieUiState(
         0,
       );
 
-    case ScanStateType.Found: {
+    case UseSmileIDScanStateType.Found: {
       const overlayState = mapScanStateToOverlayState(
         scanState,
         CaptureType.selfie,
@@ -191,7 +191,7 @@ function selfieUiState(
       return uiState(overlayState, feedbackKey, scanState.captureProgress ?? 0);
     }
 
-    case ScanStateType.Satisfied:
+    case UseSmileIDScanStateType.Satisfied:
       // Progress forced to 1 so the ring completes even when the last
       // interim frame undershot; transient before `finished`.
       return uiState(
@@ -200,7 +200,7 @@ function selfieUiState(
         1,
       );
 
-    case ScanStateType.Unsatisfied:
+    case UseSmileIDScanStateType.Unsatisfied:
       // Unsatisfied collapses onto one requirements-not-met copy —
       // the per-check `reason` only feeds telemetry, not guidance.
       return uiState(
@@ -209,13 +209,13 @@ function selfieUiState(
         0,
       );
 
-    case ScanStateType.Finished:
+    case UseSmileIDScanStateType.Finished:
       return scannedUiState(enableEnhancedLiveness);
 
-    case ScanStateType.Timeout:
+    case UseSmileIDScanStateType.Timeout:
       return uiState(UseSmileIDOverlayState.IDLE, "si_capture_timeout", 0);
 
-    case ScanStateType.HeadTurn: {
+    case UseSmileIDScanStateType.HeadTurn: {
       const direction = scanState.currentDirection ?? null;
       const turnPrompt: SiKey =
         direction === "left"
@@ -243,20 +243,20 @@ function selfieUiState(
 
 /** Document scan-state → UI-state mapping. */
 export function mapDocumentUiState(
-  scanState: ScanState,
+  scanState: UseSmileIDScanState,
 ): UseSmileIDCaptureUiState {
   switch (scanState.type) {
-    case ScanStateType.Initial:
+    case UseSmileIDScanStateType.Initial:
     // No head-turn phase for documents; a degenerate headTurn maps to
     // the pre-capture instruction.
-    case ScanStateType.HeadTurn:
+    case UseSmileIDScanStateType.HeadTurn:
       return uiState(
         UseSmileIDOverlayState.INSTRUCTION,
         "si_document_initial_instruction",
         0,
       );
 
-    case ScanStateType.Found: {
+    case UseSmileIDScanStateType.Found: {
       const overlayState = mapScanStateToOverlayState(
         scanState,
         CaptureType.document,
@@ -275,20 +275,20 @@ export function mapDocumentUiState(
 
     // Documents collapse satisfied/finished onto the same terminal
     // snapshot: the still is captured and the screen is moving on.
-    case ScanStateType.Satisfied:
+    case UseSmileIDScanStateType.Satisfied:
       return scannedDocumentUiState();
 
-    case ScanStateType.Unsatisfied:
+    case UseSmileIDScanStateType.Unsatisfied:
       return uiState(
         UseSmileIDOverlayState.IDLE,
         "si_document_capture_unsatisfied",
         0,
       );
 
-    case ScanStateType.Finished:
+    case UseSmileIDScanStateType.Finished:
       return scannedDocumentUiState();
 
-    case ScanStateType.Timeout:
+    case UseSmileIDScanStateType.Timeout:
       return uiState(
         UseSmileIDOverlayState.IDLE,
         "si_document_capture_timeout",

package/src/presentation/screen/helpers/ess_turn_haptics.ts

@@ -1,6 +1,6 @@
 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";
 
 /** Which haptic a completed Enhanced Smart Selfie head turn warrants. */
 export type EssTurnHaptic = "intermediate" | "final";
@@ -20,16 +20,16 @@ export type EssTurnHaptic = "intermediate" | "final";
  * scan state so the same completion is reported exactly once.
  */
 export function essTurnHaptic(
-  previous: ScanState,
-  next: ScanState,
+  previous: UseSmileIDScanState,
+  next: UseSmileIDScanState,
 ): EssTurnHaptic | null {
   // Only a transition out of an active, directed head turn can complete one.
-  if (previous.type !== ScanStateType.HeadTurn) return null;
+  if (previous.type !== UseSmileIDScanStateType.HeadTurn) return null;
   if (previous.currentDirection === undefined) return null;
 
   // The requested direction advanced — the previous turn completed.
   if (
-    next.type === ScanStateType.HeadTurn &&
+    next.type === UseSmileIDScanStateType.HeadTurn &&
     next.currentDirection !== undefined &&
     next.currentDirection !== previous.currentDirection
   ) {
@@ -39,9 +39,9 @@ export function essTurnHaptic(
   // Leaving the head-turn phase toward capture is the final turn's
   // completion; `initial` / `timeout` are resets, not completions.
   if (
-    next.type === ScanStateType.Found ||
-    next.type === ScanStateType.Satisfied ||
-    next.type === ScanStateType.Finished
+    next.type === UseSmileIDScanStateType.Found ||
+    next.type === UseSmileIDScanStateType.Satisfied ||
+    next.type === UseSmileIDScanStateType.Finished
   ) {
     return "final";
   }

package/src/presentation/screen/helpers/scan_state_to_overlay_state.ts

@@ -1,16 +1,16 @@
-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";
 
 /**
- * Map an analyzer's `ScanState` into the SDK's visual `OverlayState`.
+ * Map an analyzer's `UseSmileIDScanState` into the SDK's visual `OverlayState`.
  *
  * The overlay enum drives the face/document oval's border colour, dash
  * pattern, and fill animation — it's a presentation concept layered on
  * top of the scan-state machine. The mapping reads `state.feedback`
- * (when `type === ScanStateType.Found`) and `state.reason` (when
- * `type === ScanStateType.Unsatisfied`) to pick the fine-grained
+ * (when `type === UseSmileIDScanStateType.Found`) and `state.reason` (when
+ * `type === UseSmileIDScanStateType.Unsatisfied`) to pick the fine-grained
  * overlay state; other scan-state types map coarsely to the matching
  * lifecycle entry.
  *
@@ -20,14 +20,14 @@ import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
  * a new feedback key the JS side hasn't been updated for.
  */
 export function mapScanStateToOverlayState(
-  scanState: ScanState,
+  scanState: UseSmileIDScanState,
   captureType: CaptureType,
 ): UseSmileIDOverlayState {
   switch (scanState.type) {
-    case ScanStateType.Initial:
+    case UseSmileIDScanStateType.Initial:
       return UseSmileIDOverlayState.INSTRUCTION;
 
-    case ScanStateType.Found:
+    case UseSmileIDScanStateType.Found:
       // `feedback` is the canonical `si_capture_*` key the native side
       // emits; partner code never sees raw English copy.
       return resolveFeedbackOverlay(
@@ -38,10 +38,10 @@ export function mapScanStateToOverlayState(
           : UseSmileIDOverlayState.DOCUMENT_READY,
       );
 
-    case ScanStateType.Satisfied:
+    case UseSmileIDScanStateType.Satisfied:
       return UseSmileIDOverlayState.READY;
 
-    case ScanStateType.Unsatisfied:
+    case UseSmileIDScanStateType.Unsatisfied:
       return resolveFeedbackOverlay(
         scanState.reason,
         captureType,
@@ -50,13 +50,13 @@ export function mapScanStateToOverlayState(
           : UseSmileIDOverlayState.DOCUMENT_NOT_CENTERED,
       );
 
-    case ScanStateType.Finished:
+    case UseSmileIDScanStateType.Finished:
       return UseSmileIDOverlayState.CAPTURING;
 
-    case ScanStateType.HeadTurn:
+    case UseSmileIDScanStateType.HeadTurn:
       return UseSmileIDOverlayState.HEAD_TURN;
 
-    case ScanStateType.Timeout:
+    case UseSmileIDScanStateType.Timeout:
       // Back to the gray pre-capture state while partners re-prompt.
       return UseSmileIDOverlayState.IDLE;
   }