@incodetech/core 2.0.0 → 2.0.1

package/dist/redirect-to-mobile.d.ts

@@ -0,0 +1,107 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+
+//#region src/modules/redirect-to-mobile/types.d.ts
+type RedirectToMobileConfig = {
+  flowId?: string;
+  url?: string;
+  disableSmsOption?: boolean;
+  addContinueToDesktop?: boolean;
+  qrPhishingResistance?: boolean;
+  authHint?: string;
+  externalId?: string;
+  lang?: string;
+};
+//#endregion
+//#region src/modules/redirect-to-mobile/redirectToMobileStateMachine.d.ts
+
+declare const redirectToMobileMachine: any;
+//#endregion
+//#region src/modules/redirect-to-mobile/redirectToMobileActor.d.ts
+type CreateRedirectToMobileActorOptions = {
+  config: RedirectToMobileConfig;
+};
+//#endregion
+//#region src/modules/redirect-to-mobile/redirectToMobileManager.d.ts
+type RedirectToMobileIdleState = {
+  status: 'idle';
+};
+type RedirectToMobileLoadingState = {
+  status: 'loading';
+};
+type RedirectToMobileRedirectingState = {
+  status: 'redirecting';
+  redirectUrl: string;
+  phonePrefix: string;
+  smsSent: boolean;
+  error: string | undefined;
+};
+type RedirectToMobileFinishedState = {
+  status: 'finished';
+};
+type RedirectToMobileClosedState = {
+  status: 'closed';
+};
+type RedirectToMobileErrorState = {
+  status: 'error';
+  error: string;
+};
+type RedirectToMobileState = RedirectToMobileIdleState | RedirectToMobileLoadingState | RedirectToMobileRedirectingState | RedirectToMobileFinishedState | RedirectToMobileClosedState | RedirectToMobileErrorState;
+/**
+ * Creates a redirect-to-mobile manager for cross-device onboarding flows.
+ *
+ * On desktop, displays a QR code (and optional SMS input) so the user can
+ * continue on their mobile device. Polls the backend until the mobile
+ * session completes, then transitions to `finished`.
+ *
+ * @param options - Configuration for the redirect module
+ * @returns A manager instance with state subscription and API methods
+ *
+ * @example
+ * ```ts
+ * const manager = createRedirectToMobileManager({
+ *   config: { disableSmsOption: false, addContinueToDesktop: true },
+ * });
+ *
+ * manager.subscribe((state) => {
+ *   if (state.status === 'redirecting') {
+ *     renderQrCode(state.redirectUrl);
+ *   }
+ *   if (state.status === 'finished') {
+ *     console.log('Mobile onboarding complete');
+ *   }
+ * });
+ *
+ * manager.load();
+ * ```
+ */
+declare function createRedirectToMobileManager(options: CreateRedirectToMobileActorOptions): Manager<RedirectToMobileState> & {
+  /**
+   * Starts the redirect-to-mobile flow by fetching the redirect URL.
+   */
+  load(): void;
+  /**
+   * Sends an SMS with the redirect link to the given phone number.
+   * @param phone - Full phone number with country code
+   */
+  sendSms(phone: string): void;
+  /**
+   * Skips the redirect and allows the user to continue on desktop.
+   */
+  continueOnDesktop(): void;
+  /**
+   * Resets the SMS state so the user can re-enter their phone number.
+   */
+  resetSms(): void;
+  /**
+   * Closes/dismisses the redirect screen.
+   */
+  close(): void;
+  /**
+   * Retries generating the redirect URL after an error.
+   */
+  retry(): void;
+};
+type RedirectToMobileManager = ReturnType<typeof createRedirectToMobileManager>;
+//#endregion
+export { type RedirectToMobileConfig, type RedirectToMobileManager, type RedirectToMobileState, createRedirectToMobileManager, redirectToMobileMachine };

package/dist/redirect-to-mobile.esm.js

@@ -0,0 +1,102 @@
+import "./BrowserTimerProvider-DhNc_x02.esm.js";
+import "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
+import { t as redirectToMobileMachine } from "./redirectToMobileStateMachine-BOEqe46A.esm.js";
+
+//#region src/modules/redirect-to-mobile/redirectToMobileActor.ts
+function createRedirectToMobileActor(options) {
+	return createActor(redirectToMobileMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/redirect-to-mobile/redirectToMobileManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("generatingUrl") || typedSnapshot.matches("loadingStartInfo")) return { status: "loading" };
+	if (typedSnapshot.matches("showingQr")) return {
+		status: "redirecting",
+		redirectUrl: context.redirectUrl,
+		phonePrefix: context.phonePrefix,
+		smsSent: context.smsSent,
+		error: context.error
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	if (typedSnapshot.matches("closed")) return { status: "closed" };
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "An error occurred"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		sendSms(phone) {
+			trackElementClicked?.("sendSms");
+			actor.send({
+				type: "SEND_SMS",
+				phone
+			});
+		},
+		continueOnDesktop() {
+			trackElementClicked?.("continueOnDesktop");
+			actor.send({ type: "CONTINUE_ON_DESKTOP" });
+		},
+		resetSms() {
+			actor.send({ type: "RESET_SMS" });
+		},
+		close() {
+			trackElementClicked?.("close");
+			actor.send({ type: "CLOSE" });
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		}
+	};
+}
+/**
+* Creates a redirect-to-mobile manager for cross-device onboarding flows.
+*
+* On desktop, displays a QR code (and optional SMS input) so the user can
+* continue on their mobile device. Polls the backend until the mobile
+* session completes, then transitions to `finished`.
+*
+* @param options - Configuration for the redirect module
+* @returns A manager instance with state subscription and API methods
+*
+* @example
+* ```ts
+* const manager = createRedirectToMobileManager({
+*   config: { disableSmsOption: false, addContinueToDesktop: true },
+* });
+*
+* manager.subscribe((state) => {
+*   if (state.status === 'redirecting') {
+*     renderQrCode(state.redirectUrl);
+*   }
+*   if (state.status === 'finished') {
+*     console.log('Mobile onboarding complete');
+*   }
+* });
+*
+* manager.load();
+* ```
+*/
+function createRedirectToMobileManager(options) {
+	return createManager({
+		actor: createRedirectToMobileActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.qr)
+	});
+}
+
+//#endregion
+export { createRedirectToMobileManager, redirectToMobileMachine };

package/dist/redirectToMobileStateMachine-BOEqe46A.esm.js

@@ -0,0 +1,249 @@
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-DhNc_x02.esm.js";
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+
+//#region ../infra/src/url/urlUtils.ts
+function getUrlSearchParam(url, param) {
+	try {
+		return new URL(url).searchParams.get(param);
+	} catch {
+		return null;
+	}
+}
+function buildUrlWithSearchParams(baseUrl, params) {
+	const url = new URL(baseUrl);
+	for (const [key, value] of Object.entries(params)) if (value !== void 0) url.searchParams.set(key, value);
+	return url.href;
+}
+
+//#endregion
+//#region src/modules/redirect-to-mobile/redirectToMobileServices.ts
+async function fetchRedirectUrl(signal) {
+	const res = await api.get(endpoints.onboardingUrl, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.onboardingUrl} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function fetchOnboardingStatus(signal) {
+	const res = await api.get(endpoints.onboardingStatus, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.onboardingStatus} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function sendRedirectSms(params, signal) {
+	const res = await api.post(endpoints.sendRedirectSms, params, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.sendRedirectSms} failed: ${res.status} ${res.statusText}`);
+}
+async function addPhoneForRedirect(phone, signal) {
+	const res = await api.post(endpoints.phone, { phone }, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.phone} failed: ${res.status} ${res.statusText}`);
+}
+async function refreshQrUuid(onboardingId, signal) {
+	const res = await api.post(endpoints.qrRefreshUuid, { onboardingId }, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.qrRefreshUuid} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function fetchStartInfo(signal) {
+	const res = await api.get(endpoints.startInfo, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.startInfo} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/redirect-to-mobile/redirectToMobileStateMachine.ts
+const POLL_INTERVAL_MS = 5e3;
+const QR_REFRESH_INTERVAL_MS = 5e3;
+function buildRedirectUrl(baseUrl, customUrl, config, urlUuid) {
+	const uuid = getUrlSearchParam(baseUrl, "uuid") ?? "";
+	return buildUrlWithSearchParams(customUrl ?? baseUrl, {
+		uuid,
+		isRedirect: "true",
+		lang: config.lang,
+		externalId: config.externalId,
+		auth_hint: config.authHint,
+		url_uuid: urlUuid || void 0
+	});
+}
+function extractUuidFromUrl(url) {
+	return getUrlSearchParam(url, "uuid") ?? "";
+}
+const redirectToMobileMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchRedirectUrl: fromPromise(async ({ signal }) => {
+			return fetchRedirectUrl(signal);
+		}),
+		fetchStartInfo: fromPromise(async ({ signal }) => {
+			return fetchStartInfo(signal);
+		}),
+		pollOnboardingStatus: fromCallback(({ sendBack }) => {
+			const timer = BrowserTimerProvider.getInstance();
+			const interval = timer.setInterval(async () => {
+				try {
+					if ((await fetchOnboardingStatus()).onboardingStatus === "ONBOARDING_FINISHED") sendBack({ type: "POLL_TICK" });
+				} catch {}
+			}, POLL_INTERVAL_MS);
+			return () => timer.clearInterval(interval);
+		}),
+		refreshQrUuid: fromCallback(({ sendBack, input }) => {
+			const timer = BrowserTimerProvider.getInstance();
+			const interval = timer.setInterval(async () => {
+				try {
+					const res = await refreshQrUuid(input.uuid);
+					if (res.urlUuid) sendBack({
+						type: "QR_REFRESHED",
+						urlUuid: res.urlUuid
+					});
+				} catch {}
+			}, QR_REFRESH_INTERVAL_MS);
+			return () => timer.clearInterval(interval);
+		}),
+		sendSms: fromPromise(async ({ input, signal }) => {
+			await addPhoneForRedirect(input.phone, signal);
+			const params = input.lang ? [`lang=${input.lang}`] : [];
+			await sendRedirectSms({
+				smsType: "DESKTOP_ONBOARDING",
+				uuid: input.uuid,
+				params
+			}, signal);
+		})
+	},
+	actions: {
+		setBaseUrl: assign(({ context, event }) => {
+			const baseUrl = event.output.url;
+			return {
+				fetchedBaseUrl: baseUrl,
+				uuid: extractUuidFromUrl(baseUrl),
+				redirectUrl: buildRedirectUrl(baseUrl, context.config.url, context.config, context.urlUuid)
+			};
+		}),
+		setStartInfo: assign(({ event }) => {
+			return { phonePrefix: event.output.phonePrefix };
+		}),
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		setSmsSent: assign({ smsSent: () => true }),
+		resetSmsSent: assign({
+			smsSent: () => false,
+			error: () => void 0
+		}),
+		setSmsError: assign(({ event }) => ({ error: String(event.error) })),
+		updateQrUrl: assign(({ context, event }) => {
+			const { urlUuid } = event;
+			return {
+				urlUuid,
+				redirectUrl: buildRedirectUrl(context.fetchedBaseUrl, context.config.url, context.config, urlUuid)
+			};
+		})
+	},
+	guards: { hasPhishingResistance: ({ context }) => context.config.qrPhishingResistance === true }
+}).createMachine({
+	id: "redirectToMobile",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		redirectUrl: "",
+		fetchedBaseUrl: "",
+		uuid: "",
+		urlUuid: "",
+		phonePrefix: "",
+		smsSent: false,
+		error: void 0
+	}),
+	states: {
+		idle: { on: { LOAD: "generatingUrl" } },
+		generatingUrl: { invoke: {
+			id: "fetchRedirectUrl",
+			src: "fetchRedirectUrl",
+			onDone: {
+				target: "loadingStartInfo",
+				actions: "setBaseUrl"
+			},
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		loadingStartInfo: { invoke: {
+			id: "fetchStartInfo",
+			src: "fetchStartInfo",
+			onDone: {
+				target: "showingQr",
+				actions: "setStartInfo"
+			},
+			onError: { target: "showingQr" }
+		} },
+		showingQr: {
+			type: "parallel",
+			states: {
+				polling: {
+					invoke: {
+						id: "pollOnboardingStatus",
+						src: "pollOnboardingStatus"
+					},
+					on: { POLL_TICK: { target: "#redirectToMobile.finished" } }
+				},
+				qrRefresh: {
+					initial: "checking",
+					states: {
+						checking: { always: [{
+							target: "refreshing",
+							guard: "hasPhishingResistance"
+						}, { target: "inactive" }] },
+						refreshing: {
+							invoke: {
+								id: "refreshQrUuid",
+								src: "refreshQrUuid",
+								input: ({ context }) => ({ uuid: context.uuid })
+							},
+							on: { QR_REFRESHED: { actions: "updateQrUrl" } }
+						},
+						inactive: { type: "final" }
+					}
+				},
+				sms: {
+					initial: "idle",
+					states: {
+						idle: { on: { SEND_SMS: "sending" } },
+						sending: { invoke: {
+							id: "sendSms",
+							src: "sendSms",
+							input: ({ context, event }) => ({
+								phone: event.phone,
+								uuid: context.uuid,
+								lang: context.config.lang
+							}),
+							onDone: {
+								target: "sent",
+								actions: "setSmsSent"
+							},
+							onError: {
+								target: "idle",
+								actions: "setSmsError"
+							}
+						} },
+						sent: { on: {
+							SEND_SMS: "sending",
+							RESET_SMS: {
+								target: "idle",
+								actions: "resetSmsSent"
+							}
+						} }
+					}
+				}
+			},
+			on: {
+				CONTINUE_ON_DESKTOP: "closed",
+				CLOSE: "closed"
+			}
+		},
+		finished: { type: "final" },
+		closed: { type: "final" },
+		error: { on: { RETRY: "generatingUrl" } }
+	}
+});
+
+//#endregion
+export { redirectToMobileMachine as t };

package/dist/runChildModule-CqqwqAkW.esm.js

@@ -0,0 +1,219 @@
+import { b as createEventBus, x as getTimestamp } from "./events-D6-e4vok.esm.js";
+import { i as fromCallback, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
+
+//#region src/internal/flow-events/flowEvents.ts
+function createFlowEventBus() {
+	const eventBus = createEventBus();
+	return {
+		clear: eventBus.clear,
+		emit(event) {
+			eventBus.emit({
+				...event,
+				timestamp: getTimestamp()
+			});
+		},
+		subscribe: eventBus.subscribe
+	};
+}
+
+//#endregion
+//#region src/internal/flow-events/attachFlowEventEmitter.ts
+function getFlowId(state) {
+	return state.flow?.flowId;
+}
+function getReadyPayload(state) {
+	const payload = {
+		flow: state.flow,
+		steps: state.steps ?? [],
+		currentStepIndex: state.currentStepIndex ?? -1
+	};
+	if (state.currentStep === void 0) return payload;
+	return {
+		...payload,
+		currentStep: state.currentStep
+	};
+}
+function getCompletedPayload(state) {
+	return state.finishStatus;
+}
+function getActiveModule(state, includeHomeModule) {
+	const includesHome = state.homeScreen?.visible === true;
+	const hasHomeModule = includeHomeModule || includesHome;
+	const totalModules = state.steps !== void 0 ? state.steps.length + (hasHomeModule ? 1 : 0) : void 0;
+	if (includesHome) return {
+		key: "0:HOME",
+		module: "HOME",
+		payload: {
+			moduleIndex: 0,
+			totalModules
+		}
+	};
+	if (state.currentStep === void 0 || state.currentStep === "") return;
+	const moduleIndex = state.currentStepIndex !== void 0 ? state.currentStepIndex + (hasHomeModule ? 1 : 0) : void 0;
+	return {
+		key: `${moduleIndex ?? -1}:${state.currentStep}`,
+		module: state.currentStep,
+		payload: {
+			moduleIndex,
+			totalModules
+		}
+	};
+}
+function attachFlowEventEmitter(manager, options = {}) {
+	const flowEventBus = createFlowEventBus();
+	let hasStartedCurrentRun = false;
+	let hasReadyCurrentRun = false;
+	let hasCompletedCurrentRun = false;
+	let hasErrorCurrentRun = false;
+	let hasClosedCurrentRun = false;
+	let hasHomeModuleCurrentRun = false;
+	let activeModule;
+	let completedModuleKeys = /* @__PURE__ */ new Set();
+	function resetRunFlags() {
+		hasStartedCurrentRun = false;
+		hasReadyCurrentRun = false;
+		hasCompletedCurrentRun = false;
+		hasErrorCurrentRun = false;
+		hasClosedCurrentRun = false;
+		hasHomeModuleCurrentRun = false;
+		activeModule = void 0;
+		completedModuleKeys = /* @__PURE__ */ new Set();
+	}
+	function emitModuleStarted(state) {
+		if (state.homeScreen?.visible === true) hasHomeModuleCurrentRun = true;
+		const nextModule = getActiveModule(state, hasHomeModuleCurrentRun);
+		if (nextModule === void 0) return;
+		if (nextModule.key === activeModule?.key) return;
+		activeModule = nextModule;
+		flowEventBus.emit({
+			type: "flow.module.started",
+			interviewId: options.interviewId,
+			flowId: getFlowId(state),
+			module: nextModule.module,
+			payload: nextModule.payload
+		});
+	}
+	function emitActiveModuleCompleted(state) {
+		if (activeModule === void 0 || completedModuleKeys.has(activeModule.key)) return;
+		completedModuleKeys.add(activeModule.key);
+		flowEventBus.emit({
+			type: "flow.module.completed",
+			interviewId: options.interviewId,
+			flowId: getFlowId(state),
+			module: activeModule.module,
+			payload: activeModule.payload
+		});
+	}
+	function handleState(state) {
+		if (state.status === "idle") {
+			resetRunFlags();
+			return;
+		}
+		if (state.status === "loading" && hasStartedCurrentRun === false) {
+			hasStartedCurrentRun = true;
+			flowEventBus.emit({
+				type: "flow.started",
+				interviewId: options.interviewId
+			});
+			return;
+		}
+		const flow = state.flow;
+		if (state.status === "ready" && flow !== void 0) {
+			const readyState = {
+				...state,
+				flow
+			};
+			const nextModule = getActiveModule(readyState, hasHomeModuleCurrentRun);
+			if (activeModule !== void 0 && nextModule !== void 0 && activeModule.key !== nextModule.key) emitActiveModuleCompleted(readyState);
+			if (hasReadyCurrentRun === false) {
+				hasReadyCurrentRun = true;
+				flowEventBus.emit({
+					type: "flow.ready",
+					interviewId: options.interviewId,
+					flowId: getFlowId(readyState),
+					payload: getReadyPayload(readyState)
+				});
+			}
+			emitModuleStarted(readyState);
+			return;
+		}
+		if (state.status === "finished" && hasCompletedCurrentRun === false) {
+			emitActiveModuleCompleted(state);
+			const payload = getCompletedPayload(state);
+			hasCompletedCurrentRun = true;
+			flowEventBus.emit({
+				type: "flow.completed",
+				interviewId: options.interviewId,
+				flowId: getFlowId(state),
+				...payload !== void 0 ? { payload } : {}
+			});
+			return;
+		}
+		if (state.status === "error" && hasErrorCurrentRun === false) {
+			hasErrorCurrentRun = true;
+			flowEventBus.emit({
+				type: "flow.error",
+				interviewId: options.interviewId,
+				flowId: getFlowId(state),
+				error: state.error ?? "Unknown error"
+			});
+			return;
+		}
+		if (state.status === "closed" && hasClosedCurrentRun === false) {
+			hasClosedCurrentRun = true;
+			flowEventBus.emit({
+				type: "flow.closed",
+				interviewId: options.interviewId,
+				flowId: getFlowId(state)
+			});
+		}
+	}
+	const unsubscribe = manager.subscribe(handleState);
+	const stop = manager.stop.bind(manager);
+	let isStopped = false;
+	Object.defineProperty(manager, "subscribeFlowEvent", {
+		configurable: true,
+		enumerable: true,
+		value: flowEventBus.subscribe,
+		writable: true
+	});
+	Object.defineProperty(manager, "stop", {
+		configurable: true,
+		enumerable: true,
+		value() {
+			if (isStopped) return;
+			isStopped = true;
+			unsubscribe();
+			stop();
+		},
+		writable: true
+	});
+	return manager;
+}
+
+//#endregion
+//#region src/internal/orchestration/runChildModule.ts
+const runChildModule = fromCallback(({ sendBack, input }) => {
+	const { machine, config } = input;
+	if (!machine) return () => {};
+	const actor = createActor(machine, { input: { config } });
+	const subscription = actor.subscribe({
+		complete: () => {
+			sendBack({ type: "MODULE_COMPLETE" });
+		},
+		error: (err) => {
+			sendBack({
+				type: "MODULE_ERROR",
+				error: err
+			});
+		}
+	});
+	actor.start();
+	return () => {
+		subscription.unsubscribe();
+		actor.stop();
+	};
+});
+
+//#endregion
+export { attachFlowEventEmitter as n, runChildModule as t };

package/dist/selfie.d.ts

@@ -0,0 +1,26 @@
+import "./warmup-CEcppFiS.js";
+import "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+import "./StateMachine-BCQrZJhf.js";
+import { C as DetectionStatus, E as FaceErrorCode, T as FaceCapturedImageData, a as SelfieCaptureOnlyMachine, g as SelfieConfig, h as SelfieCaptureOnlyConfig, i as SelfieCaptureOnlyActor, l as SelfieMachine, n as FaceCaptureManagerState, o as selfieCaptureOnlyMachine, r as CreateSelfieCaptureOnlyActorOptions, t as FaceCaptureManager, u as selfieMachine, w as FaceCaptureOnlyResponse } from "./faceCaptureManagerFactory-yqtpxjnN.js";
+import { t as CameraStream } from "./camera-DBSxa6ML.js";
+import "./types-CFV9G_7j.js";
+import "./types-BP1m8VRw.js";
+import { t as DeepsightService } from "./deepsightService-CEVxzehb.js";
+import { n as PermissionStatus, t as PermissionResult } from "./types-CAD4va6a.js";
+import { a as ProcessFaceResponse, n as SelfieState, o as processFace, r as createSelfieManager, t as SelfieManager } from "./selfieManager-D0lSgd-J.js";
+
+//#region src/modules/selfie/selfieCaptureOnlyManager.d.ts
+type SelfieCaptureOnlyState = FaceCaptureManagerState;
+type SelfieCaptureOnlyManager = FaceCaptureManager;
+declare function createSelfieCaptureOnlyManagerFromActor(actor: SelfieCaptureOnlyActor, config: SelfieCaptureOnlyConfig): SelfieCaptureOnlyManager;
+/**
+ * Creates a captureOnly selfie manager.
+ *
+ * Unlike {@link createSelfieManager}, the captured face image is delivered
+ * locally to the integrator's `onCapture` callback instead of being uploaded
+ * to the Incode backend. `onCapture` is required.
+ */
+declare function createSelfieCaptureOnlyManager(options: CreateSelfieCaptureOnlyActorOptions): SelfieCaptureOnlyManager;
+//#endregion
+export { type CameraStream, type DeepsightService, type DetectionStatus, type FaceCaptureOnlyResponse, type FaceCapturedImageData, type FaceErrorCode, type PermissionResult, type PermissionStatus, type ProcessFaceResponse, type SelfieCaptureOnlyConfig, type SelfieCaptureOnlyMachine, type SelfieCaptureOnlyManager, type SelfieCaptureOnlyState, type SelfieConfig, type SelfieMachine, type SelfieManager, type SelfieState, createSelfieCaptureOnlyManager, createSelfieCaptureOnlyManagerFromActor, createSelfieManager, processFace, selfieCaptureOnlyMachine, selfieMachine };