@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/idCaptureManager-Fyd0eam-.d.ts

@@ -0,0 +1,958 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import { t as ActorRefFrom } from "./Actor-CI32dTbG.js";
+import { n as StateMachine, t as AnyStateMachine } from "./StateMachine-BCQrZJhf.js";
+import { t as CameraStream } from "./camera-DBSxa6ML.js";
+import { a as RegulationTypes, n as Flow, o as TutorialIdConfig } from "./types-BP1m8VRw.js";
+import { c as IMLProviderCapability, d as IRecordingCapability, f as RecordingConnection, i as IncodeCanvas, l as MLProviderConfig, n as IMotionSensorCapability, r as StreamCanvasCapture, t as DeepsightService, u as IStorageCapability } from "./deepsightService-CEVxzehb.js";
+import { n as PermissionStatus, t as PermissionResult } from "./types-CAD4va6a.js";
+
+//#region ../infra/src/capabilities/IIdCaptureCapability.d.ts
+/**
+ * Configuration for ID capture provider.
+ * Extends base ML provider config with ID-capture specific options.
+ */
+type IdCaptureConfig$1 = MLProviderConfig;
+interface IdCaptureThresholds$1 {
+  blurThreshold: number;
+  blurChangeThreshold: number;
+  glareThreshold: number;
+  clsThreshold: number;
+  sideThreshold: number;
+  iouThreshold: number;
+  idDetectedTimeout: number;
+  autocaptureTimeout: number;
+  framesAggregationInterval: number;
+}
+interface IdCaptureGeometry$1 {
+  areaDown: number;
+  areaUp: number;
+  areaIOSPassportUp: number;
+  areaIOSPassportDown: number;
+  widthIOSUp: number;
+  widthIOSDown: number;
+  widthDown: number;
+  widthUp: number;
+  windowOuterWidth: number;
+  windowOuterHeight: number;
+  windowInnerWidth: number;
+  windowInnerHeight: number;
+}
+interface IdCaptureSettings {
+  isFixedMask: boolean;
+  isIPhone14OrHigher: boolean;
+  idType: string;
+  blurCheckEnabled: boolean;
+  glareCheckEnabled: boolean;
+  faceQualityCheckEnabled: boolean;
+  iouCheckEnabled: boolean;
+  fpsLimitEnabled: boolean;
+}
+type IdCaptureModelType = 'v1' | 'v2' | 'v3';
+type DetectionOrientation = 'horizontal' | 'vertical';
+interface IdCaptureCallbacks {
+  onFarAway?: () => void;
+  onDetectionStarted?: () => void;
+  onMaskChange?: (show: boolean, mask: boolean, top: number, orientation: DetectionOrientation) => void;
+  onBlur?: () => void;
+  onGlare?: () => void;
+  onCapturing?: () => void;
+  onCapture?: () => void;
+  onBestFrame?: (blur: number, glare: number, orientation: string) => void;
+  onIdNotDetected?: () => void;
+  onSwitchToManualCapture?: () => void;
+  onIdTypeChange?: (idType: string) => void;
+  onIdSideChange?: (side: string) => void;
+  onCapturingCounterValueChange?: (value: number) => void;
+}
+/**
+ * WASM array type for quad coordinates.
+ * Use .get(index) instead of [index] to access elements.
+ */
+interface QuadArray {
+  get(index: number): {
+    x: number;
+    y: number;
+  };
+  size?(): number;
+  length?: number;
+}
+interface IdCaptureProcessResult {
+  cls: number;
+  blur: number;
+  glare: number;
+  quad: QuadArray;
+  barQuad: QuadArray;
+  side: string;
+  size: number;
+  idType: string;
+  networkInferenceTime: number;
+}
+/**
+ * Capability interface for ID document capture.
+ * Extends the base ML provider capability with ID-capture specific methods.
+ */
+interface IIdCaptureCapability extends IMLProviderCapability<IdCaptureConfig$1> {
+  /**
+   * Sets callbacks for ID capture events.
+   * @param callbacks - Object containing callback functions for various capture events
+   */
+  setCallbacks(callbacks: IdCaptureCallbacks): void;
+  /**
+   * Sets detection thresholds for quality checks.
+   * @param thresholds - Threshold values for blur, glare, and other quality metrics
+   */
+  setThresholds(thresholds: IdCaptureThresholds$1): void;
+  /**
+   * Sets geometry constraints for ID detection.
+   * @param geometry - Geometry parameters for ID positioning
+   */
+  setGeometry(geometry: IdCaptureGeometry$1): void;
+  /**
+   * Sets capture settings.
+   * @param settings - Configuration for capture behavior
+   */
+  setSettings(settings: IdCaptureSettings): void;
+  /**
+   * Sets the ML model type to use for ID detection.
+   * @param modelType - Model version ('v1', 'v2', or 'v3')
+   */
+  setModelType(modelType: IdCaptureModelType): void;
+  /**
+   * Gets the last process result from the most recent frame processing.
+   * Returns null if no frame has been processed yet.
+   * @returns The last process result with quad coordinates, or null if not available
+   */
+  getLastProcessResult(): IdCaptureProcessResult | null;
+  /**
+   * Transforms the canvas using perspective correction based on frame coordinates.
+   * @param canvas - The canvas to transform
+   * @param frameRect - Frame rectangle in canvas coordinates (x, y, w, h)
+   * @returns The transformed canvas
+   */
+  transformPerspective(canvas: IncodeCanvas, frameRect: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+  }): IncodeCanvas;
+  /**
+   * Gets the captured canvas (transformed for preview).
+   * @returns The captured canvas, or null if not available
+   */
+  getCapturedCanvas(): IncodeCanvas | null;
+  /**
+   * Gets the original captured canvas (full frame for upload).
+   * @returns The original captured canvas, or null if not available
+   */
+  getOriginalCapturedCanvas(): IncodeCanvas | null;
+  /**
+   * Sets the captured canvases (original and transformed).
+   * Called by the state machine after capture and transformation.
+   * @param original - The original full-frame canvas (for upload)
+   * @param transformed - The transformed canvas (for preview)
+   */
+  setCapturedCanvases(original: IncodeCanvas, transformed: IncodeCanvas): void;
+}
+//#endregion
+//#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;
+  frontFile: File | null;
+  backFile: File | null;
+  passportFile: File | null;
+  activeTab: ManualUploadTab;
+  retriesLeft: number;
+  errorMessage: string | 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;
+};
+/**
+ * Public ID capture configuration for the captureOnly flow.
+ *
+ * Differs from {@link IdCaptureConfig} by requiring an `onCapture` callback —
+ * captureOnly bypasses the Incode upload pipeline and delivers the rich
+ * capture payload locally instead. Compile-time enforcement (vs. a runtime
+ * check) prevents shipping a captureOnly flow with no destination for the
+ * payload.
+ */
+type IdCaptureOnlyConfig = IdCaptureConfig & {
+  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;
+  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;
+};
+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;
+  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;
+  recordingSession: RecordingSession | undefined;
+  attemptsRemaining: number;
+  /**
+   * Number of consecutive `isDocumentExpired === true` upload responses for
+   * the current side. Reset on side change; preserved across the soft-retry
+   * cycle (`expired → capture`). Compared against `config.captureAttempts`.
+   */
+  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;
+  uploadError: IdErrorCode | undefined;
+  permissionResult: PermissionResult | 'refresh' | undefined;
+  resetDetection: (() => void) | undefined;
+  idType: string | undefined;
+  qualityElements: {
+    glare?: number;
+    sharpness?: number;
+  } | undefined;
+  debugFrame: ImageData | undefined;
+  frameRect: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+  } | undefined;
+  detectionArea: DetectionArea | undefined;
+  previewImageUrl?: string;
+  uploadProgress?: number;
+  motionStatus?: 'PASS' | 'FAIL' | 'UNCLEAR';
+  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: '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_FRAME';
+  frame: ImageData;
+} | {
+  type: 'DETECTION_SUCCESS';
+  canvas: IncodeCanvas;
+  qualityElements?: {
+    glare?: number;
+    sharpness?: number;
+  };
+} | {
+  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: '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: 'MOTION_STATUS';
+  status: 'PASS' | 'FAIL' | 'UNCLEAR';
+} | {
+  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;
+  motionProvider?: IMotionSensorCapability;
+  analyticsProvider?: IAnalyticsCapability;
+  dependencies?: IdCaptureDependencies;
+};
+//#endregion
+//#region src/modules/id/idCaptureStateMachine.d.ts
+declare const idCaptureMachine: AnyStateMachine;
+type IdCaptureMachine = StateMachine<IdCaptureContext, IdCaptureEvent, any, any, any, any, any, any, any, IdCaptureInput, any, any, any, any>;
+//#endregion
+//#region src/modules/id/idCaptureActor.d.ts
+type CreateIdCaptureActorOptions = {
+  config: IdCaptureConfig;
+  dependencies?: IdCaptureDependencies;
+};
+type IdCaptureActor = ActorRefFrom<IdCaptureMachine>;
+declare function createIdCaptureActor(options: CreateIdCaptureActorOptions): IdCaptureActor;
+//#endregion
+//#region src/modules/id/idCaptureOnlyStateMachine.d.ts
+type IdCaptureOnlyContext = IdCaptureContext;
+type IdCaptureOnlyEvent = IdCaptureEvent;
+type IdCaptureOnlyInput = IdCaptureInput;
+/**
+ * ID capture state machine variant for the captureOnly flow. Shares the full
+ * base ID-capture state tree (chooser, tutorial, permissions, capture,
+ * front/back finished, processing, finished); only the upload, process, and
+ * recording steps are local instead of remote.
+ */
+declare const idCaptureOnlyMachine: AnyStateMachine;
+type IdCaptureOnlyMachine = StateMachine<IdCaptureOnlyContext, IdCaptureOnlyEvent, any, any, any, any, any, any, any, IdCaptureOnlyInput, any, any, any, any>;
+//#endregion
+//#region src/modules/id/idCaptureOnlyActor.d.ts
+type CreateIdCaptureOnlyActorOptions = {
+  config: IdCaptureOnlyConfig;
+  dependencies?: IdCaptureDependencies;
+};
+type IdCaptureOnlyActor = ActorRefFrom<IdCaptureOnlyMachine>;
+declare function createIdCaptureOnlyActor(options: CreateIdCaptureOnlyActorOptions): IdCaptureOnlyActor;
+//#endregion
+//#region src/modules/id/idCaptureServices.d.ts
+type IdCaptureInitResult = {
+  stream: CameraStream;
+  provider: IIdCaptureCapability;
+  captureResolution?: string;
+  cameraFallbackLevel?: number;
+};
+type InitializeIdCaptureParams = {
+  config: IdCaptureConfig;
+  deepsightService?: DeepsightService;
+};
+declare function initializeIdCapture(params: InitializeIdCaptureParams): Promise<IdCaptureInitResult>;
+declare function stopStream(stream: CameraStream): void;
+type UploadIdImageParams = {
+  image: string;
+  type: 'front' | 'back';
+  sendBase64?: boolean;
+  isSecondId?: boolean;
+  onlyFront?: boolean;
+  glare?: number;
+  sharpness?: number;
+  shouldSkipGlareBack?: boolean;
+  shouldSkipGlareFront?: boolean;
+  captureType?: string;
+  ageAssurance?: boolean;
+  onProgress?: (progress: number) => void;
+  metadata?: string;
+  signal?: AbortSignal;
+  analyticsProvider?: IAnalyticsCapability;
+  imageData?: ImageData;
+};
+type ValidationError = {
+  error: boolean;
+  message: string;
+  messageDescription?: string;
+  errorKey: IdErrorCode;
+};
+declare function validateUploadResponse(response: UploadIdResponse & {
+  failReason?: string;
+  side?: 'front' | 'back';
+}, sessionState?: {
+  skipGlareFront?: boolean;
+  skipGlareBack?: boolean;
+}): ValidationError | undefined;
+declare function uploadIdImage(params: UploadIdImageParams): Promise<CaptureIdResponse>;
+type StartRecordingParams = {
+  config: IdCaptureConfig;
+  stream: CameraStream;
+  existing?: RecordingSession;
+  type: 'frontId' | 'backId';
+};
+declare function preloadIdRecordingProvider(config: IdCaptureConfig): void;
+declare function startRecordingSession(params: StartRecordingParams): Promise<RecordingSession | undefined>;
+declare function stopRecording(session: RecordingSession): void;
+declare function processId(isSecondId?: boolean, queueName?: string, signal?: AbortSignal): Promise<{
+  isDocumentExpired: boolean;
+}>;
+type UploadManualIdFileParams = {
+  side: 'front' | 'back' | 'passport';
+  /**
+   * Raw base64 payload (no `data:<mime>;base64,` prefix). Callers must strip
+   * the data-URL prefix — the v2 backend rejects data URLs with
+   * `IllegalArgumentException: Illegal base64 character 3a`.
+   */
+  base64Image: string;
+  retry?: boolean;
+  onlyFront?: boolean;
+  signal?: AbortSignal;
+  isSecondId?: boolean;
+};
+/**
+ * Upload a user-selected image as front / back / passport ID.
+ *
+ * Uses the same request shape as the live-camera path (`uploadIdImage`):
+ * JSON body `{ base64Image }` with default application/json Content-Type,
+ * `captureType=UPLOAD` query param, `retry=true` when retrying.
+ * Back is POSTed to `/omni/add/back-id/v2` (or `/omni/add/back-second-id/v2`
+ * when `isSecondId`); front and passport go to `/omni/add/front-id/v2` (or
+ * `/omni/add/front-second-id/v2` when `isSecondId`).
+ *
+ * The v2 endpoints reject raw `image/jpeg` bodies with 415, so the caller
+ * must convert the File to base64 before calling this service.
+ */
+declare function uploadManualIdFile(params: UploadManualIdFileParams): Promise<UploadIdResponse>;
+//#endregion
+//#region src/modules/id/digitalUpload/types.d.ts
+type DigitalUploadFailReason = 'DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED' | 'ID_TYPE_UNACCEPTABLE' | 'FILE_CHANGED_ERROR' | 'INVALID_FILE_TYPE' | 'NETWORK_ERROR' | 'GENERIC';
+//#endregion
+//#region src/internal/idCapture/idCaptureManagerFactory.d.ts
+type CaptureStatus = 'initializing' | 'detecting' | 'capturing' | 'uploading' | 'uploadError' | 'success';
+type IdCaptureIdleState = {
+  status: 'idle';
+};
+type IdCaptureChooserState = {
+  status: 'chooser';
+  availableDocumentTypes: IdDocumentType[];
+};
+type IdCaptureLoadingState = {
+  status: 'loading';
+};
+type IdCaptureTutorialState = {
+  status: 'tutorial';
+  selectedDocumentType: IdDocumentType | undefined;
+  currentMode: IdCaptureMode;
+};
+type IdCaptureAgeVerificationState = {
+  status: 'ageVerification';
+};
+type IdCapturePermissionsState = {
+  status: 'permissions';
+  permissionStatus: PermissionStatus;
+};
+type IdCaptureCaptureState = {
+  status: 'capture';
+  captureStatus: CaptureStatus;
+  stream: CameraStream | undefined;
+  detectionStatus: DetectionStatus;
+  debugFrame: ImageData | undefined;
+  attemptsRemaining: number;
+  uploadError: IdErrorCode | undefined;
+  currentMode: IdCaptureMode;
+  counterValue: number;
+  orientation: DetectionOrientation | undefined;
+  idType: string | undefined;
+  previewImageUrl?: string;
+  uploadProgress?: number;
+  ageAssurance: boolean;
+  uploadErrorMessage?: string;
+  uploadErrorDescription?: string;
+  /** Whether back capture is needed after front capture completes */
+  needsBackCapture: boolean;
+  /** Whether front capture is needed after back capture (usSmartCapture + forceFrontIdCapture) */
+  needsFrontCapture: boolean;
+  showCaptureButtonInAuto: boolean;
+  /** Whether retry is available (attemptsRemaining > 0) */
+  canRetry: boolean;
+};
+type IdCaptureMandatoryConsentState = {
+  status: 'mandatoryConsent';
+  regulationType: RegulationTypes;
+};
+type IdCaptureFrontFinishedState = {
+  status: 'frontFinished';
+};
+type IdCaptureBackFinishedState = {
+  status: 'backFinished';
+};
+type IdCaptureProcessingState = {
+  status: 'processing';
+};
+type IdCaptureExpiredState = {
+  status: 'expired';
+  /**
+   * Remaining attempts after this expired result. Mirrors V1's
+   * `idv2.capture.processing.attemptsRemainingLabel` counter and Figma's
+   * "X attempts remaining" line on `1-9-11-id-documenterror`.
+   */
+  attemptsRemaining: number;
+};
+type IdCaptureExpiredExhaustedState = {
+  status: 'expiredExhausted';
+};
+type IdCaptureFinishedState = {
+  status: 'finished';
+};
+type IdCaptureClosedState = {
+  status: 'closed';
+};
+type IdCaptureErrorState = {
+  status: 'error';
+  error: string;
+};
+type ManualUploadUploadingSide = ManualUploadSide;
+type IdCaptureManualUploadState = {
+  status: 'manualUpload';
+  phase: 'selecting' | 'uploading' | 'exhausted';
+  /** Which side is currently uploading (undefined in `selecting`/`exhausted`). */
+  uploadingSide: ManualUploadUploadingSide | undefined;
+  activeTab: ManualUploadTab;
+  showIdTab: boolean;
+  showPassportTab: boolean;
+  /** Whether the ID tab should render a back-of-ID slot. */
+  showBackSlot: boolean;
+  frontFileName: string | undefined;
+  backFileName: string | undefined;
+  passportFileName: string | undefined;
+  frontUploaded: boolean;
+  backUploaded: boolean;
+  passportUploaded: boolean;
+  canContinue: boolean;
+  retriesLeft: number;
+  /** i18n key for the current error message, if any. */
+  errorKey: string | null;
+};
+type IdCaptureDigitalUploadState = {
+  status: 'digitalIdUpload';
+  phase: 'tutorial' | 'selecting' | 'reviewing' | 'uploading' | 'holding' | 'success' | 'error' | 'fileTooLarge' | 'exhausted';
+  file: File | null;
+  fileName: string | undefined;
+  failReason: DigitalUploadFailReason | null;
+  attemptsRemaining: number;
+  uploadProgress: number;
+  pickerRequestId: number;
+};
+type IdCaptureState = IdCaptureIdleState | IdCaptureChooserState | IdCaptureLoadingState | IdCaptureTutorialState | IdCaptureAgeVerificationState | IdCapturePermissionsState | IdCaptureCaptureState | IdCaptureMandatoryConsentState | IdCaptureFrontFinishedState | IdCaptureBackFinishedState | IdCaptureProcessingState | IdCaptureExpiredState | IdCaptureExpiredExhaustedState | IdCaptureFinishedState | IdCaptureClosedState | IdCaptureErrorState | IdCaptureManualUploadState | IdCaptureDigitalUploadState;
+/**
+ * Union of all `idCaptureMachine` variants' actor types. Variants share the
+ * same state tree and context shape, so the manager helpers
+ * (`mapState`, `createApi`) work uniformly for either flavor at runtime.
+ */
+type AnyIdCaptureActor = IdCaptureActor | IdCaptureOnlyActor;
+/**
+ * Builds the public ID capture manager from an already-created actor.
+ * Used by both `createIdCaptureManager` and `createIdCaptureOnlyManager`.
+ *
+ * The internal cast to `IdCaptureActor` narrows the union for `createManager`,
+ * which is typed against the regular machine. Variants produced via
+ * `idCaptureMachine.provide({...})` share the same context and event types,
+ * so the cast is sound at runtime — only the actor implementation differs.
+ */
+declare function createIdCaptureManagerFromActor(actor: AnyIdCaptureActor): Manager<IdCaptureState> & {
+  load(): void;
+  selectDocument(documentType: IdDocumentType): void;
+  nextStep(): void;
+  requestPermission(): void;
+  goToLearnMore(): void;
+  back(): void;
+  close(): void;
+  reset(): void;
+  retryCapture(): void;
+  continueExhausted(): void;
+  continueFromError(): void;
+  capture(): void;
+  switchToManualCapture(): void;
+  continueToBack(): void;
+  continueToFront(): void;
+  skipBack(): void;
+  acceptMandatoryConsent(): void;
+  cancelMandatoryConsent(): void;
+  /**
+   * Updates the detection area used for WASM geometry calculation.
+   * Call this when the UI detection area dimensions change (e.g., on resize or orientation change).
+   */
+  updateDetectionArea(detectionArea: DetectionArea): void;
+  /**
+   * Manual upload: tab change (ID / Passport). Resets per-tab file selections.
+   * Note: there is intentionally no `switchToManualUpload` method — entry to
+   * the manual-upload flow is gated by config + Chooser to prevent a
+   * dev-console bypass of live camera capture.
+   */
+  manualUploadChangeTab(tab: ManualUploadTab): void;
+  manualUploadSelectFile(side: ManualUploadSide, file: File): void;
+  manualUploadContinue(): void;
+  manualUploadReset(): void;
+  digitalUploadNextStep(): void;
+  digitalUploadPickFile(file: File): void;
+  digitalUploadConfirm(): void;
+  digitalUploadReplace(): void;
+  digitalUploadRetry(): void;
+  digitalUploadScanInstead(): void;
+  digitalUploadChooseAnother(): void;
+};
+type IdCaptureManager = ReturnType<typeof createIdCaptureManagerFromActor>;
+//#endregion
+//#region src/modules/id/idCaptureManager.d.ts
+/**
+ * Creates a manager for the regular ID capture flow. The shared
+ * `mapState`/`createApi`/state-types live in
+ * `internal/idCapture/idCaptureManagerFactory.ts`; this file is a thin
+ * wrapper that creates the actor and delegates to the factory.
+ *
+ * For the captureOnly flow (rich payload delivered locally via `onCapture`),
+ * use `createIdCaptureOnlyManager`.
+ */
+declare function createIdCaptureManager(options: CreateIdCaptureActorOptions): Manager<IdCaptureState> & {
+  load(): void;
+  selectDocument(documentType: IdDocumentType): void;
+  nextStep(): void;
+  requestPermission(): void;
+  goToLearnMore(): void;
+  back(): void;
+  close(): void;
+  reset(): void;
+  retryCapture(): void;
+  continueExhausted(): void;
+  continueFromError(): void;
+  capture(): void;
+  switchToManualCapture(): void;
+  continueToBack(): void;
+  continueToFront(): void;
+  skipBack(): void;
+  acceptMandatoryConsent(): void;
+  cancelMandatoryConsent(): void;
+  updateDetectionArea(detectionArea: DetectionArea): void;
+  manualUploadChangeTab(tab: ManualUploadTab): void;
+  manualUploadSelectFile(side: ManualUploadSide, file: File): void;
+  manualUploadContinue(): void;
+  manualUploadReset(): void;
+  digitalUploadNextStep(): void;
+  digitalUploadPickFile(file: File): void;
+  digitalUploadConfirm(): void;
+  digitalUploadReplace(): void;
+  digitalUploadRetry(): void;
+  digitalUploadScanInstead(): void;
+  digitalUploadChooseAnother(): void;
+};
+//#endregion
+export { MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES as $, CaptureIdResponse as A, IdCaptureGeometry as B, IdCaptureOnlyMachine as C, createIdCaptureActor as D, IdCaptureActor as E, ID_ERROR_CODES as F, IdCapturedImageData as G, IdCaptureMode as H, IdCaptureConfig as I, IdErrorCode as J, IdDocumentType as K, IdCaptureContext as L, CapturedImage as M, DetectionArea as N, IdCaptureMachine as O, DetectionStatus as P, MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS as Q, IdCaptureDependencies as R, createIdCaptureOnlyActor as S, CreateIdCaptureActorOptions as T, IdCaptureOnlyConfig as U, IdCaptureInput as V, IdCaptureThresholds as W, RecordingSession as X, IdFlowStep as Y, UploadIdResponse as Z, uploadIdImage as _, IdCaptureInitResult as a, IdCaptureSettings as at, CreateIdCaptureOnlyActorOptions as b, UploadIdImageParams as c, initializeIdCapture as d, MANUAL_UPLOAD_MAX_RETRIES as et, preloadIdRecordingProvider as f, stopStream as g, stopRecording as h, createIdCaptureManagerFromActor as i, DetectionOrientation as it, CaptureOnlyResponse as j, idCaptureMachine as k, UploadManualIdFileParams as l, startRecordingSession as m, IdCaptureManager as n, ManualUploadSide as nt, InitializeIdCaptureParams as o, processId as p, IdError as q, IdCaptureState as r, ManualUploadTab as rt, StartRecordingParams as s, createIdCaptureManager as t, ManualUploadContext as tt, ValidationError as u, uploadManualIdFile as v, idCaptureOnlyMachine as w, IdCaptureOnlyActor as x, validateUploadResponse as y, IdCaptureEvent as z };