@smileid/usesmileid 12.0.0 → 12.0.2

package/src/presentation/flow/validation/job_type_validator.ts

@@ -18,6 +18,12 @@ import {
   MissingCaptureForPreviewException,
 } from "../../../core/exception/screen_config_validation_exceptions";
 import { IssueSeverity } from "../../../core/exception/issue_severity";
+import {
+  tokenConsentMissingSubfields,
+  bindsRequiredUserDetails,
+  type TokenPayload,
+} from "../../../data/model/token_payload";
+import { missingUserDetailsFieldIssues } from "./user_details_validator";
 import type { ValidationIssue } from "./validation_state";
 
 /**
@@ -66,6 +72,12 @@ export type JobTypeValidatorInput = {
     | EnhancedDocumentVerificationParams
     | undefined;
   readonly userDetails?: UserDetails | undefined;
+  /**
+   * User-detail/consent bindings decoded from the JWT `payload` claim.
+   * `undefined` (no token, offline mode, legacy token) keeps every rule
+   * exactly as strict as before token support existed.
+   */
+  readonly tokenPayload?: TokenPayload | undefined;
 };
 
 /**
@@ -93,9 +105,13 @@ function jobTypeName(jobType: JobType): string {
 }
 
 /**
- * Consent rule: exactly one form of consent is required — either a
- * Consent screen or pre-supplied `consentInformation`, never both and
- * never neither.
+ * Consent rule: token consent always wins. A token that carries a
+ * consent binding must carry all four subfields — the local sources
+ * are then ignored (the consent screen is skipped and any preset is
+ * not sent), so an incomplete binding is a build-time error rather
+ * than a silent fallback. Without a token binding, exactly one local
+ * form of consent is required — either a Consent screen or
+ * pre-supplied `consentInformation`, never both.
  */
 function appendConsentRule(
   jobType: JobType,
@@ -104,6 +120,33 @@ function appendConsentRule(
 ): void {
   const hasConsentScreen = input.steps.some((s) => s.kind === "consent");
   const hasConsentInformation = input.consentInformation !== undefined;
+  if (hasConsentScreen && hasConsentInformation) {
+    issues.push(
+      InvalidJobTypeScreenConfigException.forJob({
+        jobType,
+        reason:
+          "must not include both a Consent screen and a pre-supplied consentInformation — use one or the other",
+        suggestedFix:
+          "Remove the consent { } screen if supplying consentInformation, or clear consentInformation if using the consent screen",
+      }),
+    );
+    return;
+  }
+  const tokenConsent = input.tokenPayload?.consent;
+  if (tokenConsent !== undefined) {
+    const missing = tokenConsentMissingSubfields(tokenConsent);
+    if (missing.length > 0) {
+      issues.push(
+        InvalidJobTypeScreenConfigException.forJob({
+          jobType,
+          reason: `the token's consent binding is incomplete — missing: ${missing.join(", ")}`,
+          suggestedFix:
+            "Bind all four consent fields when minting the token at /v3/token, or bind none and collect consent in the app",
+        }),
+      );
+    }
+    return;
+  }
   if (!hasConsentScreen && !hasConsentInformation) {
     issues.push(
       InvalidJobTypeScreenConfigException.forJob({
@@ -114,17 +157,36 @@ function appendConsentRule(
           "Add a consent { } screen to your flow, or supply consentInformation via the builder",
       }),
     );
-  } else if (hasConsentScreen && hasConsentInformation) {
+  }
+}
+
+/**
+ * userDetails rule: the token and the builder fill the requirement
+ * together — token-bound fields (see `bindsRequiredUserDetails`) count
+ * as supplied and the builder must cover the rest. With no token
+ * binding and no builder value the legacy blanket error fires; with a
+ * partial token binding the per-field errors name exactly what neither
+ * side provided.
+ */
+function appendUserDetailsRequiredRule(
+  jobType: JobType,
+  input: JobTypeValidatorInput,
+  issues: ValidationIssue[],
+): void {
+  if (input.userDetails !== undefined) return;
+  if (bindsRequiredUserDetails(input.tokenPayload)) return;
+  if (input.tokenPayload === undefined) {
     issues.push(
       InvalidJobTypeScreenConfigException.forJob({
         jobType,
-        reason:
-          "must not include both a Consent screen and a pre-supplied consentInformation — use one or the other",
+        reason: `userDetails is required for ${jobTypeName(jobType)} jobs`,
         suggestedFix:
-          "Remove the consent { } screen if supplying consentInformation, or clear consentInformation if using the consent screen",
+          "Set builder.userDetails with the end user PII before building",
       }),
     );
+    return;
   }
+  issues.push(...missingUserDetailsFieldIssues(undefined, input.tokenPayload));
 }
 
 /**
@@ -381,16 +443,7 @@ export class SelfieJobTypeValidator implements JobTypeValidator {
       );
     }
 
-    if (input.userDetails === undefined) {
-      issues.push(
-        InvalidJobTypeScreenConfigException.forJob({
-          jobType: this.jobType,
-          reason: `userDetails is required for ${jobTypeName(this.jobType)} jobs`,
-          suggestedFix:
-            "Set builder.userDetails with the end user PII before building",
-        }),
-      );
-    }
+    appendUserDetailsRequiredRule(this.jobType, input, issues);
   }
 }
 
@@ -477,16 +530,7 @@ export class DocumentJobTypeValidator implements JobTypeValidator {
       );
     }
 
-    if (input.userDetails === undefined) {
-      issues.push(
-        InvalidJobTypeScreenConfigException.forJob({
-          jobType: this.jobType,
-          reason: `userDetails is required for ${jobTypeName(this.jobType)} jobs`,
-          suggestedFix:
-            "Set builder.userDetails with the end user PII before building",
-        }),
-      );
-    }
+    appendUserDetailsRequiredRule(this.jobType, input, issues);
   }
 
   /**
@@ -578,18 +622,8 @@ export class NonCaptureJobTypeValidator implements JobTypeValidator {
       );
     }
 
-    if (
-      this.jobType === JobType.enhancedKyc &&
-      input.userDetails === undefined
-    ) {
-      issues.push(
-        InvalidJobTypeScreenConfigException.forJob({
-          jobType: this.jobType,
-          reason: "userDetails is required for EnhancedKyc jobs",
-          suggestedFix:
-            "Set builder.userDetails with the end user PII before building",
-        }),
-      );
+    if (this.jobType === JobType.enhancedKyc) {
+      appendUserDetailsRequiredRule(this.jobType, input, issues);
     }
   }
 }

package/src/presentation/flow/validation/user_details_validator.ts

@@ -0,0 +1,53 @@
+import type { UserDetails } from "../../../core/models/params";
+import { InvalidFieldValueException } from "../../../core/exception/job_validation_exceptions";
+import type { TokenPayload } from "../../../data/model/token_payload";
+import type { ValidationIssue } from "./validation_state";
+
+/**
+ * Field-union rule shared by the content validator and the job-type required
+ * rule: a field is covered when the token binds it or the builder supplies it.
+ */
+export function missingUserDetailsFieldIssues(
+  userDetails: UserDetails | undefined,
+  tokenPayload: TokenPayload | undefined,
+): ValidationIssue[] {
+  const issues: ValidationIssue[] = [];
+  const fieldReason =
+    tokenPayload === undefined
+      ? "must not be blank"
+      : "not bound by the token and not supplied on the builder";
+  const tokenBindsField = {
+    givenNames: tokenPayload?.hasGivenNames === true,
+    lastName: tokenPayload?.hasLastName === true,
+  } as const;
+  for (const field of ["givenNames", "lastName"] as const) {
+    if (tokenBindsField[field]) continue;
+    const value = userDetails?.[field];
+    if (!value || !value.trim()) {
+      issues.push(
+        new InvalidFieldValueException({
+          fieldName: `userDetails.${field}`,
+          reason: fieldReason,
+        }),
+      );
+    }
+  }
+  // email and phoneNumber are each optional, but one must come from the builder or the token.
+  const hasEmail = !!userDetails?.email && userDetails.email.trim().length > 0;
+  const hasPhone =
+    !!userDetails?.phoneNumber && userDetails.phoneNumber.trim().length > 0;
+  const tokenHasContact =
+    tokenPayload?.hasEmail === true || tokenPayload?.hasPhoneNumber === true;
+  if (!hasEmail && !hasPhone && !tokenHasContact) {
+    issues.push(
+      new InvalidFieldValueException({
+        fieldName: "userDetails",
+        reason:
+          tokenPayload === undefined
+            ? "at least one of email or phoneNumber must be non blank"
+            : "at least one contact field must be bound by the token or supplied on the builder",
+      }),
+    );
+  }
+  return issues;
+}

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();