@incodetech/core 2.0.0-alpha.1 → 2.0.0-alpha.2

package/dist/selfie.d.ts

@@ -0,0 +1,758 @@
+import { t as WasmPipeline } from "./warmup-Dr7OcFND.js";
+import { t as Manager } from "./Manager-6BwbaI_H.js";
+import { n as StateMachine, t as AnyStateMachine } from "./StateMachine-7c1gcu94.js";
+import { n as PermissionStatus, t as PermissionResult } from "./types-tq1ypYSL.js";
+
+//#region ../infra/src/media/canvas.d.ts
+/**
+ * Class representing a canvas element for image capture and manipulation.
+ */
+declare class IncodeCanvas {
+  canvas: HTMLCanvasElement;
+  private base64Image;
+  private blobData;
+  /**
+   * Creates an {@link IncodeCanvas} from a raw {@link ImageData} frame.
+   * @param imageData - Frame pixels in RGBA format
+   * @returns An {@link IncodeCanvas} containing the provided pixels
+   */
+  static fromImageData(imageData: ImageData): IncodeCanvas;
+  /**
+   * Create a new canvas element.
+   * @param canvas_ - The canvas element to clone.
+   */
+  constructor(canvas_: HTMLCanvasElement);
+  /**
+   * Check if the current canvas is valid.
+   */
+  private checkCanvas;
+  /**
+   * Release the data stored by IncodeCanvas.
+   */
+  release(): void;
+  /**
+   * Get the width of the canvas.
+   */
+  width(): number | null;
+  /**
+   * Get the height of the canvas.
+   */
+  height(): number | null;
+  /**
+   * Set the width of the canvas.
+   */
+  setWidth(width: number): void;
+  /**
+   * Set the height of the canvas.
+   */
+  setHeight(height: number): void;
+  /**
+   * Clone the current canvas.
+   */
+  clone(): IncodeCanvas | null;
+  /**
+   * Deep clone the current IncodeCanvas including blob data.
+   */
+  deepClone(): Promise<IncodeCanvas | null>;
+  /**
+   * Returns the drawing context on the canvas.
+   */
+  getContext(contextId: '2d', contextAttributes?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D | null;
+  /**
+   * Retrieves the image data from the canvas.
+   */
+  getImageData(): ImageData | null;
+  /**
+   * Updates the base64 representation of the current canvas image.
+   */
+  updateBase64Image(jpegQuality?: number): void;
+  /**
+   * Converts the current canvas element to a base64 string.
+   */
+  getBase64Image(jpegQuality?: number, includeDataURLPrefix?: boolean): string | null;
+  /**
+   * Sets the base64 representation of the current canvas image.
+   */
+  setBase64Image(base64Image: string | null): void;
+  /**
+   * Updates the Blob representation of the current canvas image.
+   */
+  updateBlob(jpegQuality?: number, includeDataURLPrefix?: boolean): void;
+  /**
+   * Converts a base64 string to a Blob and creates a URL for it.
+   */
+  static base64ToBlob(base64: string): {
+    blob: Blob;
+    url: string;
+  } | null;
+  /**
+   * Retrieves the Blob data and its URL from the current canvas.
+   */
+  getBlobData(jpegQuality?: number, includeDataURLPrefix?: boolean): {
+    blob: Blob;
+    url: string;
+  } | null;
+  /**
+   * Sets the Blob data of the current canvas image.
+   */
+  setBlobData(blobData: {
+    blob: Blob;
+    url: string;
+  }): Promise<void>;
+  /**
+   * Returns a resized canvas according to video element size.
+   */
+  getResizedCanvas(videoElementWidth: number, videoElementHeight: number): IncodeCanvas | null;
+}
+//#endregion
+//#region ../infra/src/capabilities/IMLProviderCapability.d.ts
+/**
+ * Base configuration shared by all ML provider capabilities.
+ */
+interface MLProviderConfig {
+  /** Path to the WASM binary */
+  wasmPath?: string;
+  /** Path to the SIMD-optimized WASM binary (optional) */
+  wasmSimdPath?: string;
+  /** Path to the WASM glue code */
+  glueCodePath?: 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 interface for ML provider capabilities.
+ * Provides common lifecycle and frame processing methods shared by
+ * FaceDetectionCapability and IdCaptureCapability.
+ */
+interface IMLProviderCapability<TConfig extends MLProviderConfig> {
+  /**
+   * Whether the provider has been initialized and is ready to process frames.
+   */
+  readonly initialized: boolean;
+  /**
+   * Initializes the provider with the given configuration.
+   * If WASM was already warmed up via `setup()` or `warmupWasm()`, this returns almost instantly.
+   * @param config - Provider configuration including WASM paths
+   */
+  initialize(config: TConfig): Promise<void>;
+  /**
+   * Processes a frame through the ML pipeline.
+   * Callbacks set via `setCallbacks()` will be invoked based on the analysis results.
+   * @param image - Image data to process
+   * @throws Error if provider is not initialized
+   */
+  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/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;
+}
+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;
+}
+interface FaceAttributesThresholds {
+  headwearThreshold: number;
+  lensesThreshold: number;
+  closedEyesThreshold: number;
+  maskThreshold: number;
+}
+interface FaceChecksConfig {
+  lenses: boolean;
+  mask: boolean;
+  closedEyes: boolean;
+  headWear: boolean;
+  occlusion: boolean;
+}
+interface FaceData {
+  rect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  rightEye: {
+    x: number;
+    y: number;
+  };
+  leftEye: {
+    x: number;
+    y: number;
+  };
+  noseTip: {
+    x: number;
+    y: number;
+  };
+  rightMouthCorner: {
+    x: number;
+    y: number;
+  };
+  leftMouthCorner: {
+    x: number;
+    y: number;
+  };
+  pitch: number;
+  yaw: number;
+  roll: number;
+}
+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;
+  onBestShot?: (face: FaceData) => 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;
+}
+//#endregion
+//#region ../infra/src/capabilities/IRecordingCapability.d.ts
+type RecordingPublisher = {
+  getStreamId: () => string | undefined;
+  replaceVideoTrack: (track: MediaStreamTrack) => Promise<void>;
+  destroy: () => void;
+};
+type RecordingConnection = {
+  sessionId: string | undefined;
+  publisher: RecordingPublisher;
+  disconnect: () => Promise<void>;
+};
+type RecordingConnectionEvents = {
+  onSessionConnected?: (sessionId: string | undefined) => void;
+  onSessionDisconnected?: (sessionId: string | undefined) => void;
+  onSessionException?: (params: {
+    name?: string;
+    message?: string;
+    sessionId?: string;
+  }) => void;
+  onPublisherCreated?: (params: {
+    streamId?: string;
+    sessionId?: string;
+  }) => void;
+  onPublisherError?: (params: {
+    message?: string;
+    sessionId?: string;
+    streamId?: string;
+  }) => void;
+};
+type ConnectRecordingParams = {
+  sessionToken: string;
+  stream: MediaStream;
+  events?: RecordingConnectionEvents;
+};
+type IRecordingCapability = {
+  /**
+   * Connects to a recording session and publishes the provided media stream.
+   * Returns a connection handle that can be disconnected and used to manage the publisher.
+   */
+  connect: (params: ConnectRecordingParams) => Promise<RecordingConnection>;
+};
+//#endregion
+//#region ../infra/src/media/camera.d.ts
+type CameraStream = MediaStream;
+//#endregion
+//#region ../infra/src/media/StreamCanvasCapture.d.ts
+type StreamCanvasCaptureOptions = {
+  fps?: number;
+  width?: number;
+  height?: number;
+};
+type StreamCanvasCaptureEventMap = {
+  frame: Event;
+};
+declare class StreamCanvasCapture {
+  private video;
+  private canvas;
+  private ctx;
+  private rafId;
+  private lastFrameTimeSeconds;
+  private lastTickTimeMs;
+  private hasFrame;
+  private disposed;
+  private eventTarget;
+  constructor(stream: CameraStream, options?: StreamCanvasCaptureOptions);
+  addEventListener(type: keyof StreamCanvasCaptureEventMap, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+  removeEventListener(type: keyof StreamCanvasCaptureEventMap, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
+  /**
+   * Returns the latest cached frame as an {@link IncodeCanvas}.
+   */
+  getLatestCanvas(): IncodeCanvas | null;
+  /**
+   * Returns the latest cached frame as raw {@link ImageData}.
+   */
+  getLatestFrame(): ImageData | null;
+  /**
+   * Disposes internal resources and stops the capture loop.
+   */
+  dispose(): void;
+  private rafLoop;
+  private tick;
+}
+//#endregion
+//#region ../infra/src/wasm/WasmPipelineType.d.ts
+declare enum WasmPipelineType {
+  IdBlurGlarePipeline = 0,
+  IdBarcodeAndTextQualityPipeline = 1,
+  IdVideoSelfiePipeline = 2,
+  SelfieWithAggregationMetrics = 3,
+  SelfieWithQualityMetrics = 4,
+  IdFaceDetectionPipeline = 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 */
+  glueCodePath?: 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
+   */
+  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;
+  private bestCanvas;
+  private bestFace;
+  constructor();
+  processFrame(image: ImageData): Promise<void>;
+  initialize(config: FaceDetectionConfig): Promise<void>;
+  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/selfie/types.d.ts
+type SelfieConfig = {
+  showTutorial: boolean;
+  showPreview: boolean;
+  assistedOnboarding: boolean;
+  enableFaceRecording: boolean;
+  recording?: {
+    capability?: IRecordingCapability;
+  };
+  autoCaptureTimeout: number;
+  captureAttempts: number;
+  validateLenses: boolean;
+  validateFaceMask: boolean;
+  validateHeadCover: boolean;
+  validateClosedEyes: boolean;
+  validateBrightness: boolean;
+  deepsightLiveness: 'SINGLE_FRAME' | 'MULTIMODAL' | 'VIDEOLIVENESS';
+};
+type DetectionStatus = 'idle' | 'detecting' | 'noFace' | 'tooManyFaces' | 'tooClose' | 'tooFar' | 'blur' | 'dark' | 'faceAngle' | 'headWear' | 'lenses' | 'eyesClosed' | 'faceMask' | 'centerFace' | 'manualCapture' | 'success' | 'error' | 'capturing' | 'getReady' | 'getReadyFinished' | 'offline';
+type SendFaceImageResponse = {
+  age: number;
+  confidence: number;
+  hasClosedEyes: boolean;
+  hasFaceMask: boolean;
+  hasHeadCover: boolean;
+  hasLenses: boolean;
+  isBright: boolean;
+  liveness: boolean;
+  imageBase64: string;
+  sessionStatus: string;
+};
+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];
+type RecordingSession = {
+  token: string;
+  sessionId: string;
+  videoRecordingId: string;
+  connection: RecordingConnection;
+  resolution?: string;
+  hasAudio: boolean;
+};
+//#endregion
+//#region src/selfie/selfieStateMachine.d.ts
+type SelfieContext = {
+  config: SelfieConfig;
+  stream: CameraStream | undefined;
+  provider: FaceDetectionProvider | undefined;
+  frameCapturer: StreamCanvasCapture | undefined;
+  error: string | undefined;
+  detectionStatus: DetectionStatus;
+  debugFrame: ImageData | undefined;
+  capturedImage: IncodeCanvas | undefined;
+  faceCoordinates: FaceCoordinates | undefined;
+  uploadResponse: SendFaceImageResponse | undefined;
+  recordingSession: RecordingSession | undefined;
+  attemptsRemaining: number;
+  uploadError: FaceErrorCode | undefined;
+  permissionResult: PermissionResult | 'refresh' | undefined;
+  resetDetection: (() => void) | undefined;
+};
+type SelfieEvent = {
+  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';
+};
+type SelfieInput = {
+  config: SelfieConfig;
+};
+/**
+ * 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/selfie/selfieActor.d.ts
+type CreateSelfieActorOptions = {
+  config: SelfieConfig;
+};
+//#endregion
+//#region src/selfie/selfieManager.d.ts
+type CaptureStatus = 'initializing' | 'detecting' | 'capturing' | 'uploading' | 'uploadError' | 'success';
+/** Selfie manager is waiting to be started */
+type SelfieIdleState = {
+  status: 'idle';
+};
+/** Checking camera permissions (when no tutorial) */
+type SelfieLoadingState = {
+  status: 'loading';
+};
+/** Showing selfie tutorial */
+type SelfieTutorialState = {
+  status: 'tutorial';
+};
+/** Handling camera permissions */
+type SelfiePermissionsState = {
+  status: 'permissions';
+  /** Current permission sub-state: initial, requesting, denied, or learnMore */
+  permissionStatus: PermissionStatus;
+};
+/** Camera is ready for selfie capture */
+type SelfieCaptureState = {
+  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;
+};
+/** Selfie capture completed successfully */
+type SelfieFinishedState = {
+  status: 'finished';
+};
+/** User closed the selfie flow */
+type SelfieClosedState = {
+  status: 'closed';
+};
+/** An error occurred during the flow */
+type SelfieErrorState = {
+  status: 'error';
+  /** The error message */
+  error: string;
+};
+/** Union of all possible selfie states */
+type SelfieState = SelfieIdleState | SelfieLoadingState | SelfieTutorialState | SelfiePermissionsState | SelfieCaptureState | SelfieFinishedState | SelfieClosedState | SelfieErrorState;
+/**
+ * Creates a selfie manager instance for handling selfie capture flow.
+ *
+ * The selfie manager provides:
+ * - State management with statuses: `idle`, `loading`, `tutorial`, `permissions`, `capture`, `finished`, `closed`, `error`
+ * - Permission handling with nested states: `idle`, `requesting`, `denied`, `learnMore`
+ * - Capture handling with nested states: `initializing`, `startingRecorder`, `recordingActive`, `detecting`, `capturing`, `uploading`, `uploadError`, `success`
+ * - Camera stream access when in `capture` state
+ * - Detection status feedback during face detection
+ * - Attempt tracking with `attemptsRemaining`
+ *
+ * @param options - Configuration for the selfie actor
+ * @param options.config - The selfie module configuration from the flow
+ * @returns A manager instance with state subscription, API methods, and lifecycle controls
+ *
+ * @example
+ * ```ts
+ * const selfieManager = createSelfieManager({ config: selfieConfig });
+ *
+ * selfieManager.subscribe((state) => {
+ *   if (state.status === 'capture') {
+ *     console.log('Camera ready:', state.stream);
+ *     console.log('Detection status:', state.detectionStatus);
+ *   }
+ * });
+ *
+ * selfieManager.load();
+ * ```
+ */
+declare function createSelfieManager(options: CreateSelfieActorOptions): Manager<SelfieState> & {
+  /**
+   * Starts the selfie 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 selfie flow and transitions to `closed` state.
+   * Can be called from any state.
+   */
+  close(): void;
+  /**
+   * Resets the selfie manager to its initial `idle` state.
+   * Can be called from `finished` or `error` states.
+   */
+  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 selfie in manual capture mode.
+   * Only effective when in `capture.detecting` state and `detectionStatus === 'manualCapture'`.
+   */
+  capture(): void;
+};
+type SelfieManager = ReturnType<typeof createSelfieManager>;
+//#endregion
+export { type CameraStream, type DetectionStatus, type FaceErrorCode, type PermissionResult, type PermissionStatus, type SelfieConfig, type SelfieMachine, type SelfieManager, type SelfieState, createSelfieManager, selfieMachine };