@adyen/kyc-components 3.91.0 → 3.92.0

package/dist/useBusinessDetailsData-DG9EJBH_.js

@@ -1,2441 +0,0 @@
-;
-{
-  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] = "1a257d6a-01e8-41bb-9504-99ba1fe86766", e._sentryDebugIdIdentifier = "sentry-dbid-1a257d6a-01e8-41bb-9504-99ba1fe86766");
-  } 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, a1 as entriesOf, bC as businessDetailsComponentsKeyMapping, bD as solePropBusinessDetailsKeyMapping, ak as objectsDeepEqual, aq as keysOf, i as isUndefinedOrNull, bE as solePropBusinessDetailsApiKeyMapping, bp as businessDetailsApiKeyMapping, P as createLogger, b8 as filterOutUnwantedAssociationsIfRootLE, b6 as drop, ag as getOwnEntityAssociations, aV as doArraysMatch, b as useApiContext, a3 as useAnalyticsContext, a2 as useQueryClient, X as useExperimentsContext, $ as useVersionConfiguration, o as useSettingsContext, K as useAccountHolder, bF as solePropBusinessDetailsDocumentMapping, bG as businessDetailsDocumentMapping, j as useQuery, c as useLegalEntity, R as ROOT_LE } from "./StoreProvider-CyzNf7KK.js";
-import { useState, useEffect, useMemo, useCallback } from "preact/hooks";
-import { u as useCreateBusinessLine, a as useUpdateBusinessLine } from "./useUpdateBusinessLines-8bDYsLav.js";
-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 financialInfoValidationWithEmployeesRules, U as tinMatched, V as businessMismatchModalOpen, W as useCompanySearch, X as useVerifyTin, Y as handleCompanySelection, Z as applyVerifiedBusinessData, _ as useBusinessLines } from "./OnboardingDropinComponent-Cx-c_p0i.js";
-import { u as useCreateLegalEntity } from "./useCreateLegalEntity-DT7ue23d.js";
-import { u as useUpdateLegalEntity } from "./useUpdateLegalEntity-Aubxhgvv.js";
-import { F as FormContextProvider, a as FormFlow } from "./FormFlow-BrgeP70A.js";
-import { a as useToastContext } from "./useToastContext-Cbw29cqc.js";
-import { _ as MemoizedDocumentUpload, C as CompanyTypesValues, m as COUNTRIES_USING_COMPANY_SEARCH, $ as isRegistrationNumberAbsentStateV4Scenario, D 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-pGSPtITh.js";
-import { c as composePerScenarioFormConfigurations, g as getPropsFromConfigurations } from "./process-field-configurations-BZQqH4-M.js";
-import { a as addValidityToForms, u as useFormComposer } from "./dropinUtils-DCWhMKpQ.js";
-import { u as useMultiForm } from "./useMultiForm-DWozxGN4.js";
-import { m as mapExistingFile, g as getPageName, u as useScenarioConfiguration } from "./mapExistingFile-Bd7nsoK8.js";
-import { a as datasetUtilities, C as Confirm } from "./useDataset-DCCxYOjr.js";
-import { a as getDocument, e as getDocuments, c as createDocumentRequest, h as mergeProofOfOwnershipAttachments, b as getFileExtention, d as documentApiUtils } from "./documentUtils-Be5wlCwo.js";
-import { g as getFieldsWithExistingData } from "./getFieldsWithExistingData-CfckMyJ1.js";
-import { u as useFormContext, i as isDateOlderThanAYear, o as mapAddressLabels, p as getKeyForField } from "./Address-BUrDDnmR.js";
-import { M as MemoizedConstitutionalDocument } from "./ConstitutionalDocument-DM6M40MP.js";
-import { M as Modal, a as ModalContent } from "./Modal-B4wxf7HK.js";
-import { S as SettingNames } from "./InputText-DLAmX8CW.js";
-import { m as mapJpAddressSchemaToAddressLocalizations, a as mapJpAddressSummary } from "./mapJpAddressSchemaToAddressLocalizations-CWY2lZGD.js";
-import { o as organizationTypesToSkipCompanyStructureForm } from "./utils-D1-D6fui.js";
-import { f as formatCurrency, A as ALLOWED_SOF_SERVICES } from "./utils-DenrGsUh.js";
-import { s as summaryItem } from "./CountryField-CsKJAI53.js";
-import { s as summaryStep } from "./Summary-QyNHKBjO.js";
-import { i as isValidationError, p as processValidationErrors, a as isMaintenanceModeError } from "./validationError-DPP91cM3.js";
-import { r as resolveFieldMetadata } from "./Spacer-w89ksCbG.js";
-import { m as mapFinancialReportsToFinancialInformation, a as mapFinancialInformationToFinancialReport } from "./mapFinancialReportsToFinancialInformation-Bfvt2G87.js";
-import { f as formatObject } from "./utils-DNSfZiio.js";
-import { b as mapAddressLocalizationToJpAddressSchema, a as mapApiScriptLocalizationToSchemaFields, m as mapSchemaFieldsToApiScriptLocalization } from "./mapAddressLocalizationToJpAddressSchema-vJWbpAyq.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: (fieldName) => handleChange("companyTaxDocument", fieldName),
-            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: (fieldName) => handleChange("companyRegistrationDocument", fieldName),
-            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: (fieldName) => handleChange("companyProofOfDirectorDocument", fieldName),
-            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: (fieldName) => handleChange("companyProofOfSignatoryDocument", fieldName),
-            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: (fieldName) => handleChange("companyProofOfOwnershipDocument", fieldName),
-            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: (fieldName) => handleChange("companyConstitutionalDocument", fieldName),
-            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 = getDocuments(entityId, "proofOfOwnership") ?? null;
-  const constitutionalDocument = getDocument(entityId, "constitutionalDocument") ?? null;
-  const mergedProofOfOwnershipAttachments = proofOfOwnership?.flatMap((doc) => doc.attachments ?? []) ?? [];
-  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: mergedProofOfOwnershipAttachments.length > 0 ? {
-      proofOfOwnership: mergedProofOfOwnershipAttachments.map(
-        (attachment) => mapExistingFile(attachment.pageName ?? "")
-      )
-    } : 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",
-      description: companyRegistrationDocument?.description,
-      page1: companyRegistrationDocument?.registrationDocument?.[0]
-    }),
-    createDocumentRequest({
-      entityId,
-      entityType: "legalEntity",
-      documentType: taxDocumentType,
-      description: companyTaxDocument?.description,
-      page1: companyTaxDocument?.taxDocument?.[0]
-    }),
-    createDocumentRequest({
-      entityId,
-      entityType: "legalEntity",
-      documentType: "proofOfDirector",
-      description: companyProofOfDirectorDocument?.description,
-      page1: companyProofOfDirectorDocument?.proofOfDirector?.[0]
-    }),
-    createDocumentRequest({
-      entityId,
-      entityType: "legalEntity",
-      documentType: "constitutionalDocument",
-      description: companyConstitutionalDocument?.description,
-      page1: companyConstitutionalDocument?.constitutionalDocument?.[0]
-    }),
-    createDocumentRequest({
-      entityId,
-      entityType: "legalEntity",
-      documentType: "proofOfSignatory",
-      description: companyProofOfSignatoryDocument?.description,
-      page1: companyProofOfSignatoryDocument?.proofOfSignatory?.[0]
-    }),
-    createDocumentRequest({
-      entityId,
-      entityType: "legalEntity",
-      documentType: "proofOfOwnership",
-      description: companyProofOfOwnershipDocument?.description,
-      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, version) => {
-  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 && version === 4 ? 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 && version === 4 ? 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,
-              description: data[form]?.description
-            }
-          }
-        };
-      case "companyTaxDocument":
-        if (!isDocumentsRequired(forms)) return summaryData;
-        return {
-          ...summaryData,
-          [form]: {
-            companyTaxDocument: {
-              fileName: data[form].taxDocument?.[0]?.name,
-              description: data[form]?.description
-            }
-          }
-        };
-      case "companyProofOfDirectorDocument":
-        if (!isDocumentsRequired(forms)) return summaryData;
-        return {
-          ...summaryData,
-          [form]: {
-            companyProofOfDirectorDocument: {
-              fileName: data[form].proofOfDirector?.[0]?.name,
-              description: data[form]?.description
-            }
-          }
-        };
-      case "companyProofOfSignatoryDocument":
-        if (!isDocumentsRequired(forms)) return summaryData;
-        return {
-          ...summaryData,
-          [form]: {
-            companyProofOfSignatoryDocument: {
-              fileName: data[form].proofOfSignatory?.[0]?.name,
-              description: data[form]?.description
-            }
-          }
-        };
-      case "companyProofOfOwnershipDocument":
-        if (!isDocumentsRequired(forms)) return summaryData;
-        return {
-          ...summaryData,
-          [form]: {
-            companyProofOfOwnershipDocument: {
-              fileName: data[form].proofOfOwnership?.map((doc) => doc.name).join("\n"),
-              description: data[form]?.description
-            }
-          }
-        };
-      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);
-  formattedDocument.forEach((doc) => {
-    const existingDoc = getDocument(legalEntity.id, doc.type);
-    if (doc.type === "proofOfOwnership" && existingDoc && doc.attachments?.length) {
-      doc.attachments = mergeProofOfOwnershipAttachments(
-        existingDoc.attachments ?? [],
-        doc.attachments
-      ).filter((attachment) => attachment.pageName);
-    }
-  });
-  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,
-  country: propCountry,
-  problems: propProblems,
-  legalEntityResponse,
-  efpBusinessLines,
-  documents,
-  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 { data: versionData } = useVersionConfiguration();
-  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 !== TaskTypes.BUSINESS_DETAILS;
-  const legalEntityType = !isSoleProp ? LegalEntityTypes.ORGANIZATION : LegalEntityTypes.SOLE_PROPRIETORSHIP;
-  const subjectEntity = !isAssociationTaskType ? legalEntityResponse : isSoleProp ? associatedLegalArrangement : nestedLegalEntity;
-  const [country, setCountry] = useState(propCountry);
-  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(() => {
-    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 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;
-      const companyType = taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY ? CompanyTypesValues.SOLE_PROPRIETORSHIP : data?.companyStructure?.entityType;
-      return {
-        basicInformation: basicInformationValidators({
-          country,
-          state: data?.basicInformation?.stateOrProvince,
-          companyType,
-          taxIdNumberType: taxIdType,
-          registrationNumberType: regNumberType,
-          isExperimentEnabled
-        }),
-        businessSelection: businessSelectionValidators(),
-        companyStructure: CompanyStructureValidation,
-        additionalInformation: additionalInformationValidators({
-          country,
-          taxIdNumberType: taxIdType,
-          companyType,
-          registrationNumberType: regNumberType,
-          vatNumberType: data?.additionalInformation?.vatNumberType,
-          isExperimentEnabled
-        }),
-        financialInformation: financialInfoValidationWithEmployeesRules
-      };
-    },
-    [country, isExperimentEnabled, taskType]
-  );
-  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,
-      version: versionData?.version
-    }),
-    [
-      multiForm.data,
-      country,
-      taskType,
-      isExperimentEnabled,
-      isSettingEnabled,
-      accountHolder,
-      isTinMatched,
-      legalEntityResponse,
-      versionData?.version
-    ]
-  );
-  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,
-      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,
-      activeForm,
-      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"
-          }
-        )
-      ]
-    }
-  ) });
-}
-const useDocuments = (documentDetails, entityId, options) => {
-  const { rootLegalEntityId, baseUrl } = useApiContext();
-  const documentUtils = documentApiUtils({
-    baseUrl: baseUrl.value,
-    rootLegalEntityId: rootLegalEntityId.value
-  });
-  const documentDetailsKey = (documentDetails || []).map((details) => details.id).sort((a, b) => a.localeCompare(b)).join(",");
-  return useQuery({
-    queryKey: ["documents", documentDetailsKey, entityId + ""],
-    queryFn: () => documentUtils.fetchDocuments(documentDetails, entityId),
-    retry: 0,
-    ...options
-  });
-};
-function useBusinessDetailsData(taskType, associatedLegalArrangement, nestedLegalEntity) {
-  const { t } = useTranslation(["common"]);
-  const { data: rootLe } = useLegalEntity(ROOT_LE);
-  const { accountHolder } = useAccountHolder();
-  const { showToast } = useToastContext();
-  const { isSettingEnabled } = useSettingsContext();
-  const { data: efpBusinessLines, isLoading: fetchingEfpBusinessLines } = useBusinessLines(
-    ALLOWED_SOF_SERVICES,
-    {
-      enabled: isSettingEnabled("allowBusinessLines")
-    }
-  );
-  const isSoleProp = accountHolder === "mySoleProprietorName";
-  const isAssociationTaskType = taskType !== TaskTypes.BUSINESS_DETAILS;
-  const subjectEntity = !isAssociationTaskType ? rootLe : isSoleProp ? associatedLegalArrangement : nestedLegalEntity;
-  const { isLoading: fetchingDocuments, isError } = useDocuments(
-    subjectEntity?.documentDetails || [],
-    subjectEntity?.id || "",
-    {
-      enabled: subjectEntity?.documentDetails && subjectEntity?.documentDetails.length > 0
-    }
-  );
-  useEffect(() => {
-    if (isError) {
-      showToast({
-        label: t(($) => $["failedToFetchRelevantDocuments"], { ns: "common" }),
-        variant: "error"
-      });
-    }
-  }, [isError, showToast, t]);
-  let mappedDocs;
-  if (subjectEntity?.id) {
-    mappedDocs = mapApiDocumentToBusinessDetailsDocuments(subjectEntity.id);
-  }
-  return rootLe && !fetchingEfpBusinessLines && !fetchingDocuments ? {
-    data: {
-      rootLe,
-      efpBusinessLines,
-      documents: mappedDocs
-    },
-    isLoading: false
-  } : {
-    data: {
-      rootLe,
-      efpBusinessLines,
-      documents: mappedDocs
-    },
-    isLoading: true
-  };
-}
-export {
-  BusinessDetailsDropin as B,
-  useBusinessDetailsData as u
-};