@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/flowCompletionService-DhkT4SRY.d.ts

@@ -0,0 +1,10 @@
+//#region src/modules/flow/flowCompletionService.d.ts
+type FinishStatus = {
+  redirectionUrl: string;
+  action: 'approved' | 'rejected' | 'none';
+  scoreStatus: 'OK' | 'WARN' | 'MANUAL_OK' | 'FAIL' | 'UNKNOWN' | 'MANUAL_FAIL';
+};
+type GetFinishStatusFn = (flowId: string | undefined | null, signal?: AbortSignal) => Promise<FinishStatus>;
+declare const getFinishStatus: GetFinishStatusFn;
+//#endregion
+export { GetFinishStatusFn as n, getFinishStatus as r, FinishStatus as t };

package/dist/flowCompletionService-P54yzGvA.esm.js

@@ -0,0 +1,13 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+
+//#region src/modules/flow/flowCompletionService.ts
+const getFinishStatus = async (flowId, signal) => {
+	const url = `${endpoints.finishStatus}${flowId ? `?flowId=${flowId}` : ""}`;
+	const res = await api.get(url, { signal });
+	if (!res.ok) throw new Error(`GET ${url} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+};
+
+//#endregion
+export { getFinishStatus as t };

package/dist/flowServices-DG3IdWw6.esm.js

@@ -0,0 +1,188 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { n as getSessionFingerprintResult, r as initializeSession } from "./session-CGtQJJzB.esm.js";
+
+//#region src/modules/flow/flowUtils.ts
+const WASM_MODULE_PIPELINES = {
+	SELFIE: "selfie",
+	AUTHENTICATION: "selfie",
+	FACE_MATCH: "selfie",
+	VIDEO_ONBOARDING: "selfie",
+	ID: "idCapture",
+	TUTORIAL_ID: "idCapture",
+	SECOND_ID: "idCapture"
+};
+const FACE_MODULES_WITH_ON_DEVICE_VARIANT = new Set(["SELFIE", "AUTHENTICATION"]);
+function isOnDeviceFaceModule(module) {
+	if (!FACE_MODULES_WITH_ON_DEVICE_VARIANT.has(module.key)) return false;
+	return module.configuration?.onDeviceFaceResultsSubmissionEnabled === true;
+}
+/**
+* Analyzes a flow configuration and returns the WASM pipelines needed.
+* Use this to conditionally warmup WASM only when required by the flow.
+*
+* Modules with `onDeviceFaceResultsSubmissionEnabled: true` (currently SELFIE
+* and AUTHENTICATION) select the 6-model `'onDeviceSelfie'` bundle instead of
+* the default 4-model `'selfie'` bundle.
+*
+* @param flow - The flow configuration from /omni/onboarding/flow
+* @returns Array of WASM pipelines needed (e.g., ['selfie', 'idCapture'])
+*
+* @example
+* ```typescript
+* const pipelines = getRequiredWasmPipelines(flow);
+* if (pipelines.length > 0) {
+*   warmupWasm({ ...wasmConfig, pipelines });
+* }
+* ```
+*/
+function getRequiredWasmPipelines(flow) {
+	const pipelines = /* @__PURE__ */ new Set();
+	for (const module of flow.flowModules) {
+		if (isOnDeviceFaceModule(module)) {
+			pipelines.add("onDeviceSelfie");
+			continue;
+		}
+		const pipeline = WASM_MODULE_PIPELINES[module.key];
+		if (pipeline) pipelines.add(pipeline);
+	}
+	return [...pipelines];
+}
+/**
+* Normalizes flow modules by expanding TUTORIAL_ID into ID + SECOND_ID
+* based on configuration flags. Matches legacy flowService behavior.
+*
+* - TUTORIAL_ID becomes ID (with same config)
+* - If secondId: true, adds SECOND_ID module with isSecondId: true
+* - thirdId is deprecated and ignored; the flow continues to the next step
+* - Bare ID following TUTORIAL_ID is dropped (already merged)
+*/
+function normalizeFlowModules(flow, options = {}) {
+	let modules = normalizeIdModules(flow.flowModules);
+	modules = normalizeCpfModules(modules, options);
+	modules = dropWatchlistBusinessIfEkyb(modules);
+	if (shouldInjectRedirect(flow, modules, options)) modules = addRedirect(flow, modules, options);
+	return modules;
+}
+/**
+* Drops WATCHLIST_BUSINESS when EKYB is present in the same flow.
+* The EKYB module performs a superset of the watchlist-for-business check,
+* so running both would be redundant.
+*/
+function dropWatchlistBusinessIfEkyb(modules) {
+	if (!hasModule(modules, "EKYB")) return modules;
+	return modules.filter((m) => m.key !== "WATCHLIST_BUSINESS");
+}
+function normalizeIdModules(modules) {
+	return modules.flatMap((module, idx, arr) => {
+		if (module.key === "TUTORIAL_ID") {
+			const idConfig = module.configuration;
+			const result = [{
+				key: "ID",
+				configuration: idConfig
+			}];
+			if (idConfig.secondId) result.push({
+				key: "SECOND_ID",
+				configuration: {
+					...idConfig,
+					isSecondId: true
+				}
+			});
+			return result;
+		}
+		const prev = arr[idx - 1];
+		if (module.key === "ID" && prev?.key === "TUTORIAL_ID") return [];
+		return [module];
+	});
+}
+function normalizeCpfModules(modules, options) {
+	if (options.useCPF !== true) return modules;
+	return modules.map((module) => module.key === "ID_OCR" ? {
+		key: "CPF_OCR",
+		configuration: {}
+	} : module);
+}
+function shouldInjectRedirect(flow, modules, options) {
+	return options.isDesktop === true && flow.redirectDesktopToMobile === true && !hasModule(modules, "REDIRECT_TO_MOBILE");
+}
+function addRedirect(flow, modules, options) {
+	return [{
+		key: "REDIRECT_TO_MOBILE",
+		configuration: {
+			flowId: flow.flowId,
+			disableSmsOption: flow.disableSmsOption ?? false,
+			addContinueToDesktop: flow.addContinueToDesktop ?? false,
+			qrPhishingResistance: flow.qrPhishingResistance ?? false,
+			authHint: options.authHint,
+			lang: options.lang
+		}
+	}, ...modules];
+}
+function hasModule(modules, key) {
+	return modules.some((module) => module.key === key);
+}
+
+//#endregion
+//#region src/modules/flow/flowServices.ts
+const REGULATION_TYPES = [
+	"US",
+	"Worldwide",
+	"Other",
+	"US_Illinois",
+	"US_Texas",
+	"US_California",
+	"US_Washington"
+];
+const REGULATION_TYPE_ALIASES = {
+	us: "US",
+	worldwide: "Worldwide",
+	worldwide_consent: "Worldwide",
+	other: "Other",
+	us_illinois: "US_Illinois",
+	usillinois: "US_Illinois",
+	us_texas: "US_Texas",
+	ustexas: "US_Texas",
+	us_california: "US_California",
+	uscalifornia: "US_California",
+	us_washington: "US_Washington",
+	uswashington: "US_Washington"
+};
+function toRegulationType(value) {
+	if (!value) return "Other";
+	if (REGULATION_TYPES.includes(value)) return value;
+	return REGULATION_TYPE_ALIASES[value.trim().toLowerCase().replace(/[\s-]+/g, "_")] ?? "Other";
+}
+function prependMandatoryConsent(flow) {
+	if (flow.mandatoryConsentCheck === false) return flow;
+	const fingerprintResult = getSessionFingerprintResult();
+	if (!fingerprintResult?.showMandatoryConsent) return flow;
+	if (flow.flowModules.find((module) => module.key === "MANDATORY_CONSENT")) return flow;
+	const mandatoryConsentModule = {
+		key: "MANDATORY_CONSENT",
+		configuration: { consentType: toRegulationType(fingerprintResult.regulationType) }
+	};
+	return {
+		...flow,
+		flowModules: [mandatoryConsentModule, ...flow.flowModules]
+	};
+}
+const getFlow = async (signal, options = {}) => {
+	const sessionPromise = initializeSession({ signal }).catch(() => void 0);
+	const res = await api.get(endpoints.flow, { signal });
+	if (!res.ok) throw new Error(`GET /flow failed: ${res.status} ${res.statusText}`);
+	const data = res.data;
+	if (data.mandatoryConsentCheck !== false) await sessionPromise;
+	const flow = prependMandatoryConsent(data);
+	const normalizedModules = normalizeFlowModules(flow, options);
+	console.log({
+		...flow,
+		flowModules: normalizedModules
+	});
+	return {
+		...flow,
+		flowModules: normalizedModules
+	};
+};
+
+//#endregion
+export { getRequiredWasmPipelines as n, normalizeFlowModules as r, getFlow as t };

package/dist/geolocation.d.ts

@@ -0,0 +1,127 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+
+//#region ../infra/src/capabilities/IGeolocationCapability.d.ts
+type GeolocationCoords = {
+  latitude: number;
+  longitude: number;
+};
+type IGeolocationCapability = {
+  getCurrentPosition(): Promise<GeolocationCoords>;
+};
+//#endregion
+//#region src/modules/geolocation/types.d.ts
+/**
+ * Configuration options for the Geolocation module.
+ *
+ * @example
+ * ```typescript
+ * const config: GeolocationConfig = {
+ *   allowUserToSkipGeolocation: true,
+ * };
+ * ```
+ */
+type GeolocationConfig = {
+  /**
+   * Whether the user is allowed to skip geolocation capture.
+   * When true, a skip button is shown on the permission-denied screen.
+   * Backend field name from flow/workflow configuration.
+   * @default false
+   */
+  allowUserToSkipGeolocation?: boolean;
+};
+//#endregion
+//#region src/modules/geolocation/geolocationStateMachine.d.ts
+type GeolocationDeviceType = 'ios' | 'android' | 'desktop';
+declare const geolocationMachine: any;
+//#endregion
+//#region src/modules/geolocation/geolocationActor.d.ts
+type CreateGeolocationActorOptions = {
+  config: GeolocationConfig;
+  geolocation?: IGeolocationCapability;
+};
+//#endregion
+//#region src/modules/geolocation/geolocationManager.d.ts
+/** Geolocation manager is in initial state, waiting for `request()` to be called */
+type GeolocationIdleState = {
+  status: 'idle';
+};
+/** Browser geolocation permission prompt is active */
+type GeolocationRequestingState = {
+  status: 'requestingLocation';
+};
+/** Coordinates are being submitted to the backend */
+type GeolocationSubmittingState = {
+  status: 'submitting';
+};
+/**
+ * Location successfully acquired — call `continue()` to proceed
+ * @property location - Location name returned from backend, or 'Unknown'
+ */
+type GeolocationAcquiredState = {
+  status: 'locationAcquired';
+  location: string;
+};
+/**
+ * User denied geolocation permission — shows device-specific instructions
+ * @property deviceType - Used by UI to render the correct instruction panel
+ * @property canSkip - Whether the skip button should be shown
+ */
+type GeolocationPermissionDeniedState = {
+  status: 'permissionDenied';
+  deviceType: GeolocationDeviceType;
+  canSkip: boolean;
+};
+/** Geolocation flow completed successfully */
+type GeolocationFinishedState = {
+  status: 'finished';
+};
+/**
+ * Union of all possible geolocation manager states.
+ *
+ * @example
+ * ```typescript
+ * const state = geolocationManager.getState();
+ * if (state.status === 'locationAcquired') {
+ *   console.log(state.location);
+ * }
+ * if (state.status === 'permissionDenied') {
+ *   console.log(state.deviceType); // 'ios' | 'android' | 'desktop'
+ * }
+ * ```
+ */
+type GeolocationState = GeolocationIdleState | GeolocationRequestingState | GeolocationSubmittingState | GeolocationAcquiredState | GeolocationPermissionDeniedState | GeolocationFinishedState;
+/**
+ * Creates a geolocation manager for headless or UI-driven usage.
+ *
+ * @example Headless usage
+ * ```typescript
+ * const manager = createGeolocationManager({ config: { allowUserToSkipGeolocation: true } });
+ * manager.subscribe((state) => console.log(state.status));
+ * manager.request();
+ * ```
+ */
+declare function createGeolocationManager(options: CreateGeolocationActorOptions): Manager<GeolocationState> & {
+  /**
+   * Initiates the browser geolocation permission request.
+   * Transitions from 'idle' to 'requestingLocation'.
+   */
+  request(): void;
+  /**
+   * Confirms the acquired location and completes the module.
+   * Should be called when state is 'locationAcquired'.
+   */
+  continue(): void;
+  /**
+   * Skips geolocation when the user has denied permission.
+   * Only works when `config.allowUserToSkipGeolocation` is true.
+   */
+  skip(): void;
+  /**
+   * Resets the manager back to initial state.
+   */
+  reset(): void;
+};
+type GeolocationManager = ReturnType<typeof createGeolocationManager>;
+//#endregion
+export { type GeolocationConfig, type GeolocationManager, type GeolocationState, createGeolocationManager, geolocationMachine };

package/dist/geolocation.esm.js

@@ -0,0 +1,89 @@
+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 "./platform-CfrjKhmi.esm.js";
+import { t as geolocationMachine } from "./geolocationStateMachine-asasuHY2.esm.js";
+
+//#region ../infra/src/providers/browser/BrowserGeolocationProvider.ts
+var BrowserGeolocationProvider = class {
+	getCurrentPosition() {
+		return new Promise((resolve, reject) => {
+			navigator.geolocation.getCurrentPosition((pos) => resolve({
+				latitude: pos.coords.latitude,
+				longitude: pos.coords.longitude
+			}), reject);
+		});
+	}
+};
+
+//#endregion
+//#region src/modules/geolocation/geolocationActor.ts
+function createGeolocationActor(options) {
+	const geolocation = options.geolocation ?? new BrowserGeolocationProvider();
+	return createActor(geolocationMachine, { input: {
+		config: options.config,
+		geolocation
+	} }).start();
+}
+
+//#endregion
+//#region src/modules/geolocation/geolocationManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("requestingLocation")) return { status: "requestingLocation" };
+	if (typedSnapshot.matches("submitting")) return { status: "submitting" };
+	if (typedSnapshot.matches("locationAcquired")) return {
+		status: "locationAcquired",
+		location: context.location ?? "Unknown"
+	};
+	if (typedSnapshot.matches("permissionDenied")) return {
+		status: "permissionDenied",
+		deviceType: context.deviceType,
+		canSkip: context.config.allowUserToSkipGeolocation === true
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		request() {
+			trackElementClicked?.("request");
+			actor.send({ type: "REQUEST" });
+		},
+		continue() {
+			trackElementClicked?.("continue");
+			actor.send({ type: "CONTINUE" });
+		},
+		skip() {
+			trackElementClicked?.("skip");
+			actor.send({ type: "SKIP" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		}
+	};
+}
+/**
+* Creates a geolocation manager for headless or UI-driven usage.
+*
+* @example Headless usage
+* ```typescript
+* const manager = createGeolocationManager({ config: { allowUserToSkipGeolocation: true } });
+* manager.subscribe((state) => console.log(state.status));
+* manager.request();
+* ```
+*/
+function createGeolocationManager(options) {
+	return createManager({
+		actor: createGeolocationActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.geolocation)
+	});
+}
+
+//#endregion
+export { createGeolocationManager, geolocationMachine };

package/dist/geolocationStateMachine-asasuHY2.esm.js

@@ -0,0 +1,105 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+import { r as isIOS, t as isAndroid } from "./platform-CfrjKhmi.esm.js";
+
+//#region src/modules/geolocation/geolocationServices.ts
+async function addGeolocation(params, signal) {
+	const res = await api.post(endpoints.addGeolocation, {
+		latitude: params.latitude,
+		longitude: params.longitude
+	}, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.addGeolocation} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/geolocation/geolocationStateMachine.ts
+function detectDeviceType() {
+	if (isIOS()) return "ios";
+	if (isAndroid()) return "android";
+	return "desktop";
+}
+const geolocationMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		requestPosition: fromPromise(async ({ input }) => {
+			return input.geolocation.getCurrentPosition();
+		}),
+		submitPosition: fromPromise(async ({ input, signal }) => {
+			try {
+				return await addGeolocation(input, signal);
+			} catch {
+				return { location: "Unknown" };
+			}
+		})
+	},
+	actions: {
+		setCoords: assign(({ event }) => ({ coords: event.output })),
+		setLocation: assign(({ event }) => ({ location: event.output.location })),
+		setDeviceType: assign({ deviceType: () => detectDeviceType() }),
+		resetContext: assign(({ context }) => ({
+			config: context.config,
+			geolocation: context.geolocation,
+			coords: void 0,
+			location: void 0,
+			deviceType: detectDeviceType()
+		}))
+	},
+	guards: { canSkip: ({ context }) => context.config.allowUserToSkipGeolocation === true }
+}).createMachine({
+	id: "geolocation",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		geolocation: input.geolocation,
+		coords: void 0,
+		location: void 0,
+		deviceType: detectDeviceType()
+	}),
+	states: {
+		idle: { on: { REQUEST: { target: "requestingLocation" } } },
+		requestingLocation: { invoke: {
+			id: "requestPosition",
+			src: "requestPosition",
+			input: ({ context }) => ({ geolocation: context.geolocation }),
+			onDone: {
+				target: "submitting",
+				actions: "setCoords"
+			},
+			onError: {
+				target: "permissionDenied",
+				actions: "setDeviceType"
+			}
+		} },
+		submitting: { invoke: {
+			id: "submitPosition",
+			src: "submitPosition",
+			input: ({ context }) => ({
+				latitude: context.coords?.latitude ?? 0,
+				longitude: context.coords?.longitude ?? 0
+			}),
+			onDone: {
+				target: "locationAcquired",
+				actions: "setLocation"
+			},
+			onError: {
+				target: "locationAcquired",
+				actions: assign({ location: () => "Unknown" })
+			}
+		} },
+		locationAcquired: { on: { CONTINUE: { target: "finished" } } },
+		permissionDenied: { on: { SKIP: {
+			target: "finished",
+			guard: "canSkip"
+		} } },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+export { geolocationMachine as t };

package/dist/getBrowser-BSXUTWXw.esm.js

@@ -0,0 +1,41 @@
+//#region ../infra/src/device/getDeviceClass.ts
+function getDeviceInfo() {
+	if (typeof navigator === "undefined") return {
+		userAgent: "",
+		platform: "",
+		maxTouchPoints: 0
+	};
+	return {
+		userAgent: navigator.userAgent,
+		platform: navigator.platform,
+		maxTouchPoints: navigator.maxTouchPoints
+	};
+}
+/**
+* Gets the current window dimensions.
+* Returns default values (1280x720) in non-browser environments.
+*/
+function getWindowDimensions(defaultWidth = 1280, defaultHeight = 720) {
+	if (typeof window === "undefined") return {
+		outerWidth: defaultWidth,
+		outerHeight: defaultHeight,
+		innerWidth: defaultWidth,
+		innerHeight: defaultHeight
+	};
+	return {
+		outerWidth: window.outerWidth,
+		outerHeight: window.outerHeight,
+		innerWidth: window.innerWidth,
+		innerHeight: window.innerHeight
+	};
+}
+
+//#endregion
+//#region ../infra/src/device/getBrowser.ts
+function getUserAgent() {
+	if (typeof navigator === "undefined") return "";
+	return navigator.userAgent;
+}
+
+//#endregion
+export { getDeviceInfo as n, getWindowDimensions as r, getUserAgent as t };

package/dist/getDeviceClass-BSntT9_j.esm.js

@@ -0,0 +1,14 @@
+import { n as getDeviceInfo } from "./getBrowser-BSXUTWXw.esm.js";
+
+//#region src/internal/device/getDeviceClass.ts
+function getDeviceClass() {
+	const { userAgent, platform, maxTouchPoints } = getDeviceInfo();
+	if (!userAgent) return "desktop";
+	const ua = userAgent.toLowerCase();
+	if (/iphone|ipad|ipod/.test(ua) || platform === "MacIntel" && maxTouchPoints > 1) return "ios";
+	if (/android/.test(ua)) return "android";
+	return "desktop";
+}
+
+//#endregion
+export { getDeviceClass as t };

package/dist/government-validation.d.ts

@@ -0,0 +1,67 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+
+//#region src/modules/government-validation/types.d.ts
+type GovernmentValidationConfig = {
+  validationCountries: string[];
+  facialValidation: boolean;
+  dataValidation: boolean;
+  faceAndDataValidation: boolean;
+  addressValidation: boolean;
+  backgroundExecution: boolean;
+  faceMatchOverrideDataScore: boolean;
+  useCroppedIdFacePhoto: boolean;
+  maxOtpAttempts?: number;
+};
+//#endregion
+//#region src/modules/government-validation/governmentValidationStateMachine.d.ts
+
+declare const governmentValidationMachine: any;
+//#endregion
+//#region src/modules/government-validation/governmentValidationActor.d.ts
+type CreateGovernmentValidationActorOptions = {
+  config: GovernmentValidationConfig;
+};
+//#endregion
+//#region src/modules/government-validation/governmentValidationManager.d.ts
+type GovernmentValidationIdleState = {
+  status: 'idle';
+};
+type GovernmentValidationLoadingState = {
+  status: 'loading';
+};
+type GovernmentValidationProcessingState = {
+  status: 'processing';
+};
+type GovernmentValidationAwaitingOtpState = {
+  status: 'awaitingOtp';
+  resendTimer: number;
+  canResend: boolean;
+  attemptsRemaining: number;
+  otpError?: string;
+};
+type GovernmentValidationVerifyingOtpState = {
+  status: 'verifyingOtp';
+};
+type GovernmentValidationFinishedState = {
+  status: 'finished';
+};
+type GovernmentValidationErrorState = {
+  status: 'error';
+  error: string;
+};
+type GovernmentValidationUnknownState = {
+  status: 'unknown';
+  error: string;
+};
+type GovernmentValidationState = GovernmentValidationIdleState | GovernmentValidationLoadingState | GovernmentValidationProcessingState | GovernmentValidationAwaitingOtpState | GovernmentValidationVerifyingOtpState | GovernmentValidationFinishedState | GovernmentValidationErrorState | GovernmentValidationUnknownState;
+declare function createGovernmentValidationManager(options: CreateGovernmentValidationActorOptions): Manager<GovernmentValidationState> & {
+  load(): void;
+  setOtpCode(code: string): void;
+  submitOtp(code: string): void;
+  resendOtp(): void;
+  retry(): void;
+};
+type GovernmentValidationManager = ReturnType<typeof createGovernmentValidationManager>;
+//#endregion
+export { type GovernmentValidationConfig, type GovernmentValidationManager, type GovernmentValidationState, createGovernmentValidationManager, governmentValidationMachine };