@adyen/kyc-components 4.23.0 → 4.24.0-beta.0

package/dist/IndividualDropin-0t7Oj71F.js

@@ -0,0 +1,4175 @@
+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] = "ab449e7d-b048-46fd-a6fa-bf0676a6bf59", e._sentryDebugIdIdentifier = "sentry-dbid-ab449e7d-b048-46fd-a6fa-bf0676a6bf59");
+} catch (e) {}
+import { r as useTranslation, t as Trans } from "./translation-DbATp_35.js";
+import { t as createLogger } from "./logger-Z8AeTE4x.js";
+import { t as Typography } from "./Typography-CAc_f5Iq.js";
+import { t as Loader } from "./Loader-BVtlpTeo.js";
+import { t as Button } from "./Button-DPJ1k02w.js";
+import { n as httpGet, r as httpPost, s as useApiContext } from "./http-fdIO--pH.js";
+import { t as getLegalEntityCountry } from "./getLegalEntityCountry-BK-HHa65.js";
+import { t as useAccountHolder } from "./useAccountHolder-DDto9d9n.js";
+import { t as useSettingsContext } from "./useSettingsContext-9O3Aqpfq.js";
+import { a as objectsDeepEqual, n as doArraysMatch, r as drop, t as cloneObject } from "./genUtils-nphCwt1A.js";
+import { E as standardKatakanaValidator, T as standardKanjiValidator, _ as hasText, c as SPECIAL_CHARS, f as getFormattingRegEx, h as hasMaximumTwoRepeatedCharacters, n as EMOJI_REGEX, o as NO_ALPHABET_UNICODE_REGEX, r as INDIVIDUAL_VALID_CHAR_REGEX, w as matchesRegex, x as isInvalidName, y as isEmpty } from "./validatorUtils-D2O6AAZn.js";
+import { t as useToggleContext } from "./useToggleContext-B_YexrbT.js";
+import { t as Header } from "./Header-DVLlJ6we.js";
+import { n as useCapabilities, t as useAllowedCountries } from "./useAllowedCountries-C-nqVePW.js";
+import { r as euCountries, t as CountryCodes } from "./country-code-CJk2hdPu.js";
+import { t as useDataset } from "./useDataset-CdLBLq98.js";
+import { n as datasetUtilities, t as datasetIdentifier } from "./datasetUtil-BdHPWsxZ.js";
+import { t as Alert } from "./Alert-Cc7p0N5h.js";
+import { l as individualDocumentMapping, s as individualApiKeyMapping, u as individualObscuredFields } from "./processCapabilities-CWE5UFt8.js";
+import { t as TaskTypes } from "./taskTypes-3vSkMBDm.js";
+import { n as attachNomineeToRole, r as filterOutUnwantedAssociationsIfRootLE, s as getOwnEntityAssociations, t as allowedCountriesForNominee, u as hasNomineesChanged } from "./entityAssociationUtil-CY0grcyH.js";
+import { t as DecisionMakerTypes } from "./decision-maker-type-NR4GFAeT.js";
+import { t as Scenarios } from "./get-scenarios-Bb-paHmJ.js";
+import { s as getAvailableDecisionMakerRoleTypes, t as getAllowedDecisionMakerRoles } from "./decisionMakerRoles-C6LMC4mh.js";
+import { i as isLowRiskCountry } from "./country-BEZkohEO.js";
+import { i as isLegalRepresentativeNeeded, n as getAgeRangeForLegalRepresentative, r as getAgeToday } from "./birthDateUtils-D6uk7zwm.js";
+import { t as useAnalyticsContext } from "./useAnalyticsContext-gSnRnYgV.js";
+import { t as SettingNames } from "./types-Cwq1JAWT.js";
+import { t as useToastContext } from "./useToastContext-B6Mqc2HY.js";
+import { t as LandingLayout } from "./LandingLayout-BsIoIFzs.js";
+import { t as LoaderWrapper } from "./LoaderWrapper-Dc88hY-P.js";
+import { t as Modal } from "./Modal-CHES6970.js";
+import { t as Confirm } from "./Confirm-DoN9R9Z3.js";
+import { t as useCreateLegalEntity } from "./useCreateLegalEntity-qP7MeAmi.js";
+import { t as useUpdateLegalEntity } from "./useUpdateLegalEntity-CqmqXsbR.js";
+import { a as useFormComposer, i as FormFlow, n as getRequiredForms, o as FormContextProvider, r as useFormContext, t as addValidityToForms } from "./dropinUtils-DTBezwYT.js";
+import { i as getPropsFromConfigurations, r as composePerScenarioFormConfigurations, t as createFormRules } from "./form-rules-B0RwhsVw.js";
+import { t as Image } from "./Image-Bn_Yyuof.js";
+import { r as translateTranslatable } from "./utils-CYUYe54m.js";
+import { n as useFormRouterContext, t as ErrorPanel } from "./ErrorPanel-D4JNFkvi.js";
+import { n as mergeFieldMetadataIntoProps, t as createFormUtils } from "./formUtils-DVDcdZsP.js";
+import { n as preTranslatedSummaryItem } from "./summaryItem-uDWmtYtt.js";
+import { r as isTruthyValidator, t as useMultiForm } from "./useMultiForm-BxASst0O.js";
+import { t as Field } from "./Field-DwDJQVSS.js";
+import { A as taxIdNumberOptions, c as taxInformationDefaultFieldConfig, l as taxInformationDefaultFieldMetadata } from "./utils-Ck_mZapQ.js";
+import { n as mapSchemaFieldsToApiScriptLocalization } from "./mapScriptLocalization-BCfkZo1y.js";
+import { t as isEmpty$1 } from "./isEmpty-Uewyl-r6.js";
+import { t as Select } from "./Select-phAxjMBQ.js";
+import { n as CountryField } from "./CountryField-DT6-Jr_b.js";
+import { c as COUNTRIES_WITH_STATES_DATASET, i as mapAddressLabels, l as addressFields, t as getAddressSchemaForCountry } from "./utils-BWumuCvl.js";
+import { t as InputText } from "./InputText-CFDEmEtp.js";
+import { t as resolveFieldMetadata } from "./fieldConfigurations-CZCFghnK.js";
+import { t as convertFullToHalf } from "./formFieldsUtils-CnDkgahc.js";
+import { n as TaxInformationField, r as isJapanLocalizationEnabled } from "./TaxInformationField-CV7SpMH1.js";
+import { t as toFullWidth } from "./toFullWidth-Dgy4X4i8.js";
+import { c as MaskedInput, l as InputEmail } from "./maskHelpers-C0wnCoJl.js";
+import { t as RadioGroup } from "./RadioGroup-Bf3DlQnZ.js";
+import { r as formatObject } from "./utils-DdHbAadK.js";
+import { a as idNowPostSubmit, i as idNowModalChildEntityId, n as isBafinSignatoryFlow, o as shouldShowIdNowModal, s as showIdNowModal } from "./bafinUtils-DDrD6bfK.js";
+import { t as getIndividualLegalEntityName } from "./getName-DgxRqagk.js";
+import { t as useScenarios } from "./useScenarios-Bn93htbx.js";
+import { a as GuidanceQuestion, c as shouldNavigateToAdditionalPersonalDetailsForMissingData, i as findRelevantTaxInformation, l as useCreateInvitation, n as getOnfidoIdentityTypeToApiIdentityTypeMap, o as GuidanceQuestionValues, r as isManualVerificationOrExistingDoc, s as individualFormDefaultData, t as mapLegalEntityToIndividualSchema } from "./mapLegalEntityToIndividualSchema-CBKR-InO.js";
+import { n as ALL_ADDRESS_FIELDS, s as useProviderStatus, t as AddressFields } from "./AddressFields-BC3QHs2u.js";
+import { a as contactDetailsValidationRules, c as getAsyncPhoneValidationRules, i as phonePrefixes_default, l as getPhonePlaceholder, n as contactDetailFields, o as defaultFieldMetadata, r as PhoneField, s as fieldConfig, t as ContactDetails, u as useValidatePhoneNumberImperatively } from "./ContactDetails-CiWftLi4.js";
+import { i as useScenarioConfiguration, n as getPage, r as getPageName, t as mapExistingFile } from "./mapExistingFile-BkwRTTRm.js";
+import { t as useTaskLandedEvent } from "./useTaskLandedEvent-DwZHcMEQ.js";
+import { i as JP_ADDRESS_REQUIRED_FIELDS, n as mapJpAddressSummary, t as mapJpAddressSchemaToAddressLocalizations } from "./mapJpAddressSchemaToAddressLocalizations-D3VO2nhc.js";
+import { n as isMaintenanceModeError, t as processValidationErrors } from "./processValidationErrors-CjsNfiRK.js";
+import { a as createDocumentRequest, d as mergeAttachments, l as getFileExtention, o as documentApiUtils, p as getLocalizedIdDocumentTypeOptions, s as getDocument, u as getIdDocument } from "./validate-BZ1-ZeKr.js";
+import { i as getFieldsWithExistingData, n as MemoizedDocumentUpload, r as DocumentGuidance, t as PatriotActDisclosure } from "./PatriotActDisclosure-DqUZeLms.js";
+import { t as localizeDateString } from "./localizeDateString-Dxlqr4rL.js";
+import { n as omitObscuredFieldsIfUnchanged, t as AdyenKycSdkError } from "./error-BvgoQFEI.js";
+import { a as isValidationError } from "./validationError-DV6t8Ubb.js";
+import { a as getAsyncIdNumberValidationRule, i as defaultFieldMetadata$1, n as idNumberFields, o as licenseCardNumberDefaultConfig, r as defaultFieldConfig, s as licenseCardNumberDefaultMetadata, t as IdentityNumber } from "./IdentityNumber-3V6ZqvHB.js";
+import { n as formatDateObj, t as InputDate } from "./InputDate-Bq3Sb-ZW.js";
+import { t as addressValidators } from "./validate-DTz70AWN.js";
+import { n as emailPattern } from "./basePatterns-plHFNzgJ.js";
+import { t as TextArea } from "./TextArea-qGEo3PFG.js";
+import { t as Dropzone } from "./Dropzone-ttbRg2LI.js";
+import { n as getFieldProps, r as getFormProps } from "./getProps-DVqK7eRw.js";
+import { t as Link } from "./Link-CvYhseSD.js";
+import { t as ContextGuidance } from "./ContextGuidance-BQPwRscq.js";
+import { n as nameFields, t as Name } from "./Name-CdCsijr5.js";
+import { t as formatValidationError } from "./formatValidationError-q_w9DTrl.js";
+import { a as fromIndividualConflictSchema, c as createAddressConflictRule, d as useExtractDocumentInformation, i as mapExtractionResultToSchema, l as useDataConflicts, n as UploadedDocument, o as toIndividualConflictSchema, r as useIdVerificationToken, s as IdVerificationMethod_module_default, t as validateExtractionResult, u as addressToString } from "./validateExtractionResult-CntKbt8c.js";
+import { t as DataConflictsModal } from "./DataConflictsModal-CCaMgguu.js";
+import { Suspense, lazy, memo } from "preact/compat";
+import { useCallback as useCallback$1, useEffect as useEffect$1, useMemo as useMemo$1, useRef as useRef$1, useState as useState$1 } from "preact/hooks";
+import { Fragment as Fragment$1, jsx, jsxs } from "preact/jsx-runtime";
+import { signal } from "@preact/signals";
+import { skipToken, useMutation, useQuery, useQueryClient } from "@tanstack/preact-query";
+import { Show } from "@preact/signals/utils";
+import { Onfido } from "onfido-sdk-ui";
+import parsePhoneNumber from "libphonenumber-js/mobile";
+//#region src/api/entityVerifications/useVerifyIdNumber.ts
+var verifyIdNumber = async (legalEntityId, baseUrl, data) => {
+	return await httpPost({
+		baseUrl,
+		path: `legalEntities/${legalEntityId}/verifications/idNumber`,
+		errorHandler: async (response) => {
+			const responseData = await response;
+			if (responseData.status === 422) return {
+				status: 422,
+				message: responseData.detail,
+				errorCode: responseData.errorCode
+			};
+			if (responseData.status === 500) return {
+				status: 500,
+				message: "Service did not respond, do not block verification"
+			};
+		}
+	}, data);
+};
+var useVerifyIdNumber = (options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	return useMutation({
+		mutationFn: (data) => verifyIdNumber(rootLegalEntityId.value, baseUrl.value, data),
+		...options
+	});
+};
+//#endregion
+//#region src/api/idVerificationProviders/idVerificationStartCheck.ts
+var startVerificationCheck = async (rootLegalEntityId, baseUrl, data) => {
+	return httpPost({
+		baseUrl,
+		path: `legalEntities/${rootLegalEntityId}/providers/idVerification/process`
+	}, data);
+};
+var useIdVerificationStartCheck = (options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	return useMutation({
+		mutationFn: (data) => startVerificationCheck(rootLegalEntityId.value, baseUrl.value, data),
+		...options
+	});
+};
+//#endregion
+//#region src/utils/customerSupportUtils.ts
+var customerSupportPresubmitProcess = (legalEntityResponse, legalEntityToSubmit) => {
+	if (legalEntityResponse.type === "individual") return processCustomerSupportForIndividual(legalEntityResponse, legalEntityToSubmit);
+	if (legalEntityResponse.type === "organization") return processCustomerSupportForOrganization(legalEntityResponse, legalEntityToSubmit);
+};
+var processCustomerSupportForOrganization = (legalEntityResponse, legalEntityToSubmit) => {
+	if (!legalEntityResponse.organization?.support) return legalEntityToSubmit.organization?.support ?? void 0;
+	if (legalEntityResponse.organization?.countryOfGoverningLaw !== legalEntityToSubmit.organization?.countryOfGoverningLaw) {
+		const customerSupport = legalEntityResponse.organization?.support;
+		switch (legalEntityToSubmit.organization?.countryOfGoverningLaw) {
+			case CountryCodes.Japan: return unsetCustomerSupportNumber(customerSupport);
+			default: return customerSupport;
+		}
+	}
+};
+var processCustomerSupportForIndividual = (legalEntityResponse, legalEntityToSubmit) => {
+	if (!legalEntityResponse.individual?.support) return legalEntityToSubmit.individual?.support ?? void 0;
+	if (legalEntityResponse.individual?.residentialAddress.country !== legalEntityToSubmit.individual?.residentialAddress.country) {
+		const customerSupport = legalEntityResponse.individual?.support;
+		switch (legalEntityToSubmit.individual?.residentialAddress.country) {
+			case CountryCodes.Japan: return unsetCustomerSupportNumber(customerSupport);
+			default: return customerSupport;
+		}
+	}
+};
+var unsetCustomerSupportNumber = (customerSupport) => {
+	return customerSupport ? {
+		email: customerSupport.email,
+		phone: {
+			number: "",
+			type: "mobile"
+		}
+	} : void 0;
+};
+//#endregion
+//#region src/utils/getSSNType.ts
+var ERROR_CODES = {
+	SSN_REMEDIATION: "1_316",
+	SSN_4_DIGITS_VALIDATION: "1_3062",
+	PERSONAL_DETAILS_VALIDATION: "1_30"
+};
+var getSSNType = (formVerifcationErrors, existingIdNumber) => {
+	return check4DigitSsnFailed(formVerifcationErrors) || existingIdNumber?.length === 9 ? "ssn" : "ssnLastFour";
+};
+var check4DigitSsnFailed = (formVerifcationErrors) => {
+	return (formVerifcationErrors?.[ERROR_CODES.PERSONAL_DETAILS_VALIDATION])?.[ERROR_CODES.SSN_4_DIGITS_VALIDATION]?.some((error) => error.code === ERROR_CODES.SSN_REMEDIATION);
+};
+//#endregion
+//#region src/components/Shared/fields/Name/validate.ts
+var nameValidationRulesV4 = () => {
+	return {
+		firstName: [{
+			modes: ["blur"],
+			validate: (input) => !matchesRegex(NO_ALPHABET_UNICODE_REGEX, input),
+			errorMessage: "nameMustContainLetters"
+		}, {
+			modes: ["blur"],
+			validate: (input) => !matchesRegex(EMOJI_REGEX, input) && !hasMaximumTwoRepeatedCharacters(input) && !isInvalidName(input) && matchesRegex(INDIVIDUAL_VALID_CHAR_REGEX, input),
+			errorMessage: "checkForTypos"
+		}],
+		lastName: [{
+			modes: ["blur"],
+			validate: (input) => !matchesRegex(NO_ALPHABET_UNICODE_REGEX, input),
+			errorMessage: "nameMustContainLetters"
+		}, {
+			modes: ["blur"],
+			validate: (input) => !matchesRegex(EMOJI_REGEX, input) && !hasMaximumTwoRepeatedCharacters(input) && !isInvalidName(input) && matchesRegex(INDIVIDUAL_VALID_CHAR_REGEX, input),
+			errorMessage: "checkForTypos"
+		}]
+	};
+};
+getFormattingRegEx(SPECIAL_CHARS.replace("-", ""));
+//#endregion
+//#region src/components/Individual/forms/AdditionalPersonalDetails/validate.ts
+var isNotOutOfRangeBirthDateValidatorRule = {
+	modes: ["blur"],
+	validate: (birthDate) => !isEmpty(birthDate) && new Date(birthDate) < /* @__PURE__ */ new Date(),
+	errorMessage: "invalidDateOfBirth"
+};
+var buildMinimumAgeValidationRule = (minimumAge) => ({
+	modes: ["blur"],
+	validate: (birthDate) => !!birthDate && getAgeToday(birthDate) >= minimumAge,
+	errorMessage: {
+		key: "youMustXYearsOldToContinue",
+		values: { minimumAge: minimumAge.toString() }
+	}
+});
+var getCountrySpecificMinimumAgeValidationRule = (country) => {
+	if (!country) return buildMinimumAgeValidationRule(13);
+	if ([
+		...euCountries,
+		CountryCodes.UnitedKingdom,
+		CountryCodes.Switzerland
+	].some((c) => c === country)) return buildMinimumAgeValidationRule(16);
+	switch (country) {
+		case CountryCodes.HongKong:
+		case CountryCodes.Singapore: return buildMinimumAgeValidationRule(18);
+		default: return buildMinimumAgeValidationRule(13);
+	}
+};
+var additionalPersonalDetailsValidators = ({ country, isFeatureEnabled = () => false, isSettingEnabled = () => false, taskType, idNumberType, idNumberExempt, idNumber, existingIdNumber, formVerificationErrors, t, taxIdNumberType }) => ({
+	taxInformation: resolveFieldMetadata(taxInformationDefaultFieldConfig[country], {
+		taxIdNumberType,
+		companyType: "individual"
+	}, taxInformationDefaultFieldMetadata)?.validators,
+	birthDate: (() => {
+		const baseValidators = [isNotOutOfRangeBirthDateValidatorRule];
+		if (isSettingEnabled("enforceLegalAge")) return [...baseValidators, buildMinimumAgeValidationRule(18)];
+		if (isFeatureEnabled("EnableAgeVerification")) {
+			if (taskType === TaskTypes.LEGAL_REPRESENTATIVE_DETAILS) return [...baseValidators, buildMinimumAgeValidationRule(18)];
+			return [...baseValidators, getCountrySpecificMinimumAgeValidationRule(country)];
+		}
+		return baseValidators;
+	})(),
+	...isFeatureEnabled("StrictNameAndAddressValidationV4") ? nameValidationRulesV4() : void 0,
+	...contactDetailsValidationRules,
+	idNumber: (() => {
+		const derivedIdNumberType = country === CountryCodes.UnitedStates || country === CountryCodes.PuertoRico ? getSSNType(formVerificationErrors, existingIdNumber) : idNumberType;
+		return idNumberExempt ? {
+			validate: () => {
+				return idNumberExempt || !isEmpty(idNumber);
+			},
+			modes: ["blur"]
+		} : resolveFieldMetadata(defaultFieldConfig[country], { idNumberType: derivedIdNumberType }, defaultFieldMetadata$1)?.validators;
+	})(),
+	...addressValidators({
+		isFeatureEnabled,
+		country,
+		t
+	})
+});
+//#endregion
+//#region src/components/Shared/fields/LocalizedNameFields/validate.ts
+var localizedNameValidationRulesV4 = (isFeatureEnabled = () => false, country) => {
+	if (isJapanLocalizationEnabled(isFeatureEnabled, country)) return {
+		jaHaniFirstName: [{
+			modes: ["blur"],
+			validate: hasText,
+			errorMessage: "fieldIsRequired"
+		}, {
+			modes: ["blur"],
+			validate: (input) => standardKanjiValidator(input),
+			errorMessage: "checkForTypos"
+		}],
+		jaHaniLastName: [{
+			modes: ["blur"],
+			validate: hasText,
+			errorMessage: "fieldIsRequired"
+		}, {
+			modes: ["blur"],
+			validate: (input) => standardKanjiValidator(input),
+			errorMessage: "checkForTypos"
+		}],
+		jaKanaFirstName: [{
+			modes: ["blur"],
+			validate: hasText,
+			errorMessage: "fieldIsRequired"
+		}, {
+			modes: ["blur"],
+			validate: (input) => standardKatakanaValidator(input),
+			errorMessage: "ensureValidFullWidthKatakana"
+		}],
+		jaKanaLastName: [{
+			modes: ["blur"],
+			validate: hasText,
+			errorMessage: "fieldIsRequired"
+		}, {
+			modes: ["blur"],
+			validate: (input) => standardKatakanaValidator(input),
+			errorMessage: "ensureValidFullWidthKatakana"
+		}]
+	};
+	return {};
+};
+//#endregion
+//#region src/components/Individual/forms/BasicDetails/validate.ts
+var basicDetailsValidators = ({ isFeatureEnabled = () => false, country }) => ({
+	...contactDetailsValidationRules,
+	...isFeatureEnabled("StrictNameAndAddressValidationV4") ? nameValidationRulesV4() : void 0,
+	...localizedNameValidationRulesV4(isFeatureEnabled, country)
+});
+//#endregion
+//#region src/components/Individual/forms/IdDocumentUpload/types.ts
+var onfidoDocumentTypeMapping = [
+	{
+		id: "driversLicense",
+		name: "driversLicense",
+		hasBackPage: true
+	},
+	{
+		id: "identityCard",
+		name: "identityCard",
+		hasBackPage: true
+	},
+	{
+		id: "passport",
+		name: "passport",
+		hasBackPage: false
+	}
+];
+//#endregion
+//#region src/api/idNowProvider/useIdNowProvider.ts
+var getIdNowProviderIdentificationStatus = async (rootLegalEntityId, baseUrl, legalEntityId) => {
+	return httpGet({
+		baseUrl,
+		path: `legalEntities/${rootLegalEntityId}/child/${legalEntityId}/provider/idnow/identification/status`,
+		errorHandler: async (response) => {
+			const responseData = await response;
+			if (responseData.status === 404) return {
+				status: 404,
+				message: responseData.detail,
+				errorCode: responseData.errorCode
+			};
+		}
+	});
+};
+var useIdNowIdentificationStatus = (legalEntityId, options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	return useQuery({
+		queryKey: legalEntityId === skipToken ? [] : ["idNowProviderIdentificationStatus", legalEntityId],
+		queryFn: legalEntityId === skipToken ? skipToken : () => getIdNowProviderIdentificationStatus(rootLegalEntityId.value, baseUrl.value, legalEntityId),
+		...options
+	});
+};
+var idNowProviderStartIdentification = async (rootLegalEntityId, baseUrl, legalEntityId) => {
+	return httpPost({
+		baseUrl,
+		path: `legalEntities/${rootLegalEntityId}/child/${legalEntityId}/provider/idnow/identification/start`
+	});
+};
+var useIdNowStartIdentification = (legalEntityId, options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	return useQuery({
+		queryKey: legalEntityId === skipToken ? [] : ["idNowProviderStartIdentification", legalEntityId],
+		queryFn: legalEntityId === skipToken ? skipToken : () => idNowProviderStartIdentification(rootLegalEntityId.value, baseUrl.value, legalEntityId),
+		...options
+	});
+};
+var IdNowVerificationModal_module_default = {
+	"idnow-header": "_idnow-header_m87oy_1",
+	idnowHeader: "_idnow-header_m87oy_1",
+	"idnow-verification-header-iframe-container": "_idnow-verification-header-iframe-container_m87oy_7",
+	idnowVerificationHeaderIframeContainer: "_idnow-verification-header-iframe-container_m87oy_7",
+	"idnow-verification-header-iframe": "_idnow-verification-header-iframe_m87oy_7",
+	idnowVerificationHeaderIframe: "_idnow-verification-header-iframe_m87oy_7",
+	"idnow-verification-header-image": "_idnow-verification-header-image_m87oy_18",
+	idnowVerificationHeaderImage: "_idnow-verification-header-image_m87oy_18"
+};
+//#endregion
+//#region src/components/Individual/forms/IdNowVerificationModal/IFrameWidget.ts
+var MOUNT_TIMEOUT = 10 * 1e3;
+var activeWidget;
+var IFrameWidget = class {
+	iframeUrl;
+	iframeElement;
+	mountInProgress = false;
+	constructor(iframeElement, url, _vendor, _sdkToken) {
+		try {
+			this.iframeUrl = new URL(url);
+		} catch (err) {
+			throw new AdyenKycSdkError("WIDGET_URL_MALFORMED", err);
+		}
+		this.iframeElement = iframeElement;
+	}
+	unmount() {
+		if (this.mountInProgress) throw new AdyenKycSdkError("Cannot unmount widget, mounting is still in progress");
+		this.iframeElement.remove();
+		activeWidget = null;
+	}
+	async mount() {
+		if (activeWidget) throw new AdyenKycSdkError(`You can only have one ${this.constructor.name} mounted at a time`);
+		activeWidget = this;
+		if (this.mountInProgress) throw new AdyenKycSdkError("Cannot mount widget, mounting is already in progress");
+		this.mountInProgress = true;
+		try {
+			await new Promise((resolve, reject) => {
+				const timeoutId = setTimeout(() => {
+					this.mountInProgress = false;
+					reject(new AdyenKycSdkError("WIDGET_TIMEOUT"));
+				}, MOUNT_TIMEOUT);
+				const cancelTimeout = () => {
+					if (timeoutId) clearTimeout(timeoutId);
+				};
+				this.iframeElement.addEventListener("load", () => {
+					cancelTimeout();
+					this.mountInProgress = false;
+					resolve();
+				});
+				requestAnimationFrame(() => {
+					try {
+						this.iframeElement.setAttribute("src", this.iframeUrl.href);
+					} catch (ex) {
+						cancelTimeout();
+						this.mountInProgress = false;
+						reject(ex);
+					}
+				});
+			});
+		} catch (err) {
+			throw new AdyenKycSdkError("WIDGET_LAUNCH_FAILED", err);
+		}
+	}
+	async mountAndWaitForResponse() {
+		await this.mount();
+	}
+};
+//#endregion
+//#region src/components/Individual/forms/IdNowVerificationModal/IdNowVerificationModal.tsx
+var passportFrontGreenImage$1 = lazy(() => import("./passport-front-green-BWuD3-Fs.js"));
+/**
+* Checks if the IDnow identification status is considered successful.
+* @param status - The status object from the IDnow provider.
+* @returns True if the provider status is 'SUCCESS', 'SUCCESS_DATA_CHANGED', or 'REVIEW_PENDING'.
+*/
+var isIdNowSuccessful = (status) => {
+	const providerStatus = status?.providerStatus;
+	return providerStatus === "SUCCESS" || providerStatus === "SUCCESS_DATA_CHANGED" || providerStatus === "REVIEW_PENDING";
+};
+var IdNowVerificationModal = ({ handleFinish }) => {
+	const { t } = useTranslation(["individual", "common"]);
+	const [isConfirmPresented, setIsConfirmPresented] = useState$1(false);
+	const [genericError, setGenericError] = useState$1(false);
+	const widgetContainerRef = useRef$1(null);
+	const iFrameRef = useRef$1(null);
+	const iFrameWidgetRef = useRef$1(null);
+	const [page, setPage] = useState$1(1);
+	const queryClient = useQueryClient();
+	const { showToast } = useToastContext();
+	const { data: idNowStatus, isLoading: isStatusLoading, isError: isStatusError, refetch: refetchIdNowIdentificationStatus } = useIdNowIdentificationStatus(idNowModalChildEntityId.value?.id ?? skipToken, {
+		enabled: !!idNowModalChildEntityId.value?.id,
+		refetchOnMount: "always",
+		refetchInterval: (query) => {
+			if (query.state.status === "error") return false;
+			return 1e4;
+		},
+		retry: (failureCount, error) => {
+			if ("status" in error && (error.status === 404 || error.status === 500)) return false;
+			return failureCount < 3;
+		}
+	});
+	const { data: idNowStart, isLoading, isError: idNowStartError, refetch: refetchIdNowStartIdentification } = useIdNowStartIdentification(idNowModalChildEntityId.value?.id ?? skipToken, { enabled: !!idNowModalChildEntityId.value?.id && page === 2 });
+	const handleDismiss = () => {
+		setIsConfirmPresented(true);
+	};
+	const handleCancelDismiss = () => {
+		setIsConfirmPresented(false);
+	};
+	const handleConfirmDismiss = () => {
+		setPage(1);
+		setGenericError(false);
+		setIsConfirmPresented(false);
+		showIdNowModal.value = false;
+		if (idNowStartError && idNowModalChildEntityId.value?.id) queryClient.resetQueries({ queryKey: ["idNowProviderStartIdentification", idNowModalChildEntityId.value?.id] });
+		idNowModalChildEntityId.value = void 0;
+		iFrameWidgetRef.current?.unmount();
+		iFrameRef.current?.remove();
+		if (idNowPostSubmit.value) handleFinish?.();
+		idNowPostSubmit.value = false;
+	};
+	if (idNowStatus?.status === "finished") {
+		if (isIdNowSuccessful(idNowStatus)) {
+			idNowPostSubmit.value = true;
+			showToast({
+				label: t(($) => $["successfullyUpdatedDetails"], { ns: "common" }),
+				variant: "success"
+			});
+			handleConfirmDismiss();
+		} else if (page === 2) handleConfirmDismiss();
+	}
+	if (!isLoading && idNowStartError) {
+		setGenericError(true);
+		setPage(1);
+	}
+	const initializeIdNowWidget = useCallback$1(async (url) => {
+		const container = widgetContainerRef.current;
+		if (!container) return;
+		const iFrame = document.createElement("iframe");
+		iFrameRef.current = iFrame;
+		iFrame.setAttribute("allowFullscreen", "true");
+		iFrame.setAttribute("name", "idnow");
+		iFrame.classList.add(IdNowVerificationModal_module_default.idnowVerificationHeaderIframe);
+		iFrame.setAttribute("height", "800");
+		iFrame.setAttribute("allow", "camera *;microphone *;geolocation *;clipboard-read *;clipboard-write *");
+		container.appendChild(iFrame);
+		try {
+			iFrameWidgetRef.current = new IFrameWidget(iFrame, url, "idnow", "");
+			await iFrameWidgetRef.current.mountAndWaitForResponse();
+		} catch (err) {
+			console.error("Error occurred:", err);
+			setGenericError(true);
+			setPage(1);
+		}
+	}, []);
+	useEffect$1(() => {
+		if (page === 2 && !isLoading && idNowStart && idNowStart?.url) (async () => {
+			await refetchIdNowIdentificationStatus();
+			await initializeIdNowWidget(idNowStart.url);
+		})();
+		return () => {
+			iFrameWidgetRef.current?.unmount();
+			iFrameRef.current?.remove();
+		};
+	}, [
+		isLoading,
+		page,
+		initializeIdNowWidget,
+		refetchIdNowIdentificationStatus,
+		idNowStart
+	]);
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [!isStatusLoading && /* @__PURE__ */ jsxs(Modal, {
+		size: page === 2 ? "large" : "medium",
+		showCloseButton: !isLoading && !isStatusLoading,
+		onClose: handleDismiss,
+		ariaLabel: t(($) => $["identityVerification"]),
+		children: [page === 1 && /* @__PURE__ */ jsx("div", {
+			className: IdNowVerificationModal_module_default.idnowHeader,
+			children: /* @__PURE__ */ jsx(LandingLayout, {
+				media: /* @__PURE__ */ jsx(Image, {
+					className: IdNowVerificationModal_module_default.idnowVerificationHeaderImage,
+					lazyLoadedImage: passportFrontGreenImage$1
+				}),
+				title: t(($) => $["identityVerification"]),
+				description: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+					t(($) => $["idNowDescription"], { ns: "individual" }),
+					/* @__PURE__ */ jsx("br", {}),
+					/* @__PURE__ */ jsx("br", {}),
+					getIndividualLegalEntityName(idNowModalChildEntityId.value) && t(($) => $["idNowDescriptionName"], {
+						ns: "individual",
+						name: getIndividualLegalEntityName(idNowModalChildEntityId.value)
+					})
+				] }),
+				error: !isLoading && (genericError || isStatusError) ? /* @__PURE__ */ jsx(Alert, {
+					variant: "error",
+					title: t(($) => $["thereWasAnErrorTryAgain"], { ns: "common" })
+				}) : void 0,
+				actions: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Button, {
+					onClick: async () => {
+						setGenericError(false);
+						setPage(2);
+						await refetchIdNowStartIdentification();
+					},
+					disabled: isLoading || isStatusLoading || idNowStatus?.status === "finished" && isIdNowSuccessful(idNowStatus),
+					fullWidth: true,
+					children: idNowStatus?.status === "pending" ? t(($) => $["continueVerification"], { ns: "common" }) : t(($) => $["startVerification"], { ns: "common" })
+				}), /* @__PURE__ */ jsx(Button, {
+					disabled: isLoading || isStatusLoading,
+					variant: "tertiary",
+					onClick: handleConfirmDismiss,
+					fullWidth: true,
+					children: idNowPostSubmit.value ? t(($) => $["finishLater"], { ns: "common" }) : t(($) => $["editDetails"], { ns: "common" })
+				})] })
+			})
+		}), page === 2 && (isLoading ? /* @__PURE__ */ jsx(Loader, {}) : /* @__PURE__ */ jsx("div", {
+			ref: widgetContainerRef,
+			className: IdNowVerificationModal_module_default.idnowVerificationHeaderIframeContainer
+		}))]
+	}), isConfirmPresented && /* @__PURE__ */ jsx(Confirm, {
+		confirmText: t(($) => $["leave"], { ns: "common" }),
+		onCancel: handleCancelDismiss,
+		onConfirm: handleConfirmDismiss,
+		title: t(($) => $["unsavedChanges"], { ns: "common" })
+	})] });
+};
+//#endregion
+//#region src/components/Individual/forms/IdVerification/idVerificationProviderId.ts
+var idVerificationProviderId = signal();
+//#endregion
+//#region src/utils/areArraysDifferent.ts
+var areArraysDifferent = (a = [], b = []) => {
+	if (a.length !== b.length) return true;
+	const sortedA = [...a].sort();
+	const sortedB = [...b].sort();
+	return sortedA.some((item, index) => item !== sortedB[index]);
+};
+//#endregion
+//#region src/utils/useModalAction.ts
+var useModalAction = () => {
+	const userEvents = useAnalyticsContext();
+	return useCallback$1((label, actionType, setModalState, callback) => {
+		userEvents.addPageEvent(actionType === "open" ? "Opened modal" : actionType === "close" ? "Closed modal" : "Clicked button", {
+			actionType,
+			label
+		});
+		setModalState(actionType === "open");
+		callback?.();
+	}, [userEvents]);
+};
+/**
+* Checks whether the entity is missing a live selfie, which mandates ID verification
+* through motion capture.
+*
+* @param problems - The entity problems object.
+* @returns `true` when a `dataMissing` problem with the live-selfie code is present.
+*/
+var hasLiveSelfieError = (problems) => problems?.missingData?.some((problem) => problem.code === "2_8210" && problem.type === "dataMissing") ?? false;
+//#endregion
+//#region src/components/Individual/helpers/roleUtils.ts
+var calculateRoles = (data) => {
+	return [
+		{
+			isApplicable: data?.signatoryQuestionnaire?.isSignatory === GuidanceQuestionValues.YES,
+			role: DecisionMakerTypes.SIGNATORY
+		},
+		{
+			isApplicable: data?.uboQuestionnaire?.isOwner === GuidanceQuestionValues.YES,
+			role: DecisionMakerTypes.OWNER
+		},
+		{
+			isApplicable: data?.uboQuestionnaire?.isControllingPerson === GuidanceQuestionValues.YES,
+			role: DecisionMakerTypes.CONTROLLING_PERSON
+		},
+		{
+			isApplicable: data?.uboQuestionnaire?.isDirector === GuidanceQuestionValues.YES,
+			role: DecisionMakerTypes.DIRECTOR
+		}
+	].filter(({ isApplicable }) => isApplicable).map(({ role }) => role);
+};
+//#endregion
+//#region src/components/Individual/helpers/shouldShowMotionCapture.ts
+var showIndividualMotionCapture = signal(void 0);
+var setShowIndividualMotionCapture = (showMotionCapture) => {
+	showIndividualMotionCapture.value = showMotionCapture;
+};
+var hasMotionCaptureScenario = signal(void 0);
+var setHasMotionCaptureScenario = (scenarios) => {
+	hasMotionCaptureScenario.value = scenarios?.some((scenario) => scenario === Scenarios.L_MOTION || scenario === Scenarios.L1_ID);
+};
+var allowedRolesForMotionCapture = [DecisionMakerTypes.SIGNATORY];
+var shouldShowMotionCapture = ({ capabilities, userRoles, taskType, hasMotionScenario, hasLiveSelfieError, isInvitedEntity = false }) => {
+	if (hasLiveSelfieError) return true;
+	if (isInvitedEntity) return shouldShowMotionCaptureForInvitedEntity({
+		capabilities,
+		userRoles
+	});
+	if (!hasMotionScenario) return false;
+	const isIndividual = taskType === TaskTypes.INDIVIDUAL;
+	const hasRequiredRole = userRoles?.some((role) => allowedRolesForMotionCapture.includes(role));
+	const hasRequiredCapability = capabilities?.issueBankAccount?.requested ?? false;
+	return (isIndividual || hasRequiredRole) && hasRequiredCapability;
+};
+var shouldShowMotionCaptureForInvitedEntity = ({ capabilities, userRoles }) => {
+	if (!userRoles || !userRoles.includes("signatory") || capabilities === void 0) return false;
+	const rootCapabilitiesToShowMotionCaptureFor = [
+		"issueBankAccount",
+		"receiveFromThirdParty",
+		"sendToThirdParty"
+	];
+	return Object.keys(capabilities).some((capabilityName) => rootCapabilitiesToShowMotionCaptureFor.includes(capabilityName) && capabilities[capabilityName]?.requested);
+};
+//#endregion
+//#region src/components/Shared/fields/IdFieldTypeSelector/countryIdNumberTypes.ts
+var individualIdNumberOptions = { [CountryCodes.Spain]: [{
+	id: "dni",
+	name: "dni"
+}, {
+	id: "nie",
+	name: "nie"
+}] };
+var additionallIdNumberOptions = {
+	[CountryCodes.NewZealand]: [{
+		id: "driversLicense",
+		name: "driversLicense"
+	}, {
+		id: "passport",
+		name: "passportNumber"
+	}],
+	[CountryCodes.HongKong]: [
+		{
+			id: "proofOfIdentityCard",
+			name: "stateIssuedProofOfIdentityCard"
+		},
+		{
+			id: "driversLicense",
+			name: "driversLicense"
+		},
+		{
+			id: "passport",
+			name: "passportNumber"
+		}
+	],
+	[CountryCodes.Australia]: [{
+		id: "driversLicense",
+		name: "driversLicense"
+	}, {
+		id: "passport",
+		name: "passportNumber"
+	}]
+};
+//#endregion
+//#region src/components/Shared/fields/IdFieldTypeSelector/IndividualIdNumberTypeSelector.tsx
+function IndividualIdNumberTypeSelector({ country, selected, handleFieldChange }) {
+	const { t } = useTranslation("common");
+	const options = useMemo$1(() => individualIdNumberOptions[country] ?? [], [country]);
+	useEffect$1(() => {
+		if (!selected && options.length > 0) handleFieldChange(options[0].id);
+	}, [
+		options,
+		selected,
+		handleFieldChange
+	]);
+	if (options.length <= 1) return null;
+	return /* @__PURE__ */ jsx(Field, {
+		el: "fieldset",
+		name: "individualIdNumberType",
+		label: t(($) => $["whichTypeOfIdNumberDoYouHave"]),
+		children: (childProps) => /* @__PURE__ */ jsx(RadioGroup, {
+			...childProps,
+			name: "individualIdNumberType",
+			items: options,
+			value: selected,
+			onChange: (value) => handleFieldChange(value)
+		})
+	});
+}
+//#endregion
+//#region src/components/Individual/helpers/isDecisionMakerTask.ts
+var isDecisionMakerTask = (taskType) => taskType === TaskTypes.DECISION_MAKER || taskType === TaskTypes.TRUST_MEMBER_COMPANY_OWNER || taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY_OWNER;
+var AdditionalPersonalDetails_module_default = {
+	"additional-details-section-heading": "_additional-details-section-heading_o3tfa_1",
+	additionalDetailsSectionHeading: "_additional-details-section-heading_o3tfa_1"
+};
+//#endregion
+//#region src/components/Individual/fields/DriversLicense/DriversLicense.tsx
+var DriversLicense = ({ country, driversLicense, onIssuerStateChange, onLicenseNumberInput, onLicenseNumberBlur, onCardNumberInput, onCardNumberBlur, formUtils, isValid, errorMessages, guidanceText, shouldValidate }) => {
+	const { t: commonT } = useTranslation("common");
+	const { t: individualT } = useTranslation("individual");
+	const { dataset: auStates } = useDataset(datasetIdentifier.state("AU"));
+	const isCountryAustralia = country === CountryCodes.Australia;
+	const isCountryNewZealand = country === CountryCodes.NewZealand;
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		isCountryAustralia && onIssuerStateChange !== void 0 && /* @__PURE__ */ jsx(Field, {
+			name: "issuerState",
+			label: formUtils.getLabel("issuerState"),
+			isValid: isValid.issuerState,
+			errorMessage: errorMessages.issuerState,
+			children: (childProps) => /* @__PURE__ */ jsx(Select, {
+				...childProps,
+				name: "issuerState",
+				onChange: onIssuerStateChange,
+				isInvalid: false,
+				items: auStates,
+				placeholder: commonT(($) => $["selectState"]),
+				selected: driversLicense.issuerState
+			})
+		}),
+		/* @__PURE__ */ jsxs("div", {
+			className: "adyen-kyc-field-wrapper",
+			children: [/* @__PURE__ */ jsx(MaskedInput, {
+				name: "idNumber",
+				type: "text",
+				label: formUtils.getLabel("idNumber", "idNumber"),
+				formatGuidance: guidanceText.idNumber,
+				errorMessage: errorMessages.idNumber,
+				shouldValidate,
+				isValid: Boolean(isValid.idNumber),
+				"aria-required": formUtils.isRequiredField("idNumber"),
+				"aria-invalid": !isValid.idNumber,
+				onBlur: onLicenseNumberBlur,
+				readonly: formUtils.isReadOnly("idNumber"),
+				value: driversLicense.idNumber ?? "",
+				onInput: onLicenseNumberInput,
+				acceptObscuredValue: formUtils?.isObscured("idNumber"),
+				...formUtils.getMask("idNumber")
+			}), /* @__PURE__ */ jsx(MaskedInput, {
+				name: "licenseCardNumber",
+				type: "text",
+				label: formUtils.getLabel("licenseCardNumber", "licenseCardNumber"),
+				formatGuidance: guidanceText.licenseCardNumber,
+				errorMessage: errorMessages.licenseCardNumber,
+				shouldValidate,
+				isValid: Boolean(isValid.licenseCardNumber),
+				"aria-required": formUtils.isRequiredField("licenseCardNumber"),
+				"aria-invalid": !isValid.licenseCardNumber,
+				onBlur: onCardNumberBlur,
+				readonly: formUtils.isReadOnly("licenseCardNumber"),
+				value: driversLicense.licenseCardNumber ?? "",
+				onInput: onCardNumberInput,
+				acceptObscuredValue: formUtils?.isObscured("licenseCardNumber"),
+				...formUtils.getMask("licenseCardNumber")
+			})]
+		}),
+		(isCountryAustralia || isCountryNewZealand) && /* @__PURE__ */ jsx(ContextGuidance, {
+			title: individualT(($) => $["whereCanIFindTheseNumbersOnMyDriversLicense"]),
+			content: /* @__PURE__ */ jsxs(Fragment$1, { children: [isCountryAustralia ? `${individualT(($) => $["whereToFindNumbersOnDriversLicense"])}\u00A0` : `${individualT(($) => $["whereToFindNumbersOnDriversLicense__NZ"])}\u00A0`, /* @__PURE__ */ jsx(Link, {
+				href: isCountryAustralia ? "https://www.usi.gov.au/about/forms-id/drivers-licence" : "https://www.nzta.govt.nz/driver-licences/getting-a-licence/your-driver-licence-explained/",
+				children: individualT(($) => $["iStillCantFindIt"])
+			})] }),
+			titleId: "whereCanIFindTheseNumbersOnMyDriversLicense",
+			contentId: "whereToFindNumbersOnDriversLicense"
+		})
+	] });
+};
+//#endregion
+//#region src/components/Individual/forms/Individual.rules.ts
+var REQUIRED = "REQUIRED";
+var OPTIONAL = "OPTIONAL";
+var ID_NUMBER_EXEMPT_COUNTRIES = [
+	CountryCodes.Canada,
+	CountryCodes.Mexico,
+	CountryCodes.PuertoRico,
+	CountryCodes.UnitedStates
+];
+var COUNTRIES_WHICH_USE_MULTIPLE_IDENTITY_TYPES = [
+	CountryCodes.HongKong,
+	CountryCodes.Australia,
+	CountryCodes.NewZealand
+];
+var ID_NUMBER_REQUIRED_FOR_DIRECTOR_COUNTRIES = [CountryCodes.Singapore, CountryCodes.UnitedStates];
+var NATIONALITY_REQUIRED_FOR_COUNTRIES = [CountryCodes.Singapore, CountryCodes.HongKong];
+var JOB_TITLE_REQUIRED_FOR_COUNTRIES = [CountryCodes.NewZealand];
+var ISSUER_REQUIRED_FOR_COUNTRIES = [CountryCodes.Australia];
+var EXPIRY_DATE_REQUIRED_FOR_COUNTRIES = [CountryCodes.NewZealand];
+var LICENSE_CARD_NUMBER_REQUIRED_FOR_COUNTRIES = [CountryCodes.NewZealand, CountryCodes.Australia];
+var TAX_ID_REQUIRED_COUNTRIES = [
+	CountryCodes.Austria,
+	CountryCodes.Belgium,
+	CountryCodes.Croatia,
+	CountryCodes.Cyprus,
+	CountryCodes.Estonia,
+	CountryCodes.Finland,
+	CountryCodes.France,
+	CountryCodes.Germany,
+	CountryCodes.Greece,
+	CountryCodes.Ireland,
+	CountryCodes.Latvia,
+	CountryCodes.Lithuania,
+	CountryCodes.Luxembourg,
+	CountryCodes.Malta,
+	CountryCodes.Netherlands,
+	CountryCodes.Portugal,
+	CountryCodes.Slovakia,
+	CountryCodes.Slovenia,
+	CountryCodes.UnitedKingdom
+];
+var DECISION_MAKER_TYPES_WITH_JOBTITLE = [DecisionMakerTypes.SIGNATORY, DecisionMakerTypes.CONTROLLING_PERSON];
+var ID_MISSING_DATA_ERROR_CODE = "2_8071";
+var REMEDIATION_CODES_UPLOAD_ID = [
+	"1_301",
+	"1_302",
+	"1_303"
+];
+var individualRules = ({ matchingScenario, data, country, taskType, isFeatureEnabled = () => false, rootLegalEntity, problems }) => createFormRules({
+	countryUsesTaxId: () => {
+		if (matchingScenario?.includes(Scenarios.L_TAXINFO) && TAX_ID_REQUIRED_COUNTRIES.includes(country)) return "REQUIRED";
+	},
+	isDirectorIdNumberRequiredForCountry: () => {
+		if (!data.basicDetails?.role) return REQUIRED;
+		if (data.basicDetails?.role?.some((role) => role !== DecisionMakerTypes.DIRECTOR)) return REQUIRED;
+		if (ID_NUMBER_REQUIRED_FOR_DIRECTOR_COUNTRIES.includes(country) && data.basicDetails?.role?.some((role) => role === DecisionMakerTypes.DIRECTOR)) return REQUIRED;
+	},
+	idNumberRules: () => {
+		if (data.additionalPersonalDetails?.idNumberExempt) return OPTIONAL;
+		if (!data.basicDetails?.role) return REQUIRED;
+		if (country === CountryCodes.UnitedStates && data.basicDetails?.role?.every((role) => role === DecisionMakerTypes.SIGNATORY)) return;
+		if (data.basicDetails?.role?.some((role) => role !== DecisionMakerTypes.DIRECTOR)) return REQUIRED;
+		if (ID_NUMBER_REQUIRED_FOR_DIRECTOR_COUNTRIES.includes(country) && data.basicDetails?.role?.some((role) => role === DecisionMakerTypes.DIRECTOR)) return REQUIRED;
+	},
+	requiredIfDecisionMakerTask: () => {
+		if (taskType === TaskTypes.DECISION_MAKER || taskType === TaskTypes.TRUST_MEMBER_COMPANY_OWNER || taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY_OWNER) return REQUIRED;
+	},
+	idNumberExemptIfApplicableCountry: () => {
+		if (matchingScenario?.includes(Scenarios.L_TAXINFO)) return;
+		if (country === CountryCodes.UnitedStates && data.basicDetails?.role?.every((role) => role === DecisionMakerTypes.SIGNATORY)) return;
+		if (ID_NUMBER_EXEMPT_COUNTRIES.includes(country)) return REQUIRED;
+	},
+	hasChosenIdType: () => {
+		return data?.manualIdUpload?.idDocumentType ? REQUIRED : void 0;
+	},
+	backPageIfRequiredForIdType: () => {
+		return getLocalizedIdDocumentTypeOptions(country).find(({ id }) => id === data.manualIdUpload?.idDocumentType)?.hasBackPage ? REQUIRED : void 0;
+	},
+	isProofOfResidencyRequired: () => {
+		if (isBafinSignatoryFlow({
+			taskType,
+			data,
+			scenarios: matchingScenario
+		})) return;
+		if (data.proofOfResidency?.proofOfResidency?.length) return REQUIRED;
+		if (!(data?.idVerificationMethod?.idVerificationMethod === "instantVerification")) return;
+		const documentCountry = data?.idVerificationMethod?.idDocument?.documentCountry;
+		const residenceCountry = data?.additionalPersonalDetails?.country ?? country;
+		if (!documentCountry || !residenceCountry) return;
+		const countriesMismatch = documentCountry !== residenceCountry;
+		const isEeaLowRiskException = isLowRiskCountry(documentCountry) && isLowRiskCountry(residenceCountry);
+		if (countriesMismatch && !isEeaLowRiskException) return REQUIRED;
+	},
+	isProofOfNationalIdRequired: () => {
+		if (isBafinSignatoryFlow({
+			taskType,
+			data,
+			scenarios: matchingScenario
+		})) return;
+		if (data.proofOfNationalId?.proofOfNationalId?.length) return REQUIRED;
+	},
+	isIdVerificationMethodRequired: () => {
+		if (isBafinSignatoryFlow({
+			taskType,
+			data,
+			scenarios: matchingScenario
+		})) return;
+		return REQUIRED;
+	},
+	isVerifyByInviteSelected: () => {
+		return taskType === TaskTypes.DECISION_MAKER && isFeatureEnabled("EnableVerifyByInvite") && data?.idVerificationMethod?.idVerificationMethod === "verifyByInvite" ? REQUIRED : void 0;
+	},
+	contactsIfRequiredForRole: () => {
+		if (taskType === TaskTypes.DECISION_MAKER) {
+			if (data.basicDetails?.role?.includes(DecisionMakerTypes.SIGNATORY)) return REQUIRED;
+			return;
+		}
+		return REQUIRED;
+	},
+	requiredIfPhoneScenarioDisabled: () => !isFeatureEnabled("EnablePhoneFieldScenario") ? REQUIRED : void 0,
+	jobTitleIfRequiredForRole: () => {
+		if (taskType !== TaskTypes.DECISION_MAKER) return;
+		if (data.basicDetails?.role?.some((role) => DECISION_MAKER_TYPES_WITH_JOBTITLE.includes(role)) || JOB_TITLE_REQUIRED_FOR_COUNTRIES.includes(country)) return REQUIRED;
+	},
+	isPlaceOfBirthRequired: () => {
+		if (isBafinSignatoryFlow({
+			taskType,
+			data,
+			scenarios: matchingScenario
+		})) return REQUIRED;
+	},
+	nationalityIfRequiredForRole: () => {
+		if (isBafinSignatoryFlow({
+			taskType,
+			data,
+			scenarios: matchingScenario
+		})) return REQUIRED;
+		const enableNationalitySGHK = isFeatureEnabled("EnableNationalitySGHK");
+		const rootLegalEntityCountry = rootLegalEntity ? getLegalEntityCountry(rootLegalEntity) : void 0;
+		if (enableNationalitySGHK && rootLegalEntityCountry && NATIONALITY_REQUIRED_FOR_COUNTRIES.includes(rootLegalEntityCountry)) return REQUIRED;
+		if (NATIONALITY_REQUIRED_FOR_COUNTRIES.includes(country) || data?.additionalPersonalDetails?.nationality) return REQUIRED;
+	},
+	requiredIfCountryUsesMultipleTypesOfIdentity: () => {
+		if (COUNTRIES_WHICH_USE_MULTIPLE_IDENTITY_TYPES.includes(country)) return REQUIRED;
+	},
+	licenseCardNumberRules: () => {
+		if (data.additionalPersonalDetails?.typeOfIdentity === "driversLicense" && LICENSE_CARD_NUMBER_REQUIRED_FOR_COUNTRIES.includes(country)) return REQUIRED;
+	},
+	issuerStateRequired: () => {
+		if (data.additionalPersonalDetails?.typeOfIdentity === "driversLicense" && ISSUER_REQUIRED_FOR_COUNTRIES.includes(country)) return REQUIRED;
+	},
+	expiryDateRequired: () => {
+		if (data.additionalPersonalDetails?.typeOfIdentity === "passport" && EXPIRY_DATE_REQUIRED_FOR_COUNTRIES.includes(country)) return REQUIRED;
+	},
+	legalRepresentativeRelationshipRequired: () => taskType === TaskTypes.LEGAL_REPRESENTATIVE_DETAILS ? REQUIRED : void 0,
+	isProofOfRelationshipRequired: () => void 0,
+	addressIfRequiredForCountry: () => {
+		return getAddressSchemaForCountry(data?.additionalPersonalDetails?.country).includes("street") ? "REQUIRED" : void 0;
+	},
+	otherAddressInfoIfRequiredForCountry: () => {
+		if (isJapanLocalizationEnabled(isFeatureEnabled, country)) return "REQUIRED";
+		return getAddressSchemaForCountry(data?.additionalPersonalDetails?.country).includes("street2") ? "OPTIONAL" : void 0;
+	},
+	postalCodeIfRequiredForCountry: () => {
+		return getAddressSchemaForCountry(data?.additionalPersonalDetails?.country).includes("postalCode") ? "REQUIRED" : void 0;
+	},
+	cityIfRequiredForCountry: () => {
+		return getAddressSchemaForCountry(data?.additionalPersonalDetails?.country).includes("city") ? "REQUIRED" : void 0;
+	},
+	stateOrProvinceIfRequiredForCountry: () => {
+		return getAddressSchemaForCountry(data?.additionalPersonalDetails?.country).includes("stateOrProvince") && COUNTRIES_WITH_STATES_DATASET.includes(data?.additionalPersonalDetails?.country ?? country) ? "REQUIRED" : void 0;
+	},
+	nomineeDirectorRequiredForCountry: () => {
+		if (allowedCountriesForNominee.includes(data?.additionalPersonalDetails?.country ?? country) && data?.basicDetails?.role?.includes(DecisionMakerTypes.DIRECTOR)) return "REQUIRED";
+	},
+	nomineeShareHolderRequiredForCountry: () => {
+		if (allowedCountriesForNominee.includes(data?.additionalPersonalDetails?.country ?? country) && data?.basicDetails?.role?.includes(DecisionMakerTypes.OWNER)) return "REQUIRED";
+	},
+	isUsingInstantVerificationOrHasExistingDocument: () => {
+		if (isBafinSignatoryFlow({
+			taskType,
+			data,
+			scenarios: matchingScenario
+		})) return;
+		const isUsingInstantVerification = data?.idVerificationMethod?.idVerificationMethod === "instantVerification";
+		const existingDocument = data?.idVerificationMethod?.idDocument;
+		return isUsingInstantVerification || existingDocument ? REQUIRED : void 0;
+	},
+	isManualIdFlow: () => {
+		if (isBafinSignatoryFlow({
+			taskType,
+			data,
+			scenarios: matchingScenario
+		})) return;
+		return data?.idVerificationMethod?.idVerificationMethod === "manualVerification" ? "REQUIRED" : void 0;
+	},
+	isManualIdFlowAndNotProvidingIdNumber: () => {
+		if (isBafinSignatoryFlow({
+			taskType,
+			data,
+			scenarios: matchingScenario
+		})) return;
+		const hasMissingId = problems?.missingData?.some((error) => error.code === ID_MISSING_DATA_ERROR_CODE);
+		const isManualFlow = data?.idVerificationMethod?.idVerificationMethod === "manualVerification";
+		const idNumberExempt = data?.additionalPersonalDetails?.idNumberExempt;
+		const hasIdRemediationAction = Object.keys(problems?.remediationActions ?? {}).some((code) => REMEDIATION_CODES_UPLOAD_ID.includes(code));
+		return isManualFlow && (idNumberExempt || hasMissingId || hasIdRemediationAction) ? "REQUIRED" : void 0;
+	},
+	isManualIdFlowAndHasMissingData: () => {
+		if (isBafinSignatoryFlow({
+			taskType,
+			data,
+			scenarios: matchingScenario
+		})) return;
+		const isManualFlow = data?.idVerificationMethod?.idVerificationMethod === "manualVerification";
+		if (matchingScenario?.includes(Scenarios.L1_IDDOC)) return isManualFlow ? "REQUIRED" : void 0;
+		const hasMissingId = problems?.missingData?.some((error) => error.code === ID_MISSING_DATA_ERROR_CODE);
+		const hasIdRemediationAction = Object.keys(problems?.remediationActions ?? {}).some((code) => REMEDIATION_CODES_UPLOAD_ID.includes(code));
+		return isManualFlow && (hasMissingId || hasIdRemediationAction) ? "REQUIRED" : void 0;
+	},
+	idVerificationRequired: () => {
+		return REQUIRED;
+	},
+	isDirectorRequiredForCountry: () => {
+		if (getAvailableDecisionMakerRoleTypes(rootLegalEntity ? getLegalEntityCountry(rootLegalEntity) : country, matchingScenario).some((maker) => maker.roleType === DecisionMakerTypes.DIRECTOR)) return "REQUIRED";
+	},
+	japanSpecificField: () => {
+		if (isJapanLocalizationEnabled(isFeatureEnabled, taskType === TaskTypes.DECISION_MAKER && rootLegalEntity && getLegalEntityCountry(rootLegalEntity) || country)) return "REQUIRED";
+	}
+});
+//#endregion
+//#region src/components/Individual/forms/AdditionalPersonalDetails/Identity/TypeOfIdentity/index.tsx
+var TypeOfIdentity = ({ availableIdentityTypesOptions, selectedIdentityType, setSelectedIdentityType, label, errorMessage, isValid }) => {
+	const { t } = useTranslation(["common", "individual"]);
+	return /* @__PURE__ */ jsx(Field, {
+		name: "typeOfIdentity",
+		label,
+		errorMessage,
+		isValid,
+		helper: t(($) => $["typeOfIdentitySubtitle"], { ns: "individual" }),
+		children: (childProps) => /* @__PURE__ */ jsx(Select, {
+			...childProps,
+			name: "typeOfIdentity",
+			isInvalid: false,
+			items: availableIdentityTypesOptions.map(({ id, name }) => ({
+				id,
+				name: t(($) => $[name])
+			})),
+			placeholder: t(($) => $["selectOne"]),
+			selected: selectedIdentityType,
+			onChange: (event) => setSelectedIdentityType(event.target.value)
+		})
+	});
+};
+//#endregion
+//#region src/components/Individual/forms/AdditionalPersonalDetails/Identity/validate.ts
+var identityValidationRules = (country) => {
+	switch (country) {
+		case CountryCodes.Australia: return {
+			typeOfIdentity: [isTruthyValidator],
+			issuerState: [isTruthyValidator]
+		};
+		case CountryCodes.HongKong:
+		case CountryCodes.NewZealand: return { typeOfIdentity: [isTruthyValidator] };
+		default: return {};
+	}
+};
+//#endregion
+//#region src/components/Individual/forms/AdditionalPersonalDetails/Identity/Identity.tsx
+function Identity(props) {
+	const { additionalPersonalDetails, country, idNumberType, handleFieldChange } = props;
+	const { data, errors, fieldValidationErrors, formVerificationErrors, id: dataStoreId, labels, obscuredFields, optionalFields, requiredFields, readOnlyFields, shouldValidate, validators, valid } = additionalPersonalDetails;
+	const initialFormUtilProps = useMemo$1(() => {
+		return {
+			validators: {
+				...identityValidationRules(country),
+				...validators
+			},
+			labels,
+			obscuredFields,
+			readOnlyFields,
+			optionalFields,
+			requiredFields
+		};
+	}, [
+		country,
+		validators,
+		labels,
+		obscuredFields,
+		readOnlyFields,
+		optionalFields,
+		requiredFields
+	]);
+	const licenseCardNumberMetaData = useMemo$1(() => {
+		return resolveFieldMetadata(licenseCardNumberDefaultConfig[country], {}, licenseCardNumberDefaultMetadata);
+	}, [country]);
+	const idNumberMetadata = useMemo$1(() => {
+		return resolveFieldMetadata(defaultFieldConfig[country], { idNumberType: data?.typeOfIdentity }, defaultFieldMetadata$1);
+	}, [country, data?.typeOfIdentity]);
+	const mergedProps = useMemo$1(() => {
+		return mergeFieldMetadataIntoProps("idNumber", idNumberMetadata, mergeFieldMetadataIntoProps("licenseCardNumber", licenseCardNumberMetaData, initialFormUtilProps));
+	}, [
+		idNumberMetadata,
+		initialFormUtilProps,
+		licenseCardNumberMetaData
+	]);
+	const { t } = useTranslation("common");
+	const formUtils = useMemo$1(() => createFormUtils(mergedProps, t), [mergedProps, t]);
+	const { form } = useFormContext();
+	const defaultIdNumber = form?.defaultData?.additionalPersonalDetails?.idNumber;
+	const ssnType = getSSNType(formVerificationErrors, defaultIdNumber);
+	const today = /* @__PURE__ */ new Date();
+	const maxExpiryDateSelection = new Date((/* @__PURE__ */ new Date()).setFullYear(today.getFullYear() + 10));
+	const isCountryAustralia = country === CountryCodes.Australia;
+	const isCountryNewZealand = country === CountryCodes.NewZealand;
+	useEffect$1(() => {
+		if (data?.typeOfIdentity === "nationalIdNumber") handleFieldChange("typeOfIdentity")(void 0);
+	}, [data?.typeOfIdentity, handleFieldChange]);
+	if (!handleFieldChange) return;
+	const identityProps = getFieldProps(additionalPersonalDetails, idNumberFields);
+	if (country === CountryCodes.UnitedStates || country === CountryCodes.PuertoRico) return /* @__PURE__ */ jsx(IdentityNumber, {
+		...identityProps,
+		errors,
+		dataStoreId,
+		country,
+		formVerificationErrors,
+		handleFieldChange,
+		idNumberType: ssnType
+	});
+	return COUNTRIES_WHICH_USE_MULTIPLE_IDENTITY_TYPES.includes(country) ? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(TypeOfIdentity, {
+			availableIdentityTypesOptions: additionallIdNumberOptions?.[country],
+			selectedIdentityType: data?.typeOfIdentity,
+			setSelectedIdentityType: handleFieldChange("typeOfIdentity"),
+			label: formUtils.getLabel("typeOfIdentity"),
+			isValid: Boolean(valid?.typeOfIdentity),
+			errorMessage: formUtils.getErrorMessage("typeOfIdentity", errors, fieldValidationErrors)
+		}),
+		(isCountryAustralia || isCountryNewZealand) && data?.typeOfIdentity === "passport" && /* @__PURE__ */ jsx(MaskedInput, {
+			name: "idNumber",
+			type: "text",
+			label: formUtils.getLabel("idNumber", "idNumber"),
+			formatGuidance: translateTranslatable(t, idNumberMetadata.guidanceText),
+			errorMessage: formUtils.getErrorMessage("idNumber", errors, fieldValidationErrors),
+			shouldValidate,
+			isValid: Boolean(valid?.idNumber),
+			"aria-required": formUtils.isRequiredField("idNumber"),
+			"aria-invalid": !valid?.idNumber,
+			onBlur: handleFieldChange("idNumber", "blur"),
+			readonly: formUtils.isReadOnly("idNumber"),
+			value: data?.idNumber ?? "",
+			onInput: handleFieldChange("idNumber", "input"),
+			acceptObscuredValue: formUtils?.isObscured("idNumber"),
+			...formUtils.getMask("idNumber")
+		}),
+		isCountryNewZealand && data?.typeOfIdentity === "passport" && /* @__PURE__ */ jsx(Field, {
+			name: "expiryDate",
+			label: formUtils.getLabel("passportExpiryDate"),
+			errorMessage: formUtils.getErrorMessage("expiryDate", errors, fieldValidationErrors),
+			isValid: valid?.expiryDate,
+			children: (childProps) => /* @__PURE__ */ jsx(InputDate, {
+				...childProps,
+				name: "expiryDate",
+				value: data?.expiryDate,
+				placeholder: t(($) => $["datePlaceholder"]),
+				readonly: formUtils.isReadOnly("expiryDate"),
+				onInput: handleFieldChange("expiryDate", "input"),
+				onBlur: handleFieldChange("expiryDate", "blur"),
+				"aria-required": true,
+				"aria-invalid": !valid?.expiryDate,
+				min: formatDateObj(today),
+				max: formatDateObj(maxExpiryDateSelection)
+			})
+		}),
+		(isCountryAustralia || isCountryNewZealand) && data?.typeOfIdentity === "driversLicense" && /* @__PURE__ */ jsx(DriversLicense, {
+			country,
+			driversLicense: data,
+			onIssuerStateChange: handleFieldChange("issuerState"),
+			onLicenseNumberInput: handleFieldChange("idNumber", "input"),
+			onLicenseNumberBlur: handleFieldChange("idNumber", "blur"),
+			onCardNumberInput: handleFieldChange("licenseCardNumber", "input"),
+			onCardNumberBlur: handleFieldChange("licenseCardNumber", "blur"),
+			formUtils,
+			isValid: {
+				idNumber: Boolean(valid?.idNumber),
+				licenseCardNumber: Boolean(valid?.licenseCardNumber),
+				issuerState: Boolean(valid?.issuerState)
+			},
+			guidanceText: {
+				idNumber: translateTranslatable(t, idNumberMetadata.guidanceText),
+				licenseCardNumber: translateTranslatable(t, licenseCardNumberMetaData.guidanceText)
+			},
+			errorMessages: {
+				idNumber: formUtils.getErrorMessage("idNumber", errors, fieldValidationErrors),
+				licenseCardNumber: formUtils.getErrorMessage("licenseCardNumber", errors, fieldValidationErrors),
+				issuerState: formUtils.getErrorMessage("issuerState", errors, fieldValidationErrors)
+			},
+			shouldValidate
+		}),
+		country === CountryCodes.HongKong && /* @__PURE__ */ jsx(MaskedInput, {
+			name: "idNumber",
+			type: "text",
+			label: formUtils.getLabel("idNumber", "idNumber"),
+			formatGuidance: translateTranslatable(t, idNumberMetadata.guidanceText),
+			errorMessage: formUtils.getErrorMessage("idNumber", errors, fieldValidationErrors),
+			shouldValidate,
+			isValid: Boolean(valid?.idNumber),
+			"aria-required": formUtils.isRequiredField("idNumber"),
+			"aria-invalid": Boolean(!valid?.idNumber),
+			onBlur: handleFieldChange("idNumber", "blur"),
+			readonly: formUtils.isReadOnly("idNumber"),
+			value: data?.idNumber ?? "",
+			onInput: handleFieldChange("idNumber", "input"),
+			acceptObscuredValue: formUtils?.isObscured("idNumber"),
+			...formUtils.getMask("idNumber")
+		})
+	] }) : /* @__PURE__ */ jsx(IdentityNumber, {
+		...identityProps,
+		errors,
+		country,
+		dataStoreId,
+		idNumberType,
+		handleFieldChange
+	});
+}
+//#endregion
+//#region src/components/Individual/forms/AdditionalPersonalDetails/Identity/Identity.types.ts
+var additionalIdentityInfoFields = [
+	"typeOfIdentity",
+	"licenseCardNumber",
+	"issuerState",
+	"expiryDate"
+];
+//#endregion
+//#region src/components/Individual/forms/AdditionalPersonalDetails/AdditionalPersonalDetails.tsx
+var LazyJpAddressFields = lazy(async () => (await import("./JpAddressFields-F1YCOcbO.js")).JpAddressFields);
+var additionalPersonalDetailsFields = [
+	"birthDate",
+	...idNumberFields,
+	...additionalIdentityInfoFields,
+	"country",
+	"nationality",
+	"placeOfBirth",
+	...addressFields,
+	...JP_ADDRESS_REQUIRED_FIELDS,
+	"taxInformation"
+];
+function AdditionalPersonalDetails(props) {
+	const { t } = useTranslation(["common", "individual"]);
+	const allowedCountries = useAllowedCountries();
+	const [showLegalRepresentativePrompt, setShowLegalRepresentativePrompt] = useState$1(false);
+	const { isSettingEnabled } = useSettingsContext();
+	const { isFeatureEnabled } = useToggleContext();
+	const { form } = useFormContext();
+	const isAgeVerificationFeatureEnabled = isFeatureEnabled("EnableAgeVerification");
+	const isSettingsEnforceLegalAgeEnabled = isSettingEnabled(SettingNames.EnforceLegalAge);
+	const { country: defaultCountry, data, formVerificationErrors, heading, shouldValidate, valid, fieldValidationErrors, errors = {}, taskType, handleFieldChange } = props;
+	const country = data?.country ?? defaultCountry;
+	const showField = (fieldKeys) => fieldKeys.some((field) => formUtils.isRequiredField(field) || formUtils.isOptionalField(field));
+	const formUtils = createFormUtils(props, t);
+	const birthDateErrorMessage = formUtils.getErrorMessage("birthDate", errors, fieldValidationErrors);
+	if (!handleFieldChange) return;
+	const handleBirthDateChange = (event) => {
+		handleFieldChange("birthDate", "blur")(event);
+		if (isAgeVerificationFeatureEnabled && !isSettingsEnforceLegalAgeEnabled && isLegalRepresentativeNeeded(event.currentTarget.value, country, taskType)) setShowLegalRepresentativePrompt(true);
+	};
+	const isRootIndividual = taskType === TaskTypes.INDIVIDUAL;
+	const canEditCountry = isSettingEnabled(SettingNames.AllowPrefilledCountryEdit) || isDecisionMakerTask(taskType);
+	const addressProps = {
+		...props,
+		fieldValidationErrors,
+		handleFieldChange
+	};
+	const buildJpProps = () => getFieldProps(addressProps, ALL_ADDRESS_FIELDS);
+	const buildProps = () => getFieldProps(addressProps, addressFields);
+	const addressFieldProps = isJapanLocalizationEnabled(isFeatureEnabled, country) ? {
+		showJapanLocalization: true,
+		residentialAddress: {
+			...buildJpProps(),
+			handleFieldChange
+		}
+	} : {
+		showJapanLocalization: false,
+		residentialAddress: {
+			...buildProps(),
+			handleFieldChange
+		}
+	};
+	return /* @__PURE__ */ jsxs("form", {
+		"aria-describedby": "ariaErrorField",
+		children: [
+			heading && /* @__PURE__ */ jsx(Header, { title: heading }),
+			/* @__PURE__ */ jsx(ErrorPanel, {
+				verificationErrors: formVerificationErrors,
+				validationErrors: fieldValidationErrors,
+				formUtils,
+				id: "ariaErrorField"
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: AdditionalPersonalDetails_module_default.additionalDetailsSectionHeading,
+				children: [/* @__PURE__ */ jsx(Typography, {
+					el: "h3",
+					variant: "title",
+					children: t(($) => $["residentialAddress"])
+				}), /* @__PURE__ */ jsx(Typography, {
+					el: "p",
+					variant: "body",
+					children: t(($) => $["thisPersonsPrimaryAddress"], { ns: "individual" })
+				})]
+			}),
+			formUtils.isRequiredField("country") && /* @__PURE__ */ jsx(CountryField, {
+				data: { country },
+				valid: { country: valid?.country },
+				errors: { country: formUtils.getErrorMessage("country", errors, fieldValidationErrors) },
+				labels: { country: formUtils.getLabel("country") },
+				readonly: formUtils.isReadOnly("country") || !canEditCountry,
+				allowedCountries: isRootIndividual ? allowedCountries : void 0,
+				handleChangeFor: handleFieldChange
+			}),
+			addressFieldProps.showJapanLocalization ? /* @__PURE__ */ jsx(Suspense, {
+				fallback: /* @__PURE__ */ jsx(Loader, {}),
+				children: /* @__PURE__ */ jsx(LazyJpAddressFields, {
+					...addressFieldProps.residentialAddress,
+					handleFieldChange,
+					addressType: "residentialAddress"
+				})
+			}) : /* @__PURE__ */ jsx(AddressFields, {
+				...addressFieldProps.residentialAddress,
+				handleFieldChange,
+				addressType: "residentialAddress",
+				hideCountry: true
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: AdditionalPersonalDetails_module_default.additionalDetailsSectionHeading,
+				children: [/* @__PURE__ */ jsx(Typography, {
+					el: "h3",
+					variant: "title",
+					children: t(($) => $["personalIdentityDetails"], { ns: "individual" })
+				}), /* @__PURE__ */ jsxs(Typography, {
+					el: "p",
+					variant: "body",
+					children: [
+						t(($) => $["weOnlyUseTheseDetailsForIdentityVerification"], { ns: "individual" }),
+						" ",
+						/* @__PURE__ */ jsx(Link, {
+							href: "https://www.adyen.com/privacy-policy",
+							external: true,
+							children: t(($) => $["privacyStatement"])
+						})
+					]
+				})]
+			}),
+			formUtils.isRequiredField("birthDate") && /* @__PURE__ */ jsx(Field, {
+				name: "birthDate",
+				label: formUtils.getLabel("birthDate"),
+				errorMessage: birthDateErrorMessage,
+				isValid: valid?.birthDate,
+				children: (childProps) => /* @__PURE__ */ jsx(InputDate, {
+					...childProps,
+					name: "birthDate",
+					value: data?.birthDate,
+					placeholder: t(($) => $["datePlaceholder"]),
+					readonly: formUtils.isReadOnly("birthDate"),
+					onInput: handleFieldChange("birthDate", "input"),
+					onBlur: handleBirthDateChange,
+					"aria-required": true,
+					"aria-invalid": !valid?.birthDate,
+					max: formatDateObj(/* @__PURE__ */ new Date())
+				})
+			}),
+			showLegalRepresentativePrompt && /* @__PURE__ */ jsx(Confirm, {
+				title: t(($) => $["legalRepresentativeForMinorIsRequired"], { ns: "individual" }),
+				description: t(($) => $["becauseThisPersonIsUnderXYearsOld"], {
+					ns: "individual",
+					age: getAgeRangeForLegalRepresentative(country)?.max?.toString() ?? ""
+				}),
+				onCancel: () => {
+					setShowLegalRepresentativePrompt(false);
+				},
+				confirmText: t(($) => $["ok"]),
+				cancelText: t(($) => $["editDetails"]),
+				onConfirm: () => {
+					setShowLegalRepresentativePrompt(false);
+				}
+			}),
+			/* @__PURE__ */ jsx(IndividualIdNumberTypeSelector, {
+				country,
+				handleFieldChange: handleFieldChange("typeOfIdentity", "input"),
+				selected: data?.typeOfIdentity
+			}),
+			/* @__PURE__ */ jsx(Identity, {
+				additionalPersonalDetails: props,
+				country,
+				errors,
+				idNumberType: data?.typeOfIdentity,
+				handleFieldChange
+			}),
+			showField(["taxInformation"]) && /* @__PURE__ */ jsx(TaxInformationField, {
+				data: formUtils.getFieldData(form.data?.additionalPersonalDetails ?? {}, ["taxInformation"]),
+				valid: formUtils.getFieldValid(form.valid?.additionalPersonalDetails ?? {}, ["taxInformation"]),
+				errors: { taxInformation: formUtils.getErrorMessage("taxInformation", errors, fieldValidationErrors) },
+				readonly: formUtils.isReadOnly("taxInformation"),
+				shouldValidate,
+				handleChangeFor: handleFieldChange,
+				canExempt: false,
+				country,
+				entityType: "individual",
+				defaultData: form.defaultData?.additionalPersonalDetails?.taxInformation
+			}),
+			formUtils.isRequiredField("nationality") && /* @__PURE__ */ jsx(CountryField, {
+				data: { country: data?.nationality },
+				valid: { country: valid?.nationality },
+				name: "nationality",
+				errors: { country: formUtils.getErrorMessage("nationality", errors, fieldValidationErrors) },
+				labels: { country: formUtils.getLabel("nationality") },
+				readonly: formUtils.isReadOnly("nationality"),
+				handleChangeFor: () => handleFieldChange("nationality", "input")
+			}),
+			formUtils.isRequiredField("placeOfBirth") && /* @__PURE__ */ jsx(Field, {
+				name: "placeOfBirth",
+				label: formUtils.getLabel("placeOfBirth"),
+				errorMessage: formUtils.getErrorMessage("placeOfBirth", errors, fieldValidationErrors),
+				isValid: valid?.placeOfBirth,
+				children: (childProps) => /* @__PURE__ */ jsx(InputText, {
+					...childProps,
+					name: "placeOfBirth",
+					value: data?.placeOfBirth,
+					readonly: formUtils.isReadOnly("placeOfBirth"),
+					onInput: handleFieldChange("placeOfBirth", "input"),
+					onBlur: handleFieldChange("placeOfBirth", "blur"),
+					"aria-required": true,
+					"aria-invalid": !valid?.placeOfBirth
+				})
+			}),
+			country === "US" ? /* @__PURE__ */ jsx(PatriotActDisclosure, {}) : void 0
+		]
+	});
+}
+//#endregion
+//#region src/components/Individual/fields/NameFields/NameFields.tsx
+function NameFields(props) {
+	const { formProps, fieldConfigs } = props;
+	const { t } = useTranslation("common");
+	const { data, handleFieldChange, errors, fieldValidationErrors } = formProps;
+	if (!handleFieldChange) return;
+	const formUtils = createFormUtils(formProps, t);
+	return /* @__PURE__ */ jsx("div", {
+		className: "adyen-kyc-field-wrapper",
+		children: fieldConfigs.map(({ name, isValid, label, helper, transformInput, transformMode }) => formUtils.isRequiredField(name) && /* @__PURE__ */ jsx(Field, {
+			name,
+			label: formUtils.getLabel(label),
+			errorMessage: formUtils.getErrorMessage(name, errors, fieldValidationErrors),
+			isValid,
+			helper: helper && formUtils.getLabel(helper),
+			children: (childProps) => /* @__PURE__ */ jsx(InputText, {
+				...childProps,
+				name,
+				value: data?.[name],
+				readonly: formUtils.isReadOnly(name),
+				onInput: handleFieldChange(name, "input"),
+				onBlur: handleFieldChange(name, "blur"),
+				trimOnBlur: true,
+				spellCheck: false,
+				"aria-required": true,
+				"aria-invalid": !isValid,
+				transformInput,
+				transformMode
+			})
+		}, name))
+	});
+}
+//#endregion
+//#region src/components/Individual/fields/NameFields/types.ts
+var jaHaniNameFields = ["jaHaniFirstName", "jaHaniLastName"];
+var jaKanaNameFields = ["jaKanaFirstName", "jaKanaLastName"];
+//#endregion
+//#region src/components/Shared/fields/LocalizedNameFields/LocalizedNameFields.tsx
+var LocalizedNameFields = (props) => {
+	const { errors, id, handleFieldChange, country } = props;
+	const jaHaniNameProps = getFieldProps(props, jaHaniNameFields);
+	const jaKanaNameProps = getFieldProps(props, jaKanaNameFields);
+	const nameProps = getFieldProps(props, nameFields);
+	if (country === CountryCodes.Japan) return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		!!jaHaniNameProps?.requiredFields?.length && /* @__PURE__ */ jsx(NameFields, {
+			fieldConfigs: [{
+				name: "jaHaniLastName",
+				label: "jaHaniLastName",
+				isValid: jaHaniNameProps.valid?.jaHaniLastName,
+				transformInput: toFullWidth,
+				transformMode: "blur"
+			}, {
+				name: "jaHaniFirstName",
+				label: "jaHaniFirstName",
+				isValid: jaHaniNameProps.valid?.jaHaniFirstName,
+				transformInput: toFullWidth,
+				transformMode: "blur"
+			}],
+			formProps: {
+				...jaHaniNameProps,
+				dataStoreId: id,
+				errors,
+				handleFieldChange
+			}
+		}),
+		!!jaKanaNameProps?.requiredFields?.length && /* @__PURE__ */ jsx(NameFields, {
+			fieldConfigs: [{
+				name: "jaKanaLastName",
+				label: "jaKanaLastName",
+				isValid: jaKanaNameProps.valid?.jaKanaLastName,
+				transformInput: toFullWidth,
+				transformMode: "blur"
+			}, {
+				name: "jaKanaFirstName",
+				label: "jaKanaFirstName",
+				isValid: jaKanaNameProps.valid?.jaKanaFirstName,
+				transformInput: toFullWidth,
+				transformMode: "blur"
+			}],
+			formProps: {
+				...jaKanaNameProps,
+				dataStoreId: id,
+				errors,
+				handleFieldChange
+			}
+		}),
+		!!nameProps?.requiredFields?.length && /* @__PURE__ */ jsx(NameFields, {
+			fieldConfigs: [{
+				name: "lastName",
+				label: "lastName__JP",
+				isValid: nameProps.valid?.lastName,
+				transformInput: convertFullToHalf,
+				transformMode: "blur"
+			}, {
+				name: "firstName",
+				label: "firstName__JP",
+				isValid: nameProps.valid?.firstName,
+				transformInput: convertFullToHalf,
+				transformMode: "blur"
+			}],
+			formProps: {
+				...nameProps,
+				dataStoreId: id,
+				errors,
+				handleFieldChange
+			}
+		})
+	] });
+	return /* @__PURE__ */ jsx(Name, {
+		...nameProps,
+		dataStoreId: id,
+		errors,
+		handleFieldChange
+	});
+};
+//#endregion
+//#region src/components/Individual/forms/BasicDetails/BasicDetails.tsx
+var decisionMakerRoleFields = ["role"];
+var nomineeFields = ["nomineeDirector", "nomineeShareholder"];
+var basicDetailsFields = [
+	...nameFields,
+	"jobTitle",
+	...decisionMakerRoleFields,
+	...nomineeFields,
+	...contactDetailFields,
+	"relationship",
+	"jaHaniFirstName",
+	"jaHaniLastName",
+	"jaKanaFirstName",
+	"jaKanaLastName"
+];
+function BasicDetails(props) {
+	const { t: commonT } = useTranslation("common");
+	const { t: individualT } = useTranslation("individual");
+	const { form: { triggerValidation } } = useFormContext();
+	const { country, data, formVerificationErrors, heading, id: basicDetailsId, parentLegalEntity, readOnlyFields, taskType, trustedFieldsProvider, fieldValidationErrors, errors, handleFieldChange } = props;
+	const isLegalRepresentativeDetailsTask = taskType === TaskTypes.LEGAL_REPRESENTATIVE_DETAILS;
+	const formUtils = createFormUtils(props, commonT);
+	const localizedNameProps = getFieldProps(props, [
+		"jaHaniFirstName",
+		"jaHaniLastName",
+		"jaKanaFirstName",
+		"jaKanaLastName",
+		...nameFields
+	]);
+	const contactDetailsFormProps = getFieldProps(props, contactDetailFields);
+	if (!handleFieldChange) return;
+	return /* @__PURE__ */ jsxs("form", {
+		"aria-describedby": "ariaErrorField",
+		children: [
+			heading && /* @__PURE__ */ jsx(Header, { title: heading }),
+			/* @__PURE__ */ jsx(ErrorPanel, {
+				verificationErrors: formVerificationErrors,
+				validationErrors: fieldValidationErrors,
+				formUtils,
+				id: "ariaErrorField"
+			}),
+			isLegalRepresentativeDetailsTask && /* @__PURE__ */ jsx(Alert, {
+				variant: "info",
+				title: individualT(($) => $["legalRepresentativeFor"], {
+					firstName: parentLegalEntity?.individual?.name.firstName || "",
+					lastName: parentLegalEntity?.individual?.name.lastName || ""
+				})
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "u-margin-bottom-32",
+				children: /* @__PURE__ */ jsx(ContextGuidance, {
+					title: commonT(($) => $["whyDoINeedToFillInThisInformation"]),
+					content: individualT(($) => $["reasonForFillingIndividualPersonalDetails"]),
+					titleId: "whyDoINeedToFillInThisInformation",
+					contentId: "reasonForFillingIndividualPersonalDetails"
+				})
+			}),
+			isDecisionMakerTask(taskType) && trustedFieldsProvider === "singpass" && readOnlyFields && /* @__PURE__ */ jsx(Typography, {
+				color: "secondary",
+				variant: "caption",
+				children: individualT(($) => $["weSelectedSomeRolesBasedOnMyinfoBusinessDataAboutYourCompanysAppointmentHoldersAndShareholders"])
+			}),
+			/* @__PURE__ */ jsx(LocalizedNameFields, {
+				...localizedNameProps,
+				country,
+				handleFieldChange
+			}),
+			formUtils.isRequiredField("jobTitle", false) && /* @__PURE__ */ jsx(Field, {
+				name: "jobTitle",
+				label: formUtils.getLabel("jobTitle"),
+				errorMessage: formUtils.getErrorMessage("jobTitle", errors, fieldValidationErrors),
+				children: (childProps) => /* @__PURE__ */ jsx(InputText, {
+					...childProps,
+					name: "jobTitle",
+					value: data?.jobTitle,
+					readonly: formUtils.isReadOnly("jobTitle"),
+					onInput: handleFieldChange("jobTitle", "input"),
+					onBlur: handleFieldChange("jobTitle", "blur"),
+					"aria-required": true
+				})
+			}),
+			!!contactDetailsFormProps?.requiredFields?.length && /* @__PURE__ */ jsx(ContactDetails, {
+				...contactDetailsFormProps,
+				dataStoreId: basicDetailsId,
+				country,
+				handleFieldChange,
+				triggerValidation: () => triggerValidation("basicDetails")
+			})
+		]
+	});
+}
+var IdDocumentUpload_module_default = {
+	"individual-document-upload": "_individual-document-upload_7mw7n_1",
+	individualDocumentUpload: "_individual-document-upload_7mw7n_1",
+	"individual-document-upload-subtitle": "_individual-document-upload-subtitle_7mw7n_5",
+	individualDocumentUploadSubtitle: "_individual-document-upload-subtitle_7mw7n_5"
+};
+//#endregion
+//#region src/components/Individual/forms/IdDocumentUpload/IdDocumentManualUpload.tsx
+var idDocumentUploadFields = [
+	"idDocumentType",
+	"idFrontPage",
+	"idBackPage",
+	"instantIdVerificationData"
+];
+function IdDocumentManualUpload(props) {
+	const { t } = useTranslation(["common", "individual"]);
+	const { data, id, name, errors, valid, handleFieldChange, country, formVerificationErrors, fieldValidationErrors } = props;
+	if (!handleFieldChange) return;
+	const isOptional = !(formVerificationErrors && Object.keys(formVerificationErrors)?.length === 0);
+	const idDocumentTypeOptions = getLocalizedIdDocumentTypeOptions(country);
+	const hasBackPage = (documentType) => {
+		if (documentType) return idDocumentTypeOptions.find(({ id }) => documentType === id)?.hasBackPage;
+	};
+	const hasBack = hasBackPage(data?.idDocumentType);
+	const formUtils = createFormUtils(props, t);
+	return /* @__PURE__ */ jsxs("div", {
+		className: IdDocumentUpload_module_default.individualDocumentUpload,
+		children: [
+			/* @__PURE__ */ jsx(Header, { title: t(($) => $["idDocument"]) }),
+			/* @__PURE__ */ jsx(ErrorPanel, {
+				verificationErrors: formVerificationErrors,
+				validationErrors: fieldValidationErrors,
+				formUtils,
+				id: "ariaErrorField"
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: IdDocumentUpload_module_default.individualDocumentUploadSubtitle,
+				children: /* @__PURE__ */ jsx(Trans, {
+					t,
+					i18nKey: ($) => $["idUploadDocumentSubtitle"],
+					values: { name }
+				})
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				name: "idDocumentType",
+				label: t(($) => $["selectDocumentType"]),
+				errorMessage: formatValidationError(errors?.idDocumentType?.errorMessage, t),
+				isValid: valid?.idDocumentType,
+				children: (childProps) => /* @__PURE__ */ jsx(Select, {
+					...childProps,
+					onChange: handleFieldChange("idDocumentType", "input"),
+					name: "idDocumentType",
+					placeholder: t(($) => $["selectDocument"]),
+					selected: data?.idDocumentType,
+					items: idDocumentTypeOptions.map(({ id, name }) => ({
+						id,
+						name: t(($) => $[name])
+					}))
+				})
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: IdDocumentUpload_module_default.individualDocumentUploadSubtitle,
+				children: [" ", t(($) => $["requirements"])]
+			}),
+			/* @__PURE__ */ jsxs("ul", { children: [
+				/* @__PURE__ */ jsx("li", { children: t(($) => $["documentNotExpiredOrDamaged"], { ns: "individual" }) }),
+				/* @__PURE__ */ jsx("li", { children: hasBackPage(data?.idDocumentType) ? t(($) => $["includeFrontAndBack"], { ns: "individual" }) : t(($) => $["providePageWithPhotoAndCode"], { ns: "individual" }) }),
+				/* @__PURE__ */ jsx("li", { children: t(($) => $["fullDocumentVisible"], { ns: "individual" }) }),
+				/* @__PURE__ */ jsx("li", { children: t(($) => $["imagesInColor"], { ns: "individual" }) })
+			] }),
+			data?.idDocumentType && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(DocumentGuidance, {
+				type: data?.idDocumentType,
+				className: "u-margin-y-16"
+			}), /* @__PURE__ */ jsx(Dropzone, {
+				name: "idFrontPage",
+				label: t(($) => $["frontPage"], { ns: "individual" }),
+				defaultData: data,
+				id,
+				isOptional,
+				shouldValidate: true,
+				handleFieldChange,
+				errors,
+				valid
+			})] }),
+			data?.idDocumentType && hasBack && /* @__PURE__ */ jsx("div", {
+				className: "u-margin-top-16",
+				children: /* @__PURE__ */ jsx(Dropzone, {
+					name: "idBackPage",
+					label: t(($) => $["backPage"], { ns: "individual" }),
+					defaultData: data,
+					id,
+					isOptional,
+					shouldValidate: true,
+					handleFieldChange,
+					errors,
+					valid
+				})
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/Individual/tasks/IndividualDropin/IndividualStore.tsx
+/**
+* A global signal to control the disabled state of the 'Next' button in the `FormFlow`.
+* This is imported and updated by child components (e.g., `IdVerificationMethod`)
+* to disable navigation from the parent, avoiding the need for prop drilling callbacks.
+*/
+var isNextStepDisabled = signal(false);
+//#endregion
+//#region src/components/Individual/forms/IdVerification/IdVerification.tsx
+var containerId = "adyen-kyc-id-verification";
+var getOnfidoLocaleConfig = (locale, t) => {
+	const language = locale.substring(0, 2);
+	/**
+	* We need to do this right now because if we provide language overrides via
+	* {@link LocaleConfig.phrases} then {@link LocaleConfig.locale} is ignored. Therefore
+	* we can't currently override language within Onfido's SDK for other locales.
+	*
+	* TODO simplify once Onfido has fixed their SDK to respect the value of `locale`.
+	*/
+	return language === "en" ? {
+		locale: language,
+		phrases: {
+			"country_select.button_primary": t(($) => $["continue"]),
+			"doc_submit.title_id_back": t(($) => $["identityCardBack"]),
+			"doc_submit.title_id_front": t(($) => $["identityCardFront"]),
+			"doc_submit.title_license_back": t(($) => $["drivinglicenseBack"]),
+			"doc_submit.title_license_front": t(($) => $["drivinglicenseFront"]),
+			"doc_submit.title_passport": t(($) => $["passportPhotoPage"]),
+			"doc_submit.title_permit_back": t(($) => $["residencePermitBack"]),
+			"doc_submit.title_permit_front": t(($) => $["residencePermitFront"])
+		}
+	} : language;
+};
+var initOnfido = async ({ containerEl, token, t, locale, onIdVerificationComplete, onIdVerificationError, showMotionCapture }) => {
+	const steps = [{
+		type: "document",
+		options: { documentTypes: {
+			passport: true,
+			driving_licence: true,
+			national_identity_card: true,
+			residence_permit: false
+		} }
+	}, showMotionCapture ? {
+		type: "face",
+		options: { requestedVariant: "motion" }
+	} : void 0].filter(Boolean);
+	return Onfido.init({
+		token,
+		containerEl,
+		disableAnalytics: false,
+		onComplete: onIdVerificationComplete,
+		onError: onIdVerificationError,
+		steps,
+		language: getOnfidoLocaleConfig(locale, t)
+	});
+};
+var logger$3 = createLogger();
+function IdVerification({ minimumApplicantDetails, legalEntityId, onIdVerificationError, onIdVerificationComplete }) {
+	const containerRef = useRef$1(null);
+	const { t, i18n } = useTranslation("individual");
+	const { data: tokenResponse, isLoading, isError } = useIdVerificationToken(minimumApplicantDetails, legalEntityId);
+	const onfidoSdk = useRef$1();
+	useEffect$1(() => {
+		(async () => {
+			if (!tokenResponse) return;
+			const { sdkToken, id: providerId } = tokenResponse;
+			if (!containerRef.current) throw new Error("No container for Onfido found");
+			idVerificationProviderId.value = providerId;
+			onfidoSdk.current = await initOnfido({
+				containerEl: containerRef.current,
+				token: sdkToken,
+				t,
+				locale: i18n.language,
+				onIdVerificationError,
+				onIdVerificationComplete,
+				showMotionCapture: showIndividualMotionCapture.value
+			});
+		})().catch(logger$3.error);
+		return async () => {
+			if (onfidoSdk.current) await onfidoSdk.current.tearDown();
+		};
+	}, [tokenResponse, i18n]);
+	return /* @__PURE__ */ jsx(LoaderWrapper, {
+		status: tokenResponse ? "success" : isLoading ? "loading" : isError ? "error" : "pending",
+		children: /* @__PURE__ */ jsx("div", {
+			ref: containerRef,
+			className: containerId
+		})
+	});
+}
+//#endregion
+//#region src/components/Individual/forms/IdVerificationMethod/OnfidoVerificationModal/OnfidoVerificationModal.tsx
+var OnfidoVerificationModal = ({ closeModal, minimumApplicantDetails, legalEntityId, onError, onComplete }) => {
+	const { t } = useTranslation("individual");
+	return /* @__PURE__ */ jsx(Modal, {
+		size: "medium",
+		onClose: closeModal,
+		ariaLabel: t(($) => $["identityVerification"]),
+		children: minimumApplicantDetails && /* @__PURE__ */ jsx(IdVerification, {
+			minimumApplicantDetails,
+			legalEntityId,
+			onIdVerificationComplete: onComplete,
+			onIdVerificationError: onError
+		})
+	});
+};
+//#endregion
+//#region src/components/Individual/forms/IdVerificationMethod/IdVerificationMethod.tsx
+var logger$2 = createLogger();
+var passportFrontGreenImage = lazy(() => import("./passport-front-green-BWuD3-Fs.js"));
+var idVerificationMethodFields = ["idVerificationMethod", "idDocument"];
+function IdVerificationMethod(props) {
+	const { legalEntityId, taskType, handlers, formVerificationErrors, fieldValidationErrors, hasLiveSelfieErrorCode, isInvitedEntity } = props;
+	const { t: individualT, i18n } = useTranslation("individual");
+	const { t: commonT } = useTranslation("common");
+	const userEvents = useAnalyticsContext();
+	const { isFeatureEnabled } = useToggleContext();
+	const extractDocumentInformation = useExtractDocumentInformation();
+	const { form: { data, handleChangeFor, setFormData, setValid, valid } } = useFormContext();
+	const datasetUtils = datasetUtilities(i18n.language);
+	const existingDocument = data.idVerificationMethod?.idDocument;
+	const hasExistingDocument = !isEmpty$1(existingDocument);
+	const handleFieldChange = useCallback$1((fieldName, mode = "input") => handleChangeFor("idVerificationMethod", fieldName, mode), [handleChangeFor]);
+	useDataset(datasetIdentifier.country);
+	const [status, setStatus] = useState$1("ready");
+	const [error, setError] = useState$1();
+	const [showLoadingSpinner, setShowLoadingSpinner] = useState$1(false);
+	const clearError = () => setError(void 0);
+	const [ocrExtractedData, setOcrExtractedData] = useState$1(void 0);
+	const allowedCountries = useAllowedCountries();
+	const { isSettingEnabled } = useSettingsContext();
+	const canEditPrefilledCountry = isSettingEnabled(SettingNames.AllowPrefilledCountryEdit);
+	const restrictCountryOfResidenceTo = useMemo$1(() => {
+		if (isDecisionMakerTask(taskType)) return;
+		if (!canEditPrefilledCountry) return [data.additionalPersonalDetails.country];
+		return allowedCountries;
+	}, [
+		allowedCountries,
+		canEditPrefilledCountry,
+		data.additionalPersonalDetails,
+		taskType
+	]);
+	const extractedData = useMemo$1(() => ocrExtractedData ? mapExtractionResultToSchema(ocrExtractedData, restrictCountryOfResidenceTo) : void 0, [ocrExtractedData, restrictCountryOfResidenceTo]);
+	const comparableExistingData = useMemo$1(() => toIndividualConflictSchema(data), [data]);
+	const comparableExtractedData = useMemo$1(() => extractedData ? toIndividualConflictSchema(extractedData) : void 0, [extractedData]);
+	const conflictRules = useMemo$1(() => ({ address: createAddressConflictRule(datasetUtils) }), [datasetUtils]);
+	const onAutoResolve = (resolvedData) => {
+		const resolvedSchema = fromIndividualConflictSchema(resolvedData);
+		setFormData("basicDetails", {
+			...data.basicDetails,
+			...resolvedSchema.basicDetails
+		});
+		setFormData("additionalPersonalDetails", resolvedSchema.additionalPersonalDetails);
+		setOcrExtractedData(void 0);
+		handlers.handleContinueToAdditionalDetails();
+	};
+	const { hasConflicts, conflictingProperties, resolvedData } = useDataConflicts(comparableExistingData, comparableExtractedData, conflictRules, onAutoResolve);
+	const minimumApplicantDetails = {
+		firstName: data.basicDetails?.firstName,
+		lastName: data.basicDetails?.lastName,
+		residencyCountry: data.additionalPersonalDetails?.country
+	};
+	const { registerFieldAction, unregisterFieldAction } = useFormRouterContext();
+	const launchOnfido = useCallback$1(() => {
+		clearError();
+		userEvents.addPageEvent("Clicked button", {
+			actionType: "add",
+			label: "instantVerification",
+			returnValue: "launchingOnfido"
+		});
+		setStatus("onfidoModal");
+		handleFieldChange("idVerificationMethod")("instantVerification");
+	}, [userEvents, handleFieldChange]);
+	useEffect$1(() => {
+		if (hasLiveSelfieErrorCode) {
+			registerFieldAction("idDocument", launchOnfido);
+			return () => unregisterFieldAction("idDocument");
+		}
+	}, [
+		registerFieldAction,
+		unregisterFieldAction,
+		launchOnfido,
+		hasLiveSelfieErrorCode
+	]);
+	const handleOnfidoComplete = async (onfidoResult) => {
+		clearError();
+		setShowLoadingSpinner(true);
+		setStatus("extractionLoading");
+		const documentIds = [onfidoResult.document_front.id];
+		if (onfidoResult.document_back) documentIds.push(onfidoResult.document_back.id);
+		try {
+			const extractionResult = await extractDocumentInformation.mutateAsync({ documents: documentIds.map((documentId) => ({ documentId })) });
+			const validationError = validateExtractionResult(extractionResult);
+			if (validationError) {
+				setError(validationError);
+				setStatus("ready");
+				return;
+			}
+			setOcrExtractedData(extractionResult);
+			handleFieldChange("idDocument")({
+				instantIdVerificationData: onfidoResult,
+				idDocumentType: onfidoResult.document_front.type,
+				modificationDate: (/* @__PURE__ */ new Date()).toISOString(),
+				documentCountry: extractionResult.issuingCountry
+			});
+			setStatus("ready");
+		} catch (err) {
+			handleOnfidoExtractionError(err);
+			handleFieldChange("idDocument")({
+				instantIdVerificationData: onfidoResult,
+				idDocumentType: onfidoResult.document_front.type,
+				modificationDate: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		} finally {
+			setShowLoadingSpinner(false);
+		}
+	};
+	const handleOnfidoExtractionError = (error) => {
+		logger$2.error("Onfido extraction error", error);
+		userEvents.addPageEvent("Encountered error", {
+			actionType: "submit",
+			returnType: "onfido",
+			returnValue: "weCouldNotExtractDocumentInformation"
+		});
+		setStatus("ready");
+	};
+	const handleOnfidoError = (error) => {
+		logger$2.error("Onfido error", error);
+		setError({ key: "weCouldNotReachOnfido" });
+		userEvents.addPageEvent("Encountered error", {
+			actionType: "submit",
+			returnType: "onfido",
+			returnValue: "weCouldNotReachOnfido"
+		});
+		setStatus("ready");
+	};
+	const handleDataConflictsResolved = (resolved) => {
+		const resolvedSchema = fromIndividualConflictSchema(resolved);
+		setFormData("basicDetails", {
+			...data.basicDetails,
+			...resolvedSchema.basicDetails
+		});
+		setFormData("additionalPersonalDetails", resolvedSchema.additionalPersonalDetails);
+		setOcrExtractedData(void 0);
+		setStatus("ready");
+		userEvents.addPageEvent("Success", {
+			actionType: "submit",
+			returnType: "ocrExtraction",
+			returnValue: "resolvedConflictsAfterOcrExtraction"
+		});
+		handlers.handleContinueToAdditionalDetails();
+	};
+	const handleContinueViaManualEntryFlow = () => {
+		handleFieldChange("idVerificationMethod")("manualVerification");
+		userEvents.addPageEvent("Clicked button", {
+			actionType: "submit",
+			label: "addDetailsManually"
+		});
+		handlers.handleContinueToAdditionalDetails();
+	};
+	const handleVerifyByInvite = () => {
+		handleFieldChange("idVerificationMethod")("verifyByInvite");
+		userEvents.addPageEvent("Clicked button", {
+			actionType: "add",
+			label: "verifyByInvite"
+		});
+		handlers.handleContinueToInviteDetails?.();
+	};
+	const handleDeleteDocument = () => {
+		setStatus("ready");
+		if (hasExistingDocument) {
+			handlers.handleDeleteDocument();
+			userEvents.addPageEvent("Clicked button", {
+				actionType: "remove",
+				label: "deleteDocument"
+			});
+			handleFieldChange("idDocument")(void 0);
+			handleFieldChange("idVerificationMethod")(void 0);
+		}
+	};
+	if (hasLiveSelfieErrorCode && (data.idVerificationMethod?.idVerificationMethod !== "instantVerification" || !data.idVerificationMethod?.idDocument?.instantIdVerificationData) && valid.idVerificationMethod?.idVerificationMethod) setValid("idVerificationMethod", "idVerificationMethod", false);
+	const doesUserHaveExistingDocument = hasLiveSelfieErrorCode && (data.idVerificationMethod?.idVerificationMethod !== "instantVerification" || !data.idVerificationMethod?.idDocument?.instantIdVerificationData) ? false : hasExistingDocument;
+	const handleCancelDeleteDocument = () => {
+		setStatus("ready");
+		userEvents.addPageEvent("Clicked button", {
+			actionType: "cancel",
+			label: "cancelDeleteDocument"
+		});
+	};
+	const handleCancelAddDetailsManually = () => {
+		setStatus("ready");
+		userEvents.addPageEvent("Clicked button", {
+			actionType: "cancel",
+			label: "cancelAddDetailsManually"
+		});
+	};
+	const handleUpdateExistingDocument = () => {
+		userEvents.addPageEvent("Clicked button", {
+			actionType: "change",
+			label: "updateExistingDocument"
+		});
+		launchOnfido();
+		handlers.handleUpdateDocument();
+	};
+	const modalProvidedData = resolvedData || comparableExistingData;
+	const formUtils = createFormUtils(props, commonT);
+	const showInviteOption = isFeatureEnabled("EnableVerifyByInvite") && isDecisionMakerTask(taskType) && !isInvitedEntity;
+	const verifyIdentityDescription = showInviteOption ? individualT(($) => $["weNeedToVerifyTheDecisionMakersIdentity"]) : showIndividualMotionCapture?.value ? individualT(($) => $["toHelpProtectAgainstFraudAndKeepOurServices"]) : /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		commonT(($) => $["takeOrUploadAPhoto"]),
+		" ",
+		/* @__PURE__ */ jsx(Link, {
+			href: "https://onfido.com",
+			external: true,
+			inline: true,
+			children: commonT(($) => $["onfido"])
+		})
+	] });
+	isNextStepDisabled.value = showLoadingSpinner;
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(ErrorPanel, {
+			verificationErrors: formVerificationErrors,
+			validationErrors: fieldValidationErrors,
+			formUtils,
+			id: "ariaErrorField"
+		}),
+		/* @__PURE__ */ jsx(LandingLayout, {
+			media: /* @__PURE__ */ jsx(Image, {
+				className: IdVerificationMethod_module_default.verificationHeaderImage,
+				lazyLoadedImage: passportFrontGreenImage
+			}),
+			title: individualT(($) => $["verifyIdentity"]),
+			description: verifyIdentityDescription,
+			error: error ? /* @__PURE__ */ jsx(Alert, {
+				variant: "error",
+				title: commonT(($) => $[error.key], { ...error.options?.values })
+			}) : void 0,
+			actions: /* @__PURE__ */ jsx(Fragment$1, { children: showLoadingSpinner ? /* @__PURE__ */ jsx(Loader, { size: "large" }) : !doesUserHaveExistingDocument && /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				/* @__PURE__ */ jsx(Button, {
+					fullWidth: true,
+					onClick: launchOnfido,
+					disabled: status === "extractionLoading",
+					loading: status === "extractionLoading",
+					children: individualT(($) => $["getVerifiedInstantly"])
+				}),
+				!showIndividualMotionCapture?.value && /* @__PURE__ */ jsx(Button, {
+					onClick: () => setStatus("confirmManualFlowModal"),
+					variant: "secondary",
+					fullWidth: true,
+					children: commonT(($) => $["addDetailsManually"])
+				}),
+				showInviteOption && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("span", {
+					className: IdVerificationMethod_module_default.orSeparator,
+					children: individualT(($) => $["or"])
+				}), /* @__PURE__ */ jsx(Button, {
+					onClick: handleVerifyByInvite,
+					variant: "secondary",
+					fullWidth: true,
+					children: individualT(($) => $["inviteDecisionMaker"])
+				})] })
+			] }) }),
+			content: !showLoadingSpinner && doesUserHaveExistingDocument && /* @__PURE__ */ jsx(UploadedDocument, {
+				document: existingDocument,
+				onDelete: () => setStatus("confirmDeleteDocumentModal"),
+				onUpdate: handleUpdateExistingDocument
+			}),
+			disclaimer: !doesUserHaveExistingDocument && /* @__PURE__ */ jsx(Trans, {
+				t: individualT,
+				ns: "individual",
+				i18nKey: ($) => $["byContinuingWithInstantVerification"],
+				components: {
+					facialScanLink: /* @__PURE__ */ jsx(Link, {
+						href: "https://onfido.com/facial-scan-policy-and-release/",
+						external: true,
+						inline: true
+					}),
+					privacyLink: /* @__PURE__ */ jsx(Link, {
+						href: "https://onfido.com/privacy/",
+						external: true,
+						inline: true
+					}),
+					termsLink: /* @__PURE__ */ jsx(Link, {
+						href: "https://onfido.com/terms-of-service/",
+						external: true,
+						inline: true
+					})
+				}
+			})
+		}),
+		status === "onfidoModal" && /* @__PURE__ */ jsx(OnfidoVerificationModal, {
+			closeModal: () => setStatus("ready"),
+			onError: handleOnfidoError,
+			onComplete: handleOnfidoComplete,
+			minimumApplicantDetails,
+			legalEntityId
+		}),
+		status === "confirmManualFlowModal" && /* @__PURE__ */ jsx(Confirm, {
+			title: individualT(($) => $["addDetailsManuallyQuestion"]),
+			description: individualT(($) => $["itCanTakeUpTo"]),
+			onCancel: handleCancelAddDetailsManually,
+			confirmText: individualT(($) => $["yesAddManually"]),
+			onConfirm: handleContinueViaManualEntryFlow
+		}),
+		status === "confirmDeleteDocumentModal" && /* @__PURE__ */ jsx(Confirm, {
+			title: individualT(($) => $["deleteIdDocument"]),
+			description: individualT(($) => $["youMayBeAskedToReUpload"]),
+			confirmText: commonT(($) => $["deleteDocument"]),
+			onCancel: handleCancelDeleteDocument,
+			onConfirm: handleDeleteDocument,
+			critical: true
+		}),
+		hasConflicts && comparableExtractedData ? /* @__PURE__ */ jsx(DataConflictsModal, {
+			providedData: modalProvidedData,
+			detectedData: comparableExtractedData,
+			conflictingProperties,
+			formatters: { address: (val) => addressToString(val, datasetUtils) },
+			title: individualT(($) => $["confirmPersonalDetails"]),
+			explanation: individualT(($) => $["theDetailsYouEnteredDontMatch"]),
+			cancelConfirmation: {
+				title: individualT(($) => $["leaveInstantVerification"]),
+				confirmText: individualT(($) => $["leaveVerification"]),
+				description: individualT(($) => $["anyInformationFromTheUploadedDocumentWillBeLost"])
+			},
+			onContinue: handleDataConflictsResolved,
+			onCancel: () => {
+				handleFieldChange("idDocument")(void 0);
+				setOcrExtractedData(void 0);
+				handleFieldChange("idVerificationMethod")(void 0);
+			}
+		}) : void 0
+	] });
+}
+//#endregion
+//#region src/components/Individual/forms/InviteDetails/utils.ts
+var isPhoneNumberMobile = (phoneNumber) => {
+	const phoneCountryCode = phoneNumber?.phoneCountryCode ? phoneNumber?.phoneCountryCode : void 0;
+	const parsedPhoneNumber = parsePhoneNumber(phoneNumber.number, phoneCountryCode);
+	return Boolean(parsedPhoneNumber && (parsedPhoneNumber.getType() === "MOBILE" || parsedPhoneNumber.getType() === "FIXED_LINE_OR_MOBILE"));
+};
+var inviteDetailsFields = [
+	"senderName",
+	"message",
+	"email",
+	"phoneNumber"
+];
+function InviteDetails(props) {
+	const { t } = useTranslation("individual");
+	const { t: commonT } = useTranslation("common");
+	const { form: { data: formData, handleChangeFor: handleBasicDetailsChangeFor } } = useFormContext();
+	const { country, data, errors = {}, fieldValidationErrors, handleFieldChange, heading, recipientFirstName, valid = {} } = props;
+	const phoneMetadata = resolveFieldMetadata(fieldConfig[data?.phoneNumber?.phoneCountryCode ?? country], {}, defaultFieldMetadata);
+	const formUtils = createFormUtils(mergeFieldMetadataIntoProps("phoneNumber", {
+		label: phoneMetadata.label,
+		mask: phoneMetadata.mask
+	}, props), commonT);
+	const basicDetails = formData.basicDetails ?? {};
+	const handleEmailChange = useCallback$1((mode) => (e) => {
+		handleFieldChange?.("email", mode)(e);
+		handleBasicDetailsChangeFor("basicDetails", "email", mode)(e);
+	}, [handleFieldChange, handleBasicDetailsChangeFor]);
+	const handlePhoneChange = useCallback$1((key, mode) => (e) => {
+		handleFieldChange?.(key, mode)(e);
+		handleBasicDetailsChangeFor("basicDetails", key, mode)(e);
+	}, [handleFieldChange, handleBasicDetailsChangeFor]);
+	useEffect$1(() => {
+		if (!handleFieldChange) return;
+		handleFieldChange("email", "input")(data?.email);
+		if (!data?.phoneNumber || !isPhoneNumberMobile(data.phoneNumber)) {
+			handleFieldChange("phoneNumber", "input")({
+				number: "",
+				phoneCountryCode: country,
+				type: "mobile"
+			});
+			handleBasicDetailsChangeFor("basicDetails", "phoneNumber", "input")({
+				number: "",
+				phoneCountryCode: country,
+				type: "mobile"
+			});
+		} else handleFieldChange("phoneNumber", "input")(data?.phoneNumber);
+	}, []);
+	const emailValue = data?.email ?? basicDetails.email ?? "";
+	const phoneValue = data?.phoneNumber ?? basicDetails?.phoneNumber;
+	if (!handleFieldChange) return null;
+	return /* @__PURE__ */ jsxs("form", { children: [
+		/* @__PURE__ */ jsx(Header, {
+			title: heading ?? t(($) => $["inviteDetails"]),
+			description: t(($) => $["checkThatContactInfoIsCorrect"], { name: recipientFirstName })
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			name: "email",
+			label: commonT(($) => $["email"]),
+			errorMessage: formUtils.getErrorMessage("email", errors, fieldValidationErrors),
+			helper: t(($) => $.wellSendTheInvitationToThisAddress),
+			helperPosition: "below",
+			isValid: valid.email,
+			children: (childProps) => /* @__PURE__ */ jsx(InputEmail, {
+				...childProps,
+				name: "email",
+				value: emailValue,
+				onInput: handleEmailChange("input"),
+				onBlur: handleEmailChange("blur"),
+				"aria-required": true,
+				"aria-invalid": valid.email === false
+			})
+		}),
+		/* @__PURE__ */ jsx(PhoneField, {
+			country,
+			data: { phoneNumber: phoneValue },
+			valid: { phoneNumber: valid.phoneNumber ?? true },
+			errors: { phoneNumber: formatValidationError(errors.phoneNumber?.errorMessage, commonT) },
+			label: t(($) => $["mobileNumber"]),
+			placeholder: getPhonePlaceholder(country),
+			optional: false,
+			readonly: false,
+			handleChangeFor: handlePhoneChange,
+			mask: formUtils.getMask("phoneNumber"),
+			helper: t(($) => $["wellUseThisNumberToSendAOneTimeVerificationCode"]),
+			helperPosition: "below"
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			name: "senderName",
+			label: t(($) => $["sender"]),
+			errorMessage: formUtils.getErrorMessage("senderName", errors, fieldValidationErrors),
+			isValid: valid.senderName,
+			children: (childProps) => /* @__PURE__ */ jsx(InputText, {
+				...childProps,
+				name: "senderName",
+				value: data?.senderName,
+				placeholder: t(($) => $["name"]),
+				maxLength: 30,
+				onInput: handleFieldChange("senderName", "input"),
+				onBlur: handleFieldChange("senderName", "blur"),
+				"aria-required": true,
+				"aria-invalid": !valid.senderName
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			name: "message",
+			errorMessage: formUtils.getErrorMessage("message", errors, fieldValidationErrors),
+			isValid: valid.message,
+			helper: t(($) => $["thisMessageAppearsInTheEmail"]),
+			helperPosition: "below",
+			children: (childProps) => /* @__PURE__ */ jsx(TextArea, {
+				...childProps,
+				name: "message",
+				value: data?.message,
+				placeholder: t(($) => $["message"]),
+				maxLength: 200,
+				onInput: handleFieldChange("message", "input"),
+				onBlur: handleFieldChange("message", "blur"),
+				"aria-required": true,
+				"aria-invalid": !valid.message
+			})
+		})
+	] });
+}
+//#endregion
+//#region src/components/Individual/forms/ManualIdUpload/ManualIdUpload.tsx
+var ManualIdUpload = () => {
+	const { form } = useFormContext();
+	const { handleChangeFor } = form;
+	const data = form.data.manualIdUpload;
+	const valid = form.valid.manualIdUpload;
+	const errors = form.errors.manualIdUpload;
+	const name = `${form.data.basicDetails?.firstName} ${form.data.basicDetails?.lastName}`;
+	const country = form.data.additionalPersonalDetails?.country;
+	const handleFieldChange = (fieldName, mode) => handleChangeFor("manualIdUpload", fieldName, mode);
+	return /* @__PURE__ */ jsx(IdDocumentManualUpload, {
+		data,
+		valid,
+		errors,
+		name,
+		handleFieldChange,
+		country
+	});
+};
+//#endregion
+//#region src/components/Individual/forms/ProofOfRelationship/types.ts
+var ProofOfRelationshipDocumentTypes = {
+	BIRTH_CERTIFICATE: "birthCertificate",
+	GUARDIANSHIP_CERTIFICATE: "guardianshipCertificate",
+	ADOPTION_CERTIFICATE: "adoptionCertificate"
+};
+var proofOfRelationshipDocumentOptions = [
+	{
+		id: ProofOfRelationshipDocumentTypes.BIRTH_CERTIFICATE,
+		name: "birthCertificate"
+	},
+	{
+		id: ProofOfRelationshipDocumentTypes.GUARDIANSHIP_CERTIFICATE,
+		name: "guardianshipCertificate"
+	},
+	{
+		id: ProofOfRelationshipDocumentTypes.ADOPTION_CERTIFICATE,
+		name: "adoptionCertificate"
+	}
+];
+//#endregion
+//#region src/components/Individual/forms/ProofOfRelationship/index.tsx
+function ProofOfRelationship({ id, ...props }) {
+	const { t } = useTranslation(["individual", "common"]);
+	const [proofOfRelationshipDocumentType, setProofOfRelationshipDocumentType] = useState$1(proofOfRelationshipDocumentOptions[0].id);
+	const proofOfResidencyGuidanceContent = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs("div", {
+		className: "adyen-kyc-upload-field__subtitle",
+		children: [" ", t(($) => $["requirements"], { ns: "common" })]
+	}), /* @__PURE__ */ jsxs("ul", { children: [
+		/* @__PURE__ */ jsx("li", { children: t(($) => $["documentAddressedToName"], { name: props.name }) }),
+		/* @__PURE__ */ jsx("li", { children: t(($) => $["showAddressStateCountry"]) }),
+		/* @__PURE__ */ jsx("li", { children: t(($) => $["fullDocumentVisibleWithReadableText"]) }),
+		/* @__PURE__ */ jsx("li", { children: t(($) => $["documentCannotBeDamaged"]) })
+	] })] });
+	return /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(MemoizedDocumentUpload, {
+		...props,
+		documentField: "proofOfRelationship",
+		documentType: "proofOfRelationship",
+		heading: t(($) => $["proofOfRelationship"], { ns: "common" }),
+		guidanceHeader: /* @__PURE__ */ jsx("div", {
+			className: "u-margin-bottom-16",
+			children: t(($) => $["proofOfResidenceDocumentTypeLabel"], { name: props.name })
+		}),
+		documentTypeSelect: {
+			selectedType: proofOfRelationshipDocumentType,
+			setSelectedType: setProofOfRelationshipDocumentType,
+			options: proofOfRelationshipDocumentOptions
+		},
+		guidanceContent: proofOfResidencyGuidanceContent,
+		id
+	}) });
+}
+var MemoizedProofOfRelationship = memo(ProofOfRelationship, (prevProps, nextProps) => objectsDeepEqual(prevProps.data, nextProps.data) && objectsDeepEqual(prevProps.formVerificationErrors, nextProps.formVerificationErrors) && objectsDeepEqual(prevProps.fieldValidationErrors, nextProps.fieldValidationErrors) && objectsDeepEqual(prevProps.requiredFields, nextProps.requiredFields) && prevProps.shouldValidate === nextProps.shouldValidate && prevProps.name === nextProps.name);
+//#endregion
+//#region src/components/Individual/forms/ProofOfResidency/types.ts
+var ProofOfResidenceDocumentTypes = {
+	BANK_STATEMENT: "bankStatement",
+	UTILITY_BILL: "utilityBill",
+	GOVERNMENT_ISSUED_CORRESPONDENCE: "governmentIssuedCorrespondence",
+	TAXATION_DOCUMENT: "taxationDocument",
+	EXTRACT_FROM_MUNICIPAL_PERSONAL_RECORDS_DATABASE: "extractFromMunicipalPersonalRecordsDatabase",
+	SALARY_SLIP: "salarySlip",
+	MORTGAGE_STATEMENT: "mortgageStatement",
+	CERTIFICATE_OF_VOTER_REGISTRATION: "certificateOfVoterRegistration"
+};
+var proofOfResidenceDocumentOptions = [
+	{
+		id: ProofOfResidenceDocumentTypes.BANK_STATEMENT,
+		name: "bankStatementDocument"
+	},
+	{
+		id: ProofOfResidenceDocumentTypes.UTILITY_BILL,
+		name: "utilityBill"
+	},
+	{
+		id: ProofOfResidenceDocumentTypes.GOVERNMENT_ISSUED_CORRESPONDENCE,
+		name: "governmentIssuedCorrespondence"
+	},
+	{
+		id: ProofOfResidenceDocumentTypes.TAXATION_DOCUMENT,
+		name: "taxationDocument"
+	},
+	{
+		id: ProofOfResidenceDocumentTypes.EXTRACT_FROM_MUNICIPAL_PERSONAL_RECORDS_DATABASE,
+		name: "extractFromMunicipalPersonalRecordsDatabase"
+	},
+	{
+		id: ProofOfResidenceDocumentTypes.SALARY_SLIP,
+		name: "salarySlip"
+	},
+	{
+		id: ProofOfResidenceDocumentTypes.MORTGAGE_STATEMENT,
+		name: "mortgageStatement"
+	},
+	{
+		id: ProofOfResidenceDocumentTypes.CERTIFICATE_OF_VOTER_REGISTRATION,
+		name: "certificateOfVoterRegistration"
+	}
+];
+//#endregion
+//#region src/components/Individual/forms/ProofOfResidency/ProofOfResidency.tsx
+function ProofOfResidency({ id, ...props }) {
+	const { t } = useTranslation(["individual", "common"]);
+	const [proofOfResidenceDocumentType, setProofOfResidenceDocumentType] = useState$1(proofOfResidenceDocumentOptions[0].id);
+	const isMortgageOrVoterRegistration = proofOfResidenceDocumentType === ProofOfResidenceDocumentTypes.MORTGAGE_STATEMENT || proofOfResidenceDocumentType === ProofOfResidenceDocumentTypes.CERTIFICATE_OF_VOTER_REGISTRATION;
+	const proofOfResidencyGuidanceContent = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs("div", {
+		className: "adyen-kyc-upload-field__subtitle",
+		children: [" ", t(($) => $["requirements"], { ns: "common" })]
+	}), /* @__PURE__ */ jsxs("ul", { children: [
+		/* @__PURE__ */ jsx("li", { children: t(($) => $["documentAddressedToName"], { name: props.name }) }),
+		/* @__PURE__ */ jsx("li", { children: t(($) => $["showAddressStateCountry"]) }),
+		/* @__PURE__ */ jsx("li", { children: isMortgageOrVoterRegistration ? t(($) => $["dateOnDocumentNoOlderThanXMonths"], { numberOfMonths: 12 }) : t(($) => $["dateOnDocumentNoOlderThanXMonths"], { numberOfMonths: 3 }) }),
+		/* @__PURE__ */ jsx("li", { children: t(($) => $["fullDocumentVisibleWithReadableText"]) }),
+		/* @__PURE__ */ jsx("li", { children: t(($) => $["documentCannotBeDamaged"]) })
+	] })] });
+	return /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(MemoizedDocumentUpload, {
+		...props,
+		documentField: "proofOfResidency",
+		documentType: "proofOfResidency",
+		heading: t(($) => $["proofOfResidency"], { ns: "common" }),
+		guidanceHeader: /* @__PURE__ */ jsx("div", {
+			className: "u-margin-bottom-16",
+			children: t(($) => $["proofOfResidenceDocumentTypeLabel"], { name: props.name })
+		}),
+		documentTypeSelect: {
+			selectedType: proofOfResidenceDocumentType,
+			setSelectedType: setProofOfResidenceDocumentType,
+			options: proofOfResidenceDocumentOptions
+		},
+		guidanceContent: proofOfResidencyGuidanceContent,
+		id
+	}) });
+}
+var MemoizedProofOfResidencyUpload = memo(ProofOfResidency, (prevProps, nextProps) => objectsDeepEqual(prevProps.data, nextProps.data) && objectsDeepEqual(prevProps.formVerificationErrors, nextProps.formVerificationErrors) && objectsDeepEqual(prevProps.fieldValidationErrors, nextProps.fieldValidationErrors) && objectsDeepEqual(prevProps.requiredFields, nextProps.requiredFields) && prevProps.shouldValidate === nextProps.shouldValidate && prevProps.name === nextProps.name);
+//#endregion
+//#region src/components/Individual/forms/SignatoryQuestionnaire/SignatoryQuestionnaireModalContent.tsx
+var SignatoryQuestionnaireModalContent = () => {
+	const { t } = useTranslation("individual");
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(Typography, {
+			variant: "title-l",
+			el: "h3",
+			className: "u-margin-bottom-40",
+			children: t(($) => $["moreAboutAuthorizedSignatories"])
+		}),
+		/* @__PURE__ */ jsx(Typography, {
+			variant: "body-strongest",
+			el: "h4",
+			className: "u-margin-bottom-12",
+			children: t(($) => $["signatoryDescriptionQ1"])
+		}),
+		/* @__PURE__ */ jsx(Typography, {
+			el: "p",
+			className: "u-margin-bottom-32",
+			children: t(($) => $["signatoryDescriptionA1"])
+		}),
+		/* @__PURE__ */ jsx(Typography, {
+			variant: "body-strongest",
+			el: "h4",
+			className: "u-margin-bottom-12",
+			children: t(($) => $["signatoryDescriptionQ2"])
+		}),
+		/* @__PURE__ */ jsx(Typography, {
+			el: "p",
+			children: t(($) => $["signatoryDescriptionA2"])
+		})
+	] });
+};
+//#endregion
+//#region src/components/Individual/forms/SignatoryQuestionnaire/SignatoryQuestionnaire.tsx
+function SignatoryQuestionnaire(props) {
+	const { t } = useTranslation(["common", "individual"]);
+	const handleModalAction = useModalAction();
+	const [isModalOpen, setIsModalOpen] = useState$1(false);
+	const { data, errors, formVerificationErrors, heading, fieldValidationErrors, handleFieldChange } = props;
+	const formUtils = createFormUtils(props, t);
+	if (!handleFieldChange) return;
+	const openModal = () => handleModalAction("isSignatoryModal", "open", setIsModalOpen);
+	const closeModal = () => handleModalAction("isSignatoryModal", "close", setIsModalOpen);
+	const errorMessage = formUtils.getErrorMessage("isSignatory", errors, fieldValidationErrors);
+	return /* @__PURE__ */ jsxs("form", {
+		"aria-describedby": "ariaErrorField",
+		children: [
+			heading && /* @__PURE__ */ jsx(Header, { title: heading }),
+			/* @__PURE__ */ jsx(ErrorPanel, {
+				verificationErrors: formVerificationErrors,
+				validationErrors: fieldValidationErrors,
+				formUtils,
+				id: "ariaErrorField"
+			}),
+			/* @__PURE__ */ jsx(GuidanceQuestion, {
+				name: "isSignatory",
+				value: data?.isSignatory,
+				onChange: handleFieldChange("isSignatory"),
+				onDescriptionLinkClick: openModal,
+				question: t(($) => $["doesThisPersonHaveTheAuthority"], { ns: "individual" }),
+				descriptionLinkText: t(($) => $["whatDoesThisMean"]),
+				errorMessage
+			}),
+			isModalOpen && /* @__PURE__ */ jsx(Modal, {
+				onClose: closeModal,
+				ariaLabel: t(($) => $["moreAboutAuthorizedSignatories"], { ns: "individual" }),
+				inset: true,
+				children: /* @__PURE__ */ jsx(SignatoryQuestionnaireModalContent, {})
+			})
+		]
+	});
+}
+//#endregion
+//#region src/hooks/useUboQuestionnaire.ts
+var useGuidanceQuestionnaire = ({ data, handleFieldChange, openModal, formUtils, errors, fieldValidationErrors, country }) => {
+	const { t } = useTranslation(["individual"]);
+	const defaultQuestions = useMemo$1(() => ({
+		isDirector: t(($) => {
+			return $["isThisPersonListedAsADirector"];
+		}),
+		isOwner: t(($) => $["doesThisPersonOwn25PercentOrMoreOfBusiness"]),
+		isControllingPerson: t(($) => $["doesThisPersonHaveSignificantResponsibility"]),
+		isNomineeDirector: t(($) => $["isThisPersonANomineeDirectorAppointed"]),
+		isNomineeShareholder: t(($) => $["isThisPersonANomineeShareholderAppointedToHold"])
+	}), [t]);
+	const defaultDescriptionLinkTextByField = useMemo$1(() => ({
+		isDirector: t(($) => $["whatDoesThisMean"]),
+		isNomineeDirector: t(($) => $["whatDoesThisMean"]),
+		isOwner: t(($) => $["whatDoesThisMean"]),
+		isNomineeShareholder: void 0,
+		isControllingPerson: t(($) => $["whatDoesThisMean"])
+	}), [t]);
+	const questionsMap = useMemo$1(() => {
+		return { JP: {
+			isDirector: t(($) => $["isThisPersonARegisteredRepresentativeDirector"]),
+			isOwner: t(($) => $["doesThisPersonOwn25PercentOrMoreOfBusiness"]),
+			isControllingPerson: t(($) => $["doesThisPersonHaveSignificantResponsibility"])
+		} }[country] ?? {};
+	}, [t, country]);
+	return { registerGuidanceQuestion: useCallback$1((fieldName) => {
+		return {
+			name: fieldName,
+			value: data?.[fieldName],
+			onChange: handleFieldChange ? handleFieldChange(fieldName) : () => {},
+			onDescriptionLinkClick: fieldName !== "isNomineeShareholder" ? openModal(fieldName) : void 0,
+			question: questionsMap[fieldName] || defaultQuestions[fieldName],
+			descriptionLinkText: defaultDescriptionLinkTextByField[fieldName],
+			errorMessage: formUtils.getErrorMessage(fieldName, errors, fieldValidationErrors)
+		};
+	}, [
+		data,
+		defaultDescriptionLinkTextByField,
+		defaultQuestions,
+		errors,
+		fieldValidationErrors,
+		formUtils,
+		handleFieldChange,
+		openModal,
+		questionsMap
+	]) };
+};
+var UboQuestionnaireModalContent_module_default = {
+	"questionnaire-modal-content": "_questionnaire-modal-content_8je6c_1",
+	questionnaireModalContent: "_questionnaire-modal-content_8je6c_1",
+	"questionnaire-list": "_questionnaire-list_8je6c_5",
+	questionnaireList: "_questionnaire-list_8je6c_5"
+};
+//#endregion
+//#region src/components/Individual/forms/UboQuestionnaire/UboQuestionnaireModalContent.tsx
+var UboQuestionnaireModalContent = ({ modalType, country }) => {
+	const { t } = useTranslation("individual");
+	switch (modalType) {
+		case "isOwner": return /* @__PURE__ */ jsxs("div", {
+			className: UboQuestionnaireModalContent_module_default.questionnaireModalContent,
+			children: [
+				/* @__PURE__ */ jsx(Typography, {
+					variant: "title-l",
+					el: "h3",
+					className: "u-margin-bottom-40",
+					children: t(($) => $["moreAboutOwners"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					variant: "body-strongest",
+					el: "h4",
+					className: "u-margin-bottom-12",
+					children: t(($) => $["ownersDescriptionQ1"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					el: "p",
+					children: t(($) => $["ownersDescriptionA1P1"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					el: "p",
+					className: "u-margin-bottom-32",
+					children: t(($) => $["ownersDescriptionA1P2"])
+				}),
+				/* @__PURE__ */ jsx(Alert, {
+					title: t(($) => $["ownersDescriptionAlertTitle"]),
+					icon: false,
+					className: "u-margin-bottom-32",
+					children: t(($) => $["ownersDescriptionAlertContent"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					variant: "body-strongest",
+					el: "h4",
+					className: "u-margin-bottom-12",
+					children: t(($) => $["ownersDescriptionQ2"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					el: "p",
+					children: t(($) => $["ownersDescriptionA2P1"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					el: "p",
+					className: "u-margin-bottom-32",
+					children: t(($) => $["ownersDescriptionA2P2"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					variant: "body-strongest",
+					el: "h4",
+					className: "u-margin-bottom-12",
+					children: t(($) => $["ownersDescriptionQ3"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					el: "p",
+					className: "u-margin-bottom-32",
+					children: t(($) => $["ownersDescriptionA3"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					variant: "body-strongest",
+					el: "h4",
+					className: "u-margin-bottom-12",
+					children: t(($) => $["ownersDescriptionQ4"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					el: "p",
+					className: "u-margin-bottom-32",
+					children: t(($) => $["ownersDescriptionA4"])
+				})
+			]
+		});
+		case "isControllingPerson": return /* @__PURE__ */ jsxs("div", {
+			className: UboQuestionnaireModalContent_module_default.questionnaireModalContent,
+			children: [
+				/* @__PURE__ */ jsx(Typography, {
+					variant: "title-l",
+					el: "h3",
+					className: "u-margin-bottom-40",
+					children: t(($) => $["moreAboutOwnershipThroughControl"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					variant: "body-strongest",
+					el: "h4",
+					className: "u-margin-bottom-12",
+					children: t(($) => $["controllingPersonDescriptionQ1"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					el: "p",
+					className: "u-margin-bottom-16",
+					children: t(($) => $["controllingPersonDescriptionA1P1"])
+				}),
+				/* @__PURE__ */ jsxs("ul", {
+					className: UboQuestionnaireModalContent_module_default.questionnaireList,
+					children: [
+						/* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(Trans, {
+							t,
+							i18nKey: ($) => $["controllingPersonDescriptionA1L1"]
+						}) }),
+						/* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(Trans, {
+							t,
+							i18nKey: ($) => $["controllingPersonDescriptionA1L2"]
+						}) }),
+						/* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(Trans, {
+							t,
+							i18nKey: ($) => $["controllingPersonDescriptionA1L3"]
+						}) }),
+						/* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(Trans, {
+							t,
+							i18nKey: ($) => $["controllingPersonDescriptionA1L4"]
+						}) })
+					]
+				}),
+				/* @__PURE__ */ jsx(Alert, {
+					title: t(($) => $["ownersDescriptionAlertTitle"]),
+					icon: false,
+					className: "u-margin-bottom-32",
+					children: t(($) => $["controllingPersonDescriptionAlertContent"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					variant: "body-strongest",
+					el: "h4",
+					className: "u-margin-bottom-12",
+					children: t(($) => $["ownersDescriptionQ4"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					el: "p",
+					children: t(($) => $["ownersDescriptionA4"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					variant: "body-strongest",
+					el: "h4",
+					className: "u-margin-bottom-12",
+					children: t(($) => $["controllingPersonDescriptionQ2"])
+				}),
+				/* @__PURE__ */ jsx(Typography, {
+					el: "p",
+					className: "u-margin-bottom-32",
+					children: t(($) => $["controllingPersonDescriptionA2"])
+				})
+			]
+		});
+		case "isDirector":
+			if (country === "JP") return /* @__PURE__ */ jsxs("div", {
+				className: UboQuestionnaireModalContent_module_default.questionnaireModalContent,
+				children: [
+					/* @__PURE__ */ jsx(Typography, {
+						variant: "title-l",
+						el: "h3",
+						className: "u-margin-bottom-40",
+						children: t(($) => $["moreAboutRegisteredRepresentativeDirectors"])
+					}),
+					/* @__PURE__ */ jsx(Typography, {
+						variant: "body-strongest",
+						el: "h4",
+						className: "u-margin-bottom-12",
+						children: t(($) => $["whatIsARegisteredRepresentativeDirector"])
+					}),
+					/* @__PURE__ */ jsx(Typography, {
+						el: "p",
+						className: "u-margin-bottom-32",
+						children: t(($) => $["directorIsANaturalPerson"])
+					}),
+					/* @__PURE__ */ jsx(Typography, {
+						variant: "body-strongest",
+						el: "h4",
+						className: "u-margin-bottom-12",
+						children: t(($) => $["canABusinessHaveMultipleRegisteredRepresentativeDirectors"])
+					}),
+					/* @__PURE__ */ jsx(Typography, {
+						el: "p",
+						children: t(($) => $["aBusinessCanHaveManyDirectors"])
+					})
+				]
+			});
+			return /* @__PURE__ */ jsxs("div", {
+				className: UboQuestionnaireModalContent_module_default.questionnaireModalContent,
+				children: [
+					/* @__PURE__ */ jsx(Typography, {
+						variant: "title-l",
+						el: "h3",
+						className: "u-margin-bottom-40",
+						children: t(($) => $["moreAboutDirectors"])
+					}),
+					/* @__PURE__ */ jsx(Typography, {
+						variant: "body-strongest",
+						el: "h4",
+						className: "u-margin-bottom-12",
+						children: t(($) => $["directorDescriptionQ1"])
+					}),
+					/* @__PURE__ */ jsx(Typography, {
+						el: "p",
+						className: "u-margin-bottom-32",
+						children: t(($) => $["directorDescriptionA1"])
+					}),
+					/* @__PURE__ */ jsx(Typography, {
+						variant: "body-strongest",
+						el: "h4",
+						className: "u-margin-bottom-12",
+						children: t(($) => $["directorDescriptionQ2"])
+					}),
+					/* @__PURE__ */ jsx(Typography, {
+						el: "p",
+						children: t(($) => $["directorDescriptionA2"])
+					})
+				]
+			});
+		default: return null;
+	}
+};
+//#endregion
+//#region src/components/Individual/forms/UboQuestionnaire/UboQuestionnaire.tsx
+var uboQuestionnaireFields = [
+	"isOwner",
+	"isControllingPerson",
+	"isDirector",
+	"isNomineeDirector",
+	"isNomineeShareholder"
+];
+function UboQuestionnaire(props) {
+	const { t } = useTranslation(["common"]);
+	const { t: individualT } = useTranslation(["individual"]);
+	const handleModalAction = useModalAction();
+	const { data, description, errors, formVerificationErrors, heading, fieldValidationErrors, handleFieldChange, country } = props;
+	const formUtils = createFormUtils(props, t);
+	const [activeModal, setActiveModal] = useState$1(null);
+	const openModal = (modalType) => () => {
+		handleModalAction(`${modalType}Modal`, "open", (isOpen) => setActiveModal(isOpen ? modalType : null));
+	};
+	const closeModal = () => {
+		if (activeModal) handleModalAction(`${activeModal}Modal`, "close", () => setActiveModal(null));
+	};
+	const { registerGuidanceQuestion } = useGuidanceQuestionnaire({
+		data,
+		handleFieldChange,
+		openModal,
+		country,
+		formUtils,
+		errors,
+		fieldValidationErrors
+	});
+	if (!handleFieldChange) return;
+	const modalAriaLabelMap = {
+		isOwner: individualT(($) => $["moreAboutOwners"]),
+		isControllingPerson: individualT(($) => $["moreAboutOwnershipThroughControl"]),
+		isDirector: individualT(($) => $["moreAboutDirectors"]),
+		isNomineeDirector: "",
+		isNomineeShareholder: ""
+	};
+	return /* @__PURE__ */ jsxs("form", {
+		"aria-describedby": "ariaErrorField",
+		children: [
+			heading && /* @__PURE__ */ jsx(Header, {
+				title: heading,
+				description
+			}),
+			/* @__PURE__ */ jsx(ErrorPanel, {
+				verificationErrors: formVerificationErrors,
+				validationErrors: fieldValidationErrors,
+				formUtils,
+				id: "ariaErrorField"
+			}),
+			formUtils.isRequiredField("isDirector") && /* @__PURE__ */ jsx(GuidanceQuestion, { ...registerGuidanceQuestion("isDirector") }),
+			formUtils.isRequiredField("isNomineeDirector") && data?.isDirector === GuidanceQuestionValues.YES && /* @__PURE__ */ jsx(GuidanceQuestion, { ...registerGuidanceQuestion("isNomineeDirector") }),
+			formUtils.isRequiredField("isOwner") && /* @__PURE__ */ jsx(GuidanceQuestion, { ...registerGuidanceQuestion("isOwner") }),
+			formUtils.isRequiredField("isNomineeShareholder") && data?.isOwner === GuidanceQuestionValues.YES && /* @__PURE__ */ jsx(GuidanceQuestion, { ...registerGuidanceQuestion("isNomineeShareholder") }),
+			formUtils.isRequiredField("isControllingPerson") && /* @__PURE__ */ jsx(GuidanceQuestion, { ...registerGuidanceQuestion("isControllingPerson") }),
+			activeModal && /* @__PURE__ */ jsx(Modal, {
+				onClose: closeModal,
+				ariaLabel: modalAriaLabelMap[activeModal],
+				inset: true,
+				children: /* @__PURE__ */ jsx(UboQuestionnaireModalContent, {
+					modalType: activeModal,
+					country
+				})
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/Individual/forms/Individual.tsx
+var logger$1 = createLogger();
+var individualForms = {
+	signatoryQuestionnaire: {
+		formId: "signatoryQuestionnaire",
+		formName: "authorizedSignatory",
+		fields: ["isSignatory"]
+	},
+	uboQuestionnaire: {
+		formId: "uboQuestionnaire",
+		formName: "beneficialOwnership",
+		fields: uboQuestionnaireFields
+	},
+	basicDetails: {
+		formId: "basicDetails",
+		formName: "basicInformationFormName",
+		fields: basicDetailsFields
+	},
+	idVerificationMethod: {
+		formId: "idVerificationMethod",
+		formName: "verificationMethod",
+		fields: idVerificationMethodFields
+	},
+	inviteDetails: {
+		formId: "inviteDetails",
+		formName: "inviteDetails",
+		fields: inviteDetailsFields
+	},
+	additionalPersonalDetails: {
+		formId: "additionalPersonalDetails",
+		formName: "additionalPersonalDetails",
+		fields: additionalPersonalDetailsFields
+	},
+	manualIdUpload: {
+		formId: "manualIdUpload",
+		formName: "idDocument",
+		fields: idDocumentUploadFields
+	},
+	proofOfResidency: {
+		formId: "proofOfResidency",
+		formName: "proofOfResidency",
+		fields: ["proofOfResidency"]
+	},
+	proofOfNationalId: {
+		formId: "proofOfNationalId",
+		formName: "proofOfNationalId",
+		fields: ["proofOfNationalId"]
+	},
+	proofOfRelationship: {
+		formId: "proofOfRelationship",
+		formName: "proofOfRelationship",
+		fields: ["proofOfRelationship"]
+	}
+};
+var signatoryQuestionnaireFormID = individualForms.signatoryQuestionnaire.formId;
+var uboQuestionnaireFormID = individualForms.uboQuestionnaire.formId;
+var basicDetailsFormID = individualForms.basicDetails.formId;
+var additionalPersonalDetailsFormID = individualForms.additionalPersonalDetails.formId;
+var inviteDetailsFormID = individualForms.inviteDetails.formId;
+var idVerificationMethodFormID = individualForms.idVerificationMethod.formId;
+var manualIdUploadFormID = individualForms.manualIdUpload.formId;
+var proofOfResidencyFormID = individualForms.proofOfResidency.formId;
+var proofOfNationalIdFormID = individualForms.proofOfNationalId.formId;
+var proofOfRelationshipFormID = individualForms.proofOfRelationship.formId;
+function Individual(props) {
+	const { t: commonT } = useTranslation("common");
+	const { t: individualT } = useTranslation("individual");
+	const { form: { errors, valid, fieldProblems: fieldValidationErrors, handleChangeFor, setFormData } } = useFormContext();
+	const { goToFormByFormId } = useFormRouterContext();
+	const [isDecisionMakerNotRequiredModalOpen, setIsDecisionMakerNotRequiredModalOpen] = useState$1(false);
+	const [isDuplicateNameModalOpen, setIsDuplicateNameModalOpen] = useState$1(false);
+	const { activeForm: propActiveForm, defaultCountry, data, taskType, allowedRoles, parentLegalEntity, trustedFieldsProvider, trustedRoles, legalEntityId, problems, onNext, setNextHandler, handleHomeClick, scenarios, isInvitedEntity, invitedEntityDetails } = props;
+	const basicDetailsFormProps = getFormProps(props, basicDetailsFormID);
+	const signatoryQuestionnaireFormProps = getFormProps(props, signatoryQuestionnaireFormID);
+	const uboQuestionnaireFormProps = getFormProps(props, uboQuestionnaireFormID);
+	const additionalPersonalDetailsFormProps = getFormProps(props, additionalPersonalDetailsFormID);
+	const proofOfResidencyFormProps = getFormProps(props, proofOfResidencyFormID);
+	const proofOfNationalIdFormProps = getFormProps(props, proofOfNationalIdFormID);
+	const proofOfRelationshipFormProps = getFormProps(props, proofOfRelationshipFormID);
+	const countryOfResidence = data?.additionalPersonalDetails?.country ?? defaultCountry;
+	const handleModalAction = useModalAction();
+	const handleNextForPersonNotRequired = () => {
+		if (!data?.signatoryQuestionnaire && !data?.uboQuestionnaire) return;
+		const { signatoryQuestionnaire, uboQuestionnaire } = data;
+		const isDirectorApplicable = uboQuestionnaireFormProps?.requiredFields?.includes("isDirector");
+		if (signatoryQuestionnaire && uboQuestionnaire && signatoryQuestionnaire?.isSignatory === GuidanceQuestionValues.NO && uboQuestionnaire?.isOwner === GuidanceQuestionValues.NO && uboQuestionnaire?.isControllingPerson === GuidanceQuestionValues.NO && (!isDirectorApplicable || uboQuestionnaire?.isDirector === GuidanceQuestionValues.NO)) handleModalAction("personalInfoNotNeeded", "open", setIsDecisionMakerNotRequiredModalOpen);
+		else onNext?.();
+	};
+	const { firstName, lastName } = data?.basicDetails ?? {};
+	const enteredFullName = useMemo$1(() => {
+		if (firstName && lastName) return `${firstName} ${lastName}`;
+		return null;
+	}, [firstName, lastName]);
+	const existingNames = useMemo$1(() => {
+		const associations = parentLegalEntity?.entityAssociations ?? [];
+		return new Set(associations.flatMap((entity) => entity.name ? [entity.name.toLowerCase()] : []));
+	}, [parentLegalEntity]);
+	const handleBasicDetailsNext = useCallback$1(() => {
+		if (legalEntityId) {
+			onNext?.();
+			return;
+		}
+		if (enteredFullName === null) {
+			onNext?.();
+			return;
+		}
+		if (existingNames.has(enteredFullName.toLowerCase())) setIsDuplicateNameModalOpen(true);
+		else onNext?.();
+	}, [
+		enteredFullName,
+		existingNames,
+		onNext,
+		legalEntityId
+	]);
+	useEffect$1(() => {
+		if (propActiveForm.formId === uboQuestionnaireFormID) setNextHandler?.(() => handleNextForPersonNotRequired);
+		else if (propActiveForm.formId === basicDetailsFormID) setNextHandler?.(() => handleBasicDetailsNext);
+		else setNextHandler?.(void 0);
+	}, [
+		propActiveForm,
+		setNextHandler,
+		data
+	]);
+	const handleCloseModalAndGoBack = useCallback$1(() => handleModalAction("personalInfoNotNeeded", "close", setIsDecisionMakerNotRequiredModalOpen, handleHomeClick), [handleModalAction, handleHomeClick]);
+	const handleCloseModalAndChangeAnswers = useCallback$1(() => handleModalAction("personalInfoNotNeeded", "cancel", setIsDecisionMakerNotRequiredModalOpen), [handleModalAction]);
+	const handleCloseModalAndGoToOverview = useCallback$1(() => handleModalAction("thisPersonAlreadyExists", "close", setIsDuplicateNameModalOpen, handleHomeClick), [handleModalAction, handleHomeClick]);
+	const handleCloseModalAndContinue = useCallback$1(() => handleModalAction("thisPersonAlreadyExists", "cancel", setIsDuplicateNameModalOpen, onNext), [handleModalAction, onNext]);
+	const handleContinueToAdditionalDetails = () => {
+		goToFormByFormId(additionalPersonalDetailsFormID);
+	};
+	const handleContinueToInviteDetails = () => {
+		goToFormByFormId(inviteDetailsFormID);
+	};
+	const handleDeleteDocument = () => {
+		logger$1.info("handle delete document");
+	};
+	const handleUpdateDocument = () => {
+		logger$1.info("handle update document");
+	};
+	const capabilities = useCapabilities();
+	const newRoles = useMemo$1(() => isInvitedEntity ? invitedEntityDetails?.roles : calculateRoles(data), [
+		data,
+		invitedEntityDetails,
+		isInvitedEntity
+	]);
+	useEffect$1(() => {
+		const currentRoles = data?.basicDetails?.role ?? [];
+		if (areArraysDifferent(newRoles, currentRoles)) {
+			const basicDetailsData = data?.basicDetails ?? {};
+			setFormData("basicDetails", {
+				...basicDetailsData,
+				role: newRoles
+			});
+		}
+	}, [
+		newRoles,
+		data?.basicDetails?.role,
+		setFormData
+	]);
+	const hasLiveSelfieErrorCode = hasLiveSelfieError(problems);
+	const hasMotionCaptureScenarioValue = hasMotionCaptureScenario?.value;
+	useEffect$1(() => {
+		setShowIndividualMotionCapture(shouldShowMotionCapture({
+			capabilities: isInvitedEntity ? invitedEntityDetails?.rootCapabilities : capabilities,
+			userRoles: data?.basicDetails?.role,
+			taskType,
+			hasLiveSelfieError: hasLiveSelfieErrorCode,
+			hasMotionScenario: data?.basicDetails?.role?.includes(DecisionMakerTypes.SIGNATORY) && scenarios?.includes(Scenarios.L_BAFIN) ? false : hasMotionCaptureScenarioValue,
+			isInvitedEntity
+		}));
+	}, [
+		data?.basicDetails?.role,
+		scenarios,
+		taskType,
+		capabilities,
+		hasMotionCaptureScenarioValue,
+		hasLiveSelfieErrorCode,
+		isInvitedEntity,
+		invitedEntityDetails?.rootCapabilities
+	]);
+	const fullName = `${data?.basicDetails?.firstName} ${data?.basicDetails?.lastName}`;
+	const handleFieldChange = (formName) => (fieldName, mode) => handleChangeFor(formName, fieldName, mode);
+	const renderActiveForm = (activeForm) => {
+		switch (activeForm.formId) {
+			case signatoryQuestionnaireFormID: return /* @__PURE__ */ jsx(SignatoryQuestionnaire, {
+				...signatoryQuestionnaireFormProps,
+				heading: individualT(($) => $["signatoryQuestionnaireHeader"]),
+				id: signatoryQuestionnaireFormID,
+				handleFieldChange: handleFieldChange("signatoryQuestionnaire"),
+				errors: errors?.signatoryQuestionnaire,
+				fieldValidationErrors: fieldValidationErrors?.signatoryQuestionnaire
+			});
+			case uboQuestionnaireFormID: return /* @__PURE__ */ jsx(UboQuestionnaire, {
+				...uboQuestionnaireFormProps,
+				heading: individualT(($) => $["uboQuestionnaireHeader"]),
+				description: individualT(($) => countryOfResidence === CountryCodes.Japan ? $["registeringTheLegalRepresentativeAsRequiredByLaw"] : $["thisIsImportantBecauseItIsARegulatoryRequirement"]),
+				id: uboQuestionnaireFormID,
+				handleFieldChange: handleFieldChange("uboQuestionnaire"),
+				errors: errors?.uboQuestionnaire,
+				fieldValidationErrors: fieldValidationErrors?.uboQuestionnaire,
+				country: countryOfResidence
+			});
+			case basicDetailsFormID: return /* @__PURE__ */ jsx(BasicDetails, {
+				...basicDetailsFormProps,
+				data: data?.basicDetails ?? {},
+				heading: commonT(($) => $["basicInformationFormName"]),
+				taskType,
+				id: basicDetailsFormID,
+				allowedRoles,
+				country: countryOfResidence,
+				parentLegalEntity,
+				trustedFieldsProvider,
+				trustedRoles,
+				errors: errors?.basicDetails,
+				fieldValidationErrors: fieldValidationErrors?.basicDetails,
+				valid: valid?.basicDetails,
+				handleFieldChange: handleFieldChange("basicDetails")
+			});
+			case idVerificationMethodFormID: return /* @__PURE__ */ jsx(IdVerificationMethod, {
+				legalEntityId,
+				taskType,
+				handlers: {
+					handleContinueToAdditionalDetails,
+					handleContinueToInviteDetails,
+					handleDeleteDocument,
+					handleUpdateDocument
+				},
+				formVerificationErrors: problems?.verificationErrors?.idVerificationMethod,
+				fieldValidationErrors: problems?.validationErrors?.idVerificationMethod,
+				hasLiveSelfieErrorCode,
+				isInvitedEntity
+			});
+			case inviteDetailsFormID: {
+				const inviteDetailsData = {
+					email: data?.basicDetails?.email ?? "",
+					phoneNumber: data?.basicDetails?.phoneNumber,
+					senderName: data?.inviteDetails?.senderName ?? "",
+					message: data?.inviteDetails?.message ?? ""
+				};
+				return /* @__PURE__ */ jsx(InviteDetails, {
+					country: countryOfResidence,
+					data: inviteDetailsData,
+					errors: errors?.inviteDetails,
+					fieldValidationErrors: fieldValidationErrors?.inviteDetails,
+					handleFieldChange: handleFieldChange("inviteDetails"),
+					heading: individualT(($) => $["inviteDetails"]),
+					id: inviteDetailsFormID,
+					recipientFirstName: data?.basicDetails?.firstName ?? "",
+					valid: valid?.inviteDetails
+				});
+			}
+			case additionalPersonalDetailsFormID: return /* @__PURE__ */ jsx(AdditionalPersonalDetails, {
+				...additionalPersonalDetailsFormProps,
+				country: countryOfResidence,
+				data: data?.additionalPersonalDetails ?? {},
+				heading: individualT(($) => $["additionalPersonalDetails"]),
+				id: additionalPersonalDetailsFormID,
+				errors: errors?.additionalPersonalDetails,
+				fieldValidationErrors: fieldValidationErrors?.additionalPersonalDetails,
+				valid: valid?.additionalPersonalDetails,
+				taskType,
+				handleFieldChange: handleFieldChange("additionalPersonalDetails")
+			});
+			case manualIdUploadFormID: return /* @__PURE__ */ jsx(ManualIdUpload, {});
+			case proofOfResidencyFormID: return /* @__PURE__ */ jsx(MemoizedProofOfResidencyUpload, {
+				...proofOfResidencyFormProps,
+				data: data?.proofOfResidency,
+				id: proofOfResidencyFormID,
+				name: fullName,
+				errors: errors.proofOfResidency,
+				fieldValidationErrors: fieldValidationErrors.proofOfResidency,
+				valid: valid.proofOfResidency,
+				handleFieldChange: handleFieldChange("proofOfResidency")
+			});
+			case proofOfNationalIdFormID: return /* @__PURE__ */ jsx(MemoizedDocumentUpload, {
+				...proofOfNationalIdFormProps,
+				data: data?.proofOfNationalId,
+				documentField: "proofOfNationalId",
+				documentType: "registrationDocument",
+				heading: commonT(($) => $["proofOfNationalId"]),
+				id: proofOfNationalIdFormID,
+				errors: errors.proofOfNationalId,
+				fieldValidationErrors: fieldValidationErrors.proofOfNationalId,
+				valid: valid.proofOfNationalId,
+				handleFieldChange: handleFieldChange("proofOfNationalId")
+			});
+			case proofOfRelationshipFormID: return /* @__PURE__ */ jsx(MemoizedProofOfRelationship, {
+				...proofOfRelationshipFormProps,
+				data: data?.proofOfRelationship,
+				id: proofOfRelationshipFormID,
+				name: fullName,
+				errors: errors.proofOfRelationship,
+				fieldValidationErrors: fieldValidationErrors.proofOfRelationship,
+				valid: valid.proofOfRelationship,
+				handleFieldChange: handleFieldChange("proofOfRelationship")
+			});
+			default: logger$1.warn(`Active form (${activeForm.formId}) is not supported'`);
+		}
+	};
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		renderActiveForm(propActiveForm),
+		isDecisionMakerNotRequiredModalOpen && /* @__PURE__ */ jsx(Confirm, {
+			title: individualT(($) => $["personalInfoNotNeeded"]),
+			description: individualT(($) => $["weWontCollectAnyInfoAboutThisPerson"]),
+			onConfirm: handleCloseModalAndGoBack,
+			confirmText: individualT(($) => $["backToOverview"]),
+			onCancel: handleCloseModalAndChangeAnswers,
+			cancelText: individualT(($) => $["changeAnswers"])
+		}),
+		isDuplicateNameModalOpen && /* @__PURE__ */ jsx(Confirm, {
+			title: individualT(($) => $["thisPersonAlreadyExists"]),
+			description: individualT(($) => $["doYouWantToUpdateTheirExistingDetails"], { name: enteredFullName ?? "" }),
+			onConfirm: handleCloseModalAndGoToOverview,
+			confirmText: individualT(($) => $["updateExistingDetails"]),
+			onCancel: handleCloseModalAndContinue,
+			cancelText: commonT(($) => $["continue"])
+		})
+	] });
+}
+//#endregion
+//#region src/components/Individual/forms/InviteDetails/validate.ts
+var validateSenderNameNotEmpty = {
+	modes: ["blur"],
+	validate: (senderName) => !isEmpty(senderName),
+	errorMessage: "fieldIsRequired"
+};
+var senderNameRules = () => {
+	const v4NameRules = nameValidationRulesV4().firstName ?? [];
+	return Array.isArray(v4NameRules) ? v4NameRules : [v4NameRules];
+};
+var validateMessageNotEmpty = {
+	modes: ["blur"],
+	validate: (message) => !isEmpty(message),
+	errorMessage: "fieldIsRequired"
+};
+var validateEmailNotEmpty = {
+	modes: ["blur"],
+	validate: (email) => !isEmpty(email),
+	errorMessage: "fieldIsRequired"
+};
+var validateEmailFormat = {
+	modes: ["blur"],
+	validate: (email) => email ? emailPattern.test(email) : true,
+	errorMessage: "invalidEmail"
+};
+var validateMobilePhoneNumberNotEmpty = {
+	modes: ["blur"],
+	validate: (phone) => {
+		if (phone?.number && phone?.phoneCountryCode) {
+			const prefix = phonePrefixes_default[phone?.phoneCountryCode];
+			return Boolean(phone.number.replace(prefix, "").trim().length);
+		}
+		return false;
+	},
+	errorMessage: "fieldIsRequired"
+};
+var validateMobilePhoneNumber = {
+	modes: ["blur"],
+	validate: (phone) => Boolean(phone?.number && isPhoneNumberMobile(phone)),
+	errorMessage: "invalidPhoneNumber"
+};
+var inviteDetailsValidators = () => ({
+	senderName: [validateSenderNameNotEmpty, ...senderNameRules()],
+	message: [validateMessageNotEmpty],
+	email: [validateEmailNotEmpty, validateEmailFormat],
+	phoneNumber: [validateMobilePhoneNumberNotEmpty, validateMobilePhoneNumber]
+});
+//#endregion
+//#region src/components/Individual/helpers/mandateIdVerificationForMotionCapture.ts
+var mandateIdVerificationForMotionCapture = (showMotionCapture, derivedProps) => {
+	if (!derivedProps) return;
+	const copiedDerivedProps = { ...derivedProps };
+	if (showMotionCapture) {
+		const idVerificationFields = [...derivedProps.requiredFields.idVerificationMethod ?? [], "idVerificationMethod"];
+		copiedDerivedProps.allFields.idVerificationMethod = idVerificationFields;
+		copiedDerivedProps.requiredFields.idVerificationMethod = idVerificationFields;
+	}
+	return copiedDerivedProps;
+};
+//#endregion
+//#region src/components/Individual/mapping/mapApiDocumentToIndividualDocuments.ts
+var mapApiDocumentToIndividualDocuments = (entityId) => {
+	const idDocument = getIdDocument(entityId);
+	const proofOfResidency = getDocument(entityId, "proofOfResidency");
+	const proofOfNationalId = getDocument(entityId, "proofOfNationalIdNumber");
+	const proofOfRelationship = getDocument(entityId, "proofOfRelationship");
+	return {
+		manualIdUpload: idDocument ? mapApiIdDocumentToSchema(idDocument) : void 0,
+		proofOfResidency: proofOfResidency ? { proofOfResidency: [mapExistingFile(getPageName(proofOfResidency))] } : void 0,
+		proofOfNationalId: proofOfNationalId ? { proofOfNationalId: [mapExistingFile(getPageName(proofOfNationalId))] } : void 0,
+		proofOfRelationship: proofOfRelationship ? { proofOfRelationship: [mapExistingFile(getPageName(proofOfRelationship))] } : void 0
+	};
+};
+var mapApiIdDocumentToSchema = (idDocument) => {
+	const { type, attachments, modificationDate } = idDocument;
+	const { hasBackPage } = getLocalizedIdDocumentTypeOptions().find(({ id }) => id === type);
+	let frontPage;
+	let backPage;
+	if (attachments?.length === 1) frontPage = getPage(idDocument);
+	else {
+		frontPage = hasBackPage ? getPage(idDocument, "front") : getPage(idDocument);
+		backPage = hasBackPage ? getPage(idDocument, "back") : void 0;
+	}
+	return {
+		...frontPage ? { idFrontPage: [mapExistingFile(frontPage.pageName ?? "")] } : {},
+		...backPage ? { idBackPage: [mapExistingFile(backPage.pageName ?? "")] } : {},
+		idDocumentType: type,
+		modificationDate
+	};
+};
+//#endregion
+//#region src/components/Individual/mapping/mapIndividualDocumentToApiDocument.ts
+var mapIndividualDocumentToApiDocument = async (data, entityId) => {
+	if (!data) return void 0;
+	const { proofOfNationalId, proofOfResidency, proofOfRelationship, manualIdUpload } = data;
+	const entityType = "legalEntity";
+	return (await Promise.all([
+		manualIdUpload?.idFrontPage ? createDocumentRequest({
+			entityId,
+			entityType,
+			documentType: manualIdUpload.idDocumentType,
+			page1: manualIdUpload?.idFrontPage?.[0],
+			page2: manualIdUpload?.idBackPage?.[0]
+		}) : void 0,
+		proofOfNationalId?.proofOfNationalId ? createDocumentRequest({
+			entityId,
+			entityType,
+			documentType: "proofOfNationalIdNumber",
+			page1: proofOfNationalId.proofOfNationalId[0]
+		}) : void 0,
+		proofOfResidency?.proofOfResidency ? createDocumentRequest({
+			entityId,
+			entityType,
+			documentType: "proofOfResidency",
+			description: proofOfResidency?.description,
+			page1: proofOfResidency.proofOfResidency[0]
+		}) : void 0,
+		proofOfRelationship?.proofOfRelationship ? createDocumentRequest({
+			entityId,
+			entityType,
+			documentType: "proofOfRelationship",
+			description: proofOfRelationship?.description,
+			page1: proofOfRelationship.proofOfRelationship[0]
+		}) : void 0
+	])).filter(Boolean);
+};
+//#endregion
+//#region src/components/Individual/mapping/adjustOnfidoIdentificationData.ts
+var adjustOnfidoIdentificationData = (data, apiData) => {
+	const { typeOfIdentity, idNumber, idNumberExempt } = data;
+	const type = getOnfidoIdentityTypeToApiIdentityTypeMap(data)[typeOfIdentity] ?? "nationalIdNumber";
+	const identificationData = {
+		...apiData,
+		number: idNumber,
+		type
+	};
+	switch (typeOfIdentity) {
+		case "passport": return {
+			...identificationData,
+			cardNumber: ""
+		};
+		case "driversLicense": return {
+			...identificationData,
+			expiryDate: ""
+		};
+		default: return idNumber === void 0 && idNumberExempt === void 0 ? void 0 : {
+			...identificationData,
+			expiryDate: "",
+			cardNumber: "",
+			nationalIdExempt: apiData?.nationalIdExempt ?? !idNumber
+		};
+	}
+};
+//#endregion
+//#region src/components/Individual/mapping/mapIndividualSchemaToLegalEntity.ts
+var mapIndividualSchemaToLegalEntity = (individual, isFeatureEnabled, matchingScenario) => {
+	const legalEntity = {
+		...formatObject(individual, individualApiKeyMapping),
+		type: "individual"
+	};
+	if (individual.additionalPersonalDetails) {
+		if (matchingScenario?.includes(Scenarios.L_TAXINFO) && individual.additionalPersonalDetails?.idNumber && (individual.additionalPersonalDetails?.country === CountryCodes.Spain || individual.additionalPersonalDetails?.country === CountryCodes.Italy)) {
+			const taxCountry = individual.additionalPersonalDetails?.country;
+			const taxType = taxCountry === CountryCodes.Spain && individual.additionalPersonalDetails?.typeOfIdentity ? individual.additionalPersonalDetails?.typeOfIdentity.toUpperCase() : taxIdNumberOptions[taxCountry][0]["id"];
+			legalEntity.individual.taxInformation = [{
+				country: taxCountry,
+				number: individual.additionalPersonalDetails.idNumber,
+				type: taxType
+			}];
+		}
+		legalEntity.individual.identificationData = adjustOnfidoIdentificationData(individual.additionalPersonalDetails, legalEntity.individual.identificationData);
+	}
+	const nameLocalization = [mapSchemaFieldsToApiScriptLocalization(individual.basicDetails ?? {}, "jaHani"), mapSchemaFieldsToApiScriptLocalization(individual.basicDetails ?? {}, "jaKana")].filter(({ fields }) => !isEmpty$1(fields));
+	if (nameLocalization.length) legalEntity.individual.name.localization = nameLocalization;
+	const addressLocalizations = mapJpAddressSchemaToAddressLocalizations(individual.additionalPersonalDetails);
+	if (addressLocalizations.length > 0) legalEntity.individual.residentialAddress.localization = addressLocalizations;
+	if (individual.basicDetails?.phoneNumber) {
+		const phone = {
+			number: individual.basicDetails.phoneNumber.number,
+			type: "mobile"
+		};
+		if (phone.number && legalEntity.individual) legalEntity.individual.phone = phone;
+		else delete legalEntity?.individual?.phone;
+	}
+	return legalEntity;
+};
+//#endregion
+//#region src/components/Individual/tasks/IndividualDropin/individualFormConfig.ts
+var identityOnfidoBase = {
+	role: { rule: "requiredIfDecisionMakerTask" },
+	firstName: { rule: "REQUIRED" },
+	lastName: { rule: "REQUIRED" },
+	birthDate: { rule: "REQUIRED" },
+	phoneNumber: { rules: ["requiredIfPhoneScenarioDisabled", "contactsIfRequiredForRole"] },
+	email: { rule: "contactsIfRequiredForRole" },
+	jobTitle: { rule: "jobTitleIfRequiredForRole" },
+	placeOfBirth: { rule: "isPlaceOfBirthRequired" },
+	nationality: { rule: "nationalityIfRequiredForRole" },
+	street: { rule: "addressIfRequiredForCountry" },
+	street2: { rule: "otherAddressInfoIfRequiredForCountry" },
+	country: { rule: "REQUIRED" },
+	postalCode: { rule: "postalCodeIfRequiredForCountry" },
+	city: { rule: "cityIfRequiredForCountry" },
+	stateOrProvince: { rule: "stateOrProvinceIfRequiredForCountry" },
+	proofOfResidency: { rule: "isProofOfResidencyRequired" },
+	proofOfNationalId: { rule: "isProofOfNationalIdRequired" },
+	relationship: { rule: "legalRepresentativeRelationshipRequired" },
+	proofOfRelationship: { rule: "isProofOfRelationshipRequired" },
+	idVerificationMethod: { rule: "isIdVerificationMethodRequired" },
+	idDocument: { rule: "isUsingInstantVerificationOrHasExistingDocument" },
+	idDocumentType: { rule: "isManualIdFlowAndHasMissingData" },
+	/**
+	* Below fields only relevant if manual ID is needed
+	* @see identityNumber
+	* @see idDocRequired
+	*/
+	idFrontPage: { rule: "hasChosenIdType" },
+	idBackPage: { rule: "backPageIfRequiredForIdType" },
+	isSignatory: { rules: ["requiredIfDecisionMakerTask"] },
+	isOwner: { rules: ["requiredIfDecisionMakerTask"] },
+	isControllingPerson: { rules: ["requiredIfDecisionMakerTask"] },
+	isDirector: { rules: ["requiredIfDecisionMakerTask", "isDirectorRequiredForCountry"] },
+	isNomineeDirector: { rules: ["requiredIfDecisionMakerTask", "nomineeDirectorRequiredForCountry"] },
+	isNomineeShareholder: { rules: ["requiredIfDecisionMakerTask", "nomineeShareHolderRequiredForCountry"] },
+	jaHaniFirstName: { rule: "japanSpecificField" },
+	jaHaniLastName: { rule: "japanSpecificField" },
+	jaKanaFirstName: { rule: "japanSpecificField" },
+	jaKanaLastName: { rule: "japanSpecificField" },
+	jaHaniStreet: { rule: "japanSpecificField" },
+	jaHaniCity: { rule: "japanSpecificField" },
+	jaHaniStateOrProvince: { rule: "japanSpecificField" },
+	jaKanaCity: { rule: "japanSpecificField" },
+	jaKanaStateOrProvince: { rule: "japanSpecificField" }
+};
+var identityNumber = {
+	idNumber: {
+		rule: "idNumberRules",
+		obscured: true
+	},
+	idNumberExempt: { rules: ["idNumberExemptIfApplicableCountry", "isDirectorIdNumberRequiredForCountry"] },
+	idDocumentType: { rule: "isManualIdFlowAndNotProvidingIdNumber" }
+};
+var additionalIdentityInfo = {
+	typeOfIdentity: { rules: ["requiredIfCountryUsesMultipleTypesOfIdentity", "isDirectorIdNumberRequiredForCountry"] },
+	issuerState: { rule: "issuerStateRequired" },
+	licenseCardNumber: { rule: "licenseCardNumberRules" },
+	expiryDate: { rule: "expiryDateRequired" }
+};
+var idDocRequired = { idDocumentType: { rule: "isManualIdFlow" } };
+var nationality = { nationality: { rule: "REQUIRED" } };
+var phoneNumberBase = { phoneNumber: { rule: "contactsIfRequiredForRole" } };
+var inviteDetails = {
+	senderName: { rule: "isVerifyByInviteSelected" },
+	message: { rule: "isVerifyByInviteSelected" }
+};
+var taxInformationBase = { taxInformation: { rule: "countryUsesTaxId" } };
+var individualFieldsPerScenario = {
+	L0: {
+		...drop("address", "birthDate").from(identityOnfidoBase),
+		...inviteDetails
+	},
+	L1: {
+		...identityOnfidoBase,
+		...inviteDetails
+	},
+	L1_ID: {
+		...identityOnfidoBase,
+		...identityNumber,
+		...additionalIdentityInfo,
+		...inviteDetails
+	},
+	L1_IDO: {
+		...identityOnfidoBase,
+		...identityNumber,
+		...additionalIdentityInfo,
+		...inviteDetails
+	},
+	L1_NAT: {
+		...identityOnfidoBase,
+		...identityNumber,
+		...additionalIdentityInfo,
+		...nationality,
+		...inviteDetails
+	},
+	L_TAXINFO: {
+		...identityOnfidoBase,
+		...taxInformationBase,
+		...inviteDetails
+	},
+	L1_IDDOC: idDocRequired,
+	L_PH: phoneNumberBase
+};
+//#endregion
+//#region src/components/Individual/tasks/IndividualDropin/IndividualDropin.tsx
+var parseIndividualScenarios = (scenarios) => composePerScenarioFormConfigurations(scenarios, individualFieldsPerScenario);
+var parseConfiguration = ({ scenarios }) => parseIndividualScenarios(scenarios);
+var logger = createLogger();
+function IndividualDropin({ taskType = TaskTypes.INDIVIDUAL, parentLegalEntity, legalEntityResponse, handleHomeClick, isTargetLegalEntityType, country: parentCountry, problems: propProblems, trustMember, onSubmit: externalOnSubmit, asModal = false, handleBackClick: externalBackClick, trustedFields, trustedFieldsProvider, trustedRoles, isInvitedEntity, invitedEntityDetails }) {
+	const { baseUrl, rootLegalEntityId } = useApiContext();
+	const { accountHolder, setAccountHolder } = useAccountHolder();
+	const { t, i18n } = useTranslation(["common", "individual"]);
+	const userEvents = useAnalyticsContext();
+	const { showToast, clearToasts } = useToastContext();
+	const { isFeatureEnabled } = useToggleContext();
+	const { isSettingEnabled } = useSettingsContext();
+	const queryClient = useQueryClient();
+	const { data: providerStatus } = useProviderStatus({
+		providers: ["idDocument"],
+		country: legalEntityResponse ? getLegalEntityCountry(legalEntityResponse) : "NL"
+	});
+	const isInstantVerificationEnabled = providerStatus?.statuses?.idDocument?.enabled ?? true;
+	const { mutateAsync: updateLegalEntity } = useUpdateLegalEntity();
+	const isRoleFieldNeeded = taskType === TaskTypes.DECISION_MAKER || taskType === TaskTypes.TRUST_MEMBER_COMPANY_OWNER || taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY_OWNER;
+	const dataFromResponse = useMemo$1(() => {
+		const formStateData = individualFormDefaultData.value;
+		individualFormDefaultData.value = null;
+		if (legalEntityResponse) {
+			const mappedData = mapLegalEntityToIndividualSchema(legalEntityResponse, isTargetLegalEntityType, isRoleFieldNeeded, parentLegalEntity);
+			return {
+				...mappedData,
+				...isInvitedEntity && invitedEntityDetails?.jobTitle && { basicDetails: {
+					...mappedData.basicDetails,
+					jobTitle: invitedEntityDetails.jobTitle
+				} },
+				...formStateData
+			};
+		}
+		return {
+			additionalPersonalDetails: { country: parentCountry },
+			...formStateData
+		};
+	}, [
+		legalEntityResponse,
+		parentCountry,
+		isTargetLegalEntityType,
+		isRoleFieldNeeded,
+		parentLegalEntity,
+		isInvitedEntity,
+		invitedEntityDetails
+	]);
+	const [matchingScenario, setMatchingScenario] = useState$1();
+	const [validationErrors, setValidationErrors] = useState$1();
+	const [loadingStatus, setLoadingStatus] = useState$1("success");
+	const [existingAttachments, setExistingAttachments] = useState$1();
+	const [documents, setDocuments] = useState$1();
+	const [country, setCountry] = useState$1(dataFromResponse?.additionalPersonalDetails?.country ?? parentCountry);
+	const [derivedProps, setDerivedProps] = useState$1();
+	const [nextHandler, setNextHandler] = useState$1();
+	const [hasBafinNavigated, setHasBafinNavigated] = useState$1(false);
+	const problems = useMemo$1(() => ({
+		...propProblems,
+		validationErrors
+	}), [propProblems, validationErrors]);
+	const hasVerificationErrors = propProblems?.verificationErrors && Object.keys(propProblems.verificationErrors).length > 0;
+	/**
+	* Analytics
+	*/
+	useTaskLandedEvent(taskType);
+	const individualFieldValidations = useCallback$1((data) => ({
+		basicDetails: basicDetailsValidators({
+			isFeatureEnabled,
+			country
+		}),
+		additionalPersonalDetails: additionalPersonalDetailsValidators({
+			country: data?.additionalPersonalDetails?.country ?? country,
+			isFeatureEnabled,
+			isSettingEnabled,
+			taskType,
+			idNumberType: data?.additionalPersonalDetails?.typeOfIdentity,
+			idNumberExempt: data?.additionalPersonalDetails?.idNumberExempt,
+			idNumber: data?.additionalPersonalDetails?.idNumber,
+			existingIdNumber: dataFromResponse.additionalPersonalDetails?.idNumber,
+			formVerificationErrors: problems?.verificationErrors?.additionalPersonalDetails,
+			t,
+			taxIdNumberType: data?.additionalPersonalDetails?.taxInformation?.length ? data?.additionalPersonalDetails?.taxInformation[0]?.type : void 0
+		}),
+		inviteDetails: inviteDetailsValidators()
+	}), [
+		country,
+		dataFromResponse.additionalPersonalDetails?.idNumber,
+		t,
+		isFeatureEnabled,
+		isSettingEnabled,
+		problems?.verificationErrors?.additionalPersonalDetails,
+		taskType
+	]);
+	const validatePhoneNumber = useValidatePhoneNumberImperatively();
+	const { mutateAsync: verifyIdNumber } = useVerifyIdNumber();
+	const individualFieldAsyncValidations = useCallback$1((data) => ({
+		basicDetails: { phoneNumber: getAsyncPhoneValidationRules(validatePhoneNumber).phoneNumber },
+		additionalPersonalDetails: { idNumber: getAsyncIdNumberValidationRule(verifyIdNumber, data?.additionalPersonalDetails, data?.basicDetails).idNumber }
+	}), [verifyIdNumber, validatePhoneNumber]);
+	const defaultData = useMemo$1(() => {
+		if (!documents) return dataFromResponse;
+		return {
+			...dataFromResponse,
+			...drop("manualIdUpload").from(documents),
+			idVerificationMethod: {
+				idDocument: documents.manualIdUpload,
+				idVerificationMethod: "existingDocument"
+			}
+		};
+	}, [documents, dataFromResponse]);
+	const form = useMultiForm({
+		requiredFields: derivedProps?.requiredFields,
+		defaultData,
+		rules: individualFieldValidations,
+		asyncRules: individualFieldAsyncValidations,
+		optionalFields: derivedProps?.optionalFields,
+		obscuredFields: { 
+		/**takes care of scenario when the 4 digit provided is wrong based on verification errors and
+		* we need to show validation error for defaultData which is already saved
+		**/
+additionalPersonalDetails: check4DigitSsnFailed(problems?.verificationErrors?.additionalPersonalDetails) ? [] : ["idNumber"] }
+	});
+	const documentUtils = documentApiUtils({
+		baseUrl: baseUrl.value,
+		rootLegalEntityId: rootLegalEntityId.value
+	});
+	const { data, requiredFields } = form;
+	useEffect$1(() => {
+		setCountry(data?.additionalPersonalDetails?.country ?? parentCountry);
+	}, [data?.additionalPersonalDetails?.country, parentCountry]);
+	const { data: scenarios } = useScenarios(country, "individual");
+	useEffect$1(() => {
+		if (!scenarios) return;
+		setHasMotionCaptureScenario(scenarios);
+		setMatchingScenario(scenarios);
+	}, [scenarios]);
+	/**
+	* Fetch Configurations
+	*/
+	const { fieldConfigurations } = useScenarioConfiguration({
+		parseConfiguration,
+		legalEntityType: "individual",
+		setLoadingStatus,
+		country
+	});
+	/**
+	* parse configuration and create component props
+	*/
+	const fieldsFromCustomRules = useMemo$1(() => individualRules({
+		matchingScenario,
+		data,
+		country: data?.additionalPersonalDetails?.country ?? country,
+		taskType,
+		isFeatureEnabled,
+		rootLegalEntity: parentLegalEntity,
+		problems
+	}), [
+		country,
+		matchingScenario,
+		data,
+		isFeatureEnabled,
+		parentLegalEntity,
+		taskType,
+		problems
+	]);
+	const hasLiveSelfieErrorCode = hasLiveSelfieError(problems);
+	useEffect$1(() => {
+		const derivedProps = getPropsFromConfigurations({
+			scenarioConfiguration: fieldConfigurations,
+			forms: individualForms,
+			remediationActions: problems?.remediationActions ? Object.values(problems?.remediationActions) : [],
+			dataMissingErrors: problems?.missingData ?? [],
+			fieldsWithExistingData: legalEntityResponse ? getFieldsWithExistingData(legalEntityResponse, individualApiKeyMapping, individualDocumentMapping, [
+				"additionalPersonalDetails.typeOfIdentity",
+				"additionalPersonalDetails.idNumber",
+				"additionalPersonalDetails.stateOrProvince",
+				"additionalPersonalDetails.issuerState"
+			]) : [],
+			customRules: fieldsFromCustomRules,
+			legalEntityType: legalEntityResponse?.type,
+			legalEntityTrustedFields: [],
+			remediationFieldAsOptional: true
+		});
+		/**
+		* For invited entities, if they already have data for certain basic details (jobTitle, email, phoneNumber),
+		* we do not want to prompt them to enter or edit these details again.
+		* By calculating these 'hidden' fields and removing them from required/optional fields,
+		* the BasicDetails form will not render them.
+		*/
+		if (isInvitedEntity && derivedProps && dataFromResponse?.basicDetails) {
+			const basicDetailsData = dataFromResponse.basicDetails;
+			const hiddenFields = new Set([
+				"jobTitle",
+				"email",
+				"phoneNumber"
+			].filter((field) => Boolean(basicDetailsData[field])));
+			if (hiddenFields.size > 0) {
+				const filterFields = (fields) => fields?.filter((field) => !hiddenFields.has(field));
+				if (derivedProps.requiredFields?.basicDetails) derivedProps.requiredFields.basicDetails = filterFields(derivedProps.requiredFields.basicDetails);
+				if (derivedProps.optionalFields?.basicDetails) derivedProps.optionalFields.basicDetails = filterFields(derivedProps.optionalFields.basicDetails);
+			}
+		}
+		const updatedDerivedProps = mandateIdVerificationForMotionCapture(hasLiveSelfieErrorCode || showIndividualMotionCapture?.value, derivedProps);
+		if (updatedDerivedProps) setDerivedProps(updatedDerivedProps);
+	}, [
+		fieldConfigurations,
+		legalEntityResponse,
+		fieldsFromCustomRules,
+		problems?.remediationActions,
+		problems?.missingData,
+		hasLiveSelfieErrorCode,
+		isInvitedEntity,
+		dataFromResponse?.basicDetails
+	]);
+	/**
+	* Fetch the documents of the legal entity
+	*/
+	useEffect$1(() => {
+		if (!legalEntityResponse?.documentDetails?.length) return;
+		documentUtils.fetchDocuments(legalEntityResponse.documentDetails, legalEntityResponse?.id).then((res) => {
+			setExistingAttachments(res[0].attachments);
+			setDocuments(mapApiDocumentToIndividualDocuments(legalEntityResponse?.id));
+		}).catch(() => {
+			showToast({
+				label: t(($) => $["failedToFetchRelevantDocuments"]),
+				variant: "error"
+			});
+		});
+	}, []);
+	/**
+	* Configure forms based on obtained props
+	*/
+	const forms = useMemo$1(() => {
+		return addValidityToForms(getRequiredForms(individualForms, derivedProps?.requiredFields, derivedProps?.optionalFields).filter((form) => {
+			const { formId } = form;
+			if (!isInstantVerificationEnabled && formId === individualForms.idVerificationMethod.formId) return false;
+			if (data.idVerificationMethod?.idVerificationMethod === "verifyByInvite" && ![
+				individualForms.uboQuestionnaire.formId,
+				individualForms.signatoryQuestionnaire.formId,
+				individualForms.basicDetails.formId,
+				individualForms.idVerificationMethod.formId,
+				individualForms.inviteDetails.formId,
+				"summary"
+			].includes(formId)) return false;
+			if (isInvitedEntity && (formId === individualForms.signatoryQuestionnaire.formId || formId === individualForms.uboQuestionnaire.formId)) return false;
+			if (formId === individualForms.inviteDetails.formId) return data.idVerificationMethod?.idVerificationMethod === "verifyByInvite";
+			return true;
+		}), form.isValid, problems);
+	}, [
+		derivedProps,
+		form.isValid,
+		isInstantVerificationEnabled,
+		problems,
+		isInvitedEntity,
+		data.idVerificationMethod?.idVerificationMethod
+	]);
+	const { mutateAsync: getIdVerificationStartCheck } = useIdVerificationStartCheck();
+	const handleInstantIdVerificationStartCheck = async (onfidoResponse, legalEntityId) => {
+		const providerId = idVerificationProviderId.value;
+		if (!providerId) throw Error("idVerificationProviderId not yet set");
+		await getIdVerificationStartCheck({
+			providerId,
+			legalEntityId,
+			captureMetadata: onfidoResponse
+		});
+	};
+	const roleTypes = isRoleFieldNeeded && parentLegalEntity ? getAllowedDecisionMakerRoles(parentLegalEntity, taskType, matchingScenario) : [];
+	const { mutateAsync: createLegalEntity } = useCreateLegalEntity();
+	const { mutateAsync: createInvitationMutation } = useCreateInvitation();
+	const idDocumentTypeOptions = getLocalizedIdDocumentTypeOptions(country);
+	const submitLegalEntity = async ({ dataSubmitted, legalEntity, idDocumentType }) => {
+		let updatedLegalEntity;
+		/**
+		* Check whether the individual was already created. Can happen when the individual got created,
+		* but a subsequent call (POSTing documents or PATCHing parent LE) failed.
+		*/
+		const existingLeId = legalEntityResponse?.id;
+		if (legalEntity.individual && legalEntityResponse?.individual?.support) legalEntity.individual.support = customerSupportPresubmitProcess(legalEntityResponse, legalEntity);
+		if (!existingLeId) {
+			updatedLegalEntity = await createLegalEntity(legalEntity);
+			userEvents.addTaskEvent("Success", {
+				actionType: "submit",
+				countryOfRegistration: dataSubmitted.additionalPersonalDetails?.country,
+				roles: dataSubmitted.basicDetails?.role
+			});
+		} else {
+			updatedLegalEntity = await updateLegalEntity({
+				...drop("type").from(legalEntity),
+				id: existingLeId
+			});
+			userEvents.addTaskEvent("Success", {
+				actionType: "submit",
+				countryOfRegistration: dataSubmitted.additionalPersonalDetails?.country,
+				documentType: idDocumentType
+			});
+		}
+		return updatedLegalEntity;
+	};
+	const createInvite = async ({ inviteeLegalEntityId, inviteDetails }) => {
+		if (!parentLegalEntity?.id || !inviteDetails?.senderName || !inviteDetails?.message) {
+			logger.warn("createInvite: Missing required data", {
+				hasParentLegalEntity: !!parentLegalEntity?.id,
+				hasSenderName: !!inviteDetails?.senderName,
+				hasMessage: !!inviteDetails?.message
+			});
+			showToast({
+				label: t(($) => $["provideAllRequiredDetails"]),
+				variant: "error"
+			});
+			throw new Error("createInvite: Missing required data");
+		}
+		try {
+			const { url } = await createInvitationMutation({
+				organizationLegalEntityId: parentLegalEntity.id,
+				inviteeLegalEntityId,
+				data: {
+					facilitatorName: inviteDetails.senderName,
+					facilitatorMessage: inviteDetails.message,
+					sendEmail: true,
+					locale: i18n.language
+				}
+			});
+			logger.log("Invitation created successfully", {
+				inviteeLegalEntityId,
+				inviteLink: url
+			});
+			showToast({
+				label: t(($) => $["invitationSent"], { ns: "individual" }),
+				variant: "success"
+			});
+		} catch (error) {
+			logger.error("Failed to create invitation", {
+				error,
+				inviteeLegalEntityId
+			});
+			showToast({
+				label: t(($) => $["failedToUpdateDetails"]),
+				variant: "error"
+			});
+			throw error;
+		}
+	};
+	const submitDocuments = async ({ legalEntity, dataSubmitted }) => {
+		const idDocument = dataSubmitted.idVerificationMethod?.idDocument;
+		if (idDocument?.instantIdVerificationData) {
+			if (providerStatus?.statuses?.idDocument?.enabled === false) throw new Error("Provider unexpectedly disabled instant verification flow");
+			await handleInstantIdVerificationStartCheck(idDocument.instantIdVerificationData, legalEntity.id);
+		} else {
+			const formattedDocuments = await mapIndividualDocumentToApiDocument(dataSubmitted, legalEntity.id);
+			if (!formattedDocuments || formattedDocuments?.length === 0) {
+				if (existingAttachments?.length) logger.log("User has already uploaded documents and is not changing them, nothing needs to be done");
+				else logger.log("No documents to submit and no existing documents — skipping document upload");
+				return;
+			}
+			formattedDocuments[0].attachments = mergeAttachments(existingAttachments ?? [], formattedDocuments[0]?.attachments ?? []).filter((attachment) => attachment.content);
+			(await documentUtils.uploadDocuments(formattedDocuments, legalEntity.id))?.forEach((doc) => {
+				userEvents.addTaskEvent("Success", {
+					actionType: "upload",
+					documentType: doc.type,
+					fileExtention: doc?.attachments?.map((item) => getFileExtention(item.pageName ?? "")).filter((item) => item !== void 0) ?? void 0
+				});
+			});
+		}
+	};
+	/**
+	* Compares an entity's existing roles with a new set of roles to see if they have changed.
+	* @param legalEntityId - The ID of the legal entity whose roles are being checked.
+	* @param existingEntityAssociations - The array of existing legal entity associations.
+	* @param newRoles - The array of new roles.
+	* @returns `true` if the roles have changed, `false` otherwise.
+	*/
+	const hasRolesChanged = (legalEntityId, existingEntityAssociations, newRoles) => {
+		const existingRoles = existingEntityAssociations?.filter((association) => association.legalEntityId === legalEntityId).map(({ type }) => type);
+		return !doArraysMatch(existingRoles, newRoles);
+	};
+	const attachAssociationToParentLegalEntity = async ({ legalEntity, parentLE, dataSubmitted }) => {
+		let newRoles = null;
+		switch (taskType) {
+			case TaskTypes.DECISION_MAKER:
+			case TaskTypes.TRUST_MEMBER_COMPANY_OWNER:
+			case TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY_OWNER:
+				newRoles = dataSubmitted?.basicDetails?.role;
+				break;
+			case TaskTypes.TRUST_MEMBER_INDIVIDUAL:
+			case TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_INDIVIDUAL:
+				newRoles = trustMember?.roles;
+				break;
+		}
+		const existingEntityAssociations = getOwnEntityAssociations(parentLE);
+		if (newRoles && (hasRolesChanged(legalEntity?.id, existingEntityAssociations, newRoles) || dataFromResponse.basicDetails?.jobTitle !== dataSubmitted?.basicDetails?.jobTitle || hasNomineesChanged(dataFromResponse.basicDetails, dataSubmitted.basicDetails))) {
+			const updatedParentLegalEntity = { entityAssociations: [...newRoles.map((role) => ({
+				type: role,
+				legalEntityId: legalEntity.id,
+				...DECISION_MAKER_TYPES_WITH_JOBTITLE.some((type) => type === role) && { jobTitle: dataSubmitted?.basicDetails?.jobTitle }
+			})) || [], ...existingEntityAssociations.filter((ea) => ea.legalEntityId !== legalEntity.id) || []] };
+			const nomineeDataSource = dataSubmitted?.uboQuestionnaire;
+			if (nomineeDataSource && updatedParentLegalEntity.entityAssociations) updatedParentLegalEntity.entityAssociations = updatedParentLegalEntity.entityAssociations.map((ea) => attachNomineeToRole(ea, country, nomineeDataSource));
+			await updateLegalEntity({
+				...updatedParentLegalEntity,
+				id: parentLE.id
+			});
+		}
+	};
+	async function rollbackAttachingAssociation(legalEntityId, parentLE) {
+		try {
+			const updatedEntityAssociations = { entityAssociations: (parentLE.entityAssociations ?? []).filter((entityAssociation) => entityAssociation.legalEntityId !== legalEntityId) };
+			await updateLegalEntity({
+				...updatedEntityAssociations,
+				id: parentLE.id
+			});
+		} catch (err) {
+			logger.error(`Could not roll back attaching association ${legalEntityId} to ${parentLE.id}`, err);
+		}
+	}
+	/**
+	* OnSubmit will handle the creation and updating of Legal Entities (individuals)
+	* 1) Format component data to legal API data
+	* 2) Create/Update depending on legalEntity?.id
+	*/
+	const onSubmit = async () => {
+		setLoadingStatus("loading");
+		const dataSubmitted = omitObscuredFieldsIfUnchanged(individualObscuredFields, data, dataFromResponse);
+		if (!dataSubmitted) return;
+		try {
+			const legalEntity = mapIndividualSchemaToLegalEntity(dataSubmitted, isFeatureEnabled, matchingScenario);
+			const idDocumentType = idDocumentTypeOptions.find(({ id }) => dataSubmitted?.idVerificationMethod?.idDocument?.idDocumentType === id)?.id;
+			legalEntity.entityAssociations = filterOutUnwantedAssociationsIfRootLE(taskType, legalEntityResponse, accountHolder || void 0);
+			clearToasts();
+			const submittedLegalEntity = await submitLegalEntity({
+				dataSubmitted,
+				legalEntity,
+				idDocumentType
+			});
+			setAccountHolder(accountHolder);
+			if (dataSubmitted.idVerificationMethod?.idVerificationMethod && dataSubmitted.idVerificationMethod.idVerificationMethod !== "existingDocument" || hasVerificationErrors) {
+				if (!(dataSubmitted?.basicDetails?.role?.includes(DecisionMakerTypes.SIGNATORY) && matchingScenario?.includes(Scenarios.L_BAFIN))) await submitDocuments({
+					legalEntity: submittedLegalEntity,
+					dataSubmitted
+				});
+			}
+			if (parentLegalEntity) {
+				await attachAssociationToParentLegalEntity({
+					legalEntity: submittedLegalEntity,
+					parentLE: parentLegalEntity,
+					dataSubmitted
+				});
+				queryClient.invalidateQueries({
+					queryKey: ["legalEntity", parentLegalEntity.id],
+					refetchType: "all"
+				});
+			}
+			if (parentLegalEntity && dataSubmitted.idVerificationMethod?.idVerificationMethod === "verifyByInvite") try {
+				await createInvite({
+					inviteeLegalEntityId: submittedLegalEntity.id,
+					inviteDetails: dataSubmitted.inviteDetails
+				});
+			} catch (err) {
+				logger.error("An error occurred when creating invite, rolling back association of this LE");
+				await rollbackAttachingAssociation(submittedLegalEntity.id, parentLegalEntity);
+				throw err;
+			}
+			idNowModalChildEntityId.value = submittedLegalEntity;
+			setLoadingStatus("success");
+			externalOnSubmit?.(dataSubmitted, matchingScenario);
+		} catch (e) {
+			const eventsAdditionalData = {};
+			logger.error("Failed to update individual", e);
+			if (isValidationError(e)) {
+				const getErrors = processValidationErrors(e, TaskTypes.INDIVIDUAL);
+				if (getErrors && !Object.keys(getErrors).length) {
+					showToast({
+						label: t(($) => $["failedToUpdateDetails"]),
+						variant: "error"
+					});
+					eventsAdditionalData.unmappedErrorNames = e.invalidFields?.map((field) => field.name).filter(Boolean);
+				} else setValidationErrors(getErrors);
+			} else if (isMaintenanceModeError(e)) showToast({
+				label: t(($) => $["maintenanceModeMessage"]),
+				variant: "error",
+				duration: "indefinite"
+			});
+			else showToast({
+				label: t(($) => $["failedToUpdateDetails"]),
+				variant: "error"
+			});
+			setLoadingStatus("success");
+			userEvents.addTaskEvent("Encountered error", {
+				actionType: "submit",
+				additionalData: eventsAdditionalData,
+				returnType: e?.errorCode,
+				returnValue: e?.title || "backend"
+			});
+		}
+	};
+	const datasetUtils = datasetUtilities(i18n.language);
+	const formatIdDocument = (idDocument) => {
+		if (!idDocument) return void 0;
+		const documentType = idDocument?.instantIdVerificationData ? onfidoDocumentTypeMapping.find((document) => idDocument.instantIdVerificationData?.document_front.type === document.id) : idDocumentTypeOptions.find(({ id }) => idDocument.idDocumentType === id);
+		if (!documentType) return void 0;
+		const frontPage = idDocument.idFrontPage?.[0];
+		const backPage = idDocument.idBackPage?.[0];
+		if (!frontPage) return void 0;
+		return {
+			documentType: t(($) => $[documentType.name]),
+			...backPage && documentType.hasBackPage ? {
+				frontPage: frontPage.name,
+				backPage: backPage.name
+			} : { fileName: frontPage.name }
+		};
+	};
+	const formatFileSummaryData = ({ idVerificationMethod, manualIdUpload, proofOfNationalId, proofOfResidency, proofOfRelationship }) => {
+		const proofOfNationalIdFile = proofOfNationalId?.proofOfNationalId?.[0];
+		const proofOfResidencyFile = proofOfResidency?.proofOfResidency?.[0];
+		const proofOfRelationshipFile = proofOfRelationship?.proofOfRelationship?.[0];
+		const idDocument = idVerificationMethod?.idVerificationMethod === "manualVerification" ? manualIdUpload : idVerificationMethod?.idDocument;
+		return {
+			...(idDocument?.idDocumentType || idDocument?.instantIdVerificationData) && { idDocument: formatIdDocument(idDocument) },
+			...proofOfNationalIdFile && { proofOfNationalId: { fileName: proofOfNationalIdFile.name } },
+			...proofOfResidencyFile && { proofOfResidency: {
+				fileName: proofOfResidencyFile.name,
+				description: proofOfResidency?.description
+			} },
+			...proofOfRelationshipFile && { proofOfRelationship: {
+				fileName: proofOfRelationshipFile.name,
+				description: proofOfRelationship?.description
+			} }
+		};
+	};
+	const formatDataForSummary = () => {
+		let summaryData = cloneObject(data);
+		if (summaryData?.basicDetails?.phoneNumber) summaryData.basicDetails.phoneNumber = summaryData.basicDetails.phoneNumber.number;
+		if (summaryData.additionalPersonalDetails?.nationality) summaryData.additionalPersonalDetails.nationality = datasetUtils.getCountryName(summaryData.additionalPersonalDetails.nationality);
+		if (data.additionalPersonalDetails) if (isJapanLocalizationEnabled(isFeatureEnabled, country)) summaryData.additionalPersonalDetails = {
+			...drop(...JP_ADDRESS_REQUIRED_FIELDS).from(summaryData.additionalPersonalDetails),
+			...mapJpAddressSummary(data.additionalPersonalDetails, datasetUtils)
+		};
+		else summaryData.additionalPersonalDetails = {
+			...summaryData.additionalPersonalDetails,
+			...mapAddressLabels(data.additionalPersonalDetails, datasetUtils)
+		};
+		if (summaryData.basicDetails?.accountHolder) summaryData.basicDetails.accountHolder = t(($) => $[summaryData.basicDetails.accountHolder]);
+		if (summaryData.additionalPersonalDetails?.birthDate) summaryData.additionalPersonalDetails.birthDate = localizeDateString(summaryData.additionalPersonalDetails.birthDate, i18n.language);
+		if (summaryData.idVerificationMethod?.idVerificationMethod === "verifyByInvite") summaryData.idVerificationMethod = {
+			idVerificationMethod: preTranslatedSummaryItem(t(($) => $["type"], { ns: "individual" }), t(($) => $["inviteDecisionMaker"], { ns: "individual" })),
+			sender: preTranslatedSummaryItem(t(($) => $["sender"], { ns: "individual" }), data?.inviteDetails?.senderName ?? null),
+			message: preTranslatedSummaryItem(t(($) => $["message"], { ns: "individual" }), data?.inviteDetails?.message ?? null)
+		};
+		if (isManualVerificationOrExistingDoc(summaryData.idVerificationMethod?.idVerificationMethod) || summaryData.proofOfResidency) {
+			const fileSummaryData = formatFileSummaryData(data);
+			summaryData = {
+				...summaryData,
+				...fileSummaryData
+			};
+			summaryData.manualIdUpload = { ...summaryData.idDocument };
+			summaryData.idVerificationMethod.idDocument = { ...summaryData.idDocument };
+		}
+		const relevantTaxInformation = findRelevantTaxInformation(summaryData.additionalPersonalDetails?.taxInformation, {
+			nationality: data.additionalPersonalDetails?.nationality,
+			country: data.additionalPersonalDetails?.country
+		});
+		if (relevantTaxInformation) {
+			delete summaryData.additionalPersonalDetails.taxInformation;
+			summaryData.additionalPersonalDetails[relevantTaxInformation.type] = relevantTaxInformation.number;
+		}
+		if (summaryData?.signatoryQuestionnaire) summaryData.signatoryQuestionnaire = data?.signatoryQuestionnaire?.isSignatory === GuidanceQuestionValues.YES ? [t(($) => $["signatorySummaryLabel"])] : [];
+		if (summaryData?.uboQuestionnaire) {
+			const roleFieldToLabelMap = {
+				isOwner: "ownerSummaryLabel",
+				isControllingPerson: "controllingPersonSummaryLabel",
+				isDirector: "directorSummaryLabel"
+			};
+			summaryData.uboQuestionnaire = Object.keys(roleFieldToLabelMap).flatMap((field) => data?.uboQuestionnaire?.[field] === GuidanceQuestionValues.YES ? [t(($) => $[roleFieldToLabelMap[field]], { ns: "individual" })] : []);
+		}
+		return summaryData;
+	};
+	const omittedKeysForSummary = [
+		...taskType === TaskTypes.DECISION_MAKER ? ["role"] : [],
+		...data?.additionalPersonalDetails?.idNumberExempt ? ["idNumber"] : [],
+		...isManualVerificationOrExistingDoc(data?.idVerificationMethod?.idVerificationMethod) ? ["idVerificationMethod", "modificationDate"] : []
+	];
+	const isUploadEmpty = !data?.manualIdUpload || Object.keys(data?.manualIdUpload).length === 0;
+	const omittedFormsForSummary = [...data?.idVerificationMethod?.idVerificationMethod === "instantVerification" || isManualVerificationOrExistingDoc(data?.idVerificationMethod?.idVerificationMethod) && isUploadEmpty || data?.idVerificationMethod?.idVerificationMethod === "verifyByInvite" ? ["idDocument", "inviteDetails"] : [], ...isManualVerificationOrExistingDoc(data?.idVerificationMethod?.idVerificationMethod) ? ["idVerificationMethod", "inviteDetails"] : []];
+	const customLabelsForSummary = { idVerificationMethod: {
+		instantVerification: "idVerificationMethod",
+		manualVerification: "idDocument",
+		existingDocument: "idDocument",
+		verifyByInvite: "idVerificationMethod"
+	}[data?.idVerificationMethod?.idVerificationMethod ?? ""] ?? "idDocument" };
+	const { handleNextClick, handleBackClick, activeForm, shouldValidate, gotoFormByFormIndex, gotoFormByFormId, steps } = useFormComposer({
+		problems,
+		externalBackClick,
+		forms,
+		onSubmit,
+		triggerValidation: form.triggerValidation
+	});
+	const isBafinSignatory = data?.basicDetails?.role?.includes(DecisionMakerTypes.SIGNATORY) && scenarios?.includes(Scenarios.L_BAFIN);
+	const shouldNavigateToAdditionalPersonalDetails = isBafinSignatory && shouldNavigateToAdditionalPersonalDetailsForMissingData.value && Boolean(legalEntityResponse?.id) && (!data?.additionalPersonalDetails?.placeOfBirth || !data?.additionalPersonalDetails?.nationality);
+	if (isBafinSignatory && !hasBafinNavigated) {
+		setHasBafinNavigated(true);
+		shouldNavigateToAdditionalPersonalDetailsForMissingData.value = false;
+		gotoFormByFormId(shouldNavigateToAdditionalPersonalDetails ? individualForms.additionalPersonalDetails.formId : individualForms.signatoryQuestionnaire.formId);
+	}
+	const disableNextButton = activeForm?.formId === "idVerificationMethod" && !activeForm?.isValid || isNextStepDisabled.value;
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Show, {
+		when: shouldShowIdNowModal,
+		children: /* @__PURE__ */ jsx(IdNowVerificationModal, { handleFinish: handleHomeClick })
+	}), /* @__PURE__ */ jsx(FormContextProvider, {
+		form,
+		children: /* @__PURE__ */ jsx(FormFlow, {
+			summary: {
+				data: formatDataForSummary(),
+				omitted: {
+					keys: omittedKeysForSummary,
+					forms: omittedFormsForSummary
+				},
+				problems,
+				labels: customLabelsForSummary
+			},
+			asModal,
+			currentStep: steps.current,
+			disableNextButton,
+			forms,
+			activeForm,
+			gotoFormByFormIndex,
+			gotoFormByFormId,
+			handleBackClick,
+			handleCancelClick: handleHomeClick,
+			handleNextClick: nextHandler || handleNextClick,
+			loadingStatus,
+			totalSteps: steps.total,
+			children: /* @__PURE__ */ jsx(Individual, {
+				...derivedProps,
+				requiredFields,
+				data,
+				defaultCountry: country,
+				activeForm,
+				forms,
+				scenarios,
+				taskType,
+				problems,
+				onNext: handleNextClick,
+				onBack: handleBackClick,
+				legalEntityId: legalEntityResponse?.id,
+				allowedRoles: roleTypes,
+				shouldValidate,
+				accountHolder,
+				parentLegalEntity,
+				trustedFields,
+				trustedFieldsProvider,
+				trustedRoles,
+				setNextHandler,
+				handleHomeClick,
+				isInvitedEntity,
+				invitedEntityDetails
+			})
+		})
+	})] });
+}
+//#endregion
+export { individualForms as n, IndividualDropin as t };