@incodetech/core 2.4.1-agentic → 2.4.1-agentic.1

package/dist/kybChecksStateMachine-B43NAnv7.esm.js

@@ -0,0 +1,718 @@
+import { t as api, u as endpoints } from "./api-CpP4PS4S.esm.js";
+import { i as toIncodeApiError, t as IncodeApiError } from "./apiError-DH-CH4Nz.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 { i as usStateOptions, n as checkSupport, r as DYNAMIC_REQUIRED_KEY, t as resolveForm } from "./resolveForm-O7-r79VA.esm.js";
+import { r as hasAllowedCharacters, t as formatPhoneE164 } from "./phoneFormat-JJNaWthV.esm.js";
+function isSupportedSchema(form) {
+	return String(form.schemaVersion).split(".")[0] === "1";
+}
+/** Every field of the form, in display order. */
+function formFields(form) {
+	if (!form) return [];
+	return form.steps.flatMap((step) => step.sections.flatMap((section) => section.fields));
+}
+function findField(form, name) {
+	return formFields(form).find((field) => field.name === name);
+}
+/** Blank text, or a list with no non-blank entry. */
+function isBlank(value) {
+	if (Array.isArray(value)) return value.every((v) => v.trim() === "");
+	return value === void 0 || value.trim() === "";
+}
+//#endregion
+//#region src/modules/kyb-checks/kybChecksDefinition.ts
+const KYB_CHECKS_MODULE = "kybChecks";
+/** Served field name → vocabulary group. Every group is on: the backend already chose the fields. */
+const GROUPS = {
+	country: "country",
+	taxId: "taxId",
+	businessName: "businessName",
+	alternativeNames: "alternativeNames",
+	street: "address",
+	city: "address",
+	state: "address",
+	postalCode: "address",
+	website: "website",
+	phoneNumber: "phone",
+	email: "email",
+	personNames: "personNames"
+};
+/** The group of a served field name this build has no group for. */
+const OTHER_GROUP = "other";
+/** Served field type → vocabulary kind. Any other type renders as text. */
+const KINDS = {
+	text: "text",
+	select: "choice",
+	phone: "phone",
+	list: "list"
+};
+const KEYBOARDS = /* @__PURE__ */ new Set(["url", "email"]);
+const TRANSFORMS = /* @__PURE__ */ new Set(["trim", "e164"]);
+const KYB_CHECKS_SUPPORTED_IDS = {
+	schemaVersions: [1],
+	vocabulary: "1.3",
+	kinds: new Set(Object.values(KINDS)),
+	groups: /* @__PURE__ */ new Set([...Object.values(GROUPS), OTHER_GROUP]),
+	rules: /* @__PURE__ */ new Set(["allowedCharacters"]),
+	transforms: TRANSFORMS,
+	groupRules: /* @__PURE__ */ new Set(["oneOfRequired"]),
+	optionLists: /* @__PURE__ */ new Set(["US_STATES"]),
+	conditions: /* @__PURE__ */ new Set(),
+	prefillSources: /* @__PURE__ */ new Set()
+};
+/** A served regex of the one shape `allowedCharacters` can express: `^[…]{1,n}$` or `^[…]+$`. */
+const CHARACTER_CLASS_REGEX = /^\^\[([^\]]+)\](?:\{[01],(\d+)\}|\+)\$$/;
+/**
+* Reads a served pattern as `allowedCharacters` (ASCII letters) plus a maximum
+* length. Returns `undefined` for any other regex, which the adapter leaves
+* out.
+*/
+function toCharacterPattern(regex, flags = "") {
+	const match = regex ? CHARACTER_CLASS_REGEX.exec(regex) : null;
+	if (!match || flags !== "" && flags !== "i") return void 0;
+	const [, body, max] = match;
+	let upper = false;
+	let lower = false;
+	let digit = false;
+	let space = false;
+	let extra = "";
+	for (let i = 0; i < body.length; i++) {
+		const range = body.slice(i, i + 3);
+		if (range === "A-Z" || range === "a-z" || range === "0-9") {
+			if (range === "A-Z") upper = true;
+			if (range === "a-z") lower = true;
+			if (range === "0-9") digit = true;
+			i += 2;
+		} else if (body[i] === "\\" && i + 1 < body.length) {
+			const escaped = body[++i];
+			if (escaped === "d") digit = true;
+			else if (/[A-Za-z]/.test(escaped)) return void 0;
+			else extra += escaped;
+		} else if (body[i] === "-" && i > 0 && i < body.length - 1) return;
+		else if (body[i] === " ") space = true;
+		else extra += body[i];
+	}
+	const letter = upper && lower || flags === "i" && (upper || lower);
+	if ((upper || lower) && !letter) return void 0;
+	const classes = [];
+	if (letter) classes.push("letter");
+	if (digit) classes.push("digit");
+	if (space) classes.push("space");
+	return {
+		classes,
+		extra,
+		max: max ? Number(max) : void 0
+	};
+}
+const toFormText = ({ key, text }) => ({
+	key,
+	text
+});
+function toField(field, section, country) {
+	const options = field.options?.map((option) => ({
+		value: option.value,
+		label: toFormText(option.label)
+	}));
+	let kind = KINDS[field.type] ?? "text";
+	if (kind === "choice" && !options?.length) kind = "text";
+	const rules = [];
+	let maxLength;
+	for (const rule of field.rules) {
+		if (rule.kind !== "pattern" || kind === "phone") continue;
+		const pattern = toCharacterPattern(rule.regex, rule.flags);
+		if (!pattern) continue;
+		rules.push({
+			id: "allowedCharacters",
+			params: {
+				classes: pattern.classes,
+				extra: pattern.extra,
+				ascii: true
+			},
+			message: toFormText(rule.message)
+		});
+		if (pattern.max !== void 0) maxLength = Math.min(maxLength ?? pattern.max, pattern.max);
+	}
+	const keyboard = field.input?.keyboard;
+	const input = {
+		...maxLength !== void 0 && { maxLength },
+		...keyboard && KEYBOARDS.has(keyboard) && { keyboard }
+	};
+	const usStates = kind === "choice" && field.name === "state" && country === "US";
+	return {
+		name: field.name,
+		kind,
+		group: GROUPS[field.name] ?? OTHER_GROUP,
+		section,
+		required: field.required,
+		label: toFormText(field.label),
+		...Object.keys(input).length > 0 && { input },
+		...kind === "choice" && (usStates ? { optionsRef: "US_STATES" } : { options }),
+		...kind === "phone" && { phone: {
+			lockCountry: !field.phone?.allowCountryChange,
+			defaultCountry: "definition"
+		} },
+		...rules.length > 0 && { rules },
+		payload: {
+			key: field.payload.key,
+			transforms: field.payload.transforms.filter((id) => TRANSFORMS.has(id)).map((id) => ({ id })),
+			omitWhenEmpty: field.payload.omitWhenEmpty
+		}
+	};
+}
+function toGroupRules(form, names) {
+	return [...form.rules, ...formFields(form).flatMap((field) => field.rules)].flatMap((rule) => {
+		const fields = (rule.fields ?? []).filter((name) => names.has(name));
+		if (rule.kind !== "requireAnyOf" || fields.length === 0) return [];
+		return [{
+			id: "oneOfRequired",
+			fields,
+			message: toFormText(rule.message)
+		}];
+	});
+}
+/**
+* The served form as a form definition, plus what the definition has no slot
+* for. Steps are flattened: the backend always sends one.
+*/
+function toKybChecksDefinition(form) {
+	const country = form.context.country;
+	const sections = [];
+	const fields = [];
+	const layoutFields = {};
+	for (const step of form.steps) for (const section of step.sections) {
+		sections.push(section.title ? {
+			id: section.id,
+			title: toFormText(section.title)
+		} : { id: section.id });
+		for (const field of section.fields) {
+			fields.push(toField(field, section.id, country));
+			layoutFields[field.name] = {
+				value: field.value,
+				readonly: field.display !== "editable",
+				...field.refetchOnChange && { refetchOnChange: field.refetchOnChange }
+			};
+		}
+	}
+	const groupRules = toGroupRules(form, new Set(fields.map((field) => field.name)));
+	return {
+		definition: {
+			schemaVersion: 1,
+			vocabulary: KYB_CHECKS_SUPPORTED_IDS.vocabulary,
+			id: `${KYB_CHECKS_MODULE}/${country ?? "country"}`,
+			module: KYB_CHECKS_MODULE,
+			...country && { country },
+			sections,
+			fields,
+			...groupRules.length > 0 && { groupRules },
+			submit: { static: form.submit?.static ?? {} }
+		},
+		layout: {
+			title: form.steps[0]?.title,
+			fields: layoutFields
+		}
+	};
+}
+//#endregion
+//#region src/modules/kyb-checks/kybChecksFields.ts
+const PHONE_FORMAT_ERROR = {
+	key: "kyb.errors.phoneNumberFormat",
+	text: "Enter a valid phone number"
+};
+const INVALID_CHARACTERS = {
+	key: "verification.errors.invalidCharacters",
+	text: "Use only the allowed characters"
+};
+const ALL_GROUPS_ON = Object.fromEntries([...KYB_CHECKS_SUPPORTED_IDS.groups].map((group) => [group, true]));
+const TYPES = {
+	choice: "dropdown",
+	phone: "phone",
+	list: "list"
+};
+const toText = (text, fallback) => text ? {
+	key: text.key,
+	text: text.text ?? fallback.text
+} : fallback;
+const fromFormText = (text) => ({
+	key: text.key,
+	text: text.text ?? ""
+});
+function projectRules(rules, required, maxLength) {
+	const validation = required ? [{ type: "required" }] : [];
+	let lengthMessage;
+	for (const rule of rules ?? []) {
+		if (rule.id !== "allowedCharacters") continue;
+		const params = rule.params ?? {};
+		const message = toText(rule.message, INVALID_CHARACTERS);
+		validation.push({
+			type: "allowedCharacters",
+			classes: params.classes ?? [],
+			extra: typeof params.extra === "string" ? params.extra : "",
+			ascii: params.ascii === true,
+			message
+		});
+		lengthMessage ??= message;
+	}
+	if (maxLength !== void 0 && lengthMessage) validation.push({
+		type: "maxLength",
+		max: maxLength,
+		message: lengthMessage
+	});
+	return validation;
+}
+function projectField(resolved, layout, country) {
+	const { field, required, phoneLocked } = resolved;
+	const type = TYPES[field.kind] ?? "text";
+	const served = layout.fields[field.name];
+	const keyboard = field.input?.keyboard;
+	const maxLength = field.input?.maxLength;
+	const options = field.optionsRef === "US_STATES" ? usStateOptions.map((option) => ({ ...option })) : field.options?.map((option) => ({
+		value: option.value,
+		label: option.label.key,
+		labelText: option.label.text
+	}));
+	return {
+		name: field.name,
+		type,
+		label: field.label.key,
+		labelText: field.label.text ?? "",
+		required,
+		...field.section && { section: field.section },
+		...maxLength !== void 0 && { maxLength },
+		...type === "dropdown" && { options },
+		...(keyboard === "url" || keyboard === "email") && { inputType: keyboard },
+		...type === "phone" && {
+			phoneCountry: country,
+			disableCountrySelector: phoneLocked
+		},
+		...served?.readonly && { readonly: true },
+		...served?.refetchOnChange && { refetchOnChange: served.refetchOnChange },
+		initialValue: served?.value ?? (type === "list" ? [] : ""),
+		validation: projectRules(field.rules, required, maxLength)
+	};
+}
+const preparedForms = /* @__PURE__ */ new WeakMap();
+/**
+* The served form on the forms kernel: translated to a definition, checked,
+* resolved with every group on and projected. `undefined` when this build
+* can't render it: a newer schema major, or an adapter output that fails
+* `checkSupport`, which would be a bug in the adapter.
+*/
+function prepareKybChecksForm(form) {
+	if (preparedForms.has(form)) return preparedForms.get(form) ?? void 0;
+	let prepared = null;
+	if (isSupportedSchema(form)) {
+		const { definition, layout } = toKybChecksDefinition(form);
+		const support = checkSupport(definition, KYB_CHECKS_SUPPORTED_IDS);
+		if (support.supported) {
+			const resolved = resolveForm(definition, { groups: ALL_GROUPS_ON });
+			const sections = (definition.sections ?? []).map((section) => ({
+				id: section.id,
+				...section.title && { title: fromFormText(section.title) },
+				fields: resolved.fields.filter((field) => field.field.section === section.id).map((field) => projectField(field, layout, definition.country))
+			}));
+			const formRules = resolved.groupRules.map(({ rule, fields }) => ({
+				type: "oneOfRequired",
+				fields: [...fields],
+				message: fromFormText(rule.message ?? { key: rule.id })
+			}));
+			prepared = {
+				submit: toSubmitPlan(definition),
+				title: layout.title,
+				sections,
+				formRules
+			};
+		} else console.warn("[kyb-checks] Unsupported form definition", support.problems);
+	}
+	preparedForms.set(form, prepared);
+	return prepared ?? void 0;
+}
+function sectionFields(prepared) {
+	return prepared.sections.flatMap((section) => section.fields);
+}
+function canKeep(field, before, value) {
+	if (field.readonly) return false;
+	if (before && before.type !== field.type) return false;
+	if (Array.isArray(value) !== Array.isArray(field.initialValue)) return false;
+	if (field.type !== "dropdown" || value === "") return true;
+	return (field.options ?? []).some((option) => option.value === value);
+}
+/**
+* Values for a newly fetched form. What the user entered carries over to the
+* field of the same name only when that field is editable, has the same type
+* and shape as before and, for a dropdown, still offers the value. A phone
+* the input flagged as invalid stays flagged with it. Every other field
+* starts from its served value.
+*/
+function carryOverValues(prepared, before, previous, invalidFormats) {
+	const beforeFields = new Map((before ? sectionFields(before) : []).map((field) => [field.name, field]));
+	const values = {};
+	const stillInvalid = {};
+	for (const field of sectionFields(prepared)) {
+		const kept = previous[field.name];
+		if (kept !== void 0 && canKeep(field, beforeFields.get(field.name), kept)) {
+			values[field.name] = kept;
+			if (field.type === "phone" && invalidFormats[field.name]) stillInvalid[field.name] = true;
+		} else values[field.name] = field.initialValue;
+	}
+	return {
+		values,
+		invalidFormats: stillInvalid
+	};
+}
+function requiredMessage(field) {
+	return {
+		key: DYNAMIC_REQUIRED_KEY,
+		text: `${field.labelText} is required`,
+		params: { fieldName: {
+			key: field.label,
+			text: field.labelText
+		} }
+	};
+}
+function failsRule(rule, value) {
+	if (rule.type === "required") return isBlank(value);
+	const entries = (Array.isArray(value) ? value : [value]).map((entry) => entry.trim()).filter((entry) => entry !== "");
+	if (rule.type === "maxLength") return entries.some((entry) => entry.length > rule.max);
+	return entries.some((entry) => !hasAllowedCharacters(entry, rule.classes, rule.extra, rule.ascii));
+}
+/** The first failing rule's message for a field, in rule order. */
+function validateField(field, values, invalidFormats = {}) {
+	const value = values[field.name] ?? field.initialValue;
+	for (const rule of field.validation) if (failsRule(rule, value)) return rule.type === "required" ? requiredMessage(field) : rule.message;
+	if (invalidFormats[field.name] && !isBlank(value)) return PHONE_FORMAT_ERROR;
+}
+/**
+* Errors for the whole form. A form-level rule is shown on the first field it
+* names, unless that field already has an error.
+*/
+function validateForm(prepared, values, invalidFormats = {}) {
+	const errors = {};
+	for (const field of sectionFields(prepared)) {
+		const error = validateField(field, values, invalidFormats);
+		if (error) errors[field.name] = error;
+	}
+	for (const rule of prepared.formRules) {
+		const [target] = rule.fields;
+		const allBlank = rule.fields.every((name) => isBlank(values[name]));
+		if (target && !errors[target] && allBlank) errors[target] = rule.message;
+	}
+	return errors;
+}
+function applyTransforms(value, transforms, country) {
+	let current = value;
+	for (const transform of transforms) if (transform === "trim") current = Array.isArray(current) ? current.map((entry) => entry.trim()) : current.trim();
+	else if (transform === "e164" && typeof current === "string") current = current ? formatPhoneE164(current, country ?? "") : current;
+	return current;
+}
+/**
+* The request body the definition describes, in the module's own terms.
+* `submit.static` wins over a field with the same key: the backend sends the
+* country both ways, with the same value. The catalog compiler rejects two
+* fields writing one key, but a served form is never compiled, so a later
+* field whose key an earlier field already writes is left out, with a warning.
+*/
+function toSubmitPlan(definition) {
+	const staticKeys = new Set(Object.keys(definition.submit.static ?? {}));
+	const claimed = /* @__PURE__ */ new Set();
+	const fields = [];
+	for (const field of definition.fields) {
+		if (field.payload?.omit) continue;
+		const key = field.payload?.key ?? field.name;
+		if (staticKeys.has(key)) continue;
+		if (claimed.has(key)) {
+			console.warn(`[kyb-checks] Not sending field "${field.name}": request key "${key}" is already written`);
+			continue;
+		}
+		claimed.add(key);
+		fields.push({
+			name: field.name,
+			key,
+			transforms: (field.payload?.transforms ?? []).map((t) => t.id),
+			omitWhenEmpty: field.payload?.omitWhenEmpty === true,
+			isList: field.kind === "list"
+		});
+	}
+	return {
+		static: { ...definition.submit.static },
+		country: definition.country,
+		fields
+	};
+}
+/**
+* The `POST /omni/kyb` body: `submit.static`, then each field's value under
+* its request key after its transforms. List fields drop blank entries, and
+* a field marked `omitWhenEmpty` is left out when it's empty.
+*/
+function buildSubmitBody(submit, values) {
+	const body = { ...submit.static };
+	for (const field of submit.fields) {
+		let value = applyTransforms(values[field.name] ?? (field.isList ? [] : ""), field.transforms, submit.country);
+		if (Array.isArray(value)) value = value.filter((entry) => entry.trim() !== "");
+		if (field.omitWhenEmpty && isBlank(value)) continue;
+		body[field.key] = value;
+	}
+	return body;
+}
+//#endregion
+//#region src/modules/kyb-checks/kybChecksServices.ts
+/**
+* Fetches the KYB form for the session. Without `country` it holds only the
+* country picker; with it, the fields that country needs and a `submit` block.
+*/
+async function fetchKybForm(country, signal) {
+	try {
+		const res = await api.get(endpoints.kybForm, {
+			query: { country },
+			signal
+		});
+		if (!res.ok) throw res;
+		return res.data;
+	} catch (error) {
+		throw toIncodeApiError(endpoints.kybForm, error);
+	}
+}
+/**
+* Runs the KYB checks. Always posts to `endpoints.kybSubmit`: the form's
+* `submit.endpoint` and `submit.method` are not followed.
+*/
+async function submitKyb(body, signal) {
+	try {
+		const res = await api.post(endpoints.kybSubmit, body, { signal });
+		if (!res.ok) throw res;
+		return res.data;
+	} catch (error) {
+		throw toIncodeApiError(endpoints.kybSubmit, error);
+	}
+}
+//#endregion
+//#region src/modules/kyb-checks/kybChecksStateMachine.ts
+/** The only `refetchOnChange` query parameter `GET /omni/kyb/form` takes. */
+const COUNTRY_PARAM = "country";
+function isForbidden(error) {
+	return error instanceof IncodeApiError && error.httpStatus === 403;
+}
+/**
+* A submit is retried only when the server answered with a 4xx: it rejected
+* the request, so no check ran. After a timeout, a network failure or a 5xx
+* the checks may already have run, and `POST /omni/kyb` has no duplicate
+* guard, so a retry could run (and charge) them twice.
+*/
+function canRetrySubmit(error) {
+	return error instanceof IncodeApiError && error.httpStatus >= 400 && error.httpStatus < 500;
+}
+function errorMessageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+const kybChecksMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {},
+		output: {}
+	},
+	actors: {
+		fetchForm: fromPromise(async ({ input, signal }) => fetchKybForm(input.country, signal)),
+		submit: fromPromise(async ({ input, signal }) => {
+			await loadPhoneValidation();
+			return submitKyb(buildSubmitBody(input.submit, input.values), signal);
+		})
+	},
+	actions: {
+		startPhoneValidationLoad: () => {
+			loadPhoneValidation();
+		},
+		applyForm: assign(({ context, event }) => {
+			const form = event.output;
+			const prepared = prepareKybChecksForm(form);
+			return {
+				form,
+				prepared,
+				...carryOverValues(prepared, context.prepared, context.values, context.invalidFormats),
+				errors: {},
+				country: form.context.country ?? context.country
+			};
+		}),
+		setFieldValue: assign(({ context, event }) => {
+			const { name, value, isValid } = event;
+			const invalidFormats = { ...context.invalidFormats };
+			if (isValid === false) invalidFormats[name] = true;
+			else delete invalidFormats[name];
+			const errors = { ...context.errors };
+			delete errors[name];
+			return {
+				values: {
+					...context.values,
+					[name]: value
+				},
+				errors,
+				invalidFormats
+			};
+		}),
+		setCountryFromEvent: assign(({ event }) => ({ country: String(event.value) })),
+		validateAll: assign(({ context }) => ({ errors: context.prepared ? validateForm(context.prepared, context.values, context.invalidFormats) : {} })),
+		setLoadError: assign(({ event }) => ({
+			errorKind: "load",
+			canRetry: true,
+			errorMessage: errorMessageOf(event.error)
+		})),
+		setSubmitError: assign(({ event }) => {
+			const { error } = event;
+			return {
+				errorKind: "submit",
+				canRetry: canRetrySubmit(error),
+				errorMessage: errorMessageOf(error)
+			};
+		}),
+		clearError: assign({
+			errorKind: void 0,
+			errorMessage: void 0,
+			canRetry: false
+		}),
+		setResult: assign(({ event }) => ({ result: { referenceId: event.output?.referenceId } }))
+	},
+	guards: {
+		isSupportedForm: ({ event }) => !!prepareKybChecksForm(event.output),
+		isForbidden: ({ event }) => isForbidden(event.error),
+		changesCountry: ({ context, event }) => {
+			const { name, value } = event;
+			return findField(context.form, name)?.refetchOnChange === COUNTRY_PARAM && typeof value === "string" && value !== "" && value !== context.country;
+		},
+		hasNoErrors: ({ context }) => Object.keys(context.errors).length === 0 && !!context.form?.submit,
+		failedLoadingFirstForm: ({ context }) => context.errorKind === "load" && context.form === void 0,
+		failedLoading: ({ context }) => context.errorKind === "load",
+		canRetry: ({ context }) => context.canRetry
+	}
+}).createMachine({
+	id: "kybChecks",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input?.config ?? {},
+		form: void 0,
+		prepared: void 0,
+		values: {},
+		errors: {},
+		invalidFormats: {},
+		country: void 0,
+		errorKind: void 0,
+		errorMessage: void 0,
+		canRetry: false,
+		result: void 0
+	}),
+	output: ({ context }) => context.result ?? {},
+	states: {
+		idle: { on: { LOAD: "loading" } },
+		loading: {
+			entry: "startPhoneValidationLoad",
+			invoke: {
+				id: "fetchForm",
+				src: "fetchForm",
+				input: ({ context }) => ({ country: context.country }),
+				onDone: [{
+					guard: "isSupportedForm",
+					target: "form",
+					actions: "applyForm"
+				}, { target: "misconfigured" }],
+				onError: [{
+					guard: "isForbidden",
+					target: "misconfigured"
+				}, {
+					target: "error",
+					actions: "setLoadError"
+				}]
+			}
+		},
+		form: {
+			initial: "inputting",
+			states: {
+				inputting: { on: {
+					SET_FIELD: [{
+						guard: "changesCountry",
+						target: "refetching",
+						actions: ["setFieldValue", "setCountryFromEvent"]
+					}, { actions: "setFieldValue" }],
+					SUBMIT: "validating"
+				} },
+				refetching: {
+					invoke: {
+						id: "refetchForm",
+						src: "fetchForm",
+						input: ({ context }) => ({ country: context.country }),
+						onDone: [{
+							guard: "isSupportedForm",
+							target: "inputting",
+							actions: "applyForm"
+						}, { target: "#kybChecks.misconfigured" }],
+						onError: [{
+							guard: "isForbidden",
+							target: "#kybChecks.misconfigured"
+						}, {
+							target: "#kybChecks.error",
+							actions: "setLoadError"
+						}]
+					},
+					on: { SET_FIELD: [{
+						guard: "changesCountry",
+						target: "refetching",
+						reenter: true,
+						actions: ["setFieldValue", "setCountryFromEvent"]
+					}, { actions: "setFieldValue" }] }
+				},
+				validating: {
+					entry: "validateAll",
+					always: [{
+						guard: "hasNoErrors",
+						target: "#kybChecks.submitting"
+					}, { target: "inputting" }]
+				}
+			},
+			on: { CLOSE: "closed" }
+		},
+		submitting: { invoke: {
+			id: "submit",
+			src: "submit",
+			input: ({ context }) => ({
+				submit: context.prepared?.submit,
+				values: context.values
+			}),
+			onDone: {
+				target: "finished",
+				actions: "setResult"
+			},
+			onError: [{
+				guard: "isForbidden",
+				target: "misconfigured"
+			}, {
+				target: "error",
+				actions: "setSubmitError"
+			}]
+		} },
+		error: { on: {
+			RETRY: [
+				{
+					guard: "failedLoadingFirstForm",
+					target: "loading",
+					actions: "clearError"
+				},
+				{
+					guard: "failedLoading",
+					target: "form.refetching",
+					actions: "clearError"
+				},
+				{
+					guard: "canRetry",
+					target: "submitting",
+					actions: "clearError"
+				}
+			],
+			CLOSE: "closed"
+		} },
+		/** KYB is not in the session's flow, the session is closed, or the form schema is newer than this SDK. */
+		misconfigured: { on: { CLOSE: "closed" } },
+		finished: { type: "final" },
+		closed: { type: "final" }
+	}
+});
+//#endregion
+export { kybChecksMachine as t };