@incodetech/core 0.0.0-dev-20260207-ef0d08c → 0.0.0-dev-20260209-c0e857b

package/dist/faceCaptureManagerFactory-CZgmP4pc.d.ts

@@ -0,0 +1,227 @@
+import { a as IRecordingCapability, c as MLProviderConfig, i as IStorageCapability, n as PermissionStatus, r as CameraStream } from "./types-u31qr1MR.js";
+import { s as WasmPipeline, t as Flow } from "./types-Dc1nBvy2.js";
+import { t as Manager } from "./Manager-BiAYYF50.js";
+
+//#region ../infra/src/capabilities/IWasmUtilCapability.d.ts
+type WasmUtilConfig = MLProviderConfig & {
+  pipelines?: WasmPipeline[];
+};
+type VirtualCameraCheckOutput = {
+  canvas: HTMLCanvasElement | null;
+  itr: boolean | null;
+  skipped: boolean | null;
+};
+type IWasmUtilCapability = {
+  /**
+   * Whether the provider has been initialized and is ready to be used.
+   */
+  readonly initialized: boolean;
+  /**
+   * Initializes the provider with the given configuration.
+   * If WASM was already warmed up via `warmupWasm()`, this returns almost instantly.
+   * @param config - Provider configuration including WASM paths
+   */
+  initialize(config: WasmUtilConfig): Promise<void>;
+  /**
+   * Encrypts a base64 image using the WASM utility API.
+   * @param image - Base64 image string (no data URL prefix)
+   * @returns Encrypted string
+   */
+  encryptImage(image: string): string;
+  setSdkVersion(version: string): void;
+  setSdkPlatform(platform: string): void;
+  setDeviceInfo(deviceInfo: object, overrideExisting?: boolean): void;
+  setBrowserInfo(browserInfo: object, overrideExisting?: boolean): void;
+  setCameraInfo(cameraInfo: object, overrideExisting?: boolean): void;
+  setMotionStatus(status: string): void;
+  setBackgroundMode(backgroundMode: boolean): void;
+  setZc(zc: string): void;
+  setInspectorOpened(opened: boolean): void;
+  getMetadata(): string;
+  analyzeFrame(image: ImageData): Promise<void>;
+  getCheck(): string;
+  /**
+   * Gets the current pipeline state. Must be called before setMotionStatus(),
+   * getCheck(), setBackgroundMode(), and getMetadata() for proper metadata generation.
+   */
+  getPipelineState(): string;
+  estimatePerformance(): string;
+  isVirtualCamera(label: string | null): boolean;
+  prc(): Promise<void>;
+  poc(output: VirtualCameraCheckOutput): Promise<void>;
+  ckvcks(data: ArrayBuffer): void;
+  getVersions(): Promise<unknown>;
+  /**
+   * Disposes of resources and resets initialization state.
+   */
+  dispose(): Promise<void>;
+};
+//#endregion
+//#region src/internal/faceCapture/types.d.ts
+type BaseFaceCaptureConfig = {
+  showTutorial: boolean;
+  showPreview?: boolean;
+  assistedOnboarding?: boolean;
+  enableFaceRecording?: boolean;
+  autoCaptureTimeout: number;
+  captureAttempts?: number;
+  numberOfAttempts?: number;
+  validateLenses?: boolean;
+  validateFaceMask?: boolean;
+  validateHeadCover?: boolean;
+  validateClosedEyes?: boolean;
+  validateBrightness?: boolean;
+  deepsightLiveness?: 'SINGLE_FRAME' | 'MULTIMODAL' | 'VIDEOLIVENESS';
+  recording?: {
+    capability?: IRecordingCapability;
+  };
+  ds?: Flow['ds'];
+};
+type FaceCaptureDependencies = {
+  storage: IStorageCapability;
+  getWasmUtil: () => Promise<IWasmUtilCapability>;
+};
+type DetectionStatus = 'idle' | 'detecting' | 'noFace' | 'tooManyFaces' | 'tooClose' | 'tooFar' | 'blur' | 'dark' | 'faceAngle' | 'headWear' | 'lenses' | 'eyesClosed' | 'faceMask' | 'centerFace' | 'manualCapture' | 'success' | 'error' | 'capturing' | 'getReady' | 'getReadyFinished' | 'offline';
+declare const FACE_ERROR_CODES: {
+  readonly FACE_OCCLUDED: "FACE_OCCLUDED";
+  readonly LIVENESS: "LIVENESS_ERROR";
+  readonly BRIGHTNESS: "BRIGHTNESS_ERROR";
+  readonly LENSES: "LENSES_ERROR";
+  readonly MASK: "MASK_ERROR";
+  readonly CLOSED_EYES: "CLOSED_EYES_ERROR";
+  readonly HEAD_COVER: "HEAD_COVER_ERROR";
+  readonly SERVER: "SERVER_ERROR";
+  readonly FACE_NOT_FOUND: "FACE_NOT_FOUND";
+  readonly MULTIPLE_FACES: "MULTIPLE_FACES";
+  readonly TOO_BLURRY: "TOO_BLURRY_ERROR";
+  readonly TOO_DARK: "TOO_DARK_ERROR";
+  readonly USER_IS_NOT_RECOGNIZED: "USER_IS_NOT_RECOGNIZED";
+  readonly SPOOF_ATTEMPT_DETECTED: "SPOOF_ATTEMPT_DETECTED";
+  readonly FACE_TOO_DARK: "FACE_TOO_DARK";
+  readonly LENSES_DETECTED: "LENSES_DETECTED";
+  readonly FACE_MASK_DETECTED: "FACE_MASK_DETECTED";
+  readonly CLOSED_EYES_DETECTED: "CLOSED_EYES_DETECTED";
+  readonly HEAD_COVER_DETECTED: "HEAD_COVER_DETECTED";
+  readonly FACE_CROPPING_FAILED: "FACE_CROPPING_FAILED";
+  readonly FACE_TOO_SMALL: "FACE_TOO_SMALL";
+  readonly FACE_TOO_BLURRY: "FACE_TOO_BLURRY";
+  readonly BAD_PHOTO_QUALITY: "BAD_PHOTO_QUALITY";
+  readonly PROCESSING_ERROR: "PROCESSING_ERROR";
+  readonly BAD_REQUEST: "BAD_REQUEST";
+  readonly NONEXISTENT_CUSTOMER: "NONEXISTENT_CUSTOMER";
+  readonly HINT_NOT_PROVIDED: "HINT_NOT_PROVIDED";
+  readonly SELFIE_IMAGE_LOW_QUALITY: "SELFIE_IMAGE_LOW_QUALITY";
+};
+type FaceErrorCode = (typeof FACE_ERROR_CODES)[keyof typeof FACE_ERROR_CODES];
+//#endregion
+//#region src/internal/faceCapture/faceCaptureManagerFactory.d.ts
+type CaptureStatus = 'initializing' | 'detecting' | 'capturing' | 'uploading' | 'uploadError' | 'success';
+/** Face capture manager is waiting to be started */
+type FaceCaptureIdleState = {
+  status: 'idle';
+};
+/** Checking camera permissions (when no tutorial) */
+type FaceCaptureLoadingState = {
+  status: 'loading';
+};
+/** Showing face capture tutorial */
+type FaceCaptureTutorialState = {
+  status: 'tutorial';
+};
+/** Handling camera permissions */
+type FaceCapturePermissionsState = {
+  status: 'permissions';
+  /** Current permission sub-state: initial, requesting, denied, or learnMore */
+  permissionStatus: PermissionStatus;
+};
+/** Camera is ready for face capture */
+type FaceCaptureCaptureState = {
+  status: 'capture';
+  /** Current capture sub-state */
+  captureStatus: CaptureStatus;
+  /** The active camera stream */
+  stream: CameraStream | undefined;
+  /** Current face detection status */
+  detectionStatus: DetectionStatus;
+  /** Latest frame processed in the detection loop (for UI debug rendering) */
+  debugFrame: ImageData | undefined;
+  /** Number of capture attempts remaining */
+  attemptsRemaining: number;
+  /** Error message from failed upload */
+  uploadError: string | undefined;
+};
+/** Processing the captured face */
+type FaceCaptureProcessingState = {
+  status: 'processing';
+};
+/** Face capture completed successfully */
+type FaceCaptureFinishedState = {
+  status: 'finished';
+  /** Face processing result (face match, confidence, existing user) */
+  processResponse: Record<string, unknown> | undefined;
+};
+/** User closed the face capture flow */
+type FaceCaptureClosedState = {
+  status: 'closed';
+};
+/** An error occurred during the flow */
+type FaceCaptureErrorState = {
+  status: 'error';
+  /** The error message */
+  error: string;
+};
+/** Union of all possible face capture states */
+type FaceCaptureManagerState = FaceCaptureIdleState | FaceCaptureLoadingState | FaceCaptureTutorialState | FaceCapturePermissionsState | FaceCaptureCaptureState | FaceCaptureProcessingState | FaceCaptureFinishedState | FaceCaptureClosedState | FaceCaptureErrorState;
+declare function createFaceCaptureManager(actor: unknown): Manager<FaceCaptureManagerState> & {
+  /**
+   * Starts the face capture flow.
+   * Goes to `tutorial` if showTutorial is true, otherwise to `loading`.
+   * Requires setup() to have been called with a token first.
+   */
+  load(): void;
+  /**
+   * Advances to the next step.
+   * From `tutorial` → permissions or capture (based on permission status).
+   * From `capture` → finished.
+   */
+  nextStep(): void;
+  /**
+   * Requests camera permission via getUserMedia.
+   * Only effective when in `permissions.idle` or `permissions.learnMore` state.
+   */
+  requestPermission(): void;
+  /**
+   * Navigates to the "learn more" permission screen.
+   * Only effective when in `permissions.idle` state.
+   */
+  goToLearnMore(): void;
+  /**
+   * Goes back from "learn more" to the initial permission screen.
+   * Only effective when in `permissions.learnMore` state.
+   */
+  back(): void;
+  /**
+   * Closes the face capture flow and transitions to `closed` state.
+   * Can be called from any state.
+   */
+  close(): void;
+  /**
+   * Resets the face capture manager to its initial `idle` state.
+   * Can be called from `error` state. Not available from `finished` (final state).
+   */
+  reset(): void;
+  /**
+   * Retries the capture after an upload error.
+   * Only effective when in `capture.uploadError` state and `attemptsRemaining > 0`.
+   * If no attempts remaining, the transition is blocked.
+   */
+  retryCapture(): void;
+  /**
+   * Captures a face in manual capture mode.
+   * Only effective when in `capture.detecting` state and `detectionStatus === 'manualCapture'`.
+   */
+  capture(): void;
+};
+type FaceCaptureManager = ReturnType<typeof createFaceCaptureManager>;
+//#endregion
+export { FaceCaptureDependencies as a, DetectionStatus as i, FaceCaptureManagerState as n, FaceErrorCode as o, BaseFaceCaptureConfig as r, FaceCaptureManager as t };