@adyen/kyc-components 4.0.0-compact.1 → 4.0.0-compact.3

package/dist/BusinessDetailsDropin-DDh_D2hv.js

@@ -0,0 +1,2359 @@
+;
+{
+  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] = "6bd99c14-1e9d-4878-bca1-7c53c4630e16", e._sentryDebugIdIdentifier = "sentry-dbid-6bd99c14-1e9d-4878-bca1-7c53c4630e16");
+  } catch (e) {
+  }
+}
+;
+import { jsx, jsxs, Fragment } from "preact/jsx-runtime";
+import { u as useTranslation, B as Button, G as Typography, C as CountryCodes, O as TaskTypes, r as LegalEntityTypes, W as isEmpty, a0 as entriesOf, bC as businessDetailsComponentsKeyMapping, bD as solePropBusinessDetailsKeyMapping, aj as objectsDeepEqual, ap as keysOf, i as isUndefinedOrNull, bE as solePropBusinessDetailsApiKeyMapping, bp as businessDetailsApiKeyMapping, P as createLogger, b8 as filterOutUnwantedAssociationsIfRootLE, b6 as drop, af as getOwnEntityAssociations, aV as doArraysMatch, b as useApiContext, a2 as useAnalyticsContext, a1 as useQueryClient, X as useExperimentsContext, o as useSettingsContext, K as useAccountHolder, bF as solePropBusinessDetailsDocumentMapping, bG as businessDetailsDocumentMapping } from "./StoreProvider-jtUYKLRz.js";
+import { useState, useEffect, useMemo, useCallback } from "preact/hooks";
+import { F as FinancialInformation, A as AdditionalInformation, C as CompanyStructure, B as BusinessSelection, h as BasicInformation, i as getDefaultRegistrationNumberType, j as getDefaultVatNumberType, o as operationalAddressIsSameIds, k as FIELDS_NEEDED_FOR_COMPANY_SEARCH, v as verifiedBusiness, l as isVerifiedSingleCompanySearchResult, m as companyTypeMetadata, p as documentFormsIds, r as registrationNumberDefaultFieldMetadata, q as inferCompanyRegistrationNumberType, s as registrationNumberDefaultFieldConfig, t as stockTickerSymbolFieldMetadata, w as stockISINFieldMetadata, x as stockExchangeMICFieldMetadata, y as dateOfIncorporationFieldMetadata, z as industryCodeFieldMetadata, D as eInvoicingCodeFieldMetadata, G as vatAbsenceReasonMetadata, H as exemptFromRegistrationNumberDefaultFieldMetadata, I as doingBusinessAsFieldMetadata, J as doingBusinessAsAbsentFieldMetadata, K as defaultFieldMetadata, L as defaultFieldConfig, M as defaultFieldMetadata$1, N as defaultFieldConfig$1, P as defaultFieldMetadataV4, Q as defaultFieldMetadata$2, R as defaultFieldConfigV4, S as defaultFieldConfig$2, g as getForms, T as useBusinessLines, U as financialInfoValidationWithEmployeesRules, V as tinMatched, W as businessMismatchModalOpen, X as useCompanySearch, Y as useVerifyTin, Z as handleCompanySelection, _ as applyVerifiedBusinessData } from "./OnboardingDropinComponent-D3dYF_4W.js";
+import { u as useCreateBusinessLine, a as useUpdateBusinessLine } from "./useUpdateBusinessLines-BulhyPjH.js";
+import { u as useCreateLegalEntity } from "./useCreateLegalEntity-BvvwB9r0.js";
+import { u as useUpdateLegalEntity } from "./useUpdateLegalEntity-Q3Icdeo6.js";
+import { F as FormContextProvider, a as FormFlow } from "./FormFlow-PppMJ6OA.js";
+import { a as useToastContext } from "./useToastContext-FI3dwzzs.js";
+import { c as composePerScenarioFormConfigurations, g as getPropsFromConfigurations } from "./process-field-configurations-N1jHgPa8.js";
+import { a as addValidityToForms, u as useFormComposer } from "./dropinUtils-BK1u6OTG.js";
+import { u as useMultiForm } from "./useMultiForm--sSlt50X.js";
+import { m as mapExistingFile, g as getPageName, u as useScenarioConfiguration } from "./mapExistingFile-CqrlnmFQ.js";
+import { a as datasetUtilities, C as Confirm } from "./useDataset-8WyOJBhU.js";
+import { a as getDocument, c as createDocumentRequest, b as getFileExtention, d as documentApiUtils } from "./documentUtils-DIcRD9lR.js";
+import { g as getFieldsWithExistingData } from "./getFieldsWithExistingData-DxCFyXNd.js";
+import { f as formatCurrency, A as ALLOWED_SOF_SERVICES } from "./utils-DQLhii3U.js";
+import { u as useFormContext, i as isDateOlderThanAYear, o as mapAddressLabels, p as getKeyForField } from "./Address-e41CN3CB.js";
+import { _ as MemoizedDocumentUpload, C as CompanyTypesValues, l as COUNTRIES_USING_COMPANY_SEARCH, $ as isRegistrationNumberAbsentStateV4Scenario, B as isEmpty$1, a0 as COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT, r as requestingBanking, e as requestingIssuing, a as getCompanyRegistrationNumberOptions, t as taxInformationDefaultFieldMetadata, a1 as countryToTaxInfoTypeMap, f as taxInformationDefaultFieldConfig, a2 as rules } from "./IndividualOnfido-CmmyKC7J.js";
+import { M as MemoizedConstitutionalDocument } from "./ConstitutionalDocument-CcwyClZ7.js";
+import { M as Modal, a as ModalContent } from "./Modal-CJ_hgcGb.js";
+import { b as mapAddressLocalizationToJpAddressSchema, a as mapApiScriptLocalizationToSchemaFields, m as mapSchemaFieldsToApiScriptLocalization } from "./mapAddressLocalizationToJpAddressSchema-vJWbpAyq.js";
+import { m as mapFinancialReportsToFinancialInformation, a as mapFinancialInformationToFinancialReport } from "./mapFinancialReportsToFinancialInformation-ZmhVRj3f.js";
+import { f as formatObject } from "./utils-DNSfZiio.js";
+import { S as SettingNames } from "./InputText-BfL9DgWp.js";
+import { m as mapJpAddressSchemaToAddressLocalizations, a as mapJpAddressSummary } from "./mapJpAddressSchemaToAddressLocalizations-D6HjhjJT.js";
+import { o as organizationTypesToSkipCompanyStructureForm } from "./utils-DV0_GilJ.js";
+import { s as summaryItem } from "./CountryField-CzRN1OE8.js";
+import { s as summaryStep } from "./Summary-COehg8IT.js";
+import { i as isValidationError, p as processValidationErrors, a as isMaintenanceModeError } from "./validationError-B5aoMbe_.js";
+import { r as resolveFieldMetadata } from "./Spacer-D4I0f08n.js";
+const stripWhitespace = (str) => str.replace(/\s/g, "");
+const toNormalizedString = (s) => stripWhitespace(s.toLowerCase());
+const isNormalizedStringMatch = (s1, s2) => toNormalizedString(s1) === toNormalizedString(s2);
+const documentTypes$2 = [
+  { id: "Internal company document", name: "internalCompanyDocument" },
+  { id: "Business registry statement", name: "businessRegistryStatement" }
+];
+const GuidanceContent$4 = ({ t }) => {
+  return /* @__PURE__ */ jsx("div", { className: "adyen-kyc-upload-field__guidance", children: /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-u-margin-bottom-24", children: [
+    /* @__PURE__ */ jsx("strong", { children: t(($) => $["documentRequirements"], { ns: "common" }) }),
+    /* @__PURE__ */ jsxs("ul", { children: [
+      /* @__PURE__ */ jsx("li", { children: t(($) => $["includesTheDirectorsFullName"], { ns: "business" }) }),
+      /* @__PURE__ */ jsx("li", { children: t(($) => $["includesEvidenceOfTheIndividualsRole"], { ns: "business" }) }),
+      /* @__PURE__ */ jsx("li", { children: t(($) => $["issuedOrSignedByALegalRepresentative"], { ns: "business" }) })
+    ] })
+  ] }) });
+};
+function ProofOfDirectorDocument({ id, country, ...props }) {
+  const { t } = useTranslation(["common", "business"]);
+  const [selectedDocumentName, setSelectedDocumentName] = useState(documentTypes$2[0].id);
+  return /* @__PURE__ */ jsx(
+    MemoizedDocumentUpload,
+    {
+      ...props,
+      id,
+      heading: t(($) => $["uploadYourOrganizationProofOfDirector"], { ns: "business" }),
+      description: t(($) => $["weNeedAnOfficialDocument"], { ns: "business" }),
+      documentField: "proofOfDirector",
+      documentType: "proofOfDirector",
+      guidanceContent: /* @__PURE__ */ jsx(GuidanceContent$4, { t }),
+      country,
+      hidePageCount: true,
+      documentTypeSelect: {
+        selectedType: selectedDocumentName,
+        setSelectedType: setSelectedDocumentName,
+        options: documentTypes$2
+      }
+    }
+  );
+}
+const DOC_TYPE_FOR_MULTI_UPLOAD = "Organizational chart and supporting document";
+const documentTypes$1 = [
+  { id: "Certified Organizational chart", name: "certifiedOrganizationalChart" },
+  {
+    id: "Organizational chart and supporting document",
+    name: "organizationalChartAndSupportingDocument"
+  }
+];
+const GuidanceContent$3 = ({
+  selectedDocumentName,
+  t
+}) => {
+  const [showGuidanceModal, setShowGuidanceModal] = useState(false);
+  return /* @__PURE__ */ jsx("div", { className: "adyen-kyc-upload-field__guidance", children: /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-u-margin-bottom-24", children: [
+    /* @__PURE__ */ jsx("strong", { children: t(($) => $["documentRequirements"], { ns: "common" }) }),
+    selectedDocumentName === "Certified Organizational chart" ? /* @__PURE__ */ jsxs("ul", { children: [
+      /* @__PURE__ */ jsx("li", { children: t(($) => $["showsOwnershipAndControllingRelations"], { ns: "business" }) }),
+      /* @__PURE__ */ jsx("li", { children: t(($) => $["entitiesMustIncludeANameLegalStructureAndCountryRegionOfRegistration"], {
+        ns: "business"
+      }) }),
+      /* @__PURE__ */ jsx("li", { children: t(($) => $["signedByALawyerAccountantAuditorWithinTheLast6Months"], {
+        ns: "business"
+      }) })
+    ] }) : /* @__PURE__ */ jsxs("ul", { children: [
+      /* @__PURE__ */ jsx("li", { children: t(($) => $["oneOrganizationalChartShowingOwnershipAndControllingRelations"], {
+        ns: "business"
+      }) }),
+      /* @__PURE__ */ jsxs("ul", { children: [
+        /* @__PURE__ */ jsx("li", { children: t(
+          ($) => $["entitiesMustIncludeANameLegalStructureAndCountryRegionOfRegistration"],
+          {
+            ns: "business"
+          }
+        ) }),
+        /* @__PURE__ */ jsxs("li", { children: [
+          /* @__PURE__ */ jsxs("span", { children: [
+            t(($) => $["one"], { ns: "common" }),
+            " "
+          ] }),
+          /* @__PURE__ */ jsx(Button, { onClick: () => setShowGuidanceModal(true), variant: "link", children: t(($) => $["supportingDocument"], { ns: "common" }) }),
+          /* @__PURE__ */ jsxs("span", { children: [
+            " ",
+            t(($) => $["describingTheOrganizationAndItsUBOSignedWithinTheLast6Months"], {
+              ns: "business"
+            })
+          ] })
+        ] })
+      ] })
+    ] }),
+    showGuidanceModal && /* @__PURE__ */ jsx(
+      Modal,
+      {
+        size: "small",
+        onClose: () => setShowGuidanceModal(false),
+        ariaLabel: t(($) => $["whichDocumentsQualifyToProveOwnership"], { ns: "business" }),
+        children: /* @__PURE__ */ jsxs(ModalContent, { children: [
+          /* @__PURE__ */ jsx(
+            Typography,
+            {
+              el: "h1",
+              variant: "title-l",
+              className: "adyen-kyc-u-margin-bottom-32 adyen-kyc-u-margin-top-32",
+              children: t(($) => $["whichDocumentsQualifyToProveOwnership"], { ns: "business" })
+            }
+          ),
+          /* @__PURE__ */ jsx(Typography, { el: "p", variant: "body", children: t(($) => $["theDocumentsWeCanAcceptToProveOwnershipAre"], { ns: "business" }) }),
+          /* @__PURE__ */ jsxs("ul", { children: [
+            /* @__PURE__ */ jsx("li", { children: t(($) => $["securitiesRegister"], { ns: "business" }) }),
+            /* @__PURE__ */ jsx("li", { children: t(($) => $["shareholderRegister"], { ns: "business" }) }),
+            /* @__PURE__ */ jsx("li", { children: t(($) => $["ultimateBeneficialOwnerRegister"], { ns: "business" }) }),
+            /* @__PURE__ */ jsx("li", { children: t(($) => $["articlesOfIncorporation"], { ns: "business" }) }),
+            /* @__PURE__ */ jsx("li", { children: t(($) => $["annualReports"], { ns: "business" }) }),
+            /* @__PURE__ */ jsx("li", { children: t(($) => $["annualReturns"], { ns: "business" }) }),
+            /* @__PURE__ */ jsx("li", { children: t(($) => $["certificateOfCorporateStatus"], { ns: "business" }) }),
+            /* @__PURE__ */ jsx("li", { children: t(($) => $["shareholderAgreements"], { ns: "business" }) }),
+            /* @__PURE__ */ jsx("li", { children: t(($) => $["assignmentAgreements"], { ns: "business" }) }),
+            /* @__PURE__ */ jsx("li", { children: t(($) => $["partnershipAgreements"], { ns: "business" }) }),
+            /* @__PURE__ */ jsx("li", { children: t(($) => $["boardOfDirectorsMeetingRecords"], { ns: "business" }) }),
+            /* @__PURE__ */ jsx("li", { children: t(($) => $["registrationDocument"], { ns: "business" }) }),
+            /* @__PURE__ */ jsx("li", { children: t(($) => $["certificateOfIncumbency"], { ns: "business" }) })
+          ] })
+        ] })
+      }
+    )
+  ] }) });
+};
+function ProofOfOwnershipDocument({ id, country, ...props }) {
+  const { t } = useTranslation(["common", "business"]);
+  const [selectedDocumentName, setSelectedDocumentName] = useState(documentTypes$1[0].id);
+  const supportsMultiple = selectedDocumentName === DOC_TYPE_FOR_MULTI_UPLOAD;
+  useEffect(() => {
+    if (props.data?.proofOfOwnership?.length === 2) {
+      setSelectedDocumentName(DOC_TYPE_FOR_MULTI_UPLOAD);
+    }
+  }, [props.data?.proofOfOwnership]);
+  return /* @__PURE__ */ jsx(
+    MemoizedDocumentUpload,
+    {
+      ...props,
+      id,
+      heading: t(($) => $["uploadYourOrganizationProofOfOwnership"], { ns: "business" }),
+      description: t(($) => $["weNeedAnOfficialDocumentForOwnership"], { ns: "business" }),
+      documentField: "proofOfOwnership",
+      documentType: "proofOfOwnership",
+      guidanceContent: /* @__PURE__ */ jsx(GuidanceContent$3, { selectedDocumentName, t }),
+      country,
+      label: t(($) => $["uploadYourDocuments"], { ns: "business" }),
+      documentTypeSelect: {
+        selectedType: selectedDocumentName,
+        setSelectedType: setSelectedDocumentName,
+        options: documentTypes$1
+      },
+      hidePageCount: true,
+      supportsMultipleUploads: supportsMultiple,
+      maxNumberOfFiles: supportsMultiple ? 2 : 1,
+      extraDropzoneDescription: supportsMultiple ? t(($) => $["oneOrganizationalChartAndOneSupportingDocument"], { ns: "business" }) : void 0
+    }
+  );
+}
+const documentTypes = [
+  { id: "Trade registry document", name: "tradeRegistryDocument" },
+  { id: "Internal company document", name: "internalCompanyDocument" }
+];
+const GuidanceContent$2 = ({ t }) => {
+  return /* @__PURE__ */ jsx("div", { className: "adyen-kyc-upload-field__guidance", children: /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-u-margin-bottom-24", children: [
+    /* @__PURE__ */ jsx("strong", { children: t(($) => $["documentRequirements"], { ns: "common" }) }),
+    /* @__PURE__ */ jsxs("ul", { children: [
+      /* @__PURE__ */ jsx("li", { children: t(($) => $["includesTheSignatorysFullName"], { ns: "business" }) }),
+      /* @__PURE__ */ jsx("li", { children: t(($) => $["includesEvidenceOfTheIndividualsRoleSignatory"], { ns: "business" }) }),
+      /* @__PURE__ */ jsx("li", { children: t(($) => $["issuedOrSignedByALegalRepresentative"], { ns: "business" }) })
+    ] })
+  ] }) });
+};
+function ProofOfSignatoryDocument({ id, country, ...props }) {
+  const { t } = useTranslation(["common", "business"]);
+  const [selectedDocumentName, setSelectedDocumentName] = useState(documentTypes[0].id);
+  return /* @__PURE__ */ jsx(
+    MemoizedDocumentUpload,
+    {
+      ...props,
+      id,
+      heading: t(($) => $["uploadYourOrganizationProofOfSignatory"], { ns: "business" }),
+      description: t(($) => $["weNeedAnOfficialDocumentSignatory"], { ns: "business" }),
+      documentField: "proofOfSignatory",
+      documentType: "proofOfSignatory",
+      guidanceContent: /* @__PURE__ */ jsx(GuidanceContent$2, { t }),
+      country,
+      hidePageCount: true,
+      documentTypeSelect: {
+        selectedType: selectedDocumentName,
+        setSelectedType: setSelectedDocumentName,
+        options: documentTypes
+      }
+    }
+  );
+}
+const ACCEPTED_DOCUMENTS_MAP$1 = {
+  [CountryCodes.PuertoRico]: {
+    // should exactly match CountryCodes.UnitedStates
+    [CompanyTypesValues.PRIVATE_COMPANY]: {
+      header: "acceptedDocumentsForPrivateCompanies",
+      documents: [
+        "certificateOfIncorporation",
+        "certificateOfFormation",
+        "secretaryOfStateFiling__PR"
+      ]
+    },
+    [CompanyTypesValues.PUBLIC_COMPANY]: {
+      header: "acceptedDocumentsForPublicCompanies",
+      documents: ["certificateOfIncorporation", "certificateOfFormation"]
+    },
+    [CompanyTypesValues.UNLISTED_PUBLIC_COMPANY]: {
+      header: "acceptedDocumentsForPublicCompanies",
+      documents: ["certificateOfIncorporation", "certificateOfFormation"]
+    },
+    [CompanyTypesValues.GOVERNMENTAL_ORGANIZATION]: {
+      header: "acceptedDocumentsForGovernment",
+      documents: ["charter"]
+    },
+    [CompanyTypesValues.NON_PROFIT_OR_CHARITABLE]: {
+      header: "acceptedDocumentsForNonProfit",
+      documents: [
+        "articlesOfIncorporation",
+        "meetingRecords",
+        "secretaryOfStateRegDoc__PR",
+        "certificateOfIncumbency"
+      ]
+    },
+    [CompanyTypesValues.INCORPORATED_PARTNERSHIP]: {
+      header: "acceptedDocumentsForPartnerships",
+      documents: ["partnerShipAgreement", "secretaryOfStateFiling__PR"]
+    }
+  },
+  [CountryCodes.UnitedStates]: {
+    [CompanyTypesValues.PRIVATE_COMPANY]: {
+      header: "acceptedDocumentsForPrivateCompanies",
+      documents: ["certificateOfIncorporation", "certificateOfFormation", "secretaryOfStateFiling"]
+    },
+    [CompanyTypesValues.PUBLIC_COMPANY]: {
+      header: "acceptedDocumentsForPublicCompanies",
+      documents: ["certificateOfIncorporation", "certificateOfFormation"]
+    },
+    [CompanyTypesValues.UNLISTED_PUBLIC_COMPANY]: {
+      header: "acceptedDocumentsForPublicCompanies",
+      documents: ["certificateOfIncorporation", "certificateOfFormation"]
+    },
+    [CompanyTypesValues.GOVERNMENTAL_ORGANIZATION]: {
+      header: "acceptedDocumentsForGovernment",
+      documents: ["charter"]
+    },
+    [CompanyTypesValues.NON_PROFIT_OR_CHARITABLE]: {
+      header: "acceptedDocumentsForNonProfit",
+      documents: [
+        "articlesOfIncorporation",
+        "meetingRecords",
+        "secretaryOfStateRegDoc",
+        "certificateOfIncumbency"
+      ]
+    },
+    [CompanyTypesValues.INCORPORATED_PARTNERSHIP]: {
+      header: "acceptedDocumentsForPartnerships",
+      documents: ["partnerShipAgreement", "secretaryOfStateFiling"]
+    }
+  }
+};
+const GuidanceContent$1 = ({
+  country,
+  companyType,
+  t
+}) => {
+  const acceptedDocGuidance = ACCEPTED_DOCUMENTS_MAP$1[country]?.[companyType];
+  return /* @__PURE__ */ jsx("div", { className: "adyen-kyc-upload-field__guidance", children: country === "US" ? /* @__PURE__ */ jsxs(Fragment, { children: [
+    acceptedDocGuidance && /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-u-margin-bottom-24", children: [
+      /* @__PURE__ */ jsx("strong", { children: t(($) => $[acceptedDocGuidance.header], { ns: "business" }) }),
+      /* @__PURE__ */ jsx("ul", { children: acceptedDocGuidance.documents.map((document, i) => /* @__PURE__ */ jsx("li", { children: t(($) => $[document], { ns: "business" }) }, i)) })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-u-margin-bottom-24", children: [
+      /* @__PURE__ */ jsx("strong", { children: t(($) => $["documentRequirements"], { ns: "common" }) }),
+      /* @__PURE__ */ jsx("ul", { children: /* @__PURE__ */ jsx("li", { children: t(($) => $["includesLegalCompanyName"], { ns: "business" }) }) })
+    ] })
+  ] }) : /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-u-margin-bottom-24", children: [
+    /* @__PURE__ */ jsx("strong", { children: t(($) => $["documentRequirements"], { ns: "common" }) }),
+    /* @__PURE__ */ jsx("ul", { children: /* @__PURE__ */ jsx("li", { children: t(($) => $["documentIssuedByGovernmentAuthority"], { ns: "business" }) }) })
+  ] }) });
+};
+function RegistrationDocument({
+  id,
+  country,
+  companyType = CompanyTypesValues.PRIVATE_COMPANY,
+  ...props
+}) {
+  const { t } = useTranslation(["common", "business"]);
+  return /* @__PURE__ */ jsx(
+    MemoizedDocumentUpload,
+    {
+      ...props,
+      id,
+      heading: t(($) => $["companyRegistrationDocumentFormHeading"], { ns: "business" }),
+      description: t(($) => $["companyRegistrationDocumentFormDescription"], { ns: "business" }),
+      documentField: "registrationDocument",
+      documentType: "registrationDocument",
+      guidanceContent: /* @__PURE__ */ jsx(GuidanceContent$1, { country, companyType, t }),
+      companyType,
+      country,
+      hidePageCount: true
+    }
+  );
+}
+const ACCEPTED_DOCUMENTS_MAP = {
+  [CountryCodes.PuertoRico]: {
+    // should exactly match CountryCodes.UnitedStates
+    [CompanyTypesValues.PRIVATE_COMPANY]: {
+      header: "acceptedDocumentsForPrivateCompanies",
+      documents: ["irsCP575"]
+    },
+    [CompanyTypesValues.PUBLIC_COMPANY]: {
+      header: "acceptedDocumentsForPublicCompanies",
+      documents: ["annualReport", "secForm10k"]
+    },
+    [CompanyTypesValues.UNLISTED_PUBLIC_COMPANY]: {
+      header: "acceptedDocumentsForPublicCompanies",
+      documents: ["annualReport", "secForm10k"]
+    },
+    [CompanyTypesValues.NON_PROFIT_OR_CHARITABLE]: {
+      header: "acceptedDocumentsForNonProfit",
+      documents: ["annualReport"]
+    },
+    [CompanyTypesValues.INCORPORATED_PARTNERSHIP]: {
+      header: "acceptedDocumentsForPartnerships",
+      documents: ["irsScheduleK1"]
+    }
+  },
+  [CountryCodes.UnitedStates]: {
+    [CompanyTypesValues.PRIVATE_COMPANY]: {
+      header: "acceptedDocumentsForPrivateCompanies",
+      documents: ["irsCP575"]
+    },
+    [CompanyTypesValues.PUBLIC_COMPANY]: {
+      header: "acceptedDocumentsForPublicCompanies",
+      documents: ["annualReport", "secForm10k"]
+    },
+    [CompanyTypesValues.UNLISTED_PUBLIC_COMPANY]: {
+      header: "acceptedDocumentsForPublicCompanies",
+      documents: ["annualReport", "secForm10k"]
+    },
+    [CompanyTypesValues.NON_PROFIT_OR_CHARITABLE]: {
+      header: "acceptedDocumentsForNonProfit",
+      documents: ["annualReport"]
+    },
+    [CompanyTypesValues.INCORPORATED_PARTNERSHIP]: {
+      header: "acceptedDocumentsForPartnerships",
+      documents: ["irsScheduleK1"]
+    }
+  }
+};
+const GuidanceContent = ({
+  country,
+  companyType
+}) => {
+  const { t } = useTranslation(["common", "business"]);
+  const acceptedDocGuidance = ACCEPTED_DOCUMENTS_MAP[country]?.[companyType];
+  return /* @__PURE__ */ jsx("div", { className: "adyen-kyc-upload-field__guidance", children: country === "US" ? /* @__PURE__ */ jsxs(Fragment, { children: [
+    acceptedDocGuidance && /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-u-margin-bottom-24", children: [
+      /* @__PURE__ */ jsx("strong", { children: t(($) => $[acceptedDocGuidance.header], { ns: "business" }) }),
+      /* @__PURE__ */ jsx("ul", { children: acceptedDocGuidance.documents.map((document, i) => /* @__PURE__ */ jsx("li", { children: t(($) => $[document], { ns: "business" }) }, i)) })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-u-margin-bottom-24", children: [
+      /* @__PURE__ */ jsx("strong", { children: t(($) => $["documentRequirements"], { ns: "common" }) }),
+      /* @__PURE__ */ jsxs("ul", { children: [
+        /* @__PURE__ */ jsx("li", { children: t(($) => $["includesLegalCompanyName"], { ns: "business" }) }),
+        /* @__PURE__ */ jsx("li", { children: t(($) => $["includesEIN"], { ns: "business" }) })
+      ] })
+    ] })
+  ] }) : /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-u-margin-bottom-24", children: [
+    /* @__PURE__ */ jsx("div", { className: "adyen-kyc-upload-field__subtitle", children: t(($) => $["documentRequirements"], { ns: "common" }) }),
+    /* @__PURE__ */ jsxs("ul", { children: [
+      /* @__PURE__ */ jsx("li", { children: t(($) => $["containsNameOfCompany"], { ns: "business" }) }),
+      /* @__PURE__ */ jsx("li", { children: t(($) => $["documentShowsTaxIdOfCompany"], { ns: "business" }) }),
+      /* @__PURE__ */ jsx("li", { children: t(($) => $["issuedByTheTaxAuthority"], { ns: "business" }) })
+    ] })
+  ] }) });
+};
+function TaxDocument({
+  id,
+  country,
+  companyType = CompanyTypesValues.PRIVATE_COMPANY,
+  ...props
+}) {
+  const { t } = useTranslation("business");
+  return /* @__PURE__ */ jsx(
+    MemoizedDocumentUpload,
+    {
+      ...props,
+      id,
+      heading: t(($) => $["companyTaxDocumentFormHeading"]),
+      description: t(($) => $["companyTaxDocumentFormDescription"]),
+      documentField: "taxDocument",
+      documentType: "proofOfOrganizationTaxInfo",
+      guidanceContent: /* @__PURE__ */ jsx(GuidanceContent, { country, companyType }),
+      companyType,
+      country,
+      hidePageCount: true
+    }
+  );
+}
+function BusinessDetailsMultiform({
+  taskType,
+  country,
+  activeForm,
+  shouldValidate,
+  problems = {},
+  handleNextClick,
+  handleBackClick,
+  setLoadingStatus,
+  isTopLevelEntity
+}) {
+  const { t } = useTranslation(["common", "business"]);
+  const { form } = useFormContext();
+  const companyType = taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY ? CompanyTypesValues.SOLE_PROPRIETORSHIP : form.data.companyStructure?.entityType;
+  function handleChange(formName, fieldName, mode) {
+    return form.handleChangeFor(fieldName, formName, mode);
+  }
+  const renderActiveForm = (activeForm2) => {
+    switch (activeForm2.formId) {
+      case "basicInformation":
+        return /* @__PURE__ */ jsx(
+          BasicInformation,
+          {
+            id: activeForm2.formId,
+            country,
+            shouldValidate,
+            validationErrors: problems.validationErrors?.[activeForm2.formId],
+            verificationErrors: problems.verificationErrors?.[activeForm2.formId],
+            companyType,
+            isTopLevelEntity,
+            disableCountry: taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY
+          }
+        );
+      case "businessSelection":
+        return /* @__PURE__ */ jsx(
+          BusinessSelection,
+          {
+            id: activeForm2.formId,
+            country,
+            shouldValidate,
+            validationErrors: problems.validationErrors?.[activeForm2.formId],
+            verificationErrors: problems.verificationErrors?.[activeForm2.formId],
+            handleNextClick,
+            handleBackClick,
+            setLoadingStatus
+          }
+        );
+      case "companyStructure":
+        return /* @__PURE__ */ jsx(
+          CompanyStructure,
+          {
+            id: activeForm2.formId,
+            country,
+            shouldValidate,
+            validationErrors: problems.validationErrors?.[activeForm2.formId],
+            verificationErrors: problems.verificationErrors?.[activeForm2.formId]
+          }
+        );
+      case "additionalInformation":
+        return /* @__PURE__ */ jsx(
+          AdditionalInformation,
+          {
+            id: activeForm2.formId,
+            country,
+            companyType,
+            shouldValidate,
+            validationErrors: problems.validationErrors?.[activeForm2.formId],
+            verificationErrors: problems.verificationErrors?.[activeForm2.formId]
+          }
+        );
+      case "companyTaxDocument":
+        return country === "US" ? /* @__PURE__ */ jsx(
+          TaxDocument,
+          {
+            id: activeForm2.formId,
+            country,
+            companyType,
+            shouldValidate,
+            fieldValidationErrors: problems.validationErrors?.[activeForm2.formId] ?? {},
+            formVerificationErrors: problems.verificationErrors?.[activeForm2.formId] ?? {},
+            data: form.data.companyTaxDocument,
+            errors: form.errors.companyTaxDocument,
+            valid: form.valid.companyTaxDocument,
+            allFields: form.allFields?.companyTaxDocument,
+            requiredFields: form.requiredFields?.companyTaxDocument,
+            optionalFields: form.optionalFields?.companyTaxDocument,
+            trustedFields: form.trustedFields?.companyTaxDocument,
+            handleFieldChange: () => handleChange("companyTaxDocument", "taxDocument")
+          }
+        ) : /* @__PURE__ */ jsx(
+          MemoizedDocumentUpload,
+          {
+            id: activeForm2.formId,
+            country,
+            companyType,
+            shouldValidate,
+            heading: t(($) => $["companyTaxDocumentFormHeading"], { ns: "business" }),
+            description: t(($) => $["companyTaxDocumentFormDescription"], { ns: "business" }),
+            fieldValidationErrors: problems.validationErrors?.[activeForm2.formId] ?? {},
+            formVerificationErrors: problems.verificationErrors?.[activeForm2.formId] ?? {},
+            data: form.data.companyTaxDocument,
+            errors: form.errors.companyTaxDocument,
+            valid: form.valid.companyTaxDocument,
+            allFields: form.allFields?.companyTaxDocument,
+            requiredFields: form.requiredFields?.companyTaxDocument,
+            optionalFields: form.optionalFields?.companyTaxDocument,
+            trustedFields: form.trustedFields?.companyTaxDocument,
+            handleFieldChange: () => handleChange("companyTaxDocument", "taxDocument"),
+            documentField: "taxDocument",
+            documentType: "vatDocument",
+            hidePageCount: true,
+            guidanceContent: /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-u-margin-bottom-24", children: [
+              /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-upload-field__subtitle", children: [
+                " ",
+                t(($) => $["requirements"], { ns: "common" })
+              ] }),
+              /* @__PURE__ */ jsxs("ul", { children: [
+                /* @__PURE__ */ jsx("li", { children: t(($) => $["containsNameOfCompany"], { ns: "business" }) }),
+                /* @__PURE__ */ jsx("li", { children: t(($) => $["documentShowsTaxIdOfCompany"], { ns: "business" }) }),
+                /* @__PURE__ */ jsx("li", { children: t(($) => $["issuedByTheTaxAuthority"], { ns: "business" }) })
+              ] })
+            ] })
+          }
+        );
+      case "companyRegistrationDocument":
+        return /* @__PURE__ */ jsx(
+          RegistrationDocument,
+          {
+            id: activeForm2.formId,
+            country,
+            companyType,
+            data: form.data.companyRegistrationDocument,
+            errors: form.errors.companyRegistrationDocument,
+            valid: form.valid.companyRegistrationDocument,
+            allFields: form.allFields?.companyRegistrationDocument,
+            requiredFields: form.requiredFields?.companyRegistrationDocument,
+            optionalFields: form.optionalFields?.companyRegistrationDocument,
+            trustedFields: form.trustedFields?.companyRegistrationDocument,
+            handleFieldChange: () => handleChange("companyRegistrationDocument", "registrationDocument"),
+            shouldValidate,
+            fieldValidationErrors: problems.validationErrors?.[activeForm2.formId] ?? {},
+            formVerificationErrors: problems.verificationErrors?.[activeForm2.formId] ?? {}
+          }
+        );
+      case "companyProofOfDirectorDocument":
+        return /* @__PURE__ */ jsx(
+          ProofOfDirectorDocument,
+          {
+            id: activeForm2.formId,
+            country,
+            data: form.data?.companyProofOfDirectorDocument,
+            errors: form.errors.companyProofOfDirectorDocument,
+            valid: form.valid.companyProofOfDirectorDocument,
+            allFields: form.allFields?.companyProofOfDirectorDocument,
+            requiredFields: form.requiredFields?.companyProofOfDirectorDocument,
+            optionalFields: form.optionalFields?.companyProofOfDirectorDocument,
+            trustedFields: form.trustedFields?.companyProofOfDirectorDocument,
+            handleFieldChange: () => handleChange("companyProofOfDirectorDocument", "proofOfDirector"),
+            shouldValidate,
+            fieldValidationErrors: problems.validationErrors?.[activeForm2.formId] ?? {},
+            formVerificationErrors: problems.verificationErrors?.[activeForm2.formId] ?? {}
+          }
+        );
+      case "companyProofOfSignatoryDocument":
+        return /* @__PURE__ */ jsx(
+          ProofOfSignatoryDocument,
+          {
+            id: activeForm2.formId,
+            country,
+            data: form.data?.companyProofOfSignatoryDocument,
+            errors: form.errors.companyProofOfSignatoryDocument,
+            valid: form.valid.companyProofOfSignatoryDocument,
+            allFields: form.allFields?.companyProofOfSignatoryDocument,
+            requiredFields: form.requiredFields?.companyProofOfSignatoryDocument,
+            optionalFields: form.optionalFields?.companyProofOfSignatoryDocument,
+            trustedFields: form.trustedFields?.companyProofOfSignatoryDocument,
+            handleFieldChange: () => handleChange("companyProofOfSignatoryDocument", "proofOfSignatory"),
+            shouldValidate,
+            fieldValidationErrors: problems.validationErrors?.[activeForm2.formId] ?? {},
+            formVerificationErrors: problems.verificationErrors?.[activeForm2.formId] ?? {}
+          }
+        );
+      case "companyProofOfOwnershipDocument":
+        return /* @__PURE__ */ jsx(
+          ProofOfOwnershipDocument,
+          {
+            id: activeForm2.formId,
+            country,
+            data: form.data?.companyProofOfOwnershipDocument,
+            errors: form.errors.companyProofOfOwnershipDocument,
+            valid: form.valid.companyProofOfOwnershipDocument,
+            allFields: form.allFields?.companyProofOfOwnershipDocument,
+            requiredFields: form.requiredFields?.companyProofOfOwnershipDocument,
+            optionalFields: form.optionalFields?.companyProofOfOwnershipDocument,
+            trustedFields: form.trustedFields?.companyProofOfOwnershipDocument,
+            handleFieldChange: () => handleChange("companyProofOfOwnershipDocument", "proofOfOwnership"),
+            shouldValidate,
+            fieldValidationErrors: problems.validationErrors?.[activeForm2.formId] ?? {},
+            formVerificationErrors: problems.verificationErrors?.[activeForm2.formId] ?? {}
+          }
+        );
+      case "companyConstitutionalDocument":
+        return /* @__PURE__ */ jsx(
+          MemoizedConstitutionalDocument,
+          {
+            id: activeForm2.formId,
+            legalEntityType: LegalEntityTypes.SOLE_PROPRIETORSHIP,
+            country,
+            data: form.data?.companyConstitutionalDocument,
+            errors: form.errors.companyConstitutionalDocument,
+            valid: form.valid.companyConstitutionalDocument,
+            allFields: form.allFields?.companyConstitutionalDocument,
+            requiredFields: form.requiredFields?.companyConstitutionalDocument,
+            optionalFields: form.optionalFields?.companyConstitutionalDocument,
+            trustedFields: form.trustedFields?.companyConstitutionalDocument,
+            handleFieldChange: () => handleChange("companyConstitutionalDocument", "constitutionalDocument"),
+            shouldValidate,
+            fieldValidationErrors: problems.validationErrors?.[activeForm2.formId] ?? {},
+            formVerificationErrors: problems.verificationErrors?.[activeForm2.formId] ?? {}
+          }
+        );
+      case "companyFinancialInformation":
+        return /* @__PURE__ */ jsx(
+          FinancialInformation,
+          {
+            multiForm: form,
+            id: activeForm2.formId,
+            country,
+            data: form.data?.companyFinancialInformation,
+            allFields: form.allFields?.companyFinancialInformation,
+            requiredFields: form.requiredFields?.companyFinancialInformation,
+            optionalFields: form.optionalFields?.companyFinancialInformation,
+            trustedFields: form.trustedFields?.companyFinancialInformation,
+            shouldValidate
+          }
+        );
+      default:
+        return null;
+    }
+  };
+  return /* @__PURE__ */ jsx("div", { className: "adyen-kyc-business-details", children: /* @__PURE__ */ jsx("div", { className: "adyen-kyc-form-wrapper", children: renderActiveForm(activeForm) }) });
+}
+const CompanyStructureValidation = {
+  entityType: {
+    modes: ["blur"],
+    validate: (entityType) => !isEmpty(entityType),
+    errorMessage: "fieldIsRequired"
+  }
+};
+const mapApiDocumentToBusinessDetailsDocuments = (entityId) => {
+  const registrationDocument = getDocument(entityId, "registrationDocument") ?? null;
+  const taxDocument = getDocument(entityId, "vatDocument") ?? getDocument(entityId, "proofOfOrganizationTaxInfo") ?? null;
+  const proofOfDirector = getDocument(entityId, "proofOfDirector") ?? null;
+  const proofOfSignatory = getDocument(entityId, "proofOfSignatory") ?? null;
+  const proofOfOwnership = getDocument(entityId, "proofOfOwnership") ?? null;
+  const constitutionalDocument = getDocument(entityId, "constitutionalDocument") ?? null;
+  return {
+    companyRegistrationDocument: registrationDocument ? { registrationDocument: [mapExistingFile(getPageName(registrationDocument))] } : void 0,
+    companyTaxDocument: taxDocument ? { taxDocument: [mapExistingFile(getPageName(taxDocument))] } : void 0,
+    companyProofOfDirectorDocument: proofOfDirector ? { proofOfDirector: [mapExistingFile(getPageName(proofOfDirector))] } : void 0,
+    companyProofOfSignatoryDocument: proofOfSignatory ? { proofOfSignatory: [mapExistingFile(getPageName(proofOfSignatory))] } : void 0,
+    companyProofOfOwnershipDocument: proofOfOwnership ? { proofOfOwnership: [mapExistingFile(getPageName(proofOfOwnership))] } : void 0,
+    companyConstitutionalDocument: constitutionalDocument ? {
+      constitutionalDocument: [mapExistingFile(getPageName(constitutionalDocument))]
+    } : void 0
+  };
+};
+const mapBasicInformation = (data) => {
+  if (!data) return;
+  return !!data.country && COUNTRIES_USING_COMPANY_SEARCH.includes(data.country) ? data : entriesOf(data).reduce((acc, [field]) => {
+    if (!FIELDS_NEEDED_FOR_COMPANY_SEARCH.includes(field)) {
+      return {
+        ...acc,
+        [field]: data[field]
+      };
+    }
+    return acc;
+  }, {});
+};
+const mapDbaName = (legalEntity) => {
+  const entity = legalEntity.type === "organization" ? legalEntity.organization : legalEntity.soleProprietorship;
+  const dbaName = {};
+  if (typeof entity?.doingBusinessAsAbsent !== "undefined") {
+    dbaName.hasDoingBusinessAs = !entity.doingBusinessAsAbsent;
+  } else {
+    if (entity?.doingBusinessAs) {
+      dbaName.hasDoingBusinessAs = entity?.doingBusinessAs !== (legalEntity.type === "organization" ? legalEntity.organization?.legalName : legalEntity.soleProprietorship?.name);
+    } else {
+      dbaName.hasDoingBusinessAs = void 0;
+    }
+  }
+  if (legalEntity.organization?.doingBusinessAs) {
+    dbaName.doingBusinessAs = legalEntity.organization?.doingBusinessAs;
+  }
+  return dbaName;
+};
+const mapIsUen = (taxInformation, registrationNumber, country) => {
+  const currentCountryTaxInfo = taxInformation?.find((taxInfo) => taxInfo.country === country);
+  if (!currentCountryTaxInfo || country !== "SG") return {};
+  return {
+    registrationNumber: currentCountryTaxInfo.type === "UEN" ? currentCountryTaxInfo.number : registrationNumber,
+    isUen: currentCountryTaxInfo.type === "UEN"
+  };
+};
+const mapAdditionalInformation = (data, legalEntity) => {
+  if (!data) return;
+  const entity = legalEntity.type === "organization" ? legalEntity.organization : legalEntity.soleProprietorship;
+  const currentCountry = entity?.registeredAddress.country;
+  const dbaNameFields = mapDbaName(legalEntity);
+  const isUen = mapIsUen(
+    data.taxInformation,
+    data.registrationNumber,
+    currentCountry
+  );
+  const companyType = legalEntity.type === "organization" ? legalEntity.organization?.type : CompanyTypesValues.SOLE_PROPRIETORSHIP;
+  const registrationNumberType = getDefaultRegistrationNumberType(
+    entity?.registrationNumber,
+    currentCountry,
+    companyType
+  );
+  const vatNumberType = getDefaultVatNumberType(entity?.vatNumber, currentCountry);
+  const operationalAddressIsSame = entity?.principalPlaceOfBusiness && !objectsDeepEqual(entity?.principalPlaceOfBusiness, entity?.registeredAddress) ? operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME : operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_SAME;
+  if (entity?.registeredAddress?.localization) {
+    data.registrationAddress = {
+      ...data.registrationAddress,
+      ...mapAddressLocalizationToJpAddressSchema(entity.registeredAddress.localization)
+    };
+  }
+  if (entity?.principalPlaceOfBusiness?.localization) {
+    data.operationalAddress = {
+      ...data.operationalAddress,
+      ...mapAddressLocalizationToJpAddressSchema(entity.principalPlaceOfBusiness.localization)
+    };
+  }
+  const result = entriesOf(data).reduce(
+    (acc, [field]) => {
+      if (!COUNTRIES_USING_COMPANY_SEARCH.includes(currentCountry)) {
+        return {
+          ...acc,
+          [field]: data[field]
+        };
+      }
+      if (!FIELDS_NEEDED_FOR_COMPANY_SEARCH.includes(field)) {
+        return {
+          ...acc,
+          [field]: data[field]
+        };
+      }
+      return acc;
+    },
+    { operationalAddressIsSame, registrationNumberType, vatNumberType }
+  );
+  return { ...result, ...dbaNameFields, ...isUen };
+};
+const mapLegalNameLocalization = (data) => {
+  const localization = data.organization?.localization;
+  if (!localization) return {};
+  let result = {};
+  for (const { script, fields } of localization) {
+    const schemaFieldsFromLocalization = mapApiScriptLocalizationToSchemaFields({
+      script,
+      fields: {
+        // mismatch between API `legalName` and schema `legalCompanyName`
+        legalCompanyName: fields.legalName
+      }
+    });
+    result = {
+      ...result,
+      ...schemaFieldsFromLocalization
+    };
+  }
+  return result;
+};
+const mapLegalEntityToBusinessDetailsSchema = (legalEntity, parentEntity) => {
+  if (!legalEntity) return {};
+  const {
+    companyRegistrationDocument,
+    companyTaxDocument,
+    companyProofOfDirectorDocument,
+    companyProofOfSignatoryDocument,
+    companyProofOfOwnershipDocument,
+    companyConstitutionalDocument
+  } = mapApiDocumentToBusinessDetailsDocuments(legalEntity.id);
+  const buildSolePropSchema = () => {
+    const solePropData = formatObject(
+      legalEntity,
+      solePropBusinessDetailsKeyMapping
+    );
+    const country = solePropData?.additionalInformation?.registrationAddress?.country ?? parentEntity?.individual?.residentialAddress.country;
+    if (legalEntity?.soleProprietorship?.financialReports && solePropData) {
+      solePropData.companyFinancialInformation = mapFinancialReportsToFinancialInformation(
+        legalEntity.soleProprietorship.financialReports
+      );
+    }
+    return {
+      ...solePropData,
+      basicInformation: {
+        ...solePropData?.basicInformation,
+        country
+      },
+      companyConstitutionalDocument
+    };
+  };
+  const orgSchema = {
+    ...formatObject(legalEntity, businessDetailsComponentsKeyMapping),
+    businessSelection: {},
+    companyRegistrationDocument,
+    companyTaxDocument,
+    companyProofOfDirectorDocument,
+    companyProofOfSignatoryDocument,
+    companyProofOfOwnershipDocument,
+    companyFinancialInformation: {}
+  };
+  const businessDetailsSchema = legalEntity.type === "organization" ? orgSchema : buildSolePropSchema();
+  return entriesOf(businessDetailsSchema).reduce((componentData, [key]) => {
+    switch (key) {
+      case "basicInformation": {
+        return {
+          ...componentData,
+          [key]: {
+            ...mapBasicInformation(businessDetailsSchema[key]),
+            ...mapLegalNameLocalization(legalEntity)
+          }
+        };
+      }
+      case "businessSelection": {
+        return {
+          ...componentData,
+          [key]: {
+            hasSelectedBusiness: false
+          }
+        };
+      }
+      case "companyStructure": {
+        return {
+          ...componentData,
+          [key]: {
+            ...businessDetailsSchema[key]
+          }
+        };
+      }
+      case "additionalInformation": {
+        return {
+          ...componentData,
+          [key]: mapAdditionalInformation(businessDetailsSchema[key], legalEntity)
+        };
+      }
+      case "companyRegistrationDocument": {
+        return {
+          ...componentData,
+          [key]: businessDetailsSchema[key]
+        };
+      }
+      case "companyTaxDocument": {
+        return {
+          ...componentData,
+          [key]: businessDetailsSchema[key]
+        };
+      }
+      case "companyProofOfDirectorDocument": {
+        return {
+          ...componentData,
+          [key]: businessDetailsSchema[key]
+        };
+      }
+      case "companyProofOfSignatoryDocument": {
+        return {
+          ...componentData,
+          [key]: businessDetailsSchema[key]
+        };
+      }
+      case "companyProofOfOwnershipDocument": {
+        return {
+          ...componentData,
+          [key]: businessDetailsSchema[key]
+        };
+      }
+      case "companyConstitutionalDocument": {
+        return {
+          ...componentData,
+          [key]: businessDetailsSchema[key]
+        };
+      }
+      case "companyFinancialInformation": {
+        const financialReports = legalEntity.type === "organization" ? legalEntity?.organization?.financialReports : legalEntity?.soleProprietorship?.financialReports;
+        return financialReports?.length ? {
+          ...componentData,
+          [key]: mapFinancialReportsToFinancialInformation(financialReports)
+        } : componentData;
+      }
+      default:
+        return componentData;
+    }
+  }, {});
+};
+const businessDetailsBase = {
+  /* Base required fields */
+  country: { rule: "REQUIRED" },
+  entityType: { rule: "businessRequiresCompanyType" },
+  legalCompanyName: { rule: "REQUIRED" },
+  jaHaniLegalCompanyName: { rule: "japaneseLegalCompanyName" },
+  jaKanaLegalCompanyName: { rule: "japaneseLegalCompanyName" },
+  hasDoingBusinessAs: { rule: "REQUIRED" },
+  doingBusinessAs: { rule: "requireDoingBusinessAsName" },
+  registrationAddress: { rule: "REQUIRED" },
+  operationalAddressIsSame: { rule: "REQUIRED" },
+  /* Base optional fields */
+  operationalAddress: { rule: "OPTIONAL" },
+  /* Fields with custom country specific rules */
+  hasSelectedBusiness: { rule: "requireBusinessSelection" },
+  stockExchangeMIC: { rule: "ifPubliclyTradedCompany" },
+  stockISIN: { rule: "ifPubliclyTradedCompany" },
+  stockTickerSymbol: { rule: "ifPubliclyTradedCompany" },
+  dateOfIncorporation: { rule: "isDateOfIncorporationRequired" },
+  stateOrProvince: { rule: "countryUsingCompanySearch" },
+  registrationNumber: { rule: "countryRequiresRegistrationNumber" },
+  registrationNumberType: { rule: "registrationNumberType" },
+  exemptedFromRegistrationNumber: { rule: "companyRegistrationNumberExemptionAllowed" },
+  eInvoicingCode: { rule: "isEInvoicingCodeEnabled" },
+  countryOfGoverningLaw: { rule: "countryOfGoverningLawRequired" },
+  taxDocument: { rule: "ifCountryUsAndTinFailed" },
+  /* Fields derived from capabilities */
+  industryCodes: { rule: "isIndustryCodeRequired" }
+};
+const taxInformationBase = {
+  vatNumber: { rule: "countryUsesVat" },
+  vatNumberType: { rule: "vatNumberType" },
+  exemptedFromVat: { rule: "isVatExempt" },
+  vatAbsenceReason: { rule: "isVatExempt" },
+  taxInformation: { rule: "countryUsesTaxId" },
+  exemptedFromTax: { rule: "countryHasTaxExemptions" },
+  isUen: { rule: "countryUsesUenOrGst" }
+};
+const financialInformationBase = {
+  numberOfEmployees: { rule: "countryRequiresFinancialInformation" },
+  financialReportingDate: { rule: "isFinancialReportingFieldsRequired" },
+  currency: { rule: "isFinancialReportingFieldsRequired" },
+  reportedValueOption: { rule: "isFinancialReportingFieldsRequired" },
+  annualTurnover: { rule: "annualTurnoverRequired" },
+  netAssets: { rule: "netAssetsRequired" },
+  balanceSheetTotal: { rule: "balanceSheetTotalRequired" }
+};
+const businessDetailsFieldsPerScenario = {
+  L0: {
+    country: { rule: "REQUIRED" },
+    legalCompanyName: { rule: "REQUIRED" },
+    stateOrProvince: { rule: "countryUsingCompanySearch" },
+    ...financialInformationBase
+  },
+  L1: {
+    ...businessDetailsBase,
+    ...financialInformationBase
+  },
+  L: {
+    ...businessDetailsBase,
+    ...taxInformationBase,
+    ...financialInformationBase
+  },
+  L_PROOFOFADDRESS: {
+    // TODO this field does not exist
+    // proofOfAddressDocument: { rule: 'REQUIRED' },
+  },
+  L_REGDOC: {
+    registrationDocument: { rule: "REQUIRED" }
+  },
+  L_TAXDOC: {
+    taxDocument: { rule: "REQUIRED" }
+  },
+  L_BAFIN: {
+    legalForm: { rule: "REQUIRED" }
+  }
+};
+const adjustFormData = (oldFormData, newFormData) => {
+  const schema = Array.from((/* @__PURE__ */ new Set([...keysOf(oldFormData), ...keysOf(newFormData)])).keys());
+  return schema.reduce((acc, key) => {
+    const oldValue = oldFormData[key];
+    const newValue = newFormData[key];
+    if (!isUndefinedOrNull(newValue)) return { ...acc, [key]: newValue };
+    if (Array.isArray(oldValue)) return { ...acc, [key]: [] };
+    if (typeof oldValue === "number") return { ...acc, [key]: null };
+    if (typeof oldValue === "string") return { ...acc, [key]: "" };
+    return { ...acc, [key]: "" };
+  }, {});
+};
+const setRemovedFieldsOnSchemaToDeletedValue = (newData, existingData) => {
+  const formIds = Array.from((/* @__PURE__ */ new Set([...keysOf(existingData), ...keysOf(newData)])).keys());
+  return formIds.reduce((adjusted, formId) => {
+    const oldFormData = existingData[formId];
+    const newFormData = newData[formId];
+    if (isUndefinedOrNull(oldFormData)) return { ...adjusted, [formId]: newFormData };
+    if (isUndefinedOrNull(newFormData)) return adjusted;
+    return { ...adjusted, [formId]: adjustFormData(oldFormData, newFormData) };
+  }, {});
+};
+const formatFinancialInformationSummary = (data, language, country, dateOfIncorporation) => {
+  let summary;
+  if (!data) return void 0;
+  if (dateOfIncorporation && !isDateOlderThanAYear(dateOfIncorporation)) {
+    if (country === CountryCodes.UnitedKingdom) {
+      summary = { numberOfEmployees: `${data.numberOfEmployees}` };
+      return summary;
+    }
+    return void 0;
+  }
+  summary = {
+    currency: data.currency,
+    financialReportingDate: data.financialReportingDate
+  };
+  if (country === CountryCodes.UnitedKingdom) {
+    summary.numberOfEmployees = `${data.numberOfEmployees}`;
+  }
+  if (data.balanceSheetTotal) {
+    summary.balanceSheetTotal = summaryItem(
+      "balanceSheetTotal",
+      formatCurrency(data.balanceSheetTotal, data.currency, language)
+    );
+  }
+  if (data.annualTurnover) {
+    summary.annualTurnover = formatCurrency(data.annualTurnover, data.currency, language);
+  }
+  return summary;
+};
+const mapBusinessDetailsDocumentToApiDocument = async (data, entityId) => {
+  const {
+    companyRegistrationDocument,
+    companyTaxDocument,
+    companyProofOfDirectorDocument,
+    companyConstitutionalDocument,
+    companyProofOfSignatoryDocument,
+    companyProofOfOwnershipDocument,
+    basicInformation
+  } = data;
+  const taxDocumentType = COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT.includes(
+    basicInformation?.country
+  ) ? "proofOfOrganizationTaxInfo" : "vatDocument";
+  const documents = await Promise.all([
+    createDocumentRequest({
+      entityId,
+      entityType: "legalEntity",
+      documentType: "registrationDocument",
+      page1: companyRegistrationDocument?.registrationDocument?.[0]
+    }),
+    createDocumentRequest({
+      entityId,
+      entityType: "legalEntity",
+      documentType: taxDocumentType,
+      page1: companyTaxDocument?.taxDocument?.[0]
+    }),
+    createDocumentRequest({
+      entityId,
+      entityType: "legalEntity",
+      documentType: "proofOfDirector",
+      page1: companyProofOfDirectorDocument?.proofOfDirector?.[0]
+    }),
+    createDocumentRequest({
+      entityId,
+      entityType: "legalEntity",
+      documentType: "constitutionalDocument",
+      page1: companyConstitutionalDocument?.constitutionalDocument?.[0]
+    }),
+    createDocumentRequest({
+      entityId,
+      entityType: "legalEntity",
+      documentType: "proofOfSignatory",
+      page1: companyProofOfSignatoryDocument?.proofOfSignatory?.[0]
+    }),
+    createDocumentRequest({
+      entityId,
+      entityType: "legalEntity",
+      documentType: "proofOfOwnership",
+      page1: companyProofOfOwnershipDocument?.proofOfOwnership?.[0],
+      page2: companyProofOfOwnershipDocument?.proofOfOwnership?.[1]
+    })
+  ]);
+  return documents.filter(Boolean);
+};
+const mapBusinessDetailsSchemaToLegalEntity = (data, accountHolder, isExperimentEnabled) => {
+  const requestObj = {
+    ...formatObject(
+      data,
+      accountHolder === "mySoleProprietorName" ? solePropBusinessDetailsApiKeyMapping : businessDetailsApiKeyMapping
+    )
+  };
+  delete requestObj.organization?.legalFormDescription;
+  const canSaveRegNumberAbsentState = isExperimentEnabled("EnableRegistrationAndTaxAbsentStatesV4") && isRegistrationNumberAbsentStateV4Scenario(
+    data.basicInformation?.country,
+    data.companyStructure?.entityType
+  );
+  const taxData = COUNTRIES_USING_COMPANY_SEARCH.includes(
+    data.basicInformation?.country
+  ) ? data.basicInformation?.taxInformation : data.additionalInformation?.taxInformation;
+  const registrationNumber = COUNTRIES_USING_COMPANY_SEARCH.includes(
+    data.basicInformation?.country
+  ) ? data.basicInformation?.registrationNumber : data.additionalInformation?.registrationNumber;
+  const localization = [
+    mapSchemaFieldsToApiScriptLocalization(data.basicInformation ?? {}, "jaHani"),
+    mapSchemaFieldsToApiScriptLocalization(data.basicInformation ?? {}, "jaKana")
+  ].filter(({ fields }) => !isEmpty$1(fields)).map(({ script, fields }) => ({
+    script,
+    // mismatch between API `legalName` and schema `legalCompanyName`
+    fields: { legalName: fields.legalCompanyName }
+  }));
+  const doingBusinessAs = data.additionalInformation?.doingBusinessAs ?? "";
+  const entityObject = isEmpty$1(data.companyStructure) ? requestObj.soleProprietorship : requestObj.organization;
+  if (entityObject) {
+    if (taxData) {
+      entityObject.taxInformation = taxData;
+    }
+    if (!!requestObj.soleProprietorship && !requestObj.soleProprietorship?.countryOfGoverningLaw && !!data.basicInformation?.country) {
+      requestObj.soleProprietorship.countryOfGoverningLaw = data.basicInformation.country;
+    }
+    if (registrationNumber) {
+      entityObject.registrationNumber = registrationNumber;
+      if (canSaveRegNumberAbsentState && requestObj.organization) {
+        requestObj.organization.registrationNumberAbsent = false;
+      }
+    }
+    if (requestObj.organization && entityObject && localization.length > 0) {
+      entityObject.localization = localization;
+    }
+    if (data.additionalInformation?.exemptedFromRegistrationNumber && canSaveRegNumberAbsentState && requestObj.organization) {
+      requestObj.organization.registrationNumberAbsent = data.additionalInformation?.exemptedFromRegistrationNumber;
+    }
+    if (data.additionalInformation?.vatAbsenceReason) {
+      entityObject.vatNumber = "";
+    }
+    if (isExperimentEnabled("EnableDoingBusinessAsNameV4")) {
+      if (typeof data.additionalInformation?.hasDoingBusinessAs !== "undefined") {
+        entityObject.doingBusinessAsAbsent = !data.additionalInformation?.hasDoingBusinessAs;
+      }
+    } else {
+      entityObject.doingBusinessAs = doingBusinessAs || data.basicInformation?.legalCompanyName;
+      delete entityObject.doingBusinessAsAbsent;
+    }
+    if (data.additionalInformation?.operationalAddressIsSame === operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_SAME && entityObject.principalPlaceOfBusiness) {
+      entityObject.principalPlaceOfBusiness = entityObject.registeredAddress;
+    }
+    if (entityObject.registeredAddress) {
+      const addressLocalizations = mapJpAddressSchemaToAddressLocalizations(
+        data.additionalInformation?.registrationAddress
+      );
+      if (addressLocalizations.length > 0)
+        entityObject.registeredAddress.localization = addressLocalizations;
+    }
+    if (!isEmpty$1(data.companyFinancialInformation)) {
+      const isIncorporationDateDependencyEnabled = isExperimentEnabled(
+        "EnableIncorporationDateBasedFinancialValidationForHO"
+      );
+      entityObject.financialReports = [
+        mapFinancialInformationToFinancialReport(
+          data.companyFinancialInformation,
+          isIncorporationDateDependencyEnabled ? data?.additionalInformation?.dateOfIncorporation : void 0
+        )
+      ];
+    }
+  }
+  requestObj.type = requestObj.organization ? LegalEntityTypes.ORGANIZATION : LegalEntityTypes.SOLE_PROPRIETORSHIP;
+  if (entityObject?.registeredAddress.country === "US") {
+    delete entityObject.registrationNumber;
+  }
+  if (!canSaveRegNumberAbsentState) {
+    delete requestObj.organization?.registrationNumberAbsent;
+  }
+  return requestObj;
+};
+function buildRequiredForms({
+  config: {
+    forms,
+    requiredFields,
+    optionalFields,
+    isValid,
+    problems,
+    isSettingEnabled,
+    accountHolder,
+    legalEntityResponse
+  },
+  options
+}) {
+  const skipCompanyStructure = !!verifiedBusiness.value?.legalForm || isSettingEnabled(SettingNames.AllowLegalEntityTypeChange) && organizationTypesToSkipCompanyStructureForm.includes(
+    legalEntityResponse?.organization?.type ?? ""
+  ) && accountHolder !== "aTrust" && accountHolder !== "anUnincorporatedPartnership";
+  const filteredForms = Object.values(forms).filter(({ formId }) => {
+    if (formId === "businessSelection") {
+      if (options?.hasNoSearchResults || isVerifiedSingleCompanySearchResult.value) return false;
+    }
+    if (formId === "companyStructure") {
+      if (skipCompanyStructure) return false;
+    }
+    if (requiredFields || optionalFields) {
+      return Boolean(requiredFields?.[formId]) || Boolean(optionalFields?.[formId]);
+    }
+    return true;
+  });
+  const requiredForms = options?.skipSummary ? filteredForms : [...filteredForms, summaryStep];
+  return addValidityToForms(requiredForms, isValid, problems);
+}
+const isDocumentsRequired = (forms) => forms.some((form) => documentFormsIds.includes(form.formId));
+const formatBasicInformation = (data, datasetUtils, companyType, isCountryOfGoverningLawEnabled) => {
+  const country = data?.country;
+  const registrationNumberLabel = resolveFieldMetadata(
+    registrationNumberDefaultFieldConfig[country],
+    {
+      companyType,
+      registrationNumberType: data.registrationNumber ? inferCompanyRegistrationNumberType(data?.registrationNumber, country, companyType) : getCompanyRegistrationNumberOptions(country, companyType)?.[0]?.id
+    },
+    registrationNumberDefaultFieldMetadata
+  ).label;
+  const taxIdLabel = resolveFieldMetadata(
+    taxInformationDefaultFieldConfig[country],
+    {
+      taxIdNumberType: countryToTaxInfoTypeMap[country] ?? void 0,
+      // TODO use type selector
+      companyType: void 0
+    },
+    taxInformationDefaultFieldMetadata
+  ).label;
+  const countryOfGoverningLaw = getCountryOfGoverningLaw(isCountryOfGoverningLawEnabled, data);
+  return {
+    ["legalCompanyName"]: data.legalCompanyName,
+    country: datasetUtils.getCountryName(data.country),
+    [getKeyForField("stateOrProvince", data.country)]: datasetUtils.getStateName(
+      data.stateOrProvince,
+      data.country
+    ),
+    [taxIdLabel]: data.taxInformation?.find((taxId) => data.country === taxId.country)?.number,
+    [registrationNumberLabel]: data.registrationNumber,
+    countryOfGoverningLaw: datasetUtils.getCountryName(countryOfGoverningLaw)
+  };
+};
+const formatAdditionalInformation = (data, country, companyType, t) => {
+  const registrationNumberLabel = resolveFieldMetadata(
+    registrationNumberDefaultFieldConfig[country],
+    {
+      companyType,
+      registrationNumberType: data.registrationNumber ? inferCompanyRegistrationNumberType(data?.registrationNumber, country, companyType) : getCompanyRegistrationNumberOptions(country, companyType)?.[0]?.id
+    },
+    registrationNumberDefaultFieldMetadata
+  ).label;
+  const taxIdLabel = resolveFieldMetadata(
+    taxInformationDefaultFieldConfig[country],
+    {
+      taxIdNumberType: countryToTaxInfoTypeMap[country] ?? void 0,
+      // TODO use type selector
+      companyType: void 0
+    },
+    taxInformationDefaultFieldMetadata
+  ).label;
+  return {
+    ["businessStructure"]: data.legalFormLabel,
+    ["doingBusinessAs"]: data.doingBusinessAs,
+    ["industry"]: data.industryCodes?.[0].name,
+    [registrationNumberLabel]: data.registrationNumber,
+    [taxIdLabel]: data.isUen ? void 0 : data.taxInformation?.find((taxId) => country === taxId.country)?.number,
+    ["vatNumber"]: data.vatNumber,
+    ["vatAbsenceReason"]: data.vatAbsenceReason ? t(($) => $[data.vatAbsenceReason], { ns: "common" }) : void 0,
+    ["dateOfIncorporation"]: data.dateOfIncorporation,
+    ["stockExchangeMIC"]: data.stockExchangeMIC,
+    ["stockISIN"]: data.stockISIN,
+    ["stockTickerSymbol"]: data.stockTickerSymbol,
+    ["eInvoicingCode"]: data.eInvoicingCode
+  };
+};
+const formatDataForSummary = (data, forms, t, language, isExperimentEnabled) => {
+  const datasetUtils = datasetUtilities(language);
+  return entriesOf(data).reduce((summaryData, [form]) => {
+    if (!form || !data[form]) return summaryData;
+    const isCountryOfGoverningLawEnabled = isExperimentEnabled(
+      "EnableCountryOfGoverningLawForUKCompanies"
+    );
+    switch (form) {
+      case "basicInformation":
+        return {
+          ...summaryData,
+          [form]: formatBasicInformation(
+            data[form],
+            datasetUtils,
+            data.companyStructure?.entityType,
+            isCountryOfGoverningLawEnabled
+          )
+        };
+      case "companyStructure":
+        return {
+          ...summaryData,
+          [form]: {
+            entityType: t(
+              ($) => $[companyTypeMetadata[data["companyStructure"]?.entityType]?.name],
+              {
+                ns: "business"
+              }
+            )
+          }
+        };
+      case "additionalInformation":
+        return {
+          ...summaryData,
+          [form]: {
+            hasInnerForms: true,
+            additionalInformationFormName: formatAdditionalInformation(
+              data[form],
+              data.basicInformation?.country,
+              data.companyStructure?.entityType,
+              t
+            ),
+            registrationAddress: data.basicInformation?.country === CountryCodes.Japan ? mapJpAddressSummary(data[form].registrationAddress, datasetUtils) : mapAddressLabels(data[form].registrationAddress, datasetUtils),
+            operationalAddress: data[form].operationalAddressIsSame === operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME ? data.basicInformation?.country === CountryCodes.Japan ? mapJpAddressSummary(data[form].operationalAddress, datasetUtils) : mapAddressLabels(data[form].operationalAddress, datasetUtils) : void 0
+          }
+        };
+      case "companyRegistrationDocument":
+        if (!isDocumentsRequired(forms)) return summaryData;
+        return {
+          ...summaryData,
+          [form]: {
+            companyRegistrationDocument: {
+              fileName: data[form].registrationDocument?.[0]?.name
+            }
+          }
+        };
+      case "companyTaxDocument":
+        if (!isDocumentsRequired(forms)) return summaryData;
+        return {
+          ...summaryData,
+          [form]: {
+            companyTaxDocument: {
+              fileName: data[form].taxDocument?.[0]?.name
+            }
+          }
+        };
+      case "companyProofOfDirectorDocument":
+        if (!isDocumentsRequired(forms)) return summaryData;
+        return {
+          ...summaryData,
+          [form]: {
+            companyProofOfDirectorDocument: {
+              fileName: data[form].proofOfDirector?.[0]?.name
+            }
+          }
+        };
+      case "companyProofOfSignatoryDocument":
+        if (!isDocumentsRequired(forms)) return summaryData;
+        return {
+          ...summaryData,
+          [form]: {
+            companyProofOfSignatoryDocument: {
+              fileName: data[form].proofOfSignatory?.[0]?.name
+            }
+          }
+        };
+      case "companyProofOfOwnershipDocument":
+        if (!isDocumentsRequired(forms)) return summaryData;
+        return {
+          ...summaryData,
+          [form]: {
+            companyProofOfOwnershipDocument: {
+              fileName: data[form].proofOfOwnership?.map((doc) => doc.name).join("\n")
+            }
+          }
+        };
+      case "companyFinancialInformation": {
+        const isIncorporationDateDependencyEnabled = isExperimentEnabled(
+          "EnableIncorporationDateBasedFinancialValidationForHO"
+        );
+        return {
+          ...summaryData,
+          [form]: formatFinancialInformationSummary(
+            data[form],
+            language,
+            data?.basicInformation?.country,
+            isIncorporationDateDependencyEnabled ? data?.additionalInformation?.dateOfIncorporation : void 0
+          )
+        };
+      }
+      default:
+        return summaryData;
+    }
+  }, {});
+};
+async function submitDocuments({
+  data,
+  legalEntity,
+  forms,
+  documentUtils,
+  userEvents
+}) {
+  if (!isDocumentsRequired(forms)) return;
+  const logger = createLogger();
+  const formattedDocument = await mapBusinessDetailsDocumentToApiDocument(data, legalEntity.id);
+  try {
+    if (formattedDocument) {
+      await documentUtils.uploadDocuments(formattedDocument, legalEntity.id);
+      formattedDocument.forEach((doc) => {
+        userEvents?.addTaskEvent("Success", {
+          actionType: "upload",
+          documentType: doc.type,
+          fileExtention: doc.attachments?.map((item) => getFileExtention(item.pageName)).filter((item) => item !== void 0) ?? []
+        });
+      });
+    }
+  } catch (err) {
+    logger.error(err);
+    userEvents.addTaskEvent("Encountered error", {
+      actionType: "upload",
+      returnType: err.errorCode,
+      returnValue: err.title ?? err.message
+    });
+  }
+}
+async function submit({
+  data,
+  legalEntityResponse,
+  associatedLegalArrangement,
+  nestedLegalEntity,
+  nestedLegalEntityDetails,
+  problems,
+  taskType,
+  accountHolder,
+  forms,
+  documentUtils,
+  t,
+  showToast,
+  setLoadingStatus,
+  setProblems,
+  handleUpdateLegalEntity,
+  createLegalEntity,
+  onExternalSubmit,
+  isExperimentEnabled,
+  userEvents,
+  efpBusinessLines,
+  createBusinessLine,
+  updateBusinessLine
+}) {
+  const logger = createLogger();
+  setLoadingStatus("loading");
+  let trackingPayload = {
+    actionType: "submit",
+    companyStructure: data.companyStructure?.entityType,
+    countryOfRegistration: data.basicInformation?.country,
+    legalEntityName: accountHolder === "theCompanyIWorkFor" ? data.basicInformation?.legalCompanyName : void 0,
+    // Only send legalCompanyName for organizations
+    usedAdditionalAddress: data.additionalInformation?.operationalAddressIsSame === operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME
+  };
+  const entityToUpdate = (() => {
+    switch (taskType) {
+      case TaskTypes.SOLE_PROPRIETOR_COMPANY:
+        return associatedLegalArrangement;
+      case TaskTypes.TRUST_MEMBER_COMPANY:
+      case TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY:
+        return nestedLegalEntity;
+      case TaskTypes.BUSINESS_DETAILS:
+      default:
+        return legalEntityResponse;
+    }
+  })();
+  const handleSubmitLegalEntity = async (legalEntity) => {
+    if (taskType === TaskTypes.TRUST_MEMBER_COMPANY && !nestedLegalEntity?.id || taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY && !nestedLegalEntity?.id || taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY && !associatedLegalArrangement?.id) {
+      return await createLegalEntity(legalEntity);
+    } else {
+      return handleUpdateLegalEntity({
+        ...drop("type").from(legalEntity),
+        id: entityToUpdate?.id ?? legalEntityResponse.id
+      });
+    }
+  };
+  const associateLegalEntityWithParent = async ({
+    legalEntity,
+    associatedLegalArrangement: associatedLegalArrangement2,
+    nestedLegalEntityDetails: nestedLegalEntityDetails2
+  }) => {
+    if (nestedLegalEntityDetails2 && associatedLegalArrangement2) {
+      const existingEntityAssociations = getOwnEntityAssociations(associatedLegalArrangement2);
+      const existingRoles = existingEntityAssociations.filter((ea) => ea.legalEntityId === associatedLegalArrangement2.id).map(({ type }) => type);
+      const newRoles = nestedLegalEntityDetails2?.roles ?? [];
+      const rolesChanged = !doArraysMatch(existingRoles, newRoles);
+      if (rolesChanged) {
+        const updatedAssociations = {
+          entityAssociations: [
+            ...newRoles.map((role) => ({
+              type: role,
+              legalEntityId: legalEntity.id
+            })) || [],
+            ...existingEntityAssociations.filter((ea) => ea.legalEntityId !== legalEntity.id) || []
+          ]
+        };
+        await handleUpdateLegalEntity({
+          ...updatedAssociations,
+          id: associatedLegalArrangement2.id
+        });
+      }
+      return;
+    } else {
+      const updatedAssociations = {
+        entityAssociations: [
+          {
+            type: LegalEntityTypes.SOLE_PROPRIETORSHIP,
+            legalEntityId: legalEntity.id
+          }
+        ]
+      };
+      await handleUpdateLegalEntity({ ...updatedAssociations, id: legalEntityResponse.id });
+    }
+  };
+  const savedLegalEntityData = legalEntityResponse ? mapLegalEntityToBusinessDetailsSchema(legalEntityResponse, void 0) : null;
+  const filteredData = savedLegalEntityData ? setRemovedFieldsOnSchemaToDeletedValue(data, savedLegalEntityData) : data;
+  if (filteredData?.additionalInformation && !filteredData?.additionalInformation?.taxInformation) {
+    filteredData.additionalInformation.taxInformation = void 0;
+  }
+  const isCountryOfGoverningLawEnabled = isExperimentEnabled(
+    "EnableCountryOfGoverningLawForUKCompanies"
+  );
+  const countryOfGoverningLaw = getCountryOfGoverningLaw(
+    isCountryOfGoverningLawEnabled,
+    filteredData?.basicInformation
+  );
+  if (filteredData?.basicInformation) {
+    if (countryOfGoverningLaw) {
+      filteredData.basicInformation.countryOfGoverningLaw = countryOfGoverningLaw;
+    } else {
+      delete filteredData.basicInformation.countryOfGoverningLaw;
+    }
+  }
+  const primaryIndustryCode = data.additionalInformation?.industryCodes && data.additionalInformation.industryCodes[0].id;
+  if (createBusinessLine && updateBusinessLine && primaryIndustryCode) {
+    const bankingBusinessLines = [];
+    const issuingBusinessLines = [];
+    if (efpBusinessLines) {
+      for (const bl of efpBusinessLines) {
+        if (bl.service === "banking") bankingBusinessLines.push(bl);
+        else issuingBusinessLines.push(bl);
+      }
+    }
+    const promises = [];
+    const operations = [];
+    const updateOrCreateBusinessLinesIfNeeded = (businessLines, requestedCapability, service) => {
+      if (businessLines.length) {
+        for (const bl of businessLines) {
+          if (bl.industryCode === primaryIndustryCode) continue;
+          const payload = {
+            id: bl.id,
+            legalEntityId: legalEntityResponse.id,
+            industryCode: primaryIndustryCode,
+            service
+          };
+          promises.push(updateBusinessLine(payload));
+          operations.push(payload);
+        }
+      } else if (requestedCapability) {
+        const payload = {
+          legalEntityId: legalEntityResponse.id,
+          industryCode: primaryIndustryCode,
+          service
+        };
+        promises.push(createBusinessLine(payload));
+        operations.push(payload);
+      }
+    };
+    updateOrCreateBusinessLinesIfNeeded(
+      bankingBusinessLines,
+      requestingBanking(legalEntityResponse),
+      "banking"
+    );
+    updateOrCreateBusinessLinesIfNeeded(
+      issuingBusinessLines,
+      requestingIssuing(legalEntityResponse),
+      "issuing"
+    );
+    let hadRejection = false;
+    (await Promise.allSettled(promises)).forEach((result, idx) => {
+      if (result.status !== "rejected") return;
+      const op = operations[idx];
+      logger.log(
+        `Failed to ${op.id ? "update" : "create"} business line with payload: ${JSON.stringify(op)}`
+      );
+      hadRejection = true;
+    });
+    const eventPayload = {
+      actionType: trackingPayload.actionType,
+      legalEntityName: trackingPayload.legalEntityName
+    };
+    if (!hadRejection) {
+      userEvents?.addTaskEvent("Success", eventPayload);
+    } else {
+      userEvents?.addTaskEvent("Encountered error", {
+        ...eventPayload,
+        returnType: "businessLines",
+        returnValue: "couldNotCreateOrUpdateBusinessLine"
+      });
+      showToast({
+        label: t(($) => $["failedToUpdateEfpBusinessLines"], { ns: "business" }),
+        variant: "error"
+      });
+      return setLoadingStatus("success");
+    }
+  }
+  try {
+    const mappedLegalEntity = {
+      ...mapBusinessDetailsSchemaToLegalEntity(filteredData, accountHolder, isExperimentEnabled),
+      entityAssociations: filterOutUnwantedAssociationsIfRootLE(
+        taskType,
+        entityToUpdate,
+        accountHolder
+      )
+    };
+    if (mappedLegalEntity.type === LegalEntityTypes.ORGANIZATION && legalEntityResponse.organization?.countryOfGoverningLaw !== mappedLegalEntity.organization?.countryOfGoverningLaw && legalEntityResponse.organization?.support) {
+      mappedLegalEntity.organization.support = determineCustomerSupport(
+        legalEntityResponse.organization.support,
+        mappedLegalEntity.organization?.countryOfGoverningLaw
+      );
+    }
+    const legalEntity = await handleSubmitLegalEntity(mappedLegalEntity);
+    if (taskType === TaskTypes.TRUST_MEMBER_COMPANY || taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY || taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY && !associatedLegalArrangement?.id) {
+      await associateLegalEntityWithParent({
+        legalEntity,
+        associatedLegalArrangement,
+        nestedLegalEntityDetails
+      });
+    }
+    await submitDocuments({
+      data,
+      legalEntity,
+      documentUtils,
+      forms,
+      userEvents
+    });
+    userEvents?.addTaskEvent("Success", trackingPayload);
+    showToast({
+      label: t(($) => $["successfullyUpdatedDetails"], { ns: "common" }),
+      variant: "success"
+    });
+    onExternalSubmit?.(data);
+  } catch (err) {
+    if (isValidationError(err)) {
+      const getErrors = processValidationErrors(err, TaskTypes.BUSINESS_DETAILS);
+      if (getErrors && !Object.keys(getErrors).length) {
+        showToast({
+          label: t(($) => $["failedToUpdateDetails"], { ns: "common" }),
+          variant: "error"
+        });
+        const unmappedErrorNames = err.invalidFields?.map((field) => field.name).filter(Boolean) ?? [];
+        if (unmappedErrorNames.length) {
+          trackingPayload = {
+            ...trackingPayload,
+            additionalData: { unmappedErrorNames }
+          };
+        }
+      } else {
+        setProblems({
+          ...problems,
+          validationErrors: getErrors
+        });
+      }
+    }
+    if (isMaintenanceModeError(err)) {
+      showToast({
+        label: t(($) => $["maintenanceModeMessage"], { ns: "common" }),
+        variant: "error",
+        duration: "indefinite"
+      });
+    }
+    if (!isValidationError(err) && !isMaintenanceModeError(err)) {
+      showToast({
+        label: t(($) => $["failedToUpdateDetails"], { ns: "common" }),
+        variant: "error"
+      });
+    }
+    logger.error(err);
+    userEvents?.addTaskEvent("Encountered error", {
+      ...trackingPayload,
+      returnType: err?.errorCode,
+      returnValue: err?.title || "backend"
+    });
+  } finally {
+    setLoadingStatus("success");
+  }
+}
+const getCountryOfGoverningLaw = (isCountryOfGoverningLawEnabled, basicData) => {
+  if (!isCountryOfGoverningLawEnabled || basicData?.country !== CountryCodes.UnitedKingdom) {
+    return void 0;
+  }
+  if (isCountryOfGoverningLawEnabled && basicData?.country === CountryCodes.UnitedKingdom && !basicData?.countryOfGoverningLaw) {
+    return CountryCodes.UnitedKingdom;
+  }
+  return basicData?.countryOfGoverningLaw;
+};
+const determineCustomerSupport = (customerSupport, country) => {
+  switch (country) {
+    case CountryCodes.Japan:
+      return unsetCustomerSupportNumber(customerSupport);
+    default:
+      return customerSupport;
+  }
+};
+const unsetCustomerSupportNumber = (customerSupport) => {
+  return customerSupport ? {
+    email: customerSupport.email,
+    phone: { number: "", type: "mobile" }
+  } : void 0;
+};
+const CountryFieldValidation = () => ({
+  country: {
+    modes: ["blur"],
+    validate: (country) => !isEmpty(country),
+    errorMessage: "fieldIsRequired"
+  }
+});
+const CountryOfGoverningLawFieldValidation = () => ({
+  countryOfGoverningLaw: {
+    modes: ["blur"],
+    validate: (countryOfGoverningLaw) => !isEmpty(countryOfGoverningLaw),
+    errorMessage: "fieldIsRequired"
+  }
+});
+function basicInformationValidators({
+  country,
+  taxIdNumberType,
+  companyType,
+  registrationNumberType,
+  state,
+  isExperimentEnabled
+}) {
+  return {
+    country: CountryFieldValidation().country,
+    countryOfGoverningLaw: CountryOfGoverningLawFieldValidation().countryOfGoverningLaw,
+    legalCompanyName: resolveFieldMetadata(
+      isExperimentEnabled("StrictNameAndAddressValidationV4") ? defaultFieldConfigV4[country] : defaultFieldConfig$2[country],
+      { isBusiness: true },
+      isExperimentEnabled("StrictNameAndAddressValidationV4") ? defaultFieldMetadataV4 : defaultFieldMetadata$2
+    )?.validators,
+    taxInformation: resolveFieldMetadata(
+      taxInformationDefaultFieldConfig[country],
+      {
+        taxIdNumberType,
+        companyType
+      },
+      taxInformationDefaultFieldMetadata
+    )?.validators,
+    stateOrProvince: resolveFieldMetadata(
+      defaultFieldConfig$1[country],
+      { isBusiness: true },
+      defaultFieldMetadata$1
+    )?.validators,
+    registrationNumber: resolveFieldMetadata(
+      registrationNumberDefaultFieldConfig[country],
+      {
+        companyType,
+        registrationNumberType,
+        state,
+        isExperimentEnabled
+      },
+      registrationNumberDefaultFieldMetadata
+    )?.validators
+  };
+}
+function businessSelectionValidators() {
+  return {
+    hasSelectedBusiness: {
+      modes: ["blur", "input"],
+      validate: (value) => typeof value === "boolean",
+      // indicates a selection was made
+      errorMessage: "fieldIsRequired"
+    }
+  };
+}
+function additionalInformationValidators({
+  country,
+  taxIdNumberType,
+  companyType,
+  registrationNumberType,
+  vatNumberType,
+  isExperimentEnabled
+}) {
+  return {
+    hasDoingBusinessAs: doingBusinessAsAbsentFieldMetadata.validators,
+    doingBusinessAs: doingBusinessAsFieldMetadata.validators,
+    registrationNumber: resolveFieldMetadata(
+      registrationNumberDefaultFieldConfig[country],
+      {
+        companyType,
+        registrationNumberType,
+        isExperimentEnabled
+      },
+      registrationNumberDefaultFieldMetadata
+    )?.validators,
+    exemptedFromRegistrationNumber: exemptFromRegistrationNumberDefaultFieldMetadata.validators,
+    taxInformation: resolveFieldMetadata(
+      taxInformationDefaultFieldConfig[country],
+      {
+        taxIdNumberType,
+        companyType
+      },
+      taxInformationDefaultFieldMetadata
+    ).validators,
+    vatNumber: resolveFieldMetadata(
+      defaultFieldConfig[country],
+      { vatNumberType },
+      defaultFieldMetadata
+    ).validators,
+    vatAbsenceReason: vatAbsenceReasonMetadata.validators,
+    eInvoicingCode: eInvoicingCodeFieldMetadata.validators,
+    industryCodes: industryCodeFieldMetadata.validators,
+    dateOfIncorporation: dateOfIncorporationFieldMetadata.validators,
+    stockExchangeMIC: stockExchangeMICFieldMetadata.validators,
+    stockISIN: stockISINFieldMetadata.validators,
+    stockTickerSymbol: stockTickerSymbolFieldMetadata.validators
+  };
+}
+function BusinessDetailsDropin({
+  taskType = TaskTypes.BUSINESS_DETAILS,
+  country: propCountry,
+  problems: propProblems,
+  legalEntityResponse,
+  associatedLegalArrangement,
+  // initially undefined when creating entity
+  nestedLegalEntity,
+  // initially undefined when creating entity
+  nestedLegalEntityDetails,
+  // has entity roles for association logic
+  onSubmit: onExternalSubmit,
+  handleHomeClick,
+  asModal = false
+}) {
+  const { t, i18n } = useTranslation(["common", "business"]);
+  const { baseUrl, rootLegalEntityId } = useApiContext();
+  const userEvents = useAnalyticsContext();
+  const { showToast } = useToastContext();
+  const queryClient = useQueryClient();
+  const { isExperimentEnabled } = useExperimentsContext();
+  const { isSettingEnabled } = useSettingsContext();
+  const { accountHolder, setAccountHolder } = useAccountHolder();
+  const { mutateAsync: createLegalEntity } = useCreateLegalEntity();
+  const { mutateAsync: updateLegalEntity } = useUpdateLegalEntity();
+  const logger = createLogger();
+  const isSoleProp = accountHolder === "mySoleProprietorName";
+  const isAssociationTaskType = !taskType ? accountHolder !== "theCompanyIWorkFor" : taskType !== TaskTypes.BUSINESS_DETAILS;
+  const legalEntityType = !isSoleProp ? LegalEntityTypes.ORGANIZATION : LegalEntityTypes.SOLE_PROPRIETORSHIP;
+  const subjectEntity = !isAssociationTaskType ? legalEntityResponse : isSoleProp ? associatedLegalArrangement : nestedLegalEntity;
+  const [country, setCountry] = useState(propCountry);
+  const [documents, setDocuments] = useState();
+  const [problems, setProblems] = useState(propProblems ?? {});
+  const [loadingStatus, setLoadingStatus] = useState("success");
+  const [derivedProps, setDerivedProps] = useState();
+  const [trustedFields, setTrustedFields] = useState(subjectEntity?.trustedFields ?? void 0);
+  const defaultForms = useMemo(() => getForms(country), [country]);
+  const documentUtils = documentApiUtils({
+    baseUrl: baseUrl.value,
+    rootLegalEntityId: rootLegalEntityId.value
+  });
+  useEffect(() => {
+    if (!subjectEntity?.documentDetails?.length) return;
+    documentUtils.fetchDocuments(subjectEntity.documentDetails, subjectEntity?.id).then(() => {
+      setDocuments(mapApiDocumentToBusinessDetailsDocuments(subjectEntity?.id));
+    }).catch(() => {
+      showToast({
+        label: t(($) => $["failedToFetchRelevantDocuments"], { ns: "common" }),
+        variant: "error"
+      });
+    });
+  }, [subjectEntity?.documentDetails, subjectEntity?.id]);
+  useEffect(() => {
+    userEvents.updateBaseTrackingPayload({ task: taskType });
+    userEvents.addTaskEvent("Landed on page", {
+      actionType: "start"
+    });
+  }, []);
+  const parseConfiguration = useCallback(
+    ({ scenarios }) => composePerScenarioFormConfigurations(scenarios, businessDetailsFieldsPerScenario),
+    []
+  );
+  const { fieldConfigurations } = useScenarioConfiguration({
+    legalEntityType,
+    parseConfiguration,
+    setLoadingStatus,
+    country
+  });
+  const { data: efpBusinessLines } = useBusinessLines(ALLOWED_SOF_SERVICES, {
+    enabled: isSettingEnabled("allowBusinessLines")
+  });
+  const defaultData = useMemo(() => {
+    const mapped = mapLegalEntityToBusinessDetailsSchema(
+      !isAssociationTaskType ? legalEntityResponse : isSoleProp ? associatedLegalArrangement ?? legalEntityResponse : nestedLegalEntity,
+      isSoleProp ? legalEntityResponse : void 0
+    );
+    const initialEfpBusinessLineData = isSettingEnabled("allowBusinessLines") && efpBusinessLines && efpBusinessLines.length > 0 ? {
+      additionalInformation: {
+        ...mapped.additionalInformation,
+        industryCodes: [
+          {
+            id: efpBusinessLines[0].industryCode,
+            name: `${efpBusinessLines[0].industryCode} - ${efpBusinessLines[0].industryCodeDescription}`
+          }
+        ]
+      }
+    } : {};
+    return {
+      ...mapped,
+      ...documents,
+      ...initialEfpBusinessLineData
+    };
+  }, [
+    isAssociationTaskType,
+    legalEntityResponse,
+    isSoleProp,
+    associatedLegalArrangement,
+    nestedLegalEntity,
+    documents,
+    efpBusinessLines,
+    isSettingEnabled
+  ]);
+  const buildFieldValidations = useCallback(
+    (data) => {
+      const taxInfo = data?.basicInformation?.taxInformation ?? data?.additionalInformation?.taxInformation;
+      const taxIdType = taxInfo?.length ? taxInfo.find((taxId) => taxId.country === country)?.type : void 0;
+      const regNumberType = data?.basicInformation?.registrationNumberType ?? data?.additionalInformation?.registrationNumberType;
+      return {
+        basicInformation: basicInformationValidators({
+          country,
+          state: data?.basicInformation?.stateOrProvince,
+          companyType: data?.companyStructure?.entityType,
+          taxIdNumberType: taxIdType,
+          registrationNumberType: regNumberType,
+          isExperimentEnabled
+        }),
+        businessSelection: businessSelectionValidators(),
+        companyStructure: CompanyStructureValidation,
+        additionalInformation: additionalInformationValidators({
+          country,
+          taxIdNumberType: taxIdType,
+          companyType: data?.companyStructure?.entityType,
+          registrationNumberType: regNumberType,
+          vatNumberType: data?.additionalInformation?.vatNumberType,
+          isExperimentEnabled
+        }),
+        financialInformation: financialInfoValidationWithEmployeesRules
+      };
+    },
+    [country, isExperimentEnabled]
+  );
+  const multiForm = useMultiForm({
+    defaultData,
+    allFields: derivedProps?.allFields,
+    requiredFields: derivedProps?.requiredFields,
+    optionalFields: derivedProps?.optionalFields,
+    obscuredFields: derivedProps?.obscuredFields,
+    trustedFields: derivedProps?.trustedFields,
+    rules: buildFieldValidations
+  });
+  const isTinMatched = tinMatched.value;
+  const customRules = useMemo(
+    () => rules({
+      data: multiForm.data,
+      country,
+      taskType,
+      isExperimentEnabled,
+      isSettingEnabled,
+      accountHolder,
+      tinMatched: isTinMatched,
+      rootLegalEntity: legalEntityResponse
+    }),
+    [
+      multiForm.data,
+      country,
+      taskType,
+      isExperimentEnabled,
+      isSettingEnabled,
+      accountHolder,
+      isTinMatched,
+      legalEntityResponse
+    ]
+  );
+  useEffect(() => {
+    const props = getPropsFromConfigurations({
+      scenarioConfiguration: fieldConfigurations,
+      forms: defaultForms,
+      remediationActions: problems?.remediationActions ? Object.values(problems?.remediationActions) : [],
+      dataMissingErrors: problems?.missingData ?? [],
+      fieldsWithExistingData: subjectEntity ? subjectEntity.type === LegalEntityTypes.SOLE_PROPRIETORSHIP ? getFieldsWithExistingData(
+        subjectEntity,
+        solePropBusinessDetailsApiKeyMapping,
+        solePropBusinessDetailsDocumentMapping
+      ) : getFieldsWithExistingData(
+        subjectEntity,
+        businessDetailsApiKeyMapping,
+        businessDetailsDocumentMapping
+      ) : [],
+      customRules,
+      legalEntityType: subjectEntity?.type,
+      legalEntityTrustedFields: trustedFields
+    });
+    setDerivedProps(props);
+  }, [
+    customRules,
+    defaultForms,
+    subjectEntity,
+    problems?.missingData,
+    problems?.remediationActions,
+    trustedFields,
+    fieldConfigurations
+  ]);
+  const [prevCountry, setPrevCountry] = useState(multiForm.data.basicInformation?.country);
+  if (multiForm.data.basicInformation?.country && prevCountry !== multiForm.data.basicInformation?.country) {
+    setCountry(multiForm.data?.basicInformation?.country);
+    setPrevCountry(multiForm.data.basicInformation?.country);
+    setTrustedFields(void 0);
+    verifiedBusiness.value = void 0;
+    tinMatched.value = void 0;
+    businessMismatchModalOpen.value = false;
+  }
+  const [forms, setForms] = useState(
+    buildRequiredForms({
+      config: {
+        forms: defaultForms,
+        requiredFields: derivedProps?.requiredFields,
+        optionalFields: derivedProps?.optionalFields,
+        isValid: multiForm.isValid ?? {},
+        problems,
+        isSettingEnabled,
+        accountHolder,
+        legalEntityResponse
+      },
+      options: {
+        hasNoSearchResults: false
+      }
+    })
+  );
+  const updateForms = useCallback(
+    ({ searchResults }) => {
+      const updatedForms = buildRequiredForms({
+        config: {
+          forms: defaultForms,
+          requiredFields: derivedProps?.requiredFields,
+          optionalFields: derivedProps?.optionalFields,
+          isValid: multiForm.isValid ?? {},
+          problems,
+          isSettingEnabled,
+          accountHolder,
+          legalEntityResponse
+        },
+        options: {
+          hasNoSearchResults: searchResults && !searchResults.length
+        }
+      });
+      setForms(updatedForms);
+      return updatedForms;
+    },
+    [
+      defaultForms,
+      derivedProps?.optionalFields,
+      derivedProps?.requiredFields,
+      multiForm.isValid,
+      problems,
+      isSettingEnabled,
+      accountHolder,
+      legalEntityResponse
+    ]
+  );
+  const summaryData = useMemo(
+    () => formatDataForSummary(multiForm.data, forms, t, i18n.language, isExperimentEnabled),
+    [multiForm.data, forms, t, i18n.language, isExperimentEnabled]
+  );
+  const { mutateAsync: createBusinessLine } = useCreateBusinessLine();
+  const { mutateAsync: updateBusinessLine } = useUpdateBusinessLine();
+  const submitTask = useCallback(() => {
+    setAccountHolder(accountHolder);
+    return submit({
+      data: multiForm.data,
+      legalEntityResponse,
+      associatedLegalArrangement,
+      nestedLegalEntity,
+      nestedLegalEntityDetails,
+      problems,
+      taskType: taskType ?? TaskTypes.BUSINESS_DETAILS,
+      accountHolder: accountHolder ?? "theCompanyIWorkFor",
+      forms,
+      documentUtils,
+      t,
+      showToast,
+      setLoadingStatus,
+      setProblems,
+      handleUpdateLegalEntity: updateLegalEntity,
+      createLegalEntity,
+      onExternalSubmit,
+      isExperimentEnabled,
+      userEvents,
+      efpBusinessLines,
+      createBusinessLine,
+      updateBusinessLine
+    });
+  }, [
+    setAccountHolder,
+    accountHolder,
+    multiForm.data,
+    legalEntityResponse,
+    associatedLegalArrangement,
+    nestedLegalEntity,
+    nestedLegalEntityDetails,
+    problems,
+    taskType,
+    forms,
+    documentUtils,
+    t,
+    showToast,
+    updateLegalEntity,
+    createLegalEntity,
+    onExternalSubmit,
+    isExperimentEnabled,
+    userEvents,
+    efpBusinessLines,
+    createBusinessLine,
+    updateBusinessLine
+  ]);
+  const {
+    handleNextClick,
+    handleBackClick,
+    activeForm,
+    shouldValidate,
+    gotoFormByFormIndex,
+    steps
+  } = useFormComposer({
+    problems,
+    forms,
+    onSubmit: submitTask,
+    triggerValidation: multiForm.triggerValidation
+  });
+  const handleBusinessMismatchContinue = () => {
+    setTrustedFields([]);
+    businessMismatchModalOpen.value = false;
+    handleNextClick();
+  };
+  const handleBusinessMismatchCancel = () => {
+    handleBackClick?.();
+    businessMismatchModalOpen.value = false;
+    tinMatched.value = false;
+  };
+  const companySearchQueryInput = {
+    name: multiForm.data?.basicInformation?.legalCompanyName ?? "",
+    country: multiForm.data?.basicInformation?.country,
+    state: multiForm.data?.basicInformation?.stateOrProvince,
+    registrationNumber: multiForm.data?.basicInformation?.registrationNumber
+  };
+  const verifyTinQueryInput = {
+    name: multiForm.data.basicInformation?.legalCompanyName ?? "",
+    tin: multiForm.data?.basicInformation?.taxInformation?.find((taxId) => taxId.country === country)?.number ?? ""
+  };
+  const {
+    data: companySearchResponse,
+    isLoading: searchingCompanies,
+    isError: searchingError
+  } = useCompanySearch(companySearchQueryInput, {
+    enabled: false
+  });
+  useEffect(() => {
+    if (!searchingCompanies && companySearchResponse?.results) {
+      userEvents.addPageEvent("Success", {
+        actionType: "submit",
+        returnValue: "companySearch",
+        additionalData: {
+          numberOfResults: companySearchResponse?.results.length
+        }
+      });
+    }
+  }, [searchingCompanies, userEvents, subjectEntity, companySearchResponse?.results]);
+  const companySelectionInput = {
+    company: companySearchResponse?.results[0],
+    state: multiForm.data.basicInformation?.stateOrProvince,
+    name: multiForm.data?.basicInformation?.legalCompanyName ?? "",
+    tin: multiForm.data?.basicInformation?.taxInformation?.find((taxId) => taxId.country === country)?.number ?? ""
+  };
+  useVerifyTin(verifyTinQueryInput, { enabled: false });
+  const attemptBusinessSearch = async () => {
+    if (customRules.countryUsingCompanySearch() !== "REQUIRED") {
+      const currentForms = updateForms({ searchResults: [] });
+      return handleNextClick(currentForms);
+    }
+    try {
+      setLoadingStatus("loading");
+      tinMatched.value = void 0;
+      verifiedBusiness.value = void 0;
+      isVerifiedSingleCompanySearchResult.value = false;
+      const searchResponse = await queryClient.fetchQuery({
+        queryKey: ["companySearch", companySearchQueryInput]
+      });
+      let currentForms = updateForms({ searchResults: searchResponse.results });
+      const handleTinResponse = (matched) => {
+        if (matched) {
+          tinMatched.value = true;
+        } else {
+          businessMismatchModalOpen.value = true;
+          tinMatched.value = false;
+        }
+        return tinMatched.value;
+      };
+      if (searchResponse?.results.length === 1 && isNormalizedStringMatch(
+        multiForm.data?.basicInformation?.legalCompanyName ?? "",
+        searchResponse.results[0].name
+      )) {
+        const companySelectionResponse = await handleCompanySelection(
+          rootLegalEntityId.value,
+          baseUrl.value,
+          { ...companySelectionInput, company: searchResponse.results[0] }
+        );
+        if (handleTinResponse(!!companySelectionResponse.tinMatched)) {
+          verifiedBusiness.value = companySelectionResponse;
+          isVerifiedSingleCompanySearchResult.value = true;
+          applyVerifiedBusinessData(multiForm, country, verifiedBusiness.value);
+          currentForms = updateForms({ searchResults: searchResponse.results });
+        } else {
+          return setLoadingStatus("success");
+        }
+      }
+      if (!searchResponse.results.length) {
+        const tinVerificationResponse = await queryClient.fetchQuery({
+          queryKey: ["verifyTin", verifyTinQueryInput]
+        });
+        if (!handleTinResponse(!!tinVerificationResponse?.matched)) {
+          return setLoadingStatus("success");
+        }
+      }
+      setLoadingStatus("success");
+      return handleNextClick(currentForms);
+    } catch (e) {
+      logger.error(e);
+      setLoadingStatus("error");
+      const currentForms = updateForms({ searchResults: [] });
+      return handleNextClick(currentForms);
+    }
+  };
+  const overrideNextClick = async () => {
+    if (!activeForm.isValid) return handleNextClick();
+    if (!COUNTRIES_USING_COMPANY_SEARCH.includes(country) || isSoleProp) {
+      return handleNextClick();
+    }
+    switch (activeForm.formId) {
+      case "basicInformation": {
+        return await attemptBusinessSearch();
+      }
+      case "businessSelection": {
+        const currentForms = updateForms({
+          searchResults: companySearchResponse?.results
+        });
+        return handleNextClick(currentForms);
+      }
+      default:
+        return handleNextClick();
+    }
+  };
+  useEffect(() => {
+    updateForms({
+      searchResults: searchingError ? [] : companySearchResponse?.results
+    });
+  }, [updateForms, companySearchResponse?.results, searchingError]);
+  return /* @__PURE__ */ jsx(FormContextProvider, { form: multiForm, children: /* @__PURE__ */ jsxs(
+    FormFlow,
+    {
+      summary: {
+        data: summaryData,
+        omitted: {
+          keys: ["operationalAddressIsSame"],
+          forms: ["businessSelection"]
+        },
+        problems,
+        showLegalCaption: true
+      },
+      asModal,
+      currentStep: steps.current,
+      totalSteps: steps.total,
+      forms,
+      disableNextButton: activeForm.formId === "businessSelection",
+      gotoFormByFormIndex,
+      handleNextClick: overrideNextClick,
+      handleBackClick,
+      handleCancelClick: handleHomeClick,
+      loadingStatus,
+      children: [
+        /* @__PURE__ */ jsx(
+          BusinessDetailsMultiform,
+          {
+            taskType,
+            activeForm,
+            country,
+            shouldValidate,
+            problems,
+            handleNextClick: overrideNextClick,
+            handleBackClick,
+            setLoadingStatus,
+            isTopLevelEntity: taskType === TaskTypes.BUSINESS_DETAILS
+          }
+        ),
+        businessMismatchModalOpen.value && /* @__PURE__ */ jsx(
+          Confirm,
+          {
+            title: t(($) => $["businessSelection__tinVerificationFailureModalHeader"], {
+              ns: "business"
+            }),
+            description: t(($) => $["businessSelection__tinVerificationFailureModalContent"], {
+              ns: "business"
+            }),
+            cancelText: t(
+              ($) => $["businessSelection__tinVerificationFailureModalSecondaryButton"],
+              { ns: "business" }
+            ),
+            confirmText: t(
+              ($) => $["businessSelection__tinVerificationFailureModalPrimaryButton"],
+              { ns: "business" }
+            ),
+            onCancel: handleBusinessMismatchCancel,
+            onConfirm: handleBusinessMismatchContinue,
+            analyticsEventLabel: "tinVerificationFailureModal"
+          }
+        )
+      ]
+    }
+  ) });
+}
+export {
+  BusinessDetailsDropin as B
+};