@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/ekybStateMachine-BR2let5f.esm.js

@@ -0,0 +1,674 @@
+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 { a as POSTAL_CODE_FORMAT_ERROR_KEYS, c as getPostalCodeMaxLength, i as FIXED_DIGIT_POSTAL_CODE_LENGTH, l as validatePostalCode, n as fillFromSuggestion, o as formatPostalCode, r as DYNAMIC_REQUIRED_KEY, s as getPostalCodeErrorKey, t as debounceSearchActor, u as usStateOptions } from "./addressSearch-BpTbTWCa.esm.js";
+import { t as getFlow } from "./flowServices-DG3IdWw6.esm.js";
+
+//#region src/modules/ekyb/ekybConstants.ts
+const UBO_INPUT_LIMIT = 8;
+/**
+* Countries available in all environments.
+* Sorted alphabetically by display name.
+*/
+const SUPPORTED_COUNTRIES = [
+	"BR",
+	"CN",
+	"FR",
+	"DE",
+	"IL",
+	"IT",
+	"MX",
+	"ES",
+	"GB",
+	"US"
+];
+/**
+* Additional countries available only in dev/staging environments.
+*/
+const DEV_ONLY_COUNTRIES = [
+	"CM",
+	"KE",
+	"NG"
+];
+/**
+* Union of all recognized country codes (prod + dev).
+*/
+const ALL_COUNTRIES = [...SUPPORTED_COUNTRIES, ...DEV_ONLY_COUNTRIES];
+const ALL_COUNTRIES_SET = new Set(ALL_COUNTRIES);
+function isSupportedCountry(code) {
+	return ALL_COUNTRIES_SET.has(code);
+}
+const FIELD_ORDER = [
+	"name-user_input",
+	"taxId-user_input",
+	"street-user_input",
+	"houseNo-user_input",
+	"address2-user_input",
+	"city-user_input",
+	"state-user_input",
+	"postalCode-user_input"
+];
+const FIELD_NAME_MAPPING = {
+	"name-user_input": "businessName",
+	"street-user_input": "street",
+	"houseNo-user_input": "houseNo",
+	"address2-user_input": "addressLine2",
+	"city-user_input": "city",
+	"state-user_input": "state",
+	"postalCode-user_input": "postalCode",
+	"taxId-user_input": "taxId"
+};
+const COUNTRIES_WITH_CNPJ_VALIDATION = ["BR"];
+const COUNTRIES_WITH_SPECIAL_TAX_ID_RULES = [
+	"NG",
+	"CM",
+	"KE"
+];
+const BUSINESS_NAME_OPTIONAL_COUNTRIES = [];
+const ADDRESS_FULLY_OPTIONAL_COUNTRIES = [
+	"BR",
+	"GB",
+	"FR"
+];
+const ADDRESS_FIELDS = [
+	"street",
+	"houseNo",
+	"addressLine2",
+	"city",
+	"state",
+	"postalCode"
+];
+const ALL_COUNTRIES_OPTIONAL_FIELDS = ["ubo"];
+
+//#endregion
+//#region src/modules/ekyb/ekybValidators.ts
+const CNPJ_FORMATTED_LENGTH = 18;
+const CNPJ_CLEAN_LENGTH = 14;
+const INVALID_CNPJ_PATTERNS = [
+	"00000000000000",
+	"11111111111111",
+	"22222222222222",
+	"33333333333333",
+	"44444444444444",
+	"55555555555555",
+	"66666666666666",
+	"77777777777777",
+	"88888888888888",
+	"99999999999999"
+];
+const CNPJ_FIRST_DIGIT_FACTORS = [
+	5,
+	4,
+	3,
+	2,
+	9,
+	8,
+	7,
+	6,
+	5,
+	4,
+	3,
+	2
+];
+const CNPJ_SECOND_DIGIT_FACTORS = [
+	6,
+	5,
+	4,
+	3,
+	2,
+	9,
+	8,
+	7,
+	6,
+	5,
+	4,
+	3,
+	2
+];
+function cleanCnpjString(cnpj) {
+	return cnpj.replace(/\./g, "").replace(/\//g, "").replace(/-/g, "");
+}
+function calculateVerificationDigit(cnpjString, factors) {
+	let digit = 11 - factors.reduce((acc, factor, index) => acc + Number.parseInt(cnpjString.charAt(index), 10) * factor, 0) % 11;
+	if (digit >= 10) digit = 0;
+	return digit.toString();
+}
+/**
+* Validates a Brazilian CNPJ number (14-digit checksum).
+* Accepts formatted (00.000.000/0000-00) or unformatted input.
+*/
+function validateCNPJ(cnpjInput) {
+	if (!cnpjInput || typeof cnpjInput !== "string") return false;
+	let cnpj = cnpjInput.trim();
+	if (cnpj.length === CNPJ_FORMATTED_LENGTH) cnpj = cleanCnpjString(cnpj);
+	if (cnpj.length !== CNPJ_CLEAN_LENGTH) return false;
+	if (!/^\d+$/.test(cnpj)) return false;
+	if (INVALID_CNPJ_PATTERNS.includes(cnpj)) return false;
+	const first = calculateVerificationDigit(cnpj, CNPJ_FIRST_DIGIT_FACTORS);
+	if (cnpj.charAt(12) !== first) return false;
+	const second = calculateVerificationDigit(cnpj, CNPJ_SECOND_DIGIT_FACTORS);
+	if (cnpj.charAt(13) !== second) return false;
+	return true;
+}
+
+//#endregion
+//#region src/modules/ekyb/ekybUtils.ts
+/**
+* Normalizes any supported eKYB config input into a manager-ready `EkybConfig`.
+*
+* Accepts either:
+*  - A manager-ready `EkybConfig` (with `flowId` or `verificationFields`) →
+*    returned unchanged.
+*  - A raw backend `EkybFlowConfig` (with `*Source` companions) → stripped to
+*    the four `check*` fields the manager consumes.
+*
+* Idempotent: `toEkybConfig(toEkybConfig(x))` equals `toEkybConfig(x)`.
+*/
+function toEkybConfig(config) {
+	if (config.flowId || config.verificationFields) return config;
+	return {
+		checkBusinessName: config.checkBusinessName,
+		checkAddress: config.checkAddress,
+		checkTaxId: config.checkTaxId,
+		checkUniqueBeneficialOwner: config.checkUniqueBeneficialOwner
+	};
+}
+/** Sorts modules based on a custom order; items not in order maintain relative position */
+function sortModulesByOrder(modules, customOrder) {
+	return [...modules].sort((a, b) => {
+		const indexA = customOrder.indexOf(a);
+		const indexB = customOrder.indexOf(b);
+		if (indexA !== -1 && indexB !== -1) return indexA - indexB;
+		if (indexA !== -1) return -1;
+		if (indexB !== -1) return 1;
+		return 0;
+	});
+}
+/** Determines if a field is optional for the given country */
+function isFieldOptional(fieldName, countryCode) {
+	if (ALL_COUNTRIES_OPTIONAL_FIELDS.includes(fieldName)) return true;
+	if (fieldName === "businessName") return BUSINESS_NAME_OPTIONAL_COUNTRIES.includes(countryCode);
+	if (fieldName === "addressLine2") return true;
+	if (ADDRESS_FIELDS.includes(fieldName)) return false;
+	if (fieldName === "taxId") return false;
+	return false;
+}
+/** Checks if at least one address field has a non-empty value */
+function hasAtLeastOneAddressField(formData) {
+	return ADDRESS_FIELDS.some((field) => {
+		const value = formData[field];
+		return value !== void 0 && value.trim() !== "";
+	});
+}
+/** Returns false for countries where address is fully optional */
+function requiresAddressValidation(countryCode) {
+	return !ADDRESS_FULLY_OPTIONAL_COUNTRIES.includes(countryCode);
+}
+
+//#endregion
+//#region src/modules/ekyb/ekybActions.ts
+const REQUIRED_ERROR_KEYS = new Set(["ekyb.error.requiredField"]);
+const UBO_FIELD_LABELS = {
+	name: "ekyb.uboName",
+	surname: "ekyb.uboSurname"
+};
+function buildEkybFields(verificationFields, country, _hasUbos) {
+	let modules = verificationFields.filter((f) => f !== "ubos-user_input" && !f.startsWith("socure"));
+	if (country === "GB") modules = modules.filter((m) => m !== "state-user_input");
+	if (country === "MX") modules = modules.filter((m) => {
+		if (m === "ubos-user_input") return false;
+		const fieldName = FIELD_NAME_MAPPING[m] ?? m;
+		if (ADDRESS_FIELDS.includes(fieldName) && fieldName !== "postalCode") return false;
+		return true;
+	});
+	return sortModulesByOrder(modules, FIELD_ORDER).map((moduleName) => {
+		const fieldName = FIELD_NAME_MAPPING[moduleName] ?? moduleName;
+		const optional = isFieldOptional(fieldName, country);
+		const def = {
+			name: fieldName,
+			type: "text",
+			label: `ekyb.${fieldName}`,
+			required: !optional
+		};
+		if (fieldName === "taxId") {
+			def.required = true;
+			if (country === "CN") def.label = "verification.labels.prcId";
+			if (country === "BR") def.displayLabel = "CPF";
+		}
+		if (fieldName === "postalCode") def.maxLength = getPostalCodeMaxLength(country);
+		if (fieldName === "state" && country === "US") {
+			def.type = "dropdown";
+			def.options = usStateOptions;
+			def.placeholder = "verification.placeholder.state";
+		}
+		return def;
+	});
+}
+function getDefaultVerificationFields(config) {
+	if (config.verificationFields && config.verificationFields.length > 0) return config.verificationFields;
+	const fields = [];
+	if (config.checkBusinessName !== false) fields.push("name-user_input");
+	if (config.checkAddress !== false) fields.push("street-user_input", "houseNo-user_input", "address2-user_input", "city-user_input", "state-user_input", "postalCode-user_input");
+	if (config.checkTaxId !== false) fields.push("taxId-user_input");
+	if (config.checkUniqueBeneficialOwner !== false) fields.push("ubos-user_input");
+	return fields;
+}
+function validateEkybField(name, value, required, country) {
+	const val = (value ?? "").trim();
+	if (required && !val) return "ekyb.error.requiredField";
+	if (name === "taxId") {
+		if (COUNTRIES_WITH_CNPJ_VALIDATION.includes(country)) {
+			if (val && !validateCNPJ(val)) return "ekyb.error.invalidTaxId";
+		}
+		if (COUNTRIES_WITH_SPECIAL_TAX_ID_RULES.includes(country) && !val) return;
+	}
+	if (name === "postalCode" && val) {
+		if (!validatePostalCode(val, country)) return getPostalCodeErrorKey(country);
+	}
+}
+function computeEkybValidation(fields, values, country, ubos, hasUbos) {
+	const errors = {};
+	for (const field of fields) {
+		const val = values[field.name];
+		const err = validateEkybField(field.name, val, field.required, country);
+		if (err) errors[field.name] = err;
+	}
+	if (requiresAddressValidation(country)) {
+		const addressValues = {};
+		for (const f of ADDRESS_FIELDS) addressValues[f] = values[f];
+		if (!hasAtLeastOneAddressField(addressValues)) {
+			const requiredAddressFields = fields.filter((f) => ADDRESS_FIELDS.includes(f.name) && f.required);
+			for (const f of requiredAddressFields) if (!errors[f.name] && !(values[f.name] ?? "").trim()) errors[f.name] = "ekyb.error.requiredField";
+		}
+	}
+	if (hasUbos) for (let i = 0; i < ubos.length; i++) {
+		const isDefault = i === 0;
+		const hasAnyValue = ubos[i].name.trim() !== "" || ubos[i].surname.trim() !== "";
+		if (isDefault || hasAnyValue) {
+			if (!ubos[i].name.trim()) errors[`ubo-${i}-name`] = "ekyb.error.requiredField";
+			if (!ubos[i].surname.trim()) errors[`ubo-${i}-surname`] = "ekyb.error.requiredField";
+		}
+	}
+	return {
+		errors,
+		isValid: Object.keys(errors).length === 0
+	};
+}
+function computeDisplayErrors(errors, touched, submitAttempted, country, fields) {
+	const display = {};
+	const errorParams = {};
+	const fieldLabelMap = new Map(fields?.map((f) => [f.name, f.displayLabel ?? f.label]));
+	for (const [field, err] of Object.entries(errors)) {
+		const isRequiredErr = REQUIRED_ERROR_KEYS.has(err);
+		if (isRequiredErr && (submitAttempted || touched[field])) {
+			display[field] = DYNAMIC_REQUIRED_KEY;
+			const label = fieldLabelMap.get(field);
+			if (label) errorParams[field] = { fieldName: label };
+			else {
+				const uboMatch = field.match(/^ubo-\d+-(name|surname)$/);
+				if (uboMatch) errorParams[field] = { fieldName: UBO_FIELD_LABELS[uboMatch[1]] ?? field };
+			}
+		} else if (!isRequiredErr && touched[field]) display[field] = err;
+		if (display[field] && field === "postalCode" && POSTAL_CODE_FORMAT_ERROR_KEYS.has(err)) {
+			const fixedLen = FIXED_DIGIT_POSTAL_CODE_LENGTH[country];
+			if (fixedLen !== void 0) errorParams[field] = {
+				...errorParams[field] ?? {},
+				length: fixedLen
+			};
+			else {
+				let maxLen = getPostalCodeMaxLength(country);
+				if (country === "US" || country === "BR") maxLen = maxLen - 1;
+				errorParams[field] = {
+					...errorParams[field] ?? {},
+					maxLength: maxLen
+				};
+			}
+		}
+	}
+	return {
+		displayErrors: display,
+		errorParams
+	};
+}
+function processEkybFieldValue(name, value, country) {
+	if (name === "postalCode") return formatPostalCode(value, country);
+	return value;
+}
+function buildEkybSubmitPayload(ctx) {
+	const uboNames = ctx.ubos.filter((u) => u.name.trim() || u.surname.trim()).map((u) => `${u.name.trim()} ${u.surname.trim()}`.trim());
+	const payload = {
+		country: ctx.country,
+		plugins: ["ekyb"],
+		uboNames
+	};
+	for (const field of ctx.fields) {
+		const val = ctx.values[field.name];
+		if (val !== void 0 && val !== "") payload[field.name] = val;
+	}
+	return payload;
+}
+
+//#endregion
+//#region src/modules/ekyb/ekybGuards.ts
+const hasFlowIdGuard = ({ context }) => !!context.config.flowId;
+const isValidGuard = ({ context }) => context.isValid;
+const canAddUboGuard = ({ context }) => context.canAddUbo;
+const isValidUboIndexGuard = ({ context, event }) => {
+	const { index } = event;
+	return Number.isInteger(index) && index >= 0 && index < context.ubos.length;
+};
+const isSupportedCountryGuard = ({ event }) => {
+	const { country } = event;
+	return isSupportedCountry(country);
+};
+
+//#endregion
+//#region src/modules/ekyb/ekybServices.ts
+/** Fetches the onboarding flow and extracts the EKYB module configuration */
+async function fetchEkybModuleConfig(signal) {
+	const ekybModule = (await getFlow(signal)).flowModules.find((m) => m.key === "EKYB");
+	if (!ekybModule) throw new Error("EKYB module not found in flow configuration");
+	return ekybModule.configuration;
+}
+/** Submits eKYB business verification */
+async function submitEkyb(data, signal) {
+	const res = await api.post(endpoints.ekybSubmit, data, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.ekybSubmit} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/ekyb/ekybActors.ts
+const fetchEkybModuleConfigActor = fromPromise(async ({ signal }) => fetchEkybModuleConfig(signal));
+const submitEkybActor = fromPromise(async ({ input, signal }) => submitEkyb(input, signal));
+
+//#endregion
+//#region src/modules/ekyb/ekybStateMachine.ts
+const ekybMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchEkybModuleConfig: fetchEkybModuleConfigActor,
+		submitEkyb: submitEkybActor,
+		debounceSearch: debounceSearchActor
+	},
+	actions: {
+		applyFetchedConfig: assign(({ event }) => {
+			const fetched = event.output;
+			const config = {
+				checkBusinessName: fetched.checkBusinessName,
+				checkAddress: fetched.checkAddress,
+				checkTaxId: fetched.checkTaxId,
+				checkUniqueBeneficialOwner: fetched.checkUniqueBeneficialOwner
+			};
+			const country = "US";
+			const vFields = getDefaultVerificationFields(config);
+			const hasUbos = config.checkUniqueBeneficialOwner !== false && vFields.includes("ubos-user_input");
+			const fields = buildEkybFields(vFields, country, hasUbos);
+			const values = { country };
+			const ubos = hasUbos ? [{
+				id: "ubo-1",
+				name: "",
+				surname: ""
+			}] : [];
+			const { errors, isValid } = computeEkybValidation(fields, values, country, ubos, hasUbos);
+			return {
+				config,
+				country,
+				availableCountries: ALL_COUNTRIES,
+				fields,
+				values,
+				errors,
+				isValid,
+				ubos,
+				canAddUbo: hasUbos,
+				hasUbos,
+				submitAttempted: false,
+				addressSuggestions: [],
+				_nextUboId: 2,
+				_searchQuery: ""
+			};
+		}),
+		setCountry: assign(({ context, event }) => {
+			const { country } = event;
+			const vFields = getDefaultVerificationFields(context.config);
+			const hasUbos = context.config.checkUniqueBeneficialOwner !== false && vFields.includes("ubos-user_input") && country !== "MX";
+			const fields = buildEkybFields(vFields, country, hasUbos);
+			let nextId = context._nextUboId;
+			let ubos;
+			if (hasUbos) if (context.ubos.length > 0) ubos = context.ubos;
+			else {
+				ubos = [{
+					id: `ubo-${nextId}`,
+					name: "",
+					surname: ""
+				}];
+				nextId += 1;
+			}
+			else ubos = [];
+			const newValues = {
+				...context.values,
+				country,
+				state: ""
+			};
+			const { errors, isValid } = computeEkybValidation(fields, newValues, country, ubos, hasUbos);
+			return {
+				country,
+				fields,
+				values: newValues,
+				errors,
+				isValid,
+				ubos,
+				canAddUbo: hasUbos && ubos.length < UBO_INPUT_LIMIT,
+				hasUbos,
+				_nextUboId: nextId
+			};
+		}),
+		updateField: assign(({ context, event }) => {
+			const { name, value } = event;
+			const processed = processEkybFieldValue(name, value, context.country);
+			const newValues = {
+				...context.values,
+				[name]: processed
+			};
+			const { errors, isValid } = computeEkybValidation(context.fields, newValues, context.country, context.ubos, context.hasUbos);
+			return {
+				values: newValues,
+				errors,
+				isValid
+			};
+		}),
+		addUbo: assign(({ context }) => {
+			const newId = context._nextUboId;
+			const ubos = [...context.ubos, {
+				id: `ubo-${newId}`,
+				name: "",
+				surname: ""
+			}];
+			const canAddUbo = ubos.length < UBO_INPUT_LIMIT;
+			const { errors, isValid } = computeEkybValidation(context.fields, context.values, context.country, ubos, context.hasUbos);
+			return {
+				ubos,
+				canAddUbo,
+				errors,
+				isValid,
+				_nextUboId: newId + 1
+			};
+		}),
+		removeUbo: assign(({ context, event }) => {
+			const { index } = event;
+			const ubos = context.ubos.filter((_, i) => i !== index);
+			const canAddUbo = ubos.length < UBO_INPUT_LIMIT;
+			const { errors, isValid } = computeEkybValidation(context.fields, context.values, context.country, ubos, context.hasUbos);
+			return {
+				ubos,
+				canAddUbo,
+				errors,
+				isValid
+			};
+		}),
+		setUboField: assign(({ context, event }) => {
+			const { index, field, value } = event;
+			const ubos = context.ubos.map((ubo, i) => i === index ? {
+				...ubo,
+				[field]: value
+			} : ubo);
+			const { errors, isValid } = computeEkybValidation(context.fields, context.values, context.country, ubos, context.hasUbos);
+			return {
+				ubos,
+				errors,
+				isValid
+			};
+		}),
+		setErrorMessage: assign(({ event }) => ({ errorMessage: String(event.error ?? "verification.error") })),
+		clearErrorMessage: assign({ errorMessage: () => "" }),
+		markSubmitAttempted: assign({ submitAttempted: () => true }),
+		fillAddressFields: assign(({ context, event }) => {
+			const { suggestion } = event;
+			const activeFields = new Set(context.fields.map((f) => f.name));
+			const { values: newValues } = fillFromSuggestion(context.values, {}, suggestion, activeFields);
+			const { errors, isValid } = computeEkybValidation(context.fields, newValues, context.country, context.ubos, context.hasUbos);
+			return {
+				values: newValues,
+				addressSuggestions: [],
+				errors,
+				isValid
+			};
+		}),
+		setAddressSuggestions: assign(({ event }) => ({ addressSuggestions: event.suggestions }))
+	},
+	guards: {
+		hasFlowId: hasFlowIdGuard,
+		isValid: isValidGuard,
+		canAddUbo: canAddUboGuard,
+		isValidUboIndex: isValidUboIndexGuard,
+		isSupportedCountry: isSupportedCountryGuard
+	}
+}).createMachine({
+	id: "ekyb",
+	initial: "idle",
+	context: ({ input }) => {
+		const config = toEkybConfig(input.config);
+		const country = "US";
+		const vFields = getDefaultVerificationFields(config);
+		const hasUbos = config.checkUniqueBeneficialOwner !== false && vFields.includes("ubos-user_input");
+		const fields = buildEkybFields(vFields, country, hasUbos);
+		const values = { country };
+		const ubos = hasUbos ? [{
+			id: "ubo-1",
+			name: "",
+			surname: ""
+		}] : [];
+		const { errors, isValid } = computeEkybValidation(fields, values, country, ubos, hasUbos);
+		return {
+			config,
+			country,
+			availableCountries: ALL_COUNTRIES,
+			fields,
+			values,
+			errors,
+			isValid,
+			ubos,
+			canAddUbo: hasUbos,
+			hasUbos,
+			errorMessage: "",
+			submitAttempted: false,
+			addressSuggestions: [],
+			_nextUboId: 2,
+			_searchQuery: ""
+		};
+	},
+	states: {
+		idle: { on: { LOAD: [{
+			target: "loading",
+			guard: "hasFlowId"
+		}, { target: "form" }] } },
+		loading: { invoke: {
+			id: "fetchEkybModuleConfig",
+			src: "fetchEkybModuleConfig",
+			onDone: {
+				target: "form",
+				actions: "applyFetchedConfig"
+			},
+			onError: "form"
+		} },
+		form: {
+			initial: "idle",
+			states: {
+				idle: {},
+				searching: {
+					invoke: {
+						id: "debounceSearch",
+						src: "debounceSearch",
+						input: ({ context }) => ({ query: context._searchQuery })
+					},
+					on: { RESULTS: {
+						target: "idle",
+						actions: "setAddressSuggestions"
+					} }
+				}
+			},
+			on: {
+				SET_COUNTRY: {
+					guard: "isSupportedCountry",
+					actions: "setCountry"
+				},
+				SET_FIELD: { actions: "updateField" },
+				SEARCH_ADDRESS: {
+					target: ".searching",
+					actions: assign(({ event }) => ({
+						_searchQuery: event.query,
+						addressSuggestions: []
+					}))
+				},
+				SELECT_ADDRESS: {
+					target: ".idle",
+					actions: "fillAddressFields"
+				},
+				ADD_UBO: {
+					guard: "canAddUbo",
+					actions: "addUbo"
+				},
+				REMOVE_UBO: {
+					guard: "isValidUboIndex",
+					actions: "removeUbo"
+				},
+				SET_UBO_FIELD: {
+					guard: "isValidUboIndex",
+					actions: "setUboField"
+				},
+				SUBMIT: [{
+					target: "submitting",
+					guard: "isValid"
+				}, { actions: "markSubmitAttempted" }],
+				CLOSE: { target: "closed" }
+			}
+		},
+		submitting: { invoke: {
+			id: "submitEkyb",
+			src: "submitEkyb",
+			input: ({ context }) => buildEkybSubmitPayload(context),
+			onDone: { target: "success" },
+			onError: {
+				target: "error",
+				actions: "setErrorMessage"
+			}
+		} },
+		success: { after: { 3e3: "finished" } },
+		error: { on: {
+			RETRY: {
+				target: "form",
+				actions: "clearErrorMessage"
+			},
+			CLOSE: { target: "closed" }
+		} },
+		finished: { type: "final" },
+		closed: { type: "final" }
+	}
+});
+
+//#endregion
+export { DEV_ONLY_COUNTRIES as a, ALL_COUNTRIES as i, computeDisplayErrors as n, SUPPORTED_COUNTRIES as o, toEkybConfig as r, isSupportedCountry as s, ekybMachine as t };