@incodetech/core 0.0.0-dev-20260126-4504c5b

package/dist/id.d.ts

@@ -0,0 +1,5 @@
+import { a as CameraStream, n as PermissionStatus, t as PermissionResult } from "./types-CRVSv38Q.js";
+import { A as IdCaptureMode, B as IIdCaptureCapability, C as CaptureIdResponse, D as ID_ERROR_CODES, E as DetectionStatus, F as IdFlowStep, I as RecordingSession, L as UploadIdResponse, M as IdDocumentType, N as IdError, O as IdCaptureConfig, P as IdErrorCode, R as IdCaptureProvider, S as validateUploadResponse, T as DetectionArea, V as IdCaptureSettings, _ as processId, a as IdCaptureActor, b as stopStream, c as IdCaptureEvent, d as idCaptureMachine, f as IdCaptureInitResult, g as initializeIdCapture, h as ValidationError, i as CreateIdCaptureActorOptions, j as IdCaptureThresholds, k as IdCaptureGeometry, l as IdCaptureInput, m as UploadIdImageParams, n as IdCaptureState, o as createIdCaptureActor, p as StartRecordingParams, r as createIdCaptureManager, s as IdCaptureContext, t as IdCaptureManager, u as IdCaptureMachine, v as startRecordingSession, w as CapturedImage, x as uploadIdImage, y as stopRecording, z as DetectionOrientation } from "./index-CJMK8K5u.js";
+import "./types-CMR6NkxW.js";
+import "./Manager-Co-PsiG9.js";
+export { CameraStream, CaptureIdResponse, CapturedImage, CreateIdCaptureActorOptions, DetectionArea, DetectionOrientation, DetectionStatus, ID_ERROR_CODES, IIdCaptureCapability, IdCaptureActor, IdCaptureConfig, IdCaptureContext, IdCaptureEvent, IdCaptureGeometry, IdCaptureInitResult, IdCaptureInput, IdCaptureMachine, IdCaptureManager, IdCaptureMode, IdCaptureProvider, IdCaptureSettings, IdCaptureState, IdCaptureThresholds, IdDocumentType, IdError, IdErrorCode, IdFlowStep, PermissionResult, PermissionStatus, RecordingSession, StartRecordingParams, UploadIdImageParams, UploadIdResponse, ValidationError, createIdCaptureActor, createIdCaptureManager, idCaptureMachine, initializeIdCapture, processId, startRecordingSession, stopRecording, stopStream, uploadIdImage, validateUploadResponse };

package/dist/id.esm.js

@@ -0,0 +1,9 @@
+import "./events-B8ZkhAZo.esm.js";
+import { a as processId, c as stopStream, d as ID_ERROR_CODES, i as initializeIdCapture, l as uploadIdImage, n as createIdCaptureActor, o as startRecordingSession, r as idCaptureMachine, s as stopRecording, t as createIdCaptureManager, u as validateUploadResponse } from "./id-r1mw9zBM.esm.js";
+import { i as IdCaptureProvider } from "./src-DYtpbFY5.esm.js";
+import "./getDeviceClass-DkfbtsIJ.esm.js";
+import "./endpoints-BUsSVoJV.esm.js";
+import "./streamingEvents-CfEJv3xH.esm.js";
+import "./api-DfRLAneb.esm.js";
+
+export { ID_ERROR_CODES, IdCaptureProvider, createIdCaptureActor, createIdCaptureManager, idCaptureMachine, initializeIdCapture, processId, startRecordingSession, stopRecording, stopStream, uploadIdImage, validateUploadResponse };

package/dist/index-CJMK8K5u.d.ts

@@ -0,0 +1,614 @@
+import { a as CameraStream, c as IMotionSensorCapability, d as IMLProviderCapability, f as MLProviderConfig, i as StreamCanvasCapture, n as PermissionStatus, o as IRecordingCapability, p as IncodeCanvas, r as BaseWasmProvider, s as RecordingConnection, t as PermissionResult } from "./types-CRVSv38Q.js";
+import { a as AnyStateMachine, i as TutorialIdConfig, o as StateMachine } from "./types-CMR6NkxW.js";
+import { t as Manager } from "./Manager-Co-PsiG9.js";
+import { ActorRefFrom } from "xstate";
+
+//#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;
+  minFaceIdQualityScore: 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;
+}
+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 ../infra/src/providers/wasm/IdCaptureProvider.d.ts
+declare class IdCaptureProvider extends BaseWasmProvider implements IIdCaptureCapability {
+  private lastProcessResult;
+  private capturedCanvas;
+  private originalCapturedCanvas;
+  constructor();
+  initialize(config: IdCaptureConfig$1): Promise<void>;
+  setCallbacks(callbacks: IdCaptureCallbacks): void;
+  setThresholds(thresholds: IdCaptureThresholds$1): void;
+  setGeometry(geometry: IdCaptureGeometry$1): void;
+  setSettings(settings: IdCaptureSettings): void;
+  setModelType(modelType: 'v1' | 'v2' | 'v3'): void;
+  /**
+   * Processes a frame through the WASM pipeline and stores the result.
+   */
+  processFrame(image: ImageData): Promise<void>;
+  /**
+   * Gets the last process result from the most recent frame processing.
+   * @returns The last process result with quad coordinates, or null if not available
+   */
+  getLastProcessResult(): IdCaptureProcessResult | null;
+  transformPerspective(canvas: IncodeCanvas, frameRect: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+  }): IncodeCanvas;
+  /**
+   * Crops a canvas to the specified rectangle region.
+   * @param canvas - The canvas to crop
+   * @param rect - The rectangle to crop to (x, y, w, h)
+   * @returns A new IncodeCanvas with the cropped region, or null if cropping fails
+   */
+  private cropCanvasToRect;
+  /**
+   * 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).
+   * @param original - The original full-frame canvas (for upload)
+   * @param transformed - The transformed canvas (for preview)
+   */
+  setCapturedCanvases(original: IncodeCanvas, transformed: IncodeCanvas): void;
+  reset(): void;
+}
+//#endregion
+//#region src/modules/id/types.d.ts
+type IdCaptureMode = 'front' | 'back' | 'passport';
+type IdDocumentType = 'id' | 'passport';
+type IdFlowStep = 'chooser' | 'tutorial' | 'permissions' | 'capture' | 'frontFinished' | '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;
+  minFaceIdQualityScore: 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';
+};
+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;
+  failReason?: string;
+  side?: 'front' | 'back';
+};
+type CaptureIdResponse = UploadIdResponse & {
+  croppedIDFace?: string;
+  croppedFrontID?: string;
+  croppedBackID?: string;
+  originalImage?: string;
+  frontIdImage?: string;
+  backIdImage?: string;
+};
+type CapturedImage = {
+  imageBase64: string;
+};
+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";
+};
+//#endregion
+//#region src/modules/id/idCaptureServices.d.ts
+type IdCaptureInitResult = {
+  stream: CameraStream;
+  provider: IIdCaptureCapability;
+};
+declare function initializeIdCapture(provider: IIdCaptureCapability, config: IdCaptureConfig): 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;
+};
+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 startRecordingSession(params: StartRecordingParams): Promise<RecordingSession | undefined>;
+declare function stopRecording(session: RecordingSession): void;
+declare function processId(isSecondId?: boolean, queueName?: string, signal?: AbortSignal): Promise<{
+  isDocumentExpired: boolean;
+}>;
+//#endregion
+//#region src/modules/id/idCaptureStateMachine.d.ts
+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;
+  };
+  uploadResponse: CaptureIdResponse | undefined;
+  recordingSession: RecordingSession | undefined;
+  attemptsRemaining: number;
+  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;
+  /** Detection area from UI for WASM geometry calculation */
+  detectionArea: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  } | undefined;
+  previewImageUrl?: string;
+  uploadProgress?: number;
+  motionStatus?: 'PASS' | 'FAIL' | 'UNCLEAR';
+  manualCaptureTriggered: boolean;
+};
+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_FROM_ERROR';
+} | {
+  type: 'FRONT_COMPLETE';
+} | {
+  type: 'CONTINUE_TO_BACK';
+} | {
+  type: 'PROCESS_COMPLETE';
+} | {
+  type: 'PROCESS_EXPIRED';
+} | {
+  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 IdCaptureInput = {
+  config: IdCaptureConfig;
+  provider: IIdCaptureCapability;
+  motionProvider?: IMotionSensorCapability;
+};
+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;
+  provider: IIdCaptureCapability;
+};
+type IdCaptureActor = ActorRefFrom<IdCaptureMachine>;
+declare function createIdCaptureActor(options: CreateIdCaptureActorOptions): IdCaptureActor;
+//#endregion
+//#region src/modules/id/idCaptureManager.d.ts
+type CaptureStatus = 'initializing' | 'detecting' | 'capturing' | 'uploading' | 'uploadError' | 'success';
+type IdCaptureIdleState = {
+  status: 'idle';
+};
+type IdCaptureChooserState = {
+  status: 'chooser';
+};
+type IdCaptureLoadingState = {
+  status: 'loading';
+};
+type IdCaptureTutorialState = {
+  status: 'tutorial';
+  selectedDocumentType: IdDocumentType | undefined;
+};
+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;
+  uploadErrorMessage?: string;
+  uploadErrorDescription?: string;
+  /** Whether back capture is needed after front capture completes */
+  needsBackCapture: boolean;
+  showCaptureButtonInAuto: boolean;
+  /** Whether retry is available (attemptsRemaining > 0) */
+  canRetry: boolean;
+};
+type IdCaptureFrontFinishedState = {
+  status: 'frontFinished';
+};
+type IdCaptureProcessingState = {
+  status: 'processing';
+};
+type IdCaptureExpiredState = {
+  status: 'expired';
+};
+type IdCaptureFinishedState = {
+  status: 'finished';
+};
+type IdCaptureClosedState = {
+  status: 'closed';
+};
+type IdCaptureErrorState = {
+  status: 'error';
+  error: string;
+};
+type IdCaptureState = IdCaptureIdleState | IdCaptureChooserState | IdCaptureLoadingState | IdCaptureTutorialState | IdCapturePermissionsState | IdCaptureCaptureState | IdCaptureFrontFinishedState | IdCaptureProcessingState | IdCaptureExpiredState | IdCaptureFinishedState | IdCaptureClosedState | IdCaptureErrorState;
+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;
+  continueFromError(): void;
+  capture(): void;
+  switchToManualCapture(): void;
+  continueToBack(): void;
+  skipBack(): 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).
+   * @param detectionArea - The detection area in canvas coordinates
+   */
+  updateDetectionArea(detectionArea: DetectionArea): void;
+};
+type IdCaptureManager = ReturnType<typeof createIdCaptureManager>;
+//#endregion
+export { IdCaptureMode as A, IIdCaptureCapability as B, CaptureIdResponse as C, ID_ERROR_CODES as D, DetectionStatus as E, IdFlowStep as F, RecordingSession as I, UploadIdResponse as L, IdDocumentType as M, IdError as N, IdCaptureConfig as O, IdErrorCode as P, IdCaptureProvider as R, validateUploadResponse as S, DetectionArea as T, IdCaptureSettings as V, processId as _, IdCaptureActor as a, stopStream as b, IdCaptureEvent as c, idCaptureMachine as d, IdCaptureInitResult as f, initializeIdCapture as g, ValidationError as h, CreateIdCaptureActorOptions as i, IdCaptureThresholds as j, IdCaptureGeometry as k, IdCaptureInput as l, UploadIdImageParams as m, IdCaptureState as n, createIdCaptureActor as o, StartRecordingParams as p, createIdCaptureManager as r, IdCaptureContext as s, IdCaptureManager as t, IdCaptureMachine as u, startRecordingSession as v, CapturedImage as w, uploadIdImage as x, stopRecording as y, DetectionOrientation as z };