@adyen/kyc-components 4.13.0-beta.6 → 4.14.0-beta.0

package/dist/validateExtractionResult-CHdmHmkZ.js

@@ -0,0 +1,1070 @@
+try {
+	let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+	n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "dc47ac8d-8ed9-4bfd-9a91-7b188b192f99", e._sentryDebugIdIdentifier = "sentry-dbid-dc47ac8d-8ed9-4bfd-9a91-7b188b192f99");
+} catch (e) {}
+import { i as Typography, o as createLogger, r as useTranslation } from "./translation-ZXpd9jdD.js";
+import { P as listToRecord, x as Alert } from "./resolveEnvironment-Doi5jM7g.js";
+import { n as IconButton, t as Button } from "./Button-DBN5gM_d.js";
+import { r as httpPost, s as useApiContext } from "./http-DYzfwjcs.js";
+import { l as keysOf, o as objectsDeepEqual, s as pick, u as valuesOf } from "./AnalyticsContext-BFrJmsp0.js";
+import { t as CountryCodes } from "./country-code-CJk2hdPu.js";
+import { t as Modal } from "./Modal-BgeE7zM2.js";
+import { n as translateTranslatable } from "./utils-DcUoR5qG.js";
+import { t as Confirm } from "./Confirm-C4GotFqm.js";
+import { n as mergeFieldMetadataIntoProps, t as createFormUtils } from "./formUtils-DVc3a6gf.js";
+import { a as alphanumericInputs, c as nonInputs, i as alphaInputs, l as numericInputs, o as customInputs, s as makeMask, t as MaskedInput, u as spacer } from "./MaskedInput-C_rP9ADy.js";
+import { t as localizeDateString } from "./localizeDateString-DB-oTe60.js";
+import { t as uppercase } from "./uppercase-DvjwUM0n.js";
+import { o as validatePatternOnBlur } from "./patternValidators-DWouiOVO.js";
+import { t as resolveFieldMetadata } from "./fieldConfigurations-CZCFghnK.js";
+import { t as Field } from "./Field-CQWAWo5U.js";
+import { t as Checkbox } from "./Checkbox-tUvgt59R.js";
+import { n as RadioWithLabel } from "./RadioGroup-DlzXLoMN.js";
+import { t as isEmpty } from "./isEmpty-BVlBH98t.js";
+import { t as Spacer } from "./Spacer-CEHRO4Ml.js";
+import { useCallback, useEffect, useMemo, useState } from "preact/hooks";
+import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
+import { useMutation, useQuery } from "@tanstack/preact-query";
+//#region src/utils/regex/countryIdNumberPatterns.ts
+var CountryIdNumberPatterns = {
+	[CountryCodes.Brazil]: /^\d{11}$/,
+	[CountryCodes.Canada]: /^\d{9}$/,
+	[CountryCodes.Croatia]: /^\d{11}$/,
+	[CountryCodes.Denmark]: /^\d{10}$/,
+	[CountryCodes.Italy]: /^[A-Z]{6}[0-9]{2}[ABCDEHLMPRST][0-9]{2}[A-Z][0-9]{3}[A-Z]$/,
+	[CountryCodes.Poland]: /^\d{11}$/,
+	[CountryCodes.Romania]: /^\d{13}$/,
+	[CountryCodes.Singapore]: /^[A-Z][0-9]{7}[A-Z]$/,
+	[CountryCodes.Spain]: {
+		dni: /(^[KL]?\d{8}[A-Z]$)/,
+		nie: /(^[MXYZ]\d{7,8}[A-Z]$)/
+	},
+	[CountryCodes.Sweden]: /^\d{10}$|^\d{12}$/,
+	[CountryCodes.UnitedStates]: {
+		ssn: /^\d{9}$/,
+		ssnLastFour: /^\d{4}$/
+	}
+};
+//#endregion
+//#region src/utils/regex/driversLicenseCardNumberPatterns.ts
+var DriversLicenseCardNumberPatterns = {
+	[CountryCodes.NewZealand]: /^[\d]{3}$/,
+	[CountryCodes.Australia]: /^[A-Z0-9]{5,11}$/
+};
+//#endregion
+//#region src/utils/regex/driversLicenseNumberPatterns.ts
+var DriversLicenseNumberPatterns = {
+	[CountryCodes.Australia]: /^[A-Za-z0-9]{5,11}$/,
+	[CountryCodes.HongKong]: /^[A-Z0-9]{8}$/,
+	[CountryCodes.NewZealand]: /^[A-Z]{2}[0-9]{6}$/
+};
+//#endregion
+//#region src/utils/regex/passportNumberPatterns.ts
+var PassportNumberPatterns = {
+	[CountryCodes.Australia]: /^[A-Z0-9]{8,9}$/,
+	[CountryCodes.HongKong]: /^[A-Z0-9]{9}$/,
+	[CountryCodes.NewZealand]: /^[A-Z0-9]{8,9}$/
+};
+//#endregion
+//#region src/utils/regex/proofOfIdentityCardPatterns.ts
+var ProofOfIdentityCardPatterns = { [CountryCodes.HongKong]: /^[A-Z]{1,2}[0-9]{6}[0-9A]$/ };
+//#endregion
+//#region src/utils/verification/helpers/verifyIdNumber.ts
+var COUNTRY_ID_NUMBER_MASKS = {
+	[CountryCodes.PuertoRico]: { length: 4 },
+	[CountryCodes.UnitedStates]: { length: 4 }
+};
+var COUNTRY_ID_NUMBER_UNMASKED = {
+	[CountryCodes.PuertoRico]: { length: 9 },
+	[CountryCodes.UnitedStates]: { length: 9 }
+};
+var ID_NUMBER_VERIFICATION_COUNTRIES = [CountryCodes.PuertoRico, CountryCodes.UnitedStates];
+var FIELD = "idNumber";
+var handleVerifyIdNumber = async (formData, basicDetails, verifyFn) => {
+	const country = formData.country;
+	const verified = {
+		field: "idNumber",
+		isVerified: true
+	};
+	if (formData.idNumberExempt || !country) return verified;
+	if (!ID_NUMBER_VERIFICATION_COUNTRIES.includes(country)) return verified;
+	const isCountryWithMaskedIdNumber = Object.keys(COUNTRY_ID_NUMBER_MASKS).includes(country);
+	const isValueMasked = formData.idNumber?.length === COUNTRY_ID_NUMBER_MASKS[country]?.length;
+	const hasCompleteValue = formData.idNumber?.length === COUNTRY_ID_NUMBER_UNMASKED[country]?.length;
+	if (isCountryWithMaskedIdNumber && isValueMasked) return verified;
+	if (!hasCompleteValue) return {
+		field: "idNumber",
+		isVerified: false
+	};
+	const response = await verifyFn({
+		name: {
+			firstName: basicDetails.firstName || "",
+			lastName: basicDetails.lastName || ""
+		},
+		countryCode: country,
+		idNumber: formData.idNumber || ""
+	});
+	if (response?.status === 422 || response?.verified === "false") return {
+		field: FIELD,
+		isVerified: false
+	};
+	return {
+		field: FIELD,
+		isVerified: true
+	};
+};
+//#endregion
+//#region src/components/Individual/fields/IdentityNumber/fieldConfig.ts
+var getAsyncIdNumberValidationRule = (verifyIdNumber, additionalPersonalDetails, basicDetails) => ({ idNumber: {
+	asyncValidate: async (idNumber) => {
+		if (!idNumber || !additionalPersonalDetails || !basicDetails) return false;
+		return (await handleVerifyIdNumber(additionalPersonalDetails, basicDetails, verifyIdNumber)).isVerified;
+	},
+	errorMessage: "unableToVerifyTheIdNumber",
+	modes: ["blur", "input"]
+} });
+var defaultFieldMetadata = { label: "idNumber" };
+var defaultFieldConfig = {
+	[CountryCodes.Brazil]: {
+		label: "cadastroDePessoasFisicas",
+		mask: { mask: makeMask(...numericInputs(3), ...nonInputs(" . "), ...numericInputs(3), ...nonInputs(" . "), ...numericInputs(3), ...nonInputs(" - "), ...numericInputs(2)) },
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Brazil]),
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "11",
+				example: "231.002.999-00"
+			}
+		}
+	},
+	[CountryCodes.Canada]: {
+		label: "socialInsuranceNumber",
+		mask: { mask: makeMask(...numericInputs(3), spacer, ...numericInputs(3), spacer, ...numericInputs(3)) },
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Canada]),
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "9",
+				example: "046 454 286"
+			}
+		}
+	},
+	[CountryCodes.Croatia]: {
+		label: "oib",
+		mask: { mask: makeMask(...numericInputs(11)) },
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Croatia]),
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "11",
+				example: "94577403194"
+			}
+		}
+	},
+	[CountryCodes.Denmark]: {
+		label: "detCentralePersonregister",
+		mask: { mask: makeMask(...numericInputs(6), ...nonInputs(" - "), ...numericInputs(4)) },
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Denmark]),
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "10",
+				example: "010111-1113"
+			}
+		}
+	},
+	[CountryCodes.Italy]: {
+		label: "codiceFiscale",
+		mask: {
+			mask: makeMask(...alphaInputs(6), ...numericInputs(2), ...customInputs(1, /^[ABCDEHLMPRST]$/), ...numericInputs(2), ...alphaInputs(1), ...numericInputs(3), ...alphaInputs(1)),
+			transformOnType: uppercase
+		},
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Italy]),
+		guidanceText: {
+			key: "enterNCharactersWithAMixForExample",
+			values: {
+				numChars: "16",
+				example: "YULSQG40E60L271T"
+			}
+		}
+	},
+	[CountryCodes.Poland]: {
+		label: "peselNumber",
+		mask: { mask: makeMask(...numericInputs(11)) },
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Poland]),
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "11",
+				example: "23012224757"
+			}
+		}
+	},
+	[CountryCodes.PuertoRico]: ({ idNumberType }) => {
+		switch (idNumberType) {
+			case "ssn": return {
+				label: "socialSecurityNumber",
+				mask: { mask: makeMask(...numericInputs(3), ...nonInputs(" - "), ...numericInputs(2), ...nonInputs(" - "), ...numericInputs(4)) },
+				validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.UnitedStates].ssn),
+				guidanceText: {
+					key: "enterNDigitsForExample",
+					values: {
+						numDigits: "9",
+						example: "123-12-1234"
+					}
+				}
+			};
+			default: return {
+				label: "last4DigitsOfSocialSecurityNumber",
+				mask: { mask: makeMask(...numericInputs(4)) },
+				validators: {
+					modes: ["blur"],
+					validate: (val) => !!val && CountryIdNumberPatterns[CountryCodes.UnitedStates].ssnLastFour.test(val),
+					errorMessage: "mustContain4Digits"
+				}
+			};
+		}
+	},
+	[CountryCodes.Romania]: {
+		label: "codNumericPersonal",
+		mask: { mask: makeMask(...numericInputs(13)) },
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Romania]),
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "13",
+				example: "8001011234567"
+			}
+		}
+	},
+	[CountryCodes.Singapore]: {
+		label: "nric",
+		mask: {
+			mask: makeMask(...alphaInputs(1), ...numericInputs(7), ...alphaInputs(1)),
+			transformOnType: uppercase
+		},
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Singapore]),
+		guidanceText: {
+			key: "enterNCharactersWithAMixForExample",
+			values: {
+				numChars: "9",
+				example: "T9123456J"
+			}
+		}
+	},
+	[CountryCodes.Spain]: ({ idNumberType }) => {
+		switch (idNumberType) {
+			case "dni": return {
+				label: "dni",
+				mask: {
+					mask: makeMask(...customInputs(1, /^[KL]$/, true), ...numericInputs(8), ...alphaInputs(1)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Spain].dni),
+				guidanceText: {
+					key: "enterXToYCharactersWithAMixForExample",
+					values: {
+						minChars: "9",
+						maxChars: "10",
+						example: "12345678A or L12345678A"
+					}
+				}
+			};
+			default: return {
+				label: "nie",
+				mask: {
+					mask: makeMask(...customInputs(1, /^[MXYZ]$/), ...numericInputs(7), ...numericInputs(1, true), ...alphaInputs(1)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Spain].nie),
+				guidanceText: {
+					key: "enterXToYCharactersWithAMixForExample",
+					values: {
+						minChars: "9",
+						maxChars: "10",
+						example: "X12345678A or Z6527153N"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Sweden]: {
+		label: "personnummer",
+		mask: { mask: makeMask(...numericInputs(6), ...numericInputs(2, true), ...nonInputs(" - "), ...numericInputs(4)) },
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Sweden]),
+		guidanceText: {
+			key: "enterXOrYDigitsForExample",
+			values: {
+				xDigits: "10",
+				yDigits: "12",
+				example: "640823-3234 or 19640823-3234"
+			}
+		}
+	},
+	[CountryCodes.UnitedStates]: ({ idNumberType }) => {
+		switch (idNumberType) {
+			case "ssn": return {
+				label: "socialSecurityNumber",
+				mask: { mask: makeMask(...numericInputs(3), ...nonInputs(" - "), ...numericInputs(2), ...nonInputs(" - "), ...numericInputs(4)) },
+				validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.UnitedStates].ssn),
+				guidanceText: {
+					key: "enterNDigitsForExample",
+					values: {
+						numDigits: "9",
+						example: "123-12-1234"
+					}
+				}
+			};
+			default: return {
+				label: "last4DigitsOfSocialSecurityNumber",
+				mask: { mask: makeMask(...numericInputs(4)) },
+				validators: {
+					modes: ["blur"],
+					validate: (val) => !!val && CountryIdNumberPatterns[CountryCodes.UnitedStates].ssnLastFour.test(val),
+					errorMessage: "mustContain4Digits"
+				}
+			};
+		}
+	},
+	[CountryCodes.NewZealand]: ({ idNumberType }) => {
+		switch (idNumberType) {
+			case "passport": return {
+				label: "passportNumber",
+				mask: {
+					mask: makeMask(...alphanumericInputs(9)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(PassportNumberPatterns[CountryCodes.NewZealand]),
+				guidanceText: {
+					key: "enterXToYCharactersWithAMixForExample",
+					values: {
+						minChars: "8",
+						maxChars: "9",
+						example: "RA000750"
+					}
+				}
+			};
+			default: return {
+				label: "licenseNumber",
+				mask: {
+					mask: makeMask(...alphaInputs(2), ...numericInputs(6)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(DriversLicenseNumberPatterns[CountryCodes.NewZealand]),
+				guidanceText: {
+					key: "enterNCharactersWithAMixForExample",
+					values: {
+						numChars: "8",
+						example: "KA111112"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.HongKong]: ({ idNumberType }) => {
+		switch (idNumberType) {
+			case "proofOfIdentityCard": return {
+				label: "hkid",
+				mask: {
+					mask: makeMask(...alphaInputs(1), ...alphaInputs(1, true), ...numericInputs(6), ...nonInputs("(", { displayEagerly: false }), ...customInputs(1, /^[0-9A]$/), ...nonInputs(")")),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(ProofOfIdentityCardPatterns[CountryCodes.HongKong]),
+				guidanceText: {
+					key: "enterXToYCharactersWithAMixForExample",
+					values: {
+						minChars: "8",
+						maxChars: "9",
+						example: "Z683365(5) or AB123456(A)"
+					}
+				}
+			};
+			case "passport": return {
+				label: "passportNumber",
+				mask: {
+					mask: makeMask(...alphanumericInputs(9)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(PassportNumberPatterns[CountryCodes.HongKong]),
+				guidanceText: {
+					key: "enterNCharactersWithAMixForExample",
+					values: {
+						numChars: "9",
+						example: "H12345678"
+					}
+				}
+			};
+			default: return {
+				label: "licenseNumber",
+				mask: {
+					mask: makeMask(...alphanumericInputs(7), spacer, ...alphanumericInputs(1)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(DriversLicenseNumberPatterns[CountryCodes.HongKong]),
+				guidanceText: {
+					key: "enterNCharactersForExample",
+					values: {
+						numChars: "8",
+						example: "A123452 0"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Australia]: ({ idNumberType }) => {
+		switch (idNumberType) {
+			case "passport": return {
+				label: "passportNumber",
+				mask: {
+					mask: makeMask(...alphanumericInputs(9)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(PassportNumberPatterns[CountryCodes.Australia]),
+				guidanceText: {
+					key: "enterXToYCharactersWithAMixForExample",
+					values: {
+						minChars: "8",
+						maxChars: "9",
+						example: "RA0123456"
+					}
+				}
+			};
+			default: return {
+				label: "licenseNumber",
+				mask: {
+					mask: makeMask(...alphanumericInputs(6), ...alphanumericInputs(5, true)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(DriversLicenseNumberPatterns[CountryCodes.Australia]),
+				guidanceText: {
+					key: "enterXToYCharactersWithAMixForExample",
+					values: {
+						minChars: "5",
+						maxChars: "11",
+						example: "2093628291"
+					}
+				}
+			};
+		}
+	}
+};
+var licenseCardNumberDefaultMetadata = { label: "licenseCardNumber" };
+var licenseCardNumberDefaultConfig = {
+	[CountryCodes.NewZealand]: {
+		label: "licenceVersionNumber",
+		mask: { mask: makeMask(...numericInputs(3)) },
+		validators: validatePatternOnBlur(DriversLicenseCardNumberPatterns[CountryCodes.NewZealand]),
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "3",
+				example: "108"
+			}
+		}
+	},
+	[CountryCodes.Australia]: {
+		label: "licenseCardNumber",
+		mask: {
+			mask: makeMask(...alphanumericInputs(6), ...alphanumericInputs(5, true)),
+			transformOnType: uppercase
+		},
+		validators: validatePatternOnBlur(DriversLicenseCardNumberPatterns[CountryCodes.Australia]),
+		guidanceText: {
+			key: "enterXToYCharactersWithAMixForExample",
+			values: {
+				minChars: "5",
+				maxChars: "11",
+				example: "2093628291"
+			}
+		}
+	}
+};
+var idNumberExemptDefaultMetadata = { label: "identityNumberExempt" };
+var idNumberExemptDefaultConfig = {
+	[CountryCodes.UnitedStates]: { label: "identityNumberExempt__US" },
+	[CountryCodes.Canada]: { label: "identityNumberExempt__CA" },
+	[CountryCodes.Singapore]: { label: "uploadDocumentForNric" }
+};
+//#endregion
+//#region src/components/Individual/fields/IdentityNumber/IdentityNumber.tsx
+var idNumberFields = ["idNumber", "idNumberExempt"];
+function IdentityNumber(props) {
+	const { t } = useTranslation("common");
+	const { country, data, errors, fieldValidationErrors, idNumberType, obscuredFields, requiredFields, optionalFields, fieldConfig: propFieldConfig, readOnlyFields, handleFieldChange, valid } = props;
+	if (!handleFieldChange) return;
+	const metadata = resolveFieldMetadata((propFieldConfig ?? defaultFieldConfig)[country], { idNumberType }, defaultFieldMetadata);
+	const formUtils = createFormUtils(mergeFieldMetadataIntoProps("idNumberExempt", resolveFieldMetadata(idNumberExemptDefaultConfig[country], {}, idNumberExemptDefaultMetadata), mergeFieldMetadataIntoProps("idNumber", metadata, {
+		requiredFields,
+		optionalFields,
+		obscuredFields,
+		readOnlyFields
+	})), t);
+	const errorMessage = formUtils.getErrorMessage("idNumber", errors, fieldValidationErrors);
+	return /* @__PURE__ */ jsx("div", { children: formUtils.isVisibleField("idNumber") && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(MaskedInput, {
+		name: "idNumber",
+		type: "text",
+		label: formUtils.getLabel("idNumber", "idNumber"),
+		formatGuidance: translateTranslatable(t, metadata.guidanceText),
+		errorMessage,
+		shouldValidate: errors?.idNumber?.hasError,
+		isValid: !!valid?.idNumber,
+		"aria-required": formUtils.isRequiredField("idNumber"),
+		"aria-invalid": !valid?.idNumber,
+		disabled: data?.idNumberExempt,
+		onBlur: handleFieldChange("idNumber", "blur"),
+		readonly: formUtils.isReadOnly("idNumber"),
+		value: data?.idNumberExempt ? "" : data?.idNumber ?? "",
+		onInput: (e) => {
+			handleFieldChange("idNumber", "input")(e);
+			handleFieldChange("idNumberExempt", "input")(false);
+		},
+		acceptObscuredValue: formUtils?.isObscured("idNumber"),
+		...formUtils.getMask("idNumber")
+	}), formUtils.isVisibleField("idNumberExempt") && /* @__PURE__ */ jsx(Field, {
+		name: "idNumberExempt",
+		children: (childProps) => /* @__PURE__ */ jsx(Checkbox, {
+			...childProps,
+			label: formUtils.getLabel("idNumberExempt"),
+			checked: Boolean(data?.idNumberExempt),
+			name: "idNumberExempt",
+			onChange: handleFieldChange("idNumberExempt")
+		})
+	})] }) });
+}
+//#endregion
+//#region src/api/idVerificationProviders/useExtractDocumentInformation.ts
+var extractDocumentInformation = async (legalEntityId, baseUrl, data) => httpPost({
+	baseUrl,
+	path: `legalEntities/${legalEntityId}/providers/idVerification/extract`
+}, data);
+var useExtractDocumentInformation = (options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	return useMutation({
+		mutationFn: (data) => extractDocumentInformation(rootLegalEntityId.value, baseUrl.value, data),
+		...options
+	});
+};
+//#endregion
+//#region src/utils/addressToString.tsx
+/**
+* Maps an Address object from the API model to the local AddressSchema used by forms.
+* This is the single source of truth for this conversion.
+* @param address - The Address object from the API (uses `street`, `street2`).
+* @returns An AddressSchema object for use in UI components (uses `address`, `otherAddressInformation`).
+*/
+var mapApiAddressToSchema = (address) => ({
+	address: address.street,
+	otherAddressInformation: address.street2,
+	city: address.city,
+	postalCode: address.postalCode,
+	stateOrProvince: address.stateOrProvince,
+	country: address.country
+});
+var appendWithPreSeparator = (existing, separator, appendix) => existing.length === 0 ? appendix : `${existing}${separator}${appendix}`;
+var addressToString = ({ address, otherAddressInformation, postalCode, city, stateOrProvince, country }, datasetUtils) => {
+	let out = "";
+	if (address) out = address;
+	if (otherAddressInformation) out = appendWithPreSeparator(out, " ", otherAddressInformation);
+	if (city) out = appendWithPreSeparator(out, ", ", city);
+	if (postalCode) out = appendWithPreSeparator(out, " ", postalCode);
+	if (stateOrProvince) out = appendWithPreSeparator(out, ", ", stateOrProvince);
+	if (country) out = appendWithPreSeparator(out, ", ", datasetUtils.getCountryName(country) ?? country);
+	return out;
+};
+//#endregion
+//#region src/hooks/useDataConflicts.ts
+var defaultConflictRule = (provided, detected) => {
+	if (detected === void 0 || detected === null) return { hasConflict: false };
+	if (provided === void 0 || provided === null) return {
+		hasConflict: false,
+		resolvedValue: detected
+	};
+	if (typeof provided === "string" && typeof detected === "string") return { hasConflict: provided.trim().toLowerCase() !== detected.trim().toLowerCase() };
+	return { hasConflict: !objectsDeepEqual(provided, detected) };
+};
+/**
+* A factory function that returns a conflict rule for the `Address` model.
+* The rule handles enrichment (auto-resolution) and deep equality checks.
+*/
+var createAddressConflictRule = (datasetUtils) => (provided, detected) => {
+	if (!detected || Object.keys(detected).length === 0) return { hasConflict: false };
+	if (!provided) return {
+		hasConflict: false,
+		resolvedValue: detected
+	};
+	if (provided.country !== detected.country) return { hasConflict: true };
+	const { country: _country, ...otherProvidedDetails } = provided;
+	if (valuesOf(otherProvidedDetails).every((value) => !value || value === "")) return {
+		hasConflict: false,
+		resolvedValue: detected
+	};
+	return { hasConflict: addressToString(mapApiAddressToSchema(provided), datasetUtils) !== addressToString(mapApiAddressToSchema(detected), datasetUtils) };
+};
+/**
+* A hook to compare two data objects and identify conflicting properties.
+* It supports custom rules for complex comparisons and can auto-resolve certain conflicts.
+*
+* @template T The shape of the data objects being compared.
+* @param providedData The primary data source (e.g., user input).
+* @param detectedData The secondary data source (e.g., OCR extraction).
+* @param rules A map of custom conflict rules for specific properties.
+* @param onAutoResolve
+* @returns An object containing the conflict status and any resolved data.
+*/
+var useDataConflicts = (providedData, detectedData, rules = {}, onAutoResolve) => {
+	const { conflictingProperties, wasAutoResolved, resolvedData, hasConflicts } = useMemo(() => {
+		if (!providedData || !detectedData) return {
+			hasConflicts: false,
+			conflictingProperties: [],
+			wasAutoResolved: false,
+			resolvedData: void 0
+		};
+		const propertiesToCompare = keysOf(detectedData);
+		const conflictingProperties = [];
+		const autoResolvedPatches = /* @__PURE__ */ new Map();
+		for (const property of propertiesToCompare) {
+			const result = (rules[property] || defaultConflictRule)(providedData[property], detectedData[property]);
+			if (result.hasConflict) conflictingProperties.push(property);
+			else if (result.resolvedValue !== void 0) autoResolvedPatches.set(property, result.resolvedValue);
+		}
+		const hasConflicts = conflictingProperties.length > 0;
+		const wasAutoResolved = autoResolvedPatches.size > 0;
+		const resolvedData = wasAutoResolved ? {
+			...providedData ?? {},
+			...Object.fromEntries(autoResolvedPatches)
+		} : void 0;
+		if (wasAutoResolved && !hasConflicts && resolvedData) onAutoResolve?.(resolvedData);
+		return {
+			hasConflicts,
+			conflictingProperties,
+			wasAutoResolved,
+			resolvedData
+		};
+	}, [
+		providedData,
+		detectedData,
+		rules,
+		onAutoResolve
+	]);
+	return {
+		hasConflicts,
+		conflictingProperties,
+		wasAutoResolved,
+		resolvedData
+	};
+};
+var ConflictRow_module_default = {
+	"conflict-row-table": "_conflict-row-table_y7ii4_1",
+	conflictRowTable: "_conflict-row-table_y7ii4_1",
+	"conflict-row-list": "_conflict-row-list_y7ii4_12",
+	conflictRowList: "_conflict-row-list_y7ii4_12",
+	"conflict-row-list-option-label": "_conflict-row-list-option-label_y7ii4_29",
+	conflictRowListOptionLabel: "_conflict-row-list-option-label_y7ii4_29"
+};
+//#endregion
+//#region src/components/Individual/forms/DataConflictsModal/ConflictRow.tsx
+var ConflictRow = ({ provided, detected, label, formatter = (val) => val, selected, onSelect, showAs }) => {
+	const { t } = useTranslation("common");
+	const hasOnlyProvided = !isEmpty(provided) && isEmpty(detected);
+	const hasOnlyDetected = isEmpty(provided) && !isEmpty(detected);
+	useEffect(() => {
+		if (selected !== void 0) return;
+		if (hasOnlyProvided) onSelect("provided");
+		else if (hasOnlyDetected) onSelect("detected");
+	}, [
+		hasOnlyProvided,
+		hasOnlyDetected,
+		onSelect,
+		selected
+	]);
+	if (hasOnlyProvided || hasOnlyDetected) return;
+	return showAs === "listItem" ? /* @__PURE__ */ jsxs("div", {
+		className: ConflictRow_module_default.conflictRowList,
+		children: [/* @__PURE__ */ jsx("dt", { children: /* @__PURE__ */ jsx(Typography, {
+			variant: "caption",
+			children: t(($) => $[label])
+		}) }), /* @__PURE__ */ jsxs("dd", { children: [/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx(Typography, {
+			variant: "caption",
+			color: "tertiary",
+			className: ConflictRow_module_default.conflictRowListOptionLabel,
+			children: t(($) => $["youEntered"])
+		}), /* @__PURE__ */ jsx(RadioWithLabel, {
+			label: formatter(provided),
+			value: "provided",
+			checked: selected === "provided",
+			onClick: () => onSelect("provided")
+		})] }), /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx(Typography, {
+			variant: "caption",
+			color: "tertiary",
+			className: ConflictRow_module_default.conflictRowListOptionLabel,
+			children: t(($) => $["weDetected"])
+		}), /* @__PURE__ */ jsx(RadioWithLabel, {
+			label: formatter(detected),
+			value: "detected",
+			checked: selected === "detected",
+			onClick: () => onSelect("detected")
+		})] })] })]
+	}) : /* @__PURE__ */ jsxs("tr", {
+		className: ConflictRow_module_default.conflictRowTable,
+		children: [
+			/* @__PURE__ */ jsx("td", { children: /* @__PURE__ */ jsx(Typography, {
+				variant: "caption",
+				children: t(($) => $[label])
+			}) }),
+			/* @__PURE__ */ jsx("td", { children: /* @__PURE__ */ jsx(RadioWithLabel, {
+				label: formatter(provided),
+				value: "provided",
+				checked: selected === "provided",
+				onClick: () => onSelect("provided")
+			}) }),
+			/* @__PURE__ */ jsx("td", { children: /* @__PURE__ */ jsx(RadioWithLabel, {
+				label: formatter(detected),
+				value: "detected",
+				checked: selected === "detected",
+				onClick: () => onSelect("detected")
+			}) })
+		]
+	});
+};
+var DataConflictsModal_module_default = {
+	"data-conflicts-wrapper": "_data-conflicts-wrapper_1jdw0_1",
+	dataConflictsWrapper: "_data-conflicts-wrapper_1jdw0_1",
+	"data-conflicts-header": "_data-conflicts-header_1jdw0_7",
+	dataConflictsHeader: "_data-conflicts-header_1jdw0_7",
+	"data-conflicts-table": "_data-conflicts-table_1jdw0_15",
+	dataConflictsTable: "_data-conflicts-table_1jdw0_15",
+	"data-conflicts-list": "_data-conflicts-list_1jdw0_33",
+	dataConflictsList: "_data-conflicts-list_1jdw0_33"
+};
+//#endregion
+//#region src/components/Individual/forms/DataConflictsModal/DataConflictsModal.tsx
+/**
+* A modal component for resolving data conflicts between two data sources.
+*
+* This component is typically used in a KYC (Know Your Customer) flow where user-provided data
+* is compared against data extracted from a document (e.g., via OCR).
+*
+* It identifies differing fields, presents them to the user, and allows them to select the
+* correct version for each field before proceeding.
+*
+* @template Data The shape of the data objects being compared.
+* @template Property A union of keys from the `Data` object, constrained to `NsTranslationKey<'common'>`.
+*/
+var DataConflictsModal = ({ providedData, detectedData, conflictingProperties, formatters, title, explanation, onContinue, onCancel }) => {
+	const { t: individualT } = useTranslation("individual");
+	const [showCancelModal, setShowCancelModal] = useState(false);
+	const [showError, setShowError] = useState(false);
+	/**
+	* A record object that maps each conflicting property key to its `provided` and `detected` values.
+	* This is memoized for performance, as it's derived from `conflictingProperties` and only needs
+	* to be recalculated if the list of conflicts changes.
+	*
+	* @example
+	* // returns: { firstName: { provided: 'Jon', detected: 'John' } }
+	*/
+	const conflictItems = useMemo(() => listToRecord(conflictingProperties, (property) => ({
+		provided: providedData[property],
+		detected: detectedData[property]
+	})), [
+		conflictingProperties,
+		providedData,
+		detectedData
+	]);
+	const [resolutions, setResolutions] = useState(() => listToRecord(conflictingProperties, () => void 0));
+	const resolveProperty = useCallback((property, selected) => {
+		setShowError(false);
+		setResolutions((prev) => ({
+			...prev,
+			[property]: selected
+		}));
+	}, []);
+	return /* @__PURE__ */ jsxs(Modal, {
+		ariaLabel: individualT(($) => $[title]),
+		onClose: () => setShowCancelModal(true),
+		inset: true,
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: DataConflictsModal_module_default.dataConflictsWrapper,
+			children: [
+				/* @__PURE__ */ jsxs("div", {
+					className: DataConflictsModal_module_default.dataConflictsHeader,
+					children: [/* @__PURE__ */ jsx(Typography, {
+						variant: "title-l",
+						el: "h1",
+						children: individualT(($) => $[title])
+					}), /* @__PURE__ */ jsx(Typography, {
+						variant: "body",
+						children: individualT(($) => $[explanation])
+					})]
+				}),
+				showError ? /* @__PURE__ */ jsx(Alert, {
+					variant: "error",
+					title: individualT(($) => $["chooseTheCorrectDetailsBeforeProceeding"])
+				}) : void 0,
+				/* @__PURE__ */ jsx("dl", {
+					className: DataConflictsModal_module_default.dataConflictsList,
+					children: keysOf(conflictItems).map((property) => /* @__PURE__ */ jsx(ConflictRow, {
+						showAs: "listItem",
+						label: property,
+						formatter: formatters[property],
+						provided: conflictItems[property].provided,
+						detected: conflictItems[property].detected,
+						selected: resolutions[property],
+						onSelect: (selected) => resolveProperty(property, selected)
+					}, property))
+				}),
+				/* @__PURE__ */ jsxs("table", {
+					className: DataConflictsModal_module_default.dataConflictsTable,
+					children: [/* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsxs("tr", { children: [
+						/* @__PURE__ */ jsx("th", {}),
+						/* @__PURE__ */ jsx("th", { children: /* @__PURE__ */ jsx(Typography, {
+							variant: "caption",
+							color: "tertiary",
+							children: individualT(($) => $["youEntered"])
+						}) }),
+						/* @__PURE__ */ jsx("th", { children: /* @__PURE__ */ jsx(Typography, {
+							variant: "caption",
+							color: "tertiary",
+							children: individualT(($) => $["weDetected"])
+						}) })
+					] }) }), /* @__PURE__ */ jsx("tbody", { children: keysOf(conflictItems).map((property) => /* @__PURE__ */ jsx(ConflictRow, {
+						showAs: "tableRow",
+						label: property,
+						formatter: formatters[property],
+						provided: conflictItems[property].provided,
+						detected: conflictItems[property].detected,
+						selected: resolutions[property],
+						onSelect: (selected) => resolveProperty(property, selected)
+					}, property)) })]
+				}),
+				/* @__PURE__ */ jsx(Button, {
+					fullWidth: true,
+					onClick: () => {
+						if (!conflictingProperties.every((p) => resolutions[p])) {
+							setShowError(true);
+							return;
+						}
+						/**
+						* 2. Build an object containing only the user's selections for the conflicting properties.
+						* This intermediate object will only contain the keys that had a mismatch.
+						*/
+						const resolvedConflicts = listToRecord(conflictingProperties, (property) => {
+							return resolutions[property] === "provided" ? providedData[property] : detectedData[property];
+						});
+						onContinue({
+							...providedData,
+							...resolvedConflicts
+						});
+					},
+					children: individualT(($) => $["confirmSelection"])
+				})
+			]
+		}), showCancelModal && /* @__PURE__ */ jsx(Confirm, {
+			title: individualT(($) => $["leaveInstantVerification"]),
+			confirmText: individualT(($) => $["leaveVerification"]),
+			description: individualT(($) => $["anyInformationFromTheUploadedDocumentWillBeLost"]),
+			onConfirm: onCancel,
+			onCancel: () => setShowCancelModal(false),
+			critical: false
+		})]
+	});
+};
+var IdVerificationMethod_module_default = {
+	"verification-header-image": "_verification-header-image_1vivf_1",
+	verificationHeaderImage: "_verification-header-image_1vivf_1",
+	"or-separator": "_or-separator_1vivf_5",
+	orSeparator: "_or-separator_1vivf_5"
+};
+//#endregion
+//#region src/components/Individual/forms/IdVerificationMethod/individualConflictsSchema.ts
+/**
+* Converts and flattens an {@link IndividualSchema} to an {@link IndividualConflictsSchema}.
+*
+* This is useful for comparing two {@link IndividualSchema} objects field by field.
+*
+* @param {IndividualSchema} individualSchema - The schema to convert.
+* @returns {IndividualConflictsSchema} The flattened schema.
+*/
+var toIndividualConflictSchema = ({ basicDetails, additionalPersonalDetails }) => {
+	return {
+		firstName: basicDetails?.firstName,
+		lastName: basicDetails?.lastName,
+		email: basicDetails?.email,
+		phoneNumber: basicDetails?.phoneNumber,
+		birthDate: additionalPersonalDetails?.birthDate,
+		nationality: additionalPersonalDetails?.nationality,
+		address: pick("address", "otherAddressInformation", "postalCode", "city", "stateOrProvince", "country").from(additionalPersonalDetails),
+		idNumber: additionalPersonalDetails?.idNumber,
+		typeOfIdentity: additionalPersonalDetails?.typeOfIdentity,
+		issuerState: additionalPersonalDetails?.issuerState,
+		licenseCardNumber: additionalPersonalDetails?.licenseCardNumber,
+		expiryDate: additionalPersonalDetails?.expiryDate
+	};
+};
+/**
+* Converts an {@link IndividualConflictsSchema} back to an {@link IndividualSchema}.
+*
+* This is useful for reconstructing the original schema after a comparison.
+*
+* @param {IndividualConflictsSchema} conflictSchema - The flattened schema to convert.
+* @returns {IndividualSchema} The reconstructed schema.
+*/
+var fromIndividualConflictSchema = ({ firstName, lastName, email, phoneNumber, birthDate, nationality, address, ...idFields }) => ({
+	basicDetails: {
+		firstName,
+		lastName,
+		email,
+		phoneNumber
+	},
+	additionalPersonalDetails: {
+		birthDate,
+		nationality,
+		...idFields,
+		...address
+	}
+});
+//#endregion
+//#region src/components/Individual/forms/IdVerificationMethod/mapExtractionResultToSchema.ts
+var logger = createLogger();
+var mapExtractionResultToSchema = (result, restrictCountryOfResidenceTo) => {
+	const { firstName, lastName, issuingCountry, issuingState, dateOfBirth, address, documentNumber, documentType, nationality, placeOfBirth } = result;
+	const schema = {
+		basicDetails: {
+			firstName,
+			lastName
+		},
+		additionalPersonalDetails: {}
+	};
+	let issuingCountryIsCountryOfResidency = false;
+	if (issuingCountry) {
+		const countryFromOcr = issuingCountry;
+		if (!restrictCountryOfResidenceTo || restrictCountryOfResidenceTo.includes(countryFromOcr)) {
+			schema.additionalPersonalDetails.country = countryFromOcr;
+			issuingCountryIsCountryOfResidency = true;
+		} else {
+			schema.additionalPersonalDetails.nationality = countryFromOcr;
+			issuingCountryIsCountryOfResidency = false;
+		}
+	}
+	if (dateOfBirth) schema.additionalPersonalDetails.birthDate = dateOfBirth;
+	if (issuingState) schema.additionalPersonalDetails.issuerState = issuingState;
+	if (nationality) schema.additionalPersonalDetails.nationality = nationality;
+	if (address && issuingCountryIsCountryOfResidency && Object.keys(address).length > 0) schema.additionalPersonalDetails = {
+		...schema.additionalPersonalDetails,
+		...mapAddressToSchema(address)
+	};
+	if (documentType) switch (documentType) {
+		case "identityCard":
+			schema.additionalPersonalDetails.typeOfIdentity = "proofOfIdentityCard";
+			schema.additionalPersonalDetails.idNumber = documentNumber;
+			break;
+		case "driversLicense":
+			schema.additionalPersonalDetails.typeOfIdentity = "driversLicense";
+			schema.additionalPersonalDetails.licenseCardNumber = documentNumber;
+			break;
+		case "passport":
+			schema.additionalPersonalDetails.typeOfIdentity = "passport";
+			schema.additionalPersonalDetails.idNumber = documentNumber;
+			break;
+		default:
+			logger.warn(`document type "${documentType}" not recognised`);
+			break;
+	}
+	return schema;
+};
+var mapAddressToSchema = ({ street, street2, city, postalCode, stateOrProvince }) => ({
+	address: street,
+	otherAddressInformation: street2,
+	city,
+	postalCode,
+	stateOrProvince
+});
+//#endregion
+//#region src/api/idVerificationProviders/useIdVerificationToken.ts
+var getIdVerificationToken = async (rootLegalEntityId, baseUrl, request) => httpPost({
+	baseUrl,
+	path: `legalEntities/${rootLegalEntityId}/providers/idVerification/initiate`
+}, request);
+/**
+* Retrieves a token that we can use to proceed with ID verification for the given set of applicant
+* details.
+*
+* **Note:** on the backend we re-use an existing Onfido applicant if a `legalEntityId` is sent
+* and we have previously generated a token for that same legal entity. Therefore, this request
+* effectively idempotent.
+*/
+var useIdVerificationToken = ({ firstName, lastName, residencyCountry }, legalEntityId, options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	const data = firstName && lastName && residencyCountry ? {
+		name: {
+			firstName,
+			lastName
+		},
+		country: residencyCountry,
+		origin: `${window.location.origin}/*`,
+		consents: [{
+			name: "privacy_notices_read",
+			granted: true
+		}],
+		...legalEntityId ? { legalEntityId } : {}
+	} : void 0;
+	return useQuery({
+		enabled: Boolean(firstName && lastName && residencyCountry),
+		queryKey: ["idVerificationToken", data],
+		queryFn: () => getIdVerificationToken(rootLegalEntityId.value, baseUrl.value, data),
+		...options
+	});
+};
+var UploadedDocument_module_default = {
+	"uploaded-document": "_uploaded-document_vsv6u_1",
+	uploadedDocument: "_uploaded-document_vsv6u_1"
+};
+//#endregion
+//#region src/components/Individual/forms/IdVerificationMethod/UploadedDocument/UploadedDocument.tsx
+var UploadedDocument = ({ document, onDelete, onUpdate }) => {
+	const { t, i18n } = useTranslation("common");
+	return /* @__PURE__ */ jsxs("article", {
+		className: UploadedDocument_module_default.uploadedDocument,
+		children: [
+			/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx(Typography, {
+				el: "h4",
+				variant: "title",
+				children: t(($) => $[document.idDocumentType])
+			}), /* @__PURE__ */ jsx(Typography, {
+				el: "p",
+				variant: "body",
+				children: t(($) => $["uploadedOn"], { date: localizeDateString(document.modificationDate, i18n.language, { month: "short" }) ?? "" })
+			})] }),
+			/* @__PURE__ */ jsx(Spacer, {}),
+			/* @__PURE__ */ jsx(IconButton, {
+				onClick: onDelete,
+				icon: "bin",
+				variant: "secondary",
+				ariaLabel: t(($) => $["delete"])
+			}),
+			/* @__PURE__ */ jsx(Button, {
+				onClick: onUpdate,
+				variant: "secondary",
+				children: t(($) => $["update"])
+			})
+		]
+	});
+};
+//#endregion
+//#region src/components/Individual/forms/IdVerificationMethod/validateExtractionResult.ts
+/**
+* Validates the OCR extraction result against business rules.
+* @param extractionResult - The data extracted from the document.
+* @returns A translation key for an error message if validation fails, otherwise null.
+*/
+var validateExtractionResult = (extractionResult) => {
+	const { isExpired, isValidDocumentType, isUnderage, minimumOnboardingAge } = extractionResult;
+	if (isExpired) return { key: "theDocumentYouUploadedIsExpired" };
+	if (!isValidDocumentType) return { key: "theDocumentTypeYouUploadedIsNotSupported" };
+	if (isUnderage) return {
+		key: "weDontAcceptDocumentsOrInformationAboutAnyoneYoungerThan_",
+		options: { values: { minimumOnboardingAge: minimumOnboardingAge?.toString() ?? "" } }
+	};
+	return null;
+};
+//#endregion
+export { getAsyncIdNumberValidationRule as _, fromIndividualConflictSchema as a, DataConflictsModal as c, addressToString as d, useExtractDocumentInformation as f, defaultFieldMetadata as g, defaultFieldConfig as h, mapExtractionResultToSchema as i, createAddressConflictRule as l, idNumberFields as m, UploadedDocument as n, toIndividualConflictSchema as o, IdentityNumber as p, useIdVerificationToken as r, IdVerificationMethod_module_default as s, validateExtractionResult as t, useDataConflicts as u, licenseCardNumberDefaultConfig as v, licenseCardNumberDefaultMetadata as y };