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

package/dist/useBusinessDetailsData-DFU0dLxw.js

@@ -0,0 +1,4732 @@
+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] = "1476366e-0cd3-4898-bbf7-900223d2bb8d", e._sentryDebugIdIdentifier = "sentry-dbid-1476366e-0cd3-4898-bbf7-900223d2bb8d");
+} catch (e) {}
+import { r as useTranslation } from "./translation-DbATp_35.js";
+import { t as createLogger } from "./logger-Z8AeTE4x.js";
+import { t as Typography } from "./Typography-CAc_f5Iq.js";
+import { t as Loader } from "./Loader-BVtlpTeo.js";
+import { t as Button } from "./Button-DPJ1k02w.js";
+import { r as httpPost, s as useApiContext } from "./http-fdIO--pH.js";
+import { r as useLegalEntity, t as ROOT_LE } from "./useLegalEntity-DHA8TJeV.js";
+import { t as useAccountHolder } from "./useAccountHolder-DDto9d9n.js";
+import { t as useSettingsContext } from "./useSettingsContext-9O3Aqpfq.js";
+import { a as objectsDeepEqual, n as doArraysMatch, o as entriesOf, s as keysOf } from "./genUtils-nphCwt1A.js";
+import { S as isUndefinedOrNull, b as isISIN, y as isEmpty } from "./validatorUtils-D2O6AAZn.js";
+import { t as useToggleContext } from "./useToggleContext-B_YexrbT.js";
+import { t as StackLayout } from "./StackLayout-IUdNMDgW.js";
+import { t as TaskVerificationStatus } from "./TaskVerificationStatus-DEXk_ndE.js";
+import { n as TASK_STATUS_POLLING_INTERVAL_MS } from "./taskStatus-BtekPA8E.js";
+import { t as Header } from "./Header-DVLlJ6we.js";
+import { t as useAllowedCountries } from "./useAllowedCountries-C-nqVePW.js";
+import { t as CountryCodes } from "./country-code-CJk2hdPu.js";
+import { n as datasetUtilities } from "./datasetUtil-BdHPWsxZ.js";
+import { t as Alert } from "./Alert-Cc7p0N5h.js";
+import { _ as businessDetailsKeyMapping, f as solePropBusinessDetailsApiKeyMapping, g as businessDetailsDocumentMapping, h as businessDetailsApiKeyMapping, m as solePropBusinessDetailsKeyMapping, p as solePropBusinessDetailsDocumentMapping } from "./processCapabilities-CWE5UFt8.js";
+import { t as TaskTypes } from "./taskTypes-3vSkMBDm.js";
+import { r as filterOutUnwantedAssociationsIfRootLE, s as getOwnEntityAssociations } from "./entityAssociationUtil-CY0grcyH.js";
+import { t as Scenarios } from "./get-scenarios-Bb-paHmJ.js";
+import { t as useAnalyticsContext } from "./useAnalyticsContext-gSnRnYgV.js";
+import { t as HandlerContext } from "./HandlerContext-DeMa68z0.js";
+import { t as SettingNames } from "./types-Cwq1JAWT.js";
+import { t as useBusinessLines } from "./useBusinessLines-BZfFqvS_.js";
+import { t as Card } from "./Card-BCGLpdw7.js";
+import { t as useToastContext } from "./useToastContext-B6Mqc2HY.js";
+import { t as LandingLayout } from "./LandingLayout-BsIoIFzs.js";
+import { t as useInvalidateRootLegalEntity } from "./invalidateRootLegalEntity-BHaVREw-.js";
+import { t as LoaderWrapper } from "./LoaderWrapper-Dc88hY-P.js";
+import { n as ModalContent, t as Modal } from "./Modal-CHES6970.js";
+import { t as Confirm } from "./Confirm-DoN9R9Z3.js";
+import { t as useCreateLegalEntity } from "./useCreateLegalEntity-qP7MeAmi.js";
+import { t as useUpdateLegalEntity } from "./useUpdateLegalEntity-CqmqXsbR.js";
+import { a as useFormComposer, i as FormFlow, o as FormContextProvider, r as useFormContext, t as addValidityToForms } from "./dropinUtils-DTBezwYT.js";
+import { i as getPropsFromConfigurations, r as composePerScenarioFormConfigurations, t as createFormRules } from "./form-rules-B0RwhsVw.js";
+import { t as Image } from "./Image-Bn_Yyuof.js";
+import { t as StructuredList } from "./StructuredList-nPasiuLi.js";
+import { t as ErrorPanel } from "./ErrorPanel-D4JNFkvi.js";
+import { n as summaryStep, r as Summary_module_default } from "./Summary-DM31WxLr.js";
+import { n as mergeFieldMetadataIntoProps, t as createFormUtils } from "./formUtils-DVDcdZsP.js";
+import { t as useMultiForm } from "./useMultiForm-BxASst0O.js";
+import { t as Field } from "./Field-DwDJQVSS.js";
+import { t as TileGroup } from "./TileGroup-D1-M64Ul.js";
+import { a as useLegalCompanyNameField, i as CountryOfGoverningLawField, n as COUNTRY_OF_GOVERNING_LAW_POSSIBLE, o as localizedLegalCompanyNameFieldConfig, r as COUNTRY_OF_GOVERNING_LAW_FIELD, s as useCompanyTypeExamples, t as CountryOfGoverningLawFieldValidation } from "./validate-DUcT-JGF.js";
+import { t as getFormSlice } from "./getFormSlice-C1ma6Xd4.js";
+import { a as exemptFromRegistrationNumberDefaultFieldMetadata, c as registrationNumberDefaultFieldMetadata, l as getCompanyRegistrationNumberOptions, n as inferCompanyRegistrationNumberType, s as registrationNumberDefaultFieldConfig, t as getDefaultRegistrationNumberType, u as getValidCompanyTypesForRegistrationNumberType } from "./getDefaultRegistrationNumberType-CIu4WMln.js";
+import { A as taxIdNumberOptions, C as isRegistrationNumberAbsentStateV4Scenario, D as getTaxIdNumberOptions, E as mapLocalizationToJapaneseLegalNames, S as isRegistrationExemptionAllowed, T as mapJapaneseLegalNamesToLocalization, _ as COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_COMPANIES, b as REGISTRATION_NUMBER_EXEMPTION_RULES, c as taxInformationDefaultFieldConfig, d as COUNTRIES_THAT_DONT_REQUIRE_COMPANY_REGISTRATION, f as COUNTRIES_THAT_DONT_REQUIRE_SOLE_PROP_REGISTRATION, g as COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER_SOLE_PROPS, h as COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER, k as getValidCompanyTypesForTaxIdNumberType, l as taxInformationDefaultFieldMetadata, m as COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT, p as COUNTRIES_THAT_DO_NOT_USE_TAX_ID_FOR_SOLE_PROP, s as getTaxInformationPlaceholderText, u as COUNTRIES_REQUIRING_FINANCIAL_INFORMATION, v as COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_SOLE_PROPS, w as isUsingCompanySearch, x as TAX_ID_REQUIRED_COUNTRIES_ORGANIZATION, y as COUNTRIES_WITH_POSSIBLE_TRUSTEE_TAXID_ABSENT_V4 } from "./utils-Ck_mZapQ.js";
+import { t as isEmpty$1 } from "./isEmpty-Uewyl-r6.js";
+import { n as useDebouncedCallback } from "./debouncedInputEvent-Fwwp_K_-.js";
+import { t as Checkbox } from "./Checkbox-qfdF12cF.js";
+import { n as CountryField, t as COUNTRY_FIELD } from "./CountryField-DT6-Jr_b.js";
+import { a as mapAddressLabelsNewSummary, c as COUNTRIES_WITH_STATES_DATASET, r as getKeyForField, t as getAddressSchemaForCountry } from "./utils-BWumuCvl.js";
+import { a as validateNotEmptyOnBlur, o as validatePatternOnBlur } from "./patternValidators-DsrZkuOO.js";
+import { n as StateField, r as stateFieldMetadata, t as STATE_FIELD } from "./StateField-BpMwetvd.js";
+import { t as ListItem } from "./ListItem-CYTpdOMa.js";
+import { a as defaultFieldMetadata, i as defaultFieldConfigV4, o as defaultFieldMetadataV4, r as defaultFieldConfig, t as LEGAL_COMPANY_NAME_FIELD } from "./LegalCompanyNameField-Cosyjk52.js";
+import { t as InputText } from "./InputText-CFDEmEtp.js";
+import { t as resolveFieldMetadata } from "./fieldConfigurations-CZCFghnK.js";
+import { n as TaxInformationField, r as isJapanLocalizationEnabled, t as TAX_INFORMATION_FIELD } from "./TaxInformationField-CV7SpMH1.js";
+import { c as MaskedInput, i as makeMask, n as alphanumericInputs, o as numericInputs, t as alphaInputs } from "./maskHelpers-C0wnCoJl.js";
+import { t as uppercase } from "./uppercase-DvjwUM0n.js";
+import { t as RadioGroup } from "./RadioGroup-Bf3DlQnZ.js";
+import { n as BusinessRegistrationNumberField, t as BUSINESS_REGISTRATION_NUMBER_FIELD } from "./BusinessRegistrationNumberField-DKka8aVU.js";
+import { n as LEGAL_ARRANGEMENT_COUNTRIES_REQUIRING_DATE_OF_INCORPORATION } from "./legalArrangementUtils-C68JdH6I.js";
+import { r as formatObject } from "./utils-DdHbAadK.js";
+import { t as useScenarios } from "./useScenarios-Bn93htbx.js";
+import { o as nestAddressSchema, r as flattenAddressSchema } from "./AddressFields-BC3QHs2u.js";
+import { i as useScenarioConfiguration, r as getPageName, t as mapExistingFile } from "./mapExistingFile-BkwRTTRm.js";
+import { t as useTaskLandedEvent } from "./useTaskLandedEvent-DwZHcMEQ.js";
+import { i as JP_ADDRESS_REQUIRED_FIELDS, r as mapJpAddressSummaryNewSummary, t as mapJpAddressSchemaToAddressLocalizations } from "./mapJpAddressSchemaToAddressLocalizations-D3VO2nhc.js";
+import { n as isMaintenanceModeError, t as processValidationErrors } from "./processValidationErrors-CjsNfiRK.js";
+import { a as createDocumentRequest, c as getDocuments, f as mergeProofOfOwnershipAttachments, l as getFileExtention, o as documentApiUtils, s as getDocument } from "./validate-BZ1-ZeKr.js";
+import { i as getFieldsWithExistingData, n as MemoizedDocumentUpload, t as PatriotActDisclosure } from "./PatriotActDisclosure-DqUZeLms.js";
+import { a as isValidationError, r as isBusinessSelectionLegalArrangementError } from "./validationError-DV6t8Ubb.js";
+import { i as formatAddressForCleanse, n as formatDateObj, o as useAddressCleanseImperatively, t as InputDate } from "./InputDate-Bq3Sb-ZW.js";
+import { t as addressValidators } from "./validate-DTz70AWN.js";
+import { t as capitalize } from "./getProps-DVqK7eRw.js";
+import { t as Link } from "./Link-CvYhseSD.js";
+import { t as formatValidationError } from "./formatValidationError-q_w9DTrl.js";
+import { t as DataConflictsModal } from "./DataConflictsModal-CCaMgguu.js";
+import { t as mapAddressLocalizationToJpAddressSchema } from "./mapAddressLocalizationToJpAddressSchema-DpOIaxj6.js";
+import { t as currencyByCountry } from "./types-BA3bcGAv.js";
+import { t as Divider } from "./Divider-BENvVRnz.js";
+import { n as SummarySection, t as NewSummary } from "./NewSummary-D55f70wB.js";
+import { t as DetailViewLayout } from "./DetailViewLayout-DNCGEd7b.js";
+import { a as LegalFormField, c as isDateOlderThanAYear, i as InputCurrency, l as mapAddressData, n as Currency, o as mapFinancialReportsToFinancialInformation, r as InputNumber, s as mapFinancialInformationToFinancialReport, t as CURRENCY_FIELD } from "./Currency-oeXHRWzy.js";
+import { t as useTaskStatus } from "./useTaskStatus-DJxOWvuN.js";
+import { t as useIndustryCodes } from "./useIndustryCodes-BMK6IMiW.js";
+import { n as formatCurrency } from "./formatCurrency-BetgkQKi.js";
+import { n as useCreateBusinessLine, t as useUpdateBusinessLine } from "./useUpdateBusinessLines-JRPjqoe9.js";
+import { _ as dateOfIncorporationFieldMetadata, a as defaultFieldConfig$1, c as REGISTRATION_AND_OPERATIONAL_ADDRESS_FIELDS, d as doingBusinessAsFieldMetadata, f as DBANameField, h as DateOfIncorporationField, i as getDefaultVatNumberType, l as RegistrationAndOperationalAddressFields, m as DATE_OF_INCORPORATION_FIELD, n as VAT_NUMBER_FIELD, o as defaultFieldMetadata$1, p as DBA_NAME_FIELD, r as VatNumberField, s as vatAbsenceReasonMetadata, t as MemoizedConstitutionalDocument, u as doingBusinessAsAbsentFieldMetadata } from "./ConstitutionalDocument-Bxsr1hQb.js";
+import { f as industryCodeFieldMetadata, l as IndustryCodeField, t as INDUSTRY_CODE_FIELD } from "./constants-C8yo0_RA.js";
+import { s as organizationTypesToSkipCompanyStructureForm } from "./utils-CJcGZvj1.js";
+import { lazy } from "preact/compat";
+import { useCallback as useCallback$1, useContext as useContext$1, useEffect as useEffect$1, useMemo as useMemo$1, useRef as useRef$1, useState as useState$1 } from "preact/hooks";
+import cx from "classnames";
+import { Fragment as Fragment$1, jsx, jsxs } from "preact/jsx-runtime";
+import { createModel, signal, useModel, useSignal } from "@preact/signals";
+import { queryOptions, skipToken, useMutation, useQuery, useQueryClient } from "@tanstack/preact-query";
+import { createContext as createContext$1 } from "preact";
+import { Show } from "@preact/signals/utils";
+//#region src/components/Shared/fields/EInvoicingCodeField/EInvoicingCodeField.tsx
+var EINVOICING_CODE_FIELD = ["eInvoicingCode"];
+function EInvoicingCodeField({ data, valid, errors, labels, readonly, mask, shouldValidate, handleChangeFor }) {
+	const { t } = useTranslation("common");
+	const [noInvoicingCode, setNoInvoicingCode] = useState$1(false);
+	const handleNoInvoicingCode = () => {
+		setNoInvoicingCode(!noInvoicingCode);
+		handleChangeFor("eInvoicingCode")("0000000");
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		className: "adyen-kyc-field",
+		children: [/* @__PURE__ */ jsx(MaskedInput, {
+			name: "eInvoicingCode",
+			type: "text",
+			label: labels.eInvoicingCode ?? "",
+			formatGuidance: t(($) => $["the7CharacterIdentifierAssignedToThis"], { example: "MP10YNU" }),
+			errorMessage: errors.eInvoicingCode,
+			isValid: valid.eInvoicingCode ?? false,
+			value: data.eInvoicingCode ?? "",
+			readonly: readonly || noInvoicingCode,
+			shouldValidate,
+			onInput: handleChangeFor("eInvoicingCode", "input"),
+			onBlur: handleChangeFor("eInvoicingCode", "blur"),
+			disabled: noInvoicingCode,
+			"aria-required": true,
+			"aria-invalid": !valid.eInvoicingCode,
+			...mask
+		}), /* @__PURE__ */ jsx(Field, {
+			name: "noEInvoicingCode",
+			children: (childProps) => /* @__PURE__ */ jsx(Checkbox, {
+				...childProps,
+				name: "noEInvoicingCode",
+				"aria-required": false,
+				"aria-invalid": false,
+				label: t(($) => $["thisCompanyDoesntHaveAnSDI"]),
+				checked: noInvoicingCode,
+				onChange: handleNoInvoicingCode
+			})
+		})]
+	});
+}
+//#endregion
+//#region src/components/Shared/fields/EInvoicingCodeField/fieldConfig.ts
+var eInvoicingCodeFieldMetadata = {
+	validators: validatePatternOnBlur(/^[A-Z0-9]{7}$/),
+	mask: {
+		mask: makeMask(...alphanumericInputs(16)),
+		transformOnType: uppercase
+	}
+};
+var legalEntityIdentifierFieldMetadata = {
+	validators: [{
+		modes: ["blur"],
+		validate: (val) => {
+			const isValidLength = val ? val.length === 20 : false;
+			const hasLettersAndNumbers = val ? /[a-zA-Z]/.test(val) && /[0-9]/.test(val) : false;
+			return isValidLength && hasLettersAndNumbers;
+		},
+		errorMessage: {
+			key: "enterNCharactersWithAMixForExample",
+			values: {
+				numChars: "20",
+				example: "529900T8BM49AURSDO55"
+			}
+		}
+	}],
+	mask: {
+		mask: makeMask(...alphanumericInputs(20)),
+		transformOnType: uppercase
+	}
+};
+//#endregion
+//#region src/components/Shared/fields/LegalEntityIdentifierField/LegalEntityIdentifierField.tsx
+var LEGAL_ENTITY_IDENTIFIER_FIELD = ["legalEntityIdentifier", "exemptedFromLegalEntityIdentifier"];
+function LegalEntityIdentifierField({ data, valid, errors, handleChangeFor, shouldValidate, canExempt = true }) {
+	const { t } = useTranslation("common");
+	const isExempted = Boolean(data.exemptedFromLegalEntityIdentifier);
+	const handleExemptedChange = (isChecked) => {
+		handleChangeFor("exemptedFromLegalEntityIdentifier", "blur")(isChecked);
+		if (isChecked) handleChangeFor("legalEntityIdentifier", "input")("");
+	};
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(MaskedInput, {
+		type: "text",
+		name: "legalEntityIdentifier",
+		label: t(($) => $["legalEntityIdentifier"]),
+		onInput: handleChangeFor("legalEntityIdentifier", "input"),
+		onBlur: handleChangeFor("legalEntityIdentifier", "blur"),
+		value: data.legalEntityIdentifier ?? "",
+		isValid: Boolean(valid?.legalEntityIdentifier),
+		errorMessage: errors.legalEntityIdentifier,
+		disabled: isExempted,
+		helper: /* @__PURE__ */ jsxs(Typography, {
+			variant: "caption",
+			color: "secondary",
+			children: [
+				t(($) => $["aUniqueIdentifierForGlobalFinancialReporting"]),
+				" ",
+				/* @__PURE__ */ jsx(Link, {
+					href: "https://search.gleif.org/#/search/",
+					external: true,
+					inline: true,
+					children: t(($) => $["lookUpYourLEI"])
+				})
+			]
+		}),
+		helperPosition: "below",
+		persistHelper: true,
+		shouldValidate,
+		mask: legalEntityIdentifierFieldMetadata.mask?.mask,
+		transformOnType: legalEntityIdentifierFieldMetadata.mask?.transformOnType
+	}), canExempt && /* @__PURE__ */ jsx(Field, {
+		name: "exemptedFromLegalEntityIdentifier",
+		children: (childProps) => /* @__PURE__ */ jsx(Checkbox, {
+			...childProps,
+			name: "exemptedFromLegalEntityIdentifier",
+			value: "exemptedFromLegalEntityIdentifier",
+			checked: isExempted,
+			label: t(($) => $["iDontHaveAnLEI"]),
+			onChange: handleExemptedChange
+		})
+	})] });
+}
+//#endregion
+//#region src/components/Shared/fields/StockExchangeMICField/fieldConfig.ts
+var stockExchangeMICFieldMetadata = {
+	validators: [validateNotEmptyOnBlur, validatePatternOnBlur(/^[a-zA-Z0-9]{4}$/)],
+	mask: {
+		mask: makeMask(...alphanumericInputs(4)),
+		transformOnType: uppercase
+	}
+};
+//#endregion
+//#region src/components/Shared/fields/StockExchangeMICField/StockExchangeMICField.tsx
+var STOCK_EXCHANGE_MIC_FIELD = ["stockExchangeMIC"];
+function StockExchangeMICField({ data, valid, errors, readonly, mask, shouldValidate, handleChangeFor }) {
+	const { t } = useTranslation("common");
+	return /* @__PURE__ */ jsx(MaskedInput, {
+		name: "stockExchangeMIC",
+		type: "text",
+		label: t(($) => $["stockExchangeMIC"]),
+		formatGuidance: t(($) => $["enterNCharactersForExample"], {
+			numChars: "4",
+			example: "XNAS"
+		}),
+		...mask,
+		errorMessage: errors.stockExchangeMIC,
+		isValid: valid.stockExchangeMIC ?? false,
+		value: data.stockExchangeMIC ?? "",
+		readonly,
+		shouldValidate,
+		onInput: handleChangeFor("stockExchangeMIC", "input"),
+		onBlur: handleChangeFor("stockExchangeMIC", "blur"),
+		"aria-required": true,
+		"aria-invalid": !valid.stockExchangeMIC
+	});
+}
+//#endregion
+//#region src/components/Shared/fields/StockISINField/fieldConfig.ts
+var stockISINFieldMetadata = {
+	validators: [validateNotEmptyOnBlur, {
+		modes: ["blur"],
+		validate: (value) => !!value && isISIN(value)
+	}],
+	mask: {
+		mask: makeMask(...alphaInputs(2), ...alphanumericInputs(9), ...numericInputs(1)),
+		transformOnType: uppercase
+	}
+};
+//#endregion
+//#region src/components/Shared/fields/StockISINField/StockISINField.tsx
+var STOCK_ISIN_FIELD = ["stockISIN"];
+function StockISINField({ data, valid, errors, readonly, mask, shouldValidate, handleChangeFor }) {
+	const { t } = useTranslation("common");
+	return /* @__PURE__ */ jsx(MaskedInput, {
+		name: "stockISIN",
+		type: "text",
+		label: t(($) => $["stockISIN"]),
+		formatGuidance: t(($) => $["validationPleaseEnterAValidStockISIN"], { example: "NL0012969182" }),
+		...mask,
+		errorMessage: errors.stockISIN,
+		isValid: valid.stockISIN ?? false,
+		value: data.stockISIN ?? "",
+		readonly,
+		shouldValidate,
+		onInput: handleChangeFor("stockISIN", "input"),
+		onBlur: handleChangeFor("stockISIN", "blur"),
+		"aria-required": true,
+		"aria-invalid": !valid.stockISIN
+	});
+}
+//#endregion
+//#region src/components/Shared/fields/StockTickerSymbol/fieldConfig.ts
+var stockTickerSymbolFieldMetadata = {
+	validators: [validateNotEmptyOnBlur, validatePatternOnBlur(/^[A-Z\d]{1,5}$/)],
+	mask: {
+		mask: makeMask(...alphanumericInputs(1), ...alphanumericInputs(4)),
+		transformOnType: uppercase
+	}
+};
+//#endregion
+//#region src/components/Shared/fields/StockTickerSymbol/StockTickerSymbolField.tsx
+var STOCK_TICKER_SYMBOL_FIELD = ["stockTickerSymbol"];
+function StockTickerSymbolField({ data, valid, errors, readonly, mask, shouldValidate, handleChangeFor }) {
+	const { t } = useTranslation("common");
+	return /* @__PURE__ */ jsx(MaskedInput, {
+		name: "stockTickerSymbol",
+		type: "text",
+		label: t(($) => $["stockTickerSymbol"]),
+		formatGuidance: t(($) => $["enterAMaximumOfNCharactersForExample"], {
+			maxChars: "5",
+			example: "ADYEN"
+		}),
+		...mask,
+		errorMessage: errors.stockTickerSymbol,
+		isValid: valid.stockTickerSymbol ?? false,
+		value: data.stockTickerSymbol ?? "",
+		readonly,
+		shouldValidate,
+		onInput: handleChangeFor("stockTickerSymbol", "input"),
+		onBlur: handleChangeFor("stockTickerSymbol", "blur"),
+		"aria-required": true,
+		"aria-invalid": !valid.stockTickerSymbol
+	});
+}
+//#endregion
+//#region src/components/EFP/fields/LegalFormField/types.ts
+var LEGAL_FORM_FIELDS = ["legalForm", "legalFormLabel"];
+var legalFormFieldMetadata = {
+	label: "legalForm",
+	validators: [validateNotEmptyOnBlur]
+};
+//#endregion
+//#region src/api/companyDataSet/useClearCompanyData.ts
+var clearCompanyData = async (legalEntityId, baseUrl) => {
+	return httpPost({
+		baseUrl,
+		path: `legalEntities/${legalEntityId}/companyDataset/clearCompanyData`
+	});
+};
+var useClearCompanyData = (options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	const logger = createLogger();
+	return useMutation({
+		mutationFn: () => {
+			return clearCompanyData(rootLegalEntityId.value, baseUrl.value);
+		},
+		retry: 0,
+		onError: (e) => logger.error(e),
+		...options
+	});
+};
+var BasicInformation_module_default = {
+	"basic-information": "_basic-information_1rbd4_1",
+	basicInformation: "_basic-information_1rbd4_1"
+};
+//#endregion
+//#region src/components/Business/forms/BasicInformation/BasicInformation.tsx
+var BASIC_INFORMATION_FIELDS = [
+	...COUNTRY_FIELD,
+	...LEGAL_COMPANY_NAME_FIELD,
+	"jaHaniLegalCompanyName",
+	"jaKanaLegalCompanyName",
+	...TAX_INFORMATION_FIELD,
+	...STATE_FIELD,
+	...BUSINESS_REGISTRATION_NUMBER_FIELD,
+	...COUNTRY_OF_GOVERNING_LAW_FIELD
+];
+var FormDescription = ({ description, t }) => {
+	return /* @__PURE__ */ jsxs("div", { children: [
+		description,
+		" ",
+		/* @__PURE__ */ jsx(Link, {
+			href: "https://www.adyen.com/privacy-policy",
+			external: true,
+			children: t(($) => $["privacyStatement"])
+		})
+	] });
+};
+var EMPTY_OBJ$5 = {};
+function BasicInformation({ id, country, shouldValidate, fieldValidationErrors = EMPTY_OBJ$5, formVerificationErrors = EMPTY_OBJ$5, isTopLevelEntity, disableCountry, companyType, taskType }) {
+	const { t } = useTranslation(["common", "business"]);
+	const { t: businessT } = useTranslation("business");
+	const { isSettingEnabled } = useSettingsContext();
+	const { form } = useFormContext();
+	const allowedCountries = useAllowedCountries();
+	const isAllowedEditPrefilledCountry = isSettingEnabled(SettingNames.AllowPrefilledCountryEdit);
+	const { data, defaultData, valid, errors, requiredFields, optionalFields, obscuredFields, trustedFields, fieldProblems, handleChange: handleChangeFor } = getFormSlice(form, "basicInformation");
+	const state = data?.stateOrProvince;
+	const currentCountryTaxInformation = data?.taxInformation?.find((tax) => tax.country === country);
+	const formUtils = useMemo$1(() => createFormUtils({
+		requiredFields,
+		optionalFields,
+		trustedFields,
+		obscuredFields
+	}, t), [
+		requiredFields,
+		optionalFields,
+		trustedFields,
+		obscuredFields,
+		t
+	]);
+	const showField = (fieldKeys) => fieldKeys.some((field) => {
+		switch (field) {
+			case "registrationNumberType":
+			case "registrationNumber":
+				if (isUsingCompanySearch(country, taskType)) return data?.country === "US" ? (formUtils.isRequiredField(field) || formUtils.isOptionalField(field)) && data?.stateOrProvince : formUtils.isRequiredField(field) || formUtils.isOptionalField(field);
+				return formUtils.isRequiredField(field) || formUtils.isOptionalField(field);
+			default: return formUtils.isRequiredField(field) || formUtils.isOptionalField(field);
+		}
+	});
+	const legalCompanyNameFields = useLegalCompanyNameField({
+		data: data ?? {},
+		valid: valid ?? {},
+		errors: errors ?? {},
+		fieldProblems: fieldProblems ?? {},
+		country,
+		formUtils,
+		handleChange: handleChangeFor,
+		t: businessT
+	});
+	return /* @__PURE__ */ jsxs("form", {
+		id,
+		className: BasicInformation_module_default.basicInformation,
+		children: [
+			/* @__PURE__ */ jsx(Header, {
+				title: t(($) => $["basicInformationFormHeading"], { ns: "business" }),
+				children: /* @__PURE__ */ jsx(FormDescription, {
+					slot: "description",
+					description: t(($) => $["basicInformationFormDescription"], { ns: "business" }),
+					t
+				})
+			}),
+			/* @__PURE__ */ jsx(ErrorPanel, {
+				id: "ariaErrorField",
+				verificationErrors: formVerificationErrors,
+				validationErrors: fieldValidationErrors,
+				formUtils
+			}),
+			legalCompanyNameFields.map((field) => /* @__PURE__ */ jsx(Field, {
+				name: field?.name ?? "",
+				label: field?.label,
+				formatGuidance: field?.guidance,
+				errorMessage: field?.errorMessage,
+				isValid: Boolean(field?.isValid),
+				children: (childProps) => /* @__PURE__ */ jsx(InputText, {
+					...childProps,
+					"aria-required": true,
+					"aria-invalid": !field?.isValid,
+					name: field?.name,
+					value: field?.value,
+					readonly: field?.readonly,
+					onInput: field ? field.onInput : () => {},
+					transformInput: field?.transformInput,
+					transformMode: field?.transformMode,
+					onBlur: field?.onBlur,
+					onKeyDown: field?.onKeyDown
+				})
+			}, field?.name)),
+			/* @__PURE__ */ jsxs("fieldset", { children: [
+				/* @__PURE__ */ jsx(CountryField, {
+					data: formUtils.getFieldData(data ?? {}, COUNTRY_FIELD),
+					valid: formUtils.getFieldValid(valid ?? {}, COUNTRY_FIELD),
+					errors: formUtils.getFieldErrors(errors ?? {}, fieldValidationErrors, COUNTRY_FIELD),
+					labels: formUtils.getFieldLabels(COUNTRY_FIELD, { country: "countryRegionOfEstablishment" }),
+					readonly: formUtils.isReadOnly("country") || !isAllowedEditPrefilledCountry || Boolean(disableCountry),
+					handleChangeFor,
+					allowedCountries: isTopLevelEntity ? allowedCountries : void 0
+				}),
+				showField(COUNTRY_OF_GOVERNING_LAW_FIELD) && /* @__PURE__ */ jsx(CountryOfGoverningLawField, {
+					data: formUtils.getFieldData(data ?? {}, COUNTRY_OF_GOVERNING_LAW_FIELD),
+					country,
+					valid: formUtils.getFieldValid(valid ?? {}, COUNTRY_OF_GOVERNING_LAW_FIELD),
+					errors: formUtils.getFieldErrors(errors ?? {}, fieldValidationErrors, COUNTRY_OF_GOVERNING_LAW_FIELD),
+					allowedCountries: isTopLevelEntity ? allowedCountries : void 0,
+					handleChangeFor
+				}),
+				showField(STATE_FIELD) && /* @__PURE__ */ jsx(StateField, {
+					data: formUtils.getFieldData(data ?? {}, STATE_FIELD),
+					valid: formUtils.getFieldValid(valid ?? {}, STATE_FIELD),
+					errors: formUtils.getFieldErrors(errors ?? {}, fieldValidationErrors, STATE_FIELD),
+					labelOverride: t(($) => $["whereIsYourBusinessRegistered"]),
+					readonly: formUtils.isReadOnly("stateOrProvince"),
+					handleChangeFor,
+					selectedCountry: country
+				}),
+				showField(TAX_INFORMATION_FIELD) && /* @__PURE__ */ jsx(TaxInformationField, {
+					data: formUtils.getFieldData(data ?? {}, TAX_INFORMATION_FIELD),
+					valid: formUtils.getFieldValid(valid ?? {}, TAX_INFORMATION_FIELD),
+					errors: formUtils.getFieldErrors(errors ?? {}, fieldValidationErrors, TAX_INFORMATION_FIELD),
+					placeholder: getTaxInformationPlaceholderText({
+						country,
+						companyType,
+						taxIdNumberType: currentCountryTaxInformation?.type
+					}),
+					readonly: formUtils.isReadOnly("taxInformation"),
+					shouldValidate,
+					handleChangeFor,
+					canExempt: showField(["exemptedFromTax"]),
+					registrationNumber: data?.registrationNumber,
+					country,
+					entityType: companyType,
+					defaultData: defaultData?.taxInformation
+				}),
+				showField(BUSINESS_REGISTRATION_NUMBER_FIELD) && /* @__PURE__ */ jsx(BusinessRegistrationNumberField, {
+					data: formUtils.getFieldData(data ?? {}, BUSINESS_REGISTRATION_NUMBER_FIELD),
+					valid: formUtils.getFieldValid(valid ?? {}, BUSINESS_REGISTRATION_NUMBER_FIELD),
+					errors: formUtils.getFieldErrors(errors ?? {}, fieldValidationErrors, BUSINESS_REGISTRATION_NUMBER_FIELD),
+					readonly: formUtils.isReadOnly("registrationNumber"),
+					optional: formUtils.isOptionalField("registrationNumber"),
+					shouldValidate,
+					handleChangeFor,
+					country,
+					state,
+					canExempt: showField(["exemptedFromRegistrationNumber"]),
+					companyType
+				})
+			] }),
+			country === "US" && /* @__PURE__ */ jsx(PatriotActDisclosure, {})
+		]
+	});
+}
+//#endregion
+//#region src/utils/performance.ts
+/**
+* Start timing an operation
+* @param key - Unique identifier for the operation
+* @param timings - Map to store timing information
+* @returns The start timestamp
+*/
+var startTiming = (key, timings = /* @__PURE__ */ new Map()) => {
+	const startTime = Date.now();
+	timings.set(key, { startTime });
+	return startTime;
+};
+/**
+* End timing an operation and calculate duration
+* @param key - Unique identifier for the operation
+* @param timings - Map containing timing information
+* @returns The duration in milliseconds, or undefined if timing wasn't started
+*/
+var endTiming = (key, timings) => {
+	const timing = timings.get(key);
+	if (!timing || timing.endTime) return;
+	const endTime = Date.now();
+	const duration = endTime - timing.startTime;
+	const updatedTiming = {
+		...timing,
+		endTime,
+		duration
+	};
+	timings.set(key, updatedTiming);
+	return duration;
+};
+/**
+* Execute a function with automatic timing
+* @param key - Unique identifier for the operation
+* @param fn - Function to execute
+* @param analytics - UserEvents instance for logging
+* @param timings - Optional map to store timing information
+* @returns Promise that resolves with the function result and timing duration
+*/
+var withTiming = async (key, fn, analytics, timings = /* @__PURE__ */ new Map()) => {
+	startTiming(key, timings);
+	try {
+		const result = await fn();
+		const duration = endTiming(key, timings) || 0;
+		analytics.addEvent("Performance", {
+			actionType: "resolve",
+			actionLevel: "page",
+			label: key,
+			additionalData: { duration }
+		});
+		return {
+			result,
+			duration
+		};
+	} catch (error) {
+		const duration = endTiming(key, timings) || 0;
+		analytics.addEvent("Performance", {
+			actionType: "reject",
+			actionLevel: "page",
+			label: key,
+			additionalData: { duration }
+		});
+		throw error;
+	}
+};
+/**
+* Convenience function to track async operation timing
+* @param key - Unique identifier for the operation
+* @param fn - Function to execute
+* @param analytics - UserEvents instance for logging
+* @returns Promise that resolves with the function result
+*/
+var trackPerformance = async (key, fn, analytics) => {
+	const { result } = await withTiming(key, fn, analytics);
+	return result;
+};
+//#endregion
+//#region src/api/companySearch/useCompanySearch.ts
+/**
+* Supports querying declaratively (`useCompanySearch` hook) and imperatively
+* (`queryClient.fetchQuery()`) with the same config, ensuring no deviation occurs
+* between the two types.
+*/
+var companySearchQueryOptions = (rootLegalEntityId, baseUrl, data, userEvents, options) => {
+	return queryOptions({
+		queryKey: ["companySearch", data],
+		queryFn: () => trackPerformance("companySearchNetworkTime", () => handleCompanySearch(rootLegalEntityId, baseUrl, data), userEvents),
+		retry: 0,
+		meta: {
+			onSuccess: (data) => {
+				userEvents.addPageEvent("Success", {
+					actionType: "resolve",
+					returnValue: "companySearch",
+					additionalData: {
+						numberOfResults: data.results.length,
+						..."provider" in data && { provider: data.provider }
+					}
+				});
+			},
+			onError: () => {
+				userEvents.addPageEvent("Encountered error", {
+					actionType: "resolve",
+					returnValue: "companySearch",
+					returnType: "backend"
+				});
+			}
+		},
+		...options
+	});
+};
+var useCompanySearch = (data, options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	const userEvents = useAnalyticsContext();
+	return useQuery(companySearchQueryOptions(rootLegalEntityId.value, baseUrl.value, data, userEvents, options));
+};
+var handleCompanySearch = async (rootLegalEntityId, baseUrl, data) => {
+	return httpPost({
+		baseUrl,
+		path: `legalEntities/${rootLegalEntityId}/companySearch/search`
+	}, {
+		name: data.name,
+		country: data.country,
+		stateOrProvince: data.state,
+		...data.registrationNumber ? { registrationNumber: data.registrationNumber } : {},
+		resultSizeLimit: data.resultSizeLimit ?? 15
+	});
+};
+//#endregion
+//#region src/api/companyDataSet/handleCompanyDataset.ts
+var handleCompanyDataset = async (rootLegalEntityId, baseUrl, data) => {
+	return httpPost({
+		baseUrl,
+		path: `legalEntities/${rootLegalEntityId}/companyDataset/select`
+	}, data);
+};
+//#endregion
+//#region src/api/tinVerification/useVerifyTin.ts
+/**
+* Supports querying declaratively (`useVerifyTin` hook) and imperatively
+* (`queryClient.fetchQuery()`) with the same config, ensuring no deviation occurs
+* between the two types.
+*/
+var verifyTinQueryOptions = (rootLegalEntityId, baseUrl, data, userEvents, options) => {
+	return queryOptions({
+		queryKey: ["verifyTin", data],
+		queryFn: data ? () => trackPerformance("verifyTinNetworkTime", () => verifyTin(rootLegalEntityId, baseUrl, data), userEvents) : skipToken,
+		retry: 0,
+		meta: {
+			onSuccess: (data) => {
+				if (data.matched === true) userEvents.addPageEvent("Success", {
+					actionType: "verify",
+					returnValue: "verifyTin",
+					returnType: "validation"
+				});
+				else userEvents.addPageEvent("Encountered error", {
+					actionType: "verify",
+					returnValue: "verifyTin",
+					returnType: "validation"
+				});
+			},
+			onError: () => {
+				userEvents.addPageEvent("Encountered error", {
+					actionType: "verify",
+					returnValue: "verifyTin",
+					returnType: "backend"
+				});
+			}
+		},
+		...options
+	});
+};
+var verifyTin = async (legalEntityId, baseUrl, data) => {
+	return httpPost({
+		baseUrl,
+		path: `legalEntities/${legalEntityId}/verifyTin`
+	}, data);
+};
+//#endregion
+//#region src/api/companySelection/useCompanySelection.ts
+var useCompanySelection = (options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	const userEvents = useAnalyticsContext();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (data) => trackPerformance("companySelectionNetworkTime", () => handleCompanySelection(rootLegalEntityId.value, baseUrl.value, queryClient, data, userEvents), userEvents),
+		onSuccess: (data) => {
+			userEvents.addPageEvent("Success", {
+				actionType: "select",
+				returnValue: "companySelection",
+				returnType: "validation",
+				additionalData: { tinMatched: data.tinMatched === true }
+			});
+		},
+		onError: () => {
+			userEvents.addPageEvent("Encountered error", {
+				actionType: "select",
+				returnValue: "companySelection",
+				returnType: "backend"
+			});
+		},
+		retry: (count, error) => {
+			if ("errorCode" in error && typeof error.errorCode == "string") {
+				if (error.errorCode === "00_422") return false;
+			}
+			return count === 0;
+		},
+		...options
+	});
+};
+var handleCompanySelection = async (rootLegalEntityId, baseUrl, queryClient, data, userEvents) => {
+	switch (data.country) {
+		case CountryCodes.UnitedStates: {
+			const verifyTinQueryInput = {
+				name: data.name,
+				tin: data.tin
+			};
+			const [companyDatasetResult, tinMatchResult] = await Promise.allSettled([handleCompanyDataset(rootLegalEntityId, baseUrl, { id: data.id }), queryClient.fetchQuery(verifyTinQueryOptions(rootLegalEntityId, baseUrl, verifyTinQueryInput, userEvents))]);
+			if (companyDatasetResult.status === "rejected") throw companyDatasetResult;
+			return {
+				...companyDatasetResult.value,
+				tinMatched: tinMatchResult.status === "fulfilled" ? tinMatchResult.value.matched : false
+			};
+		}
+		default: {
+			const companyDatasetResult = await handleCompanyDataset(rootLegalEntityId, baseUrl, { id: data.id });
+			return {
+				...companyDatasetResult,
+				registrationNumberMatched: companyDatasetResult.registrationNumber && data.registrationNumber ? data.registrationNumber === companyDatasetResult.registrationNumber : void 0
+			};
+		}
+	}
+};
+//#endregion
+//#region src/components/Business/forms/BusinessSelection/BusinessInformationCard/BusinessInformationCard.tsx
+function BusinessInformation({ fetching, selectedBusiness }) {
+	const { t } = useTranslation(["common", "business"]);
+	const items = useMemo$1(() => selectedBusiness ? entriesOf(selectedBusiness).reduce((acc, [key, value]) => {
+		switch (key) {
+			case "legalForm":
+				if (value) acc[0].details = value;
+				break;
+			case "name":
+				if (value) acc[1].details = value;
+				break;
+			case "registeredAddress":
+			case "principalPlaceOfBusinessAddress":
+				if (value && typeof value !== "string" && "fullAddress" in value) acc[2].details = value.fullAddress;
+				break;
+			default: break;
+		}
+		return acc;
+	}, [
+		{
+			term: t(($) => $["legalForm"], { ns: "common" }),
+			details: ""
+		},
+		{
+			term: t(($) => $["legalCompanyName"], { ns: "common" }),
+			details: ""
+		},
+		{
+			term: t(($) => $["address"], { ns: "common" }),
+			details: ""
+		}
+	]).filter((item) => !!item.details) : [], [selectedBusiness, t]);
+	if (fetching) return /* @__PURE__ */ jsx(Loader, { size: "large" });
+	return /* @__PURE__ */ jsx(StructuredList, { items });
+}
+function BusinessInformationCard({ result, isSelected, currentBusinessSelection, fetching, error, handleSelectBusiness, retryCompanySelection }) {
+	const { t } = useTranslation(["common", "business"]);
+	const isLegalArrangementError = error && isBusinessSelectionLegalArrangementError(error);
+	return /* @__PURE__ */ jsx(Card, {
+		selected: isSelected,
+		onClick: isSelected ? void 0 : handleSelectBusiness,
+		children: /* @__PURE__ */ jsxs(StackLayout, { children: [/* @__PURE__ */ jsx(ListItem, {
+			avatar: {
+				iconName: "company",
+				circle: true
+			},
+			title: result.name,
+			description: result.registrationNumber,
+			accessory: fetching && isSelected ? /* @__PURE__ */ jsx(Loader, { size: "medium" }) : null
+		}), isSelected && !fetching && !isLegalArrangementError && /* @__PURE__ */ jsx(StackLayout, { children: error ? /* @__PURE__ */ jsx(Alert, {
+			variant: "info",
+			type: "callToAction",
+			title: t(($) => $["businessDetailsFailedToLoad"], { ns: "business" }),
+			actions: /* @__PURE__ */ jsx(Button, {
+				testId: "reloadBusiness",
+				onClick: retryCompanySelection,
+				variant: "link",
+				children: t(($) => $["tryAgain"], { ns: "common" })
+			}),
+			testId: "failedToLoad"
+		}) : /* @__PURE__ */ jsx(Card, {
+			variant: "secondary",
+			padding: "large",
+			children: /* @__PURE__ */ jsx(BusinessInformation, {
+				fetching,
+				selectedBusiness: currentBusinessSelection
+			})
+		}) })] })
+	});
+}
+function CompanyNotListedCard({ isSelected, handleSelectBusiness, fetching }) {
+	const { t } = useTranslation(["business"]);
+	return /* @__PURE__ */ jsx(Card, {
+		selected: isSelected,
+		onClick: isSelected ? void 0 : handleSelectBusiness,
+		children: /* @__PURE__ */ jsx(ListItem, {
+			title: t(($) => $["myBusinessIsntHere"], { ns: "business" }),
+			accessory: fetching && isSelected ? /* @__PURE__ */ jsx(Loader, { size: "medium" }) : null
+		})
+	});
+}
+//#endregion
+//#region src/components/Business/forms/BusinessSelection/BusinessSelection.tsx
+var BUSINESS_SELECTION_FIELDS = ["selectedBusinessId"];
+var EMPTY_OBJ$4 = {};
+function BusinessSelection({ id, country, fieldValidationErrors = EMPTY_OBJ$4, formVerificationErrors = EMPTY_OBJ$4 }) {
+	const { t } = useTranslation(["common", "business"]);
+	const { baseUrl, rootLegalEntityId } = useApiContext();
+	const { form } = useFormContext();
+	const queryClient = useQueryClient();
+	const userEvents = useAnalyticsContext();
+	const logger = createLogger();
+	const companySearchStateModel = useContext$1(CompanySearchStateContext);
+	const { data, valid, errors, allFields, requiredFields, optionalFields, obscuredFields, trustedFields, handleChange: handleChangeFor } = getFormSlice(form, "businessSelection");
+	const { data: companySearchResponse, isLoading: searching } = useCompanySearch({
+		name: companySearchStateModel.companySearchName.value ?? "",
+		country,
+		state: form.data.basicInformation?.stateOrProvince,
+		registrationNumber: form.data.basicInformation?.registrationNumber
+	});
+	const { data: selectData, error: selectError, mutateAsync: selectCompany, reset: resetSelectMutationState } = useCompanySelection();
+	const { mutateAsync: clearCompanyData } = useClearCompanyData();
+	const currentTin = form.data.basicInformation?.taxInformation?.find((taxId) => taxId.country === country)?.number;
+	const currentRegistrationNumber = form.data.basicInformation?.registrationNumber;
+	/**
+	* This ID is internal to this form, controlling selection for UI & data flow purposes. The
+	* multiform state is used to determine whether the form is set & valid, ready for the user to progress.
+	*/
+	const selectedId = useSignal("");
+	const isSelectPending = useSignal(false);
+	const selectedCompanyIdx = companySearchResponse?.results.findIndex((searchResult) => searchResult.resultId === selectedId.value);
+	/**
+	* Reset company selection when re-entering form.
+	*
+	* The mutation makes this a bit awkward, as we won't have any data when re-entering. Whilst we
+	* could perhaps auto-select the result, without caching, we'd have another spinner & wait time for
+	* the user. Better to force a manual re-selection to work around our rough implementation details.
+	*/
+	const isInitializedRef = useRef$1(false);
+	if (!isInitializedRef.current) {
+		if (data?.selectedBusinessId) {
+			handleChangeFor("selectedBusinessId", "blur")("");
+			form.setErrors("businessSelection", "selectedBusinessId", null);
+		}
+		isInitializedRef.current = true;
+	}
+	const fetchCompanyData = async (result) => {
+		isSelectPending.value = true;
+		resetSelectMutationState();
+		try {
+			const companySelectionParams = {
+				id: result.resultId,
+				name: result.name,
+				tin: currentTin ?? "",
+				registrationNumber: currentRegistrationNumber ?? "",
+				country
+			};
+			const companySelectionResponse = await selectCompany(companySelectionParams);
+			handleChangeFor("selectedBusinessId", "blur")(result.resultId);
+			companySearchStateModel.selectCompany(companySelectionResponse, selectedCompanyIdx, country);
+		} catch (e) {
+			if (isBusinessSelectionLegalArrangementError(e)) {
+				companySearchStateModel.disallowSelection("LEGAL_ARRANGEMENT");
+				handleChangeFor("selectedBusinessId", "blur")("LEGAL_ARRANGEMENT_ERR");
+			} else logger.error(e);
+		} finally {
+			isSelectPending.value = false;
+		}
+	};
+	const handleSelectBusiness = (result) => {
+		selectedId.value = result.resultId;
+		companySearchStateModel.resetCompanySearchData();
+		fetchCompanyData(result);
+	};
+	const handleSelectNotListed = async () => {
+		selectedId.value = "notListed";
+		companySearchStateModel.resetCompanySearchData();
+		await clearCompanyData();
+		if (country !== CountryCodes.UnitedStates) return handleChangeFor("selectedBusinessId", "blur")("notListed");
+		try {
+			isSelectPending.value = true;
+			const tinVerificationParams = {
+				name: form.data.basicInformation?.legalCompanyName ?? "",
+				tin: currentTin ?? ""
+			};
+			const { matched } = await queryClient.fetchQuery(verifyTinQueryOptions(rootLegalEntityId.peek(), baseUrl.peek(), tinVerificationParams, userEvents));
+			companySearchStateModel.setVerificationMatched(!!matched);
+			handleChangeFor("selectedBusinessId", "blur")("notListed");
+		} catch (e) {
+			logger.error(e);
+			companySearchStateModel.setVerificationMatched(false);
+			handleChangeFor("selectedBusinessId", "blur")("notListed");
+		} finally {
+			isSelectPending.value = false;
+		}
+	};
+	const formUtils = useMemo$1(() => {
+		return createFormUtils({
+			data: data ?? {},
+			fieldValidationErrors,
+			formVerificationErrors,
+			allFields: allFields ?? [],
+			requiredFields: requiredFields ?? [],
+			optionalFields: optionalFields ?? [],
+			trustedFields: trustedFields ?? [],
+			obscuredFields: obscuredFields ?? [],
+			errors: errors ?? {},
+			valid: valid ?? {}
+		}, t);
+	}, [
+		allFields,
+		data,
+		errors,
+		obscuredFields,
+		optionalFields,
+		requiredFields,
+		trustedFields,
+		valid,
+		t,
+		fieldValidationErrors,
+		formVerificationErrors
+	]);
+	return /* @__PURE__ */ jsx("form", {
+		id,
+		children: /* @__PURE__ */ jsxs(LoaderWrapper, {
+			loaderSize: "large",
+			status: searching ? "loading" : "success",
+			children: [
+				/* @__PURE__ */ jsx(Header, { title: t(($) => $["businessSelectionFormHeading"], { ns: "business" }) }),
+				/* @__PURE__ */ jsx(ErrorPanel, {
+					id: "ariaErrorField",
+					verificationErrors: formVerificationErrors,
+					validationErrors: fieldValidationErrors,
+					formUtils
+				}),
+				/* @__PURE__ */ jsx(Field, {
+					el: "fieldset",
+					name: "selectedBusinessId",
+					errorMessage: formUtils.getErrorMessage("selectedBusinessId", errors, fieldValidationErrors),
+					isValid: valid?.selectedBusinessId,
+					children: () => /* @__PURE__ */ jsxs(StackLayout, { children: [companySearchResponse?.results.map((result) => /* @__PURE__ */ jsx(BusinessInformationCard, {
+						result,
+						isSelected: selectedId.value === result.resultId,
+						currentBusinessSelection: selectData,
+						fetching: isSelectPending.value,
+						error: selectError,
+						handleSelectBusiness: () => handleSelectBusiness(result),
+						retryCompanySelection: () => fetchCompanyData(result)
+					}, result.resultId)), /* @__PURE__ */ jsx(CompanyNotListedCard, {
+						isSelected: selectedId.value === "notListed",
+						handleSelectBusiness: handleSelectNotListed,
+						fetching: isSelectPending.value
+					})] })
+				})
+			]
+		})
+	});
+}
+//#endregion
+//#region src/components/Business/utils/companyTypeMetadata.ts
+var companyTypeMetadata = {
+	privateCompany: {
+		id: "privateCompany",
+		name: "privateCompanyTitle",
+		description: "privateCompanyDescription"
+	},
+	listedPublicCompany: {
+		id: "listedPublicCompany",
+		name: "publicCompanyTitle",
+		description: "publicCompanyDescription"
+	},
+	partnershipIncorporated: {
+		id: "partnershipIncorporated",
+		name: "partnershipIncorporated",
+		description: "partnershipIncorporatedDescription"
+	},
+	nonProfit: {
+		id: "nonProfit",
+		name: "nonProfitOrCharitableOrgTitle",
+		description: "nonProfitOrCharitableOrgDescription"
+	},
+	governmentalOrganization: {
+		id: "governmentalOrganization",
+		name: "governmentalOrganizationTitle",
+		description: "governmentalOrganizationDescription"
+	},
+	associationIncorporated: {
+		id: "associationIncorporated",
+		name: "associationIncorporated",
+		description: "associationIncorporatedDescription"
+	}
+};
+var companyTypeOptions = Object.keys(companyTypeMetadata);
+//#endregion
+//#region src/components/Business/utils/getAvailableCompanyStructures.ts
+function getAvailableCompanyStructures({ country, registrationNumberType, registrationNumberExempt, taxIdNumberType, legalEntity, accountHolder, isSettingEnabled }) {
+	const isRootOrganization = isSettingEnabled(SettingNames.AllowLegalEntityTypeChange) && accountHolder !== "aTrust" && accountHolder !== "anUnincorporatedPartnership";
+	const excludedTypes = !!legalEntity.capabilities?.issueBankAccount?.requested ? [
+		"partnershipIncorporated",
+		"associationIncorporated",
+		"governmentalOrganization"
+	] : ["partnershipIncorporated", "associationIncorporated"];
+	const companyTypeRadioOptions = isRootOrganization ? companyTypeOptions.filter((companyType) => !excludedTypes.includes(companyType)) : companyTypeOptions;
+	const validCompanyTypesByRegistrationNumber = registrationNumberExempt && isRegistrationExemptionAllowed({ country }) ? REGISTRATION_NUMBER_EXEMPTION_RULES[country] ?? [] : getValidCompanyTypesForRegistrationNumberType(country, registrationNumberType);
+	const validCompanyTypesForRegistrationNumber = new Set(validCompanyTypesByRegistrationNumber);
+	const validCompanyTypesForTaxId = new Set(getValidCompanyTypesForTaxIdNumberType(country, taxIdNumberType));
+	const constrainedCompanyTypeRadioOptions = companyTypeRadioOptions.filter((companyType) => (!validCompanyTypesForRegistrationNumber.size || validCompanyTypesForRegistrationNumber.has(companyType)) && (!validCompanyTypesForTaxId.size || validCompanyTypesForTaxId.has(companyType)));
+	return constrainedCompanyTypeRadioOptions.length > 0 ? constrainedCompanyTypeRadioOptions : companyTypeRadioOptions;
+}
+//#endregion
+//#region src/components/Business/forms/CompanyStructure/CompanyStructure.tsx
+var COMPANY_STRUCTURE_FIELDS = ["entityType"];
+var EMPTY_OBJ$3 = {};
+function CompanyStructure({ id, country, fieldValidationErrors = EMPTY_OBJ$3, formVerificationErrors = EMPTY_OBJ$3 }) {
+	const { t } = useTranslation([
+		"common",
+		"business",
+		"ui"
+	]);
+	const { form } = useFormContext();
+	const { accountHolder } = useAccountHolder();
+	const { rootLegalEntityId } = useApiContext();
+	const { data: legalEntity } = useLegalEntity(rootLegalEntityId.value);
+	const { isSettingEnabled } = useSettingsContext();
+	const { data, valid, errors, requiredFields, handleChange: handleChangeFor } = getFormSlice(form, "companyStructure");
+	const formUtils = createFormUtils({ requiredFields: requiredFields ?? [] }, t);
+	const registrationNumberType = form.data.basicInformation?.registrationNumberType;
+	const taxIdNumberType = form.data.basicInformation?.taxInformation?.find((taxInformation) => taxInformation.country === country)?.type;
+	const registrationNumberExempt = form.data.basicInformation?.exemptedFromRegistrationNumber;
+	const availableCompanyTypeRadioOptions = getAvailableCompanyStructures({
+		country,
+		registrationNumberType,
+		registrationNumberExempt,
+		taxIdNumberType,
+		legalEntity: legalEntity || {},
+		accountHolder,
+		isSettingEnabled
+	});
+	const companyTypeExamples = useCompanyTypeExamples(country);
+	const companyTiles = availableCompanyTypeRadioOptions.map((option) => {
+		const description = t(($) => $[companyTypeMetadata[option].description], { ns: "business" });
+		const examples = companyTypeExamples?.[option];
+		const subTitle = examples ? `${description} ${t(($) => $["forExample_"], {
+			examples: examples.join(", "),
+			interpolation: { escapeValue: false },
+			ns: "ui"
+		})}` : description;
+		return {
+			value: option,
+			label: t(($) => $[companyTypeMetadata[option].name], { ns: "business" }),
+			subTitle
+		};
+	});
+	return /* @__PURE__ */ jsxs("form", {
+		id,
+		children: [
+			/* @__PURE__ */ jsx(Header, {
+				title: t(($) => $["companyStructureFormHeading"], { ns: "business" }),
+				description: t(($) => $["companyStructureFormDescription"], { ns: "business" })
+			}),
+			/* @__PURE__ */ jsx(ErrorPanel, {
+				id: "ariaErrorField",
+				verificationErrors: formVerificationErrors,
+				validationErrors: fieldValidationErrors,
+				formUtils
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				el: "fieldset",
+				name: "entityType",
+				errorMessage: formUtils.getErrorMessage("entityType", errors, fieldValidationErrors),
+				isValid: valid?.entityType,
+				children: (childProps) => /* @__PURE__ */ jsx(TileGroup, {
+					...childProps,
+					name: "entityType",
+					tiles: companyTiles,
+					selected: data?.entityType ?? "",
+					onChange: (value) => handleChangeFor("entityType")(value),
+					isHorizontal: true,
+					"aria-required": true,
+					"aria-invalid": !valid?.entityType
+				})
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/Shared/fields/FinancialReportingDate/FinancialReportingDate.tsx
+var FINANCIAL_REPORTING_DATE_FIELD = ["financialReportingDate"];
+function FinancialReportingDate({ data, valid, errors, labels, readonly, handleChangeFor }) {
+	const { t } = useTranslation("common");
+	return /* @__PURE__ */ jsx(Field, {
+		name: "financialReportingDate",
+		label: labels.financialReportingDate,
+		helper: t(($) => $["dateOfTotalAssetsCalculation"]),
+		helperPosition: "below",
+		errorMessage: errors.financialReportingDate,
+		isValid: valid.financialReportingDate,
+		children: (childProps) => /* @__PURE__ */ jsx(InputDate, {
+			...childProps,
+			name: "financialReportingDate",
+			value: data.financialReportingDate,
+			onInput: handleChangeFor("financialReportingDate", "input"),
+			onBlur: handleChangeFor("financialReportingDate", "blur"),
+			"aria-required": true,
+			"aria-invalid": !valid.financialReportingDate,
+			readonly,
+			max: formatDateObj(/* @__PURE__ */ new Date())
+		})
+	});
+}
+//#endregion
+//#region src/components/Shared/fields/NumberOfEmployees/NumberOfEmployees.tsx
+var NUMBER_OF_EMPLOYEES_FIELD = ["numberOfEmployees"];
+function NumberOfEmployees({ data, valid, errors, labels, readonly, handleChangeFor }) {
+	return /* @__PURE__ */ jsx(Field, {
+		name: "numberOfEmployees",
+		label: labels.numberOfEmployees,
+		errorMessage: errors.numberOfEmployees,
+		isValid: valid.numberOfEmployees,
+		children: (childProps) => /* @__PURE__ */ jsx(InputNumber, {
+			...childProps,
+			"aria-required": true,
+			"aria-invalid": !valid.numberOfEmployees,
+			name: "numberOfEmployees",
+			min: "1",
+			step: "1",
+			value: data.numberOfEmployees,
+			readonly,
+			onInput: handleChangeFor("numberOfEmployees", "input"),
+			onBlur: handleChangeFor("numberOfEmployees", "blur")
+		})
+	});
+}
+var ReportedValueOptionField_module_default = {
+	"reported-value-options": "_reported-value-options_tqpoa_1",
+	reportedValueOptions: "_reported-value-options_tqpoa_1",
+	"reported-value": "_reported-value_tqpoa_1",
+	reportedValue: "_reported-value_tqpoa_1",
+	"reported-value-input": "_reported-value-input_tqpoa_11",
+	reportedValueInput: "_reported-value-input_tqpoa_11",
+	"reported-value-field": "_reported-value-field_tqpoa_15",
+	reportedValueField: "_reported-value-field_tqpoa_15"
+};
+//#endregion
+//#region src/components/Shared/fields/ReportedValueOptionField/ReportedValue.tsx
+var ReportedValue = ({ currency, amount, onAmountChanged, label, helper, fieldName, errorMessage, isValid }) => {
+	const { i18n } = useTranslation();
+	return /* @__PURE__ */ jsx("div", {
+		className: ReportedValueOptionField_module_default.reportedValue,
+		children: /* @__PURE__ */ jsx(Field, {
+			name: fieldName,
+			errorMessage,
+			isValid,
+			helper,
+			className: ReportedValueOptionField_module_default.reportedValueField,
+			children: (childProps) => /* @__PURE__ */ jsx(InputCurrency, {
+				...childProps,
+				locale: i18n.language,
+				currency,
+				amount,
+				onAmountChanged,
+				className: ReportedValueOptionField_module_default.reportedValueInput,
+				"aria-label": label
+			})
+		})
+	});
+};
+//#endregion
+//#region src/components/Shared/fields/ReportedValueOptionField/ReportedValueOptionField.tsx
+var REPORTED_VALUE_OPTION_FIELD = [
+	"reportedValueOption",
+	"balanceSheetTotal",
+	"annualTurnover"
+];
+function ReportedValueOptionField({ data, valid, errors, handleChangeFor, currency }) {
+	const { t } = useTranslation("common");
+	const updateReportedValueOption = (option) => {
+		if (data.reportedValueOption) handleChangeFor(data.reportedValueOption)(null);
+		const newReportedValue = option;
+		handleChangeFor("reportedValueOption")(newReportedValue);
+	};
+	return /* @__PURE__ */ jsx(Field, {
+		el: "fieldset",
+		name: "reportedValueOption",
+		label: t(($) => $["reportedValue"]),
+		errorMessage: errors.reportedValueOption,
+		helper: t(($) => $["useFiguresFromTheMostRecentYearAvailable"]),
+		isValid: Boolean(valid.reportedValueOption),
+		children: (childProps) => /* @__PURE__ */ jsx(RadioGroup, {
+			name: "reportedValueOption",
+			...childProps,
+			value: data.reportedValueOption,
+			items: [{
+				id: "balanceSheetTotal",
+				name: "balanceSheetTotal",
+				content: /* @__PURE__ */ jsx(ReportedValue, {
+					label: t(($) => $["balanceSheetTotal"]),
+					currency,
+					amount: data.balanceSheetTotal,
+					onAmountChanged: handleChangeFor("balanceSheetTotal"),
+					fieldName: "balanceSheetTotal",
+					isValid: valid.balanceSheetTotal,
+					errorMessage: errors.balanceSheetTotal
+				})
+			}, {
+				id: "annualTurnover",
+				name: "annualTurnover",
+				content: /* @__PURE__ */ jsx(ReportedValue, {
+					label: t(($) => $["annualTurnover"]),
+					currency,
+					amount: data.annualTurnover,
+					onAmountChanged: handleChangeFor("annualTurnover"),
+					fieldName: "annualTurnover",
+					isValid: valid.annualTurnover,
+					errorMessage: errors.annualTurnover
+				})
+			}],
+			onChange: updateReportedValueOption,
+			showContentOnlyOnSelected: true,
+			className: ReportedValueOptionField_module_default.reportedValueOptions
+		})
+	});
+}
+//#endregion
+//#region src/components/Business/forms/FinancialInformation/FinancialInformation.tsx
+var financialInformationFieldsForEu = [
+	...FINANCIAL_REPORTING_DATE_FIELD,
+	...CURRENCY_FIELD,
+	...REPORTED_VALUE_OPTION_FIELD
+];
+var financialInformationFields = [
+	...NUMBER_OF_EMPLOYEES_FIELD,
+	...FINANCIAL_REPORTING_DATE_FIELD,
+	...CURRENCY_FIELD,
+	...REPORTED_VALUE_OPTION_FIELD
+];
+var EMPTY_OBJ$2 = {};
+function FinancialInformation({ id, country, fieldValidationErrors = EMPTY_OBJ$2, formVerificationErrors = EMPTY_OBJ$2 }) {
+	const { t } = useTranslation("common");
+	const { form } = useFormContext();
+	const defaultCurrency = currencyByCountry[country]?.[0] ?? "EUR";
+	const { data, valid, errors, allFields, requiredFields, optionalFields, obscuredFields, trustedFields, fieldProblems, handleChange: handleChangeFor } = getFormSlice(form, "companyFinancialInformation");
+	const formUtils = useMemo$1(() => createFormUtils({
+		data: data ?? {},
+		fieldValidationErrors,
+		formVerificationErrors,
+		allFields: allFields ?? [],
+		requiredFields: requiredFields ?? [],
+		optionalFields: optionalFields ?? [],
+		trustedFields: trustedFields ?? [],
+		obscuredFields: obscuredFields ?? [],
+		errors: errors ?? {},
+		valid: valid ?? {},
+		handleFieldChange: handleChangeFor
+	}, t), [
+		data,
+		fieldValidationErrors,
+		formVerificationErrors,
+		allFields,
+		requiredFields,
+		optionalFields,
+		trustedFields,
+		obscuredFields,
+		errors,
+		valid,
+		handleChangeFor,
+		t
+	]);
+	const showField = (fieldKeys) => fieldKeys.some((field) => formUtils.isRequiredField(field) || formUtils.isOptionalField(field));
+	return /* @__PURE__ */ jsxs("form", {
+		id,
+		children: [
+			/* @__PURE__ */ jsx(Header, { title: t(($) => $["companyFinancialInformationFormHeading"], { ns: "business" }) }),
+			/* @__PURE__ */ jsx(ErrorPanel, {
+				id: "ariaErrorField",
+				verificationErrors: formVerificationErrors,
+				validationErrors: fieldValidationErrors,
+				formUtils
+			}),
+			country === CountryCodes.UnitedKingdom && /* @__PURE__ */ jsx(NumberOfEmployees, {
+				data: formUtils.getFieldData(data ?? {}, NUMBER_OF_EMPLOYEES_FIELD),
+				errors: formUtils.getFieldErrors(errors ?? {}, fieldProblems, NUMBER_OF_EMPLOYEES_FIELD),
+				handleChangeFor,
+				labels: formUtils.getFieldLabels(NUMBER_OF_EMPLOYEES_FIELD),
+				readonly: formUtils.isReadOnly("numberOfEmployees"),
+				valid: formUtils.getFieldValid(valid ?? {}, NUMBER_OF_EMPLOYEES_FIELD)
+			}),
+			showField(FINANCIAL_REPORTING_DATE_FIELD) && /* @__PURE__ */ jsx(FinancialReportingDate, {
+				data: formUtils.getFieldData(data ?? {}, FINANCIAL_REPORTING_DATE_FIELD),
+				errors: formUtils.getFieldErrors(errors ?? {}, fieldProblems, FINANCIAL_REPORTING_DATE_FIELD),
+				handleChangeFor,
+				labels: formUtils.getFieldLabels(FINANCIAL_REPORTING_DATE_FIELD),
+				readonly: formUtils.isReadOnly("financialReportingDate"),
+				valid: formUtils.getFieldValid(valid ?? {}, FINANCIAL_REPORTING_DATE_FIELD)
+			}),
+			showField(CURRENCY_FIELD) && /* @__PURE__ */ jsx(Currency, {
+				country,
+				labels: { currency: t(($) => $["reportingCurrency"]) },
+				data: formUtils.getFieldData(data ?? {}, CURRENCY_FIELD),
+				errors: formUtils.getFieldErrors(errors ?? {}, fieldProblems, CURRENCY_FIELD),
+				handleChangeFor,
+				readonly: formUtils.isReadOnly("currency"),
+				valid: formUtils.getFieldValid(valid ?? {}, CURRENCY_FIELD)
+			}),
+			showField(REPORTED_VALUE_OPTION_FIELD) && /* @__PURE__ */ jsx(ReportedValueOptionField, {
+				data: formUtils.getFieldData(data ?? {}, REPORTED_VALUE_OPTION_FIELD),
+				valid: formUtils.getFieldValid(valid ?? {}, REPORTED_VALUE_OPTION_FIELD),
+				errors: formUtils.getFieldErrors(errors ?? {}, fieldProblems, REPORTED_VALUE_OPTION_FIELD),
+				handleChangeFor,
+				currency: data?.currency ?? defaultCurrency
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/Business/forms/ProofOfAddressDocument/ProofOfAddressDocument.tsx
+var GuidanceContent$5 = ({ t }) => {
+	return /* @__PURE__ */ jsx("div", {
+		className: "adyen-kyc-upload-field__guidance",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "u-margin-bottom-24",
+			children: [/* @__PURE__ */ jsx("strong", { children: t(($) => $["documentRequirements"], { ns: "common" }) }), /* @__PURE__ */ jsxs("ul", { children: [
+				/* @__PURE__ */ jsx("li", { children: t(($) => $["yourBusinesssLegalName"], { ns: "business" }) }),
+				/* @__PURE__ */ jsx("li", { children: t(($) => $["theCompleteAddress"], { ns: "business" }) }),
+				/* @__PURE__ */ jsx("li", { children: t(($) => $["anIssueDateWithinTheLast12Months"], { ns: "business" }) }),
+				/* @__PURE__ */ jsx("li", { children: t(($) => $["clearReadableText"], { ns: "business" }) })
+			] })]
+		})
+	});
+};
+function ProofOfAddressDocument({ id, country, ...props }) {
+	const { t } = useTranslation(["common", "business"]);
+	return /* @__PURE__ */ jsx(MemoizedDocumentUpload, {
+		...props,
+		id,
+		heading: t(($) => $["uploadProofOfAddress"], { ns: "business" }),
+		description: t(($) => $["toFinishVerifyingYourBusinessWeNeedAnOfficialDocumentThatConfirmsItsAddress"], { ns: "business" }),
+		documentField: "proofOfAddress",
+		documentType: "proofOfAddress",
+		guidanceContent: /* @__PURE__ */ jsx(GuidanceContent$5, { t }),
+		country,
+		hidePageCount: true
+	});
+}
+//#endregion
+//#region src/components/Business/forms/ProofOfDirectorDocument/ProofOfDirectorDocument.tsx
+var documentTypes$2 = [{
+	id: "Internal company document",
+	name: "internalCompanyDocument"
+}, {
+	id: "Business registry statement",
+	name: "businessRegistryStatement"
+}];
+var GuidanceContent$4 = ({ t }) => {
+	return /* @__PURE__ */ jsx("div", {
+		className: "adyen-kyc-upload-field__guidance",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "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$1(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
+		}
+	});
+}
+//#endregion
+//#region src/components/Business/forms/ProofOfOwnershipDocument/ProofOfOwnershipDocument.tsx
+var DOC_TYPE_FOR_MULTI_UPLOAD = "Organizational chart and supporting document";
+var documentTypes$1 = [{
+	id: "Certified Organizational chart",
+	name: "certifiedOrganizationalChart"
+}, {
+	id: "Organizational chart and supporting document",
+	name: "organizationalChartAndSupportingDocument"
+}];
+var GuidanceContent$3 = ({ selectedDocumentName, t }) => {
+	const [showGuidanceModal, setShowGuidanceModal] = useState$1(false);
+	return /* @__PURE__ */ jsx("div", {
+		className: "adyen-kyc-upload-field__guidance",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "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: "u-margin-bottom-32 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$1(documentTypes$1[0].id);
+	const supportsMultiple = selectedDocumentName === DOC_TYPE_FOR_MULTI_UPLOAD;
+	useEffect$1(() => {
+		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
+	});
+}
+//#endregion
+//#region src/components/Business/forms/ProofOfSignatoryDocument/ProofOfSignatoryDocument.tsx
+var documentTypes = [{
+	id: "Trade registry document",
+	name: "tradeRegistryDocument"
+}, {
+	id: "Internal company document",
+	name: "internalCompanyDocument"
+}];
+var GuidanceContent$2 = ({ t }) => {
+	return /* @__PURE__ */ jsx("div", {
+		className: "adyen-kyc-upload-field__guidance",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "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$1(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
+		}
+	});
+}
+//#endregion
+//#region src/components/Business/forms/RegistrationDocument/config.ts
+var ACCEPTED_DOCUMENTS_MAP$1 = {
+	[CountryCodes.PuertoRico]: {
+		privateCompany: {
+			header: "acceptedDocumentsForPrivateCompanies",
+			documents: [
+				"certificateOfIncorporation",
+				"certificateOfFormation",
+				"secretaryOfStateFiling__PR"
+			]
+		},
+		listedPublicCompany: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["certificateOfIncorporation", "certificateOfFormation"]
+		},
+		unlistedPublicCompany: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["certificateOfIncorporation", "certificateOfFormation"]
+		},
+		governmentalOrganization: {
+			header: "acceptedDocumentsForGovernment",
+			documents: ["charter"]
+		},
+		nonProfit: {
+			header: "acceptedDocumentsForNonProfit",
+			documents: [
+				"articlesOfIncorporation",
+				"meetingRecords",
+				"secretaryOfStateRegDoc__PR",
+				"certificateOfIncumbency"
+			]
+		},
+		partnershipIncorporated: {
+			header: "acceptedDocumentsForPartnerships",
+			documents: ["partnerShipAgreement", "secretaryOfStateFiling__PR"]
+		}
+	},
+	[CountryCodes.UnitedStates]: {
+		privateCompany: {
+			header: "acceptedDocumentsForPrivateCompanies",
+			documents: [
+				"certificateOfIncorporation",
+				"certificateOfFormation",
+				"secretaryOfStateFiling"
+			]
+		},
+		listedPublicCompany: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["certificateOfIncorporation", "certificateOfFormation"]
+		},
+		unlistedPublicCompany: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["certificateOfIncorporation", "certificateOfFormation"]
+		},
+		governmentalOrganization: {
+			header: "acceptedDocumentsForGovernment",
+			documents: ["charter"]
+		},
+		nonProfit: {
+			header: "acceptedDocumentsForNonProfit",
+			documents: [
+				"articlesOfIncorporation",
+				"meetingRecords",
+				"secretaryOfStateRegDoc",
+				"certificateOfIncumbency"
+			]
+		},
+		partnershipIncorporated: {
+			header: "acceptedDocumentsForPartnerships",
+			documents: ["partnerShipAgreement", "secretaryOfStateFiling"]
+		}
+	}
+};
+//#endregion
+//#region src/components/Business/forms/RegistrationDocument/RegistrationDocument.tsx
+var 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" || country === "MX" ? /* @__PURE__ */ jsxs(Fragment$1, { children: [acceptedDocGuidance && /* @__PURE__ */ jsxs("div", {
+			className: "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: "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: "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 = "privateCompany", ...props }) {
+	const { t } = useTranslation(["common", "business"]);
+	const config = getLabelConfig(country);
+	return /* @__PURE__ */ jsx(MemoizedDocumentUpload, {
+		...props,
+		id,
+		heading: t(($) => $[config.heading], { ns: "business" }),
+		description: t(($) => $["companyRegistrationDocumentFormDescription"], { ns: "business" }),
+		documentField: "registrationDocument",
+		documentType: "registrationDocument",
+		guidanceContent: /* @__PURE__ */ jsx(GuidanceContent$1, {
+			country,
+			companyType,
+			t
+		}),
+		companyType,
+		country,
+		hidePageCount: true
+	});
+}
+function getLabelConfig(country) {
+	switch (country) {
+		case "MX": return { heading: "uploadAConstanciaDeSituacionFiscalDocument" };
+		default: return { heading: "companyRegistrationDocumentFormHeading" };
+	}
+}
+//#endregion
+//#region src/components/Business/forms/TaxDocument/config.ts
+var ACCEPTED_DOCUMENTS_MAP = {
+	[CountryCodes.PuertoRico]: {
+		privateCompany: {
+			header: "acceptedDocumentsForPrivateCompanies",
+			documents: ["irsCP575"]
+		},
+		listedPublicCompany: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["annualReport", "secForm10k"]
+		},
+		unlistedPublicCompany: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["annualReport", "secForm10k"]
+		},
+		nonProfit: {
+			header: "acceptedDocumentsForNonProfit",
+			documents: ["annualReport"]
+		},
+		partnershipIncorporated: {
+			header: "acceptedDocumentsForPartnerships",
+			documents: ["irsScheduleK1"]
+		}
+	},
+	[CountryCodes.UnitedStates]: {
+		privateCompany: {
+			header: "acceptedDocumentsForPrivateCompanies",
+			documents: ["irsCP575"]
+		},
+		listedPublicCompany: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["annualReport", "secForm10k"]
+		},
+		unlistedPublicCompany: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["annualReport", "secForm10k"]
+		},
+		nonProfit: {
+			header: "acceptedDocumentsForNonProfit",
+			documents: ["annualReport"]
+		},
+		partnershipIncorporated: {
+			header: "acceptedDocumentsForPartnerships",
+			documents: ["irsScheduleK1"]
+		}
+	}
+};
+//#endregion
+//#region src/components/Business/forms/TaxDocument/TaxDocument.tsx
+var 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$1, { children: [acceptedDocGuidance && /* @__PURE__ */ jsxs("div", {
+			className: "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: "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: "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 = "privateCompany", ...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
+	});
+}
+//#endregion
+//#region src/components/Business/forms/BusinessDetails/BusinessDetails.tsx
+var VatDocument = ({ children }) => {
+	return children;
+};
+var EMPTY_OBJ$1 = {};
+function BusinessDetails({ taskType, country, activeForm, shouldValidate, problems = EMPTY_OBJ$1, isTopLevelEntity }) {
+	const { t } = useTranslation(["common", "business"]);
+	const { form } = useFormContext();
+	const companyType = taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY ? "soleProprietorship" : form.data.companyStructure?.entityType;
+	function handleChange(formName, fieldName, mode) {
+		return form.handleChangeFor(formName, fieldName, mode);
+	}
+	const renderActiveForm = (activeForm) => {
+		switch (activeForm.formId) {
+			case "basicInformation": return /* @__PURE__ */ jsx(BasicInformation, {
+				id: activeForm.formId,
+				country,
+				shouldValidate,
+				fieldValidationErrors: problems.validationErrors?.[activeForm.formId],
+				formVerificationErrors: problems.verificationErrors?.[activeForm.formId],
+				companyType,
+				isTopLevelEntity,
+				disableCountry: taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY,
+				taskType
+			});
+			case "businessSelection": return /* @__PURE__ */ jsx(BusinessSelection, {
+				id: activeForm.formId,
+				country,
+				shouldValidate,
+				fieldValidationErrors: problems.validationErrors?.[activeForm.formId],
+				formVerificationErrors: problems.verificationErrors?.[activeForm.formId]
+			});
+			case "companyStructure": return /* @__PURE__ */ jsx(CompanyStructure, {
+				id: activeForm.formId,
+				country,
+				shouldValidate,
+				fieldValidationErrors: problems.validationErrors?.[activeForm.formId],
+				formVerificationErrors: problems.verificationErrors?.[activeForm.formId]
+			});
+			case "additionalInformation": return /* @__PURE__ */ jsx(AdditionalInformation, {
+				id: activeForm.formId,
+				country,
+				companyType,
+				shouldValidate,
+				fieldValidationErrors: problems.validationErrors?.[activeForm.formId],
+				formVerificationErrors: problems.verificationErrors?.[activeForm.formId]
+			});
+			case "companyTaxDocument": return country === "US" ? /* @__PURE__ */ jsx(TaxDocument, {
+				id: activeForm.formId,
+				country,
+				companyType,
+				shouldValidate,
+				fieldValidationErrors: problems.validationErrors?.[activeForm.formId] ?? {},
+				formVerificationErrors: problems.verificationErrors?.[activeForm.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)
+			}) : /* @__PURE__ */ jsx(VatDocument, { children: /* @__PURE__ */ jsx(MemoizedDocumentUpload, {
+				id: activeForm.formId,
+				country,
+				companyType,
+				shouldValidate,
+				heading: t(($) => $["companyTaxDocumentFormHeading"], { ns: "business" }),
+				description: t(($) => $["companyTaxDocumentFormDescription"], { ns: "business" }),
+				fieldValidationErrors: problems.validationErrors?.[activeForm.formId] ?? {},
+				formVerificationErrors: problems.verificationErrors?.[activeForm.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: "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: activeForm.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?.[activeForm.formId] ?? {},
+				formVerificationErrors: problems.verificationErrors?.[activeForm.formId] ?? {}
+			});
+			case "companyProofOfDirectorDocument": return /* @__PURE__ */ jsx(ProofOfDirectorDocument, {
+				id: activeForm.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?.[activeForm.formId] ?? {},
+				formVerificationErrors: problems.verificationErrors?.[activeForm.formId] ?? {}
+			});
+			case "companyProofOfSignatoryDocument": return /* @__PURE__ */ jsx(ProofOfSignatoryDocument, {
+				id: activeForm.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?.[activeForm.formId] ?? {},
+				formVerificationErrors: problems.verificationErrors?.[activeForm.formId] ?? {}
+			});
+			case "companyProofOfAddressDocument": return /* @__PURE__ */ jsx(ProofOfAddressDocument, {
+				id: activeForm.formId,
+				country,
+				data: form.data.companyProofOfAddressDocument,
+				errors: form.errors.companyProofOfAddressDocument,
+				valid: form.valid.companyProofOfAddressDocument,
+				allFields: form.allFields?.companyProofOfAddressDocument,
+				requiredFields: form.requiredFields?.companyProofOfAddressDocument,
+				optionalFields: form.optionalFields?.companyProofOfAddressDocument,
+				trustedFields: form.trustedFields?.companyProofOfAddressDocument,
+				handleFieldChange: (fieldName) => handleChange("companyProofOfAddressDocument", fieldName),
+				shouldValidate,
+				fieldValidationErrors: problems.validationErrors?.[activeForm.formId] ?? {},
+				formVerificationErrors: problems.verificationErrors?.[activeForm.formId] ?? {}
+			});
+			case "companyProofOfOwnershipDocument": return /* @__PURE__ */ jsx(ProofOfOwnershipDocument, {
+				id: activeForm.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?.[activeForm.formId] ?? {},
+				formVerificationErrors: problems.verificationErrors?.[activeForm.formId] ?? {}
+			});
+			case "companyConstitutionalDocument": return /* @__PURE__ */ jsx(MemoizedConstitutionalDocument, {
+				id: activeForm.formId,
+				legalEntityType: "soleProprietorship",
+				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?.[activeForm.formId] ?? {},
+				formVerificationErrors: problems.verificationErrors?.[activeForm.formId] ?? {}
+			});
+			case "companyFinancialInformation": return /* @__PURE__ */ jsx(FinancialInformation, {
+				id: activeForm.formId,
+				country,
+				shouldValidate,
+				fieldValidationErrors: problems.validationErrors?.[activeForm.formId] ?? {},
+				formVerificationErrors: problems.verificationErrors?.[activeForm.formId] ?? {}
+			});
+			default: return null;
+		}
+	};
+	return /* @__PURE__ */ jsx("div", { children: renderActiveForm(activeForm) });
+}
+//#endregion
+//#region src/components/Business/forms/CompanyStructure/validate.ts
+var CompanyStructureValidation = { entityType: {
+	modes: ["blur"],
+	validate: (entityType) => !isEmpty(entityType),
+	errorMessage: "fieldIsRequired"
+} };
+//#endregion
+//#region src/components/Shared/fields/Currency/fieldConfig.ts
+var currencyMetadata = { validators: {
+	modes: ["blur"],
+	validate: (currency) => !isEmpty(currency),
+	errorMessage: "fieldIsRequired"
+} };
+//#endregion
+//#region src/components/Shared/fields/FinancialReportingDate/fieldConfig.ts
+var financialReportingDateMetadata = { validators: [{
+	modes: ["blur"],
+	validate: (date) => !isEmpty(date),
+	errorMessage: "fieldIsRequired"
+}, {
+	modes: ["blur"],
+	validate: (date) => date ? new Date(date) < /* @__PURE__ */ new Date() : false,
+	errorMessage: "invalidFinancialReportingDate"
+}] };
+//#endregion
+//#region src/components/Shared/fields/NumberOfEmployees/fieldConfig.ts
+var numberOfEmployeesMetadata = { validators: [{
+	modes: ["blur"],
+	validate: (numberOfEmployees) => !isEmpty(numberOfEmployees),
+	errorMessage: "fieldIsRequired"
+}, {
+	modes: ["blur"],
+	validate: (numberOfEmployees) => Number.isInteger(Number(numberOfEmployees)) && Number(numberOfEmployees) > 0,
+	errorMessage: "pleaseEnterAValidWholeNumber"
+}] };
+//#endregion
+//#region src/components/Business/forms/FinancialInformation/validate.ts
+var financialInfoValidationRules = {
+	financialReportingDate: financialReportingDateMetadata.validators,
+	currency: currencyMetadata.validators,
+	reportedValueOption: { validators: {
+		modes: ["blur"],
+		validate: (option) => !isEmpty(option),
+		errorMessage: "fieldIsRequired"
+	} }.validators,
+	balanceSheetTotal: { validators: {
+		modes: ["blur"],
+		validate: (amount) => !isUndefinedOrNull(amount),
+		errorMessage: "fieldIsRequired"
+	} }.validators,
+	annualTurnover: { validators: {
+		modes: ["blur"],
+		validate: (amount) => !isUndefinedOrNull(amount),
+		errorMessage: "fieldIsRequired"
+	} }.validators
+};
+var financialInfoValidationEmployeesOnlyRules = { numberOfEmployees: numberOfEmployeesMetadata.validators };
+var financialInfoValidationWithEmployeesRules = {
+	...financialInfoValidationRules,
+	...financialInfoValidationEmployeesOnlyRules
+};
+//#endregion
+//#region src/components/Business/utils/utils.ts
+var isFinancialInformationRequired = (isFinancialInformationFeatureEnabled, taskType, country, capabilities, rootLegalEntityType) => {
+	const isOrganization = rootLegalEntityType === "organization";
+	if (!isFinancialInformationFeatureEnabled || !COUNTRIES_REQUIRING_FINANCIAL_INFORMATION.includes(country)) return;
+	if (country === CountryCodes.UnitedKingdom && (taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY || taskType === TaskTypes.BUSINESS_DETAILS)) return "REQUIRED";
+	if (taskType === TaskTypes.BUSINESS_DETAILS && isOrganization) {
+		if (keysOf(capabilities ?? {}).some((capability) => capability === "issueBankAccount")) return "REQUIRED";
+	}
+};
+var getCountryOfGoverningLaw = (isCountryOfGoverningLawEnabled, basicData) => {
+	if (!isCountryOfGoverningLawEnabled || basicData?.country !== CountryCodes.UnitedKingdom) return;
+	return !basicData.countryOfGoverningLaw ? CountryCodes.UnitedKingdom : basicData.countryOfGoverningLaw;
+};
+//#endregion
+//#region src/components/Business/forms/rules.constants.ts
+var COUNTRIES_REQUIRING_E_INVOICING_CODE = [CountryCodes.Italy];
+var ORGANIZATION_COUNTRIES_REQUIRING_DATE_OF_INCORPORATION = [
+	CountryCodes.HongKong,
+	CountryCodes.Singapore,
+	CountryCodes.India,
+	CountryCodes.Japan,
+	CountryCodes.UnitedArabEmirates
+];
+var COUNTRIES_THAT_USES_UEN_OR_GST = [CountryCodes.Singapore];
+//#endregion
+//#region src/components/Business/forms/rules.ts
+var rules = ({ data, defaultData, verifiedBusiness, country, taskType, isFeatureEnabled = () => false, isSettingEnabled = () => false, getSetting = () => void 0, accountHolder, rootLegalEntity, tinMatched }) => {
+	const countryRequiresDateOfIncorporationForCompanies = () => {
+		switch (taskType) {
+			case "SOLE_PROPRIETOR_COMPANY": return LEGAL_ARRANGEMENT_COUNTRIES_REQUIRING_DATE_OF_INCORPORATION.includes(country) ? "REQUIRED" : void 0;
+			default: return ORGANIZATION_COUNTRIES_REQUIRING_DATE_OF_INCORPORATION.includes(country) ? "REQUIRED" : void 0;
+		}
+	};
+	const countryRequiresFinancialInformation = () => {
+		const isFinancialInformationFeatureEnabled = isFeatureEnabled("EnableFinancialInformationComponentV4");
+		const leType = rootLegalEntity?.type;
+		return isFinancialInformationRequired(isFinancialInformationFeatureEnabled, taskType, country, rootLegalEntity?.capabilities, leType);
+	};
+	const hasFinancialInformation = (financialInformation) => {
+		if (!financialInformation) return false;
+		return financialInformation.numberOfEmployees != null || Boolean(financialInformation.financialReportingDate) || Boolean(financialInformation.currency) || financialInformation.balanceSheetTotal != null || financialInformation.annualTurnover != null;
+	};
+	const addressFieldRule = (field, isOperational) => {
+		if (isOperational && data.additionalInformation?.operationalAddressIsSame) return void 0;
+		if (field === "country") return "REQUIRED";
+		if (isJapanLocalizationEnabled(isFeatureEnabled, country)) {
+			if (field === "street") return "OPTIONAL";
+			return JP_ADDRESS_REQUIRED_FIELDS.includes(field) ? "REQUIRED" : "OPTIONAL";
+		}
+		if (!getAddressSchemaForCountry(country).includes(field)) return void 0;
+		if (field === "street2") return "OPTIONAL";
+		if (field === "stateOrProvince") return COUNTRIES_WITH_STATES_DATASET.includes(country) ? "REQUIRED" : void 0;
+		return "REQUIRED";
+	};
+	return createFormRules({
+		requireDoingBusinessAsName: () => {
+			return data.additionalInformation?.hasDoingBusinessAs ? "REQUIRED" : void 0;
+		},
+		countryRequiresStateOrProvince: () => {
+			if (COUNTRIES_WITH_STATES_DATASET.includes(country)) return "REQUIRED";
+		},
+		ifPubliclyTradedCompany: () => {
+			if (data.companyStructure?.entityType === "listedPublicCompany") return "REQUIRED";
+		},
+		countryUsesVat: () => {
+			if (!COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT.includes(country)) return data.additionalInformation?.exemptedFromVat ? "OPTIONAL" : "REQUIRED";
+		},
+		vatNumberType: () => {
+			if (!COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT.includes(country)) return "OPTIONAL";
+		},
+		isVatExempt: () => {
+			if (!COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT.includes(country)) return data.additionalInformation?.exemptedFromVat ? "REQUIRED" : "OPTIONAL";
+		},
+		countryUsesTaxId: () => {
+			const requiredUnlessExempt = Boolean(data.basicInformation?.exemptedFromTax) ? "OPTIONAL" : "REQUIRED";
+			const usesTaxIdInsteadOfVat = COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT.includes(country);
+			if (rootLegalEntity?.type === "organization" && keysOf(rootLegalEntity.capabilities ?? {}).includes("issueBankAccount")) {
+				if (TAX_ID_REQUIRED_COUNTRIES_ORGANIZATION.includes(country)) return requiredUnlessExempt;
+				if (country === CountryCodes.Italy && data.basicInformation?.registrationNumberType === "CCIAA") return requiredUnlessExempt;
+			}
+			if (taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY && COUNTRIES_THAT_DO_NOT_USE_TAX_ID_FOR_SOLE_PROP.includes(country)) return;
+			return usesTaxIdInsteadOfVat ? requiredUnlessExempt : void 0;
+		},
+		companyRegistrationNumberExemptionAllowed: () => {
+			const isExemptFromRegistrationNumber = Boolean(data.basicInformation?.exemptedFromRegistrationNumber);
+			if (taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY) {
+				if (!isRegistrationExemptionAllowed({
+					country,
+					companyType: "soleProprietorship"
+				})) return;
+				return isExemptFromRegistrationNumber ? "REQUIRED" : "OPTIONAL";
+			}
+			if (!isRegistrationExemptionAllowed({ country })) return;
+			/**
+			* Country-specific guard checks before applying the shared exemption rule result.
+			*
+			* - HK first enforces the legacy registration-number presence guard for existing entities.
+			* - AU/NZ then enforce the absent-state V4 feature flag gate.
+			*/
+			switch (country) {
+				case CountryCodes.HongKong:
+					if (!defaultData?.basicInformation?.registrationNumber) return;
+					return isExemptFromRegistrationNumber ? "REQUIRED" : "OPTIONAL";
+				case CountryCodes.Australia:
+				case CountryCodes.NewZealand:
+					if (!isFeatureEnabled("EnableRegistrationAndTaxAbsentStatesV4")) return;
+					return isExemptFromRegistrationNumber ? "REQUIRED" : "OPTIONAL";
+				default: return isExemptFromRegistrationNumber ? "REQUIRED" : "OPTIONAL";
+			}
+		},
+		countryOfGoverningLawRequired: () => {
+			if (isFeatureEnabled("EnableCountryOfGoverningLawForUKCompanies") && COUNTRY_OF_GOVERNING_LAW_POSSIBLE.includes(data.basicInformation?.country)) return "REQUIRED";
+		},
+		countryRequiresRegistrationNumber: () => {
+			const isExemptFromRegistrationNumber = Boolean(data.basicInformation?.exemptedFromRegistrationNumber);
+			switch (taskType) {
+				case TaskTypes.SOLE_PROPRIETOR_COMPANY:
+					if (COUNTRIES_THAT_DONT_REQUIRE_SOLE_PROP_REGISTRATION.includes(country)) return;
+					if (COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER_SOLE_PROPS.includes(country)) return "OPTIONAL";
+					return isExemptFromRegistrationNumber ? "OPTIONAL" : "REQUIRED";
+				default:
+					if (COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER.includes(country)) return "OPTIONAL";
+					if (country === CountryCodes.HongKong) {
+						if (!defaultData?.basicInformation?.registrationNumber) return;
+						return isExemptFromRegistrationNumber ? "OPTIONAL" : "REQUIRED";
+					}
+					if (!COUNTRIES_THAT_DONT_REQUIRE_COMPANY_REGISTRATION.includes(country)) return isExemptFromRegistrationNumber ? void 0 : "REQUIRED";
+			}
+		},
+		registrationNumberType: () => {
+			switch (taskType) {
+				case TaskTypes.SOLE_PROPRIETOR_COMPANY:
+					if (COUNTRIES_THAT_DONT_REQUIRE_SOLE_PROP_REGISTRATION.includes(country)) return;
+					return "OPTIONAL";
+				default:
+					if (COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER.includes(country)) return "OPTIONAL";
+					if (COUNTRIES_THAT_DONT_REQUIRE_COMPANY_REGISTRATION.includes(country)) return;
+					return "OPTIONAL";
+			}
+		},
+		countryUsesUenOrGst: () => {
+			if (taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY) return;
+			if (COUNTRIES_THAT_USES_UEN_OR_GST.includes(country)) return "REQUIRED";
+		},
+		countryHasTaxExemptions: () => {
+			const isExemptFromTax = Boolean(data.basicInformation?.exemptedFromTax);
+			switch (taskType) {
+				case TaskTypes.SOLE_PROPRIETOR_COMPANY:
+					if (!COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_SOLE_PROPS.includes(country)) return;
+					return isExemptFromTax ? "REQUIRED" : "OPTIONAL";
+				default:
+					if (isFeatureEnabled("EnableRegistrationAndTaxAbsentStatesV4") && COUNTRIES_WITH_POSSIBLE_TRUSTEE_TAXID_ABSENT_V4.includes(country) && accountHolder === "aTrust") return isExemptFromTax ? "REQUIRED" : "OPTIONAL";
+					if (COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_COMPANIES.includes(country)) return isExemptFromTax ? "REQUIRED" : "OPTIONAL";
+			}
+		},
+		usingCompanySearch: () => {
+			if (isUsingCompanySearch(country, taskType)) return "REQUIRED";
+		},
+		requireStateOrProvinceForCompanySearch: () => {
+			if (isUsingCompanySearch(country, taskType) && COUNTRIES_WITH_STATES_DATASET.includes(country)) return "REQUIRED";
+		},
+		countryRequiresFinancialInformation,
+		isDateOfIncorporationRequired: () => {
+			return countryRequiresDateOfIncorporationForCompanies() || countryRequiresFinancialInformation();
+		},
+		isFinancialReportingFieldsRequired: () => {
+			if (countryRequiresFinancialInformation() !== "REQUIRED") return;
+			if (isDateOlderThanAYear(data.additionalInformation?.dateOfIncorporation)) return "REQUIRED";
+			/**
+			* MultiForm recalculates required/optional schemas when rules change and reindexes form state
+			* against those schemas. If these financial fields are not included, provider-applied values can
+			* be pruned and appear to reset. Keeping them OPTIONAL by default when the feature is enabled
+			* (instead of undefined) preserves existing values in the form while still avoiding hard validation
+			* requirements when provider data is partial.
+			*/
+			if (hasFinancialInformation(verifiedBusiness?.financialInformation) || hasFinancialInformation(data.companyFinancialInformation)) return "OPTIONAL";
+		},
+		isIndustryCodeRequired: () => {
+			return isSettingEnabled(SettingNames.AllowBusinessLines) ? "REQUIRED" : void 0;
+		},
+		annualTurnoverRequired: () => {
+			if (data.companyFinancialInformation?.reportedValueOption === "annualTurnover") return "REQUIRED";
+		},
+		balanceSheetTotalRequired: () => {
+			if (data.companyFinancialInformation?.reportedValueOption === "balanceSheetTotal") return "REQUIRED";
+		},
+		isResidentialAddressIndicatorEnabled: () => {
+			if (isFeatureEnabled("EnableResidentialAddressIndicator")) return "OPTIONAL";
+		},
+		isEInvoicingCodeEnabled: () => {
+			if (isFeatureEnabled("EnableEInvoicingCodeField") && COUNTRIES_REQUIRING_E_INVOICING_CODE.includes(country)) return "REQUIRED";
+		},
+		isTaxDocumentRequired: () => {
+			if (tinMatched === false && country === CountryCodes.UnitedStates) return "REQUIRED";
+		},
+		isRegistrationDocumentRequired: () => {
+			if (getSetting("merchantType") === "direct" && country === CountryCodes.Mexico) return "REQUIRED";
+		},
+		businessRequiresCompanyType: () => {
+			if (taskType !== TaskTypes.SOLE_PROPRIETOR_COMPANY) return "REQUIRED";
+		},
+		japaneseLegalCompanyName: () => {
+			if (isJapanLocalizationEnabled(isFeatureEnabled, country)) return "REQUIRED";
+		},
+		requireLEI: () => {
+			if (!isFeatureEnabled("EnableLegalEntityIdentifierField") || taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY) return;
+			return data.additionalInformation?.exemptedFromLegalEntityIdentifier ? "OPTIONAL" : "REQUIRED";
+		},
+		requireLEIExemption: () => {
+			if (!isFeatureEnabled("EnableLegalEntityIdentifierField") || taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY) return;
+			return data.additionalInformation?.exemptedFromLegalEntityIdentifier ? "REQUIRED" : "OPTIONAL";
+		},
+		registrationAddressStreetRequired: () => addressFieldRule("street", false),
+		registrationAddressStreet2Required: () => addressFieldRule("street2", false),
+		registrationAddressCityRequired: () => addressFieldRule("city", false),
+		registrationAddressPostalCodeRequired: () => addressFieldRule("postalCode", false),
+		registrationAddressStateOrProvinceRequired: () => addressFieldRule("stateOrProvince", false),
+		registrationAddressCountryRequired: () => addressFieldRule("country", false),
+		operationalAddressStreetRequired: () => addressFieldRule("street", true),
+		operationalAddressStreet2Required: () => addressFieldRule("street2", true),
+		operationalAddressCityRequired: () => addressFieldRule("city", true),
+		operationalAddressPostalCodeRequired: () => addressFieldRule("postalCode", true),
+		operationalAddressStateOrProvinceRequired: () => addressFieldRule("stateOrProvince", true),
+		operationalAddressCountryRequired: () => addressFieldRule("country", true),
+		/** Localized */
+		/** JP */
+		registrationAddressJaHaniStateOrProvinceRequired: () => addressFieldRule("jaHaniStateOrProvince", false),
+		registrationAddressJaHaniCityRequired: () => addressFieldRule("jaHaniCity", false),
+		registrationAddressJaHaniStreetRequired: () => addressFieldRule("jaHaniStreet", false),
+		registrationAddressJaKanaStateOrProvinceRequired: () => addressFieldRule("jaKanaStateOrProvince", false),
+		registrationAddressJaKanaCityRequired: () => addressFieldRule("jaKanaCity", false),
+		registrationAddressStreet2FullWidthRequired: () => addressFieldRule("street2FullWidth", false),
+		operationalAddressJaHaniStateOrProvinceRequired: () => addressFieldRule("jaHaniStateOrProvince", true),
+		operationalAddressJaHaniCityRequired: () => addressFieldRule("jaHaniCity", true),
+		operationalAddressJaHaniStreetRequired: () => addressFieldRule("jaHaniStreet", true),
+		operationalAddressJaKanaStateOrProvinceRequired: () => addressFieldRule("jaKanaStateOrProvince", true),
+		operationalAddressJaKanaCityRequired: () => addressFieldRule("jaKanaCity", true),
+		operationalAddressStreet2FullWidthRequired: () => addressFieldRule("street2FullWidth", true)
+	});
+};
+//#endregion
+//#region src/utils/stripWhitespace.ts
+var stripWhitespace = (str) => str.replace(/\s/g, "");
+//#endregion
+//#region src/utils/toNormalizedString.ts
+var toNormalizedString = (s) => stripWhitespace(s.toLowerCase());
+//#endregion
+//#region src/utils/isNormalizedStringMatch.ts
+var isNormalizedStringMatch = (s1, s2) => toNormalizedString(s1) === toNormalizedString(s2);
+//#endregion
+//#region src/components/Business/hooks/useCompanySearchNextClickOverrides.ts
+function useCompanySearchNextClickOverrides({ country, multiForm, companySearchStateModel, getRequiredForms, skipBusinessSelection, setLoadingStatus, isTinMatched, tinMismatchModalOpen, legalArrangementModalOpen, registrationNumberMismatchModalOpen }) {
+	const { baseUrl, rootLegalEntityId } = useApiContext();
+	const userEvents = useAnalyticsContext();
+	const queryClient = useQueryClient();
+	const { mutateAsync: selectCompany } = useCompanySelection();
+	const { mutateAsync: clearCompanyData } = useClearCompanyData();
+	const logger = createLogger();
+	const getInferredRegistrationNumberType = () => {
+		const selectedCompany = companySearchStateModel.selectedCompany.peek();
+		if (country === CountryCodes.UnitedStates || !selectedCompany?.registrationNumber) return;
+		return inferCompanyRegistrationNumberType(selectedCompany.registrationNumber, country, selectedCompany.companyType);
+	};
+	const isVerificationFailed = () => country === CountryCodes.UnitedStates ? !companySearchStateModel.verificationMatched.value : companySearchStateModel.verificationMatched.value === false;
+	/**
+	* Returns `null` for non-navs, such as showing the TIN mismatch model for 0 or 1 results
+	*/
+	const attemptBusinessSearch = async () => {
+		const formsWithoutSearchResults = getRequiredForms({ skipBusinessSelection: true });
+		if (!multiForm.data.basicInformation?.legalCompanyName) return formsWithoutSearchResults;
+		setLoadingStatus("loading");
+		companySearchStateModel.resetCompanySearchData();
+		let searchResponse = {
+			results: [],
+			provider: "NO_PROVIDER"
+		};
+		try {
+			companySearchStateModel.companySearchName.value = multiForm.data.basicInformation?.legalCompanyName;
+			const companySearchInput = {
+				name: multiForm.data.basicInformation?.legalCompanyName,
+				country: multiForm.data.basicInformation?.country,
+				state: multiForm.data.basicInformation?.stateOrProvince,
+				registrationNumber: multiForm.data.basicInformation?.registrationNumber
+			};
+			searchResponse = await trackPerformance("companySearch", () => queryClient.fetchQuery(companySearchQueryOptions(rootLegalEntityId.peek(), baseUrl.peek(), companySearchInput, userEvents)), userEvents);
+		} catch (e) {
+			logger.error(e);
+			setLoadingStatus("error");
+			return formsWithoutSearchResults;
+		}
+		const tin = multiForm.data.basicInformation?.taxInformation?.find((taxId) => taxId.country === country)?.number ?? "";
+		const registrationNumber = multiForm.data.basicInformation?.registrationNumber ?? "";
+		skipBusinessSelection.value = searchResponse.results.length === 0;
+		const currentForms = getRequiredForms({ skipBusinessSelection: skipBusinessSelection.peek() });
+		switch (searchResponse.results.length) {
+			case 0:
+				if (country === CountryCodes.UnitedStates) try {
+					const verifyTinQueryInput = {
+						name: multiForm.data.basicInformation?.legalCompanyName,
+						tin
+					};
+					const tinVerificationResponse = await queryClient.fetchQuery(verifyTinQueryOptions(rootLegalEntityId.peek(), baseUrl.peek(), verifyTinQueryInput, userEvents));
+					setLoadingStatus("success");
+					const tinMatched = !!tinVerificationResponse.matched;
+					companySearchStateModel.setVerificationMatched(tinMatched);
+					if (companySearchStateModel.verificationMatched.value) return currentForms;
+					tinMismatchModalOpen.value = true;
+					return null;
+				} catch (e) {
+					logger.error(e);
+					setLoadingStatus("error");
+					return currentForms;
+				}
+				setLoadingStatus("success");
+				return currentForms;
+			case 1:
+				if (!isNormalizedStringMatch(multiForm.data.basicInformation?.legalCompanyName, searchResponse.results[0].name)) {
+					setLoadingStatus("success");
+					return currentForms;
+				}
+				try {
+					const companySelectionInput = {
+						state: multiForm.data.basicInformation?.stateOrProvince,
+						name: multiForm.data.basicInformation?.legalCompanyName,
+						tin,
+						registrationNumber,
+						id: searchResponse.results[0].resultId,
+						country
+					};
+					const companySelectionResponse = await selectCompany(companySelectionInput);
+					companySearchStateModel.selectCompany(companySelectionResponse, -1, country);
+					setLoadingStatus("success");
+					if (isVerificationFailed()) {
+						await clearCompanyData();
+						return currentForms;
+					} else {
+						companySearchStateModel.confirmCompany(multiForm, country);
+						skipBusinessSelection.value = true;
+						return getRequiredForms({
+							skipBusinessSelection: skipBusinessSelection.peek(),
+							skipCompanyStructure: !!companySearchStateModel.verifiedBusiness.value?.legalForm || !!getInferredRegistrationNumberType()
+						});
+					}
+				} catch (e) {
+					logger.error(e);
+					setLoadingStatus("error");
+					await clearCompanyData();
+					return formsWithoutSearchResults;
+				}
+			default:
+				setLoadingStatus("success");
+				return currentForms;
+		}
+	};
+	const confirmBusinessSelection = async () => {
+		const selectedBusinessId = multiForm.data.businessSelection.selectedBusinessId;
+		if (companySearchStateModel.disallowedSelectionReason.value) {
+			switch (companySearchStateModel.disallowedSelectionReason.value) {
+				case "LEGAL_ARRANGEMENT":
+					legalArrangementModalOpen.value = true;
+					break;
+				default:
+					logger.error("Unhandled disallowed selection reason");
+					break;
+			}
+			return null;
+		}
+		switch (selectedBusinessId) {
+			case "notListed":
+				if (country === CountryCodes.UnitedStates && isVerificationFailed()) isTinMatched.value = false;
+				return getRequiredForms({});
+			default:
+				switch (country) {
+					case CountryCodes.UnitedStates:
+						if (isVerificationFailed()) {
+							tinMismatchModalOpen.value = true;
+							return null;
+						}
+						break;
+					default:
+						if (isVerificationFailed()) {
+							registrationNumberMismatchModalOpen.value = true;
+							return null;
+						}
+						break;
+				}
+				companySearchStateModel.confirmCompany(multiForm, country);
+				return getRequiredForms({ skipCompanyStructure: !!companySearchStateModel.verifiedBusiness.value?.legalForm || !!getInferredRegistrationNumberType() });
+		}
+	};
+	return {
+		attemptBusinessSearch,
+		confirmBusinessSelection
+	};
+}
+//#endregion
+//#region src/components/Business/hooks/usePrefetchCompanySearch.ts
+var getRootElement = () => {
+	const onboardingWC = document.querySelector("adyen-onboarding");
+	return (onboardingWC && onboardingWC?.shadowRoot) ?? document;
+};
+var getRelatedFields = (country) => {
+	const baseFields = [
+		"legalCompanyName",
+		"country",
+		"registrationNumber"
+	];
+	switch (country) {
+		case "US": return baseFields.concat(["stateOrProvince"]);
+		default: return baseFields;
+	}
+};
+function usePrefetchCompanySearch({ country, multiForm, activeFormId, isUsingCompanySearch }) {
+	const queryClient = useQueryClient();
+	const { baseUrl, rootLegalEntityId } = useApiContext();
+	const userEvents = useAnalyticsContext();
+	const debouncedCompanySearchPrefetch = useDebouncedCallback(useCallback$1(async () => {
+		const root = getRootElement(), activeElementName = (root.activeElement && root.activeElement.getAttribute("name")) ?? "";
+		const fieldNames = getRelatedFields(country);
+		let allRelatedFieldsAreValid = true, noRelatedFieldsAreFocused = true;
+		for (const fieldName of fieldNames) {
+			if (multiForm.valid.basicInformation?.[fieldName] === false) allRelatedFieldsAreValid = false;
+			if (activeElementName && activeElementName === fieldName) noRelatedFieldsAreFocused = false;
+		}
+		if (!allRelatedFieldsAreValid || !noRelatedFieldsAreFocused) return;
+		const companySearchInput = {
+			name: multiForm.data.basicInformation?.legalCompanyName ?? "",
+			country: multiForm.data.basicInformation?.country,
+			state: multiForm.data.basicInformation?.stateOrProvince,
+			registrationNumber: multiForm.data.basicInformation?.registrationNumber
+		};
+		await queryClient.prefetchQuery(companySearchQueryOptions(rootLegalEntityId.peek(), baseUrl.peek(), companySearchInput, userEvents));
+	}, [
+		baseUrl,
+		country,
+		multiForm.data.basicInformation?.country,
+		multiForm.data.basicInformation?.legalCompanyName,
+		multiForm.data.basicInformation?.registrationNumber,
+		multiForm.data.basicInformation?.stateOrProvince,
+		multiForm.valid.basicInformation,
+		queryClient,
+		rootLegalEntityId,
+		userEvents
+	]), 500);
+	/**
+	* Re-fires prefetch when fields lose focus, with extra filtering within
+	* the handler to determine whether the search should continue after being debounced.
+	*/
+	useEffect$1(() => {
+		const prefetch = () => {
+			if (activeFormId !== "basicInformation" || !isUsingCompanySearch) return;
+			debouncedCompanySearchPrefetch();
+		};
+		const root = getRootElement();
+		root.addEventListener("focusout", prefetch);
+		return () => root.removeEventListener("focusout", prefetch);
+	}, [
+		activeFormId,
+		debouncedCompanySearchPrefetch,
+		isUsingCompanySearch
+	]);
+}
+//#endregion
+//#region src/core/utils.ts
+var adjustFormData = (oldFormData, newFormData) => {
+	return Array.from((/* @__PURE__ */ new Set([...keysOf(oldFormData), ...keysOf(newFormData)])).keys()).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]: ""
+		};
+	}, {});
+};
+/**
+* Set fields on the schema which have been removed to the appropriate "deleted" value.
+*
+* E.g. removed `string` fields are set to `""`, removed `number`s to `null`.
+*
+* Doesn't mutate the original object.
+*
+* @param newData - actual form data submitted from the frontend
+* @param existingData - `Schema`-fied version of the existing LE data we got from the BE
+* @returns filtered data
+*/
+var setRemovedFieldsOnSchemaToDeletedValue = (newData, existingData) => {
+	return Array.from((/* @__PURE__ */ new Set([...keysOf(existingData), ...keysOf(newData)])).keys()).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)
+		};
+	}, {});
+};
+//#endregion
+//#region src/components/Business/mapping/businessDetails/businessBankAccountTaxIdUtils.ts
+var BUSINESS_BANK_ACCOUNT_TAX_ID_COUNTRIES = [
+	CountryCodes.Estonia,
+	CountryCodes.Finland,
+	CountryCodes.France,
+	CountryCodes.Italy,
+	CountryCodes.Latvia,
+	CountryCodes.Lithuania,
+	CountryCodes.Portugal,
+	CountryCodes.Spain
+];
+/**
+* Italian registration number subtypes that are NOT valid Codice Fiscale and therefore
+* cannot be reused as `taxInformation`. Users who select these must provide a Tax ID
+* (Codice Fiscale) separately.
+*/
+var IT_REGISTRATION_TYPES_WITHOUT_TAX_ID_REUSE = ["CCIAA"];
+/**
+* Checks if a country requires business bank account tax ID validation
+* @param country - The country code to check
+* @returns true if the country requires business bank account tax ID, false otherwise
+*/
+var isBusinessBankAccountTaxIdCountry = (country) => {
+	return country ? BUSINESS_BANK_ACCOUNT_TAX_ID_COUNTRIES.includes(country) : false;
+};
+/**
+* Whether the entered `registrationNumber` should be reused as `taxInformation`
+* for a business bank account (see `isBusinessBankAccountTaxIdCountry`).
+*
+* For most countries this is equivalent to {@link isBusinessBankAccountTaxIdCountry}.
+* Italy has an additional constraint: the CCIAA number is not a valid Codice Fiscale,
+* so it must not be reused as `taxInformation`.
+*/
+var shouldReuseRegistrationNumberAsTaxId = (country, registrationNumberType) => {
+	if (!isBusinessBankAccountTaxIdCountry(country)) return false;
+	if (country === CountryCodes.Italy && registrationNumberType) return !IT_REGISTRATION_TYPES_WITHOUT_TAX_ID_REUSE.includes(registrationNumberType);
+	return true;
+};
+//#endregion
+//#region src/components/Business/mapping/businessDetails/mapBusinessDetailsSchemaToLegalEntity.ts
+var mapBusinessDetailsDocumentToApiDocument = async (data, entityId) => {
+	const { companyRegistrationDocument, companyTaxDocument, companyProofOfDirectorDocument, companyConstitutionalDocument, companyProofOfSignatoryDocument, companyProofOfAddressDocument, companyProofOfOwnershipDocument, basicInformation } = data;
+	const taxDocumentType = COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT.includes(basicInformation?.country) ? "proofOfOrganizationTaxInfo" : "vatDocument";
+	return (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]
+		}),
+		createDocumentRequest({
+			entityId,
+			entityType: "legalEntity",
+			documentType: "proofOfAddress",
+			description: companyProofOfAddressDocument?.description,
+			page1: companyProofOfAddressDocument?.proofOfAddress?.[0]
+		})
+	])).filter(Boolean);
+};
+var mapBusinessDetailsSchemaToLegalEntity = (data, accountHolder, isFeatureEnabled, taskType, matchingScenario, rootLegalEntity) => {
+	const isSoleProp = accountHolder === "mySoleProprietorName";
+	const requestObj = { ...formatObject(data, isSoleProp ? solePropBusinessDetailsApiKeyMapping : businessDetailsApiKeyMapping) };
+	delete requestObj.organization?.legalFormDescription;
+	const canSaveRegNumberAbsentState = isFeatureEnabled("EnableRegistrationAndTaxAbsentStatesV4") && isRegistrationNumberAbsentStateV4Scenario(data.basicInformation?.country, data.companyStructure?.entityType);
+	const [taxData, registrationNumber, registrationNumberType] = [
+		data.basicInformation?.taxInformation,
+		data.basicInformation?.registrationNumber,
+		data.basicInformation?.registrationNumberType
+	];
+	const localization = mapJapaneseLegalNamesToLocalization(data.basicInformation ?? {});
+	const doingBusinessAs = data.additionalInformation?.doingBusinessAs ?? "";
+	const entityObject = isSoleProp ? requestObj.soleProprietorship : requestObj.organization;
+	if (entityObject) {
+		if (taxData) entityObject.taxInformation = taxData;
+		if (rootLegalEntity?.type === "organization" && keysOf(rootLegalEntity.capabilities ?? {}).includes("issueBankAccount") && matchingScenario?.includes(Scenarios.L) && registrationNumber && data.basicInformation?.country && shouldReuseRegistrationNumberAsTaxId(data.basicInformation?.country, registrationNumberType)) {
+			const taxCountry = data.basicInformation.country;
+			const privateCompanyTaxOptions = getTaxIdNumberOptions(taxCountry, "privateCompany");
+			entityObject.taxInformation = [{
+				country: taxCountry,
+				number: registrationNumber,
+				type: privateCompanyTaxOptions && privateCompanyTaxOptions.length > 0 ? privateCompanyTaxOptions[0]["id"] : ""
+			}];
+		}
+		if (isSoleProp && !!data.basicInformation?.country) entityObject.countryOfGoverningLaw = data.basicInformation.country;
+		if (taskType !== TaskTypes.BUSINESS_DETAILS && entityObject.vatAbsenceReason === "") entityObject.vatAbsenceReason = null;
+		if (registrationNumber) {
+			entityObject.registrationNumber = registrationNumber;
+			if (canSaveRegNumberAbsentState && !isSoleProp) entityObject.registrationNumberAbsent = false;
+		}
+		if (!isSoleProp && localization.length > 0) entityObject.localization = localization;
+		if (data.basicInformation?.exemptedFromRegistrationNumber && canSaveRegNumberAbsentState && !isSoleProp) entityObject.registrationNumberAbsent = data.basicInformation.exemptedFromRegistrationNumber;
+		if (data.additionalInformation?.vatAbsenceReason) entityObject.vatNumber = "";
+		if (isFeatureEnabled("EnableDoingBusinessAsNameV4")) {
+			if (typeof data.additionalInformation?.hasDoingBusinessAs !== "undefined") entityObject.doingBusinessAsAbsent = !data.additionalInformation.hasDoingBusinessAs;
+		} else {
+			entityObject.doingBusinessAs = doingBusinessAs || data.basicInformation?.legalCompanyName;
+			delete entityObject.doingBusinessAsAbsent;
+		}
+		if (!isFeatureEnabled("EnableResidentialAddressIndicator")) delete entityObject.residentialAddressIndicator;
+		if (data.additionalInformation?.operationalAddressIsSame && entityObject.principalPlaceOfBusiness) entityObject.principalPlaceOfBusiness = structuredClone(entityObject.registeredAddress);
+		const addressLocalizations = mapJpAddressSchemaToAddressLocalizations(nestAddressSchema("registrationAddress", data.additionalInformation));
+		if (addressLocalizations.length > 0) entityObject.registeredAddress.localization = addressLocalizations;
+		if (entityObject.principalPlaceOfBusiness?.localization) delete entityObject.principalPlaceOfBusiness?.localization;
+		if (entityObject.registeredAddress?.country && entityObject.registeredAddress?.stateOrProvince && !COUNTRIES_WITH_STATES_DATASET.includes(entityObject.registeredAddress?.country)) entityObject.registeredAddress.stateOrProvince = "";
+		if (!isEmpty$1(data.companyFinancialInformation)) entityObject.financialReports = [mapFinancialInformationToFinancialReport(data.companyFinancialInformation, data.additionalInformation?.dateOfIncorporation)];
+	}
+	requestObj.type = isSoleProp ? "soleProprietorship" : "organization";
+	if (entityObject?.registeredAddress.country === "US") delete entityObject.registrationNumber;
+	if (!canSaveRegNumberAbsentState && !isSoleProp) delete requestObj.organization?.registrationNumberAbsent;
+	return requestObj;
+};
+//#endregion
+//#region src/components/Business/mapping/businessDetails/mapLegalEntityToBusinessDetailsSchema.ts
+var mapApiDocumentToBusinessDetailsDocuments = (entityId) => {
+	const registrationDocument = getDocument(entityId, "registrationDocument");
+	const taxDocument = getDocument(entityId, "vatDocument") ?? getDocument(entityId, "proofOfOrganizationTaxInfo");
+	const proofOfDirector = getDocument(entityId, "proofOfDirector");
+	const proofOfSignatory = getDocument(entityId, "proofOfSignatory");
+	const proofOfOwnership = getDocuments(entityId, "proofOfOwnership");
+	const constitutionalDocument = getDocument(entityId, "constitutionalDocument");
+	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
+	};
+};
+var mapBasicInformation = ({ data, legalEntity, taskType }) => {
+	if (!data || !data.country) return;
+	const companyType = legalEntity?.type === "organization" ? legalEntity.organization?.type : "soleProprietorship";
+	const isUen = mapIsUen(data.taxInformation, data.registrationNumber, data.country);
+	const registrationNumberType = getDefaultRegistrationNumberType(data.registrationNumber, data.country, void 0);
+	const registrationNumberExemption = !data.registrationNumber && !!companyType && isRegistrationExemptionAllowed({
+		country: data.country,
+		companyType
+	}) ? { exemptedFromRegistrationNumber: true } : {};
+	return isUsingCompanySearch(data.country, taskType) ? {
+		...data,
+		registrationNumberType,
+		...registrationNumberExemption,
+		...isUen
+	} : entriesOf(data).reduce((acc, [field]) => {
+		if (!["stateOrProvince"].includes(field)) return {
+			...acc,
+			[field]: data[field]
+		};
+		return acc;
+	}, {
+		registrationNumberType,
+		...registrationNumberExemption,
+		...isUen
+	});
+};
+var 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;
+};
+var 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"
+	};
+};
+var applyLocalizedAddressFields = (data, prefix, localization) => {
+	const flatAddress = flattenAddressSchema(prefix, localization);
+	for (const field in flatAddress) {
+		if (flatAddress[field] === void 0) continue;
+		data[field] = flatAddress[field];
+	}
+};
+var 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 vatNumberType = getDefaultVatNumberType(entity?.vatNumber, currentCountry);
+	const operationalAddressIsSame = !(entity?.principalPlaceOfBusiness && !objectsDeepEqual(entity.principalPlaceOfBusiness, entity.registeredAddress));
+	if (entity?.registeredAddress.localization) applyLocalizedAddressFields(data, "registrationAddress", mapAddressLocalizationToJpAddressSchema(entity.registeredAddress.localization));
+	if (entity?.principalPlaceOfBusiness?.localization) applyLocalizedAddressFields(data, "operationalAddress", mapAddressLocalizationToJpAddressSchema(entity.principalPlaceOfBusiness.localization));
+	return {
+		...entriesOf(data).reduce((acc, [field]) => ({
+			...acc,
+			[field]: data[field]
+		}), {
+			operationalAddressIsSame,
+			vatNumberType
+		}),
+		...dbaNameFields
+	};
+};
+var mapLegalEntityToBusinessDetailsSchema = ({ legalEntity, parentEntity, taskType, isFeatureEnabled }) => {
+	if (!legalEntity) return {};
+	const { companyRegistrationDocument, companyTaxDocument, companyProofOfDirectorDocument, companyProofOfSignatoryDocument, companyProofOfOwnershipDocument, companyConstitutionalDocument } = mapApiDocumentToBusinessDetailsDocuments(legalEntity.id);
+	const buildSolePropSchema = () => {
+		const solePropData = formatObject(legalEntity, solePropBusinessDetailsKeyMapping);
+		const country = solePropData.additionalInformation?.registrationAddressCountry ?? parentEntity?.individual?.residentialAddress.country;
+		if (legalEntity.soleProprietorship?.financialReports) solePropData.companyFinancialInformation = mapFinancialReportsToFinancialInformation(legalEntity.soleProprietorship.financialReports);
+		return {
+			...solePropData,
+			basicInformation: {
+				...solePropData.basicInformation,
+				country
+			},
+			companyConstitutionalDocument
+		};
+	};
+	const orgSchema = {
+		...formatObject(legalEntity, businessDetailsKeyMapping),
+		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({
+						data: businessDetailsSchema[key],
+						legalEntity,
+						taskType,
+						isFeatureEnabled
+					}),
+					...mapLocalizationToJapaneseLegalNames(legalEntity?.organization?.localization)
+				}
+			};
+			case "businessSelection": return {
+				...componentData,
+				[key]: { selectedBusinessId: "" }
+			};
+			case "companyStructure": return {
+				...componentData,
+				[key]: { ...businessDetailsSchema[key] }
+			};
+			case "additionalInformation": return {
+				...componentData,
+				[key]: mapAdditionalInformation({
+					data: 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;
+		}
+	}, {});
+};
+//#endregion
+//#region src/components/Business/hooks/useSubmitBusinessDetails.ts
+function useSubmitBusinessDetails({ country, data, forms, legalEntityResponse, associatedLegalArrangement, nestedLegalEntity, nestedLegalEntityDetails, efpBusinessLines, taskType, problems, setProblems, setLoadingStatus, onExternalSubmit }) {
+	const { t } = useTranslation(["common", "business"]);
+	const { baseUrl, rootLegalEntityId } = useApiContext();
+	const userEvents = useAnalyticsContext();
+	const { accountHolder: accountHolderMaybe } = useAccountHolder();
+	const { showToast } = useToastContext();
+	const { isFeatureEnabled } = useToggleContext();
+	const { data: matchingScenario } = useScenarios(country, "organization");
+	const { mutateAsync: createLegalEntity } = useCreateLegalEntity();
+	const { mutateAsync: updateLegalEntity } = useUpdateLegalEntity();
+	const { mutateAsync: createBusinessLine } = useCreateBusinessLine();
+	const { mutateAsync: updateBusinessLine } = useUpdateBusinessLine();
+	const invalidateRootLegalEntity = useInvalidateRootLegalEntity();
+	const documentUtils = documentApiUtils({
+		baseUrl: baseUrl.value,
+		rootLegalEntityId: rootLegalEntityId.value
+	});
+	return useCallback$1(async () => {
+		const accountHolder = accountHolderMaybe ?? "theCompanyIWorkFor";
+		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,
+			usedAdditionalAddress: !data.additionalInformation?.operationalAddressIsSame
+		};
+		/**
+		* Root entity is legalEntityResponse,
+		* Sole prop is associatedLegalArrangment and is undefined on initial creation
+		* Trust Member Company is nestedLegalEntity and is undefined on initial creation
+		*/
+		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 {
+				const { type: _type, ...rest } = legalEntity;
+				return updateLegalEntity({
+					...rest,
+					id: entityToUpdate?.id ?? legalEntityResponse.id
+				});
+			}
+		};
+		const associateLegalEntityWithParent = async ({ legalEntity, associatedLegalArrangement, nestedLegalEntityDetails }) => {
+			if (nestedLegalEntityDetails && associatedLegalArrangement) {
+				const existingEntityAssociations = getOwnEntityAssociations(associatedLegalArrangement);
+				const existingRoles = existingEntityAssociations.filter((ea) => ea.legalEntityId === associatedLegalArrangement.id).map(({ type }) => type);
+				const newRoles = nestedLegalEntityDetails.roles;
+				if (!doArraysMatch(existingRoles, newRoles)) await updateLegalEntity({
+					id: associatedLegalArrangement.id,
+					entityAssociations: [...newRoles.map((role) => ({
+						type: role,
+						legalEntityId: legalEntity.id
+					})), ...existingEntityAssociations.filter((ea) => ea.legalEntityId !== legalEntity.id)]
+				});
+				return;
+			} else {
+				const updatedAssociations = { entityAssociations: [{
+					type: "soleProprietorship",
+					legalEntityId: legalEntity.id
+				}] };
+				await updateLegalEntity({
+					...updatedAssociations,
+					id: legalEntityResponse.id
+				});
+			}
+		};
+		const filteredData = setRemovedFieldsOnSchemaToDeletedValue(data, mapLegalEntityToBusinessDetailsSchema({
+			legalEntity: entityToUpdate,
+			parentEntity: void 0,
+			taskType,
+			isFeatureEnabled
+		}));
+		if (filteredData.basicInformation && !filteredData.basicInformation.taxInformation) filteredData.basicInformation.taxInformation = void 0;
+		const countryOfGoverningLaw = getCountryOfGoverningLaw(isFeatureEnabled("EnableCountryOfGoverningLawForUKCompanies"), filteredData.basicInformation);
+		if (filteredData.basicInformation) if (countryOfGoverningLaw) filteredData.basicInformation.countryOfGoverningLaw = countryOfGoverningLaw;
+		else delete filteredData.basicInformation.countryOfGoverningLaw;
+		try {
+			const mappedLegalEntity = {
+				...mapBusinessDetailsSchemaToLegalEntity(filteredData, accountHolder, isFeatureEnabled, taskType, matchingScenario, legalEntityResponse),
+				entityAssociations: filterOutUnwantedAssociationsIfRootLE(taskType, entityToUpdate, accountHolder)
+			};
+			if (mappedLegalEntity.type === "organization" && (legalEntityResponse.organization?.registeredAddress.country !== mappedLegalEntity.organization?.registeredAddress.country || legalEntityResponse.organization?.countryOfGoverningLaw !== mappedLegalEntity.organization?.countryOfGoverningLaw) && legalEntityResponse.organization?.support) mappedLegalEntity.organization.support = determineCustomerSupport(legalEntityResponse.organization.support, mappedLegalEntity.organization?.registeredAddress.country);
+			const legalEntity = await handleSubmitLegalEntity(mappedLegalEntity);
+			/**
+			* Sole prop only associated during initial creation but for
+			* trust member company, association can also be updated with changed roles
+			*/
+			if (taskType === TaskTypes.TRUST_MEMBER_COMPANY || taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY || taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY && !associatedLegalArrangement?.id) await associateLegalEntityWithParent({
+				legalEntity,
+				associatedLegalArrangement,
+				nestedLegalEntityDetails
+			});
+			if (forms.some((form) => documentFormsIds.includes(form.formId))) await submitDocuments({
+				data,
+				legalEntity,
+				documentUtils,
+				userEvents
+			});
+			await submitBusinessLines({
+				data,
+				legalEntity: legalEntityResponse,
+				efpBusinessLines,
+				createBusinessLine,
+				updateBusinessLine,
+				matchingScenario,
+				t,
+				showToast
+			});
+			userEvents.addTaskEvent("Success", trackingPayload);
+			showToast({
+				label: t(($) => $["successfullyUpdatedDetails"], { ns: "common" }),
+				variant: "success"
+			});
+			await invalidateRootLegalEntity();
+			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"
+			});
+			throw err;
+		} finally {
+			setLoadingStatus("success");
+		}
+	}, [
+		accountHolderMaybe,
+		associatedLegalArrangement,
+		createBusinessLine,
+		createLegalEntity,
+		data,
+		documentUtils,
+		efpBusinessLines,
+		forms,
+		invalidateRootLegalEntity,
+		isFeatureEnabled,
+		legalEntityResponse,
+		matchingScenario,
+		nestedLegalEntity,
+		nestedLegalEntityDetails,
+		onExternalSubmit,
+		problems,
+		setLoadingStatus,
+		setProblems,
+		showToast,
+		t,
+		taskType,
+		updateBusinessLine,
+		updateLegalEntity,
+		userEvents
+	]);
+}
+async function submitDocuments({ data, legalEntity, documentUtils, userEvents }) {
+	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 {
+		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 submitBusinessLines({ data, legalEntity, efpBusinessLines, createBusinessLine, updateBusinessLine, matchingScenario, t, showToast }) {
+	const primaryIndustryCode = data.additionalInformation?.industryCodes && data.additionalInformation.industryCodes[0].id;
+	if (!primaryIndustryCode) return;
+	const logger = createLogger();
+	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: legalEntity.id,
+				industryCode: primaryIndustryCode,
+				service
+			};
+			promises.push(updateBusinessLine(payload));
+			operations.push(payload);
+		}
+		else if (requestedCapability) {
+			const payload = {
+				legalEntityId: legalEntity.id,
+				industryCode: primaryIndustryCode,
+				service
+			};
+			promises.push(createBusinessLine(payload));
+			operations.push(payload);
+		}
+	};
+	updateOrCreateBusinessLinesIfNeeded(bankingBusinessLines, !!matchingScenario?.includes("L_BANKING"), "banking");
+	updateOrCreateBusinessLinesIfNeeded(issuingBusinessLines, !!matchingScenario?.includes("L_ISSUING"), "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;
+	});
+	if (hadRejection) showToast({
+		label: t(($) => $["failedToUpdateEfpBusinessLines"], { ns: "business" }),
+		variant: "error"
+	});
+}
+var determineCustomerSupport = (customerSupport, country) => {
+	switch (country) {
+		case CountryCodes.Japan: return unsetCustomerSupportNumber(customerSupport);
+		default: return;
+	}
+};
+var unsetCustomerSupportNumber = (customerSupport) => {
+	return customerSupport ? {
+		email: customerSupport.email,
+		phone: {
+			number: "",
+			type: "mobile"
+		}
+	} : void 0;
+};
+//#endregion
+//#region src/context/handlerContext/useHandlerContext.ts
+function useHandlerContext() {
+	return useContext$1(HandlerContext);
+}
+//#endregion
+//#region src/components/Business/modals/LegalArrangementModal.tsx
+function LegalArrangementModal({ onCancel }) {
+	const { t } = useTranslation(["common", "business"]);
+	const { onNavigateToTask } = useHandlerContext();
+	return /* @__PURE__ */ jsx(Confirm, {
+		title: t(($) => $["thisBusinessIsntRegisteredAsACompany"], { ns: "business" }),
+		description: t(($) => $["ifThisIsYourBusinessGoBackAndChooseADifferentSetup"], { ns: "business" }),
+		cancelText: t(($) => $["close"], { ns: "common" }),
+		confirmText: t(($) => $["continue"], { ns: "common" }),
+		onCancel,
+		onConfirm: () => onNavigateToTask?.(TaskTypes.BUSINESS_TYPE_SELECTION),
+		analyticsEventLabel: "legalArrangementModal"
+	});
+}
+//#endregion
+//#region src/components/Business/modals/RegistrationNumberMismatchModal.tsx
+function RegistrationNumberMismatchModal({ companySearchStateModel, registrationNumberMismatchModalOpen, confirmDataSelection }) {
+	const { t } = useTranslation(["common", "business"]);
+	const { form } = useFormContext();
+	const { data } = getFormSlice(form, "basicInformation");
+	const country = data?.country;
+	const providedData = {
+		registrationNumber: data?.registrationNumber,
+		registrationNumberType: data?.registrationNumberType
+	};
+	const detectedData = {
+		registrationNumber: companySearchStateModel.selectedCompany.value?.registrationNumber,
+		registrationNumberType: void 0
+	};
+	const registrationNumberType = data?.exemptedFromRegistrationNumber ? "exempted" : data?.registrationNumberType;
+	const { label: registrationNumberLabel } = resolveFieldMetadata(registrationNumberDefaultFieldConfig[country], {
+		registrationNumberType: registrationNumberType === "exempted" ? void 0 : registrationNumberType,
+		state: data?.stateOrProvince || void 0
+	}, registrationNumberDefaultFieldMetadata);
+	return /* @__PURE__ */ jsx(DataConflictsModal, {
+		providedData,
+		detectedData,
+		conflictingProperties: ["registrationNumber"],
+		formatters: {},
+		labels: { registrationNumber: providedData.registrationNumberType === detectedData.registrationNumberType ? registrationNumberLabel : "registrationNumber" },
+		title: t(($) => $["verifyYourBusinesssDetails"], { ns: "business" }),
+		explanation: t(($) => $["selectTheOptionWithTheMostCorrectDetailsToContinue"], { ns: "business" }),
+		onCancel: () => registrationNumberMismatchModalOpen.value = false,
+		onContinue: confirmDataSelection,
+		listOnly: true
+	});
+}
+//#endregion
+//#region src/components/Business/modals/TinMismatchModal.tsx
+function TinMismatchModal({ onCancel, onConfirm }) {
+	const { t } = useTranslation(["common", "business"]);
+	const modalDescriptionKey = typeof useContext$1(CompanySearchStateContext).selectedCompany.value === "undefined" ? "theEinDidntMatchLegalBusinessName" : "itLooksLikeThisBusinessUsesADifferentEIN";
+	return /* @__PURE__ */ jsx(Confirm, {
+		title: t(($) => $["employerIdentificationNumberDoesntMatch"], { ns: "business" }),
+		description: t(($) => $[modalDescriptionKey], { ns: "business" }),
+		cancelText: t(($) => $["close"], { ns: "common" }),
+		confirmText: t(($) => $["continue"], { ns: "common" }),
+		onCancel,
+		onConfirm,
+		analyticsEventLabel: "tinVerificationFailureModal"
+	});
+}
+//#endregion
+//#region src/components/Business/utils/buildRequiredForms.ts
+function buildRequiredForms({ config: { forms, requiredFields, optionalFields, isValid, problems, isSettingEnabled, accountHolder, legalEntityResponse }, options }) {
+	/**
+	* Skip company structure if:
+	* - Only a single company structure is available
+	* - The legal form is already provided from a 3rd party provider
+	* - The legal entity type is allowed to skip company structure
+	* - The account holder is not a trust or unincorporated partnership
+	*
+	* This needs to be done here and not the rules because when selecting incorporated association or incorporated partnership, we set the entityType value in the
+	* multiform data. This means that even if the rules say we don't need this value, because the data is present we show add that field to required fields.
+	*/
+	const skipCompanyStructure = options?.skipCompanyStructure || isSettingEnabled(SettingNames.AllowLegalEntityTypeChange) && organizationTypesToSkipCompanyStructureForm.includes(legalEntityResponse.organization?.type ?? "") && accountHolder !== "aTrust" && accountHolder !== "anUnincorporatedPartnership";
+	const filteredForms = Object.values(forms).filter(({ formId }) => {
+		if (formId === "businessSelection") {
+			if (options?.skipBusinessSelection) return false;
+		}
+		if (formId === "companyStructure") {
+			if (skipCompanyStructure) return false;
+		}
+		if (requiredFields || optionalFields) return Boolean(requiredFields?.[formId]) || Boolean(optionalFields?.[formId]);
+		return true;
+	});
+	return addValidityToForms(options?.skipSummary ? filteredForms : [...filteredForms, summaryStep], isValid, problems);
+}
+//#endregion
+//#region src/components/Business/utils/formatDataForSummary.ts
+function createStructuredListItem(term, details, t) {
+	if (!details) return;
+	return {
+		term: t(($) => $[term], { ns: "common" }),
+		details
+	};
+}
+var formatBasicInformation = (data, datasetUtils, companyType, isCountryOfGoverningLawEnabled) => {
+	const country = data.country;
+	const taxInfoForCountry = data.taxInformation?.find((taxInfo) => taxInfo.country === country);
+	let taxIdLabel = "taxInformationNumber";
+	if (country in taxIdNumberOptions) {
+		const numberOption = taxIdNumberOptions[country]?.find((taxOption) => taxOption.id === taxInfoForCountry?.type);
+		if (numberOption) taxIdLabel = numberOption.name;
+	}
+	const registrationNumberLabel = resolveFieldMetadata(registrationNumberDefaultFieldConfig[country], {
+		companyType,
+		registrationNumberType: data.registrationNumber ? inferCompanyRegistrationNumberType(data.registrationNumber, country, companyType) : getCompanyRegistrationNumberOptions(country, companyType)?.[0]?.id
+	}, registrationNumberDefaultFieldMetadata).label ?? "";
+	return {
+		legalCompanyName: data.legalCompanyName,
+		country: datasetUtils.getCountryName(data.country),
+		[getKeyForField("stateOrProvince", data.country)]: datasetUtils.getStateName(data.stateOrProvince, data.country),
+		[taxIdLabel]: taxInfoForCountry?.number,
+		[registrationNumberLabel]: data.registrationNumber,
+		countryOfGoverningLaw: datasetUtils.getCountryName(getCountryOfGoverningLaw(isCountryOfGoverningLawEnabled, data))
+	};
+};
+var formatAdditionalInformation = (data, t) => {
+	const vatAbsenceReason = data.vatAbsenceReason;
+	return {
+		businessStructure: data.legalFormLabel,
+		doingBusinessAs: data.doingBusinessAs,
+		industry: data.industryCodes?.[0].name,
+		vatNumber: data.vatNumber,
+		vatAbsenceReason: vatAbsenceReason ? t(($) => $[vatAbsenceReason], { ns: "common" }) : "",
+		legalEntityIdentifier: data.legalEntityIdentifier,
+		dateOfIncorporation: data.dateOfIncorporation,
+		stockExchangeMIC: data.stockExchangeMIC,
+		stockISIN: data.stockISIN,
+		stockTickerSymbol: data.stockTickerSymbol,
+		eInvoicingCode: data.eInvoicingCode
+	};
+};
+var formatAddress = (data, datasetUtils, country, version) => {
+	return country === CountryCodes.Japan && version === 4 ? mapJpAddressSummaryNewSummary(data, datasetUtils) : mapAddressLabelsNewSummary(data, datasetUtils);
+};
+var formatFinancialInformationSummary = (data, language, country, dateOfIncorporation) => {
+	if (!data) return {};
+	if (dateOfIncorporation && !isDateOlderThanAYear(dateOfIncorporation)) return country === CountryCodes.UnitedKingdom ? { numberOfEmployees: data.numberOfEmployees } : {};
+	return {
+		currency: data.currency,
+		financialReportingDate: data.financialReportingDate,
+		...country === CountryCodes.UnitedKingdom ? { numberOfEmployees: data.numberOfEmployees } : {},
+		...data.balanceSheetTotal ? { balanceSheetTotal: formatCurrency(data.balanceSheetTotal, data.currency, language) } : {},
+		...data.annualTurnover ? { annualTurnover: formatCurrency(data.annualTurnover, data.currency, language) } : {}
+	};
+};
+var formatDataForSummary = (data, forms, t, language, isFeatureEnabled, version) => {
+	const OMITTED_FORMS = ["businessSelection", "summary"];
+	const datasetUtils = datasetUtilities(language);
+	const isCountryOfGoverningLawEnabled = isFeatureEnabled("EnableCountryOfGoverningLawForUKCompanies");
+	const getSummaryItemsForForm = (formId) => {
+		if (!data[formId]) return {};
+		switch (formId) {
+			case "basicInformation": return formatBasicInformation(data[formId], datasetUtils, data.companyStructure?.entityType, isCountryOfGoverningLawEnabled);
+			case "companyStructure": return { entityType: t(($) => $[companyTypeMetadata[data[formId]?.entityType]?.name], { ns: "business" }) };
+			case "additionalInformation": return formatAdditionalInformation(data[formId], t);
+			case "companyRegistrationDocument": return {
+				fileName: data[formId].registrationDocument?.[0]?.name,
+				description: data[formId].description
+			};
+			case "companyTaxDocument": return {
+				fileName: data[formId]?.taxDocument?.[0]?.name,
+				description: data[formId].description
+			};
+			case "companyProofOfAddressDocument": return {
+				fileName: data[formId]?.proofOfAddress?.[0]?.name,
+				description: data[formId].description
+			};
+			case "companyConstitutionalDocument": return {
+				fileName: data[formId]?.constitutionalDocument?.[0]?.name,
+				description: data[formId].description
+			};
+			case "companyProofOfDirectorDocument": return {
+				fileName: data[formId]?.proofOfDirector?.[0]?.name,
+				description: data[formId].description
+			};
+			case "companyProofOfSignatoryDocument": return {
+				fileName: data[formId]?.proofOfSignatory?.[0]?.name,
+				description: data[formId].description
+			};
+			case "companyProofOfOwnershipDocument": return {
+				fileName: data[formId].proofOfOwnership?.map((doc) => doc.name).join("\n"),
+				description: data[formId].description
+			};
+			case "companyFinancialInformation": return formatFinancialInformationSummary(data[formId], language, data.basicInformation?.country, data.additionalInformation?.dateOfIncorporation);
+			default: return {};
+		}
+	};
+	const translateAndFilterMappedSummary = (data) => {
+		const tmp = [];
+		for (const summaryItem in data) {
+			const item = createStructuredListItem(summaryItem, data[summaryItem], t);
+			if (item) tmp.push(item);
+		}
+		return tmp;
+	};
+	const summarySectionData = [];
+	for (const form of forms) {
+		if (OMITTED_FORMS.includes(form.formId)) continue;
+		const summaryItems = translateAndFilterMappedSummary(getSummaryItemsForForm(form.formId));
+		if (summaryItems.length > 0) summarySectionData.push({
+			formId: form.formId,
+			label: t(($) => $[form.formName], { ns: "common" }),
+			items: summaryItems
+		});
+		if (form.formId === "additionalInformation") {
+			const registrationAddressSummaryItems = translateAndFilterMappedSummary(formatAddress(nestAddressSchema("registrationAddress", data.additionalInformation), datasetUtils, data.basicInformation?.country, version));
+			if (registrationAddressSummaryItems.length > 0) summarySectionData.push({
+				formId: "registrationAddress",
+				label: t(($) => $["registrationAddress"], { ns: "common" }),
+				items: registrationAddressSummaryItems
+			});
+			if (!data[form.formId]?.operationalAddressIsSame) {
+				const operationalAddressSummaryItems = translateAndFilterMappedSummary(formatAddress(nestAddressSchema("operationalAddress", data.additionalInformation), datasetUtils, data.basicInformation?.country, version));
+				if (operationalAddressSummaryItems.length > 0) summarySectionData.push({
+					formId: "operationalAddress",
+					label: t(($) => $["operationalAddress"], { ns: "common" }),
+					items: operationalAddressSummaryItems
+				});
+			}
+		}
+	}
+	return summarySectionData;
+};
+//#endregion
+//#region src/components/Business/tasks/BusinessDetailsDropin/businessDetailsFormConfig.ts
+var businessDetailsBase = {
+	country: { rule: "REQUIRED" },
+	entityType: { rule: "businessRequiresCompanyType" },
+	legalCompanyName: { rule: "REQUIRED" },
+	jaHaniLegalCompanyName: { rule: "japaneseLegalCompanyName" },
+	jaKanaLegalCompanyName: { rule: "japaneseLegalCompanyName" },
+	hasDoingBusinessAs: { rule: "REQUIRED" },
+	doingBusinessAs: { rule: "requireDoingBusinessAsName" },
+	residentialAddressIndicator: { rule: "isResidentialAddressIndicatorEnabled" },
+	operationalAddressIsSame: { rule: "REQUIRED" },
+	legalEntityIdentifier: { rule: "requireLEI" },
+	exemptedFromLegalEntityIdentifier: { rule: "requireLEIExemption" },
+	selectedBusinessId: { rule: "usingCompanySearch" },
+	stateOrProvince: { rule: "requireStateOrProvinceForCompanySearch" },
+	stockExchangeMIC: { rule: "ifPubliclyTradedCompany" },
+	stockISIN: { rule: "ifPubliclyTradedCompany" },
+	stockTickerSymbol: { rule: "ifPubliclyTradedCompany" },
+	dateOfIncorporation: { rule: "isDateOfIncorporationRequired" },
+	registrationNumber: { rule: "countryRequiresRegistrationNumber" },
+	registrationNumberType: { rule: "registrationNumberType" },
+	exemptedFromRegistrationNumber: { rule: "companyRegistrationNumberExemptionAllowed" },
+	eInvoicingCode: { rule: "isEInvoicingCodeEnabled" },
+	countryOfGoverningLaw: { rule: "countryOfGoverningLawRequired" },
+	taxDocument: { rule: "isTaxDocumentRequired" },
+	registrationDocument: { rule: "isRegistrationDocumentRequired" },
+	registrationAddressStreet: { rule: "registrationAddressStreetRequired" },
+	registrationAddressStreet2: { rule: "registrationAddressStreet2Required" },
+	registrationAddressCity: { rule: "registrationAddressCityRequired" },
+	registrationAddressPostalCode: { rule: "registrationAddressPostalCodeRequired" },
+	registrationAddressStateOrProvince: { rule: "registrationAddressStateOrProvinceRequired" },
+	registrationAddressCountry: { rule: "registrationAddressCountryRequired" },
+	operationalAddressStreet: { rule: "operationalAddressStreetRequired" },
+	operationalAddressStreet2: { rule: "operationalAddressStreet2Required" },
+	operationalAddressCity: { rule: "operationalAddressCityRequired" },
+	operationalAddressPostalCode: { rule: "operationalAddressPostalCodeRequired" },
+	operationalAddressStateOrProvince: { rule: "operationalAddressStateOrProvinceRequired" },
+	operationalAddressCountry: { rule: "operationalAddressCountryRequired" },
+	registrationAddressJaHaniStateOrProvince: { rule: "registrationAddressJaHaniStateOrProvinceRequired" },
+	registrationAddressJaHaniCity: { rule: "registrationAddressJaHaniCityRequired" },
+	registrationAddressJaHaniStreet: { rule: "registrationAddressJaHaniStreetRequired" },
+	registrationAddressJaKanaStateOrProvince: { rule: "registrationAddressJaKanaStateOrProvinceRequired" },
+	registrationAddressJaKanaCity: { rule: "registrationAddressJaKanaCityRequired" },
+	registrationAddressStreet2FullWidth: { rule: "registrationAddressStreet2FullWidthRequired" },
+	operationalAddressJaHaniStateOrProvince: { rule: "operationalAddressJaHaniStateOrProvinceRequired" },
+	operationalAddressJaHaniCity: { rule: "operationalAddressJaHaniCityRequired" },
+	operationalAddressJaHaniStreet: { rule: "operationalAddressJaHaniStreetRequired" },
+	operationalAddressJaKanaStateOrProvince: { rule: "operationalAddressJaKanaStateOrProvinceRequired" },
+	operationalAddressJaKanaCity: { rule: "operationalAddressJaKanaCityRequired" },
+	operationalAddressStreet2FullWidth: { rule: "operationalAddressStreet2FullWidthRequired" }
+};
+var taxInformationBase = {
+	vatNumber: { rule: "countryUsesVat" },
+	vatNumberType: { rule: "vatNumberType" },
+	exemptedFromVat: { rule: "isVatExempt" },
+	vatAbsenceReason: { rule: "isVatExempt" },
+	taxInformation: { rule: "countryUsesTaxId" },
+	exemptedFromTax: { rule: "countryHasTaxExemptions" },
+	isUen: { rule: "countryUsesUenOrGst" }
+};
+var financialInformationBase = {
+	numberOfEmployees: { rule: "countryRequiresFinancialInformation" },
+	financialReportingDate: { rule: "isFinancialReportingFieldsRequired" },
+	currency: { rule: "isFinancialReportingFieldsRequired" },
+	reportedValueOption: { rule: "isFinancialReportingFieldsRequired" },
+	annualTurnover: { rule: "annualTurnoverRequired" },
+	balanceSheetTotal: { rule: "balanceSheetTotalRequired" }
+};
+var businessDetailsFieldsPerScenario = {
+	L0: {
+		country: { rule: "REQUIRED" },
+		legalCompanyName: { rule: "REQUIRED" },
+		stateOrProvince: { rule: "usingCompanySearch" },
+		...financialInformationBase
+	},
+	L1: {
+		...businessDetailsBase,
+		...financialInformationBase
+	},
+	L: {
+		...businessDetailsBase,
+		...taxInformationBase,
+		...financialInformationBase
+	},
+	L_PROOFOFADDRESS: { proofOfAddress: { rule: "REQUIRED" } },
+	L_REGDOC: { registrationDocument: { rule: "REQUIRED" } },
+	L_TAXDOC: { taxDocument: { rule: "REQUIRED" } },
+	L_BAFIN: { legalForm: { rule: "REQUIRED" } },
+	L_ISSUING: { industryCodes: { rule: "isIndustryCodeRequired" } },
+	L_BANKING: { industryCodes: { rule: "isIndustryCodeRequired" } }
+};
+//#endregion
+//#region src/components/Business/tasks/BusinessDetailsDropin/BusinessDetailsGettingStarted.tsx
+var businessDetailsImage = lazy(() => import("./business-details-CPkvjYXG.js"));
+var BusinessDetailsGettingStarted = ({ openModal, handleCancelClick, t, data: summaryData }) => {
+	const { data: taskStatus } = useTaskStatus(TaskTypes.BUSINESS_DETAILS, { refetchInterval: TASK_STATUS_POLLING_INTERVAL_MS });
+	return /* @__PURE__ */ jsx("div", {
+		style: {
+			maxWidth: 450,
+			margin: "0 auto"
+		},
+		children: (taskStatus?.status ?? "DETAILS_REQUIRED") === "DETAILS_REQUIRED" ? /* @__PURE__ */ jsx(LandingLayout, {
+			title: t(($) => $["businessDetails"], { ns: "common" }),
+			description: t(($) => $["businessDetailsGettingStarted"], { ns: "business" }),
+			media: /* @__PURE__ */ jsx(Image, { lazyLoadedImage: businessDetailsImage }),
+			actions: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Button, {
+				fullWidth: true,
+				onClick: openModal,
+				children: t(($) => $["getStarted"], { ns: "common" })
+			}), /* @__PURE__ */ jsx(Button, {
+				variant: "tertiary",
+				fullWidth: true,
+				onClick: handleCancelClick,
+				children: t(($) => $["finishLater"], { ns: "common" })
+			})] })
+		}) : /* @__PURE__ */ jsxs(StackLayout, {
+			align: "center",
+			children: [/* @__PURE__ */ jsx(TaskVerificationStatus, { status: taskStatus?.status ?? "FINISHED" }), /* @__PURE__ */ jsx(DetailViewLayout, {
+				title: t(($) => $["businessDetails"], { ns: "common" }),
+				align: "center",
+				description: t(($) => $["theDetailsWeCollected"], { ns: "business" }),
+				actions: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Button, {
+					onClick: openModal,
+					children: t(($) => $["edit"], { ns: "common" })
+				}), /* @__PURE__ */ jsx(Button, {
+					variant: "secondary",
+					onClick: handleCancelClick,
+					fullWidth: true,
+					children: t(($) => $["goBackToTaskList"], { ns: "common" })
+				})] }),
+				children: summaryData?.map(({ formId, label, items }) => /* @__PURE__ */ jsx(SummarySection, {
+					formId,
+					label,
+					items
+				}, formId))
+			})]
+		})
+	});
+};
+//#endregion
+//#region src/components/Business/utils/applyVerifiedBusinessData.ts
+var applyFinancialInformation = (form, verifiedData) => {
+	const financialInformation = verifiedData?.financialInformation;
+	if (!financialInformation) return;
+	const verifiedFinancialReportingDate = financialInformation.financialReportingDate;
+	const currentFinancialReportingDate = form.data.companyFinancialInformation?.financialReportingDate;
+	if (!currentFinancialReportingDate || verifiedFinancialReportingDate && verifiedFinancialReportingDate >= currentFinancialReportingDate) {
+		if (financialInformation.numberOfEmployees != null) form.handleChangeFor("companyFinancialInformation", "numberOfEmployees")(financialInformation.numberOfEmployees);
+		if (financialInformation.financialReportingDate) form.handleChangeFor("companyFinancialInformation", "financialReportingDate")(financialInformation.financialReportingDate);
+		if (financialInformation.currency) form.handleChangeFor("companyFinancialInformation", "currency")(financialInformation.currency);
+		/**
+		* Determine which reported value option to select based on available data
+		* Priority: balanceSheetTotal > annualTurnover
+		*/
+		const selectedReportedValueOption = financialInformation.balanceSheetTotal != null ? "balanceSheetTotal" : financialInformation.annualTurnover != null ? "annualTurnover" : null;
+		if (selectedReportedValueOption) {
+			const selectedReportedValue = selectedReportedValueOption === "balanceSheetTotal" ? financialInformation.balanceSheetTotal : financialInformation.annualTurnover;
+			const nonSelectedReportedValueOption = selectedReportedValueOption === "balanceSheetTotal" ? "annualTurnover" : "balanceSheetTotal";
+			form.handleChangeFor("companyFinancialInformation", "reportedValueOption")(selectedReportedValueOption);
+			form.handleChangeFor("companyFinancialInformation", selectedReportedValueOption)(selectedReportedValue);
+			form.handleChangeFor("companyFinancialInformation", nonSelectedReportedValueOption)(void 0);
+		}
+	}
+};
+var applyVerifiedBusinessData = (form, country, verifiedData, options) => {
+	if (!verifiedData) return;
+	form.handleChangeFor("basicInformation", "legalCompanyName")(verifiedData.name);
+	if (!options?.preserveRegistrationNumber && country !== CountryCodes.UnitedStates && verifiedData.registrationNumber) {
+		form.handleChangeFor("basicInformation", "registrationNumber")(verifiedData.registrationNumber);
+		const inferredRegistrationNumberType = inferCompanyRegistrationNumberType(verifiedData.registrationNumber, country, verifiedData.companyType);
+		form.handleChangeFor("basicInformation", "registrationNumberType")(inferredRegistrationNumberType);
+	}
+	const companyType = options?.companyTypeOverride ?? verifiedData.companyType;
+	if (companyType) form.handleChangeFor("companyStructure", "entityType")(companyType);
+	if (!(form.defaultData?.additionalInformation?.registrationAddressStreet || form.defaultData?.additionalInformation?.operationalAddressStreet)) {
+		if (verifiedData.principalPlaceOfBusinessAddress) form.handleChangeFor("additionalInformation", "operationalAddressIsSame", "input")(false);
+		const addressFields = [...form.requiredFields?.additionalInformation ?? [], ...form.optionalFields?.additionalInformation ?? []];
+		const applyVerifiedAddress = (prefix, address) => {
+			const flatVerifiedAddress = flattenAddressSchema(prefix, {
+				...address,
+				country
+			});
+			for (const field in flatVerifiedAddress) {
+				const fieldValue = flatVerifiedAddress[field];
+				if (fieldValue === void 0 || !addressFields.includes(field)) continue;
+				form.handleChangeFor("additionalInformation", field)(fieldValue);
+			}
+		};
+		if (verifiedData.registeredAddress) applyVerifiedAddress("registrationAddress", mapAddressData(verifiedData.registeredAddress));
+		if (verifiedData.principalPlaceOfBusinessAddress) applyVerifiedAddress("operationalAddress", mapAddressData(verifiedData.principalPlaceOfBusinessAddress));
+	}
+	applyFinancialInformation(form, verifiedData);
+};
+//#endregion
+//#region src/components/Business/tasks/BusinessDetailsDropin/businessDetailsStore.ts
+var CompanySearchStateModel = createModel((userEvents) => {
+	const companySearchName = signal();
+	const selectedCompany = signal(void 0);
+	const verifiedBusiness = signal(void 0);
+	const verificationMatched = signal(void 0);
+	/** We cannot allow selections in a few situations, this is used to track them */
+	const disallowedSelectionReason = signal(void 0);
+	/** Only used for MixPanel tracking, not meant to be exposed */
+	const selectedCompanyIdx = signal(-1);
+	const resetCompanySearchData = () => {
+		selectedCompany.value = void 0;
+		verifiedBusiness.value = void 0;
+		verificationMatched.value = void 0;
+		disallowedSelectionReason.value = void 0;
+		selectedCompanyIdx.value = -1;
+	};
+	return {
+		companySearchName,
+		selectedCompany,
+		verifiedBusiness,
+		verificationMatched,
+		disallowedSelectionReason,
+		resetCompanySearchData,
+		disallowSelection: (reason) => {
+			resetCompanySearchData();
+			disallowedSelectionReason.value = reason;
+		},
+		setVerificationMatched: (value) => {
+			resetCompanySearchData();
+			verificationMatched.value = value;
+		},
+		selectCompany: (selected, idx, country) => {
+			resetCompanySearchData();
+			selectedCompany.value = selected;
+			verificationMatched.value = country === CountryCodes.UnitedStates ? selected.tinMatched : selected.registrationNumberMatched;
+			/** `-1` indicates auto-selection, not a manual user interaction */
+			if (idx > -1) {
+				selectedCompanyIdx.value = idx;
+				selectBusinessAnalytics(userEvents, idx);
+			}
+		},
+		confirmCompany: (multiform, country, options) => {
+			verifiedBusiness.value = selectedCompany.value;
+			applyVerifiedBusinessData(multiform, country, selectedCompany.value, options);
+			if (selectedCompanyIdx.value > -1) confirmBusinessAnalytics(userEvents, selectedCompanyIdx.value);
+		}
+	};
+});
+function selectBusinessAnalytics(userEvents, idx) {
+	userEvents.addPageEvent("Clicked button", {
+		actionType: "select",
+		label: "selectBusiness",
+		additionalData: { companyIdx: idx }
+	});
+}
+function confirmBusinessAnalytics(userEvents, idx) {
+	userEvents.addPageEvent("Clicked button", {
+		actionType: "select",
+		label: "confirmBusiness",
+		additionalData: { companyIdx: idx }
+	});
+}
+//#endregion
+//#region src/components/Shared/fields/CountryField/validate.ts
+var CountryFieldValidation = () => ({ country: {
+	modes: ["blur"],
+	validate: (country) => !isEmpty(country),
+	errorMessage: "fieldIsRequired"
+} });
+//#endregion
+//#region src/components/Business/tasks/BusinessDetailsDropin/validate.ts
+var logger = createLogger();
+function basicInformationValidators({ country, taxIdNumberType, companyType, registrationNumberType, state, isFeatureEnabled }) {
+	return {
+		country: CountryFieldValidation().country,
+		countryOfGoverningLaw: CountryOfGoverningLawFieldValidation().countryOfGoverningLaw,
+		legalCompanyName: resolveFieldMetadata(isFeatureEnabled("StrictNameAndAddressValidationV4") ? defaultFieldConfigV4[country] : defaultFieldConfig[country], {}, isFeatureEnabled("StrictNameAndAddressValidationV4") ? defaultFieldMetadataV4 : defaultFieldMetadata).validators,
+		taxInformation: resolveFieldMetadata(taxInformationDefaultFieldConfig[country], {
+			taxIdNumberType,
+			companyType
+		}, taxInformationDefaultFieldMetadata).validators,
+		stateOrProvince: stateFieldMetadata.validators,
+		registrationNumber: resolveFieldMetadata(registrationNumberDefaultFieldConfig[country], {
+			companyType,
+			registrationNumberType,
+			state,
+			isFeatureEnabled
+		}, registrationNumberDefaultFieldMetadata).validators,
+		exemptedFromRegistrationNumber: exemptFromRegistrationNumberDefaultFieldMetadata.validators,
+		jaHaniLegalCompanyName: resolveFieldMetadata(localizedLegalCompanyNameFieldConfig.jaHaniLegalCompanyName.config, {}, localizedLegalCompanyNameFieldConfig.jaHaniLegalCompanyName.metadata).validators,
+		jaKanaLegalCompanyName: resolveFieldMetadata(localizedLegalCompanyNameFieldConfig.jaKanaLegalCompanyName.config, {}, localizedLegalCompanyNameFieldConfig.jaKanaLegalCompanyName.metadata).validators
+	};
+}
+function businessSelectionValidators() {
+	return { selectedBusinessId: {
+		modes: ["blur", "input"],
+		validate: (val) => !isEmpty(val),
+		errorMessage: "fieldIsRequired"
+	} };
+}
+function prefixAddressValidators(prefix, rules) {
+	const validators = {};
+	for (const field in rules) validators[`${prefix}${capitalize(field)}`] = rules[field];
+	return validators;
+}
+function additionalInformationValidators({ country, vatNumberType, isFeatureEnabled, t }) {
+	const addressRules = addressValidators({
+		isFeatureEnabled,
+		country,
+		t
+	});
+	return {
+		hasDoingBusinessAs: doingBusinessAsAbsentFieldMetadata.validators,
+		doingBusinessAs: doingBusinessAsFieldMetadata.validators,
+		legalEntityIdentifier: legalEntityIdentifierFieldMetadata.validators,
+		vatNumber: resolveFieldMetadata(defaultFieldConfig$1[country], { vatNumberType }, defaultFieldMetadata$1).validators,
+		vatAbsenceReason: vatAbsenceReasonMetadata.validators,
+		eInvoicingCode: eInvoicingCodeFieldMetadata.validators,
+		industryCodes: industryCodeFieldMetadata.validators,
+		dateOfIncorporation: dateOfIncorporationFieldMetadata.validators,
+		stockExchangeMIC: stockExchangeMICFieldMetadata.validators,
+		stockISIN: stockISINFieldMetadata.validators,
+		stockTickerSymbol: stockTickerSymbolFieldMetadata.validators,
+		...prefixAddressValidators("registrationAddress", addressRules),
+		...prefixAddressValidators("operationalAddress", addressRules)
+	};
+}
+var preventPoBoxValidation = (cleanseAddress, formData) => ({ operationalAddressStreet: {
+	modes: [],
+	errorMessage: "addressPoBoxError",
+	asyncValidate: async (street) => {
+		const country = formData?.basicInformation?.country;
+		if (!street || !country) return true;
+		const text = formatAddressForCleanse({
+			...nestAddressSchema("operationalAddress", formData.additionalInformation),
+			street
+		});
+		if (!text) return true;
+		try {
+			const { poBox } = await cleanseAddress({
+				text,
+				country
+			});
+			return !poBox;
+		} catch (error) {
+			logger.error("Error while checking if address is PO box", error);
+			return true;
+		}
+	}
+} });
+//#endregion
+//#region src/components/Business/tasks/BusinessDetailsDropin/BusinessDetailsDropin.tsx
+var CompanySearchStateContext = createContext$1({});
+function BusinessDetailsDropin({ taskType, country: propCountry, problems: propProblems, legalEntityResponse, efpBusinessLines, documents, associatedLegalArrangement, nestedLegalEntity, nestedLegalEntityDetails, onSubmit: onExternalSubmit, handleHomeClick }) {
+	const { t, i18n } = useTranslation(["common", "business"]);
+	const userEvents = useAnalyticsContext();
+	const { isFeatureEnabled } = useToggleContext();
+	const isBusinessDetailsModalEnabled = taskType === TaskTypes.BUSINESS_DETAILS;
+	const { isSettingEnabled } = useSettingsContext();
+	const { accountHolder } = useAccountHolder();
+	const logger = createLogger();
+	const { mutateAsync: clearCompanyData } = useClearCompanyData();
+	/**
+	* Analytics
+	*/
+	useTaskLandedEvent(taskType);
+	const isAssociationTaskType = taskType !== TaskTypes.BUSINESS_DETAILS;
+	const legalEntityType = taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY ? "soleProprietorship" : "organization";
+	/**
+	* Business Details is used for updating root entities of type 'Organization'
+	* and for both creating/updating associated arrangements of types 'Sole
+	* Proprietorship' and 'Trust Member Company' so must determine the subject entity
+	*
+	* Sole Props are associated to legalEntityResponse (root legal entity)
+	* Trust Member company are a nested association to associatedLegalArrangement
+	*/
+	const subjectEntity = !isAssociationTaskType ? legalEntityResponse : taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY ? associatedLegalArrangement : nestedLegalEntity;
+	const [country, setCountry] = useState$1(propCountry);
+	const [problems, setProblems] = useState$1(propProblems ?? {});
+	const [loadingStatus, setLoadingStatus] = useState$1("success");
+	const [derivedProps, setDerivedProps] = useState$1();
+	const [trustedFields, setTrustedFields] = useState$1(subjectEntity?.trustedFields ?? void 0);
+	const [isAddingBusinessDetails, setIsAddingBusinessDetails] = useState$1(false);
+	const [hasEnteredFormFlowBefore, setHasEnteredFormFlowBefore] = useState$1(false);
+	const companySearchStateModel = useModel(() => new CompanySearchStateModel(userEvents));
+	const tinMismatchModalOpen = useSignal(false);
+	const legalArrangementModalOpen = useSignal(false);
+	const registrationNumberMismatchModalOpen = useSignal(false);
+	const defaultForms = useMemo$1(() => getForms(country), [country]);
+	const { fieldConfigurations } = useScenarioConfiguration({
+		legalEntityType,
+		parseConfiguration: useCallback$1(({ scenarios }) => composePerScenarioFormConfigurations(scenarios, businessDetailsFieldsPerScenario), []),
+		setLoadingStatus,
+		country
+	});
+	const defaultData = useMemo$1(() => {
+		const mapped = mapLegalEntityToBusinessDetailsSchema({
+			legalEntity: !isAssociationTaskType ? legalEntityResponse : taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY ? associatedLegalArrangement ?? legalEntityResponse : nestedLegalEntity,
+			parentEntity: taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY ? legalEntityResponse : void 0,
+			taskType,
+			isFeatureEnabled
+		});
+		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,
+		taskType,
+		associatedLegalArrangement,
+		nestedLegalEntity,
+		isFeatureEnabled,
+		isSettingEnabled,
+		efpBusinessLines,
+		documents
+	]);
+	const buildFieldValidations = useCallback$1((data) => {
+		const taxInfo = data?.basicInformation?.taxInformation;
+		const taxIdType = taxInfo?.length ? taxInfo.find((taxId) => taxId.country === country)?.type : void 0;
+		const regNumberType = data?.basicInformation?.registrationNumberType;
+		const companyType = taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY ? "soleProprietorship" : data?.companyStructure?.entityType;
+		return {
+			basicInformation: basicInformationValidators({
+				country,
+				state: data?.basicInformation?.stateOrProvince,
+				companyType,
+				taxIdNumberType: taxIdType,
+				registrationNumberType: regNumberType,
+				isFeatureEnabled,
+				t
+			}),
+			businessSelection: businessSelectionValidators(),
+			companyStructure: CompanyStructureValidation,
+			additionalInformation: additionalInformationValidators({
+				country,
+				taxIdNumberType: taxIdType,
+				companyType,
+				registrationNumberType: regNumberType,
+				vatNumberType: data?.additionalInformation?.vatNumberType,
+				isFeatureEnabled,
+				t
+			}),
+			companyFinancialInformation: financialInfoValidationWithEmployeesRules
+		};
+	}, [
+		country,
+		isFeatureEnabled,
+		t,
+		taskType
+	]);
+	const cleanseAddress = useAddressCleanseImperatively();
+	const buildAsyncFieldValidations = useCallback$1((data) => ({ additionalInformation: { operationalAddressStreet: preventPoBoxValidation(cleanseAddress, data).operationalAddressStreet } }), [cleanseAddress]);
+	const multiForm = useMultiForm({
+		defaultData,
+		allFields: derivedProps?.allFields,
+		requiredFields: derivedProps?.requiredFields,
+		optionalFields: derivedProps?.optionalFields,
+		obscuredFields: derivedProps?.obscuredFields,
+		trustedFields: derivedProps?.trustedFields,
+		rules: buildFieldValidations,
+		asyncRules: buildAsyncFieldValidations
+	});
+	/**
+	* Whilst this value _could_ be easily derived from existing values, it's intentionally distinct.
+	* `tinMatched`, from the company search model, updates immediately from the API response but we only
+	* want to insert the tax doc once the user actually navigates forward, hence, another state value set on nav.
+	*/
+	const isTinMatched = useSignal(void 0);
+	const customRules = useMemo$1(() => rules({
+		data: multiForm.data,
+		defaultData,
+		verifiedBusiness: companySearchStateModel.verifiedBusiness.value,
+		country,
+		taskType,
+		isFeatureEnabled,
+		isSettingEnabled,
+		accountHolder,
+		tinMatched: isTinMatched.value,
+		rootLegalEntity: legalEntityResponse
+	}), [
+		multiForm.data,
+		defaultData,
+		companySearchStateModel.verifiedBusiness.value,
+		country,
+		taskType,
+		isFeatureEnabled,
+		isSettingEnabled,
+		accountHolder,
+		isTinMatched.value,
+		legalEntityResponse
+	]);
+	useEffect$1(() => {
+		const props = getPropsFromConfigurations({
+			scenarioConfiguration: fieldConfigurations,
+			forms: defaultForms,
+			remediationActions: problems.remediationActions ? Object.values(problems.remediationActions) : [],
+			dataMissingErrors: problems.missingData ?? [],
+			fieldsWithExistingData: subjectEntity ? subjectEntity.type === "soleProprietorship" ? 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
+	]);
+	/**
+	* Current country value must be kept in sync with what is selected in basicInformation form
+	*/
+	const [prevCountry, setPrevCountry] = useState$1(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);
+		companySearchStateModel.resetCompanySearchData();
+		multiForm.handleChangeFor("companyStructure", "entityType")(void 0);
+	}
+	/**
+	* The company structures that are still valid given the registration number type and tax ID
+	* number type currently in the form.
+	*/
+	const availableCompanyStructures = useMemo$1(() => getAvailableCompanyStructures({
+		country,
+		registrationNumberType: multiForm.data.basicInformation?.registrationNumberType,
+		registrationNumberExempt: multiForm.data.basicInformation?.exemptedFromRegistrationNumber,
+		taxIdNumberType: multiForm.data.basicInformation?.taxInformation?.find((taxInformation) => taxInformation.country === country)?.type,
+		legalEntity: legalEntityResponse,
+		accountHolder,
+		isSettingEnabled
+	}), [
+		accountHolder,
+		country,
+		isSettingEnabled,
+		legalEntityResponse,
+		multiForm.data.basicInformation?.exemptedFromRegistrationNumber,
+		multiForm.data.basicInformation?.registrationNumberType,
+		multiForm.data.basicInformation?.taxInformation
+	]);
+	/**
+	* Infer the company structure based on the registration number type and tax ID number type
+	* This is used to automatically select the company structure when the user has already provided
+	* the necessary information to uniquely identify the company structure
+	*/
+	const inferredCompanyStructure = useMemo$1(() => {
+		if (taskType !== "BUSINESS_DETAILS") return void 0;
+		if (multiForm.data.companyStructure?.entityType && multiForm.data.companyStructure?.entityType === "associationIncorporated" || multiForm.data.companyStructure?.entityType === "partnershipIncorporated") return;
+		return availableCompanyStructures.length === 1 ? availableCompanyStructures[0] : void 0;
+	}, [
+		availableCompanyStructures,
+		multiForm.data.companyStructure?.entityType,
+		taskType
+	]);
+	const applyInferredCompanyStructure = () => {
+		if (!inferredCompanyStructure) return;
+		if (multiForm.data.companyStructure?.entityType === inferredCompanyStructure) return;
+		multiForm.handleChangeFor("companyStructure", "entityType")(inferredCompanyStructure);
+	};
+	const getRequiredForms = useCallback$1((options) => {
+		return buildRequiredForms({
+			config: {
+				forms: defaultForms,
+				requiredFields: derivedProps?.requiredFields,
+				optionalFields: derivedProps?.optionalFields,
+				isValid: multiForm.isValid ?? {},
+				problems,
+				isSettingEnabled,
+				accountHolder,
+				legalEntityResponse
+			},
+			options: {
+				skipCompanyStructure: !!inferredCompanyStructure,
+				...options
+			}
+		});
+	}, [
+		inferredCompanyStructure,
+		accountHolder,
+		defaultForms,
+		derivedProps?.optionalFields,
+		derivedProps?.requiredFields,
+		isSettingEnabled,
+		legalEntityResponse,
+		multiForm.isValid,
+		problems
+	]);
+	const skipBusinessSelection = useSignal(true);
+	const forms = useMemo$1(() => getRequiredForms({
+		skipBusinessSelection: skipBusinessSelection.value,
+		skipCompanyStructure: !!companySearchStateModel.verifiedBusiness.value?.legalForm || !!inferredCompanyStructure
+	}), [
+		getRequiredForms,
+		skipBusinessSelection.value,
+		companySearchStateModel.verifiedBusiness.value,
+		inferredCompanyStructure
+	]);
+	const submit = useSubmitBusinessDetails({
+		country,
+		data: multiForm.data,
+		forms,
+		legalEntityResponse,
+		associatedLegalArrangement,
+		nestedLegalEntity,
+		nestedLegalEntityDetails,
+		efpBusinessLines,
+		taskType,
+		problems,
+		setProblems,
+		setLoadingStatus,
+		onExternalSubmit
+	});
+	const { handleNextClick, handleBackClick, activeForm, shouldValidate, gotoFormByFormIndex, gotoFormByFormId, steps } = useFormComposer({
+		problems,
+		forms,
+		onSubmit: useCallback$1(async () => {
+			try {
+				await submit();
+				setIsAddingBusinessDetails(false);
+			} catch (error) {
+				logger.error(error);
+			} finally {
+				setHasEnteredFormFlowBefore(true);
+			}
+		}, [logger, submit]),
+		triggerValidation: multiForm.triggerValidation
+	});
+	const tinMismatchConfirm = () => {
+		setTrustedFields([]);
+		tinMismatchModalOpen.value = false;
+		/**
+		* Only true when there are no search results.
+		*
+		* If the user is on 'Business Selection', we don't want to remove the page out from under them as
+		* nav can get a bit weird when doing so. Instead, we'll only remove it from the flow if the user is
+		* still on 'Basic Information', the only other place this modal is accessible from.
+		*/
+		skipBusinessSelection.value = activeForm.formId !== "businessSelection";
+		companySearchStateModel.confirmCompany(multiForm, country);
+		if (country === CountryCodes.UnitedStates && companySearchStateModel.verificationMatched.value === false) isTinMatched.value = false;
+		const currentForms = getRequiredForms({
+			skipBusinessSelection: skipBusinessSelection.value,
+			skipCompanyStructure: !!companySearchStateModel.verifiedBusiness.value?.legalForm
+		});
+		handleNextClick(currentForms);
+	};
+	usePrefetchCompanySearch({
+		country,
+		multiForm,
+		activeFormId: activeForm.formId,
+		isUsingCompanySearch: isUsingCompanySearch(country, taskType)
+	});
+	const { attemptBusinessSearch, confirmBusinessSelection } = useCompanySearchNextClickOverrides({
+		country,
+		multiForm,
+		companySearchStateModel,
+		getRequiredForms,
+		skipBusinessSelection,
+		setLoadingStatus,
+		isTinMatched,
+		tinMismatchModalOpen,
+		legalArrangementModalOpen,
+		registrationNumberMismatchModalOpen
+	});
+	const overrideNextClick = async () => {
+		if (!activeForm.isValid) return handleNextClick();
+		if (activeForm.formId === "basicInformation") applyInferredCompanyStructure();
+		if (!isUsingCompanySearch(country, taskType)) return handleNextClick();
+		switch (activeForm.formId) {
+			case "basicInformation": {
+				const currentForms = await attemptBusinessSearch();
+				if (currentForms === null) return;
+				return handleNextClick(currentForms);
+			}
+			case "businessSelection": {
+				const currentForms = await confirmBusinessSelection();
+				if (currentForms === null) return;
+				return handleNextClick(currentForms);
+			}
+			default: return handleNextClick();
+		}
+	};
+	const handleCancelClick = () => {
+		setIsAddingBusinessDetails(false);
+		setHasEnteredFormFlowBefore(true);
+	};
+	const handleEditForm = (formId) => {
+		if (formId === "registrationAddress" || formId === "operationalAddress") {
+			const addressFormIdx = forms.findIndex((form) => form.formId === "additionalInformation");
+			if (addressFormIdx > -1) gotoFormByFormIndex(addressFormIdx);
+			return;
+		}
+		const formIdx = forms.findIndex((form) => form.formId === formId);
+		if (formIdx > -1) gotoFormByFormIndex(formIdx);
+	};
+	const allValidationErrors = {};
+	for (const form in problems.validationErrors) for (const validationError in problems.validationErrors[form]) allValidationErrors[validationError] = problems.validationErrors[form][validationError];
+	const allVerificationErrors = {};
+	for (const form in problems.verificationErrors) for (const verificationError in problems.verificationErrors[form]) allVerificationErrors[verificationError] = problems.verificationErrors[form][verificationError];
+	const shouldAutoOpenFormForErrors = (Object.keys(allValidationErrors).length > 0 || Object.keys(allVerificationErrors).length > 0) && !hasEnteredFormFlowBefore;
+	const shouldRenderFormFlow = !isBusinessDetailsModalEnabled || isAddingBusinessDetails || shouldAutoOpenFormForErrors;
+	const summarySections = useMemo$1(() => {
+		if (activeForm.formId !== "summary") return [];
+		return formatDataForSummary(multiForm.data, forms, t, i18n.language, isFeatureEnabled);
+	}, [
+		multiForm.data,
+		forms,
+		t,
+		i18n.language,
+		isFeatureEnabled,
+		activeForm
+	]);
+	const prevDefaultSummarySections = useRef$1([]);
+	const defaultDataSummarySections = useMemo$1(() => {
+		if (shouldRenderFormFlow) return prevDefaultSummarySections.current;
+		const formattedData = formatDataForSummary(multiForm.defaultData ?? {}, forms, t, i18n.language, isFeatureEnabled);
+		prevDefaultSummarySections.current = formattedData;
+		return formattedData;
+	}, [
+		multiForm.defaultData,
+		forms,
+		t,
+		i18n.language,
+		isFeatureEnabled,
+		shouldRenderFormFlow
+	]);
+	const confirmDataSelection = async (resolvedData) => {
+		const userProvided = resolvedData.registrationNumber !== companySearchStateModel.selectedCompany.value?.registrationNumber;
+		userEvents.addPageEvent("Clicked button", {
+			actionType: "select",
+			label: "confirmCompanyConflictResolution",
+			additionalData: { selection: userProvided ? "manual" : "recommended" }
+		});
+		/**
+		* If the user is on 'Business Selection', we don't want to remove the page out from under them as
+		* nav can get a bit weird when doing so. Instead, we'll only remove it from the flow if the user is
+		* still on 'Basic Information', the only other place this modal is accessible from.
+		*/
+		skipBusinessSelection.value = activeForm.formId !== "businessSelection";
+		if (userProvided) {
+			registrationNumberMismatchModalOpen.value = false;
+			/**
+			* The user keeps their own registration number, but the rest of the provider's data
+			* (legal name, addresses, financial information) is still worth applying.
+			*
+			* The provider's company type can only be applied if it's compatible with the user's
+			* registration number — a GB charity number, for example, cannot belong to a
+			* `privateCompany`. When it isn't compatible we discard it and fall back to the company
+			* types the registration number allows: exactly one means we can infer it, otherwise the
+			* user picks it on the company structure step.
+			*/
+			const providerCompanyType = companySearchStateModel.selectedCompany.value?.companyType;
+			const resolvedCompanyType = !!providerCompanyType && availableCompanyStructures.includes(providerCompanyType) ? providerCompanyType : inferredCompanyStructure;
+			companySearchStateModel.confirmCompany(multiForm, country, {
+				preserveRegistrationNumber: true,
+				companyTypeOverride: resolvedCompanyType
+			});
+			await clearCompanyData();
+			const currentForms = getRequiredForms({
+				skipBusinessSelection: skipBusinessSelection.peek(),
+				skipCompanyStructure: !!resolvedCompanyType
+			});
+			handleNextClick(currentForms);
+		} else {
+			companySearchStateModel.confirmCompany(multiForm, country);
+			registrationNumberMismatchModalOpen.value = false;
+			const inferredRegistrationNumberType = resolvedData.registrationNumber ? inferCompanyRegistrationNumberType(resolvedData.registrationNumber, country, companySearchStateModel.verifiedBusiness.value?.companyType) : void 0;
+			const currentForms = getRequiredForms({
+				skipCompanyStructure: !!companySearchStateModel.verifiedBusiness.value?.legalForm || !!inferredRegistrationNumberType,
+				skipBusinessSelection: skipBusinessSelection.peek()
+			});
+			handleNextClick(currentForms);
+		}
+	};
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [isBusinessDetailsModalEnabled && /* @__PURE__ */ jsx(BusinessDetailsGettingStarted, {
+		openModal: () => {
+			setIsAddingBusinessDetails(true);
+			setHasEnteredFormFlowBefore(true);
+		},
+		handleCancelClick: () => handleHomeClick?.(),
+		data: defaultDataSummarySections,
+		t
+	}), shouldRenderFormFlow && /* @__PURE__ */ jsx(FormContextProvider, {
+		form: multiForm,
+		children: /* @__PURE__ */ jsx(FormFlow, {
+			summaryComponent: /* @__PURE__ */ jsxs(NewSummary, {
+				sections: summarySections,
+				handleEditForm,
+				children: [/* @__PURE__ */ jsx(ErrorPanel, {
+					validationErrors: allValidationErrors,
+					verificationErrors: allVerificationErrors,
+					formUtils: createFormUtils({ labels: {} }, t),
+					id: "ariaErrorField",
+					slot: "errorPanel"
+				}), /* @__PURE__ */ jsx("div", {
+					className: Summary_module_default.summaryContentLegalCaption,
+					slot: "extraContent",
+					children: t(($) => $["summaryLegalCaption"])
+				})]
+			}),
+			asModal: isBusinessDetailsModalEnabled,
+			currentStep: steps.current,
+			totalSteps: steps.total,
+			forms,
+			activeForm,
+			gotoFormByFormIndex,
+			gotoFormByFormId,
+			handleNextClick: overrideNextClick,
+			handleBackClick,
+			handleCancelClick: isBusinessDetailsModalEnabled ? handleCancelClick : handleHomeClick,
+			loadingStatus,
+			children: /* @__PURE__ */ jsxs(CompanySearchStateContext.Provider, {
+				value: companySearchStateModel,
+				children: [
+					/* @__PURE__ */ jsx(BusinessDetails, {
+						taskType,
+						activeForm,
+						country,
+						shouldValidate,
+						problems,
+						isTopLevelEntity: taskType === TaskTypes.BUSINESS_DETAILS
+					}),
+					/* @__PURE__ */ jsx(Show, {
+						when: tinMismatchModalOpen,
+						children: /* @__PURE__ */ jsx(TinMismatchModal, {
+							onCancel: () => tinMismatchModalOpen.value = false,
+							onConfirm: tinMismatchConfirm
+						})
+					}),
+					/* @__PURE__ */ jsx(Show, {
+						when: legalArrangementModalOpen,
+						children: /* @__PURE__ */ jsx(LegalArrangementModal, { onCancel: () => legalArrangementModalOpen.value = false })
+					}),
+					/* @__PURE__ */ jsx(Show, {
+						when: registrationNumberMismatchModalOpen,
+						children: /* @__PURE__ */ jsx(RegistrationNumberMismatchModal, {
+							companySearchStateModel,
+							registrationNumberMismatchModalOpen,
+							confirmDataSelection
+						})
+					})
+				]
+			})
+		})
+	})] });
+}
+var AdditionalInformation_module_default = {
+	"additional-information-content": "_additional-information-content_1oltc_1",
+	additionalInformationContent: "_additional-information-content_1oltc_1",
+	"additional-information-section-heading": "_additional-information-section-heading_1oltc_7",
+	additionalInformationSectionHeading: "_additional-information-section-heading_1oltc_7"
+};
+var VerifiedBusinessCard_module_default = {
+	"verified-business-card": "_verified-business-card_wxp4s_1",
+	verifiedBusinessCard: "_verified-business-card_wxp4s_1",
+	"verified-business-card-content": "_verified-business-card-content_wxp4s_9",
+	verifiedBusinessCardContent: "_verified-business-card-content_wxp4s_9",
+	"verified-business-card-content-collapsed": "_verified-business-card-content-collapsed_wxp4s_20",
+	verifiedBusinessCardContentCollapsed: "_verified-business-card-content-collapsed_wxp4s_20",
+	"verified-business-card-content-expanded": "_verified-business-card-content-expanded_wxp4s_28",
+	verifiedBusinessCardContentExpanded: "_verified-business-card-content-expanded_wxp4s_28",
+	"verified-business-card-expand-button": "_verified-business-card-expand-button_wxp4s_32",
+	verifiedBusinessCardExpandButton: "_verified-business-card-expand-button_wxp4s_32"
+};
+//#endregion
+//#region src/components/Business/forms/AdditionalInformation/VerifiedBusinessCard/VerifiedBusinessCard.tsx
+function VerifiedBusinessCard({ verifiedBusiness, verifiedAddress }) {
+	const { t } = useTranslation(["common"]);
+	const [expanded, setExpanded] = useState$1(false);
+	const address = verifiedAddress?.street && verifiedAddress.city && verifiedAddress.stateOrProvince && verifiedAddress.postalCode ? `${verifiedAddress.street} ${verifiedAddress.city} ${verifiedAddress.stateOrProvince} ${verifiedAddress.postalCode}` : verifiedAddress?.street;
+	const addressLink = `https://www.google.com/maps/place/${address?.replaceAll(" ", "+")}`;
+	const baseItems = useMemo$1(() => [{
+		term: t(($) => $["legalCompanyName"], { ns: "common" }),
+		details: verifiedBusiness?.name
+	}, {
+		term: t(($) => $["registrationNumber"], { ns: "common" }),
+		details: verifiedBusiness?.registrationNumber
+	}].filter((item) => !!item.details), [
+		verifiedBusiness?.name,
+		verifiedBusiness?.registrationNumber,
+		t
+	]);
+	const expandedItems = useMemo$1(() => [{
+		term: t(($) => $["legalForm"], { ns: "common" }),
+		details: verifiedBusiness?.legalForm
+	}, {
+		term: t(($) => $["address"], { ns: "common" }),
+		details: address && /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			address,
+			/* @__PURE__ */ jsx("br", {}),
+			/* @__PURE__ */ jsx(Link, {
+				href: addressLink,
+				external: true,
+				children: t(($) => $["showOnMap"], { ns: "common" })
+			})
+		] })
+	}].filter((item) => !!item.details), [
+		address,
+		addressLink,
+		t,
+		verifiedBusiness?.legalForm
+	]);
+	const expandedContentClasses = cx(VerifiedBusinessCard_module_default.verifiedBusinessCardContent, {
+		[VerifiedBusinessCard_module_default.verifiedBusinessCardContentCollapsed]: !expanded,
+		[VerifiedBusinessCard_module_default.verifiedBusinessCardContentExpanded]: expanded
+	});
+	return /* @__PURE__ */ jsxs("section", {
+		className: VerifiedBusinessCard_module_default.verifiedBusinessCard,
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: VerifiedBusinessCard_module_default.verifiedBusinessCardContent,
+				children: [/* @__PURE__ */ jsx(StructuredList, { items: baseItems }), /* @__PURE__ */ jsx(Divider, {})]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: expandedContentClasses,
+				children: [/* @__PURE__ */ jsx(StructuredList, { items: expandedItems }), /* @__PURE__ */ jsx(Divider, {})]
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: VerifiedBusinessCard_module_default.verifiedBusinessCardExpandButton,
+				children: /* @__PURE__ */ jsx(Button, {
+					variant: "link",
+					onClick: () => setExpanded(!expanded),
+					children: expanded ? t(($) => $["hideDetails"], { ns: "common" }) : t(($) => $["showDetails"], { ns: "common" })
+				})
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/Business/forms/AdditionalInformation/AdditionalInformation.tsx
+var ADDITIONAL_INFORMATION_FIELDS = [
+	...DBA_NAME_FIELD,
+	...VAT_NUMBER_FIELD,
+	...LEGAL_ENTITY_IDENTIFIER_FIELD,
+	...INDUSTRY_CODE_FIELD,
+	...DATE_OF_INCORPORATION_FIELD,
+	...STOCK_EXCHANGE_MIC_FIELD,
+	...STOCK_ISIN_FIELD,
+	...STOCK_TICKER_SYMBOL_FIELD,
+	...EINVOICING_CODE_FIELD,
+	"legalFormDescription",
+	"residentialAddressIndicator",
+	...LEGAL_FORM_FIELDS,
+	...REGISTRATION_AND_OPERATIONAL_ADDRESS_FIELDS
+];
+var EMPTY_OBJ = {};
+function AdditionalInformation({ id, country, companyType, shouldValidate, fieldValidationErrors = EMPTY_OBJ, formVerificationErrors = EMPTY_OBJ }) {
+	const { t, i18n } = useTranslation(["common", "business"]);
+	const { form } = useFormContext();
+	const verifiedBusiness = useContext$1(CompanySearchStateContext).verifiedBusiness.value;
+	const showVerified = !!verifiedBusiness;
+	const showStockData = companyType === "listedPublicCompany";
+	const { data: matchingScenario } = useScenarios(country, "organization");
+	const businessLineTypes = [];
+	if (matchingScenario?.includes("L_BANKING")) businessLineTypes.push("banking");
+	if (matchingScenario?.includes("L_ISSUING")) businessLineTypes.push("issuing");
+	const { data, defaultData, valid, errors, allFields, requiredFields, optionalFields, obscuredFields, trustedFields, handleChange: handleChangeFor } = getFormSlice(form, "additionalInformation");
+	/**
+	* Map the existing verified address data returned from the business data provider to our local address schema.
+	* This must be done differently than the other verified data as the address
+	* component maintains its own local form state.
+	*/
+	const verifiedAddress = useMemo$1(() => {
+		if (!verifiedBusiness) return void 0;
+		if (defaultData?.registrationAddressStreet || defaultData?.operationalAddressStreet) return { override: { street: "" } };
+		return {
+			...verifiedBusiness.registeredAddress && { registrationAddress: mapAddressData(verifiedBusiness.registeredAddress) },
+			...verifiedBusiness.principalPlaceOfBusinessAddress && { operationalAddress: mapAddressData(verifiedBusiness.principalPlaceOfBusinessAddress) }
+		};
+	}, [
+		verifiedBusiness,
+		defaultData?.registrationAddressStreet,
+		defaultData?.operationalAddressStreet
+	]);
+	const formUtils = useMemo$1(() => {
+		const initialProps = {
+			data: data ?? {},
+			fieldValidationErrors,
+			formVerificationErrors,
+			allFields: allFields ?? [],
+			requiredFields: requiredFields ?? [],
+			optionalFields: optionalFields ?? [],
+			trustedFields: trustedFields ?? [],
+			obscuredFields: obscuredFields ?? [],
+			errors: errors ?? {},
+			valid: valid ?? {},
+			handleFieldChange: handleChangeFor
+		};
+		const formUtilProps = initialProps.allFields?.reduce((acc, field) => {
+			switch (field) {
+				case "hasDoingBusinessAs": return mergeFieldMetadataIntoProps("hasDoingBusinessAs", doingBusinessAsAbsentFieldMetadata, acc);
+				case "doingBusinessAs": return mergeFieldMetadataIntoProps("doingBusinessAs", doingBusinessAsFieldMetadata, acc);
+				case "vatNumber": return mergeFieldMetadataIntoProps(field, resolveFieldMetadata(defaultFieldConfig$1[country], { vatNumberType: data?.vatNumberType }, defaultFieldMetadata$1), acc);
+				case "vatAbsenceReason": return mergeFieldMetadataIntoProps("vatAbsenceReason", vatAbsenceReasonMetadata, acc);
+				case "eInvoicingCode": return mergeFieldMetadataIntoProps("eInvoicingCode", eInvoicingCodeFieldMetadata, acc);
+				case "industryCodes": return mergeFieldMetadataIntoProps("industryCodes", industryCodeFieldMetadata, acc);
+				case "dateOfIncorporation": return mergeFieldMetadataIntoProps("dateOfIncorporation", dateOfIncorporationFieldMetadata, acc);
+				case "stockExchangeMIC": return mergeFieldMetadataIntoProps("stockExchangeMIC", stockExchangeMICFieldMetadata, acc);
+				case "stockISIN": return mergeFieldMetadataIntoProps("stockISIN", stockISINFieldMetadata, acc);
+				case "stockTickerSymbol": return mergeFieldMetadataIntoProps("stockTickerSymbol", stockTickerSymbolFieldMetadata, acc);
+				case "legalForm": return mergeFieldMetadataIntoProps("legalForm", legalFormFieldMetadata, acc);
+				default: return acc;
+			}
+		}, initialProps);
+		return createFormUtils(formUtilProps ?? initialProps, t);
+	}, [
+		country,
+		allFields,
+		data,
+		errors,
+		obscuredFields,
+		optionalFields,
+		requiredFields,
+		trustedFields,
+		valid,
+		handleChangeFor,
+		t,
+		fieldValidationErrors,
+		formVerificationErrors
+	]);
+	const showField = (fieldKeys) => fieldKeys.some((field) => formUtils.isRequiredField(field) || formUtils.isOptionalField(field));
+	const { data: industryCodes } = useIndustryCodes(businessLineTypes, i18n.language, { enabled: showField(INDUSTRY_CODE_FIELD) });
+	return /* @__PURE__ */ jsxs("form", {
+		id,
+		children: [
+			/* @__PURE__ */ jsx(Header, { title: t(($) => $["additionalInformationFormHeading"], { ns: "business" }) }),
+			/* @__PURE__ */ jsx(ErrorPanel, {
+				id: "ariaErrorField",
+				verificationErrors: formVerificationErrors,
+				validationErrors: fieldValidationErrors,
+				formUtils
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: AdditionalInformation_module_default.additionalInformationContent,
+				children: [
+					showVerified && /* @__PURE__ */ jsxs("section", { children: [/* @__PURE__ */ jsx("div", {
+						className: AdditionalInformation_module_default.additionalInformationSectionHeading,
+						children: /* @__PURE__ */ jsx(Typography, {
+							el: "h3",
+							variant: "title",
+							children: t(($) => $["verifiedInformation"], { ns: "business" })
+						})
+					}), /* @__PURE__ */ jsx(VerifiedBusinessCard, {
+						verifiedBusiness,
+						verifiedAddress: verifiedAddress?.override ?? verifiedAddress?.registrationAddress ?? verifiedAddress?.operationalAddress
+					})] }),
+					/* @__PURE__ */ jsxs("section", { children: [showVerified && /* @__PURE__ */ jsx("div", {
+						className: AdditionalInformation_module_default.additionalInformationSectionHeading,
+						children: /* @__PURE__ */ jsx(Typography, {
+							el: "h3",
+							variant: "title",
+							children: t(($) => $["otherBusinessInformation"], { ns: "business" })
+						})
+					}), /* @__PURE__ */ jsxs("fieldset", { children: [
+						showField(LEGAL_FORM_FIELDS) && /* @__PURE__ */ jsx(LegalFormField, {
+							name: "legalForm",
+							countryCode: country,
+							data: { legalForm: formUtils.getFieldData(data ?? {}, LEGAL_FORM_FIELDS).legalForm },
+							valid: formUtils.getFieldValid(valid ?? {}, LEGAL_FORM_FIELDS),
+							errorMessage: formatValidationError(errors?.legalForm?.errorMessage, t),
+							handleChangeFor,
+							readonly: false,
+							label: formUtils.getLabel("legalForm", "businessStructure")
+						}),
+						showField(DBA_NAME_FIELD) && /* @__PURE__ */ jsx(DBANameField, {
+							data: formUtils.getFieldData(data ?? {}, DBA_NAME_FIELD),
+							valid: formUtils.getFieldValid(valid ?? {}, DBA_NAME_FIELD),
+							errors: formUtils.getFieldErrors(errors ?? {}, fieldValidationErrors, DBA_NAME_FIELD),
+							readonly: formUtils.isReadOnly("doingBusinessAs"),
+							handleChangeFor
+						}),
+						showField(VAT_NUMBER_FIELD) && /* @__PURE__ */ jsx(VatNumberField, {
+							data: formUtils.getFieldData(data ?? {}, VAT_NUMBER_FIELD),
+							valid: formUtils.getFieldValid(valid ?? {}, VAT_NUMBER_FIELD),
+							errors: formUtils.getFieldErrors(errors ?? {}, fieldValidationErrors, VAT_NUMBER_FIELD),
+							labels: formUtils.getFieldLabels(VAT_NUMBER_FIELD, { exemptedFromVat: "iDontHaveAVatNumber" }),
+							mask: formUtils.getMask("vatNumber"),
+							readonly: formUtils.isReadOnly("vatNumber"),
+							handleChangeFor,
+							country,
+							canExempt: showField(["exemptedFromVat"]),
+							shouldValidate
+						}),
+						showField(LEGAL_ENTITY_IDENTIFIER_FIELD) && /* @__PURE__ */ jsx(LegalEntityIdentifierField, {
+							data: formUtils.getFieldData(data ?? {}, LEGAL_ENTITY_IDENTIFIER_FIELD),
+							valid: formUtils.getFieldValid(valid ?? {}, LEGAL_ENTITY_IDENTIFIER_FIELD),
+							errors: formUtils.getFieldErrors(errors ?? {}, fieldValidationErrors, LEGAL_ENTITY_IDENTIFIER_FIELD),
+							handleChangeFor,
+							shouldValidate
+						}),
+						formUtils.isRequiredField("eInvoicingCode", false) && /* @__PURE__ */ jsx(EInvoicingCodeField, {
+							data: formUtils.getFieldData(data ?? {}, EINVOICING_CODE_FIELD),
+							valid: formUtils.getFieldValid(valid ?? {}, EINVOICING_CODE_FIELD),
+							errors: formUtils.getFieldErrors(errors ?? {}, fieldValidationErrors, EINVOICING_CODE_FIELD),
+							labels: formUtils.getFieldLabels(EINVOICING_CODE_FIELD),
+							mask: formUtils.getMask("eInvoicingCode"),
+							readonly: formUtils.isReadOnly("eInvoicingCode"),
+							handleChangeFor
+						}),
+						showField(INDUSTRY_CODE_FIELD) && /* @__PURE__ */ jsx(IndustryCodeField, {
+							data: formUtils.getFieldData(data ?? {}, INDUSTRY_CODE_FIELD),
+							valid: formUtils.getFieldValid(valid ?? {}, INDUSTRY_CODE_FIELD),
+							errors: formUtils.getFieldErrors(errors ?? {}, fieldValidationErrors, INDUSTRY_CODE_FIELD),
+							guidanceText: t(($) => $["primaryIndustryCodeGuidance"], { ns: "business" }),
+							readonly: formUtils.isReadOnly("industryCodes"),
+							handleChangeFor,
+							businessLineTypes,
+							single: true,
+							industryCodes: industryCodes ?? []
+						}),
+						showField(DATE_OF_INCORPORATION_FIELD) && /* @__PURE__ */ jsx(DateOfIncorporationField, {
+							data: formUtils.getFieldData(data ?? {}, DATE_OF_INCORPORATION_FIELD),
+							valid: formUtils.getFieldValid(valid ?? {}, DATE_OF_INCORPORATION_FIELD),
+							errors: formUtils.getFieldErrors(errors ?? {}, fieldValidationErrors, DATE_OF_INCORPORATION_FIELD),
+							placeholder: t(($) => $["datePlaceholder"]),
+							readonly: formUtils.isReadOnly("dateOfIncorporation"),
+							handleChangeFor,
+							country
+						})
+					] })] }),
+					showStockData && /* @__PURE__ */ jsxs("section", { children: [/* @__PURE__ */ jsx("div", {
+						className: AdditionalInformation_module_default.additionalInformationSectionHeading,
+						children: /* @__PURE__ */ jsx(Typography, {
+							el: "h3",
+							variant: "title",
+							children: t(($) => $["stockExchangeInformation"], { ns: "business" })
+						})
+					}), /* @__PURE__ */ jsxs("fieldset", { children: [
+						showField(STOCK_EXCHANGE_MIC_FIELD) && /* @__PURE__ */ jsx(StockExchangeMICField, {
+							data: formUtils.getFieldData(data ?? {}, STOCK_EXCHANGE_MIC_FIELD),
+							valid: formUtils.getFieldValid(valid ?? {}, STOCK_EXCHANGE_MIC_FIELD),
+							errors: formUtils.getFieldErrors(errors ?? {}, fieldValidationErrors, STOCK_EXCHANGE_MIC_FIELD),
+							mask: formUtils.getMask("stockExchangeMIC"),
+							readonly: formUtils.isReadOnly("stockExchangeMIC"),
+							shouldValidate,
+							handleChangeFor
+						}),
+						showField(STOCK_ISIN_FIELD) && /* @__PURE__ */ jsx(StockISINField, {
+							data: formUtils.getFieldData(data ?? {}, STOCK_ISIN_FIELD),
+							valid: formUtils.getFieldValid(valid ?? {}, STOCK_ISIN_FIELD),
+							errors: formUtils.getFieldErrors(errors ?? {}, fieldValidationErrors, STOCK_ISIN_FIELD),
+							mask: formUtils.getMask("stockISIN"),
+							readonly: formUtils.isReadOnly("stockISIN"),
+							shouldValidate,
+							handleChangeFor
+						}),
+						showField(STOCK_TICKER_SYMBOL_FIELD) && /* @__PURE__ */ jsx(StockTickerSymbolField, {
+							data: formUtils.getFieldData(data ?? {}, STOCK_TICKER_SYMBOL_FIELD),
+							valid: formUtils.getFieldValid(valid ?? {}, STOCK_TICKER_SYMBOL_FIELD),
+							errors: formUtils.getFieldErrors(errors ?? {}, fieldValidationErrors, STOCK_TICKER_SYMBOL_FIELD),
+							mask: formUtils.getMask("stockTickerSymbol"),
+							readonly: formUtils.isReadOnly("stockTickerSymbol"),
+							shouldValidate,
+							handleChangeFor
+						})
+					] })] }),
+					/* @__PURE__ */ jsx(RegistrationAndOperationalAddressFields, {
+						country,
+						readOnlyAddressFields: verifiedBusiness?.registeredAddress?.state && verifiedBusiness.registeredAddress.state === form.data.basicInformation?.stateOrProvince ? ["stateOrProvince"] : [],
+						entityType: "business",
+						data,
+						valid,
+						errors,
+						requiredFields,
+						optionalFields,
+						trustedFields,
+						fieldValidationErrors,
+						handleChangeFor,
+						formUtils
+					})
+				]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/Business/forms/BusinessDetails/forms.ts
+var getFinancialInformationFields = (country) => {
+	return country === CountryCodes.UnitedKingdom ? financialInformationFields : financialInformationFieldsForEu;
+};
+var staticBusinessDetailsForms = {
+	basicInformation: {
+		formId: "basicInformation",
+		formName: "basicInformationFormName",
+		fields: BASIC_INFORMATION_FIELDS
+	},
+	businessSelection: {
+		formId: "businessSelection",
+		formName: "businessSelectionFormName",
+		fields: BUSINESS_SELECTION_FIELDS
+	},
+	companyStructure: {
+		formId: "companyStructure",
+		formName: "companyStructureFormName",
+		fields: COMPANY_STRUCTURE_FIELDS
+	},
+	additionalInformation: {
+		formId: "additionalInformation",
+		formName: "additionalInformationFormName",
+		fields: ADDITIONAL_INFORMATION_FIELDS
+	},
+	companyRegistrationDocument: {
+		formId: "companyRegistrationDocument",
+		formName: "companyRegistrationDocumentFormName",
+		fields: ["registrationDocument"]
+	},
+	companyTaxDocument: {
+		formId: "companyTaxDocument",
+		formName: "companyTaxDocumentFormName",
+		fields: ["taxDocument"]
+	},
+	companyProofOfDirectorDocument: {
+		formId: "companyProofOfDirectorDocument",
+		formName: "proofOfDirectorFormName",
+		fields: ["proofOfDirector"]
+	},
+	companyProofOfSignatoryDocument: {
+		formId: "companyProofOfSignatoryDocument",
+		formName: "proofOfSignatoryFormName",
+		fields: ["proofOfSignatory"]
+	},
+	companyProofOfAddressDocument: {
+		formId: "companyProofOfAddressDocument",
+		formName: "proofOfAddressFormName",
+		fields: ["proofOfAddress"]
+	},
+	companyProofOfOwnershipDocument: {
+		formId: "companyProofOfOwnershipDocument",
+		formName: "proofOfOwnershipFormName",
+		fields: ["proofOfOwnership"]
+	},
+	companyConstitutionalDocument: {
+		formId: "companyConstitutionalDocument",
+		formName: "constitutionalDocumentFormName",
+		fields: ["constitutionalDocument"]
+	}
+};
+var getForms = (country) => ({
+	basicInformation: staticBusinessDetailsForms.basicInformation,
+	businessSelection: staticBusinessDetailsForms.businessSelection,
+	companyStructure: staticBusinessDetailsForms.companyStructure,
+	additionalInformation: staticBusinessDetailsForms.additionalInformation,
+	companyRegistrationDocument: staticBusinessDetailsForms.companyRegistrationDocument,
+	companyTaxDocument: staticBusinessDetailsForms.companyTaxDocument,
+	companyProofOfDirectorDocument: staticBusinessDetailsForms.companyProofOfDirectorDocument,
+	companyProofOfSignatoryDocument: staticBusinessDetailsForms.companyProofOfSignatoryDocument,
+	companyProofOfAddressDocument: staticBusinessDetailsForms.companyProofOfAddressDocument,
+	companyProofOfOwnershipDocument: staticBusinessDetailsForms.companyProofOfOwnershipDocument,
+	companyFinancialInformation: {
+		formId: "companyFinancialInformation",
+		formName: "financialInformation",
+		fields: getFinancialInformationFields(country)
+	},
+	companyConstitutionalDocument: staticBusinessDetailsForms.companyConstitutionalDocument
+});
+var documentFormsIds = [
+	"companyRegistrationDocument",
+	"companyTaxDocument",
+	"companyProofOfDirectorDocument",
+	"companyProofOfSignatoryDocument",
+	"companyProofOfAddressDocument",
+	"companyConstitutionalDocument",
+	"companyProofOfOwnershipDocument"
+];
+//#endregion
+//#region src/api/documents/useDocuments.ts
+var useDocuments = (documentDetails, entityId, options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	const documentUtils = documentApiUtils({
+		baseUrl: baseUrl.value,
+		rootLegalEntityId: rootLegalEntityId.value
+	});
+	return useQuery({
+		queryKey: [
+			"documents",
+			documentDetails.map((details) => details.id).filter((id) => id !== void 0).sort((a, b) => a.localeCompare(b)).join(","),
+			entityId
+		],
+		queryFn: () => documentUtils.fetchDocuments(documentDetails, entityId),
+		retry: 0,
+		...options
+	});
+};
+//#endregion
+//#region src/components/Business/hooks/useBusinessDetailsData.ts
+var ALLOWED_SOF_SERVICES = ["issuing", "banking"];
+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 subjectEntity = !(taskType !== TaskTypes.BUSINESS_DETAILS) ? rootLe : isSoleProp ? associatedLegalArrangement : nestedLegalEntity;
+	const { isLoading: fetchingDocuments, isError } = useDocuments(subjectEntity?.documentDetails || [], subjectEntity?.id || "", { enabled: subjectEntity?.documentDetails && subjectEntity.documentDetails.length > 0 });
+	useEffect$1(() => {
+		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
+	};
+}
+//#endregion
+export { getForms as n, BusinessDetailsDropin as r, useBusinessDetailsData as t };