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

package/dist/index.d.ts

@@ -0,0 +1,445 @@
+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 { c as warmupWasm, s as WasmPipeline } from "./types-CMR6NkxW.js";
+import "./Manager-Co-PsiG9.js";
+
+//#region ../infra/src/http/types.d.ts
+type CreateApiConfig = {
+  apiURL: string;
+  customHeaders?: Record<string, string>;
+  timeout?: number;
+};
+type RequestConfig = {
+  method?: string;
+  url: string;
+  headers?: Record<string, string>;
+  query?: Record<string, string | number | boolean | undefined>;
+  params?: Record<string, string | number | boolean | undefined>;
+  body?: unknown;
+  signal?: AbortSignal;
+  timeout?: number;
+  parse?: 'json' | 'text' | 'blob' | 'arrayBuffer' | 'response';
+  onUploadProgress?: (progress: number) => void;
+};
+type HttpResponse<T = unknown> = {
+  ok: boolean;
+  status: number;
+  statusText: string;
+  url: string;
+  headers: Record<string, string>;
+  data: T;
+};
+type HttpClient = {
+  defaults: {
+    baseURL: string;
+    headers: Record<string, string>;
+  };
+  request<T = unknown>(config: RequestConfig): Promise<HttpResponse<T>>;
+  get<T = unknown>(url: string, config?: Omit<RequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
+  post<T = unknown>(url: string, body?: unknown, config?: Omit<RequestConfig, 'method' | 'url' | 'body'>): Promise<HttpResponse<T>>;
+  put<T = unknown>(url: string, body?: unknown, config?: Omit<RequestConfig, 'method' | 'url' | 'body'>): Promise<HttpResponse<T>>;
+  patch<T = unknown>(url: string, body?: unknown, config?: Omit<RequestConfig, 'method' | 'url' | 'body'>): Promise<HttpResponse<T>>;
+  delete<T = unknown>(url: string, config?: Omit<RequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
+  head<T = unknown>(url: string, config?: Omit<RequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
+  options<T = unknown>(url: string, config?: Omit<RequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
+  setHeader(name: string, value: string): void;
+};
+//#endregion
+//#region ../infra/src/http/createApi.d.ts
+declare const createApi: (config: CreateApiConfig) => HttpClient;
+//#endregion
+//#region src/internal/device/getBrowser.d.ts
+type Browser = 'chrome' | 'firefox' | 'safari' | 'edge' | 'other';
+declare function getBrowser(): Browser;
+//#endregion
+//#region src/internal/device/getDeviceClass.d.ts
+type DeviceClass = 'ios' | 'android' | 'desktop';
+declare function getDeviceClass(): DeviceClass;
+//#endregion
+//#region src/internal/http/api.d.ts
+type MethodConfig = {
+  headers?: Record<string, string>;
+  signal?: AbortSignal;
+  timeout?: number;
+  query?: Record<string, string | number | boolean | undefined>;
+  onUploadProgress?: (progress: number) => void;
+};
+type ApiClient = {
+  get<T>(url: string, config?: MethodConfig): Promise<HttpResponse<T>>;
+  post<T>(url: string, data?: unknown, config?: MethodConfig): Promise<HttpResponse<T>>;
+  put<T>(url: string, data?: unknown, config?: MethodConfig): Promise<HttpResponse<T>>;
+  patch<T>(url: string, data?: unknown, config?: MethodConfig): Promise<HttpResponse<T>>;
+  delete<T>(url: string, config?: MethodConfig): Promise<HttpResponse<T>>;
+};
+declare function getApi(): HttpClient;
+declare const api: ApiClient;
+//#endregion
+//#region src/internal/permissions/permissionServices.d.ts
+/**
+ * Checks the current camera permission state without prompting the user.
+ */
+declare function checkPermission(): Promise<PermissionResult>;
+/**
+ * Requests camera permission by attempting to access the camera, then immediately
+ * stops the obtained stream. This function does not keep or return the stream.
+ */
+declare function requestPermission(): Promise<PermissionResult>;
+//#endregion
+//#region src/internal/session/sessionService.d.ts
+type CreateSessionOptions = {
+  /** The configuration/flow ID from the Incode dashboard */
+  configurationId: string;
+  /** External ID to associate with this session */
+  externalId?: string;
+  /** External customer ID */
+  externalCustomerId?: string;
+  /** Language for the session (e.g., 'en-US', 'es-MX') */
+  language?: string;
+  /** Custom fields to attach to the session */
+  customFields?: Record<string, unknown>;
+  /** UUID for continuing an existing session */
+  uuid?: string;
+  /** Interview ID for continuing an existing interview */
+  interviewId?: string;
+};
+type Session = {
+  token: string;
+  interviewId: string;
+  uuid?: string;
+  regulationType?: string;
+  showMandatoryConsent?: boolean;
+};
+/**
+ * Creates a new onboarding session.
+ *
+ * @param apiKey - The API key from the Incode dashboard
+ * @param options - Session creation options
+ * @param signal - Optional AbortSignal for request cancellation
+ * @returns The created session with token
+ *
+ * @example
+ * ```ts
+ * const session = await createSession('your-api-key', {
+ *   configurationId: 'your-flow-id',
+ *   language: 'en-US',
+ * });
+ * console.log(session.token); // Use this token for subsequent API calls
+ * ```
+ */
+declare function createSession(apiKey: string, options: CreateSessionOptions, signal?: AbortSignal): Promise<Session>;
+//#endregion
+//#region src/setup.d.ts
+/**
+ * WASM warmup configuration.
+ */
+type WasmConfig = {
+  /** 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;
+  /** Which pipelines to preload models for */
+  pipelines?: WasmPipeline[];
+  /**
+   * 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;
+};
+/**
+ * Configuration options for the SDK setup.
+ */
+type SetupOptions = {
+  /** The base URL for the API */
+  apiURL: string;
+  /** The session token for API requests (optional - can be set later or omitted for createSession calls) */
+  token?: string;
+  /** Custom headers to include in all requests */
+  customHeaders?: Record<string, string>;
+  /** Request timeout in milliseconds */
+  timeout?: number;
+  /** Optional WASM warmup config - if provided, preloads WASM and ML models */
+  wasm?: WasmConfig;
+};
+/**
+ * Initializes the SDK with the provided configuration.
+ * Must be called before using any SDK functionality.
+ *
+ * If `wasm` config is provided, this function becomes async and will
+ * preload WASM binary and ML models. Otherwise, it's synchronous.
+ *
+ * @param options - Configuration options for the SDK
+ *
+ * @example
+ * ```ts
+ * import { setup, createSession } from '@incodetech/core';
+ *
+ * // Setup with API URL first (for session creation)
+ * await setup({ apiURL: 'https://api.incode.com' });
+ * const session = await createSession('api-key', { configurationId: 'flow-id' });
+ *
+ * // Basic setup with token
+ * await setup({
+ *   apiURL: 'https://api.incode.com',
+ *   token: 'session-token',
+ * });
+ *
+ * // Setup with WASM warmup
+ * await setup({
+ *   apiURL: 'https://api.incode.com',
+ *   token: 'session-token',
+ *   wasm: {
+ *     wasmPath: '/wasm/ml-wasm.wasm',
+ *     glueCodePath: '/wasm/ml-wasm.js',
+ *     pipelines: ['selfie', 'idCapture'],
+ *   },
+ * });
+ * ```
+ */
+declare function setup(options: SetupOptions): Promise<void>;
+/**
+ * Sets the WASM configuration without performing warmup.
+ * Useful when WASM warmup is handled separately (e.g., conditionally based on flow).
+ *
+ * @param config - WASM configuration to store
+ */
+declare function setWasmConfig(config: WasmConfig): void;
+/**
+ * Initializes WasmUtilProvider with the stored WASM configuration.
+ * Should be called after warmupWasm() completes when using conditional warmup.
+ * This ensures image encryption works properly.
+ *
+ * @param config - Optional WASM configuration. If not provided, uses the stored config from setWasmConfig().
+ * @throws Error if no config is provided and none is stored
+ */
+declare function initializeWasmUtil(config?: WasmConfig): Promise<void>;
+/**
+ * Checks if the SDK has been configured.
+ *
+ * @returns true if setup() has been called, false otherwise
+ */
+declare function isConfigured(): boolean;
+/**
+ * Resets the SDK configuration. Useful for testing.
+ */
+declare function reset(): void;
+//#endregion
+//#region src/internal/events/types.d.ts
+type Event = {
+  code: string;
+  module?: string;
+  screen?: string;
+  payload?: Record<string, unknown>;
+  clientTimestamp?: number;
+};
+declare const eventModuleNames: {
+  readonly selfie: "SELFIE";
+  readonly authFace: "AUTH_FACE";
+  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 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 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";
+};
+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 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";
+};
+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;
+/**
+ * Subscribes to all SDK events for logging, debugging, or custom analytics.
+ * Returns an unsubscribe function.
+ *
+ * @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.
+ * Events are queued if SDK is not configured yet.
+ */
+declare function addEvent(event: Event): void;
+/**
+ * Flushes any queued events that were sent before SDK was configured.
+ * Called automatically by setup() after token is set.
+ */
+declare function flushEventQueue(): void;
+//#endregion
+//#region src/internal/events/helpers.d.ts
+type ScreenEventParams = {
+  module: EventModule | string;
+  screen?: EventScreen | string;
+  code: string;
+  payload?: Record<string, unknown>;
+};
+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;
+//#endregion
+export { type Browser, CameraStream, CaptureIdResponse, CapturedImage, CreateIdCaptureActorOptions, type CreateSessionOptions, DetectionArea, DetectionOrientation, DetectionStatus, type DeviceClass, type Event, type EventModule, type EventScreen, type HttpClient, ID_ERROR_CODES, IIdCaptureCapability, IdCaptureActor, IdCaptureConfig, IdCaptureContext, IdCaptureEvent, IdCaptureGeometry, IdCaptureInitResult, IdCaptureInput, IdCaptureMachine, IdCaptureManager, IdCaptureMode, IdCaptureProvider, IdCaptureSettings, IdCaptureState, IdCaptureThresholds, IdDocumentType, IdError, IdErrorCode, IdFlowStep, type PermissionResult, type PermissionStatus, RecordingSession, type Session, type SetupOptions, StartRecordingParams, UploadIdImageParams, UploadIdResponse, ValidationError, type WasmConfig, type WasmPipeline, addEvent, api, cameraScreenNamesMapper, checkPermission as checkCameraPermission, createApi, createIdCaptureActor, createIdCaptureManager, createSession, eventModuleNames, eventScreenNames, flushEventQueue, getApi, getBrowser, getDeviceClass, idCaptureMachine, initializeIdCapture, initializeWasmUtil, isConfigured, moduleClosed, moduleOpened, processId, requestPermission as requestCameraPermission, reset, screenClosed, screenEvent, screenOpened, setWasmConfig, setup, startRecordingSession, stopRecording, stopStream, subscribeEvent, tutorialScreenNamesMapper, uploadIdImage, validateUploadResponse, videoSelfieEvents, warmupWasm };

package/dist/index.esm.js

@@ -0,0 +1,163 @@
+import { a as videoSelfieEvents, c as screenClosed, d as addEvent, f as flushEventQueue, i as tutorialScreenNamesMapper, l as screenEvent, n as eventModuleNames, o as moduleClosed, p as subscribeEvent, r as eventScreenNames, s as moduleOpened, t as cameraScreenNamesMapper, u as screenOpened } from "./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, o as warmupWasm, r as WasmUtilProvider, w as createApi_default } from "./src-DYtpbFY5.esm.js";
+import "./getDeviceClass-DkfbtsIJ.esm.js";
+import { t as endpoints } from "./endpoints-BUsSVoJV.esm.js";
+import { c as getDeviceClass, l as getBrowser, o as checkPermission, s as requestPermission } from "./streamingEvents-CfEJv3xH.esm.js";
+import { a as resetApi, n as getApi, o as setClient, s as setToken, t as api } from "./api-DfRLAneb.esm.js";
+
+//#region src/internal/session/sessionService.ts
+/**
+* Creates a new onboarding session.
+*
+* @param apiKey - The API key from the Incode dashboard
+* @param options - Session creation options
+* @param signal - Optional AbortSignal for request cancellation
+* @returns The created session with token
+*
+* @example
+* ```ts
+* const session = await createSession('your-api-key', {
+*   configurationId: 'your-flow-id',
+*   language: 'en-US',
+* });
+* console.log(session.token); // Use this token for subsequent API calls
+* ```
+*/
+async function createSession(apiKey, options, signal) {
+	const res = await getApi().post(endpoints.createSession, {
+		configurationId: options.configurationId,
+		externalId: options.externalId,
+		externalCustomerId: options.externalCustomerId,
+		language: options.language ?? "en-US",
+		customFields: options.customFields,
+		uuid: options.uuid ?? null,
+		interviewId: options.interviewId ?? null
+	}, {
+		headers: {
+			"x-api-key": apiKey,
+			"api-version": "1.0"
+		},
+		signal
+	});
+	if (!res.ok) throw new Error(`POST ${endpoints.createSession} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/setup.ts
+let wasmConfig;
+let configured = false;
+/**
+* Initializes the SDK with the provided configuration.
+* Must be called before using any SDK functionality.
+*
+* If `wasm` config is provided, this function becomes async and will
+* preload WASM binary and ML models. Otherwise, it's synchronous.
+*
+* @param options - Configuration options for the SDK
+*
+* @example
+* ```ts
+* import { setup, createSession } from '@incodetech/core';
+*
+* // Setup with API URL first (for session creation)
+* await setup({ apiURL: 'https://api.incode.com' });
+* const session = await createSession('api-key', { configurationId: 'flow-id' });
+*
+* // Basic setup with token
+* await setup({
+*   apiURL: 'https://api.incode.com',
+*   token: 'session-token',
+* });
+*
+* // Setup with WASM warmup
+* await setup({
+*   apiURL: 'https://api.incode.com',
+*   token: 'session-token',
+*   wasm: {
+*     wasmPath: '/wasm/ml-wasm.wasm',
+*     glueCodePath: '/wasm/ml-wasm.js',
+*     pipelines: ['selfie', 'idCapture'],
+*   },
+* });
+* ```
+*/
+async function setup(options) {
+	setClient(createApi_default({
+		apiURL: options.apiURL,
+		customHeaders: options.customHeaders,
+		timeout: options.timeout
+	}));
+	if (options.token) {
+		setToken(options.token);
+		flushEventQueue();
+	}
+	configured = true;
+	if (options.wasm) {
+		await warmupWasm({
+			wasmPath: options.wasm.wasmPath,
+			wasmSimdPath: options.wasm.wasmSimdPath,
+			glueCodePath: options.wasm.glueCodePath,
+			useSimd: options.wasm.useSimd,
+			pipelines: options.wasm.pipelines,
+			modelsBasePath: options.wasm.modelsBasePath
+		});
+		await (await WasmUtilProvider.getInstance()).initialize({
+			wasmPath: options.wasm.wasmPath,
+			wasmSimdPath: options.wasm.wasmSimdPath,
+			glueCodePath: options.wasm.glueCodePath,
+			useSimd: options.wasm.useSimd,
+			pipelines: options.wasm.pipelines,
+			modelsBasePath: options.wasm.modelsBasePath
+		});
+	}
+}
+/**
+* Sets the WASM configuration without performing warmup.
+* Useful when WASM warmup is handled separately (e.g., conditionally based on flow).
+*
+* @param config - WASM configuration to store
+*/
+function setWasmConfig(config) {
+	wasmConfig = config;
+}
+/**
+* Initializes WasmUtilProvider with the stored WASM configuration.
+* Should be called after warmupWasm() completes when using conditional warmup.
+* This ensures image encryption works properly.
+*
+* @param config - Optional WASM configuration. If not provided, uses the stored config from setWasmConfig().
+* @throws Error if no config is provided and none is stored
+*/
+async function initializeWasmUtil(config) {
+	const wasmConfigToUse = config ?? wasmConfig;
+	if (!wasmConfigToUse) throw new Error("WASM config is required. Provide config parameter or call setWasmConfig() first.");
+	await (await WasmUtilProvider.getInstance()).initialize({
+		wasmPath: wasmConfigToUse.wasmPath,
+		wasmSimdPath: wasmConfigToUse.wasmSimdPath,
+		glueCodePath: wasmConfigToUse.glueCodePath,
+		useSimd: wasmConfigToUse.useSimd,
+		pipelines: wasmConfigToUse.pipelines,
+		modelsBasePath: wasmConfigToUse.modelsBasePath
+	});
+}
+/**
+* Checks if the SDK has been configured.
+*
+* @returns true if setup() has been called, false otherwise
+*/
+function isConfigured() {
+	return configured;
+}
+/**
+* Resets the SDK configuration. Useful for testing.
+*/
+function reset() {
+	resetApi();
+	configured = false;
+	WasmUtilProvider.resetInstance();
+}
+
+//#endregion
+export { ID_ERROR_CODES, IdCaptureProvider, addEvent, api, cameraScreenNamesMapper, checkPermission as checkCameraPermission, createApi_default as createApi, createIdCaptureActor, createIdCaptureManager, createSession, eventModuleNames, eventScreenNames, flushEventQueue, getApi, getBrowser, getDeviceClass, idCaptureMachine, initializeIdCapture, initializeWasmUtil, isConfigured, moduleClosed, moduleOpened, processId, requestPermission as requestCameraPermission, reset, screenClosed, screenEvent, screenOpened, setWasmConfig, setup, startRecordingSession, stopRecording, stopStream, subscribeEvent, tutorialScreenNamesMapper, uploadIdImage, validateUploadResponse, videoSelfieEvents, warmupWasm };