@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/events.d.ts

@@ -0,0 +1,265 @@
+//#region src/internal/events/types.d.ts
+/**
+ * Raw SDK analytics event used by dashboard tracking and custom analytics.
+ *
+ * This event stream can include detailed/noisy tracking such as screen opens,
+ * element clicks, capture attempts, and errors. For curated flow milestones,
+ * use `FlowEvent` from `@incodetech/core/flow-events`.
+ */
+type Event = {
+  code: string;
+  module?: string;
+  screen?: string;
+  payload?: Record<string, unknown>;
+  clientTimestamp?: number;
+};
+declare const eventModuleNames: {
+  readonly selfie: "SELFIE";
+  readonly faceCapture: "faceCapture";
+  readonly authentication: "AUTHENTICATION";
+  readonly authFace: "authFace";
+  readonly mlConsent: "ML_CONSENT";
+  readonly combinedConsent: "COMBINED_CONSENT";
+  readonly curpValidation: "CURP_VALIDATION";
+  readonly faceMatch: "FACE_MATCH";
+  readonly qr: "QR";
+  readonly videoSelfie: "VIDEO_ONBOARDING";
+  readonly passport: "ID";
+  readonly front: "ID";
+  readonly back: "ID";
+  readonly id: "ID";
+  readonly idCapture: "idCapture";
+  readonly idOcr: "ID_OCR";
+  readonly document: "DOCUMENT_CAPTURE";
+  readonly creditCard: "CREDIT_CARD_FRONT";
+  readonly creditCardBack: "CREDIT_CARD_BACK";
+  readonly conference: "CONFERENCE";
+  readonly otp: "OTP";
+  readonly signature: "SIGNATURE";
+  readonly ekyc: "EXTERNAL_VERIFICATION";
+  readonly watchlist: "WATCHLIST";
+  readonly globalWatchList: "GLOBAL_WATCHLIST";
+  readonly customWatchList: "CUSTOM_WATCHLIST";
+  readonly email: "EMAIL";
+  readonly phone: "PHONE";
+  readonly instantVerifyEmail: "INSTANT_VERIFY_EMAIL";
+  readonly instantVerifyConsent: "INSTANT_VERIFY_CONSENT";
+  readonly forms: "FORMS";
+  readonly customModule: "CUSTOM_MODULE";
+  readonly geolocation: "GEOLOCATION";
+  readonly ekyb: "EKYB";
+  readonly identityReuse: "IDENTITY_REUSE";
+  readonly antifraud: "ANTIFRAUD";
+  readonly aeSignature: "AE_SIGNATURE";
+  readonly qeSignature: "QE_SIGNATURE";
+  readonly crossDocumentDataMatch: "CROSS_DOCUMENT_DATA_MATCH";
+  readonly customFields: "CUSTOM_FIELDS";
+  readonly watchlistForBusiness: "WATCHLIST_FOR_BUSINESS";
+  readonly trustGraph: "TRUST_GRAPH";
+};
+declare const eventScreenNames: {
+  readonly faceMatch: "FACE_MATCH";
+  readonly faceCaptureTutorial: "SELFIE_CAPTURE_TUTORIAL";
+  readonly faceCaptureCamera: "SELFIE_CAMERA_CAPTURE";
+  readonly faceCaptureError: "SELFIE_ATTEMPT_FAILED";
+  readonly faceCaptureSuccess: "SELFIE_UPLOAD_SUCCEEDED";
+  readonly faceCaptureUpload: "SELFIE_UPLOAD_PROGRESS";
+  readonly mlConsent: "MACHINE_LEARNING_CONSENT";
+  readonly combinedConsent: "COMBINED_CONSENT";
+  readonly curpEnter: "ENTER_CURP";
+  readonly curpValidate: "VALIDATE_CURP";
+  readonly curpGenerate: "GENERATE_CURP";
+  readonly curpValidation: "CURP_VALIDATION_PROGRESS";
+  readonly curpValidationFailed: "CURP_VALIDATION_FAILED";
+  readonly curpValidationSuccess: "CURP_VALIDATION_SUCCEEDED";
+  readonly qrTutorial: "QR_TUTORIAL";
+  readonly qrScan: "QR_SCAN";
+  readonly smsOtp: "OTP";
+  readonly simpleOTP: "OTP";
+  readonly signatureInput: "SIGNATURE_INPUT";
+  readonly frontTutorial: "FRONT_ID_CAPTURE_TUTORIAL";
+  readonly frontCameraCapture: "FRONT_ID_CAMERA_CAPTURE";
+  readonly frontHelp: "FRONT_ID_HELP";
+  readonly frontReviewPhoto: "FRONT_ID_REVIEW_PHOTO";
+  readonly frontUploadProgress: "FRONT_ID_UPLOAD_PROGRESS";
+  readonly frontAttemptFailed: "FRONT_ID_ATTEMPT_FAILED";
+  readonly frontUploadSuccess: "FRONT_ID_UPLOAD_SUCCEEDED";
+  readonly backTutorial: "BACK_ID_CAPTURE_TUTORIAL";
+  readonly backCameraCapture: "BACK_ID_CAMERA_CAPTURE";
+  readonly backReviewPhoto: "BACK_ID_REVIEW_PHOTO";
+  readonly backUploadProgress: "BACK_ID_UPLOAD_PROGRESS";
+  readonly backAttemptFailed: "BACK_ID_ATTEMPT_FAILED";
+  readonly backUploadSuccess: "BACK_ID_UPLOAD_SUCCEEDED";
+  readonly backHelp: "BACK_ID_HELP";
+  readonly passportTutorial: "TUTORIAL_PASSPORT";
+  readonly documentTutorial: "DOCUMENT_CAPTURE_TUTORIAL";
+  readonly documentCameraCapture: "DOCUMENT_CAMERA_CAPTURE";
+  readonly documentHelp: "DOCUMENT_HELP";
+  readonly documentReviewPhoto: "DOCUMENT_REVIEW_PHOTO";
+  readonly documentUploadProgress: "DOCUMENT_UPLOAD_IN_PROGRESS";
+  readonly documentAttemptFailed: "DOCUMENT_ATTEMPT_FAILED";
+  readonly documentUploadSuccess: "DOCUMENT_UPLOAD_SUCCEEDED";
+  readonly conferenceWait: "CONFERENCE_WAIT";
+  readonly conferenceVideoChat: "CONFERENCE_VIDEO_CHAT";
+  readonly conferenceMessageChat: "CONFERENCE_MESSAGE_CHAT";
+  readonly videoSelfieTutorial: "VIDEO_SELFIE_TUTORIAL";
+  readonly videoSelfie: "VIDEO_SELFIE";
+  readonly videoSelfieFaceCapture: "VIDEO_SELFIE_FACE_CAPTURE";
+  readonly videoSelfieFaceUploadProgress: "VIDEO_SELFIE_FACE_UPLOAD_PROGRESS";
+  readonly videoSelfieFaceAttemptFailed: "VIDEO_SELFIE_FACE_ATTEMPT_FAILED";
+  readonly videoSelfieFaceUploadSucceeded: "VIDEO_SELFIE_FACE_UPLOAD_SUCCEEDED";
+  readonly videoSelfieFrontIdCapture: "VIDEO_SELFIE_FRONT_ID_CAPTURE";
+  readonly videoSelfieFrontIdUploadProgress: "VIDEO_SELFIE_FRONT_ID_UPLOAD_PROGRESS";
+  readonly videoSelfieFrontIdAttemptFailed: "VIDEO_SELFIE_FRONT_ID_ATTEMPT_FAILED";
+  readonly videoSelfieFrontIdUploadSucceeded: "VIDEO_SELFIE_FRONT_ID_UPLOAD_SUCCEEDED";
+  readonly videoSelfieBackIdCapture: "VIDEO_SELFIE_BACK_ID_CAPTURE";
+  readonly videoSelfieBackIdUploadProgress: "VIDEO_SELFIE_BACK_ID_UPLOAD_PROGRESS";
+  readonly videoSelfieBackIdAttemptFailed: "VIDEO_SELFIE_BACK_ID_ATTEMPT_FAILED";
+  readonly videoSelfieBackIdUploadSucceeded: "VIDEO_SELFIE_BACK_ID_UPLOAD_SUCCEEDED";
+  readonly videoSelfieDocumentCapture: "VIDEO_SELFIE_DOCUMENT_CAPTURE";
+  readonly videoSelfieVoiceQuestion: "VIDEO_SELFIE_VOICE_QUESTION";
+  readonly videoSelfieVoiceFinalQuestion: "VIDEO_SELFIE_VOICE_FINAL_QUESTION";
+  readonly videoSelfieVideoUpload: "VIDEO SELFIE VIDEO UPLOAD";
+  readonly ekycInput: "EKYC_INPUT";
+  readonly ekycProgress: "EKYC_PROGRESS";
+  readonly ekycSucceeded: "EKYC_SUCCEEDED";
+  readonly ekycFailed: "EKYC_FAILED";
+  readonly forms: "FORMS";
+  readonly globalWatchListInput: "GLOBAL_WATCHLIST_INPUT";
+  readonly globalWatchListProgress: "GLOBAL_WATCHLIST_PROGRESS";
+  readonly globalWatchListSuccess: "GLOBAL_WATCHLIST_SUCCEEDED";
+  readonly globalWatchListFailed: "GLOBAL_WATCHLIST_FAILED";
+  readonly customWatchListInput: "CUSTOM_WATCHLIST_INPUT";
+  readonly customWatchListProgress: "CUSTOM_WATCHLIST_PROGRESS";
+  readonly customWatchListSuccess: "CUSTOM_WATCHLIST_SUCCEEDED";
+  readonly customWatchListFailed: "CUSTOM_WATCHLIST_FAILED";
+  readonly emailInput: "EMAIL_INPUT";
+  readonly phoneInput: "PHONE_INPUT";
+  readonly instantVerify: "INSTANT_VERIFY";
+  readonly authFace: "AUTH_FACE";
+  readonly authFaceError: "AUTH_FACE_ATTEMPT_FAILED";
+  readonly authFaceUpload: "AUTH_FACE_UPLOAD_PROGRESS";
+  readonly authFaceUploadSuccess: "AUTH_FACE_UPLOAD_SUCCEEDED";
+  readonly authFaceUploadFailed: "AUTH_FACE_UPLOAD_FAILED";
+  readonly authFaceTutorial: "AUTH_FACE_TUTORIAL";
+  readonly customModuleCallback: "CUSTOM_MODULE_CALLBACK";
+  readonly customModuleProcessing: "CUSTOM_MODULE_PROCESSING";
+  readonly digitalIdFileSelection: "DIGITAL_ID_FILE_SELECTION";
+  readonly digitalIdFileReview: "DIGITAL_ID_FILE_REVIEW";
+  readonly digitalIdUploadProgress: "DIGITAL_ID_UPLOAD_PROGRESS";
+  readonly digitalIdUploadSuccess: "DIGITAL_ID_UPLOAD_SUCCEEDED";
+  readonly digitalIdUploadFailed: "DIGITAL_ID_UPLOAD_FAILED";
+  readonly digitalIdAnalysisProgress: "DIGITAL_ID_ANALYSIS_PROGRESS";
+  readonly digitalIdVerificationSuccess: "DIGITAL_ID_VERIFICATION_SUCCESS";
+  readonly digitalIdVerificationFailed: "DIGITAL_ID_VERIFICATION_FAILED";
+  readonly ekybForm: "EKYB_FORM";
+};
+declare const videoSelfieEvents: {
+  readonly imageTooBlurry: "imageTooBlurry";
+  readonly fillFrame: "fillFrame";
+  readonly checkCameraOrLighting: "checkCameraOrLighting";
+  readonly frontIdCaptureStarted: "frontIdCaptureStarted";
+  readonly lookAtCamera: "lookAtCamera";
+  readonly moveCloser: "moveCloser";
+  readonly lookingForFrontId: "lookingForFrontId";
+  readonly lookingForBackId: "lookingForBackId";
+  readonly cameraSwitchToBack: "cameraSwitchToBack";
+  readonly cameraSwitchToFront: "cameraSwitchToFront";
+  readonly audioStreamOpened: "audioStreamOpened";
+  readonly audioStreamClosed: "audioStreamClosed";
+  readonly videoSelfieVideoUploadInProgress: "videoSelfieVideoUploadInProgress";
+  readonly videoSelfieTosNotAccepted: "videoSelfieTosNotAccepted";
+  readonly videoSelfieTosAccepted: "videoSelfieTosAccepted";
+  readonly videoSelfieStreamCreated: "videoSelfieStreamCreated";
+  readonly videoSelfieStreamDestroyed: "videoSelfieStreamDestroyed";
+  readonly videoSelfieReconnecting: "videoSelfieReconnecting";
+  readonly videoSelfieReconnected: "videoSelfieReconnected";
+};
+declare const tutorialScreenNamesMapper: {
+  readonly passport: "TUTORIAL_PASSPORT";
+  readonly front: "FRONT_ID_CAPTURE_TUTORIAL";
+  readonly back: "BACK_ID_CAPTURE_TUTORIAL";
+  readonly selfie: "SELFIE_CAPTURE_TUTORIAL";
+};
+declare const cameraScreenNamesMapper: {
+  readonly front: "front";
+  readonly back: "back";
+  readonly passport: "passport";
+  readonly creditCard: "front";
+  readonly creditCardBack: "back";
+  readonly document: "document";
+};
+type EventModule = (typeof eventModuleNames)[keyof typeof eventModuleNames];
+type EventScreen = (typeof eventScreenNames)[keyof typeof eventScreenNames];
+//#endregion
+//#region src/internal/events/addEvent.d.ts
+type EventSubscriber = (event: Event) => void;
+/**
+ * Registers the analytics batcher used by `addEvent` to ship events to the
+ * interview-events API. Disposes any previously-registered instance and drains
+ * any events queued before registration into the new batcher's buffer (FIFO).
+ *
+ * Returns the registered service so the caller can drive its lifecycle
+ * (e.g. call `.start()` after session initialization completes).
+ */
+
+/**
+ * Subscribes to raw SDK analytics events.
+ *
+ * This stream includes noisy tracking events such as `screenOpened`,
+ * `elementClicked`, and `captureAttemptFinished`. These events are also used by
+ * the SDK analytics pipeline and may be queued or posted to the interview-events
+ * API.
+ *
+ * For curated flow milestones such as `flow.started`, `flow.ready`, and
+ * `flow.completed`, use `manager.subscribeFlowEvent()`. The `FlowEvent` type is
+ * exported from `@incodetech/core/flow-events`.
+ *
+ * @param listener - Callback function that receives each event
+ * @returns Unsubscribe function to remove the listener
+ *
+ * @example
+ * ```typescript
+ * const unsubscribe = subscribeEvent((event) => {
+ *   console.log('[Event]', event.code, event.module);
+ * });
+ *
+ * // Later
+ * unsubscribe();
+ * ```
+ */
+declare function subscribeEvent(listener: EventSubscriber): () => void;
+/**
+ * Sends an event to the dashboard for tracking.
+ * Fire-and-forget: never blocks, never throws.
+ * Subscribers always receive the event at emit time. When a batcher is
+ * registered, the event is enqueued for batched delivery. Before any batcher
+ * is registered (events fired pre-`setup()`), the event is buffered in a
+ * one-shot pending queue and drained into the batcher when it's registered.
+ */
+declare function addEvent(event: Event): void;
+//#endregion
+//#region src/internal/events/helpers.d.ts
+type ScreenEventParams = {
+  module: EventModule | string;
+  screen?: EventScreen | string;
+  code: string;
+  payload?: Record<string, unknown>;
+};
+type ElementClickedPayload = {
+  element: string;
+  action?: string;
+  metadata?: Record<string, unknown>;
+};
+type CaptureAttemptFinishedPayload = {
+  logs: string;
+};
+declare function screenEvent(params: ScreenEventParams): void;
+declare function moduleOpened(module: EventModule | string, screen?: EventScreen | string, payload?: Record<string, unknown>): void;
+declare function moduleClosed(module: EventModule | string, screen?: EventScreen | string, payload?: Record<string, unknown>): void;
+declare function screenOpened(module: EventModule | string, screen: EventScreen | string, payload?: Record<string, unknown>): void;
+declare function screenClosed(module: EventModule | string, screen: EventScreen | string, payload?: Record<string, unknown>): void;
+declare function elementClicked(module: EventModule | string, screen: EventScreen | string | undefined, payload: ElementClickedPayload): void;
+declare function captureAttemptFinished(module: EventModule | string, screen: EventScreen | string | undefined, payload: CaptureAttemptFinishedPayload): void;
+//#endregion
+export { type CaptureAttemptFinishedPayload, type ElementClickedPayload, type Event, type EventModule, type EventScreen, addEvent, cameraScreenNamesMapper, captureAttemptFinished, elementClicked, eventModuleNames, eventScreenNames, moduleClosed, moduleOpened, screenClosed, screenEvent, screenOpened, subscribeEvent, tutorialScreenNamesMapper, videoSelfieEvents };

package/dist/events.esm.js

@@ -0,0 +1,4 @@
+import "./api-CESGtpbH.esm.js";
+import { a as videoSelfieEvents, c as elementClicked, d as screenClosed, f as screenEvent, h as addEvent, i as tutorialScreenNamesMapper, l as moduleClosed, n as eventModuleNames, p as screenOpened, r as eventScreenNames, s as captureAttemptFinished, t as cameraScreenNamesMapper, u as moduleOpened, y as subscribeEvent } from "./events-D6-e4vok.esm.js";
+
+export { addEvent, cameraScreenNamesMapper, captureAttemptFinished, elementClicked, eventModuleNames, eventScreenNames, moduleClosed, moduleOpened, screenClosed, screenEvent, screenOpened, subscribeEvent, tutorialScreenNamesMapper, videoSelfieEvents };

package/dist/extensibility.d.ts

@@ -0,0 +1,122 @@
+import "./warmup-CEcppFiS.js";
+import "./Manager-C8PrhBOx.js";
+import { n as createActor } from "./Actor-CI32dTbG.js";
+import { r as fromPromise } from "./StateMachine-BCQrZJhf.js";
+import { _ as SendFaceImageResponse, d as FaceCaptureContext, f as FaceCaptureEvent, m as faceCaptureMachine, n as FaceCaptureManagerState, p as FaceCaptureInput, t as FaceCaptureManager, v as BaseWasmProvider } from "./faceCaptureManagerFactory-yqtpxjnN.js";
+import "./camera-DBSxa6ML.js";
+import "./types-CFV9G_7j.js";
+import "./types-BP1m8VRw.js";
+import { a as IWasmUtilCapability, o as VirtualCameraCheckOutput, s as WasmUtilConfig, u as IStorageCapability } from "./deepsightService-CEVxzehb.js";
+import "./types-CAD4va6a.js";
+import { a as ProcessFaceResponse, i as createSelfieManagerFromActor, n as SelfieState, t as SelfieManager } from "./selfieManager-D0lSgd-J.js";
+import { i as createAuthenticationManagerFromActor, n as AuthenticationState, t as AuthenticationManager } from "./authenticationManager-C83GNIhl.js";
+import { i as createEmailManagerFromActor, n as EmailState, t as EmailManager } from "./emailManager-DIfnS5g1.js";
+import { A as CaptureIdResponse, i as createIdCaptureManagerFromActor, n as IdCaptureManager, r as IdCaptureState } from "./idCaptureManager-Fyd0eam-.js";
+import { i as createPhoneManagerFromActor, n as PhoneState, t as PhoneManager } from "./phoneManager-B6M30hKE.js";
+
+//#region src/modules/authentication/authenticationUploadService.d.ts
+type AuthenticationUploadResponse = {
+  overallStatus: 'PASS' | 'FAIL';
+  captureAttemptsLimit: {
+    max: number;
+    remaining: number;
+  };
+  candidate: string;
+  error: {
+    name: string;
+    message: string;
+  };
+  imageBase64?: string;
+  selfieEncryptedBase64?: string;
+  metadata?: string;
+};
+//#endregion
+//#region ../infra/src/providers/browser/BrowserStorageProvider.d.ts
+/**
+ * Browser-based storage provider wrapping localStorage.
+ * Handles JSON serialization/deserialization automatically.
+ */
+declare class BrowserStorageProvider implements IStorageCapability {
+  /**
+   * Retrieves a value from localStorage.
+   * @param key - The storage key
+   * @returns The stored value or null if not found
+   * @throws Error if stored value is invalid JSON
+   */
+  get<T>(key: string): Promise<T | null>;
+  /**
+   * Stores a value in localStorage.
+   * @param key - The storage key
+   * @param value - The value to store (will be serialized as JSON)
+   * @throws Error if value cannot be serialized or quota is exceeded
+   */
+  set<T>(key: string, value: T): Promise<void>;
+  /**
+   * Removes a value from localStorage.
+   * @param key - The storage key to remove
+   */
+  remove(key: string): Promise<void>;
+  /**
+   * Clears all values from localStorage.
+   */
+  clear(): Promise<void>;
+}
+//#endregion
+//#region ../infra/src/providers/wasm/WasmUtilProvider.d.ts
+declare class WasmUtilProvider extends BaseWasmProvider implements IWasmUtilCapability {
+  private static instance;
+  private static initPromise;
+  static getInstance(): Promise<WasmUtilProvider>;
+  static resetInstance(): void;
+  constructor();
+  initialize(config: WasmUtilConfig): Promise<void>;
+  processFrame(_image: ImageData): Promise<void>;
+  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;
+  getPipelineState(): string;
+  estimatePerformance(): string;
+  isVirtualCamera(label: string | null): boolean;
+  prc(): Promise<void>;
+  poc(output: VirtualCameraCheckOutput): Promise<void>;
+  ckvcks(data: ArrayBuffer): void;
+  getVersions(): Promise<unknown>;
+}
+//#endregion
+//#region ../infra/src/capabilities/IFingerprintCapability.d.ts
+type DeviceFingerprintInfo = {
+  device: {
+    model?: string;
+  };
+  os: {
+    name?: string;
+    version?: string;
+  };
+  browser: {
+    name?: string;
+    version?: string;
+  };
+};
+type FingerprintResult = {
+  visitorId: string;
+  ip: string;
+  deviceInfo: DeviceFingerprintInfo;
+};
+//#endregion
+//#region ../infra/src/device/getDeviceData.d.ts
+declare function getDeviceFingerprintInfo(): Promise<DeviceFingerprintInfo>;
+//#endregion
+//#region src/internal/fingerprint/fingerprintApi.d.ts
+declare function getFingerprint(disableIpify?: boolean): Promise<FingerprintResult>;
+//#endregion
+export { type AuthenticationManager, type AuthenticationState, type AuthenticationUploadResponse, BrowserStorageProvider, type CaptureIdResponse, type DeviceFingerprintInfo, type EmailManager, type EmailState, type FaceCaptureContext, type FaceCaptureEvent, type FaceCaptureInput, type FaceCaptureManager, type FaceCaptureManagerState, type FingerprintResult, type IdCaptureManager, type IdCaptureState, type PhoneManager, type PhoneState, type ProcessFaceResponse, type SelfieManager, type SelfieState, type SendFaceImageResponse, WasmUtilProvider, createActor, createAuthenticationManagerFromActor, createEmailManagerFromActor, createIdCaptureManagerFromActor, createPhoneManagerFromActor, createSelfieManagerFromActor, faceCaptureMachine, fromPromise, getDeviceFingerprintInfo, getFingerprint };

package/dist/extensibility.esm.js

@@ -0,0 +1,43 @@
+import "./BaseWasmProvider-C_DLEI40.esm.js";
+import { t as WasmUtilProvider } from "./WasmUtilProvider-j98OJf-S.esm.js";
+import "./BrowserTimerProvider-DhNc_x02.esm.js";
+import "./api-CESGtpbH.esm.js";
+import "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import { a as FingerprintProvider, o as getDeviceFingerprintInfo, t as getDisableIpify } from "./session-CGtQJJzB.esm.js";
+import { t as IpifyProvider } from "./IpifyProvider-D7jx52AL.esm.js";
+import "./browserSimulation-gxD8cSpM.esm.js";
+import { a as fromPromise, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
+import "./faceCaptureManagerFactory-Dh2PdGlF.esm.js";
+import { t as BrowserStorageProvider } from "./BrowserStorageProvider-CuOW1Er2.esm.js";
+import { t as faceCaptureMachine } from "./faceCaptureSetup-B3faSpYA.esm.js";
+import "./ITimerCapability-C67ZRskg.esm.js";
+import "./camera-PA2Ljri3.esm.js";
+import "./deepsightService-O74l4Y__.esm.js";
+import "./recordingService-Ig2UgbLv.esm.js";
+import "./platform-CfrjKhmi.esm.js";
+import "./backCameraStream-DMdMeGk2.esm.js";
+import "./getBrowser-BSXUTWXw.esm.js";
+import "./stats-CIfiPzb1.esm.js";
+import "./getDeviceClass-BSntT9_j.esm.js";
+import "./MotionSensorProvider-4v7xkqAp.esm.js";
+import "./permissionServices-D_i6nzEw.esm.js";
+import "./authenticationStateMachine-BMZqatiF.esm.js";
+import { n as createAuthenticationManagerFromActor } from "./authenticationManager-5M-fKzXx.esm.js";
+import "./emailStateMachine-DOf4j58N.esm.js";
+import { n as createEmailManagerFromActor } from "./emailManager-wAV0LE-H.esm.js";
+import "./selfieStateMachine-D76whWEf.esm.js";
+import { n as createSelfieManagerFromActor } from "./selfieManager-Duisl7qN.esm.js";
+import "./idCaptureStateMachine-BK0bPHoc.esm.js";
+import { r as createIdCaptureManagerFromActor } from "./idCaptureManager-ZPkD7Gjk.esm.js";
+import "./phoneStateMachine-CuPARRaT.esm.js";
+import { n as createPhoneManagerFromActor } from "./phoneManager-DAJbGhlY.esm.js";
+
+//#region src/internal/fingerprint/fingerprintApi.ts
+async function getFingerprint(disableIpify) {
+	const shouldDisableIpify = disableIpify ?? getDisableIpify();
+	return new FingerprintProvider(new IpifyProvider()).getFingerprint(shouldDisableIpify);
+}
+
+//#endregion
+export { BrowserStorageProvider, WasmUtilProvider, createActor, createAuthenticationManagerFromActor, createEmailManagerFromActor, createIdCaptureManagerFromActor, createPhoneManagerFromActor, createSelfieManagerFromActor, faceCaptureMachine, fromPromise, getDeviceFingerprintInfo, getFingerprint };

package/dist/face-match.d.ts

@@ -0,0 +1,228 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+
+//#region src/modules/face-match/types.d.ts
+
+/**
+ * Face match comparison variant.
+ * Determines which images are compared in the face match flow.
+ */
+type FaceMatchVariant = 'selfieVsId' | 'selfieVsNfc' | 'idVsNfc' | 'nfc3Way' | 'secondId';
+/**
+ * Configuration options for face match module.
+ *
+ * @example Standard face match with animation
+ * ```typescript
+ * const config: FaceMatchConfig = {
+ *   matchingType: 'selfieVsId',
+ *   disableFaceMatchAnimation: false,
+ * };
+ * ```
+ *
+ * @example Auto-skip mode (headless)
+ * ```typescript
+ * const config: FaceMatchConfig = {
+ *   matchingType: 'selfieVsId',
+ *   disableFaceMatchAnimation: true,
+ * };
+ * ```
+ */
+type FaceMatchConfig = {
+  /**
+   * Which images to compare in the face match flow.
+   * Backend field name: `matchingType`.
+   * @default 'selfieVsId'
+   */
+  matchingType?: FaceMatchVariant;
+  /**
+   * When true, skips the animation UI and auto-completes immediately after fetching data.
+   * Useful for headless integrations or silent verification flows.
+   * @default false
+   */
+  disableFaceMatchAnimation?: boolean;
+};
+/**
+ * Cropped face images fetched from the backend.
+ */
+type FaceMatchImages = {
+  /**
+   * Cropped face from ID document.
+   */
+  idFace: string | null;
+  /**
+   * Cropped selfie image (from face capture).
+   */
+  selfie: string | null;
+  /**
+   * Cropped face from second ID document (only for 'secondId' variant).
+   */
+  secondIdFace?: string | null;
+};
+/**
+ * Face match result parsed from score response.
+ */
+type FaceMatchResult = {
+  /**
+   * Whether faces matched (OK = true, FAIL = false, null = unknown).
+   */
+  matched: boolean | null;
+  /**
+   * Whether liveness check passed.
+   */
+  liveness: boolean | null;
+};
+//#endregion
+//#region src/modules/face-match/faceMatchActor.d.ts
+type CreateFaceMatchActorOptions = {
+  config: FaceMatchConfig;
+};
+//#endregion
+//#region src/modules/face-match/faceMatchManager.d.ts
+/** Face match manager is in initial state, waiting for `load()` to be called */
+type FaceMatchIdleState = {
+  status: 'idle';
+};
+/** Fetching images and score from backend */
+type FaceMatchLoadingState = {
+  status: 'loading';
+};
+/**
+ * Animation is playing - images are animating.
+ * @property images - Cropped face images fetched from backend
+ * @property result - Face match result (matched, liveness)
+ */
+type FaceMatchAnimatingState = {
+  status: 'animating';
+  images: {
+    idFace: string | null;
+    selfie: string | null;
+    secondIdFace?: string | null;
+  };
+  result: {
+    matched: boolean | null;
+    liveness: boolean | null;
+  };
+};
+/**
+ * Showing match result - waiting for user to click continue.
+ * @property images - Cropped face images
+ * @property result - Face match result
+ * @property matched - Whether faces matched (true/false/null)
+ */
+type FaceMatchResultState = {
+  status: 'result';
+  images: {
+    idFace: string | null;
+    selfie: string | null;
+    secondIdFace?: string | null;
+  };
+  result: {
+    matched: boolean | null;
+    liveness: boolean | null;
+  };
+  matched: boolean | null;
+};
+/** Face match completed successfully */
+type FaceMatchFinishedState = {
+  status: 'finished';
+  matched: boolean | null;
+};
+/**
+ * Fatal error occurred - call `reset()` to start over
+ * @property error - Error message describing what went wrong
+ */
+type FaceMatchErrorState = {
+  status: 'error';
+  error: string;
+};
+/**
+ * Union of all possible face match manager states.
+ * Use discriminated union pattern to narrow the type:
+ *
+ * @example
+ * ```typescript
+ * const state = faceMatchManager.getState();
+ * if (state.status === 'animating') {
+ *   // TypeScript knows state has images and result
+ *   console.log(state.images.idFace);
+ * }
+ * ```
+ */
+type FaceMatchState = FaceMatchIdleState | FaceMatchLoadingState | FaceMatchAnimatingState | FaceMatchResultState | FaceMatchFinishedState | FaceMatchErrorState;
+/**
+ * Creates a face match manager for headless or UI-driven usage.
+ *
+ * The manager provides a state machine-based API for face comparison
+ * with optional animation display.
+ *
+ * @param options - Configuration options
+ * @param options.config - Face match configuration
+ * @param options.config.matchingType - Which images to compare (default: 'selfieVsId')
+ * @param options.config.disableFaceMatchAnimation - Skip animation and auto-complete (default: false)
+ *
+ * @returns Face match manager with state, API methods, and subscription
+ *
+ * @example Headless usage
+ * ```typescript
+ * const manager = createFaceMatchManager({
+ *   config: { matchingType: 'selfieVsId', disableFaceMatchAnimation: true },
+ * });
+ *
+ * manager.subscribe((state) => console.log(state.status));
+ * manager.load();
+ * // Auto-completes when disableFaceMatchAnimation is true
+ * manager.stop();
+ * ```
+ *
+ * @example With React/Preact UI hook
+ * ```tsx
+ * const [state, manager] = useManager(() => createFaceMatchManager({ config }));
+ *
+ * if (state.status === 'animating') {
+ *   return <Animation images={state.images} />;
+ * }
+ * ```
+ */
+declare function createFaceMatchManager(options: CreateFaceMatchActorOptions): Manager<FaceMatchState> & {
+  /**
+   * Initializes the face match flow.
+   * Transitions from 'idle' to 'loading'.
+   * Must be called before any other method.
+   */
+  load(): void;
+  /**
+   * Signals that the animation has completed.
+   * Should be called when state is 'animating' and your UI animation finishes.
+   * Transitions to 'result' state.
+   */
+  animationComplete(): void;
+  /**
+   * User clicked continue button.
+   * Should be called when state is 'result'.
+   * Transitions to 'finished' state.
+   */
+  continue(): void;
+  /**
+   * Resets the manager to initial state.
+   * Can be called from 'error' state to start over.
+   * Clears all stored data including images and result.
+   */
+  reset(): void;
+};
+/**
+ * Type representing a face match manager instance.
+ * Includes state access, API methods, and lifecycle management.
+ *
+ * @property getState - Returns the current FaceMatchState
+ * @property subscribe - Subscribes to state changes, returns unsubscribe function
+ * @property stop - Stops the manager and cleans up resources
+ * @property load - Initializes the face match flow
+ * @property animationComplete - Signals animation finished
+ * @property continue - User clicked continue button
+ * @property reset - Resets to initial state
+ */
+type FaceMatchManager = ReturnType<typeof createFaceMatchManager>;
+//#endregion
+//#region src/modules/face-match/faceMatchStateMachine.d.ts
+declare const faceMatchMachine: any;
+//#endregion
+export { type FaceMatchConfig, type FaceMatchImages, type FaceMatchManager, type FaceMatchResult, type FaceMatchState, type FaceMatchVariant, createFaceMatchManager, faceMatchMachine };