@smileid/usesmileid 12.0.1 → 12.0.2

package/src/presentation/flow/validation/__tests__/flow_validator.test.ts

@@ -18,6 +18,7 @@ import {
 import {
   InvalidFieldValueException,
   InvalidJobTypeScreenConfigException,
+  MissingJobTypeException,
   MissingMLConfigurationBlockException,
 } from "../../../../core/exception/job_validation_exceptions";
 import {
@@ -25,9 +26,13 @@ import {
   InvalidDocumentCaptureConfigException,
 } from "../../../../core/exception/capture_validation_exceptions";
 import {
+  runConsentValidation,
   runDocumentVerificationParamsValidation,
   runEnhancedDocumentVerificationParamsValidation,
+  runUserDetailsValidation,
 } from "../flow_validator";
+import { InvalidConsentInformationException } from "../../../../core/exception/consent_validation_exceptions";
+import type { TokenPayload } from "../../../../data/model/token_payload";
 
 function stubFaceAnalyzer(): FaceAnalyzer {
   return {
@@ -456,3 +461,156 @@ describe("FlowValidator — document verification params", () => {
     ).toHaveLength(0);
   });
 });
+
+describe("FlowValidator — jobType recognition", () => {
+  const ml: MLConfig = { analyzers: { selfie: stubFaceAnalyzer() } };
+
+  function jobTypeIssue(jobType: JobType) {
+    const issues = runFlowValidation({
+      steps: [captureStep(CaptureType.selfie), processingStep()],
+      ml,
+      network: validNetwork(jobType),
+      userDetails: validUserDetails,
+    });
+    return issues.find(
+      (i): i is MissingJobTypeException => i instanceof MissingJobTypeException,
+    );
+  }
+
+  it("rejects a jobType that is not one of the SDK's job types", () => {
+    expect(jobTypeIssue(99 as JobType)).toBeInstanceOf(MissingJobTypeException);
+  });
+
+  it("still rejects the unknown sentinel", () => {
+    expect(jobTypeIssue(JobType.unknown)).toBeInstanceOf(
+      MissingJobTypeException,
+    );
+  });
+
+  it("accepts every job type the SDK submits", () => {
+    for (const jobType of Object.values(JobType)) {
+      if (jobType === JobType.unknown) continue;
+      expect(jobTypeIssue(jobType)).toBeUndefined();
+    }
+  });
+});
+
+describe("FlowValidator — token-provided user details (field-level relaxation)", () => {
+  function tokenPayload(overrides: Partial<TokenPayload> = {}): TokenPayload {
+    return {
+      hasGivenNames: false,
+      hasLastName: false,
+      hasEmail: false,
+      hasPhoneNumber: false,
+      ...overrides,
+    };
+  }
+
+  it("accepts contact-only userDetails when the token binds both names", () => {
+    const issues = runUserDetailsValidation(
+      { givenNames: "", lastName: "", email: "ada@example.com" },
+      tokenPayload({ hasGivenNames: true, hasLastName: true }),
+    );
+    expect(issues).toHaveLength(0);
+  });
+
+  it("accepts names-only userDetails when the token binds a contact field", () => {
+    const emailBound = runUserDetailsValidation(
+      { givenNames: "Ada", lastName: "Lovelace" },
+      tokenPayload({ hasEmail: true }),
+    );
+    expect(emailBound).toHaveLength(0);
+
+    const phoneBound = runUserDetailsValidation(
+      { givenNames: "Ada", lastName: "Lovelace" },
+      tokenPayload({ hasPhoneNumber: true }),
+    );
+    expect(phoneBound).toHaveLength(0);
+  });
+
+  it("relaxes per-field — a name the token does not bind still errors with today's message", () => {
+    const issues = runUserDetailsValidation(
+      { givenNames: "", lastName: "", email: "ada@example.com" },
+      tokenPayload({ hasGivenNames: true }),
+    );
+    expect(issues).toHaveLength(1);
+    expect(issues[0]).toBeInstanceOf(InvalidFieldValueException);
+    expect(issues[0]?.message).toContain("userDetails.lastName");
+  });
+
+  it("regression: without a token payload every existing rule fires unchanged", () => {
+    const issues = runUserDetailsValidation({ givenNames: "", lastName: "" });
+    expect(issues).toHaveLength(3);
+    const messages = issues.map((i) => i.message).join("\n");
+    expect(messages).toContain("userDetails.givenNames");
+    expect(messages).toContain("userDetails.lastName");
+    expect(messages).toContain(
+      "at least one of email or phoneNumber must be non blank",
+    );
+  });
+
+  it("threads tokenPayload through runFlowValidation to the field rules", () => {
+    const issues = runFlowValidation({
+      steps: [captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: { givenNames: "", lastName: "", email: "ada@example.com" },
+      consentInformation: {
+        granted: true,
+        grantedAt: "2026-01-01T00:00:00.000Z",
+        noticeLanguage: "EN",
+        noticePrivacyPolicyUrl: "https://example.com",
+      },
+      tokenPayload: tokenPayload({ hasGivenNames: true, hasLastName: true }),
+    });
+    expect(issues.some((i) => i instanceof InvalidFieldValueException)).toBe(
+      false,
+    );
+  });
+
+  it("a complete token consent skips content validation of the ignored preset", () => {
+    // Token data always wins: the preset is never sent, so its
+    // contents raise no issue even when they would fail on their own.
+    const issues = runFlowValidation({
+      steps: [captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      consentInformation: {
+        granted: false,
+        grantedAt: "",
+        noticeLanguage: "",
+        noticePrivacyPolicyUrl: "",
+      },
+      tokenPayload: {
+        ...tokenPayload(),
+        consent: {
+          granted: true,
+          grantedAt: "2026-01-01T09:00:00.000Z",
+          noticeLanguage: "EN",
+          noticePrivacyPolicyUrl: "https://partner.test/privacy",
+        },
+      },
+    });
+    expect(
+      issues.some((i) => i instanceof InvalidConsentInformationException),
+    ).toBe(false);
+  });
+
+  it("the standalone pre-flight validator stays strict (no token context)", () => {
+    // `b.validateUserDetails(payload)` has no token context by design —
+    // partners pre-flight the payload they would assign, and blank
+    // names still fail there.
+    expect(
+      runUserDetailsValidation({ givenNames: "", lastName: "Lovelace" }),
+    ).not.toHaveLength(0);
+    expect(
+      runConsentValidation({
+        granted: false,
+        grantedAt: "",
+        noticeLanguage: "",
+        noticePrivacyPolicyUrl: "",
+      }),
+    ).not.toHaveLength(0);
+  });
+});

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

@@ -20,10 +20,15 @@ import {
   PreviewConfigBuilder,
 } from "../../dsl/builder/screens_builder";
 import { InvalidJobTypeScreenConfigException } from "../../../../core/exception/job_validation_exceptions";
+import { InvalidFieldValueException } from "../../../../core/exception/invalid_field_value_exception";
 import {
   InvalidScreenOrderException,
   MissingCaptureForPreviewException,
 } from "../../../../core/exception/screen_config_validation_exceptions";
+import type {
+  TokenConsent,
+  TokenPayload,
+} from "../../../../data/model/token_payload";
 
 function stubFaceAnalyzer(): FaceAnalyzer {
   return {
@@ -733,6 +738,201 @@ describe("DocumentJobTypeValidator — Android-parity rules", () => {
   });
 });
 
+describe("JobTypeValidator — token-provided user details & consent", () => {
+  function tokenPayload(overrides: Partial<TokenPayload> = {}): TokenPayload {
+    return {
+      hasGivenNames: false,
+      hasLastName: false,
+      hasEmail: false,
+      hasPhoneNumber: false,
+      ...overrides,
+    };
+  }
+
+  const fullBinding = tokenPayload({
+    hasGivenNames: true,
+    hasLastName: true,
+    hasEmail: true,
+    hasPhoneNumber: true,
+  });
+
+  const completeTokenConsent: TokenConsent = {
+    granted: true,
+    grantedAt: "2026-01-01T09:00:00.000Z",
+    noticeLanguage: "EN",
+    noticePrivacyPolicyUrl: "https://partner.test/privacy",
+  };
+
+  const validConsentInformation = {
+    granted: true,
+    grantedAt: "2024-01-01T00:00:00.000Z",
+    noticeLanguage: "EN",
+    noticePrivacyPolicyUrl: "https://example.com",
+  } as const;
+
+  // Steps + params that make each submitting job type otherwise valid,
+  // so the only variable under test is the userDetails / consent rule.
+  function validInputFor(jobType: JobType): JobTypeValidatorInput {
+    switch (jobType) {
+      case JobType.documentVerification:
+      case JobType.enhancedDocumentVerification:
+        return {
+          steps: [
+            consentStep(),
+            captureStep(CaptureType.selfie),
+            captureStep(CaptureType.document),
+            processingStep(),
+          ],
+          network: validNetwork(jobType),
+          ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+          documentVerificationParams: validDocumentParams,
+          enhancedDocumentVerificationParams: validEnhancedDocumentParams,
+        };
+      case JobType.enhancedKyc:
+        return {
+          steps: [consentStep(), processingStep()],
+          network: validNetwork(jobType),
+          enhancedKYCParams: {
+            idType: "NATIONAL_ID",
+            idNumber: "1",
+            country: "KE",
+          },
+        };
+      default:
+        return {
+          steps: [
+            consentStep(),
+            captureStep(CaptureType.selfie),
+            processingStep(),
+          ],
+          network: validNetwork(jobType),
+          ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+          biometricKYCParams: validBiometricParams,
+        };
+    }
+  }
+
+  const USER_DETAILS_JOB_TYPES: readonly JobType[] = [
+    JobType.smartSelfieEnrollment,
+    JobType.smartSelfieAuthentication,
+    JobType.biometricKyc,
+    JobType.documentVerification,
+    JobType.enhancedDocumentVerification,
+    JobType.enhancedKyc,
+  ];
+
+  for (const jobType of USER_DETAILS_JOB_TYPES) {
+    it(`${jobType}: userDetails may be omitted when the token binds names + a contact field`, () => {
+      const issues = run({
+        ...validInputFor(jobType),
+        tokenPayload: fullBinding,
+      });
+      expect(
+        issues.some(
+          (i) =>
+            i instanceof InvalidJobTypeScreenConfigException &&
+            i.message.includes("userDetails is required"),
+        ),
+      ).toBe(false);
+    });
+  }
+
+  it("a names-only token binding reports the missing contact field by name", () => {
+    const issues = run({
+      ...validInputFor(JobType.smartSelfieEnrollment),
+      tokenPayload: tokenPayload({ hasGivenNames: true, hasLastName: true }),
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidFieldValueException &&
+          i.message.includes("userDetails") &&
+          i.message.includes(
+            "at least one contact field must be bound by the token or supplied on the builder",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("complete token consent satisfies the consent-source rule with no local source", () => {
+    const issues = run({
+      steps: [captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      tokenPayload: { ...tokenPayload(), consent: completeTokenConsent },
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "must include either a Consent screen or a pre-supplied consentInformation",
+          ),
+      ),
+    ).toBe(false);
+  });
+
+  it("a partial token consent fails validation naming the missing subfields", () => {
+    const issues = run({
+      steps: [captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      tokenPayload: {
+        ...tokenPayload(),
+        consent: {
+          granted: true,
+          grantedAt: "2026-01-01T09:00:00.000Z",
+        },
+      },
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "the token's consent binding is incomplete — missing: notice_language, notice_privacy_policy_url",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("complete token consent alongside a consentInformation preset is allowed", () => {
+    const issues = run({
+      steps: [captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      consentInformation: validConsentInformation,
+      tokenPayload: { ...tokenPayload(), consent: completeTokenConsent },
+    });
+    expect(
+      issues.some((i) => i instanceof InvalidJobTypeScreenConfigException),
+    ).toBe(false);
+  });
+
+  it("the consent-source mutex still fires with complete token consent", () => {
+    const issues = run({
+      steps: [consentStep(), captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      consentInformation: validConsentInformation,
+      tokenPayload: { ...tokenPayload(), consent: completeTokenConsent },
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "must not include both a Consent screen and a pre-supplied consentInformation",
+          ),
+      ),
+    ).toBe(true);
+  });
+});
+
 describe("NonCaptureJobTypeValidator — Android-parity rules", () => {
   it("passes a fully-configured EnhancedKyc flow", () => {
     const issues = run({

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

@@ -9,7 +9,7 @@ import type {
   EnhancedKYCParams,
   UserDetails,
 } from "../../../core/models/params";
-import { JobType } from "../../../core/models/job_type";
+import { JobType, jobTypeFromValue } from "../../../core/models/job_type";
 import type {
   DocumentCaptureConfigBuilder,
   ScreenSpec,
@@ -34,8 +34,10 @@ import {
   InvalidMissingCaptureTypeException,
 } from "../../../core/exception/capture_validation_exceptions";
 import { EmptyScreensBlockException } from "../../../core/exception/screen_config_validation_exceptions";
+import type { TokenPayload } from "../../../data/model/token_payload";
 import { ValidationState, type ValidationIssue } from "./validation_state";
 import { collectJobTypeIssues } from "./job_type_validator";
+import { missingUserDetailsFieldIssues } from "./user_details_validator";
 
 /**
  * Pure flow validator — returns typed `UseSmileIDValidationException`
@@ -72,6 +74,12 @@ type FlowValidatorInput = {
     | 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;
 };
 
 /**
@@ -185,9 +193,13 @@ export function runFlowValidation(
   // build (ERROR) whenever it's missing — whether or not a network
   // block was provided. The missing-network WARNING above still fires
   // alongside this when the block is absent.
+  // `jobTypeFromValue` collapses the unknown sentinel and any out-of-enum value, so an unrecognised job_type_id fails the build too.
   if (hasProcessingScreen) {
     const jobType = input.network?.config?.jobType;
-    if (jobType === undefined || jobType === JobType.unknown) {
+    if (
+      jobType === undefined ||
+      jobTypeFromValue(jobType) === JobType.unknown
+    ) {
       issues.push(new MissingJobTypeException());
     }
   }
@@ -238,7 +250,9 @@ export function runFlowValidation(
     );
   }
 
-  if (input.consentInformation) {
+  // A token consent binding supersedes the preset entirely (token data
+  // always wins), so the ignored preset's contents are not validated.
+  if (input.consentInformation && input.tokenPayload?.consent === undefined) {
     issues.push(...runConsentValidation(input.consentInformation));
   }
   if (input.enhancedKYCParams) {
@@ -262,7 +276,9 @@ export function runFlowValidation(
     );
   }
   if (input.userDetails) {
-    issues.push(...runUserDetailsValidation(input.userDetails));
+    issues.push(
+      ...runUserDetailsValidation(input.userDetails, input.tokenPayload),
+    );
   }
 
   // Every flow-composition rule (screen ordering, duplicate screens,
@@ -408,40 +424,23 @@ function runKYCParamsValidation(
  * keep working unchanged after the consolidation away from nesting
  * `userDetails` inside the KYC param shapes.
  *
+ * Each field requirement is evaluated against the union of builder
+ * input and token bindings: a field the token binds (see
+ * `TokenPayload`) never has to be supplied locally — the server
+ * injects it, and the SDK drops the local value from the wire. With
+ * no `tokenPayload` the behavior is exactly the pre-token rule set.
+ *
  * Exposed via `b.validateUserDetails(payload)` so partners can
  * pre-flight a payload before assigning to `b.userDetails`, mirroring
  * the existing `b.validateConsent` / `b.validateEnhancedKYCParams`
- * pattern.
+ * pattern (the pre-flight helper always validates strictly, without
+ * token context).
  */
 export function runUserDetailsValidation(
   userDetails: UserDetails,
+  tokenPayload?: TokenPayload,
 ): ValidationIssue[] {
-  const issues: ValidationIssue[] = [];
-  for (const field of ["givenNames", "lastName"] as const) {
-    const value = userDetails[field];
-    if (!value || !value.trim()) {
-      issues.push(
-        new InvalidFieldValueException({
-          fieldName: `userDetails.${field}`,
-          reason: "must not be blank",
-        }),
-      );
-    }
-  }
-  // At-least-one-of contact rule: email and phoneNumber are each
-  // optional, but the partner must supply one of them.
-  const hasEmail = !!userDetails.email && userDetails.email.trim().length > 0;
-  const hasPhone =
-    !!userDetails.phoneNumber && userDetails.phoneNumber.trim().length > 0;
-  if (!hasEmail && !hasPhone) {
-    issues.push(
-      new InvalidFieldValueException({
-        fieldName: "userDetails",
-        reason: "at least one of email or phoneNumber must be non blank",
-      }),
-    );
-  }
-  return issues;
+  return missingUserDetailsFieldIssues(userDetails, tokenPayload);
 }
 
 /**

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