@adyen/kyc-components 4.0.0-compact.0 → 4.0.0

package/dist/IndividualOnfidoDropin-BpU2cL4E.js

@@ -0,0 +1,2497 @@
+;
+{
+  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] = "2751d833-0647-4d90-af14-6f1304635848", e._sentryDebugIdIdentifier = "sentry-dbid-2751d833-0647-4d90-af14-6f1304635848");
+  } catch (e) {
+  }
+}
+;
+import { jsx, jsxs, Fragment } from "preact/jsx-runtime";
+import { useMemo, useState, useEffect, useCallback, useRef } from "preact/hooks";
+import { u as useScenarios } from "./useScenarios-DPOodENA.js";
+import { u as useCreateLegalEntity } from "./useCreateLegalEntity-BK5YcHA-.js";
+import { u as useUpdateLegalEntity } from "./useUpdateLegalEntity-oa8qEzc4.js";
+import { j as useProviderStatus, p as addressValidators, q as addressFormatters, r as mapAddressLabels } from "./Address-Db6Q_KUo.js";
+import { c as contactDetailsValidationRules, u as useValidatePhoneNumberImperatively } from "./validate-BYwVLb-X.js";
+import { b as useApiContext, a1 as useMutation, k as httpPost, aD as matchesRegex, aP as trimValWithOneSpace, aE as NO_ALPHABET_REGEX, aF as EMOJI_REGEX, aG as hasRepeatedCharacters, aH as isInvalidName, a$ as INDIVIDUAL_VALID_CHAR_REGEX, aN as getFormattingRegEx, aO as SPECIAL_CHARS, aK as standardKatakanaValidator, aL as standardKanjiValidator, C as CountryCodes, X as isEmpty, P as TaskTypes, t as LegalEntityTypes, b0 as getAgeToday, b1 as euCountries, b2 as individualApiKeyMapping, aZ as reverseMapping, b3 as getNomineeFromAssociation, b4 as individualComponentsKeyMapping, b5 as drop, U as createLogger, M as useAccountHolder, W as useI18nContext, a0 as useAnalyticsContext, p as useExperimentsContext, o as useSettingsContext, g as getLegalEntityCountry, b6 as getAllowedDecisionMakerRoles, b7 as filterOutUnwantedAssociationsIfRootLE, aA as cloneObject, b8 as individualDocumentMapping, b9 as individualObscuredFields, af as getOwnEntityAssociations, ba as hasNomineesChanged, bb as attachNomineeToRole, aU as doArraysMatch, j as useQuery, x as skipToken, m as httpGet, u as useTranslation, a2 as useQueryClient, B as Button, L as Loader, bc as individualOnfidoApiKeyMapping, al as Scenarios, am as DecisionMakerTypes, bd as individualOnfidoDocumentMapping, be as individualOnfidoObscuredFields } from "./StoreProvider-BFN15Go9.js";
+import { F as FormContextProvider, a as FormFlow } from "./FormFlow-Cf3Ff2qw.js";
+import { a as useToastContext } from "./useToastContext-BK9oGWtb.js";
+import { g as getPropsFromConfigurations, c as composePerScenarioFormConfigurations } from "./process-field-configurations-DoOFQqtn.js";
+import { g as getRequiredForms, a as addValidityToForms, u as useFormComposer } from "./dropinUtils-D2lBlNWp.js";
+import { u as useMultiForm } from "./useMultiForm-rZmCYsI4.js";
+import { m as mapExistingFile, g as getPageName, a as getPage, u as useScenarioConfiguration } from "./mapExistingFile-BhW5UmN9.js";
+import { y as getSSNType, z as defaultFieldMetadata, A as defaultFieldConfig, B as defaultFieldMetadata$1, D as fieldConfig, t as taxInformationDefaultFieldMetadata, i as taxInformationDefaultFieldConfig, E as isEmpty$1, F as getTrustedFields, G as getAsyncIdNumberValidationRule, H as getAsyncPhoneValidationRules, I as setHasMotionCaptureScenario, J as showIndividualMotionCapture, q as individualForms, K as Individual, L as individualDocumentForms, M as idVerificationProviderId, N as idNowModalChildEntityId, O as LandingLayout, x as showIdNowModal, P as check4DigitSsnFailed, Q as individualOnfidoRules, p as individualOnfidoForms, R as isNextStepDisabled, U as shouldShowIdNowModal, V as IndividualOnfido, W as JP_ADDRESS_REQUIRED_FIELDS, X as GuidanceQuestionValues, Y as DECISION_MAKER_TYPES_WITH_JOBTITLE$1 } from "./IndividualOnfido-Cc7dydKq.js";
+import { i as isValidationError, p as processValidationErrors, a as isMaintenanceModeError } from "./validationError-CvZLhw5H.js";
+import { g as getIdDocument, a as getDocument, c as createDocumentRequest, d as documentApiUtils, m as mergeAttachments, b as getFileExtention } from "./documentUtils-CUgKVLK4.js";
+import { a as datasetUtilities, C as Confirm } from "./useDataset-BtfHQp4w.js";
+import { g as getFieldsWithExistingData } from "./getFieldsWithExistingData-B0l_1eCG.js";
+import { l as localizeDateString } from "./localizeDateString-C-G2nUor.js";
+import { o as omitObscuredFieldsIfUnchanged, I as IFrameWidget } from "./iframeWidget-yBLSAmf8.js";
+import { r as resolveFieldMetadata, w as getLocalizedIdDocumentTypeOptions, I as Image } from "./fieldConfigurations-C38LzPl3.js";
+import { r as rules, D as DECISION_MAKER_TYPES_WITH_JOBTITLE } from "./rules-DP604XPJ.js";
+import { f as formatObject } from "./utils-DNSfZiio.js";
+import { m as mapSchemaFieldsToApiScriptLocalization, a as mapApiScriptLocalizationToSchemaFields } from "./mapAddressLocalizationToJpAddressSchema-vJWbpAyq.js";
+import { computed } from "@preact/signals";
+import { Show } from "@preact/signals/utils";
+import { m as mapJpAddressSchemaToAddressLocalizations, a as mapJpAddressSummary } from "./mapJpAddressSchemaToAddressLocalizations-KFAvfuC1.js";
+import { lazy } from "preact/compat";
+import { M as Modal } from "./Modal-CloeVnNp.js";
+import { a as Alert } from "./Alert-DEiOX0nw.js";
+import { a as getIndividualLegalEntityName } from "./getName-CIw0MR9e.js";
+import { g as getOnfidoIdentityTypeToApiIdentityTypeMap, m as mapLegalEntityToIndividualOnfidoSchema } from "./mapLegalEntityToIndividualOnfidoSchema-D51tRiYd.js";
+const verifyIdNumber = async (legalEntityId, baseUrl, data) => {
+  return await httpPost(
+    {
+      baseUrl,
+      path: `legalEntities/${legalEntityId}/verifications/idNumber`,
+      // Handler for unhappy flows, i.e. status != 200, in the idNumber verification process
+      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
+  );
+};
+const useVerifyIdNumber = (options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useMutation({
+    mutationFn: (data) => verifyIdNumber(rootLegalEntityId.value, baseUrl.value, data),
+    ...options
+  });
+};
+const startVerificationCheck = async (rootLegalEntityId, baseUrl, data) => {
+  return httpPost(
+    {
+      baseUrl,
+      path: `legalEntities/${rootLegalEntityId}/providers/idVerification/process`
+    },
+    data
+  );
+};
+const useIdVerificationStartCheck = (options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useMutation({
+    mutationFn: (data) => startVerificationCheck(rootLegalEntityId.value, baseUrl.value, data),
+    ...options
+  });
+};
+const nameValidationRulesV4 = {
+  firstName: [
+    {
+      modes: ["blur"],
+      validate: (input) => !matchesRegex(NO_ALPHABET_REGEX, input),
+      errorMessage: "nameMustContainLetters"
+    },
+    {
+      modes: ["blur"],
+      validate: (input) => !matchesRegex(EMOJI_REGEX, input) && !hasRepeatedCharacters(input) && !isInvalidName(input) && matchesRegex(INDIVIDUAL_VALID_CHAR_REGEX, input),
+      errorMessage: "checkForTypos"
+    }
+  ],
+  lastName: [
+    {
+      modes: ["blur"],
+      validate: (input) => !matchesRegex(NO_ALPHABET_REGEX, input),
+      errorMessage: "nameMustContainLetters"
+    },
+    {
+      modes: ["blur"],
+      validate: (input) => !matchesRegex(EMOJI_REGEX, input) && !hasRepeatedCharacters(input) && !isInvalidName(input) && matchesRegex(INDIVIDUAL_VALID_CHAR_REGEX, input),
+      errorMessage: "checkForTypos"
+    }
+  ]
+};
+const specialCharsRegEx = getFormattingRegEx(SPECIAL_CHARS.replace("-", ""));
+const nameFormatters = {
+  firstName: {
+    // formatter: trimValWithOneSpace // just trim
+    // Example - removing disallowed chars as they are input: then they don't end up in state
+    formatter: (val) => val ? trimValWithOneSpace(val).replace(specialCharsRegEx, "") : void 0
+    // trim & replace
+  },
+  lastName: {
+    formatter: (val) => val ? trimValWithOneSpace(val).replace(specialCharsRegEx, "") : void 0
+  }
+};
+const onfidoDocumentTypeMapping = [
+  { id: "driversLicense", name: "driversLicense", hasBackPage: true },
+  { id: "identityCard", name: "identityCard", hasBackPage: true },
+  { id: "passport", name: "passport", hasBackPage: false }
+];
+const jaHaniNameValidationRules = {
+  jaHaniFirstName: [
+    {
+      modes: ["blur"],
+      validate: (input) => standardKanjiValidator(input),
+      errorMessage: "nameMustContainLetters"
+    }
+  ],
+  jaHaniLastName: [
+    {
+      modes: ["blur"],
+      validate: (input) => standardKanjiValidator(input),
+      errorMessage: "nameMustContainLetters"
+    }
+  ]
+};
+const jaKanaNameValidationRules = {
+  jaKanaFirstName: [
+    {
+      modes: ["blur"],
+      validate: (input) => standardKatakanaValidator(input),
+      errorMessage: "nameMustContainLetters"
+    }
+  ],
+  jaKanaLastName: [
+    {
+      modes: ["blur"],
+      validate: (input) => standardKatakanaValidator(input),
+      errorMessage: "nameMustContainLetters"
+    }
+  ]
+};
+const isNotOutOfRangeBirthDateValidatorRule$1 = {
+  modes: ["blur"],
+  validate: (birthDate) => !isEmpty(birthDate) && new Date(birthDate) < /* @__PURE__ */ new Date(),
+  errorMessage: "invalidDateOfBirth"
+};
+const buildMinimumAgeValidationRule$1 = (minimumAge) => ({
+  modes: ["blur"],
+  validate: (birthDate) => !!birthDate && getAgeToday(birthDate) >= minimumAge,
+  errorMessage: {
+    key: "youMustXYearsOldToContinue",
+    values: { minimumAge: minimumAge.toString() }
+  }
+});
+const getCountrySpecificMinimumAgeValidationRule$1 = (country) => {
+  if (!country) {
+    return buildMinimumAgeValidationRule$1(13);
+  }
+  if ([...euCountries, CountryCodes.UnitedKingdom, CountryCodes.Switzerland].some(
+    (c) => c === country
+  )) {
+    return buildMinimumAgeValidationRule$1(16);
+  }
+  switch (country) {
+    case CountryCodes.HongKong:
+    case CountryCodes.Singapore:
+      return buildMinimumAgeValidationRule$1(18);
+    default:
+      return buildMinimumAgeValidationRule$1(13);
+  }
+};
+const personalDetailsValidators = ({
+  country,
+  isExperimentEnabled = () => false,
+  isSettingEnabled = () => false,
+  taskType,
+  idNumberType,
+  phonePrefix,
+  idNumberExempt,
+  idNumber,
+  existingIdNumber,
+  formVerificationErrors,
+  taxIdNumberType
+}) => ({
+  taxInformation: resolveFieldMetadata(
+    taxInformationDefaultFieldConfig[country],
+    {
+      taxIdNumberType,
+      companyType: LegalEntityTypes.INDIVIDUAL
+    },
+    taxInformationDefaultFieldMetadata
+  )?.validators,
+  birthDate: (() => {
+    const baseValidators = [isNotOutOfRangeBirthDateValidatorRule$1];
+    if (isSettingEnabled("enforceLegalAge")) {
+      return [...baseValidators, buildMinimumAgeValidationRule$1(18)];
+    }
+    if (isExperimentEnabled("EnableAgeVerification")) {
+      if (taskType === TaskTypes.LEGAL_REPRESENTATIVE_DETAILS) {
+        return [...baseValidators, buildMinimumAgeValidationRule$1(18)];
+      }
+      return [...baseValidators, getCountrySpecificMinimumAgeValidationRule$1(country)];
+    }
+    return baseValidators;
+  })(),
+  ...isExperimentEnabled("StrictNameAndAddressValidationV4") ? nameValidationRulesV4 : void 0,
+  ...contactDetailsValidationRules,
+  phoneNumber: resolveFieldMetadata(
+    fieldConfig[phonePrefix ?? country],
+    {},
+    defaultFieldMetadata$1
+  )?.validators,
+  idNumber: (() => {
+    const derivedIdNumberType = country === CountryCodes.UnitedStates ? getSSNType(formVerificationErrors, existingIdNumber) : idNumberType;
+    return idNumberExempt ? {
+      validate: () => {
+        return idNumberExempt || !isEmpty(idNumber);
+      },
+      modes: ["blur"]
+    } : resolveFieldMetadata(
+      defaultFieldConfig[country],
+      { idNumberType: derivedIdNumberType },
+      defaultFieldMetadata
+    )?.validators;
+  })(),
+  ...jaHaniNameValidationRules,
+  ...jaKanaNameValidationRules
+});
+const mandateIdVerificationForMotionCapture = (showMotionCapture, derivedProps) => {
+  if (!derivedProps) {
+    return void 0;
+  }
+  const copiedDerivedProps = { ...derivedProps };
+  if (showMotionCapture) {
+    const idVerificationFields = [
+      ...derivedProps.requiredFields.idVerificationMethod ?? [],
+      "idVerificationMethod"
+    ];
+    copiedDerivedProps.allFields.idVerificationMethod = idVerificationFields;
+    copiedDerivedProps.requiredFields.idVerificationMethod = idVerificationFields;
+  }
+  return copiedDerivedProps;
+};
+const mapApiDocumentToIndividualDocuments = (entityId) => {
+  const idDocument2 = getIdDocument(entityId);
+  const proofOfResidency = getDocument(entityId, "proofOfResidency");
+  const proofOfNationalId = getDocument(entityId, "proofOfNationalIdNumber");
+  const proofOfRelationship = getDocument(entityId, "proofOfRelationship");
+  return {
+    idDocument: idDocument2 ? mapApiIdDocumentToSchema(idDocument2) : 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
+  };
+};
+const mapApiIdDocumentToSchema = (idDocument2) => {
+  const { type, attachments, modificationDate } = idDocument2;
+  const { hasBackPage } = getLocalizedIdDocumentTypeOptions().find(({ id }) => id === type);
+  let frontPage;
+  let backPage;
+  if (attachments?.length === 1) {
+    frontPage = getPage(idDocument2);
+  } else {
+    frontPage = hasBackPage ? getPage(idDocument2, "front") : getPage(idDocument2);
+    backPage = hasBackPage ? getPage(idDocument2, "back") : void 0;
+  }
+  return {
+    ...frontPage ? { idFrontPage: [mapExistingFile(frontPage.pageName ?? "")] } : {},
+    ...backPage ? { idBackPage: [mapExistingFile(backPage.pageName ?? "")] } : {},
+    idDocumentType: type,
+    modificationDate
+  };
+};
+const mapIndividualDocumentToApiDocument = async (data, entityId) => {
+  if (!data) return void 0;
+  const { proofOfNationalId, proofOfResidency, proofOfRelationship } = data;
+  const idDocument2 = "idDocument" in data ? data.idDocument : data.manualIdUpload;
+  const entityType = "legalEntity";
+  const documents = await Promise.all([
+    idDocument2?.idFrontPage ? createDocumentRequest({
+      entityId,
+      entityType,
+      documentType: idDocument2.idDocumentType,
+      page1: idDocument2.idFrontPage?.[0],
+      page2: idDocument2.idBackPage?.[0]
+    }) : void 0,
+    proofOfNationalId?.proofOfNationalId ? createDocumentRequest({
+      entityId,
+      entityType,
+      documentType: "proofOfNationalIdNumber",
+      page1: proofOfNationalId.proofOfNationalId[0]
+    }) : void 0,
+    proofOfResidency?.proofOfResidency ? createDocumentRequest({
+      entityId,
+      entityType,
+      documentType: "proofOfResidency",
+      page1: proofOfResidency.proofOfResidency[0]
+    }) : void 0,
+    proofOfRelationship?.proofOfRelationship ? createDocumentRequest({
+      entityId,
+      entityType,
+      documentType: "proofOfRelationship",
+      page1: proofOfRelationship.proofOfRelationship[0]
+    }) : void 0
+  ]);
+  return documents.filter(Boolean);
+};
+const getIdentityTypeToApiIdentityTypeMap = (data) => {
+  const { residencyCountry } = data;
+  switch (residencyCountry) {
+    case CountryCodes.HongKong:
+      return {
+        passport: "passport",
+        driversLicense: "driversLicense",
+        proofOfIdentityCard: "nationalIdNumber"
+      };
+    default:
+      return {
+        nationalIdNumber: "nationalIdNumber",
+        passport: "passport",
+        driversLicense: "driversLicense",
+        proofOfIdentityCard: "identityCard"
+      };
+  }
+};
+const adjustIdentificationData = (data, apiData) => {
+  const { typeOfIdentity, idNumber, idNumberExempt } = data;
+  const identificationData = {
+    ...apiData,
+    number: idNumber,
+    type: getIdentityTypeToApiIdentityTypeMap(data)[typeOfIdentity] ?? "nationalIdNumber"
+  };
+  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
+      };
+  }
+};
+const mapIndividualToLegalEntity = (data) => {
+  const requestObj = {
+    ...formatObject(data, individualApiKeyMapping)
+  };
+  requestObj.type = LegalEntityTypes.INDIVIDUAL;
+  const { personalDetails } = data;
+  if (!personalDetails) return requestObj;
+  requestObj.individual.identificationData = adjustIdentificationData(
+    personalDetails,
+    requestObj.individual.identificationData
+  );
+  const localization = [
+    mapSchemaFieldsToApiScriptLocalization(personalDetails, "jaHani"),
+    mapSchemaFieldsToApiScriptLocalization(personalDetails, "jaKana")
+  ].filter(({ fields }) => !isEmpty$1(fields));
+  if (localization.length) {
+    requestObj.individual.name.localization = localization;
+  }
+  if (personalDetails.phoneNumber?.number) {
+    requestObj.individual.phone = {
+      number: personalDetails.phoneNumber.number,
+      type: "mobile"
+    };
+  } else {
+    delete requestObj.individual.phone;
+  }
+  return requestObj;
+};
+const mapLegalEntityToIndividual = (legalEntity, isChangingType, isRoleFieldNeeded, parentLegalEntity, isLegalRepresentative) => {
+  let individualData = formatObject(
+    legalEntity,
+    individualComponentsKeyMapping
+  );
+  individualData = {
+    ...individualData,
+    personalDetails: {
+      ...individualData?.personalDetails,
+      ...isChangingType && {
+        firstName: "",
+        lastName: ""
+      }
+    }
+  };
+  if (!individualData.personalDetails?.idNumberExempt) {
+    individualData.personalDetails.idNumberExempt = false;
+  }
+  const apiIdentityTypeToIdentityTypeMap = reverseMapping(
+    getIdentityTypeToApiIdentityTypeMap(individualData.personalDetails)
+  );
+  if (legalEntity?.individual?.identificationData?.type) {
+    individualData.personalDetails.typeOfIdentity = apiIdentityTypeToIdentityTypeMap[legalEntity.individual.identificationData.type];
+  }
+  if (legalEntity?.documentDetails?.length) {
+    individualData = {
+      ...individualData,
+      ...mapApiDocumentToIndividualDocuments(legalEntity?.id)
+    };
+  }
+  if (legalEntity?.individual?.residentialAddress.country === "JP" && legalEntity.individual?.name?.localization) {
+    for (const scriptLoc of legalEntity.individual.name.localization) {
+      individualData.personalDetails = {
+        ...individualData.personalDetails,
+        ...mapApiScriptLocalizationToSchemaFields(scriptLoc)
+      };
+    }
+  }
+  if (!parentLegalEntity?.entityAssociations) {
+    return individualData;
+  }
+  const associations = parentLegalEntity?.entityAssociations?.filter((ea) => ea.legalEntityId === legalEntity?.id) ?? [];
+  if (isRoleFieldNeeded) {
+    individualData.personalDetails.role = associations.map((ea) => ea.type);
+    individualData.personalDetails.jobTitle = associations.find(
+      ({ jobTitle }) => Boolean(jobTitle)
+    )?.jobTitle;
+  }
+  individualData.personalDetails = getNomineeFromAssociation(
+    associations,
+    individualData.personalDetails
+  );
+  if (isLegalRepresentative) {
+    individualData.personalDetails.relationship = associations.find(
+      ({ relationship }) => Boolean(relationship)
+    )?.relationship;
+  }
+  return individualData;
+};
+const identityBase = {
+  role: {
+    rule: "requiredIfDecisionMakerTask"
+  },
+  firstName: {
+    rule: "REQUIRED"
+  },
+  lastName: {
+    rule: "REQUIRED"
+  },
+  birthDate: {
+    rule: "REQUIRED"
+  },
+  phoneNumber: {
+    rules: ["requiredIfPhoneScenarioDisabled", "contactsIfRequiredForRole"]
+  },
+  email: {
+    rule: "contactsIfRequiredForRole"
+  },
+  jobTitle: {
+    rule: "jobTitleIfRequiredForRole"
+  },
+  nationality: {
+    rule: "nationalityIfRequiredForRole"
+  },
+  address: {
+    rule: "addressIfRequiredForCountry"
+  },
+  otherAddressInformation: {
+    rule: "otherAddressInfoIfRequiredForCountry"
+  },
+  country: {
+    rule: "REQUIRED"
+  },
+  postalCode: {
+    rule: "postalCodeIfRequiredForCountry"
+  },
+  city: {
+    rule: "cityIfRequiredForCountry"
+  },
+  stateOrProvince: {
+    rule: "stateOrProvinceIfRequiredForCountry"
+  },
+  residencyCountry: {
+    rule: "REQUIRED"
+  },
+  proofOfResidency: {
+    rule: "isProofOfResidencyRequired"
+  },
+  proofOfNationalId: {
+    rule: "isProofOfNationalIdRequired"
+  },
+  relationship: {
+    rule: "legalRepresentativeRelationshipRequired"
+  },
+  proofOfRelationship: {
+    rule: "isProofOfRelationshipRequired"
+  },
+  nomineeDirector: {
+    rule: "nomineeDirectorRequiredForCountry"
+  },
+  nomineeShareholder: {
+    rule: "nomineeShareHolderRequiredForCountry"
+  },
+  jaHaniFirstName: {
+    rule: "japaneseFirstAndLastNames"
+  },
+  jaHaniLastName: {
+    rule: "japaneseFirstAndLastNames"
+  },
+  jaKanaFirstName: {
+    rule: "japaneseFirstAndLastNames"
+  },
+  jaKanaLastName: {
+    rule: "japaneseFirstAndLastNames"
+  },
+  idDocumentType: {
+    // If the user has a missing ID error and chooses manual flow
+    rule: "isManualIdFlowAndHasMissingData"
+  }
+};
+const identityNumber$1 = {
+  idNumber: {
+    rule: "idNumberRules",
+    obscured: true
+  },
+  idNumberExempt: {
+    rules: ["idNumberExemptIfApplicableCountry", "isDirectorIdNumberRequiredForCountry"]
+  },
+  idDocumentType: {
+    rule: "manualIdDocumentRequired"
+  },
+  idFrontPage: {
+    rule: "idFrontPageIfManualUpload"
+  },
+  idBackPage: {
+    rule: "backPageIfRequiredForDocumentType"
+  },
+  idVerificationMethod: {
+    rule: "idVerificationRequired"
+  },
+  instantIdVerificationData: {
+    rule: "instantVerificationDataRule"
+  }
+};
+const additionalIdentityInfo$1 = {
+  typeOfIdentity: {
+    rules: ["requiredIfCountryUsesMultipleTypesOfIdentity", "isDirectorIdNumberRequiredForCountry"]
+  },
+  issuerState: {
+    rule: "issuerStateRequired"
+  },
+  licenseCardNumber: {
+    rule: "licenseCardNumberRules"
+  },
+  expiryDate: {
+    rule: "expiryDateRequired"
+  }
+};
+const idDocument = {
+  idVerificationMethod: {
+    rule: "REQUIRED"
+  },
+  idDocumentType: {
+    rule: "REQUIRED"
+  },
+  idFrontPage: {
+    rule: "idFrontPageIfManualUpload"
+  },
+  idBackPage: {
+    rule: "backPageIfRequiredForDocumentType"
+  }
+};
+const nationality$1 = {
+  nationality: {
+    rule: "REQUIRED"
+  }
+};
+const phoneNumberBase$1 = {
+  phoneNumber: {
+    rule: "contactsIfRequiredForRole"
+  }
+};
+const taxInformationBase$1 = {
+  taxInformation: { rule: "countryUsesTaxId" }
+};
+const fieldsPerScenario = {
+  L0: drop("address", "birthDate").from(identityBase),
+  L1: identityBase,
+  L_TAXINFO: { ...identityBase, ...taxInformationBase$1 },
+  L1_ID: {
+    ...identityBase,
+    ...identityNumber$1,
+    ...additionalIdentityInfo$1
+  },
+  L1_IDO: {
+    // TODO: change idNumber rule to optional once optional fields are implemented
+    ...identityBase,
+    ...identityNumber$1,
+    ...additionalIdentityInfo$1
+  },
+  L1_NAT: {
+    ...identityBase,
+    ...identityNumber$1,
+    ...additionalIdentityInfo$1,
+    ...nationality$1
+  },
+  L1_IDDOC: idDocument,
+  L_PH: phoneNumberBase$1
+};
+const parseIndividualScenarios = (scenarios) => composePerScenarioFormConfigurations(scenarios, fieldsPerScenario);
+const parseConfiguration$1 = ({ scenarios }) => parseIndividualScenarios(scenarios);
+const logger$1 = createLogger();
+function IndividualDropin({
+  taskType = TaskTypes.INDIVIDUAL,
+  parentLegalEntity,
+  legalEntityResponse,
+  handleHomeClick,
+  isTargetLegalEntityType,
+  country: parentCountry,
+  problems: propProblems,
+  trustMember,
+  onSubmit: externalOnSubmit,
+  asModal = false,
+  handleBackClick: externalBackClick,
+  trustedFields,
+  trustedFieldsProvider,
+  trustedRoles
+}) {
+  const { baseUrl, rootLegalEntityId } = useApiContext();
+  const { accountHolder, setAccountHolder } = useAccountHolder();
+  const { i18n } = useI18nContext();
+  const userEvents = useAnalyticsContext();
+  const { showToast, clearToasts } = useToastContext();
+  const { isExperimentEnabled } = useExperimentsContext();
+  const { isSettingEnabled } = useSettingsContext();
+  const isRoleFieldNeeded = taskType === TaskTypes.DECISION_MAKER || taskType === TaskTypes.TRUST_MEMBER_COMPANY_OWNER || taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY_OWNER;
+  const isLegalRepresentative = taskType === TaskTypes.LEGAL_REPRESENTATIVE_DETAILS;
+  const dataFromResponse = useMemo(() => {
+    if (legalEntityResponse) {
+      return mapLegalEntityToIndividual(
+        legalEntityResponse,
+        isTargetLegalEntityType,
+        isRoleFieldNeeded,
+        parentLegalEntity,
+        isLegalRepresentative
+      );
+    }
+    return {
+      personalDetails: {
+        residencyCountry: parentCountry
+      },
+      address: {
+        country: parentCountry
+      }
+    };
+  }, [
+    legalEntityResponse,
+    parentCountry,
+    isTargetLegalEntityType,
+    parentLegalEntity,
+    isRoleFieldNeeded,
+    isLegalRepresentative
+  ]);
+  const documentUtils = documentApiUtils({
+    baseUrl: baseUrl.value,
+    rootLegalEntityId: rootLegalEntityId.value
+  });
+  let roleTypes = [];
+  const [matchingScenario, setMatchingScenario] = useState();
+  const [validationErrors, setValidationErrors] = useState();
+  const [loadingStatus, setLoadingStatus] = useState("success");
+  const [documents, setDocuments] = useState();
+  const [existingAttachments, setExistingAttachments] = useState();
+  const [country, setCountry] = useState(
+    dataFromResponse?.personalDetails?.residencyCountry ?? parentCountry
+  );
+  const [hideFooter, setHideFooter] = useState(false);
+  const [derivedProps, setDerivedProps] = useState();
+  const associatedLegalEntityTrustedFields = useMemo(
+    () => legalEntityResponse ? getTrustedFields(legalEntityResponse, individualComponentsKeyMapping) : {},
+    [legalEntityResponse]
+  );
+  const { data: providerStatus } = useProviderStatus({
+    providers: ["address", "idDocument"],
+    country: legalEntityResponse ? getLegalEntityCountry(legalEntityResponse) : country
+  });
+  const problems = useMemo(
+    () => ({
+      ...propProblems,
+      validationErrors
+    }),
+    [propProblems, validationErrors]
+  );
+  useEffect(() => {
+    userEvents.updateBaseTrackingPayload({ task: taskType });
+    userEvents.addTaskEvent("Landed on page", {
+      actionType: "start"
+    });
+  }, []);
+  const individualFieldValidations = useCallback(
+    (data2) => ({
+      personalDetails: personalDetailsValidators({
+        country: data2?.personalDetails?.residencyCountry ?? country,
+        isExperimentEnabled,
+        isSettingEnabled,
+        taskType,
+        idNumberType: data2?.personalDetails?.typeOfIdentity,
+        phonePrefix: data2?.personalDetails?.phoneNumber?.phoneCountryCode,
+        idNumberExempt: data2?.personalDetails?.idNumberExempt,
+        idNumber: data2?.personalDetails?.idNumber,
+        existingIdNumber: dataFromResponse.personalDetails?.idNumber,
+        formVerificationErrors: propProblems?.verificationErrors?.personalDetails,
+        taxIdNumberType: data2?.personalDetails?.taxInformation?.length ? data2?.personalDetails?.taxInformation[0]?.type : void 0
+      }),
+      address: addressValidators({
+        isExperimentEnabled,
+        country: data2?.personalDetails?.residencyCountry ?? country,
+        i18n
+      })
+    }),
+    [isExperimentEnabled, isSettingEnabled, taskType]
+  );
+  const validatePhoneNumber = useValidatePhoneNumberImperatively();
+  const { mutateAsync: verifyIdNumber2 } = useVerifyIdNumber();
+  const individualFieldAsyncValidations = useCallback(
+    (data2) => ({
+      personalDetails: {
+        phoneNumber: getAsyncPhoneValidationRules(validatePhoneNumber).phoneNumber,
+        idNumber: getAsyncIdNumberValidationRule(verifyIdNumber2, data2?.personalDetails).idNumber
+      }
+    }),
+    [getAsyncPhoneValidationRules, getAsyncIdNumberValidationRule]
+  );
+  const defaultData = useMemo(
+    () => ({
+      ...dataFromResponse,
+      ...documents,
+      idVerificationMethod: {
+        idVerificationMethod: "instantVerification"
+      }
+    }),
+    [legalEntityResponse, documents, isTargetLegalEntityType, dataFromResponse]
+  );
+  const formatters = useMemo(
+    () => ({
+      personalDetails: {
+        ...nameFormatters
+      },
+      address: addressFormatters
+    }),
+    []
+  );
+  const form = useMultiForm({
+    requiredFields: derivedProps?.requiredFields,
+    defaultData,
+    rules: individualFieldValidations,
+    asyncRules: individualFieldAsyncValidations,
+    optionalFields: derivedProps?.optionalFields,
+    formatters,
+    obscuredFields: {
+      personalDetails: ["idNumber"]
+    }
+  });
+  const { data = dataFromResponse } = form;
+  useEffect(() => {
+    setCountry(data?.personalDetails?.residencyCountry ?? parentCountry);
+  }, [data?.personalDetails?.residencyCountry, parentCountry]);
+  const { data: scenarios } = useScenarios(country, LegalEntityTypes.INDIVIDUAL);
+  useEffect(() => {
+    if (!scenarios) return;
+    setHasMotionCaptureScenario(scenarios);
+    setMatchingScenario(scenarios);
+  }, [scenarios]);
+  const { fieldConfigurations } = useScenarioConfiguration({
+    parseConfiguration: parseConfiguration$1,
+    legalEntityType: LegalEntityTypes.INDIVIDUAL,
+    setLoadingStatus,
+    country
+  });
+  const fieldsFromCustomRules = useMemo(
+    () => rules({
+      matchingScenario,
+      data,
+      country: data?.personalDetails?.residencyCountry ?? country,
+      taskType,
+      isExperimentEnabled,
+      rootLegalEntity: parentLegalEntity,
+      problems
+    }),
+    [country, matchingScenario, data, taskType, problems]
+  );
+  useEffect(() => {
+    const derivedProps2 = getPropsFromConfigurations({
+      scenarioConfiguration: fieldConfigurations,
+      forms: individualForms,
+      remediationActions: problems?.remediationActions ? Object.values(problems?.remediationActions) : [],
+      dataMissingErrors: problems?.missingData ?? [],
+      fieldsWithExistingData: legalEntityResponse ? getFieldsWithExistingData(
+        legalEntityResponse,
+        individualApiKeyMapping,
+        individualDocumentMapping,
+        // We ignore these fields for the purposes of this rule because we know them to be problematic
+        [
+          "personalDetails.typeOfIdentity",
+          "personalDetails.idNumber",
+          "address.stateOrProvince",
+          "personalDetails.issuerState"
+        ]
+      ) : [],
+      customRules: fieldsFromCustomRules,
+      legalEntityType: legalEntityResponse?.type,
+      legalEntityTrustedFields: [],
+      remediationFieldAsOptional: true
+    });
+    const updatedDerivedProps = mandateIdVerificationForMotionCapture(
+      showIndividualMotionCapture?.value,
+      derivedProps2
+    );
+    setDerivedProps(updatedDerivedProps);
+  }, [
+    fieldConfigurations,
+    legalEntityResponse,
+    fieldsFromCustomRules,
+    problems?.remediationActions,
+    problems?.missingData
+  ]);
+  const forms = useMemo(() => {
+    const formsWithUpdatedName = {
+      ...individualForms,
+      idDocument: {
+        ...individualForms.idDocument,
+        formName: data.idVerificationMethod?.idVerificationMethod === "instantVerification" ? "instantVerification" : "idDocument"
+      }
+    };
+    const requiredForms = getRequiredForms(
+      formsWithUpdatedName,
+      derivedProps?.requiredFields,
+      derivedProps?.optionalFields
+    ).filter(
+      // Prevent showing the ID verification method step when onfido is not enabled
+      (form2) => form2.formId !== "idVerificationMethod" || providerStatus?.statuses?.idDocument?.enabled
+    );
+    return addValidityToForms(requiredForms, form.isValid, problems);
+  }, [
+    derivedProps,
+    form.isValid,
+    problems,
+    providerStatus?.statuses?.idDocument?.enabled,
+    data.idVerificationMethod?.idVerificationMethod
+  ]);
+  if (isRoleFieldNeeded && parentLegalEntity) {
+    roleTypes = getAllowedDecisionMakerRoles(parentLegalEntity, taskType);
+  }
+  useEffect(() => {
+    if (!legalEntityResponse?.documentDetails?.length) return;
+    documentUtils.fetchDocuments(legalEntityResponse.documentDetails, legalEntityResponse?.id).then((res) => {
+      setExistingAttachments(res[0].attachments);
+      setDocuments(mapApiDocumentToIndividualDocuments(legalEntityResponse?.id));
+    }).catch(() => {
+      showToast({ label: i18n.get("failedToFetchRelevantDocuments"), variant: "error" });
+    });
+  }, [legalEntityResponse]);
+  const { mutateAsync: createLegalEntity } = useCreateLegalEntity();
+  const { mutateAsync: updateLegalEntity } = useUpdateLegalEntity();
+  const idDocumentTypeOptions = getLocalizedIdDocumentTypeOptions(country);
+  const submitLegalEntity = async ({
+    dataSubmitted,
+    legalEntity,
+    idDocumentType
+  }) => {
+    let updatedLegalEntity;
+    const existingLeId = legalEntityResponse?.id;
+    if (!existingLeId) {
+      updatedLegalEntity = await createLegalEntity(legalEntity);
+      userEvents.addTaskEvent("Success", {
+        actionType: "submit",
+        countryOfRegistration: dataSubmitted.personalDetails?.residencyCountry,
+        roles: dataSubmitted.personalDetails?.role
+      });
+    } else {
+      const patchLegalEntity = { ...drop("type").from(legalEntity), id: existingLeId };
+      updatedLegalEntity = await updateLegalEntity(patchLegalEntity);
+      userEvents.addTaskEvent("Success", {
+        actionType: "submit",
+        countryOfRegistration: dataSubmitted.personalDetails?.residencyCountry,
+        documentType: idDocumentType
+      });
+    }
+    return updatedLegalEntity;
+  };
+  const { mutateAsync: getIdVerificationStartCheck } = useIdVerificationStartCheck();
+  const handleInstantIdVerificationStartCheck = async (onfidoResponse, legalEntityId) => {
+    const providerId = idVerificationProviderId.value;
+    if (!providerId) throw Error("idVerificationProviderId not yet set");
+    const data2 = {
+      providerId,
+      legalEntityId,
+      captureMetadata: onfidoResponse
+    };
+    await getIdVerificationStartCheck(data2);
+  };
+  const submitDocuments = async ({
+    forms: forms2,
+    legalEntity,
+    dataSubmitted
+  }) => {
+    if (!isDocumentsRequired(forms2)) return;
+    if (dataSubmitted.idDocument?.instantIdVerificationData) {
+      if (providerStatus?.statuses?.idDocument?.enabled === false) {
+        throw new Error("Provider unexpectedly disabled instant verification flow");
+      }
+      await handleInstantIdVerificationStartCheck(
+        dataSubmitted.idDocument.instantIdVerificationData,
+        legalEntity.id
+      );
+    } else {
+      const formattedDocuments = await mapIndividualDocumentToApiDocument(
+        dataSubmitted,
+        legalEntity.id
+      );
+      if (!formattedDocuments || formattedDocuments.length === 0) {
+        if (existingAttachments?.length)
+          logger$1.log(
+            "User has already uploaded documents and is not changing them, nothing needs to be done"
+          );
+        else
+          logger$1.error(
+            `formattedDocuments is empty, but there are no existing documents. Something has gone wrong`
+          );
+        return;
+      }
+      formattedDocuments[0].attachments = mergeAttachments(
+        existingAttachments ?? [],
+        formattedDocuments[0]?.attachments ?? []
+      ).filter((attachment) => attachment.content);
+      const uploadedDocuments = await documentUtils.uploadDocuments(
+        formattedDocuments,
+        legalEntity.id
+      );
+      uploadedDocuments?.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
+        });
+      });
+    }
+  };
+  const hasRolesChanged = (legalEntity, existingEntityAssociations, newRoles) => {
+    const existingRoles = existingEntityAssociations?.filter((ea) => ea.legalEntityId === legalEntity.id)?.map(({ type }) => type);
+    return !doArraysMatch(existingRoles, newRoles);
+  };
+  const attachAssociationToParentLegalEntity = async ({
+    legalEntity,
+    parentLE,
+    dataSubmitted
+  }) => {
+    const newRoles = taskType === TaskTypes.DECISION_MAKER || taskType === TaskTypes.TRUST_MEMBER_COMPANY_OWNER || taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY_OWNER ? dataSubmitted?.personalDetails?.role : taskType === TaskTypes.TRUST_MEMBER_INDIVIDUAL || taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_INDIVIDUAL ? trustMember?.roles : null;
+    const existingEntityAssociations = getOwnEntityAssociations(parentLE);
+    if (newRoles && (hasRolesChanged(legalEntity, existingEntityAssociations, newRoles) || dataFromResponse.personalDetails?.jobTitle !== dataSubmitted?.personalDetails?.jobTitle || hasNomineesChanged(dataFromResponse.personalDetails, dataSubmitted.personalDetails))) {
+      const updatedParentLegalEntity = {
+        entityAssociations: [
+          ...newRoles.map((role) => ({
+            type: role,
+            legalEntityId: legalEntity.id,
+            ...DECISION_MAKER_TYPES_WITH_JOBTITLE.some((type) => type === role) && {
+              jobTitle: dataSubmitted?.personalDetails?.jobTitle
+            }
+          })) || [],
+          ...existingEntityAssociations.filter((ea) => ea.legalEntityId !== legalEntity.id) || []
+        ]
+      };
+      if (updatedParentLegalEntity.entityAssociations) {
+        updatedParentLegalEntity.entityAssociations = updatedParentLegalEntity.entityAssociations.map(
+          (ea) => attachNomineeToRole(ea, country, dataSubmitted.personalDetails)
+        );
+      }
+      await updateLegalEntity({ ...updatedParentLegalEntity, id: parentLE.id });
+    }
+    if (taskType === TaskTypes.LEGAL_REPRESENTATIVE_DETAILS && (existingEntityAssociations.every((ea) => ea.legalEntityId !== legalEntity.id) || dataFromResponse?.personalDetails?.relationship !== dataSubmitted?.personalDetails?.relationship)) {
+      const newEntityAssociation = {
+        type: "legalRepresentative",
+        legalEntityId: legalEntity.id,
+        relationship: dataSubmitted?.personalDetails?.relationship
+      };
+      const updatedParentLegalEntity = {
+        entityAssociations: [newEntityAssociation, ...existingEntityAssociations]
+      };
+      await updateLegalEntity({ ...updatedParentLegalEntity, id: parentLE.id });
+    }
+  };
+  const onSubmit = async () => {
+    setLoadingStatus("loading");
+    const dataSubmitted = omitObscuredFieldsIfUnchanged(
+      individualObscuredFields,
+      data,
+      dataFromResponse
+    );
+    if (!dataSubmitted) {
+      return;
+    }
+    try {
+      const legalEntity = mapIndividualToLegalEntity(dataSubmitted);
+      const idDocumentType = idDocumentTypeOptions.find(
+        ({ id }) => dataSubmitted?.idDocument?.idDocumentType === id
+      )?.id;
+      legalEntity.entityAssociations = filterOutUnwantedAssociationsIfRootLE(
+        taskType,
+        legalEntityResponse,
+        accountHolder || void 0
+      );
+      const createdLegalEntity = await submitLegalEntity({
+        dataSubmitted,
+        legalEntity,
+        idDocumentType
+      });
+      setAccountHolder(accountHolder);
+      await submitDocuments({ forms, legalEntity: createdLegalEntity, dataSubmitted });
+      if (parentLegalEntity) {
+        await attachAssociationToParentLegalEntity({
+          legalEntity: createdLegalEntity,
+          parentLE: parentLegalEntity,
+          dataSubmitted
+        });
+      }
+      setLoadingStatus("success");
+      clearToasts();
+      externalOnSubmit?.(dataSubmitted);
+    } catch (e) {
+      logger$1.error("Failed to update individual", e);
+      if (isValidationError(e)) {
+        setValidationErrors(processValidationErrors(e, TaskTypes.INDIVIDUAL));
+      } else if (isMaintenanceModeError(e)) {
+        showToast({
+          label: i18n.get("maintenanceModeMessage"),
+          variant: "error",
+          duration: "indefinite"
+        });
+      } else {
+        showToast({ label: i18n.get("failedToUpdateDetails"), variant: "error" });
+      }
+      setLoadingStatus("success");
+      userEvents.addTaskEvent("Encountered error", {
+        actionType: "submit",
+        returnType: e.errorCode,
+        returnValue: e.title
+      });
+    }
+  };
+  const isDocumentsRequired = (forms2) => forms2.some((form2) => individualDocumentForms.includes(form2.formId));
+  const datasetUtils = datasetUtilities(i18n.locale);
+  const formatIdDocument = (idDocument2) => {
+    if (!idDocument2) return void 0;
+    const documentType = idDocument2?.instantIdVerificationData ? onfidoDocumentTypeMapping.find(
+      (document2) => idDocument2.instantIdVerificationData?.document_front.type === document2.id
+    ) : idDocumentTypeOptions.find(({ id }) => idDocument2.idDocumentType === id);
+    if (!documentType) return void 0;
+    const frontPage = idDocument2.idFrontPage?.[0];
+    const backPage = idDocument2.idBackPage?.[0];
+    if (!frontPage) return void 0;
+    return {
+      documentType: i18n.get(documentType.name),
+      ...backPage && documentType.hasBackPage ? {
+        frontPage: frontPage.name,
+        backPage: backPage.name
+      } : {
+        fileName: frontPage.name
+      }
+    };
+  };
+  const formatFileSummaryData = ({
+    idDocument: idDocument2,
+    proofOfNationalId,
+    proofOfResidency,
+    proofOfRelationship
+  }) => {
+    const proofOfNationalIdFile = proofOfNationalId?.proofOfNationalId?.[0];
+    const proofOfResidencyFile = proofOfResidency?.proofOfResidency?.[0];
+    const proofOfRelationshipFile = proofOfRelationship?.proofOfRelationship?.[0];
+    return {
+      ...(idDocument2?.idDocumentType || idDocument2?.instantIdVerificationData) && {
+        idDocument: formatIdDocument(idDocument2)
+      },
+      ...proofOfNationalIdFile && {
+        proofOfNationalId: {
+          fileName: proofOfNationalIdFile.name
+        }
+      },
+      ...proofOfResidencyFile && {
+        proofOfResidency: {
+          fileName: proofOfResidencyFile.name
+        }
+      },
+      ...proofOfRelationshipFile && {
+        proofOfRelationship: {
+          fileName: proofOfRelationshipFile.name
+        }
+      }
+    };
+  };
+  const formatDataForSummary = () => {
+    let summaryData = cloneObject(data);
+    if (summaryData.personalDetails?.residencyCountry) {
+      summaryData.personalDetails.residencyCountry = datasetUtils.getCountryName(
+        summaryData.personalDetails.residencyCountry
+      );
+    }
+    if (summaryData.personalDetails?.nationality) {
+      summaryData.personalDetails.nationality = datasetUtils.getCountryName(
+        summaryData.personalDetails.nationality
+      );
+    }
+    if (summaryData.address) {
+      summaryData.address = mapAddressLabels(summaryData.address, datasetUtils);
+    }
+    if (isDocumentsRequired(forms)) {
+      individualDocumentForms.forEach((formId) => delete summaryData[formId]);
+      summaryData = { ...summaryData, ...formatFileSummaryData(data) };
+    }
+    if (summaryData.personalDetails?.accountHolder) {
+      summaryData.personalDetails.accountHolder = i18n.get(
+        summaryData.personalDetails.accountHolder
+      );
+    }
+    if (summaryData.personalDetails?.birthDate) {
+      summaryData.personalDetails.birthDate = localizeDateString(
+        summaryData.personalDetails.birthDate,
+        i18n.locale
+      );
+    }
+    if (summaryData.personalDetails?.phoneNumber) {
+      delete summaryData.personalDetails.phoneNumber;
+      summaryData.personalDetails.phoneNumber = data.personalDetails?.phoneNumber?.number;
+    }
+    if (summaryData.personalDetails?.taxInformation) {
+      const taxInformation = summaryData.personalDetails.taxInformation.find(
+        (taxId) => taxId.country === data.personalDetails?.nationality
+      );
+      if (taxInformation) {
+        delete summaryData.personalDetails.taxInformation;
+        summaryData.personalDetails[taxInformation.type] = taxInformation.number;
+      }
+    }
+    return summaryData;
+  };
+  const summaryOmittedKeys = [
+    ...taskType === TaskTypes.DECISION_MAKER ? ["role"] : [],
+    ...data?.personalDetails?.idNumberExempt ? ["idNumber"] : []
+  ];
+  const {
+    handleNextClick,
+    handleBackClick,
+    activeForm,
+    shouldValidate,
+    gotoFormByFormIndex,
+    steps
+  } = useFormComposer({
+    problems,
+    externalBackClick,
+    forms,
+    onSubmit,
+    triggerValidation: form.triggerValidation
+    // TODO: figure out type of nested keys
+  });
+  return /* @__PURE__ */ jsx(FormContextProvider, { form, children: /* @__PURE__ */ jsx(
+    FormFlow,
+    {
+      summary: {
+        data: formatDataForSummary(),
+        omitted: {
+          keys: summaryOmittedKeys
+        },
+        problems
+      },
+      asModal,
+      currentStep: steps.current,
+      disableNextButton: hideFooter,
+      forms,
+      gotoFormByFormIndex,
+      handleBackClick,
+      handleCancelClick: handleHomeClick,
+      handleNextClick,
+      loadingStatus,
+      totalSteps: steps.total,
+      children: /* @__PURE__ */ jsx(
+        Individual,
+        {
+          ...derivedProps,
+          data,
+          country,
+          activeForm,
+          forms,
+          taskType,
+          problems,
+          onNext: handleNextClick,
+          onBack: handleBackClick,
+          setHideFooter,
+          legalEntityId: legalEntityResponse?.id,
+          allowedRoles: roleTypes,
+          shouldValidate,
+          accountHolder,
+          parentLegalEntity,
+          trustedFields: !parentLegalEntity ? trustedFields : associatedLegalEntityTrustedFields,
+          trustedFieldsProvider,
+          trustedRoles
+        }
+      )
+    }
+  ) });
+}
+const isNotOutOfRangeBirthDateValidatorRule = {
+  modes: ["blur"],
+  validate: (birthDate) => !isEmpty(birthDate) && new Date(birthDate) < /* @__PURE__ */ new Date(),
+  errorMessage: "invalidDateOfBirth"
+};
+const buildMinimumAgeValidationRule = (minimumAge) => ({
+  modes: ["blur"],
+  validate: (birthDate) => !!birthDate && getAgeToday(birthDate) >= minimumAge,
+  errorMessage: {
+    key: "youMustXYearsOldToContinue",
+    values: { minimumAge: minimumAge.toString() }
+  }
+});
+const 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);
+  }
+};
+const additionalPersonalDetailsValidators = ({
+  country,
+  isExperimentEnabled = () => false,
+  isSettingEnabled = () => false,
+  taskType,
+  idNumberType,
+  idNumberExempt,
+  idNumber,
+  existingIdNumber,
+  formVerificationErrors,
+  i18n,
+  taxIdNumberType
+}) => ({
+  taxInformation: resolveFieldMetadata(
+    taxInformationDefaultFieldConfig[country],
+    {
+      taxIdNumberType,
+      companyType: LegalEntityTypes.INDIVIDUAL
+    },
+    taxInformationDefaultFieldMetadata
+  )?.validators,
+  birthDate: (() => {
+    const baseValidators = [isNotOutOfRangeBirthDateValidatorRule];
+    if (isSettingEnabled("enforceLegalAge")) {
+      return [...baseValidators, buildMinimumAgeValidationRule(18)];
+    }
+    if (isExperimentEnabled("EnableAgeVerification")) {
+      if (taskType === TaskTypes.LEGAL_REPRESENTATIVE_DETAILS) {
+        return [...baseValidators, buildMinimumAgeValidationRule(18)];
+      }
+      return [...baseValidators, getCountrySpecificMinimumAgeValidationRule(country)];
+    }
+    return baseValidators;
+  })(),
+  ...isExperimentEnabled("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
+    )?.validators;
+  })(),
+  ...addressValidators({
+    isExperimentEnabled,
+    country,
+    i18n
+  })
+});
+const basicDetailsValidators = ({
+  isExperimentEnabled = () => false
+}) => ({
+  ...contactDetailsValidationRules,
+  ...isExperimentEnabled("StrictNameAndAddressValidationV4") ? nameValidationRulesV4 : void 0
+});
+const 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 };
+      }
+    }
+  });
+};
+const 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
+  });
+};
+const idNowProviderStartIdentification = async (rootLegalEntityId, baseUrl, legalEntityId) => {
+  return httpPost({
+    baseUrl,
+    path: `legalEntities/${rootLegalEntityId}/child/${legalEntityId}/provider/idnow/identification/start`
+  });
+};
+const 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
+  });
+};
+const idnowHeader = "adyen-kyc-idnow-header";
+const idnowVerificationHeaderIframeContainer = "adyen-kyc-idnow-verification-header-iframe-container";
+const idnowVerificationHeaderIframe = "adyen-kyc-idnow-verification-header-iframe";
+const idnowVerificationHeaderImage = "adyen-kyc-idnow-verification-header-image";
+const styles = {
+  idnowHeader,
+  idnowVerificationHeaderIframeContainer,
+  idnowVerificationHeaderIframe,
+  idnowVerificationHeaderImage
+};
+const passportFrontGreenImage = lazy(
+  () => import("./passport-front-green-BL4HmtsB.js")
+);
+const isIdNowSuccessful = (status) => {
+  const providerStatus = status?.providerStatus;
+  return providerStatus === "SUCCESS" || providerStatus === "SUCCESS_DATA_CHANGED" || providerStatus === "REVIEW_PENDING";
+};
+const IdNowVerificationModal = ({ handleFinish }) => {
+  const { t } = useTranslation(["individual", "common"]);
+  const [isConfirmPresented, setIsConfirmPresented] = useState(false);
+  const [genericError, setGenericError] = useState(false);
+  const widgetContainerRef = useRef(null);
+  const iFrameRef = useRef(null);
+  const iFrameWidgetRef = useRef(null);
+  const [page, setPage] = useState(1);
+  const queryClient = useQueryClient();
+  const { showToast } = useToastContext();
+  const {
+    data: idNowStatus,
+    isLoading: isStatusLoading,
+    refetch: refetchIdNowIdentificationStatus
+  } = useIdNowIdentificationStatus(idNowModalChildEntityId.value?.id ?? skipToken, {
+    enabled: !!idNowModalChildEntityId.value?.id,
+    refetchOnMount: "always",
+    refetchInterval: 1e4,
+    // poll every 10 seconds
+    retry: (failureCount, error) => {
+      if ("status" in error && error.status === 404) 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();
+    handleFinish?.();
+  };
+  if (idNowStatus?.status === "finished") {
+    if (isIdNowSuccessful(idNowStatus)) {
+      showToast({
+        label: t(($) => $["successfullyUpdatedDetails"], { ns: "common" }),
+        variant: "success"
+      });
+      handleConfirmDismiss();
+    } else {
+      if (page === 2) {
+        handleConfirmDismiss();
+      }
+    }
+  }
+  if (!isLoading && idNowStartError) {
+    setGenericError(true);
+    setPage(1);
+  }
+  const initializeIdNowWidget = useCallback(async (url) => {
+    const container = widgetContainerRef.current;
+    if (!container) {
+      return;
+    }
+    const iFrame = document.createElement("iframe");
+    iFrameRef.current = iFrame;
+    iFrame.setAttribute("allowFullscreen", "true");
+    iFrame.classList.add(styles.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(() => {
+    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, { children: [
+    !isStatusLoading && /* @__PURE__ */ jsxs(
+      Modal,
+      {
+        size: page === 2 ? "large" : "medium",
+        showCloseButton: !isLoading && !isStatusLoading,
+        onClose: handleDismiss,
+        ariaLabel: t(($) => $["identityVerification"], { ns: "common" }),
+        children: [
+          page === 1 && /* @__PURE__ */ jsx("div", { className: styles.idnowHeader, children: /* @__PURE__ */ jsx(
+            LandingLayout,
+            {
+              media: /* @__PURE__ */ jsx(
+                Image,
+                {
+                  className: styles.idnowVerificationHeaderImage,
+                  lazyLoadedImage: passportFrontGreenImage
+                }
+              ),
+              title: t(($) => $["identityVerification"], { ns: "common" }),
+              description: /* @__PURE__ */ jsxs(Fragment, { 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 ? /* @__PURE__ */ jsx(
+                Alert,
+                {
+                  variant: "error",
+                  title: t(($) => $["thereWasAnErrorTryAgain"], { ns: "common" })
+                }
+              ) : void 0,
+              actions: /* @__PURE__ */ jsxs(Fragment, { 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: t(($) => $["finishLater"], { ns: "common" })
+                  }
+                )
+              ] })
+            }
+          ) }),
+          page === 2 && (isLoading ? /* @__PURE__ */ jsx(Loader, {}) : /* @__PURE__ */ jsx(
+            "div",
+            {
+              ref: widgetContainerRef,
+              className: styles.idnowVerificationHeaderIframeContainer
+            }
+          ))
+        ]
+      }
+    ),
+    isConfirmPresented && /* @__PURE__ */ jsx(
+      Confirm,
+      {
+        confirmText: t(($) => $["leave"], { ns: "common" }),
+        onCancel: handleCancelDismiss,
+        onConfirm: handleConfirmDismiss,
+        title: t(($) => $["unsavedChanges"], { ns: "common" })
+      }
+    )
+  ] });
+};
+const adjustOnfidoIdentificationData = (data, apiData) => {
+  const { typeOfIdentity, idNumber, idNumberExempt } = data;
+  const identificationData = {
+    ...apiData,
+    number: idNumber,
+    type: getOnfidoIdentityTypeToApiIdentityTypeMap(data)[typeOfIdentity] ?? "nationalIdNumber"
+  };
+  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
+      };
+  }
+};
+const mapIndividualOnfidoSchemaToLegalEntity = (individualOnfido, isExperimentEnabled, matchingScenario) => {
+  const legalEntity = {
+    ...formatObject(individualOnfido, individualOnfidoApiKeyMapping),
+    type: LegalEntityTypes.INDIVIDUAL
+  };
+  if (individualOnfido.additionalPersonalDetails) {
+    if (isExperimentEnabled("EnableTaxIdRequiredForBusinessAccountsScenarios") && matchingScenario?.includes(Scenarios.L_TAXINFO) && individualOnfido.additionalPersonalDetails?.idNumber && individualOnfido.additionalPersonalDetails?.typeOfIdentity && individualOnfido.additionalPersonalDetails?.country === CountryCodes.Spain) {
+      legalEntity.individual.taxInformation = [
+        {
+          country: individualOnfido.additionalPersonalDetails.country,
+          number: individualOnfido.additionalPersonalDetails.idNumber,
+          type: individualOnfido.additionalPersonalDetails.typeOfIdentity.toUpperCase()
+        }
+      ];
+    }
+    legalEntity.individual.identificationData = adjustOnfidoIdentificationData(
+      individualOnfido.additionalPersonalDetails,
+      legalEntity.individual.identificationData
+    );
+  }
+  const nameLocalization = [
+    mapSchemaFieldsToApiScriptLocalization(individualOnfido.basicDetails ?? {}, "jaHani"),
+    mapSchemaFieldsToApiScriptLocalization(individualOnfido.basicDetails ?? {}, "jaKana")
+  ].filter(({ fields }) => !isEmpty$1(fields));
+  if (nameLocalization.length) {
+    legalEntity.individual.name.localization = nameLocalization;
+  }
+  const addressLocalizations = mapJpAddressSchemaToAddressLocalizations(
+    individualOnfido.additionalPersonalDetails
+  );
+  if (addressLocalizations.length > 0)
+    legalEntity.individual.residentialAddress.localization = addressLocalizations;
+  if (individualOnfido.basicDetails?.phoneNumber) {
+    const phone = {
+      number: individualOnfido.basicDetails.phoneNumber.number,
+      type: "mobile"
+    };
+    if (phone.number && legalEntity.individual) {
+      legalEntity.individual.phone = phone;
+    } else {
+      delete legalEntity?.individual?.phone;
+    }
+  }
+  return legalEntity;
+};
+const 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"
+  },
+  address: {
+    rule: "addressIfRequiredForCountry"
+  },
+  otherAddressInformation: {
+    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"
+  },
+  nomineeDirector: {
+    rules: ["isGuidedDecisionMakersFlowDisabled", "nomineeDirectorRequiredForCountry"]
+  },
+  nomineeShareholder: {
+    rules: ["isGuidedDecisionMakersFlowDisabled", "nomineeShareHolderRequiredForCountry"]
+  },
+  idVerificationMethod: {
+    rule: "isIdVerificationMethodRequired"
+  },
+  idDocument: {
+    // (either from Onfido or previously-uploaded document)
+    rule: "isUsingInstantVerificationOrHasExistingDocument"
+  },
+  idDocumentType: {
+    // If the user has a missing ID error and chooses manual flow
+    rule: "isManualIdFlowAndHasMissingData"
+  },
+  /**
+   * Below fields only relevant if manual ID is needed
+   * @see identityNumber
+   * @see idDocRequired
+   */
+  idFrontPage: {
+    rule: "hasChosenIdType"
+  },
+  idBackPage: {
+    rule: "backPageIfRequiredForIdType"
+  },
+  // Fields required for Guided decision makers flow
+  isSignatory: {
+    rules: ["isGuidedDecisionMakersFlowEnabled", "requiredIfDecisionMakerTask"]
+  },
+  isOwner: {
+    rules: ["isGuidedDecisionMakersFlowEnabled", "requiredIfDecisionMakerTask"]
+  },
+  isControllingPerson: {
+    rules: ["isGuidedDecisionMakersFlowEnabled", "requiredIfDecisionMakerTask"]
+  },
+  isDirector: {
+    rules: [
+      "isGuidedDecisionMakersFlowEnabled",
+      "requiredIfDecisionMakerTask",
+      "isDirectorRequiredForCountry"
+    ]
+  },
+  isNomineeDirector: {
+    rules: [
+      "isGuidedDecisionMakersFlowEnabled",
+      "requiredIfDecisionMakerTask",
+      "nomineeDirectorRequiredForCountry"
+    ]
+  },
+  isNomineeShareholder: {
+    rules: [
+      "isGuidedDecisionMakersFlowEnabled",
+      "requiredIfDecisionMakerTask",
+      "nomineeShareHolderRequiredForCountry"
+    ]
+  },
+  // Japanese name fields
+  jaHaniFirstName: {
+    rule: "japanSpecificField"
+  },
+  jaHaniLastName: {
+    rule: "japanSpecificField"
+  },
+  jaKanaFirstName: {
+    rule: "japanSpecificField"
+  },
+  jaKanaLastName: {
+    rule: "japanSpecificField"
+  },
+  // Japanese address fields
+  jaHaniAddress: {
+    rule: "japanSpecificField"
+  },
+  jaHaniCity: {
+    rule: "japanSpecificField"
+  },
+  jaHaniStateOrProvince: {
+    rule: "japanSpecificField"
+  },
+  jaKanaCity: {
+    rule: "japanSpecificField"
+  },
+  jaKanaStateOrProvince: {
+    rule: "japanSpecificField"
+  }
+};
+const identityNumber = {
+  idNumber: {
+    rule: "idNumberRules",
+    obscured: true
+  },
+  idNumberExempt: {
+    rules: ["idNumberExemptIfApplicableCountry", "isDirectorIdNumberRequiredForCountry"]
+  },
+  idDocumentType: {
+    // If the user chooses to not provide an ID number, we'll need an ID from them
+    rule: "isManualIdFlowAndNotProvidingIdNumber"
+  }
+};
+const additionalIdentityInfo = {
+  typeOfIdentity: {
+    rules: ["requiredIfCountryUsesMultipleTypesOfIdentity", "isDirectorIdNumberRequiredForCountry"]
+  },
+  issuerState: {
+    rule: "issuerStateRequired"
+  },
+  licenseCardNumber: {
+    rule: "licenseCardNumberRules"
+  },
+  expiryDate: {
+    rule: "expiryDateRequired"
+  }
+};
+const idDocRequired = {
+  // These fields are relevant for the manual ID flow only.
+  // If we get `L1_IDDOC` then we know we need to require a manual ID upload when the manual flow is used
+  idDocumentType: {
+    rule: "isManualIdFlow"
+  }
+};
+const nationality = {
+  nationality: {
+    rule: "REQUIRED"
+  }
+};
+const phoneNumberBase = {
+  phoneNumber: {
+    rule: "contactsIfRequiredForRole"
+  }
+};
+const taxInformationBase = {
+  taxInformation: { rule: "countryUsesTaxId" }
+};
+const individualOnfidoFieldsPerScenario = {
+  L0: drop("address", "birthDate").from(identityOnfidoBase),
+  L1: identityOnfidoBase,
+  L1_ID: {
+    ...identityOnfidoBase,
+    ...identityNumber,
+    ...additionalIdentityInfo
+  },
+  L1_IDO: {
+    // TODO: change idNumber rule to optional once optional fields are implemented
+    ...identityOnfidoBase,
+    ...identityNumber,
+    ...additionalIdentityInfo
+  },
+  L1_NAT: {
+    ...identityOnfidoBase,
+    ...identityNumber,
+    ...additionalIdentityInfo,
+    ...nationality
+  },
+  L_TAXINFO: { ...identityOnfidoBase, ...taxInformationBase },
+  L1_IDDOC: idDocRequired,
+  L_PH: phoneNumberBase
+};
+const parseIndividualOnfidoScenarios = (scenarios) => composePerScenarioFormConfigurations(scenarios, individualOnfidoFieldsPerScenario);
+const parseConfiguration = ({ scenarios }) => parseIndividualOnfidoScenarios(scenarios);
+const logger = createLogger();
+function IndividualOnfidoDropin({
+  taskType = TaskTypes.INDIVIDUAL,
+  parentLegalEntity,
+  legalEntityResponse,
+  handleHomeClick,
+  isTargetLegalEntityType,
+  country: parentCountry,
+  problems: propProblems,
+  onSubmit: externalOnSubmit,
+  asModal = false,
+  handleBackClick: externalBackClick,
+  trustedFields,
+  trustedFieldsProvider,
+  trustedRoles
+}) {
+  const { baseUrl, rootLegalEntityId } = useApiContext();
+  const { accountHolder, setAccountHolder } = useAccountHolder();
+  const { i18n } = useI18nContext();
+  const { t } = useTranslation("individual");
+  const userEvents = useAnalyticsContext();
+  const { showToast, clearToasts } = useToastContext();
+  const { isExperimentEnabled } = useExperimentsContext();
+  const { isSettingEnabled } = useSettingsContext();
+  const queryClient = useQueryClient();
+  const isGuidedDecisionMakersFlowEnabled = isExperimentEnabled("EnableGuidedDecisionMakersFlow") || isExperimentEnabled("DecisionMakersFlowOptimization_GuidedDecisionMakersFlow");
+  const isGuidedDecisionMakersFlowDisabled = isExperimentEnabled("DisableGuidedDecisionMakersFlow");
+  const defaultCountry = "NL";
+  const { data: providerStatus } = useProviderStatus({
+    providers: ["idDocument"],
+    country: legalEntityResponse ? getLegalEntityCountry(legalEntityResponse) : defaultCountry
+  });
+  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(() => {
+    if (legalEntityResponse) {
+      return mapLegalEntityToIndividualOnfidoSchema(
+        legalEntityResponse,
+        isTargetLegalEntityType,
+        isRoleFieldNeeded,
+        parentLegalEntity
+      );
+    }
+    return {
+      additionalPersonalDetails: {
+        country: parentCountry
+      }
+    };
+  }, [
+    legalEntityResponse,
+    parentCountry,
+    isTargetLegalEntityType,
+    isRoleFieldNeeded,
+    parentLegalEntity
+  ]);
+  const [matchingScenario, setMatchingScenario] = useState();
+  const [validationErrors, setValidationErrors] = useState();
+  const [loadingStatus, setLoadingStatus] = useState("success");
+  const [existingAttachments, setExistingAttachments] = useState();
+  const [documents, setDocuments] = useState();
+  const [country, setCountry] = useState(
+    dataFromResponse?.additionalPersonalDetails?.country ?? parentCountry
+  );
+  const [derivedProps, setDerivedProps] = useState();
+  const [nextHandler, setNextHandler] = useState();
+  const problems = useMemo(
+    () => ({
+      ...propProblems,
+      validationErrors
+    }),
+    [propProblems, validationErrors]
+  );
+  const hasVerificationErrors = propProblems?.verificationErrors && Object.keys(propProblems.verificationErrors).length > 0;
+  useEffect(() => {
+    userEvents.updateBaseTrackingPayload({ task: taskType });
+    userEvents.addTaskEvent("Landed on page", {
+      actionType: "start"
+    });
+  }, []);
+  const individualFieldValidations = useCallback(
+    (data2) => ({
+      basicDetails: basicDetailsValidators({
+        isExperimentEnabled
+      }),
+      additionalPersonalDetails: additionalPersonalDetailsValidators({
+        country: data2?.additionalPersonalDetails?.country ?? country,
+        isExperimentEnabled,
+        isSettingEnabled,
+        taskType,
+        idNumberType: data2?.additionalPersonalDetails?.typeOfIdentity,
+        idNumberExempt: data2?.additionalPersonalDetails?.idNumberExempt,
+        idNumber: data2?.additionalPersonalDetails?.idNumber,
+        existingIdNumber: dataFromResponse.additionalPersonalDetails?.idNumber,
+        formVerificationErrors: problems?.verificationErrors?.additionalPersonalDetails,
+        i18n,
+        taxIdNumberType: data2?.additionalPersonalDetails?.taxInformation?.length ? data2?.additionalPersonalDetails?.taxInformation[0]?.type : void 0
+      })
+    }),
+    [
+      country,
+      dataFromResponse.additionalPersonalDetails?.idNumber,
+      i18n,
+      isExperimentEnabled,
+      isSettingEnabled,
+      problems?.verificationErrors?.additionalPersonalDetails,
+      taskType
+    ]
+  );
+  const validatePhoneNumber = useValidatePhoneNumberImperatively();
+  const { mutateAsync: verifyIdNumber2 } = useVerifyIdNumber();
+  const individualFieldAsyncValidations = useCallback(
+    (data2) => ({
+      basicDetails: {
+        phoneNumber: getAsyncPhoneValidationRules(validatePhoneNumber).phoneNumber
+      },
+      additionalPersonalDetails: {
+        idNumber: getAsyncIdNumberValidationRule(verifyIdNumber2, data2?.additionalPersonalDetails).idNumber
+      }
+    }),
+    [verifyIdNumber2, validatePhoneNumber]
+  );
+  const defaultData = useMemo(() => {
+    if (!documents) return dataFromResponse;
+    return {
+      ...dataFromResponse,
+      ...drop("idDocument").from(documents),
+      idVerificationMethod: {
+        idDocument: documents.idDocument,
+        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(() => {
+    setCountry(data?.additionalPersonalDetails?.country ?? parentCountry);
+  }, [data?.additionalPersonalDetails?.country, parentCountry]);
+  const { data: scenarios } = useScenarios(country, LegalEntityTypes.INDIVIDUAL);
+  useEffect(() => {
+    if (!scenarios) return;
+    setHasMotionCaptureScenario(scenarios);
+    setMatchingScenario(scenarios);
+  }, [scenarios]);
+  const { fieldConfigurations } = useScenarioConfiguration({
+    parseConfiguration,
+    legalEntityType: LegalEntityTypes.INDIVIDUAL,
+    setLoadingStatus,
+    country
+  });
+  const fieldsFromCustomRules = useMemo(
+    () => individualOnfidoRules({
+      matchingScenario,
+      data,
+      country: data?.additionalPersonalDetails?.country ?? country,
+      taskType,
+      isExperimentEnabled,
+      rootLegalEntity: parentLegalEntity,
+      problems
+    }),
+    [country, matchingScenario, data, isExperimentEnabled, parentLegalEntity, taskType, problems]
+  );
+  useEffect(() => {
+    const derivedProps2 = getPropsFromConfigurations({
+      scenarioConfiguration: fieldConfigurations,
+      forms: individualOnfidoForms,
+      remediationActions: problems?.remediationActions ? Object.values(problems?.remediationActions) : [],
+      dataMissingErrors: problems?.missingData ?? [],
+      fieldsWithExistingData: legalEntityResponse ? getFieldsWithExistingData(
+        legalEntityResponse,
+        individualOnfidoApiKeyMapping,
+        individualOnfidoDocumentMapping,
+        [
+          "additionalPersonalDetails.typeOfIdentity",
+          "additionalPersonalDetails.idNumber",
+          "additionalPersonalDetails.stateOrProvince",
+          "additionalPersonalDetails.issuerState"
+        ]
+      ) : [],
+      customRules: fieldsFromCustomRules,
+      legalEntityType: legalEntityResponse?.type,
+      legalEntityTrustedFields: [],
+      remediationFieldAsOptional: true
+    });
+    const updatedDerivedProps = mandateIdVerificationForMotionCapture(
+      showIndividualMotionCapture?.value,
+      derivedProps2
+    );
+    if (updatedDerivedProps) {
+      setDerivedProps(updatedDerivedProps);
+    }
+  }, [
+    fieldConfigurations,
+    legalEntityResponse,
+    fieldsFromCustomRules,
+    problems?.remediationActions,
+    problems?.missingData
+  ]);
+  useEffect(() => {
+    if (!legalEntityResponse?.documentDetails?.length) return;
+    documentUtils.fetchDocuments(legalEntityResponse.documentDetails, legalEntityResponse?.id).then((res) => {
+      setExistingAttachments(res[0].attachments);
+      setDocuments(mapApiDocumentToIndividualDocuments(legalEntityResponse?.id));
+    }).catch(() => {
+      showToast({ label: i18n.get("failedToFetchRelevantDocuments"), variant: "error" });
+    });
+  }, []);
+  const forms = useMemo(() => {
+    const requiredForms = getRequiredForms(
+      individualOnfidoForms,
+      derivedProps?.requiredFields,
+      derivedProps?.optionalFields
+    );
+    const filteredForms = !isInstantVerificationEnabled ? requiredForms.filter((f) => f.formId !== "idVerificationMethod") : requiredForms;
+    return addValidityToForms(filteredForms, form.isValid, problems);
+  }, [derivedProps, form.isValid, isInstantVerificationEnabled, problems]);
+  const { mutateAsync: getIdVerificationStartCheck } = useIdVerificationStartCheck();
+  const handleInstantIdVerificationStartCheck = async (onfidoResponse, legalEntityId) => {
+    const providerId = idVerificationProviderId.value;
+    if (!providerId) throw Error("idVerificationProviderId not yet set");
+    const data2 = {
+      providerId,
+      legalEntityId,
+      captureMetadata: onfidoResponse
+    };
+    await getIdVerificationStartCheck(data2);
+  };
+  const roleTypes = isRoleFieldNeeded && parentLegalEntity ? getAllowedDecisionMakerRoles(parentLegalEntity, taskType, matchingScenario) : [];
+  const { mutateAsync: createLegalEntity } = useCreateLegalEntity();
+  const idDocumentTypeOptions = getLocalizedIdDocumentTypeOptions(country);
+  const submitLegalEntity = async ({
+    dataSubmitted,
+    legalEntity,
+    idDocumentType
+  }) => {
+    let updatedLegalEntity;
+    const existingLeId = legalEntityResponse?.id;
+    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 submitDocuments = async ({
+    legalEntity,
+    dataSubmitted
+  }) => {
+    const idDocument2 = dataSubmitted.idVerificationMethod?.idDocument;
+    if (idDocument2?.instantIdVerificationData) {
+      if (providerStatus?.statuses?.idDocument?.enabled === false) {
+        throw new Error("Provider unexpectedly disabled instant verification flow");
+      }
+      await handleInstantIdVerificationStartCheck(
+        idDocument2.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.error(
+            `formattedDocuments is empty, but there are no existing documents. Something has gone wrong`
+          );
+        return;
+      }
+      formattedDocuments[0].attachments = mergeAttachments(
+        existingAttachments ?? [],
+        formattedDocuments[0]?.attachments ?? []
+      ).filter((attachment) => attachment.content);
+      const uploadedDocuments = await documentUtils.uploadDocuments(
+        formattedDocuments,
+        legalEntity.id
+      );
+      uploadedDocuments?.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
+        });
+      });
+    }
+  };
+  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
+  }) => {
+    const newRoles = taskType === TaskTypes.DECISION_MAKER || taskType === TaskTypes.TRUST_MEMBER_COMPANY_OWNER || taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY_OWNER ? dataSubmitted?.basicDetails?.role : null;
+    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$1.some((type) => type === role) && {
+              jobTitle: dataSubmitted?.basicDetails?.jobTitle
+            }
+          })) || [],
+          ...existingEntityAssociations.filter((ea) => ea.legalEntityId !== legalEntity.id) || []
+        ]
+      };
+      const nomineeDataSource = !isGuidedDecisionMakersFlowDisabled && isGuidedDecisionMakersFlowEnabled ? dataSubmitted?.uboQuestionnaire : dataSubmitted.basicDetails;
+      if (nomineeDataSource && updatedParentLegalEntity.entityAssociations) {
+        updatedParentLegalEntity.entityAssociations = updatedParentLegalEntity.entityAssociations.map(
+          (ea) => attachNomineeToRole(ea, country, nomineeDataSource)
+        );
+      }
+      await updateLegalEntity({ ...updatedParentLegalEntity, id: parentLE.id });
+    }
+  };
+  const onSubmit = async () => {
+    setLoadingStatus("loading");
+    const dataSubmitted = omitObscuredFieldsIfUnchanged(
+      individualOnfidoObscuredFields,
+      data,
+      dataFromResponse
+    );
+    if (!dataSubmitted) {
+      return;
+    }
+    try {
+      const legalEntity = mapIndividualOnfidoSchemaToLegalEntity(
+        dataSubmitted,
+        isExperimentEnabled,
+        matchingScenario
+      );
+      const idDocumentType = idDocumentTypeOptions.find(
+        ({ id }) => dataSubmitted?.idVerificationMethod?.idDocument?.idDocumentType === id
+      )?.id;
+      legalEntity.entityAssociations = filterOutUnwantedAssociationsIfRootLE(
+        taskType,
+        legalEntityResponse,
+        accountHolder || void 0
+      );
+      const submittedLegalEntity = await submitLegalEntity({
+        dataSubmitted,
+        legalEntity,
+        idDocumentType
+      });
+      setAccountHolder(accountHolder);
+      if (dataSubmitted.idVerificationMethod && dataSubmitted.idVerificationMethod?.idVerificationMethod !== "existingDocument" || hasVerificationErrors) {
+        const isBafinSignatory = dataSubmitted?.basicDetails?.role?.includes(DecisionMakerTypes.SIGNATORY) && matchingScenario?.includes(Scenarios.L_BAFIN);
+        if (!isBafinSignatory) {
+          await submitDocuments({ legalEntity: submittedLegalEntity, dataSubmitted });
+        }
+      }
+      if (parentLegalEntity) {
+        await attachAssociationToParentLegalEntity({
+          legalEntity: submittedLegalEntity,
+          parentLE: parentLegalEntity,
+          dataSubmitted
+        });
+        queryClient.invalidateQueries({
+          queryKey: ["legalEntity", parentLegalEntity.id],
+          refetchType: "all"
+        });
+      }
+      idNowModalChildEntityId.value = submittedLegalEntity;
+      setLoadingStatus("success");
+      clearToasts();
+      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: i18n.get("failedToUpdateDetails"), variant: "error" });
+          eventsAdditionalData.unmappedErrorNames = e.invalidFields?.map((field) => field.name).filter(Boolean);
+        } else {
+          setValidationErrors(getErrors);
+        }
+      } else if (isMaintenanceModeError(e)) {
+        showToast({
+          label: i18n.get("maintenanceModeMessage"),
+          variant: "error",
+          duration: "indefinite"
+        });
+      } else {
+        showToast({ label: i18n.get("failedToUpdateDetails"), variant: "error" });
+      }
+      setLoadingStatus("success");
+      userEvents.addTaskEvent("Encountered error", {
+        actionType: "submit",
+        additionalData: eventsAdditionalData,
+        returnType: e?.errorCode,
+        returnValue: e?.title || "backend"
+      });
+    }
+  };
+  const datasetUtils = datasetUtilities(i18n.locale);
+  const formatIdDocument = (idDocument2) => {
+    if (!idDocument2) return void 0;
+    const documentType = idDocument2?.instantIdVerificationData ? onfidoDocumentTypeMapping.find(
+      (document2) => idDocument2.instantIdVerificationData?.document_front.type === document2.id
+    ) : idDocumentTypeOptions.find(({ id }) => idDocument2.idDocumentType === id);
+    if (!documentType) return void 0;
+    const frontPage = idDocument2.idFrontPage?.[0];
+    const backPage = idDocument2.idBackPage?.[0];
+    if (!frontPage) return void 0;
+    return {
+      documentType: i18n.get(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 idDocument2 = idVerificationMethod?.idVerificationMethod === "manualVerification" ? manualIdUpload : idVerificationMethod?.idDocument;
+    return {
+      ...(idDocument2?.idDocumentType || idDocument2?.instantIdVerificationData) && {
+        idDocument: formatIdDocument(idDocument2)
+      },
+      ...proofOfNationalIdFile && {
+        proofOfNationalId: {
+          fileName: proofOfNationalIdFile.name
+        }
+      },
+      ...proofOfResidencyFile && {
+        proofOfResidency: {
+          fileName: proofOfResidencyFile.name
+        }
+      },
+      ...proofOfRelationshipFile && {
+        proofOfRelationship: {
+          fileName: proofOfRelationshipFile.name
+        }
+      }
+    };
+  };
+  const isManualVerificationOrExistingDoc = (idVerificationMethod) => idVerificationMethod === "manualVerification" || idVerificationMethod === "existingDocument";
+  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 (country === CountryCodes.Japan) {
+        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 = i18n.get(summaryData.basicDetails.accountHolder);
+    }
+    if (summaryData.additionalPersonalDetails?.birthDate) {
+      summaryData.additionalPersonalDetails.birthDate = localizeDateString(
+        summaryData.additionalPersonalDetails.birthDate,
+        i18n.locale
+      );
+    }
+    if (isManualVerificationOrExistingDoc(summaryData.idVerificationMethod?.idVerificationMethod) || summaryData.proofOfResidency) {
+      const fileSummaryData = formatFileSummaryData(data);
+      summaryData = { ...summaryData, ...fileSummaryData };
+      summaryData.manualIdUpload = { ...summaryData.idDocument };
+      summaryData.idVerificationMethod.idDocument = { ...summaryData.idDocument };
+    }
+    if (summaryData.additionalPersonalDetails?.taxInformation) {
+      const taxInformation = summaryData.additionalPersonalDetails.taxInformation.find(
+        (taxId) => taxId.country === data.additionalPersonalDetails?.nationality
+      );
+      if (taxInformation) {
+        delete summaryData.additionalPersonalDetails.taxInformation;
+        summaryData.additionalPersonalDetails[taxInformation.type] = taxInformation.number;
+      }
+    }
+    if (summaryData?.signatoryQuestionnaire) {
+      summaryData.signatoryQuestionnaire = data?.signatoryQuestionnaire?.isSignatory === GuidanceQuestionValues.YES ? [i18n.get("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]])] : []
+      );
+    }
+    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 = [
+    // 1. Omit idDocument if instant OR (manual/existing AND upload is empty)
+    ...data?.idVerificationMethod?.idVerificationMethod === "instantVerification" || isManualVerificationOrExistingDoc(data?.idVerificationMethod?.idVerificationMethod) && isUploadEmpty ? ["idDocument"] : [],
+    // 2. Omit idVerificationMethod if manual or existing
+    ...isManualVerificationOrExistingDoc(data?.idVerificationMethod?.idVerificationMethod) ? ["idVerificationMethod"] : []
+  ];
+  const customLabelsForSummary = {
+    idVerificationMethod: data?.idVerificationMethod?.idVerificationMethod === "instantVerification" ? "idVerificationMethod" : "idDocument"
+  };
+  const {
+    handleNextClick,
+    handleBackClick,
+    activeForm,
+    shouldValidate,
+    gotoFormByFormIndex,
+    steps
+  } = useFormComposer({
+    problems,
+    externalBackClick,
+    forms,
+    onSubmit,
+    triggerValidation: form.triggerValidation
+    // TODO: figure out type of nested keys
+  });
+  const disableNextButton = computed(() => {
+    const isVerificationMethod = activeForm?.formId === "idVerificationMethod";
+    return isVerificationMethod && !activeForm?.isValid || isNextStepDisabled.value;
+  });
+  return /* @__PURE__ */ jsxs(Fragment, { 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: disableNextButton.value,
+        forms,
+        gotoFormByFormIndex,
+        handleBackClick,
+        handleCancelClick: handleHomeClick,
+        handleNextClick: nextHandler || handleNextClick,
+        loadingStatus,
+        totalSteps: steps.total,
+        children: /* @__PURE__ */ jsx(
+          IndividualOnfido,
+          {
+            ...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
+          }
+        )
+      }
+    ) })
+  ] });
+}
+export {
+  IndividualOnfidoDropin as I,
+  IndividualDropin as a
+};