@incodetech/core 2.4.1-agentic.4 → 2.4.1-agentic.6

package/dist/ekycPrefillStateMachine-ClGEAsOy.esm.js

@@ -0,0 +1,686 @@
+import { t as api, u as endpoints } from "./api-C_P9YXbL.esm.js";
+import { i as toIncodeApiError } from "./apiError-DzZ5OriE.esm.js";
+import { n as loadPhoneValidation } from "./phoneValidation-OggtfjRt.esm.js";
+import { i as assign, t as setup } from "./xstate.esm-DSajW7CJ.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-8Gzepa_A.esm.js";
+import { t as createBundledDefinitionSource } from "./definitionSource-1vPLtuXE.esm.js";
+import { n as checkSupport, t as resolveForm } from "./resolveForm-f9PhUo9j.esm.js";
+import { t as formatPhoneE164 } from "./phoneFormat-DEpESpz2.esm.js";
+import { i as cleanName, l as validateEkycField, n as projectRules, o as formatSSN } from "./ekycRules-B7vXnbdg.esm.js";
+import { t as formatCPF } from "./idOcrCpfUtils-Nfln1Psb.esm.js";
+//#region src/modules/ekyc-prefill/ekycPrefillConfig.ts
+const isString = (value) => typeof value === "string" && value !== "";
+function toConfigField(raw) {
+	if (typeof raw !== "object" || raw === null) return void 0;
+	const { field, check, mandatory } = raw;
+	if (!isString(field)) return void 0;
+	return {
+		field,
+		check: check === true,
+		mandatory: mandatory === true
+	};
+}
+/**
+* Normalizes the served `EKYC_PREFILL` configuration. Idempotent, so a
+* configuration that is already normalized passes through unchanged.
+*
+* - `check` and `mandatory` are `true` only when served as `true`; a `null`
+*   check hides the field.
+* - `fields` stays `undefined` when the configuration has no `fields` array:
+*   the flat dashboard shape, which the module can't render.
+* - `source`, `displayMode` and other per-field keys are dropped.
+*/
+function toEkycPrefillConfig(raw) {
+	const config = raw ?? {};
+	const fields = Array.isArray(config.fields) ? config.fields.map(toConfigField).filter((field) => !!field) : void 0;
+	const requireAnyOf = Array.isArray(config.requireAnyOf) ? config.requireAnyOf.filter(isString) : [];
+	return {
+		country: isString(config.country) ? config.country : void 0,
+		source: isString(config.source) ? config.source : void 0,
+		fields,
+		requireAnyOf,
+		autoExecution: config.autoExecution === true
+	};
+}
+//#endregion
+//#region ../form-definitions/generated/ekycprefill.ts
+const EKYCPREFILL_DEFINITIONS = {
+	"ekycprefill/BR": {
+		schemaVersion: 1,
+		vocabulary: "1.0",
+		id: "ekycprefill/BR",
+		module: "ekycprefill",
+		country: "BR",
+		fields: [{
+			name: "taxIdNumber",
+			kind: "text",
+			group: "ssn",
+			label: { key: "verification.labels.taxId" },
+			displayLabel: {
+				key: "verification.labels.cpf",
+				text: "CPF"
+			},
+			input: {
+				maxLength: 14,
+				keyboard: "numeric"
+			},
+			rules: [{ id: "cpf" }],
+			payload: { transforms: [{
+				id: "stripSeparators",
+				params: { chars: ".-" }
+			}] }
+		}],
+		submit: {
+			static: { plugins: ["kyc-prefill"] },
+			context: { countryCode: "country" }
+		}
+	},
+	"ekycprefill/US": {
+		schemaVersion: 1,
+		vocabulary: "1.3",
+		id: "ekycprefill/US",
+		module: "ekycprefill",
+		country: "US",
+		fields: [
+			{
+				name: "phone",
+				kind: "phone",
+				group: "phone",
+				label: { key: "verification.labels.phone" },
+				input: { autofill: "phone" },
+				phone: { lockCountry: true },
+				rules: [{ id: "phoneFormat" }],
+				payload: { transforms: [{ id: "e164" }] }
+			},
+			{
+				name: "dateOfBirth",
+				kind: "date",
+				group: "dateOfBirth",
+				label: { key: "verification.labels.dateOfBirth" },
+				input: { autofill: "birthday" },
+				rules: [{ id: "notFuture" }, {
+					id: "maxAge",
+					params: { years: 120 }
+				}]
+			},
+			{
+				name: "ssn",
+				kind: "text",
+				group: "ssn",
+				widget: "masked",
+				label: { key: "verification.labels.ssn" },
+				input: {
+					maxLength: 11,
+					keyboard: "numeric"
+				},
+				rules: [{ id: "ssnFormat" }],
+				payload: { transforms: [{
+					id: "stripSeparators",
+					params: { chars: "-" }
+				}] }
+			},
+			{
+				name: "surName",
+				kind: "text",
+				group: "name",
+				label: { key: "verification.labels.lastName" },
+				placeholder: { key: "verification.placeholder.lastName" },
+				input: {
+					maxLength: 100,
+					autofill: "familyName"
+				}
+			}
+		],
+		submit: {
+			static: { plugins: ["kyc-prefill"] },
+			context: { countryCode: "country" }
+		}
+	}
+};
+//#endregion
+//#region src/modules/ekyc-prefill/ekycPrefillDefinition.ts
+/**
+* eKYC Pre-fill adapter for form definitions.
+*
+* The catalog (`catalog/ekycprefill`) holds one definition per country with
+* every input the country's sources take, all optional: their kind, label,
+* rules and request key. The served module configuration decides the rest
+* (ENG-61990): which inputs show (`check`), which are required (`mandatory`)
+* and which are "at least one of" (`requireAnyOf`). This overlays the served
+* configuration on the country's definition, so eKYC Pre-fill runs the same
+* kernel (`checkSupport`, `resolveForm`) as eKYC, eKYB and KYB Checks. It
+* goes away once the backend serves form definitions itself.
+*/
+const EKYC_PREFILL_MODULE = "ekycprefill";
+/** The message of the "at least one of" rule. Its `fields` param lists the members' labels. */
+const ANY_OF_MESSAGE_KEY = "ekycPrefill.errors.requireAnyOf";
+/** What the projection can express: exactly the ids the catalog uses. */
+const EKYC_PREFILL_SUPPORTED_IDS = {
+	schemaVersions: [1],
+	vocabulary: "1.3",
+	kinds: /* @__PURE__ */ new Set([
+		"text",
+		"date",
+		"phone"
+	]),
+	groups: /* @__PURE__ */ new Set([
+		"phone",
+		"dateOfBirth",
+		"ssn",
+		"name"
+	]),
+	rules: /* @__PURE__ */ new Set([
+		"phoneFormat",
+		"notFuture",
+		"maxAge",
+		"ssnFormat",
+		"cpf"
+	]),
+	transforms: /* @__PURE__ */ new Set(["e164", "stripSeparators"]),
+	groupRules: /* @__PURE__ */ new Set(["oneOfRequired"]),
+	optionLists: /* @__PURE__ */ new Set(),
+	conditions: /* @__PURE__ */ new Set(),
+	prefillSources: /* @__PURE__ */ new Set()
+};
+const bundled = createBundledDefinitionSource(EKYCPREFILL_DEFINITIONS);
+/** The catalog definition for a country, or `undefined` when it has none. */
+function selectEkycPrefillDefinition(country) {
+	return bundled.select({
+		module: EKYC_PREFILL_MODULE,
+		country
+	});
+}
+/**
+* Applies the served configuration to the country's definition:
+*
+* - a field shows only when its served `check` is `true`; its group is on;
+* - a shown field is required when served `mandatory`;
+* - `requireAnyOf`, kept to the shown fields, becomes a `oneOfRequired`
+*   rule. One member left is simply required, so it gets the usual
+*   asterisk and message instead of an "at least one of" message;
+* - the served `source` goes into the request body, as a served definition
+*   would carry it.
+*
+* A served input the definition has no field for is left out with a warning.
+*/
+function toEkycPrefillResolution(definition, config) {
+	const served = new Map((config.fields ?? []).map((field) => [field.field, field]));
+	const known = new Set(definition.fields.map((field) => field.name));
+	const unknownMandatory = [];
+	for (const field of served.values()) {
+		if (known.has(field.field) || !field.check) continue;
+		console.warn(`[ekyc-prefill] No "${field.field}" field for ${definition.id}; it is not shown`);
+		if (field.mandatory) unknownMandatory.push(field.field);
+	}
+	const shown = definition.fields.filter((field) => served.get(field.name)?.check === true);
+	const shownNames = new Set(shown.map((field) => field.name));
+	const anyOf = [...new Set(config.requireAnyOf)].filter((name) => shownNames.has(name));
+	const loneMember = anyOf.length === 1 ? anyOf[0] : void 0;
+	const fields = shown.map((field) => ({
+		...field,
+		required: served.get(field.name)?.mandatory === true || field.name === loneMember
+	}));
+	const groupRules = anyOf.length > 1 ? [{
+		id: "oneOfRequired",
+		fields: anyOf,
+		message: {
+			key: ANY_OF_MESSAGE_KEY,
+			text: "Provide at least one of {{fields}}"
+		}
+	}] : [];
+	return {
+		definition: {
+			...definition,
+			...config.source && { source: config.source },
+			fields,
+			groupRules,
+			submit: {
+				...definition.submit,
+				context: {
+					...definition.submit.context,
+					...config.source && { source: "source" }
+				}
+			}
+		},
+		context: { groups: Object.fromEntries(fields.map((field) => [field.group, true])) },
+		unknownMandatory
+	};
+}
+//#endregion
+//#region src/modules/ekyc-prefill/ekycPrefillFields.ts
+const PHONE_INVALID_ERROR = { key: "verification.errors.phoneInvalid" };
+/** Vocabulary autofill ids → HTML `autocomplete` tokens (WCAG 2.2 SC 1.3.5). */
+const AUTOCOMPLETE = {
+	givenName: "given-name",
+	middleName: "additional-name",
+	familyName: "family-name",
+	email: "email",
+	phone: "tel",
+	addressLine1: "address-line1",
+	addressLine2: "address-line2",
+	addressLevel1: "address-level1",
+	addressLevel2: "address-level2",
+	postalCode: "postal-code",
+	birthday: "bday",
+	organization: "organization"
+};
+const TYPES = {
+	date: "date",
+	phone: "phone"
+};
+/** The as-you-type format a field's rule or group implies. */
+function formatAsOf(field) {
+	const rules = new Set((field.rules ?? []).map((rule) => rule.id));
+	if (rules.has("cpf")) return "cpf";
+	if (rules.has("ssnFormat")) return "ssn";
+	if (field.group === "name") return "name";
+}
+function projectField(resolved, country) {
+	const { field, required, phoneLocked } = resolved;
+	const validation = required ? [{ type: "required" }] : [];
+	validation.push(...projectRules(field.rules ?? [], country, required));
+	const autoComplete = field.input?.autofill ? AUTOCOMPLETE[field.input.autofill] : void 0;
+	const formatAs = formatAsOf(field);
+	return {
+		name: field.name,
+		type: TYPES[field.kind] ?? "text",
+		label: field.label.key,
+		required,
+		...field.displayLabel && { displayLabel: field.displayLabel.text ?? field.displayLabel.key },
+		...field.placeholder && { placeholder: field.placeholder.key },
+		...field.input?.maxLength !== void 0 && { maxLength: field.input.maxLength },
+		...field.kind === "phone" && { disableCountrySelector: phoneLocked },
+		...field.widget === "masked" && { masked: true },
+		...field.input?.keyboard === "numeric" && { numeric: true },
+		...autoComplete && { autoComplete },
+		...formatAs && { formatAs },
+		validation
+	};
+}
+/** The request body plan: static keys, the context keys resolved, then each field. */
+function toSubmitPlan(definition) {
+	const context = {
+		country: definition.country,
+		source: definition.source
+	};
+	const resolvedContext = Object.fromEntries(Object.entries(definition.submit.context ?? {}).flatMap(([key, from]) => context[from] === void 0 ? [] : [[key, context[from]]]));
+	return {
+		static: {
+			...definition.submit.static,
+			...resolvedContext
+		},
+		country: definition.country ?? "",
+		fields: definition.fields.filter((field) => !field.payload?.omit).map((field) => ({
+			name: field.name,
+			key: field.payload?.key ?? field.name,
+			transforms: (field.payload?.transforms ?? []).map((transform) => ({
+				id: transform.id,
+				...typeof transform.params?.chars === "string" && { chars: transform.params.chars }
+			}))
+		}))
+	};
+}
+const preparedForms = /* @__PURE__ */ new WeakMap();
+/**
+* The served configuration on the forms kernel: the country's definition,
+* overlaid with the served requiredness, checked, resolved and projected.
+* `undefined` when the module can't render it: no `fields` (the flat
+* dashboard shape), no source or country, no definition for the country, a
+* mandatory input the definition doesn't know, no input to show, or an
+* overlay that fails `checkSupport`, which would be a bug in the adapter.
+*/
+function prepareEkycPrefillForm(config) {
+	if (preparedForms.has(config)) return preparedForms.get(config) ?? void 0;
+	const prepared = prepare(config);
+	preparedForms.set(config, prepared ?? null);
+	return prepared;
+}
+function prepare(config) {
+	const { country, source, fields } = config;
+	if (!fields || !country || !source) return void 0;
+	const catalog = selectEkycPrefillDefinition(country);
+	if (!catalog) {
+		console.warn(`[ekyc-prefill] No form definition for country ${country}`);
+		return;
+	}
+	const { definition, context, unknownMandatory } = toEkycPrefillResolution(catalog, config);
+	if (unknownMandatory.length > 0) return void 0;
+	const support = checkSupport(definition, EKYC_PREFILL_SUPPORTED_IDS);
+	if (!support.supported) {
+		console.warn("[ekyc-prefill] Unsupported form definition", support.problems);
+		return;
+	}
+	const resolved = resolveForm(definition, context);
+	if (resolved.fields.length === 0) return void 0;
+	const [anyOf] = resolved.groupRules;
+	return {
+		country,
+		fields: resolved.fields.map((field) => projectField(field, country)),
+		anyOf: anyOf && {
+			fields: [...anyOf.fields],
+			message: anyOf.rule.message?.key ?? anyOf.rule.id
+		},
+		submit: toSubmitPlan(definition)
+	};
+}
+/** Formats a value as it is typed. */
+function formatFieldValue(field, value) {
+	switch (field?.formatAs) {
+		case "cpf": return formatCPF(value);
+		case "ssn": return formatSSN(value);
+		case "name": return value ? cleanName(value) : value;
+		default: return value;
+	}
+}
+const isBlank = (value) => (value ?? "").trim() === "";
+const asEkycFields = (fields) => fields.map(({ name, type, label, displayLabel, required, validation }) => ({
+	name,
+	type,
+	label,
+	...displayLabel && { displayLabel },
+	required,
+	validation,
+	source: "user_input"
+}));
+/**
+* A field's first failing rule. A phone the input itself reports as
+* malformed fails as invalid.
+*/
+function validateField(prepared, values, name, invalidFormats = {}) {
+	const error = validateEkycField(values, name, asEkycFields(prepared.fields));
+	if (error) return error;
+	if (invalidFormats[name] && !isBlank(values[name])) return PHONE_INVALID_ERROR;
+}
+/** Every field's error. The "at least one of" rule is reported apart, by `isAnyOfMissing`. */
+function validateForm(prepared, values, invalidFormats = {}) {
+	const errors = {};
+	for (const field of prepared.fields) {
+		const error = validateField(prepared, values, field.name, invalidFormats);
+		if (error) errors[field.name] = error;
+	}
+	return errors;
+}
+/** Whether the "at least one of" group has no member filled. */
+function isAnyOfMissing(prepared, values) {
+	return !!prepared.anyOf && prepared.anyOf.fields.every((name) => isBlank(values[name]));
+}
+function stripChars(value, chars) {
+	const remove = new Set(chars ?? " -./");
+	return [...value].filter((char) => !remove.has(char)).join("");
+}
+/**
+* The `POST /omni/externalVerification/ekyc-prefill` body: the static and
+* context keys, then each filled field under its request key after its
+* transforms. An empty field is left out.
+*/
+function buildSubmitBody(submit, values) {
+	const body = { ...submit.static };
+	for (const field of submit.fields) {
+		let value = (values[field.name] ?? "").trim();
+		if (value === "") continue;
+		for (const transform of field.transforms) if (transform.id === "e164") value = formatPhoneE164(value, submit.country);
+		else if (transform.id === "stripSeparators") value = stripChars(value, transform.chars);
+		body[field.key] = value;
+	}
+	return body;
+}
+//#endregion
+//#region src/modules/ekyc-prefill/ekycPrefillServices.ts
+/**
+* Runs the eKYC Pre-fill lookup for the session. Throws an `IncodeApiError`
+* on failure; its `status` is the body's status (4210 for a rejected phone)
+* and `httpStatus` the HTTP one.
+*/
+async function submitEkycPrefill(body, signal) {
+	try {
+		const res = await api.post(endpoints.ekycPrefillSubmit, body, { signal });
+		if (!res.ok) throw res;
+		return res.data;
+	} catch (error) {
+		throw toIncodeApiError(endpoints.ekycPrefillSubmit, error);
+	}
+}
+//#endregion
+//#region src/modules/ekyc-prefill/ekycPrefillStateMachine.ts
+/** The body status the backend answers a phone it rejects with. */
+const PHONE_REJECTED_STATUS = 4210;
+/** Shown when the backend rejects the request and no single field is to blame. */
+const SUBMIT_REJECTED_KEY = "ekycPrefill.errors.checkInformation";
+const CPF_INVALID_KEY = "verification.errors.invalidTaxId";
+/** Loads the phone rules, rejecting when the load fails or times out. */
+const requirePhoneRules = async () => {
+	if (!await loadPhoneValidation()) throw new Error("Failed to load the phone validation rules");
+};
+/** Only the `e164` transform needs the phone rules to build the body. */
+const needsPhoneRules = (submit) => submit.fields.some((field) => field.transforms.some((transform) => transform.id === "e164"));
+/**
+* The HTTP and body statuses of a failed request. Read by shape rather than
+* `instanceof IncodeApiError`, so a test or story double reaches each branch.
+*/
+const statusesOf = (error) => {
+	if (typeof error !== "object" || error === null) return {};
+	const { httpStatus, status } = error;
+	return {
+		...typeof httpStatus === "number" && { httpStatus },
+		...typeof status === "number" && { status }
+	};
+};
+const httpStatusOf = (error) => statusesOf(error).httpStatus;
+const errorOf = (event) => event.error;
+const ekycPrefillMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		loadPhoneRules: fromPromise(async ({ input }) => {
+			if (input.hasPhone) await requirePhoneRules();
+		}),
+		submit: fromPromise(async ({ input, signal }) => {
+			if (needsPhoneRules(input.submit)) await requirePhoneRules();
+			return submitEkycPrefill(buildSubmitBody(input.submit, input.values), signal);
+		})
+	},
+	actions: {
+		applyForm: assign(({ context }) => ({ prepared: prepareEkycPrefillForm(context.config) })),
+		setPhoneRulesLoaded: assign({ phoneRulesLoaded: true }),
+		setPhoneRulesFailed: assign(({ event }) => {
+			const error = errorOf(event);
+			return {
+				phoneRulesFailed: true,
+				errorKind: "unavailable",
+				errorMessage: error instanceof Error ? error.message : String(error)
+			};
+		}),
+		setFieldValue: assign(({ context, event }) => {
+			const { name, value, isValid } = event;
+			const prepared = context.prepared;
+			const field = prepared.fields.find((f) => f.name === name);
+			const values = {
+				...context.values,
+				[name]: formatFieldValue(field, value)
+			};
+			const invalidFormats = { ...context.invalidFormats };
+			if (isValid === false) invalidFormats[name] = true;
+			else delete invalidFormats[name];
+			const errors = { ...context.errors };
+			delete errors[name];
+			return {
+				values,
+				errors,
+				invalidFormats,
+				submitError: void 0,
+				anyOfError: context.anyOfError && isAnyOfMissing(prepared, values)
+			};
+		}),
+		validateOneField: assign(({ context, event }) => {
+			const { name } = event;
+			const prepared = context.prepared;
+			const error = validateField(prepared, context.values, name, context.invalidFormats);
+			const errors = { ...context.errors };
+			if (error) errors[name] = error;
+			else delete errors[name];
+			const leftEmptyMember = !!prepared.anyOf?.fields.includes(name) && isAnyOfMissing(prepared, context.values);
+			return {
+				errors,
+				anyOfError: context.anyOfError || leftEmptyMember
+			};
+		}),
+		validateAll: assign(({ context }) => {
+			const prepared = context.prepared;
+			return {
+				errors: validateForm(prepared, context.values, context.invalidFormats),
+				anyOfError: isAnyOfMissing(prepared, context.values)
+			};
+		}),
+		applyRejection: assign(({ context, event }) => {
+			const error = errorOf(event);
+			const prepared = context.prepared;
+			const names = prepared.fields.map((field) => field.name);
+			if (statusesOf(error).status === PHONE_REJECTED_STATUS && names.includes("phone")) return { errors: {
+				...context.errors,
+				phone: PHONE_INVALID_ERROR
+			} };
+			const cpfField = prepared.fields.find((field) => field.formatAs === "cpf");
+			if (cpfField && names.length === 1) return { errors: {
+				...context.errors,
+				[cpfField.name]: { key: CPF_INVALID_KEY }
+			} };
+			return { submitError: SUBMIT_REJECTED_KEY };
+		}),
+		setSubmitError: assign(({ event }) => {
+			const error = errorOf(event);
+			return {
+				errorKind: httpStatusOf(error) === 409 ? "busy" : "unavailable",
+				errorMessage: error instanceof Error ? error.message : String(error)
+			};
+		}),
+		clearError: assign({
+			errorKind: void 0,
+			errorMessage: void 0,
+			phoneRulesFailed: false
+		})
+	},
+	guards: {
+		phoneRulesFailed: ({ context }) => context.phoneRulesFailed,
+		isAutoExecution: ({ context }) => context.config.autoExecution,
+		canRender: ({ context }) => !!prepareEkycPrefillForm(context.config),
+		isValid: ({ context }) => Object.keys(context.errors).length === 0 && !context.anyOfError && !!context.prepared,
+		isBadRequest: ({ event }) => httpStatusOf(errorOf(event)) === 400,
+		isForbidden: ({ event }) => httpStatusOf(errorOf(event)) === 403,
+		isLimitReached: ({ event }) => httpStatusOf(errorOf(event)) === 429
+	}
+}).createMachine({
+	id: "ekycPrefill",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: toEkycPrefillConfig(input?.config),
+		prepared: void 0,
+		values: {},
+		errors: {},
+		invalidFormats: {},
+		anyOfError: false,
+		phoneRulesLoaded: false,
+		phoneRulesFailed: false,
+		submitError: void 0,
+		errorKind: void 0,
+		errorMessage: void 0
+	}),
+	states: {
+		idle: { on: { LOAD: [
+			{
+				guard: "isAutoExecution",
+				target: "finished"
+			},
+			{
+				guard: "canRender",
+				target: "form",
+				actions: "applyForm"
+			},
+			{ target: "misconfigured" }
+		] } },
+		form: {
+			invoke: {
+				id: "loadPhoneRules",
+				src: "loadPhoneRules",
+				input: ({ context }) => ({ hasPhone: !!context.prepared?.fields.some((field) => field.type === "phone") }),
+				onDone: { actions: "setPhoneRulesLoaded" },
+				onError: {
+					target: "#ekycPrefill.error",
+					actions: "setPhoneRulesFailed"
+				}
+			},
+			initial: "inputting",
+			states: {
+				inputting: { on: {
+					SET_FIELD: { actions: "setFieldValue" },
+					VALIDATE_FIELD: { actions: "validateOneField" },
+					SUBMIT: "validating"
+				} },
+				validating: {
+					entry: "validateAll",
+					always: [{
+						guard: "isValid",
+						target: "#ekycPrefill.submitting"
+					}, { target: "inputting" }]
+				}
+			},
+			on: { CLOSE: "closed" }
+		},
+		submitting: { invoke: {
+			id: "submit",
+			src: "submit",
+			input: ({ context }) => ({
+				submit: context.prepared.submit,
+				values: context.values
+			}),
+			onDone: { target: "finished" },
+			onError: [
+				{
+					guard: "isLimitReached",
+					target: "limitReached"
+				},
+				{
+					guard: "isBadRequest",
+					target: "form.inputting",
+					actions: "applyRejection"
+				},
+				{
+					guard: "isForbidden",
+					target: "misconfigured"
+				},
+				{
+					target: "error",
+					actions: "setSubmitError"
+				}
+			]
+		} },
+		/**
+		* The lookup could not run (409, 503, a network failure), or the phone
+		* rules did not load: offer a retry of whichever failed.
+		*/
+		error: { on: {
+			RETRY: [{
+				guard: "phoneRulesFailed",
+				target: "form",
+				actions: "clearError"
+			}, {
+				target: "submitting",
+				actions: "clearError"
+			}],
+			CLOSE: "closed"
+		} },
+		/** The lookup limit is reached; it does not reset within the session, so the flow moves on. */
+		limitReached: { on: {
+			CONTINUE: "finished",
+			CLOSE: "closed"
+		} },
+		/** The configuration can't be rendered, or the session's flow doesn't allow the lookup. */
+		misconfigured: { on: { CLOSE: "closed" } },
+		finished: { type: "final" },
+		closed: { type: "final" }
+	}
+});
+//#endregion
+export { toEkycPrefillConfig as i, isAnyOfMissing as n, validateForm as r, ekycPrefillMachine as t };