@incodetech/core 2.0.0-alpha.9 → 2.0.0-rc.0

package/dist/faceCaptureManagerFactory-yqtpxjnN.d.ts

@@ -0,0 +1,690 @@
+import { n as WasmPipeline } from "./warmup-CEcppFiS.js";
+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 { i as FlowModuleConfig, n as Flow } from "./types-BP1m8VRw.js";
+import { a as IWasmUtilCapability, c as IMLProviderCapability, d as IRecordingCapability, i as IncodeCanvas, l as MLProviderConfig, 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 src/modules/authentication/authenticationStateMachine.d.ts
+declare const _authenticationMachine: AnyStateMachine;
+type AuthenticationMachine = typeof _authenticationMachine;
+declare const authenticationMachine: AnyStateMachine;
+//#endregion
+//#region src/internal/faceCapture/types.d.ts
+type CameraResolution = {
+  width?: number;
+  height?: number;
+};
+/**
+ * Rich captured face payload delivered via `onCapture` in the selfie
+ * captureOnly flow.
+ */
+type FaceCapturedImageData = {
+  imageBase64: string;
+  blob: Blob;
+  url: string;
+  metadata: string;
+  /**
+   * Populated when local video recording is active
+   * (`enableFaceRecording === true` with `LocalRecordingService`).
+   * `undefined` when video recording is disabled, when the provider is
+   * OpenVidu (remote server-side recording), or when video assembly fails.
+   *
+   * Delivered as raw base64 (not encrypted via WASM `ens()` like the regular
+   * flow). Integrators receiving this are responsible for handling it as
+   * sensitive biometric data.
+   */
+  videoBase64: string | undefined;
+};
+/**
+ * Payload delivered to `SelfieCaptureOnlyConfig.onCapture`.
+ */
+type FaceCaptureOnlyResponse = {
+  image: FaceCapturedImageData;
+};
+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';
+  cameraResolution?: CameraResolution;
+  ageAssurance?: boolean;
+  recording?: {
+    capability?: IRecordingCapability;
+  };
+  ds?: Flow['ds'];
+  /**
+   * When true, face analysis runs on-device via the OnDevice WASM workflow
+   * (6 models) and only the results JSON is submitted to the backend
+   * (`/omni/add/face-results`). Recording is skipped entirely. Used by both
+   * SELFIE and AUTHENTICATION modules.
+   */
+  onDeviceFaceResultsSubmissionEnabled?: boolean;
+};
+type FaceCaptureDependencies = {
+  storage: IStorageCapability;
+  getWasmUtil: () => Promise<IWasmUtilCapability>;
+  trackCaptureAttemptFinished?: (payload: {
+    logs: string;
+  }) => void;
+};
+type DetectionStatus = 'idle' | 'detecting' | 'noFace' | 'tooManyFaces' | 'tooClose' | 'tooFar' | 'blur' | 'dark' | 'tooBright' | 'faceAngle' | 'lookAtCamera' | 'headWear' | 'lenses' | 'eyesClosed' | 'faceMask' | 'faceOcclusion' | 'centerFace' | 'moveLeft' | 'moveRight' | '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/modules/authentication/types.d.ts
+type AuthenticationConfig = FlowModuleConfig['AUTHENTICATION'] & BaseFaceCaptureConfig;
+//#endregion
+//#region src/modules/authentication/authenticationActor.d.ts
+type CreateAuthenticationActorOptions = {
+  config: AuthenticationConfig;
+  dependencies?: FaceCaptureDependencies;
+  authHint?: string;
+};
+type AuthenticationActor = ActorRefFrom<AuthenticationMachine>;
+declare function createAuthenticationActor(options: CreateAuthenticationActorOptions): AuthenticationActor;
+//#endregion
+//#region ../infra/src/wasm/wasmWebClient.d.ts
+
+/**
+ * Configuration shape that the C++ `WebApi` passes when calling `.post(...)`
+ * on its host JS adapter. Mirrors the upstream `ml-wasm-kit/WebClient`
+ * `RequestConfig` for the subset of fields actually set by `WebApi`.
+ */
+type WebApiHostRequestConfig = {
+  ie?: boolean;
+  headers?: Record<string, string>;
+  params?: Record<string, string | number | boolean | undefined>;
+  timeout?: number;
+};
+//#endregion
+//#region ../infra/src/capabilities/IFaceDetectionCapability.d.ts
+/**
+ * Configuration for face detection provider.
+ * Extends base ML provider config with face-detection specific options.
+ */
+interface FaceDetectionConfig extends MLProviderConfig {
+  autocaptureInterval?: number;
+  /**
+   * Load the on-device selfie workflow (6 models including liveness + age
+   * estimation) instead of the default selfie workflow (4 models). Required
+   * when SELFIE/AUTHENTICATION has `onDeviceFaceResultsSubmissionEnabled`.
+   */
+  useOnDeviceWorkflow?: boolean;
+}
+interface FacePositionConstraints {
+  minX: number;
+  minY: number;
+  maxX: number;
+  maxY: number;
+}
+interface FaceDetectionThresholds {
+  brightnessThreshold: number;
+  blurrinessThreshold: number;
+  tiltRotationAngleThreshold: number;
+  minMagicCropSize: number;
+  autocaptureInterval: number;
+  minFaceQualityScore: number;
+  faceOcclusionThreshold: number;
+  /**
+   * Milliseconds the C++ workflow waits after `onGetReady` fires before
+   * triggering autocapture. Mirrors V1's `getReadyDelay` (2000 ms) — without
+   * it, autocapture can fire on the first quality-passing frame, before the
+   * front camera has finished locking focus, producing blurry captures that
+   * the on-device quality model rejects.
+   */
+  getReadyDelay: number;
+  /**
+   * Milliseconds over which face-detection results are aggregated before the
+   * autocapture decision. Mirrors V1's `framesAggregationInterval` (2000 ms).
+   */
+  framesAggregationInterval: number;
+  /**
+   * Minimum consecutive frames with a detected face required before
+   * autocapture can trigger. Mirrors V1's `minFramesWithFace` (3).
+   */
+  minFramesWithFace: number;
+}
+interface FaceAttributesThresholds {
+  headwearThreshold: number;
+  lensesThreshold: number;
+  closedEyesThreshold: number;
+  maskThreshold: number;
+}
+interface FaceChecksConfig {
+  lenses: boolean;
+  mask: boolean;
+  closedEyes: boolean;
+  headWear: boolean;
+  occlusion: boolean;
+}
+type FaceCoordinates = {
+  rightEyeX: number;
+  rightEyeY: number;
+  leftEyeX: number;
+  leftEyeY: number;
+  noseTipX: number;
+  noseTipY: number;
+  rightMouthX: number;
+  rightMouthY: number;
+  mouthX: number;
+  mouthY: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+interface FaceDetectionCallbacks {
+  onFarAway?: () => void;
+  onTooClose?: () => void;
+  onTooManyFaces?: () => void;
+  onNoFace?: () => void;
+  onCapture?: (canvas: IncodeCanvas, faceCoordinates: FaceCoordinates) => void;
+  onGetReady?: () => void;
+  onGetReadyFinished?: () => void;
+  onCenterFace?: () => void;
+  onDark?: () => void;
+  onBlur?: () => void;
+  onFaceAngle?: () => void;
+  onLenses?: () => void;
+  onMask?: () => void;
+  onEyesClosed?: () => void;
+  onHeadWear?: () => void;
+  onSwitchToManualCapture?: () => void;
+  onFaceOccluded?: () => void;
+}
+/**
+ * Capability interface for face detection and selfie capture.
+ * Extends the base ML provider capability with face-detection specific methods.
+ */
+interface IFaceDetectionCapability extends IMLProviderCapability<FaceDetectionConfig> {
+  /**
+   * Sets callbacks for face detection events.
+   * @param callbacks - Object containing callback functions for various detection events
+   */
+  setCallbacks(callbacks: FaceDetectionCallbacks): void;
+  /**
+   * Sets position constraints for face detection.
+   * @param constraints - Bounding box constraints for valid face position
+   */
+  setPositionConstraints(constraints: FacePositionConstraints): void;
+  /**
+   * Sets detection thresholds for quality checks.
+   * @param thresholds - Threshold values for various quality metrics
+   */
+  setThresholds(thresholds: FaceDetectionThresholds): void;
+  /**
+   * Sets thresholds for face attribute detection.
+   * @param thresholds - Threshold values for attribute detection (headwear, lenses, etc.)
+   */
+  setAttributesThresholds(thresholds: FaceAttributesThresholds): void;
+  /**
+   * Enables or disables specific face checks.
+   * @param config - Configuration for which checks to enable
+   */
+  setChecksEnabled(config: FaceChecksConfig): void;
+  /**
+   * Sets video selfie mode.
+   * @param enabled - Whether to enable video selfie mode
+   */
+  setVideoSelfieMode(enabled: boolean): void;
+  /**
+   * Synchronous manual-capture entry point for the on-device selfie workflow.
+   * Runs the full on-device pipeline on a single canvas image and stages the
+   * results inside WASM for the next {@link postFaceResults} call. No-op for
+   * default (non-on-device) configurations; callers should guard with the
+   * `onDeviceFaceResultsSubmissionEnabled` flag.
+   */
+  processPhoto(canvas: HTMLCanvasElement): void;
+  /**
+   * POSTs the staged on-device face-results JSON to `/omni/add/face-results`.
+   * The C++ side encrypts the body via `SessionEncryptor` and routes through
+   * the WASM `WebClient`, so the SDK's WebClient must be initialized first
+   * (consumers calling this must configure `setup({ apiURL, wasm })`).
+   */
+  postFaceResults(config?: WebApiHostRequestConfig): Promise<unknown>;
+}
+//#endregion
+//#region ../infra/src/wasm/WasmPipelineType.d.ts
+declare enum WasmPipelineType {
+  IdBlurGlarePipeline = 0,
+  IdBarcodeAndTextQualityPipeline = 1,
+  IdVideoSelfiePipeline = 2,
+  SelfieWithAggregationMetrics = 3,
+  SelfieWithQualityMetrics = 4,
+  OnDeviceSelfieWorkflow = 5,
+}
+//#endregion
+//#region ../infra/src/providers/wasm/BaseWasmProvider.d.ts
+/**
+ * Base configuration for WASM providers
+ */
+interface BaseWasmConfig {
+  /** Path to the WASM binary */
+  wasmPath?: string;
+  /** Path to the SIMD-optimized WASM binary (optional) */
+  wasmSimdPath?: string;
+  /** Path to the WASM glue code (paired with `wasmPath`) */
+  glueCodePath?: string;
+  /**
+   * Path to the SIMD-optimized WASM glue code (paired with `wasmSimdPath`).
+   * If omitted, defaults to a sibling `.js` derived from `wasmSimdPath`.
+   */
+  glueCodeSimdPath?: string;
+  /** Whether to use SIMD optimizations (default: true) */
+  useSimd?: boolean;
+  /**
+   * Base path for ML model files. Models will be loaded from `${modelsBasePath}/${modelFileName}`.
+   * If not provided, models are expected in a 'models' subdirectory relative to the WASM binary.
+   */
+  modelsBasePath?: string;
+}
+/**
+ * Base provider class that abstracts common WASM functionality.
+ * This serves as a foundation for specific ML capability providers
+ * like FaceDetectionProvider and IdCaptureProvider.
+ */
+declare abstract class BaseWasmProvider {
+  private _isInitialized;
+  protected pipelineType: WasmPipelineType | undefined;
+  /**
+   * Creates a new BaseWasmProvider
+   * @param pipelineType - The WASM pipeline type this provider uses
+   */
+  constructor(pipelineType?: WasmPipelineType);
+  /**
+   * Returns whether this provider has been initialized.
+   */
+  get initialized(): boolean;
+  protected getPipelineType(): WasmPipelineType;
+  /**
+   * Initializes the provider by ensuring WASM is loaded
+   * @param config - Provider configuration
+   * @param pipeline - The pipeline type to warm up ('selfie', 'idCapture', etc.)
+   */
+  protected initializeBase(config: BaseWasmConfig, pipeline: WasmPipeline): Promise<void>;
+  /**
+   * Ensures the provider is initialized before performing operations.
+   * @throws Error if not initialized
+   */
+  protected ensureInitialized(): void;
+  /**
+   * Processes a frame through the WASM pipeline
+   * @param image - Image data to process
+   * @returns The pipeline result (type depends on pipeline - WASM returns any)
+   */
+  protected processFrameWasm(image: ImageData): Promise<any>;
+  abstract processFrame(image: ImageData): Promise<void>;
+  /**
+   * Resets the pipeline to its initial state.
+   * Safe to call even if not initialized (no-op in that case).
+   */
+  reset(): void;
+  /**
+   * Disposes of resources and resets initialization state.
+   * Safe to call even if not initialized.
+   */
+  dispose(): Promise<void>;
+}
+//#endregion
+//#region ../infra/src/providers/wasm/FaceDetectionProvider.d.ts
+declare class FaceDetectionProvider extends BaseWasmProvider implements IFaceDetectionCapability {
+  private defaultThresholds;
+  private currentThresholds;
+  private currentFrame;
+  constructor();
+  processFrame(image: ImageData): Promise<void>;
+  initialize(config: FaceDetectionConfig): Promise<void>;
+  processPhoto(canvas: HTMLCanvasElement): void;
+  postFaceResults(config?: WebApiHostRequestConfig): Promise<unknown>;
+  setCallbacks(callbacks: FaceDetectionCallbacks): void;
+  setPositionConstraints(constraints: FacePositionConstraints): void;
+  applyDefaults(autocaptureInterval?: number): void;
+  setAutocaptureInterval(interval: number): void;
+  setThresholds(thresholds: FaceDetectionThresholds): void;
+  setAttributesThresholds(thresholds: FaceAttributesThresholds): void;
+  setChecksEnabled(config: FaceChecksConfig): void;
+  setVideoSelfieMode(enabled: boolean): void;
+  reset(): void;
+  private createDefaultFaceCoordinates;
+  private formatFaceCoordinates;
+}
+//#endregion
+//#region src/modules/selfie/types.d.ts
+/**
+ * Public selfie configuration.
+ *
+ * For the captureOnly flow (delivering the captured image locally instead of
+ * uploading to Incode), use `createSelfieCaptureOnlyManager` with
+ * `SelfieCaptureOnlyConfig`.
+ */
+type SelfieConfig = FlowModuleConfig['SELFIE'] & BaseFaceCaptureConfig;
+/**
+ * Public selfie configuration for the captureOnly flow.
+ *
+ * Differs from {@link SelfieConfig} 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 SelfieCaptureOnlyConfig = SelfieConfig & {
+  onCapture: (response: FaceCaptureOnlyResponse) => void | Promise<void>;
+};
+type SelfieDependencies = FaceCaptureDependencies;
+type SendFaceImageResponse = {
+  age: number;
+  confidence: number;
+  hasClosedEyes: boolean;
+  hasFaceMask: boolean;
+  hasHeadCover: boolean;
+  hasLenses: boolean;
+  isBright: boolean;
+  liveness: boolean;
+  imageBase64: string;
+  sessionStatus: string;
+};
+//#endregion
+//#region src/internal/faceCapture/recordingService.d.ts
+type RecordingService = {
+  start(stream: MediaStream): Promise<void>;
+  stop(): Promise<{
+    recordingId: string | null;
+  }>;
+  /**
+   * Stops the recorder and returns the raw (un-encrypted, not uploaded)
+   * video as base64. Used by the captureOnly flow, which hands video bytes
+   * to the integrator via `onCapture` instead of uploading to Incode.
+   *
+   * Returns `{ videoBase64: undefined }` when video is not available for
+   * any reason, including:
+   * - the recorder was never started or is already stopped,
+   * - the provider is server-side (e.g. OpenVidu) and the client never
+   *   holds the bytes,
+   * - video assembly fails.
+   */
+  stopAndGetVideo(): Promise<{
+    videoBase64: string | undefined;
+  }>;
+  cleanup(): void;
+};
+//#endregion
+//#region src/internal/faceCapture/faceCaptureSetup.d.ts
+type FaceCaptureConfig = BaseFaceCaptureConfig;
+type FaceCaptureInput = {
+  config: FaceCaptureConfig;
+  dependencies: FaceCaptureDependencies;
+  authHint?: string;
+};
+type FaceErrorObject = {
+  type: string;
+  message: string;
+};
+type FaceCaptureContext = {
+  config: FaceCaptureConfig;
+  dependencies: FaceCaptureDependencies;
+  authHint: string | undefined;
+  stream: CameraStream | undefined;
+  provider: FaceDetectionProvider | undefined;
+  frameCapturer: StreamCanvasCapture | undefined;
+  error: string | FaceErrorObject | undefined;
+  detectionStatus: DetectionStatus;
+  debugFrame: ImageData | undefined;
+  capturedImage: IncodeCanvas | undefined;
+  faceCoordinates: FaceCoordinates | undefined;
+  uploadResponse: Record<string, unknown> | undefined;
+  processResponse: Record<string, unknown> | undefined;
+  recordingService: RecordingService | undefined;
+  attemptsRemaining: number;
+  uploadError: FaceErrorCode | undefined;
+  permissionResult: PermissionResult | 'refresh' | undefined;
+  resetDetection: (() => void) | undefined;
+  deepsightService: DeepsightService | undefined;
+  encryptedBase64Image: string | undefined;
+  uploadRecordingId: string | null | undefined;
+  manualCaptureTriggered: boolean;
+  /**
+   * Rich capture payload used only by the captureOnly variant. Populated by
+   * the variant's `.provide()` override of `setUploadResponseFromEvent`,
+   * which writes the `uploadFace` actor's output here instead of the loose
+   * `uploadResponse` channel. Consumed by the captureOnly manager on
+   * transition into `finished`. Remains `undefined` in the regular upload
+   * flow (the base action writes to `uploadResponse` and never touches this
+   * field).
+   */
+  captureOnlyResult: FaceCapturedImageData | undefined;
+};
+type FaceCaptureEvent = {
+  type: 'LOAD';
+} | {
+  type: 'NEXT_STEP';
+} | {
+  type: 'REQUEST_PERMISSION';
+} | {
+  type: 'GO_TO_LEARN_MORE';
+} | {
+  type: 'BACK';
+} | {
+  type: 'QUIT';
+} | {
+  type: 'RESET';
+} | {
+  type: 'MANUAL_CAPTURE';
+} | {
+  type: 'DETECTION_UPDATE';
+  status: DetectionStatus;
+} | {
+  type: 'DETECTION_FRAME';
+  frame: ImageData;
+} | {
+  type: 'DETECTION_SUCCESS';
+  canvas: IncodeCanvas;
+  faceCoordinates?: FaceCoordinates;
+} | {
+  type: 'DETECTION_RESET_READY';
+  reset: () => void;
+} | {
+  type: 'RETRY_CAPTURE';
+};
+declare const faceCaptureMachine: AnyStateMachine;
+//#endregion
+//#region src/modules/selfie/selfieStateMachine.d.ts
+type SelfieContext = FaceCaptureContext;
+type SelfieEvent = FaceCaptureEvent;
+type SelfieInput = FaceCaptureInput;
+/**
+ * The selfie capture state machine.
+ *
+ * Note: Uses AnyStateMachine type for declaration file portability.
+ * Type safety is ensured via the machine configuration.
+ */
+declare const selfieMachine: AnyStateMachine;
+/**
+ * Type representing the selfie machine.
+ * For advanced use cases requiring specific machine types.
+ */
+type SelfieMachine = StateMachine<SelfieContext, SelfieEvent, any, any, any, any, any, any, any, SelfieInput, any, any, any, any>;
+//#endregion
+//#region src/modules/selfie/selfieActor.d.ts
+type CreateSelfieActorOptions = {
+  config: SelfieConfig;
+  dependencies?: SelfieDependencies;
+  authHint?: string;
+};
+type SelfieActor = ActorRefFrom<SelfieMachine>;
+//#endregion
+//#region src/modules/selfie/selfieCaptureOnlyStateMachine.d.ts
+type SelfieCaptureOnlyContext = FaceCaptureContext;
+type SelfieCaptureOnlyEvent = FaceCaptureEvent;
+type SelfieCaptureOnlyInput = FaceCaptureInput;
+/**
+ * Selfie state machine variant for the captureOnly flow. Shares the full base
+ * face-capture state tree; only the upload/process step is local instead of
+ * remote.
+ */
+declare const selfieCaptureOnlyMachine: AnyStateMachine;
+type SelfieCaptureOnlyMachine = StateMachine<SelfieCaptureOnlyContext, SelfieCaptureOnlyEvent, any, any, any, any, any, any, any, SelfieCaptureOnlyInput, any, any, any, any>;
+//#endregion
+//#region src/modules/selfie/selfieCaptureOnlyActor.d.ts
+type CreateSelfieCaptureOnlyActorOptions = {
+  config: SelfieCaptureOnlyConfig;
+  dependencies?: SelfieDependencies;
+};
+type SelfieCaptureOnlyActor = ActorRefFrom<SelfieCaptureOnlyMachine>;
+//#endregion
+//#region src/internal/faceCapture/faceCaptureManagerFactory.d.ts
+type FaceCaptureActor = SelfieActor | AuthenticationActor | SelfieCaptureOnlyActor;
+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';
+  ageAssurance?: boolean;
+};
+/** 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;
+  /** Whether assisted onboarding mode is active (back camera, no mirror) */
+  assistedOnboarding: boolean;
+  ageAssurance?: boolean;
+};
+/** 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 createFaceCaptureManagerFromActor(actor: FaceCaptureActor, moduleName: string): 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 createFaceCaptureManagerFromActor>;
+//#endregion
+export { DetectionStatus as C, authenticationMachine as D, FaceErrorCode as E, AuthenticationConfig as S, FaceCapturedImageData as T, SendFaceImageResponse as _, SelfieCaptureOnlyMachine as a, CreateAuthenticationActorOptions as b, SelfieActor as c, FaceCaptureContext as d, FaceCaptureEvent as f, SelfieConfig as g, SelfieCaptureOnlyConfig as h, SelfieCaptureOnlyActor as i, SelfieMachine as l, faceCaptureMachine as m, FaceCaptureManagerState as n, selfieCaptureOnlyMachine as o, FaceCaptureInput as p, CreateSelfieCaptureOnlyActorOptions as r, CreateSelfieActorOptions as s, FaceCaptureManager as t, selfieMachine as u, BaseWasmProvider as v, FaceCaptureOnlyResponse as w, createAuthenticationActor as x, AuthenticationActor as y };