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

package/dist/events-D6-e4vok.esm.js

@@ -0,0 +1,596 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+
+//#region ../infra/src/capabilities/IBrowserEnvironmentCapability.ts
+function getTimestamp() {
+	return Date.now();
+}
+function revokeObjectURL(url) {
+	URL.revokeObjectURL(url);
+}
+
+//#endregion
+//#region src/internal/events/eventBus.ts
+function createEventBus() {
+	const listeners = [];
+	function subscribe(listener) {
+		listeners.push(listener);
+		return () => {
+			const index = listeners.indexOf(listener);
+			if (index > -1) listeners.splice(index, 1);
+		};
+	}
+	function emit(event) {
+		listeners.forEach((listener) => {
+			try {
+				listener(event);
+			} catch {
+				return;
+			}
+		});
+	}
+	function clear() {
+		listeners.length = 0;
+	}
+	return {
+		subscribe,
+		emit,
+		clear
+	};
+}
+
+//#endregion
+//#region src/internal/events/addEvent.ts
+const INTERVIEW_EVENTS_MAX_SCREEN_LENGTH = 50;
+function normalizeScreenForInterviewEventsApi(screenValue) {
+	const limit = INTERVIEW_EVENTS_MAX_SCREEN_LENGTH;
+	if (screenValue.length <= limit) return screenValue;
+	const head = screenValue.slice(0, limit);
+	const lastDot = head.lastIndexOf(".");
+	const lastPlus = head.lastIndexOf("+");
+	const lastBoundary = Math.max(lastDot, lastPlus);
+	if (lastBoundary > 0) return head.slice(0, lastBoundary);
+	return head;
+}
+const eventBus = createEventBus();
+let analyticsBatcher = null;
+/**
+* Buffer for events fired before any batcher has been registered (i.e. before
+* `setup()` runs). Drained into the batcher's own buffer at registration time
+* so these events ride the first flush. Subscribers receive them at emit time
+* regardless.
+*/
+const pendingEvents = [];
+/**
+* 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).
+*/
+function setAnalyticsBatcher(service) {
+	analyticsBatcher?.dispose();
+	analyticsBatcher = service;
+	if (pendingEvents.length > 0) {
+		const drained = pendingEvents.splice(0);
+		for (const entry of drained) service.enqueue(entry);
+	}
+	return service;
+}
+/**
+* Returns the currently-registered analytics batcher, or null if none.
+* Used by `setup()` to reuse an existing batcher across multi-step setup
+* calls instead of disposing the buffered events on re-registration.
+*/
+function getAnalyticsBatcher() {
+	return analyticsBatcher;
+}
+/**
+* Disposes the registered analytics batcher, clears the slot, and drops any
+* events buffered in the pre-registration queue. Used by tests and `reset()`
+* to return the events module to a clean state.
+*/
+function resetAnalyticsBatcher() {
+	analyticsBatcher?.dispose();
+	analyticsBatcher = null;
+	pendingEvents.length = 0;
+}
+/**
+* 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();
+* ```
+*/
+function subscribeEvent(listener) {
+	return eventBus.subscribe(listener);
+}
+/**
+* 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.
+*/
+function addEvent(event) {
+	eventBus.emit(event);
+	const entry = {
+		code: event.code,
+		module: event.module,
+		screen: event.screen !== void 0 ? normalizeScreenForInterviewEventsApi(event.screen) : void 0,
+		clientTimestamp: event.clientTimestamp ?? getTimestamp(),
+		payload: event.payload ?? {}
+	};
+	if (!analyticsBatcher) {
+		pendingEvents.push(entry);
+		return;
+	}
+	analyticsBatcher.enqueue(entry);
+}
+
+//#endregion
+//#region src/internal/events/AnalyticsBatchingService.ts
+const DEFAULT_MAX_BATCH_SIZE = 50;
+const DEFAULT_MAX_BATCH_AGE_MS = 1e3;
+const DEFAULT_MAX_RETRIES = 2;
+const RETRY_BASE_DELAY_MS = 250;
+function isTransientStatus(status) {
+	return status === 0 || status >= 500 || status === 408 || status === 429;
+}
+function createAnalyticsBatchingService(options) {
+	const { endpoint, authToken, pageLifecycle, timer, apiBaseUrl, apiClient = api, maxBatchSize = DEFAULT_MAX_BATCH_SIZE, maxBatchAgeMs = DEFAULT_MAX_BATCH_AGE_MS, maxRetries = DEFAULT_MAX_RETRIES } = options;
+	let buffer = [];
+	let started = false;
+	let disposed = false;
+	let ageTimerHandle = null;
+	let unsubscribeLifecycle = null;
+	let warnedNullToken = false;
+	function clearAgeTimer() {
+		if (ageTimerHandle !== null) {
+			timer.clearTimeout(ageTimerHandle);
+			ageTimerHandle = null;
+		}
+	}
+	function armAgeTimerIfNeeded() {
+		if (ageTimerHandle === null) ageTimerHandle = timer.setTimeout(() => {
+			ageTimerHandle = null;
+			flush();
+		}, maxBatchAgeMs);
+	}
+	function dropTokenless() {
+		if (!warnedNullToken) {
+			warnedNullToken = true;
+			console.warn("[AnalyticsBatchingService] Dropping batch: no auth token at flush time.");
+		}
+	}
+	function sendBatch(batch, attempt) {
+		let promise;
+		try {
+			promise = apiClient.post(endpoint, batch, { keepalive: true });
+		} catch (error) {
+			handleSendError(batch, error, attempt);
+			return;
+		}
+		promise.catch((error) => handleSendError(batch, error, attempt));
+	}
+	function handleSendError(batch, error, attempt) {
+		if (disposed) return;
+		if (!isTransientStatus(error && typeof error === "object" && "status" in error ? Number(error.status) || 0 : 0)) return;
+		if (attempt >= maxRetries) return;
+		const delay = RETRY_BASE_DELAY_MS * 2 ** attempt;
+		timer.setTimeout(() => {
+			if (disposed) return;
+			sendBatch(batch, attempt + 1);
+		}, delay);
+	}
+	function flush() {
+		if (disposed || buffer.length === 0) return;
+		const batch = buffer;
+		buffer = [];
+		clearAgeTimer();
+		if (!authToken()) {
+			dropTokenless();
+			return;
+		}
+		sendBatch(batch, 0);
+	}
+	function handlePageHide() {
+		if (disposed || buffer.length === 0) return;
+		const batch = buffer;
+		buffer = [];
+		clearAgeTimer();
+		const token = authToken();
+		if (!token) {
+			dropTokenless();
+			return;
+		}
+		const url = `${apiBaseUrl().replace(/\/$/, "")}${endpoint}`;
+		const body = JSON.stringify({
+			token,
+			events: batch
+		});
+		pageLifecycle.sendBeacon(url, body);
+	}
+	function enqueue(entry) {
+		if (disposed) return;
+		buffer.push(entry);
+		if (!started) return;
+		if (buffer.length >= maxBatchSize) {
+			flush();
+			return;
+		}
+		armAgeTimerIfNeeded();
+	}
+	function start() {
+		if (started || disposed) return;
+		started = true;
+		unsubscribeLifecycle = pageLifecycle.onPageHide(handlePageHide);
+		if (buffer.length > 0) flush();
+	}
+	function dispose() {
+		if (disposed) return;
+		disposed = true;
+		clearAgeTimer();
+		unsubscribeLifecycle?.();
+		unsubscribeLifecycle = null;
+		buffer = [];
+	}
+	return {
+		enqueue,
+		start,
+		flush,
+		dispose
+	};
+}
+
+//#endregion
+//#region src/internal/events/helpers.ts
+function screenEvent(params) {
+	addEvent({
+		code: params.code,
+		module: params.module,
+		screen: params.screen,
+		clientTimestamp: getTimestamp(),
+		payload: params.payload
+	});
+}
+function moduleOpened(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "moduleOpened",
+		payload
+	});
+}
+function moduleClosed(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "moduleClosed",
+		payload
+	});
+}
+function screenOpened(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "screenOpened",
+		payload
+	});
+}
+function screenClosed(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "screenClosed",
+		payload
+	});
+}
+function errorTriggered(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "errorTriggered",
+		payload
+	});
+}
+function elementClicked(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "elementClicked",
+		payload
+	});
+}
+function captureAttemptFinished(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "captureAttemptFinished",
+		payload
+	});
+}
+
+//#endregion
+//#region src/internal/events/managerInstrumentation.ts
+function normalizeSegment(segment) {
+	if (typeof segment !== "string") return "";
+	return segment.trim().replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function normalizeDottedPath(path) {
+	return path.split("+").map((branch) => branch.split(".").map((segment) => normalizeSegment(segment)).filter((segment) => segment.length > 0).join(".")).filter((branch) => branch.length > 0).join("+");
+}
+function stateValueToScreenSegment(value) {
+	if (typeof value === "string" || typeof value === "number") {
+		const segment = normalizeSegment(String(value));
+		return segment.length > 0 ? segment : void 0;
+	}
+	if (typeof value !== "object" || value === null) return;
+	const entries = Object.entries(value).sort(([left], [right]) => {
+		if (left < right) return -1;
+		if (left > right) return 1;
+		return 0;
+	});
+	if (entries.length === 0) return;
+	const branches = entries.map(([key, nestedValue]) => {
+		const normalizedKey = normalizeSegment(key);
+		const nestedSegment = stateValueToScreenSegment(nestedValue);
+		if (normalizedKey.length === 0) return nestedSegment;
+		if (nestedSegment === void 0) return normalizedKey;
+		return `${normalizedKey}.${nestedSegment}`;
+	}).filter((branch) => branch !== void 0 && branch.length > 0);
+	if (branches.length === 0) return;
+	return branches.join("+");
+}
+function buildScreenName(moduleName, screenName) {
+	const normalizedModuleName = typeof moduleName === "string" ? moduleName.trim() : "";
+	const normalizedScreen = normalizeDottedPath(screenName);
+	if (normalizedModuleName.length === 0) return normalizedScreen;
+	if (normalizedScreen.length === 0) return normalizedModuleName;
+	return `${normalizedModuleName}.${normalizedScreen}`;
+}
+function getDefaultManagerScreenName(snapshot) {
+	return stateValueToScreenSegment(snapshot.value);
+}
+function getManagerScreenName(moduleName, snapshot, options) {
+	const eventScreen = options?.getEventScreenName?.(snapshot);
+	if (eventScreen !== void 0) return eventScreen;
+	const mappedScreen = options?.getScreenName?.(snapshot) ?? getDefaultManagerScreenName(snapshot);
+	if (mappedScreen === void 0) return;
+	return buildScreenName(moduleName, mappedScreen);
+}
+function isErrorLikeSegment(segment) {
+	return segment === "error" || segment.includes("error") || segment.includes("failed") || segment.includes("failure");
+}
+function getDefaultManagerErrorName(snapshot) {
+	const screenSegment = stateValueToScreenSegment(snapshot.value);
+	if (screenSegment === void 0) return;
+	const normalizedSegment = normalizeDottedPath(screenSegment);
+	if (normalizedSegment.length === 0) return;
+	if (normalizedSegment === "error") return "error.unknown";
+	if (!isErrorLikeSegment(normalizedSegment)) return;
+	return `error.${normalizedSegment}`;
+}
+function createManagerInstrumentation(moduleName, options) {
+	return {
+		moduleName,
+		onModuleOpened: moduleOpened,
+		onModuleClosed: moduleClosed,
+		onScreenOpened: screenOpened,
+		onScreenClosed: screenClosed,
+		onErrorTriggered: errorTriggered,
+		onElementClicked: (moduleName$1, screenName, payload) => elementClicked(moduleName$1, screenName, payload),
+		onCaptureAttemptFinished: (moduleName$1, screenName, payload) => captureAttemptFinished(moduleName$1, screenName, payload),
+		getScreenName: (snapshot) => getManagerScreenName(moduleName, snapshot, {
+			getEventScreenName: options?.getEventScreenName,
+			getScreenName: options?.getScreenName
+		}),
+		getErrorName: (snapshot) => {
+			const mappedError = options?.getErrorName?.(snapshot) ?? getDefaultManagerErrorName(snapshot);
+			if (mappedError === void 0) return;
+			return buildScreenName(moduleName, mappedError);
+		},
+		getErrorPayload: (snapshot) => options?.getErrorPayload?.(snapshot)
+	};
+}
+
+//#endregion
+//#region src/internal/events/types.ts
+const eventModuleNames = {
+	selfie: "SELFIE",
+	faceCapture: "faceCapture",
+	authentication: "AUTHENTICATION",
+	authFace: "authFace",
+	mlConsent: "ML_CONSENT",
+	combinedConsent: "COMBINED_CONSENT",
+	curpValidation: "CURP_VALIDATION",
+	faceMatch: "FACE_MATCH",
+	qr: "QR",
+	videoSelfie: "VIDEO_ONBOARDING",
+	passport: "ID",
+	front: "ID",
+	back: "ID",
+	id: "ID",
+	idCapture: "idCapture",
+	idOcr: "ID_OCR",
+	document: "DOCUMENT_CAPTURE",
+	creditCard: "CREDIT_CARD_FRONT",
+	creditCardBack: "CREDIT_CARD_BACK",
+	conference: "CONFERENCE",
+	otp: "OTP",
+	signature: "SIGNATURE",
+	ekyc: "EXTERNAL_VERIFICATION",
+	watchlist: "WATCHLIST",
+	globalWatchList: "GLOBAL_WATCHLIST",
+	customWatchList: "CUSTOM_WATCHLIST",
+	email: "EMAIL",
+	phone: "PHONE",
+	instantVerifyEmail: "INSTANT_VERIFY_EMAIL",
+	instantVerifyConsent: "INSTANT_VERIFY_CONSENT",
+	forms: "FORMS",
+	customModule: "CUSTOM_MODULE",
+	geolocation: "GEOLOCATION",
+	ekyb: "EKYB",
+	identityReuse: "IDENTITY_REUSE",
+	antifraud: "ANTIFRAUD",
+	aeSignature: "AE_SIGNATURE",
+	qeSignature: "QE_SIGNATURE",
+	crossDocumentDataMatch: "CROSS_DOCUMENT_DATA_MATCH",
+	customFields: "CUSTOM_FIELDS",
+	watchlistForBusiness: "WATCHLIST_FOR_BUSINESS",
+	trustGraph: "TRUST_GRAPH"
+};
+const eventScreenNames = {
+	faceMatch: "FACE_MATCH",
+	faceCaptureTutorial: "SELFIE_CAPTURE_TUTORIAL",
+	faceCaptureCamera: "SELFIE_CAMERA_CAPTURE",
+	faceCaptureError: "SELFIE_ATTEMPT_FAILED",
+	faceCaptureSuccess: "SELFIE_UPLOAD_SUCCEEDED",
+	faceCaptureUpload: "SELFIE_UPLOAD_PROGRESS",
+	mlConsent: "MACHINE_LEARNING_CONSENT",
+	combinedConsent: "COMBINED_CONSENT",
+	curpEnter: "ENTER_CURP",
+	curpValidate: "VALIDATE_CURP",
+	curpGenerate: "GENERATE_CURP",
+	curpValidation: "CURP_VALIDATION_PROGRESS",
+	curpValidationFailed: "CURP_VALIDATION_FAILED",
+	curpValidationSuccess: "CURP_VALIDATION_SUCCEEDED",
+	qrTutorial: "QR_TUTORIAL",
+	qrScan: "QR_SCAN",
+	smsOtp: "OTP",
+	simpleOTP: "OTP",
+	signatureInput: "SIGNATURE_INPUT",
+	frontTutorial: "FRONT_ID_CAPTURE_TUTORIAL",
+	frontCameraCapture: "FRONT_ID_CAMERA_CAPTURE",
+	frontHelp: "FRONT_ID_HELP",
+	frontReviewPhoto: "FRONT_ID_REVIEW_PHOTO",
+	frontUploadProgress: "FRONT_ID_UPLOAD_PROGRESS",
+	frontAttemptFailed: "FRONT_ID_ATTEMPT_FAILED",
+	frontUploadSuccess: "FRONT_ID_UPLOAD_SUCCEEDED",
+	backTutorial: "BACK_ID_CAPTURE_TUTORIAL",
+	backCameraCapture: "BACK_ID_CAMERA_CAPTURE",
+	backReviewPhoto: "BACK_ID_REVIEW_PHOTO",
+	backUploadProgress: "BACK_ID_UPLOAD_PROGRESS",
+	backAttemptFailed: "BACK_ID_ATTEMPT_FAILED",
+	backUploadSuccess: "BACK_ID_UPLOAD_SUCCEEDED",
+	backHelp: "BACK_ID_HELP",
+	passportTutorial: "TUTORIAL_PASSPORT",
+	documentTutorial: "DOCUMENT_CAPTURE_TUTORIAL",
+	documentCameraCapture: "DOCUMENT_CAMERA_CAPTURE",
+	documentHelp: "DOCUMENT_HELP",
+	documentReviewPhoto: "DOCUMENT_REVIEW_PHOTO",
+	documentUploadProgress: "DOCUMENT_UPLOAD_IN_PROGRESS",
+	documentAttemptFailed: "DOCUMENT_ATTEMPT_FAILED",
+	documentUploadSuccess: "DOCUMENT_UPLOAD_SUCCEEDED",
+	conferenceWait: "CONFERENCE_WAIT",
+	conferenceVideoChat: "CONFERENCE_VIDEO_CHAT",
+	conferenceMessageChat: "CONFERENCE_MESSAGE_CHAT",
+	videoSelfieTutorial: "VIDEO_SELFIE_TUTORIAL",
+	videoSelfie: "VIDEO_SELFIE",
+	videoSelfieFaceCapture: "VIDEO_SELFIE_FACE_CAPTURE",
+	videoSelfieFaceUploadProgress: "VIDEO_SELFIE_FACE_UPLOAD_PROGRESS",
+	videoSelfieFaceAttemptFailed: "VIDEO_SELFIE_FACE_ATTEMPT_FAILED",
+	videoSelfieFaceUploadSucceeded: "VIDEO_SELFIE_FACE_UPLOAD_SUCCEEDED",
+	videoSelfieFrontIdCapture: "VIDEO_SELFIE_FRONT_ID_CAPTURE",
+	videoSelfieFrontIdUploadProgress: "VIDEO_SELFIE_FRONT_ID_UPLOAD_PROGRESS",
+	videoSelfieFrontIdAttemptFailed: "VIDEO_SELFIE_FRONT_ID_ATTEMPT_FAILED",
+	videoSelfieFrontIdUploadSucceeded: "VIDEO_SELFIE_FRONT_ID_UPLOAD_SUCCEEDED",
+	videoSelfieBackIdCapture: "VIDEO_SELFIE_BACK_ID_CAPTURE",
+	videoSelfieBackIdUploadProgress: "VIDEO_SELFIE_BACK_ID_UPLOAD_PROGRESS",
+	videoSelfieBackIdAttemptFailed: "VIDEO_SELFIE_BACK_ID_ATTEMPT_FAILED",
+	videoSelfieBackIdUploadSucceeded: "VIDEO_SELFIE_BACK_ID_UPLOAD_SUCCEEDED",
+	videoSelfieDocumentCapture: "VIDEO_SELFIE_DOCUMENT_CAPTURE",
+	videoSelfieVoiceQuestion: "VIDEO_SELFIE_VOICE_QUESTION",
+	videoSelfieVoiceFinalQuestion: "VIDEO_SELFIE_VOICE_FINAL_QUESTION",
+	videoSelfieVideoUpload: "VIDEO SELFIE VIDEO UPLOAD",
+	ekycInput: "EKYC_INPUT",
+	ekycProgress: "EKYC_PROGRESS",
+	ekycSucceeded: "EKYC_SUCCEEDED",
+	ekycFailed: "EKYC_FAILED",
+	forms: "FORMS",
+	globalWatchListInput: "GLOBAL_WATCHLIST_INPUT",
+	globalWatchListProgress: "GLOBAL_WATCHLIST_PROGRESS",
+	globalWatchListSuccess: "GLOBAL_WATCHLIST_SUCCEEDED",
+	globalWatchListFailed: "GLOBAL_WATCHLIST_FAILED",
+	customWatchListInput: "CUSTOM_WATCHLIST_INPUT",
+	customWatchListProgress: "CUSTOM_WATCHLIST_PROGRESS",
+	customWatchListSuccess: "CUSTOM_WATCHLIST_SUCCEEDED",
+	customWatchListFailed: "CUSTOM_WATCHLIST_FAILED",
+	emailInput: "EMAIL_INPUT",
+	phoneInput: "PHONE_INPUT",
+	instantVerify: "INSTANT_VERIFY",
+	authFace: "AUTH_FACE",
+	authFaceError: "AUTH_FACE_ATTEMPT_FAILED",
+	authFaceUpload: "AUTH_FACE_UPLOAD_PROGRESS",
+	authFaceUploadSuccess: "AUTH_FACE_UPLOAD_SUCCEEDED",
+	authFaceUploadFailed: "AUTH_FACE_UPLOAD_FAILED",
+	authFaceTutorial: "AUTH_FACE_TUTORIAL",
+	customModuleCallback: "CUSTOM_MODULE_CALLBACK",
+	customModuleProcessing: "CUSTOM_MODULE_PROCESSING",
+	digitalIdFileSelection: "DIGITAL_ID_FILE_SELECTION",
+	digitalIdFileReview: "DIGITAL_ID_FILE_REVIEW",
+	digitalIdUploadProgress: "DIGITAL_ID_UPLOAD_PROGRESS",
+	digitalIdUploadSuccess: "DIGITAL_ID_UPLOAD_SUCCEEDED",
+	digitalIdUploadFailed: "DIGITAL_ID_UPLOAD_FAILED",
+	digitalIdAnalysisProgress: "DIGITAL_ID_ANALYSIS_PROGRESS",
+	digitalIdVerificationSuccess: "DIGITAL_ID_VERIFICATION_SUCCESS",
+	digitalIdVerificationFailed: "DIGITAL_ID_VERIFICATION_FAILED",
+	ekybForm: "EKYB_FORM"
+};
+const videoSelfieEvents = {
+	imageTooBlurry: "imageTooBlurry",
+	fillFrame: "fillFrame",
+	checkCameraOrLighting: "checkCameraOrLighting",
+	frontIdCaptureStarted: "frontIdCaptureStarted",
+	lookAtCamera: "lookAtCamera",
+	moveCloser: "moveCloser",
+	lookingForFrontId: "lookingForFrontId",
+	lookingForBackId: "lookingForBackId",
+	cameraSwitchToBack: "cameraSwitchToBack",
+	cameraSwitchToFront: "cameraSwitchToFront",
+	audioStreamOpened: "audioStreamOpened",
+	audioStreamClosed: "audioStreamClosed",
+	videoSelfieVideoUploadInProgress: "videoSelfieVideoUploadInProgress",
+	videoSelfieTosNotAccepted: "videoSelfieTosNotAccepted",
+	videoSelfieTosAccepted: "videoSelfieTosAccepted",
+	videoSelfieStreamCreated: "videoSelfieStreamCreated",
+	videoSelfieStreamDestroyed: "videoSelfieStreamDestroyed",
+	videoSelfieReconnecting: "videoSelfieReconnecting",
+	videoSelfieReconnected: "videoSelfieReconnected"
+};
+const tutorialScreenNamesMapper = {
+	passport: eventScreenNames.passportTutorial,
+	front: eventScreenNames.frontTutorial,
+	back: eventScreenNames.backTutorial,
+	selfie: eventScreenNames.faceCaptureTutorial
+};
+const cameraScreenNamesMapper = {
+	front: "front",
+	back: "back",
+	passport: "passport",
+	creditCard: "front",
+	creditCardBack: "back",
+	document: "document"
+};
+
+//#endregion
+export { revokeObjectURL as S, resetAnalyticsBatcher as _, videoSelfieEvents as a, createEventBus as b, elementClicked as c, screenClosed as d, screenEvent as f, getAnalyticsBatcher as g, addEvent as h, tutorialScreenNamesMapper as i, moduleClosed as l, createAnalyticsBatchingService as m, eventModuleNames as n, createManagerInstrumentation as o, screenOpened as p, eventScreenNames as r, captureAttemptFinished as s, cameraScreenNamesMapper as t, moduleOpened as u, setAnalyticsBatcher as v, getTimestamp as x, subscribeEvent as y };