@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/types-M6eb82ra2.d.ts

@@ -0,0 +1,589 @@
+import { t as CameraStream } from "./camera-9wWD-pwg.js";
+import { n as IRecordingCapability, o as IncodeCanvas, r as RecordingConnection, t as IStorageCapability } from "./IStorageCapability-ORkQfK3F.js";
+import { a as RegulationTypes, n as Flow, o as TutorialIdConfig } from "./types-KPvmag_B.js";
+import { t as PermissionResult } from "./types-BEwVKkLJ.js";
+import { n as StreamCanvasCapture, t as DeepsightService } from "./deepsightService-DLVQS_RH.js";
+import { i as Pdf417DecodeResult, n as IIdCaptureCapability, r as IdCaptureSettings, t as DetectionOrientation } from "./IIdCaptureCapability-DHTT3FC2.js";
+//#region src/modules/id/manualUpload/types.d.ts
+type ManualUploadTab = 'id' | 'passport';
+type ManualUploadSide = 'front' | 'back' | 'passport';
+type ManualUploadContext = {
+  /** Passed from parent machine input — used by guards and actor inputs. */
+  onlyFront: boolean;
+  isSecondId: boolean;
+  /** Retry budget for this manual upload (sourced from `config.captureAttempts`). */
+  captureAttempts: number;
+  /** [ENG-44176] Forwarded to front / passport manual uploads when explicitly false. */
+  extractIdFace?: boolean;
+  frontFile: File | null;
+  backFile: File | null;
+  passportFile: File | null;
+  activeTab: ManualUploadTab;
+  retriesLeft: number;
+  errorMessage: string | null;
+  errorSide: ManualUploadSide | null;
+  /** Set from the front upload response; when true the back slot is auto-completed */
+  skipBackFromServer: boolean;
+  /** Whether each side has been successfully uploaded (for Continue gating) */
+  frontUploaded: boolean;
+  backUploaded: boolean;
+  passportUploaded: boolean;
+};
+declare const MANUAL_UPLOAD_MAX_RETRIES = 3;
+declare const MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES: number;
+declare const MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS = 5000;
+//#endregion
+//#region ../infra/src/capabilities/IAnalyticsCapability.d.ts
+interface IAnalyticsCapability {
+  analyzeFrame(image: ImageData): Promise<void>;
+  update(): void;
+  getAnalysisStatus(): string;
+  getMotionStatus(): string;
+  getMetadata(): string;
+}
+//#endregion
+//#region src/modules/id/types.d.ts
+type IdCaptureMode = 'front' | 'back' | 'passport';
+/**
+ * Document type options for the ID capture chooser (ID, passport, manual ID upload, digital ID upload, digital ID from device wallet).
+ * Used for selection and for the list of available options derived from config.
+ */
+type IdDocumentType = 'id' | 'passport' | 'manualIdUpload' | 'digitalIdUpload' | 'digitalId';
+type IdFlowStep = 'chooser' | 'ageVerification' | 'tutorial' | 'permissions' | 'capture' | 'mandatoryConsent' | 'frontFinished' | 'backFinished' | 'success' | 'processing' | 'expired' | 'finished' | 'error' | 'closed' | 'manualIdUpload' | 'digitalIdUpload';
+type DetectionStatus = 'idle' | 'detecting' | 'farAway' | 'blur' | 'glare' | 'wrongSide' | 'capturing' | 'manualCapture' | 'idNotDetected' | 'offline';
+/**
+ * Represents the detection area dimensions in pixels.
+ * Used by UI to communicate the expected ID position and size to the WASM detection.
+ */
+type DetectionArea = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+type IdCaptureGeometry = {
+  areaDown: number;
+  areaUp: number;
+  areaIOSPassportUp: number;
+  areaIOSPassportDown: number;
+  widthIOSUp: number;
+  widthIOSDown: number;
+  widthDown: number;
+  widthUp: number;
+  windowOuterWidth: number;
+  windowOuterHeight: number;
+  windowInnerWidth: number;
+  windowInnerHeight: number;
+};
+type IdCaptureThresholds = {
+  blurThreshold: number;
+  blurChangeThreshold: number;
+  glareThreshold: number;
+  clsThreshold: number;
+  sideThreshold: number;
+  iouThreshold: number;
+  framesAggregationInterval: number;
+  idDetectedTimeout: number;
+  autocaptureTimeout: number;
+};
+type IdCaptureConfig = TutorialIdConfig & {
+  recording?: {
+    capability?: IRecordingCapability;
+  };
+  ageAssurance?: boolean;
+  mergeSessionRecordings?: boolean;
+  isDeepsightEnabled?: boolean;
+  isSecondId?: boolean;
+  geometry?: IdCaptureGeometry;
+  detectionArea?: DetectionArea;
+  thresholds?: Partial<IdCaptureThresholds>;
+  settings?: Partial<IdCaptureSettings>;
+  modelVersion?: 'v1' | 'v2' | 'v3';
+  ds?: Flow['ds'];
+  /**
+   * When true, the capture machine reaches `finished` immediately after
+   * back-side / manual-upload completion instead of invoking `/process/id`.
+   * Used by engines where verification is owned by a downstream node — the
+   * Workflow engine's `ID` node (handled by `idVerificationMachine`). Flow and
+   * any other single-step caller leave this `false` so the inline verification
+   * + recapture-on-expired UX continues to work.
+   */
+  skipProcessId?: boolean;
+  /**
+   * Opts the rendering layer into the IDC-05 post-capture preview beat.
+   * When enabled, the machine waits in `resultPreview` until the rendering
+   * layer calls `completeResultPreview()`. When false or omitted, capture
+   * proceeds directly to `uploading`, preserving the existing headless flow.
+   *
+   * `@incodetech/web` enables this because it implements the flash and frozen
+   * preview. Headless integrations should enable it only when they implement
+   * that state and its `completeResultPreview()` transition.
+   *
+   * Pass `false` to opt the session out of the experiment entirely — no
+   * parameter-store read, no Statsig exposure, and no assignment event.
+   */
+  supportsCaptureResultPreview?: boolean;
+};
+/**
+ * Public ID capture configuration for the captureOnly flow.
+ *
+ * captureOnly bypasses the Incode upload/processing pipeline, so this config
+ * intentionally exposes ONLY the options that affect the on-device capture
+ * experience. The backend-coupled flags of {@link IdCaptureConfig} (device
+ * wallet, barcode, additional pages, digital-id upload, smart capture, session
+ * recording, per-country overrides, …) don't apply here and are omitted.
+ *
+ * `onCapture` is the one required field — it receives the captured image(s)
+ * locally (compile-time enforced so you can't ship a captureOnly flow with no
+ * destination for the payload). Everything else is optional and defaulted by
+ * the factory (see `DEFAULT_ID_CAPTURE_ONLY_CONFIG`); set only what you care
+ * about, e.g. `{ onCapture, captureAttempts: 5, showDocumentChooserScreen: true }`.
+ */
+type IdCaptureOnlyConfig = Partial<Pick<IdCaptureConfig, 'showTutorial' | 'captureAttempts' | 'autoCaptureTimeout' | 'deviceIdleTimeout' | 'enableId' | 'enablePassport' | 'onlyFront' | 'onlyBack' | 'showDocumentChooserScreen'>> & {
+  onCapture: (response: CaptureOnlyResponse) => void | Promise<void>;
+};
+type IdErrorCode = 'UPLOAD_ERROR' | 'CLASSIFICATION_FAILED' | 'LOW_SHARPNESS' | 'GLARE_DETECTED' | 'WRONG_DOCUMENT_SIDE' | 'ID_TYPE_UNACCEPTABLE' | 'READABILITY_ISSUE' | 'RETRY_EXHAUSTED_CONTINUE_TO_BACK' | 'RETRY_EXHAUSTED_SKIP_BACK' | 'NO_MORE_TRIES' | 'UNEXPECTED_ERROR' | 'NO_TOKEN' | 'PERMISSION_DENIED' | 'USER_CANCELLED' | 'SERVER_ERROR';
+type IdError = {
+  code: IdErrorCode;
+  message: string;
+  messageDescription?: string;
+};
+type UploadIdResponse = {
+  sharpness: number;
+  correctSharpness: boolean;
+  glare: number;
+  correctGlare: boolean;
+  horizontalResolution: number;
+  classification: boolean;
+  readability: boolean;
+  typeOfId: string;
+  issueYear: number;
+  issueName: string;
+  curpCheck?: boolean;
+  sessionStatus: string;
+  countryCode: string;
+  state?: string;
+  skipBackIdCapture?: boolean;
+  skipGlareFront?: boolean;
+  skipGlareBack?: boolean;
+  documentIsOnTheEdge?: boolean;
+  acceptedDocuments?: Array<{
+    type: string;
+    name: string;
+  }>;
+  forceFrontIdCapture?: boolean;
+  /**
+   * US Smart Capture: when `true`, the backend has already validated the ID
+   * (e.g. from the parallel barcode submission), so the inline Process ID
+   * (`/omni/process/id`) call must be skipped. Mirrors SDK 1's
+   * `AddBarcodeV3Response.idValidationCompleted`.
+   */
+  idValidationCompleted?: boolean;
+  showMandatoryConsent?: boolean;
+  regulationType?: RegulationTypes;
+  failReason?: string;
+  side?: 'front' | 'back';
+  idQualityAttemptApproved?: boolean;
+  isDocumentExpired?: boolean;
+  /** `false` means the upload was rejected even when no `failReason` is set. */
+  success?: boolean;
+};
+/**
+ * Response from `POST /omni/add/barcode/v3` (US Smart Capture). The barcode
+ * submission is the server's fast path: it drives whether front capture and
+ * Process ID are still required. Mirrors SDK 1's `AddBarcodeV3Response`.
+ */
+type AddBarcodeV3Response = {
+  countryCode?: string;
+  /** When false, front capture can be skipped after the barcode is added. */
+  forceFrontIdCapture?: boolean;
+  /** When true, server-side ID validation completed (Process ID not required). */
+  idValidationCompleted?: boolean;
+  isDocumentExpired?: boolean;
+  sessionStatus?: string;
+  success?: boolean;
+};
+type CaptureIdResponse = UploadIdResponse & {
+  croppedIDFace?: string;
+  croppedFrontID?: string;
+  croppedBackID?: string;
+  originalImage?: string;
+  frontIdImage?: string;
+  backIdImage?: string;
+};
+type CapturedImage = {
+  imageBase64: string;
+};
+/**
+ * Rich captured image shape used by the captureOnly flow.
+ *
+ * `imageBase64`/`blob`/`url` reference the unprocessed full frame — always
+ * present and the safest input for integrator-side processing.
+ *
+ * `croppedImage` is a best-effort approximate document crop produced by a
+ * bilinear quad map (not a true perspective/homography warp). It is
+ * populated only when on-device quad detection succeeds, and will visibly
+ * diverge from the correct projective result for strongly tilted captures.
+ * Prefer `imageBase64` when fidelity matters.
+ */
+type IdCapturedImageData = {
+  imageBase64: string;
+  blob: Blob;
+  url: string;
+  metadata: string;
+  croppedImage?: {
+    imageBase64: string;
+    blob: Blob;
+    url: string;
+  };
+};
+/**
+ * Payload delivered to `IdCaptureConfig.onCapture` when `captureOnly` is enabled.
+ */
+type CaptureOnlyResponse = {
+  frontImage: IdCapturedImageData;
+  backImage: IdCapturedImageData | undefined;
+};
+type RecordingSession = {
+  token: string;
+  sessionId: string;
+  videoRecordingId: string;
+  connection: RecordingConnection;
+  resolution?: string;
+  hasAudio: boolean;
+};
+declare const ID_ERROR_CODES: {
+  readonly UPLOAD_ERROR: "UPLOAD_ERROR";
+  readonly CLASSIFICATION_FAILED: "CLASSIFICATION_FAILED";
+  readonly LOW_SHARPNESS: "LOW_SHARPNESS";
+  readonly GLARE_DETECTED: "GLARE_DETECTED";
+  readonly WRONG_DOCUMENT_SIDE: "WRONG_DOCUMENT_SIDE";
+  readonly ID_TYPE_UNACCEPTABLE: "ID_TYPE_UNACCEPTABLE";
+  readonly READABILITY_ISSUE: "READABILITY_ISSUE";
+  readonly RETRY_EXHAUSTED_CONTINUE_TO_BACK: "RETRY_EXHAUSTED_CONTINUE_TO_BACK";
+  readonly RETRY_EXHAUSTED_SKIP_BACK: "RETRY_EXHAUSTED_SKIP_BACK";
+  readonly NO_MORE_TRIES: "NO_MORE_TRIES";
+  readonly UNEXPECTED_ERROR: "UNEXPECTED_ERROR";
+  readonly NO_TOKEN: "NO_TOKEN";
+  readonly PERMISSION_DENIED: "PERMISSION_DENIED";
+  readonly USER_CANCELLED: "USER_CANCELLED";
+  readonly SERVER: "SERVER_ERROR";
+};
+type IdCaptureContext = {
+  config: IdCaptureConfig;
+  /**
+   * SDK-resolved capture feedback mode for this session. Set once at actor
+   * creation from the IDC-05 treatment (or `'countdown'` when excluded).
+   * Not host-settable — use `supportsCaptureResultPreview: false` to opt out.
+   */
+  captureFeedbackMode: 'countdown' | 'result-preview';
+  currentMode: IdCaptureMode;
+  selectedDocumentType: IdDocumentType | undefined;
+  stream: CameraStream | undefined;
+  provider: IIdCaptureCapability | undefined;
+  frameCapturer: StreamCanvasCapture | undefined;
+  error: string | undefined;
+  detectionStatus: DetectionStatus;
+  counterValue: number;
+  orientation: DetectionOrientation | undefined;
+  capturedImages: {
+    front?: CapturedImage;
+    back?: CapturedImage;
+  };
+  /**
+   * Rich capture payload used only by the captureOnly flow.
+   * Populated by `finalizeIdCaptureOnly` actor; consumed by `finished.entry`
+   * when firing `config.onCapture`. Remains empty in the regular upload flow.
+   */
+  captureOnlyImages: {
+    front?: IdCapturedImageData;
+    back?: IdCapturedImageData;
+  };
+  uploadResponse: CaptureIdResponse | undefined;
+  /**
+   * Most recent PDF417 barcode decoded on-device during US Smart Capture back
+   * capture, or `null` when none decoded this attempt. Drives the barcode
+   * submit path; cleared on side flip / retry.
+   */
+  decodedBarcode: Pdf417DecodeResult | null;
+  /**
+   * Whether the pre-capture barcode fast path has fired this attempt. One-shot:
+   * once attempted, a repeat decode falls through to the best-frame submit
+   * path. Reset on side flip / retry.
+   */
+  barcodeFastPathAttempted: boolean;
+  /**
+   * True while `success` was reached via the pre-capture barcode fast path. The
+   * fast path grabs an unframed analyzing frame only as a backend "no front, no
+   * match" signal, so that frame must NOT be shown as a captured photo: the UI
+   * keeps the "Hold on a sec" spinner and the step auto-advances. Set on the
+   * fast-path submit's `onDone`, cleared on `success` exit (so a later
+   * best-frame / front `success` shows its real captured image as usual).
+   */
+  barcodeFastPathCaptured: boolean;
+  recordingSession: RecordingSession | undefined;
+  attemptsRemaining: number;
+  /**
+   * Number of consecutive `isDocumentExpired === true` upload responses for
+   * the current side (V1's `expiredFirstSideAttempt`). Reset on every side
+   * change; preserved across the same-side soft-retry cycle
+   * (`expired → capture`). Compared against `config.captureAttempts`. This is
+   * a per-side local counter only — the cross-side expired-back→front redirect
+   * is bounded separately by `expiredRedirected` (see below).
+   */
+  expiredAttempts: number;
+  /**
+   * Number of times `processId` (end-of-flow expired detection) has returned
+   * `isDocumentExpired === true` in this session. Persists across the full
+   * `resetContext`-driven retry loop (Figma Story #2.2, 2-cap on the
+   * digital-upload / multi-side path).
+   */
+  processingExpiredAttempts: number;
+  /**
+   * Set when the user has reached `expiredExhausted` and clicks Continue.
+   * Tells the `processing` state to bypass `processId` (V1 parity: no
+   * `/omni/process-id` call after force-back).
+   */
+  skipProcessId: boolean;
+  /**
+   * Distinguishes the two entry paths into the `expired` screen:
+   * `true` for per-upload (camera) expired, `false` for `processing.onDone`
+   * (digital-upload / end-of-flow expired). Drives the soft-retry branch.
+   */
+  expiredFromUpload: boolean;
+  /**
+   * `true` once a Digital ID upload has succeeded for this session. Digital
+   * IDs are single-side documents (semantically like a passport), so back
+   * capture must be skipped regardless of `alwaysCaptureBackOfId`. Used by
+   * the manager mapper's `shouldCaptureBack` to suppress `needsBackCapture`
+   * for the workflow orchestrator.
+   */
+  isDigitalUpload: boolean;
+  /**
+   * Set when `expiredExhausted` was reached via the per-upload (camera)
+   * exhaustion path. Used by `CONTINUE_EXHAUSTED` to decide whether to run
+   * `processId` once before finishing — required so the backend processes
+   * whatever sides were uploaded (e.g. valid front + expired back).
+   */
+  exhaustedFromUpload: boolean;
+  /**
+   * Tells the `processing` state to skip the per-upload-expired retry/exhaustion
+   * branches and go straight to `finished` after `processId.onDone`. Set
+   * when entering `processing` from the `expiredExhausted → Continue` path
+   * so we don't loop back to the Expired screen after we've already shown
+   * the terminal "No attempts remaining" view.
+   */
+  forceFinishAfterProcessing: boolean;
+  /**
+   * One-shot flag (V1's `expiredRedirected`). Set when an expired BACK upload
+   * in a multi-side flow sends the user back to FRONT capture for one more
+   * attempt (Figma Story #2.1 / ENG-46592). Session-global — preserved across
+   * the front/back side resets so it survives the flip cycle. Once set, any
+   * further expired upload routes straight to `expiredExhausted` instead of
+   * redirecting again, so the back→front redirect happens AT MOST ONCE per
+   * session. This is what keeps total captures within the backend's
+   * max-attempts/OCR cap (re-respects ENG-45666). Session-global: preserved
+   * across side resets and mid-flow `resetContext` restarts (like V1's
+   * localStorage flag); a fresh session starts it `false`.
+   */
+  expiredRedirected: boolean;
+  uploadError: IdErrorCode | undefined;
+  permissionResult: PermissionResult | 'refresh' | undefined;
+  resetDetection: (() => void) | undefined;
+  idType: string | undefined;
+  qualityElements: {
+    glare?: number;
+    sharpness?: number;
+  } | undefined;
+  frameRect: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+  } | undefined;
+  detectionArea: DetectionArea | undefined;
+  previewImageUrl?: string;
+  /** Experiment (uxp_idc_exp07): the just-captured photo preserved across the
+   *  side-switch reset so the flip screen can render it. */
+  flipPreview?: {
+    url: string;
+    orientation: DetectionOrientation | undefined;
+    mode: 'id' | 'passport';
+  };
+  uploadProgress?: number;
+  manualCaptureTriggered: boolean;
+  deepsightService: DeepsightService | undefined;
+  analyticsProvider: IAnalyticsCapability | undefined;
+  dependencies: IdCaptureDependencies | undefined;
+  disableIpify: boolean;
+  deepsightInitAttempted: boolean;
+  availableDocumentTypes: IdDocumentType[];
+  /** Negotiated camera resolution (e.g. "1920x1080") for telemetry */
+  captureResolution?: string;
+  /** Android camera access fallback level that succeeded */
+  cameraFallbackLevel?: number;
+};
+type IdCaptureEvent = {
+  type: 'LOAD';
+} | {
+  type: 'SELECT_DOCUMENT';
+  documentType: IdDocumentType;
+} | {
+  type: 'NEXT_STEP';
+} | {
+  type: 'RESULT_PREVIEW_COMPLETE';
+} | {
+  type: 'REQUEST_PERMISSION';
+} | {
+  type: 'GO_TO_LEARN_MORE';
+} | {
+  type: 'BACK';
+} | {
+  type: 'QUIT';
+} | {
+  type: 'RESET';
+} | {
+  type: 'MANUAL_CAPTURE';
+} | {
+  type: 'SWITCH_TO_MANUAL_CAPTURE';
+} | {
+  type: 'DETECTION_UPDATE';
+  status: DetectionStatus;
+} | {
+  type: 'DETECTION_SUCCESS';
+  canvas: IncodeCanvas;
+  qualityElements?: {
+    glare?: number;
+    sharpness?: number;
+  };
+} | {
+  type: 'BARCODE_DECODED';
+  decoded: Pdf417DecodeResult;
+} | {
+  type: 'DETECTION_RESET_READY';
+  reset: () => void;
+} | {
+  type: 'COUNTER_VALUE_CHANGE';
+  value: number;
+} | {
+  type: 'ID_TYPE_CHANGE';
+  idType: string;
+} | {
+  type: 'ID_SIDE_CHANGE';
+  side: string;
+} | {
+  type: 'ORIENTATION_CHANGE';
+  orientation: DetectionOrientation;
+} | {
+  type: 'RETRY_CAPTURE';
+} | {
+  type: 'CONTINUE_EXHAUSTED';
+} | {
+  type: 'CONTINUE_FROM_ERROR';
+} | {
+  type: 'FRONT_COMPLETE';
+} | {
+  type: 'CONTINUE_TO_BACK';
+} | {
+  type: 'CONTINUE_TO_FRONT';
+} | {
+  type: 'PROCESS_COMPLETE';
+} | {
+  type: 'PROCESS_EXPIRED';
+} | {
+  type: 'CONSENT_ACCEPT';
+} | {
+  type: 'CONSENT_CANCEL';
+} | {
+  type: 'SKIP_BACK';
+} | {
+  type: 'UPLOAD_PROGRESS';
+  progress: number;
+} | {
+  type: 'UPLOAD_PROGRESS_TICK';
+} | {
+  type: 'SET_FRAME_RECT';
+  frameRect: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+  };
+} | {
+  type: 'UPDATE_DETECTION_AREA';
+  detectionArea: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+} | {
+  type: 'MANUAL_UPLOAD_TAB_CHANGED';
+  tab: ManualUploadTab;
+} | {
+  type: 'MANUAL_UPLOAD_FILE_SELECTED';
+  side: ManualUploadSide;
+  file: File;
+} | {
+  type: 'MANUAL_UPLOAD_CONTINUE';
+} | {
+  type: 'MANUAL_UPLOAD_RESET';
+} | {
+  type: 'DIGITAL_UPLOAD_NEXT_STEP';
+} | {
+  type: 'DIGITAL_UPLOAD_FILE_PICKED';
+  file: File;
+} | {
+  type: 'DIGITAL_UPLOAD_CONFIRM';
+} | {
+  type: 'DIGITAL_UPLOAD_REPLACE';
+} | {
+  type: 'DIGITAL_UPLOAD_RETRY';
+} | {
+  type: 'DIGITAL_UPLOAD_SCAN_INSTEAD';
+} | {
+  type: 'DIGITAL_UPLOAD_CHOOSE_ANOTHER';
+};
+type IdCaptureDependencies = {
+  storage: IStorageCapability;
+  trackCaptureAttemptFinished?: (payload: {
+    logs: string;
+    resolution?: string;
+    fallbackLevel?: number;
+  }) => void;
+};
+type IdCaptureInput = {
+  config: IdCaptureConfig;
+  /**
+   * SDK-resolved at actor creation. Omitted by direct machine construction
+   * defaults to `'countdown'` in the context factory.
+   */
+  captureFeedbackMode?: 'countdown' | 'result-preview';
+  analyticsProvider?: IAnalyticsCapability;
+  dependencies?: IdCaptureDependencies;
+};
+/**
+ * Terminal output of `idCaptureMachine`, read by the Flow orchestrator (via
+ * `runChildModule`'s `MODULE_COMPLETE`) to decide downstream module skipping.
+ *
+ * Declared at the machine ROOT (not on a final state) so it actually populates
+ * the actor output in this XState version. It is therefore emitted on EVERY
+ * top-level final state (`finished` AND `closed`); `computeIdCaptureOutput`
+ * gates the skip on a captured back + no front, so cancel / no-capture paths
+ * yield `skipFaceMatch: false`. The `| undefined` branch is a defensive type
+ * allowance and is not produced at runtime.
+ */
+type IdCaptureOutput = {
+  /** A front-of-ID image was captured this session (an ID face exists). */
+  frontIdCaptured: boolean;
+  /**
+   * Under US Smart Capture, `true` when the ID completed WITHOUT a front
+   * image ("no front, no match"): the downstream Face Match step has no ID
+   * face to compare the selfie against and should be skipped. Always
+   * `false` outside `usSmartCapture` (standard front+back always captures a
+   * front). The selfie/face capture itself is unaffected.
+   */
+  skipFaceMatch: boolean;
+} | undefined;
+//#endregion
+export { ManualUploadSide as A, RecordingSession as C, MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES as D, MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS as E, MANUAL_UPLOAD_MAX_RETRIES as O, IdFlowStep as S, IAnalyticsCapability as T, IdCaptureThresholds as _, DetectionArea as a, IdError as b, IdCaptureConfig as c, IdCaptureEvent as d, IdCaptureGeometry as f, IdCaptureOutput as g, IdCaptureOnlyConfig as h, CapturedImage as i, ManualUploadTab as j, ManualUploadContext as k, IdCaptureContext as l, IdCaptureMode as m, CaptureIdResponse as n, DetectionStatus as o, IdCaptureInput as p, CaptureOnlyResponse as r, ID_ERROR_CODES as s, AddBarcodeV3Response as t, IdCaptureDependencies as u, IdCapturedImageData as v, UploadIdResponse as w, IdErrorCode as x, IdDocumentType as y };

package/dist/{types-DV3wkhQ4.d.ts → types-Vb4P9ovf.d.ts}

@@ -1,7 +1,5 @@
-import { t as CameraStream } from "./camera-CKU96nwJ.js";
-
+import { t as CameraStream } from "./camera-9wWD-pwg.js";
 //#region src/modules/document-upload/types.d.ts
-
 /**
  * Configuration for document upload (e.g., third ID capture).
  * The documentType determines the backend endpoint query parameter.

package/dist/{urlUtils-CpiYwn7w.esm.js → urlUtils-D6phjq1-.esm.js}

@@ -11,6 +11,5 @@ function buildUrlWithSearchParams(baseUrl, params) {
 	for (const [key, value] of Object.entries(params)) if (value !== void 0) url.searchParams.set(key, value);
 	return url.href;
 }
-
 //#endregion
-export { getUrlSearchParam as n, buildUrlWithSearchParams as t };
+export { getUrlSearchParam as n, buildUrlWithSearchParams as t };

package/dist/{video-ZY92rkel.esm.js → video-BtSWtHy1.esm.js}

@@ -31,6 +31,5 @@ function createHiddenVideoElement(stream, options) {
 		}
 	};
 }
-
 //#endregion
-export { createHiddenVideoElement as t };
+export { createHiddenVideoElement as t };