@adyen/kyc-components 4.13.0 → 4.14.0-beta.0

package/dist/useBusinessDetailsData-BDxT0mFG.js

@@ -0,0 +1,4647 @@
+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] = "73290c1d-d3cb-4985-9a4d-94f852f50509", e._sentryDebugIdIdentifier = "sentry-dbid-73290c1d-d3cb-4985-9a4d-94f852f50509");
+} catch (e) {}
+import { i as Typography, o as createLogger, r as useTranslation } from "./translation-ZXpd9jdD.js";
+import { E as useAllowedCountries, T as datasetUtilities, at as isUndefinedOrNull, ft as useAccountHolder, j as useToggleContext, k as Header, nt as isEmpty, rt as isISIN, x as Alert } from "./resolveEnvironment-Doi5jM7g.js";
+import { r as Loader, t as Button } from "./Button-DBN5gM_d.js";
+import { r as httpPost, s as useApiContext } from "./http-DYzfwjcs.js";
+import { r as useLegalEntity, t as ROOT_LE } from "./useLegalEntity-EN5ubX2H.js";
+import { t as LegalEntityTypes } from "./legal-entity-type-0MfCGzUf.js";
+import { t as useSettingsContext } from "./useSettingsContext-Bpf4UqRT.js";
+import { c as entriesOf, i as drop, l as keysOf, o as objectsDeepEqual, r as doArraysMatch } from "./AnalyticsContext-BFrJmsp0.js";
+import { t as StackLayout } from "./StackLayout-IUdNMDgW.js";
+import { t as TaskVerificationStatus } from "./TaskVerificationStatus-gGr34dp5.js";
+import { n as TASK_STATUS_POLLING_INTERVAL_MS } from "./taskStatus-BtekPA8E.js";
+import { t as CountryCodes } from "./country-code-CJk2hdPu.js";
+import { _ as businessDetailsDocumentMapping, f as solePropBusinessDetailsApiKeyMapping, g as businessDetailsComponentsKeyMapping, h as businessDetailsApiKeyMapping, m as solePropBusinessDetailsKeyMapping, p as solePropBusinessDetailsDocumentMapping } from "./processCapabilities-hLmRus8U.js";
+import { t as TaskTypes } from "./taskTypes-NawDTp5n.js";
+import { r as filterOutUnwantedAssociationsIfRootLE, s as getOwnEntityAssociations } from "./entityAssociationUtil-C-wflW8q.js";
+import { t as Scenarios } from "./get-scenarios-Bb-paHmJ.js";
+import { t as useBusinessLines } from "./useBusinessLines-Dshc0pYD.js";
+import { t as Card } from "./Card-BCGLpdw7.js";
+import { i as useAnalyticsContext, n as ModalContent, r as KEYBOARD_KEYS, t as Modal } from "./Modal-BgeE7zM2.js";
+import { t as SettingNames } from "./types-Cwq1JAWT.js";
+import { n as useToastContext, t as useInvalidateRootLegalEntity } from "./invalidateRootLegalEntity-B_H-aJ0s.js";
+import { c as CompanyTypesValues } from "./bafinUtils-BKq-s1Ka.js";
+import { r as LoaderWrapper } from "./utils-DcUoR5qG.js";
+import { t as Confirm } from "./Confirm-C4GotFqm.js";
+import { t as HandlerContext } from "./HandlerContext-DeMa68z0.js";
+import { t as useScenarios } from "./useScenarios-ful0VqQ4.js";
+import { t as useCreateLegalEntity } from "./useCreateLegalEntity-38twl3gB.js";
+import { t as useUpdateLegalEntity } from "./useUpdateLegalEntity-DnkFwUCD.js";
+import { a as defaultFieldMetadata, i as defaultFieldConfig, l as formatAddressForCleanse, n as STATE_FIELD, r as StateField, t as Address, u as useAddressCleanse } from "./Address-D5zWC8Kk.js";
+import { i as FormFlow, n as addValidityToForms, o as useFormComposer, s as FormContextProvider, t as useFormContext } from "./useFormContext-CyhnFPOt.js";
+import { n as composePerScenarioFormConfigurations, r as getPropsFromConfigurations } from "./process-field-configurations-U459c7bG.js";
+import { t as StructuredList } from "./StructuredList-CUyo9-3i.js";
+import { t as ErrorPanel } from "./ErrorPanel-ct3r_pLg.js";
+import { n as mergeFieldMetadataIntoProps, t as createFormUtils } from "./formUtils-DVc3a6gf.js";
+import { n as summaryStep, r as Summary_module_default } from "./Summary-DdatuZ77.js";
+import { t as useMultiForm } from "./useMultiForm-NwELDSnm.js";
+import { i as useScenarioConfiguration, r as getPageName, t as mapExistingFile } from "./mapExistingFile-CZB9JLAV.js";
+import { t as useTaskLandedEvent } from "./useTaskLandedEvent-CtlV_Bum.js";
+import { a as alphanumericInputs, i as alphaInputs, l as numericInputs, s as makeMask, t as MaskedInput } from "./MaskedInput-C_rP9ADy.js";
+import { i as mapJpAddressSummaryNewSummary, n as toFullWidth, t as mapJpAddressSchemaToAddressLocalizations } from "./mapJpAddressSchemaToAddressLocalizations-DUElzaoS.js";
+import { i as COUNTRIES_WITH_STATES_DATASET } from "./constants-DrtMSDfx.js";
+import { a as mapAddressLabelsNewSummary, n as getAddressSchemaLabelsByCountry, r as getKeyForField, t as getAddressSchemaForCountry } from "./utils-BgdkZkf5.js";
+import { i as isValidationError, n as isBusinessSelectionLegalArrangementError, o as processValidationErrors, s as isMaintenanceModeError } from "./validationError-tIm9Zzjt.js";
+import { c as getDocument, l as getDocuments, o as createDocumentRequest, p as mergeProofOfOwnershipAttachments, s as documentApiUtils, u as getFileExtention } from "./validate-j0h8oux2.js";
+import { r as formatObject } from "./utils-DdHbAadK.js";
+import { a as getFieldsWithExistingData, n as TaxInformationField, r as MemoizedDocumentUpload, t as TAX_INFORMATION_FIELD } from "./TaxInformationField-C5s9CTSB.js";
+import { t as isJapanLocalizationEnabled } from "./japanSupportUtils-H5Zfox2v.js";
+import { t as uppercase } from "./uppercase-DvjwUM0n.js";
+import { a as validateNotEmptyOnBlur, n as validateJaKanaLegalCompanyName, o as validatePatternOnBlur, t as validateJaHaniLegalCompanyName } from "./patternValidators-DWouiOVO.js";
+import { C as taxInformationDefaultFieldConfig, S as getTaxInformationPlaceholderText, _ as getTaxIdNumberOptions, c as isUsingCompanySearch, d as isRegistrationExemptionAllowed, f as countryToTaxInfoTypeMap, h as requestingIssuing, i as COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT, l as rules, m as requestingBanking, o as COUNTRY_OF_GOVERNING_LAW_POSSIBLE, p as getCountryOfGoverningLaw, s as isRegistrationNumberAbsentStateV4Scenario, u as REGISTRATION_NUMBER_EXEMPTION_RULES, v as getValidCompanyTypesForTaxIdNumberType, w as taxInformationDefaultFieldMetadata } from "./utils-B6a1FGxD.js";
+import { t as resolveFieldMetadata } from "./fieldConfigurations-CZCFghnK.js";
+import { t as Field } from "./Field-CQWAWo5U.js";
+import { t as TileGroup } from "./TileGroup-B7-q4NXH.js";
+import { t as LandingLayout } from "./LandingLayout-Dg0sEASR.js";
+import { r as useDebouncedCallback } from "./debouncedInputEvent-D2-Kctv9.js";
+import { t as Checkbox } from "./Checkbox-tUvgt59R.js";
+import { n as convertFullToHalf } from "./TextArea-C2DkQ41s.js";
+import { t as Link } from "./Link-DtaYQWb-.js";
+import { t as InputText } from "./InputText-8abfNtHh.js";
+import { n as formatDateObj, t as InputDate } from "./InputDate-cTgjAhzm.js";
+import { n as CountryField, t as COUNTRY_FIELD } from "./CountryField-zsA_yVzc.js";
+import { t as RadioGroup } from "./RadioGroup-DlzXLoMN.js";
+import { n as isDateOlderThanAYear, r as mapAddressData, t as getNestedTrustedFields } from "./utils-K8Z-zRnu.js";
+import { t as isEmpty$1 } from "./isEmpty-BVlBH98t.js";
+import { n as mapApiScriptLocalizationToSchemaFields, r as mapSchemaFieldsToApiScriptLocalization, t as mapAddressLocalizationToJpAddressSchema } from "./mapAddressLocalizationToJpAddressSchema-CBeBTFmC.js";
+import { t as currencyByCountry } from "./types-Bvp3aTbC.js";
+import { t as Divider } from "./Divider-BENvVRnz.js";
+import { t as DetailViewLayout } from "./DetailViewLayout-DNCGEd7b.js";
+import { a as LegalFormField, i as InputCurrency, n as Currency, o as mapFinancialReportsToFinancialInformation, r as InputNumber, s as mapFinancialInformationToFinancialReport, t as CURRENCY_FIELD } from "./Currency-C2HN8hvK.js";
+import { n as SummarySection, t as NewSummary } from "./NewSummary-DnJjib28.js";
+import { t as useTaskStatus } from "./useTaskStatus-CLcXCIz7.js";
+import { t as ListItem } from "./ListItem-CZWSCEeJ.js";
+import { a as getValidCompanyTypesForRegistrationNumberType, c as getRegistrationNumberHelperText, i as getCompanyRegistrationNumberOptions, l as registrationNumberDefaultFieldConfig, n as getDefaultRegistrationNumberType, r as inferCompanyRegistrationNumberType, s as exemptFromRegistrationNumberDefaultFieldMetadata, u as registrationNumberDefaultFieldMetadata } from "./CompanyRegistrationNumberTypeSelector-BF5XC5w0.js";
+import { n as useCreateBusinessLine, r as useIndustryCodes, t as useUpdateBusinessLine } from "./useUpdateBusinessLines-BRxlqBnM.js";
+import { n as formatCurrency } from "./formatCurrency-Cq3WFpdZ.js";
+import { a as VAT_NUMBER_FIELD, c as defaultFieldConfig$1, d as doingBusinessAsAbsentFieldMetadata, f as doingBusinessAsFieldMetadata, g as BusinessRegistrationNumberField, h as BUSINESS_REGISTRATION_NUMBER_FIELD, l as defaultFieldMetadata$1, m as DBA_NAME_FIELD, n as registrationAddressFields, o as VatNumberField, p as DBANameField, r as operationalAddressIsSameIds, s as getDefaultVatNumberType, t as MemoizedConstitutionalDocument, u as vatAbsenceReasonMetadata } from "./ConstitutionalDocument-C7TXcsUK.js";
+import { f as industryCodeFieldMetadata, l as IndustryCodeField, t as INDUSTRY_CODE_FIELD } from "./constants-CQUBFYB0.js";
+import { a as defaultFieldMetadata$2, i as defaultFieldConfigV4, o as defaultFieldMetadataV4, r as defaultFieldConfig$2, s as getLegalCompanyNameGuidanceText, t as LEGAL_COMPANY_NAME_FIELD } from "./LegalCompanyNameField-LcnS0m3Z.js";
+import { s as organizationTypesToSkipCompanyStructureForm } from "./utils-iXMYP5kO.js";
+import { Suspense, 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/DateOfIncorporationField/DateOfIncorporationField.tsx
+var DATE_OF_INCORPORATION_FIELD = ["dateOfIncorporation"];
+function DateOfIncorporationField({ data, valid, errors, placeholder, readonly, handleChangeFor }) {
+	const { t } = useTranslation("common");
+	return /* @__PURE__ */ jsx(Field, {
+		name: "dateOfIncorporation",
+		label: t(($) => $["dateOfIncorporation"]),
+		errorMessage: errors.dateOfIncorporation,
+		isValid: valid.dateOfIncorporation,
+		children: (childProps) => /* @__PURE__ */ jsx(InputDate, {
+			...childProps,
+			"aria-required": true,
+			"aria-invalid": !valid.dateOfIncorporation,
+			name: "dateOfIncorporation",
+			value: data.dateOfIncorporation,
+			placeholder,
+			readonly,
+			onInput: handleChangeFor("dateOfIncorporation", "input"),
+			onBlur: handleChangeFor("dateOfIncorporation", "blur"),
+			max: formatDateObj(/* @__PURE__ */ new Date()),
+			min: formatDateObj(new Date(1900, 0, 1))
+		})
+	});
+}
+//#endregion
+//#region src/components/Shared/fields/DateOfIncorporationField/fieldConfig.ts
+var validateDateOfIncorporation = (dateOfIncorporation) => {
+	if (!dateOfIncorporation) return false;
+	const date = new Date(dateOfIncorporation);
+	return date < /* @__PURE__ */ new Date() && date > new Date(1900, 0, 1);
+};
+var dateOfIncorporationFieldMetadata = { validators: [validateNotEmptyOnBlur, {
+	modes: ["blur"],
+	validate: validateDateOfIncorporation,
+	errorMessage: "invalidDateOfIncorporation"
+}] };
+//#endregion
+//#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
+	}
+};
+//#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/utils/useDebouncedState.ts
+/**
+* Like {@link useState}, but waits for the given amount of time before applying *only* the most recent update.
+*
+* @param wait the time to wait, in milliseconds
+* @param initialState (optional) the default value
+*/
+function useDebouncedState(wait, initialState) {
+	const [state, _setState] = useState$1(initialState);
+	return [state, useDebouncedCallback(_setState, wait)];
+}
+//#endregion
+//#region src/components/EFP/fields/LegalFormField/types.ts
+var LEGAL_FORM_FIELDS = ["legalForm", "legalFormLabel"];
+var legalFormFieldMetadata = {
+	label: "legalForm",
+	validators: [validateNotEmptyOnBlur]
+};
+//#endregion
+//#region src/context/handlerContext/useHandlerContext.ts
+function useHandlerContext() {
+	return useContext$1(HandlerContext);
+}
+//#endregion
+//#region src/components/Shared/fields/LocalizedLegalCompanyNameField/types.ts
+var JAPANESE_LEGAL_COMPANY_NAME_FIELDS = ["jaHaniLegalCompanyName", "jaKanaLegalCompanyName"];
+//#endregion
+//#region src/hooks/useLegalCompanyNameField/useLegalCompanyNameField.ts
+function useLegalCompanyNameField({ data, valid, errors, fieldProblems, country, formUtils, handleChange, t }) {
+	const { isFeatureEnabled } = useToggleContext();
+	const fieldKeys = getFieldKeys(isFeatureEnabled, country);
+	const labels = formUtils.getFieldLabels(fieldKeys);
+	const fieldErrors = formUtils.getFieldErrors(errors, fieldProblems, fieldKeys);
+	const fieldsTransformInput = {
+		jaHaniLegalCompanyName: toFullWidth,
+		jaKanaLegalCompanyName: toFullWidth,
+		legalCompanyName: convertFullToHalf
+	};
+	const fieldsTransformMode = {
+		jaHaniLegalCompanyName: "blur",
+		jaKanaLegalCompanyName: "blur",
+		legalCompanyName: "blur"
+	};
+	return fieldKeys.map((fieldKey) => {
+		if (formUtils.isRequiredField(fieldKey) || formUtils.isOptionalField(fieldKey)) {
+			const guidance = fieldKey === "legalCompanyName" ? getLegalCompanyNameGuidanceText(t, { country }) : void 0;
+			return {
+				name: fieldKey,
+				value: data[fieldKey] ?? "",
+				readonly: formUtils.isReadOnly(fieldKey),
+				onInput: handleChange(fieldKey, "input"),
+				onBlur: handleChange(fieldKey, "blur"),
+				isValid: valid[fieldKey],
+				errorMessage: fieldErrors[fieldKey],
+				label: labels[fieldKey],
+				guidance,
+				onKeyDown: handleKeyDown,
+				transformInput: fieldsTransformInput[fieldKey],
+				transformMode: fieldsTransformMode[fieldKey]
+			};
+		}
+	});
+}
+var getFieldKeys = (isFeatureEnabled = () => false, country) => {
+	if (isJapanLocalizationEnabled(isFeatureEnabled, country)) return [...JAPANESE_LEGAL_COMPANY_NAME_FIELDS, ...LEGAL_COMPANY_NAME_FIELD];
+	return LEGAL_COMPANY_NAME_FIELD;
+};
+var handleKeyDown = (e) => {
+	if (e.key === KEYBOARD_KEYS.enter) e.preventDefault();
+};
+//#endregion
+//#region src/components/Shared/fields/CountryOfGoverningLawField/CountryOfGoverningLawField.tsx
+var COUNTRY_OF_GOVERNING_LAW_FIELD = ["countryOfGoverningLaw"];
+function CountryOfGoverningLawField({ data, valid, errors, labels, readonly, handleChangeFor, allowedCountries, country }) {
+	const { t } = useTranslation("common");
+	useEffect$1(() => {
+		if (country === CountryCodes.UnitedKingdom && !data.countryOfGoverningLaw) {
+			const countryOfGoverningLawEvent = { target: {
+				name: "countryOfGoverningLaw",
+				value: CountryCodes.UnitedKingdom
+			} };
+			handleChangeFor("countryOfGoverningLaw")(countryOfGoverningLawEvent);
+		}
+	}, [country]);
+	return /* @__PURE__ */ jsx(CountryField, {
+		name: "countryOfGoverningLaw",
+		data: { country: data.countryOfGoverningLaw },
+		valid: { country: valid.countryOfGoverningLaw },
+		errors: { country: errors.countryOfGoverningLaw },
+		labels: { country: labels?.countryOfGoverningLaw || t(($) => $["countryOfGoverningLaw"]) },
+		readonly,
+		allowedCountries,
+		handleChangeFor: () => handleChangeFor("countryOfGoverningLaw")
+	});
+}
+var localizedLegalCompanyNameFieldConfig = {
+	jaHaniLegalCompanyName: {
+		config: {
+			label: "jaHaniLegalCompanyName",
+			validators: validateJaHaniLegalCompanyName
+		},
+		metadata: { label: "jaHaniLegalCompanyName" }
+	},
+	jaKanaLegalCompanyName: {
+		config: {
+			label: "jaKanaLegalCompanyName",
+			validators: validateJaKanaLegalCompanyName
+		},
+		metadata: { label: "jaKanaLegalCompanyName" }
+	}
+};
+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 { isFeatureEnabled } = useToggleContext();
+	const { form } = useFormContext();
+	const allowedCountries = useAllowedCountries();
+	const isAllowedEditPrefilledCountry = isSettingEnabled(SettingNames.AllowPrefilledCountryEdit);
+	const state = form.data.basicInformation?.stateOrProvince;
+	const currentCountryTaxInformation = form.data.basicInformation?.taxInformation?.find((tax) => tax.country === country);
+	const handleChangeFor = useCallback$1((fieldName, mode) => form.handleChangeFor(fieldName, "basicInformation", mode), [form]);
+	const formUtils = useMemo$1(() => {
+		const initialProps = {
+			data: form.data.basicInformation ?? {},
+			fieldValidationErrors,
+			formVerificationErrors,
+			allFields: form.allFields?.basicInformation ?? [],
+			requiredFields: form.requiredFields?.basicInformation ?? [],
+			optionalFields: form.optionalFields?.basicInformation ?? [],
+			trustedFields: form.trustedFields?.basicInformation ?? [],
+			obscuredFields: form.obscuredFields?.basicInformation ?? [],
+			errors: form.errors.basicInformation ?? {},
+			valid: form.valid.basicInformation ?? {},
+			handleFieldChange: handleChangeFor
+		};
+		const formUtilProps = initialProps.allFields?.reduce((acc, field) => {
+			switch (field) {
+				case "country": return acc;
+				case "legalCompanyName": return mergeFieldMetadataIntoProps(field, resolveFieldMetadata(isFeatureEnabled("StrictNameAndAddressValidationV4") ? defaultFieldConfigV4[country] : defaultFieldConfig$2[country], {}, isFeatureEnabled("StrictNameAndAddressValidationV4") ? defaultFieldMetadataV4 : defaultFieldMetadata$2), acc);
+				case "countryOfGoverningLaw": return acc;
+				case "stateOrProvince": return mergeFieldMetadataIntoProps(field, resolveFieldMetadata(defaultFieldConfig[country], { isBusiness: true }, defaultFieldMetadata), acc);
+				case "taxInformation": return mergeFieldMetadataIntoProps(field, resolveFieldMetadata(taxInformationDefaultFieldConfig[country], {
+					taxIdNumberType: currentCountryTaxInformation?.type,
+					companyType
+				}, taxInformationDefaultFieldMetadata), acc);
+				case "jaHaniLegalCompanyName": return mergeFieldMetadataIntoProps(field, resolveFieldMetadata(localizedLegalCompanyNameFieldConfig.jaHaniLegalCompanyName.config, {}, localizedLegalCompanyNameFieldConfig.jaHaniLegalCompanyName.metadata), acc);
+				case "jaKanaLegalCompanyName": return mergeFieldMetadataIntoProps(field, resolveFieldMetadata(localizedLegalCompanyNameFieldConfig.jaKanaLegalCompanyName.config, {}, localizedLegalCompanyNameFieldConfig.jaKanaLegalCompanyName.metadata), acc);
+				default: return acc;
+			}
+		}, initialProps);
+		return createFormUtils(formUtilProps ?? initialProps, t);
+	}, [
+		companyType,
+		country,
+		currentCountryTaxInformation?.type,
+		form.allFields?.basicInformation,
+		form.data.basicInformation,
+		form.errors.basicInformation,
+		form.obscuredFields?.basicInformation,
+		form.optionalFields?.basicInformation,
+		form.requiredFields?.basicInformation,
+		form.trustedFields?.basicInformation,
+		form.valid.basicInformation,
+		handleChangeFor,
+		isFeatureEnabled,
+		t,
+		fieldValidationErrors,
+		formVerificationErrors
+	]);
+	const showField = (fieldKeys) => fieldKeys.some((field) => {
+		switch (field) {
+			case "registrationNumberType":
+			case "registrationNumber":
+				if (isUsingCompanySearch(country, taskType)) return form.data.basicInformation?.country === "US" ? (formUtils.isRequiredField(field) || formUtils.isOptionalField(field)) && form.data.basicInformation?.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: form.data.basicInformation ?? {},
+		valid: form.valid.basicInformation ?? {},
+		errors: form.errors.basicInformation ?? {},
+		fieldProblems: form.fieldProblems.basicInformation ?? {},
+		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(form.data.basicInformation ?? {}, COUNTRY_FIELD),
+					valid: formUtils.getFieldValid(form.valid.basicInformation ?? {}, COUNTRY_FIELD),
+					errors: formUtils.getFieldErrors(form.errors.basicInformation ?? {}, fieldValidationErrors, COUNTRY_FIELD),
+					labels: formUtils.getFieldLabels(COUNTRY_FIELD, { country: "countryRegionOfEstablishment" }),
+					readonly: formUtils.isReadOnly("country") || !isAllowedEditPrefilledCountry || Boolean(disableCountry),
+					handleChangeFor,
+					allowedCountries: isTopLevelEntity ? allowedCountries : void 0
+				}),
+				COUNTRY_OF_GOVERNING_LAW_POSSIBLE.includes(country) && showField(COUNTRY_OF_GOVERNING_LAW_FIELD) && /* @__PURE__ */ jsx(CountryOfGoverningLawField, {
+					data: formUtils.getFieldData(form.data.basicInformation ?? {}, COUNTRY_OF_GOVERNING_LAW_FIELD),
+					country,
+					valid: formUtils.getFieldValid(form.valid.basicInformation ?? {}, COUNTRY_OF_GOVERNING_LAW_FIELD),
+					errors: formUtils.getFieldErrors(form.errors.basicInformation ?? {}, fieldValidationErrors, COUNTRY_OF_GOVERNING_LAW_FIELD),
+					labels: formUtils.getFieldLabels(COUNTRY_OF_GOVERNING_LAW_FIELD),
+					readonly: false,
+					allowedCountries: isTopLevelEntity ? allowedCountries : void 0,
+					handleChangeFor
+				}),
+				showField(STATE_FIELD) && /* @__PURE__ */ jsx(StateField, {
+					data: formUtils.getFieldData(form.data.basicInformation ?? {}, STATE_FIELD),
+					valid: formUtils.getFieldValid(form.valid.basicInformation ?? {}, STATE_FIELD),
+					errors: formUtils.getFieldErrors(form.errors.basicInformation ?? {}, fieldValidationErrors, STATE_FIELD),
+					labels: formUtils.getFieldLabels(STATE_FIELD),
+					readonly: formUtils.isReadOnly("stateOrProvince"),
+					handleChangeFor,
+					selectedCountry: country
+				}),
+				showField(TAX_INFORMATION_FIELD) && /* @__PURE__ */ jsx(TaxInformationField, {
+					data: formUtils.getFieldData(form.data.basicInformation ?? {}, TAX_INFORMATION_FIELD),
+					valid: formUtils.getFieldValid(form.valid.basicInformation ?? {}, TAX_INFORMATION_FIELD),
+					errors: formUtils.getFieldErrors(form.errors.basicInformation ?? {}, fieldValidationErrors, TAX_INFORMATION_FIELD),
+					labels: formUtils.getFieldLabels(TAX_INFORMATION_FIELD, { exemptedFromTax: "iDontHaveATaxId" }),
+					mask: formUtils.getMask("taxInformation"),
+					placeholder: getTaxInformationPlaceholderText({
+						country,
+						companyType,
+						taxIdNumberType: currentCountryTaxInformation?.type
+					}),
+					readonly: formUtils.isReadOnly("taxInformation"),
+					shouldValidate,
+					handleChangeFor,
+					canExempt: showField(["exemptedFromTax"]),
+					registrationNumber: form.data.basicInformation?.registrationNumber,
+					country,
+					entityType: companyType,
+					defaultData: form.defaultData?.basicInformation?.taxInformation,
+					invertCompanyTypeFilter: isFeatureEnabled("EnableUnifiedCompanySearch")
+				}),
+				showField(BUSINESS_REGISTRATION_NUMBER_FIELD) && /* @__PURE__ */ jsx(BusinessRegistrationNumberField, {
+					data: formUtils.getFieldData(form.data.basicInformation ?? {}, BUSINESS_REGISTRATION_NUMBER_FIELD),
+					valid: formUtils.getFieldValid(form.valid.basicInformation ?? {}, BUSINESS_REGISTRATION_NUMBER_FIELD),
+					errors: formUtils.getFieldErrors(form.errors.basicInformation ?? {}, fieldValidationErrors, BUSINESS_REGISTRATION_NUMBER_FIELD),
+					helperText: getRegistrationNumberHelperText(businessT, {
+						country,
+						companyType
+					}),
+					readonly: formUtils.isReadOnly("registrationNumber"),
+					optional: formUtils.isOptionalField("registrationNumber"),
+					shouldValidate,
+					handleChangeFor,
+					country,
+					state,
+					canExempt: showField(["exemptedFromRegistrationNumber"]),
+					companyType,
+					invertCompanyTypeFilter: isFeatureEnabled("EnableUnifiedCompanySearch")
+				})
+			] })
+		]
+	});
+}
+//#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();
+	return useMutation({
+		mutationFn: () => {
+			return clearCompanyData(rootLegalEntityId.value, baseUrl.value);
+		},
+		retry: 0,
+		...options
+	});
+};
+//#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: return await handleCompanyDataset(rootLegalEntityId, baseUrl, { id: data.id });
+	}
+};
+//#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: 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 handleChange = useCallback$1((fieldName, mode) => form.handleChangeFor(fieldName, "businessSelection", mode), [form]);
+	/**
+	* 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 (form.data.businessSelection?.selectedBusinessId) {
+			handleChange("selectedBusinessId", "blur")("");
+			form.setErrors("selectedBusinessId", null, "businessSelection");
+		}
+		isInitializedRef.current = true;
+	}
+	const fetchCompanyData = async (result) => {
+		isSelectPending.value = true;
+		resetSelectMutationState();
+		try {
+			const companySelectionResponse = await selectCompany({
+				id: result.resultId,
+				name: result.name,
+				tin: currentTin ?? "",
+				country
+			});
+			handleChange("selectedBusinessId", "blur")(result.resultId);
+			companySearchStateModel.selectCompany(companySelectionResponse, selectedCompanyIdx);
+		} catch (e) {
+			if (isBusinessSelectionLegalArrangementError(e)) {
+				companySearchStateModel.disallowSelection("LEGAL_ARRANGEMENT");
+				handleChange("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();
+		clearCompanyData();
+		if (country !== CountryCodes.UnitedStates) return handleChange("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.setTinMatched(!!matched);
+			handleChange("selectedBusinessId", "blur")("notListed");
+		} catch (e) {
+			logger.error(e);
+			companySearchStateModel.setTinMatched(false);
+			handleChange("selectedBusinessId", "blur")("notListed");
+		} finally {
+			isSelectPending.value = false;
+		}
+	};
+	const formUtils = useMemo$1(() => {
+		return createFormUtils({
+			data: form.data.businessSelection ?? {},
+			fieldValidationErrors,
+			formVerificationErrors,
+			allFields: form.allFields?.businessSelection ?? [],
+			requiredFields: form.requiredFields?.businessSelection ?? [],
+			optionalFields: form.optionalFields?.businessSelection ?? [],
+			trustedFields: form.trustedFields?.businessSelection ?? [],
+			obscuredFields: form.obscuredFields?.businessSelection ?? [],
+			errors: form.errors.businessSelection ?? {},
+			valid: form.valid.businessSelection ?? {}
+		}, t);
+	}, [
+		form.allFields?.businessSelection,
+		form.data.businessSelection,
+		form.errors.businessSelection,
+		form.obscuredFields?.businessSelection,
+		form.optionalFields?.businessSelection,
+		form.requiredFields?.businessSelection,
+		form.trustedFields?.businessSelection,
+		form.valid.businessSelection,
+		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", form.errors.businessSelection, fieldValidationErrors),
+					isValid: form.valid.businessSelection?.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/datasets/generators/getCompanyTypeExamplesForCountry.ts
+var companyTypeExamples = /* @__PURE__ */ Object.assign({
+	"../localized/companyTypeExamples/AT.json": () => import("./AT-BNvEEyA1.js"),
+	"../localized/companyTypeExamples/AU.json": () => import("./AU-yI1HPsCK.js"),
+	"../localized/companyTypeExamples/BE.json": () => import("./BE-BsQPppoQ.js"),
+	"../localized/companyTypeExamples/BR.json": () => import("./BR-Df_k79xR.js"),
+	"../localized/companyTypeExamples/CA.json": () => import("./CA-Drxrt6ud.js"),
+	"../localized/companyTypeExamples/CH.json": () => import("./CH-C93Zls9o.js"),
+	"../localized/companyTypeExamples/CZ.json": () => import("./CZ-Bk7V7DHn.js"),
+	"../localized/companyTypeExamples/DE.json": () => import("./DE-CKGX5CHO.js"),
+	"../localized/companyTypeExamples/DK.json": () => import("./DK-DORnwCWQ.js"),
+	"../localized/companyTypeExamples/ES.json": () => import("./ES-C89tOy9e.js"),
+	"../localized/companyTypeExamples/FI.json": () => import("./FI-DCXniiD4.js"),
+	"../localized/companyTypeExamples/FR.json": () => import("./FR-CxvXXv-O.js"),
+	"../localized/companyTypeExamples/GB.json": () => import("./GB-DCF0Nkem.js"),
+	"../localized/companyTypeExamples/HK.json": () => import("./HK-C1qODiFA.js"),
+	"../localized/companyTypeExamples/HR.json": () => import("./HR-DomyNfJ0.js"),
+	"../localized/companyTypeExamples/HU.json": () => import("./HU-HvuEJeUR.js"),
+	"../localized/companyTypeExamples/IE.json": () => import("./IE-DwzVxL1C.js"),
+	"../localized/companyTypeExamples/IT.json": () => import("./IT-CISIu45c.js"),
+	"../localized/companyTypeExamples/LT.json": () => import("./LT-DnvVPVhz.js"),
+	"../localized/companyTypeExamples/NL.json": () => import("./NL-Bn2QKc20.js"),
+	"../localized/companyTypeExamples/NO.json": () => import("./NO-D7BSfuUs.js"),
+	"../localized/companyTypeExamples/PL.json": () => import("./PL-CtjljK4S.js"),
+	"../localized/companyTypeExamples/PT.json": () => import("./PT-Ck3Uvmoz.js"),
+	"../localized/companyTypeExamples/RO.json": () => import("./RO-CewdEU2z.js"),
+	"../localized/companyTypeExamples/SE.json": () => import("./SE-DzRKAJvT.js"),
+	"../localized/companyTypeExamples/SG.json": () => import("./SG-sKZVzzs9.js"),
+	"../localized/companyTypeExamples/SI.json": () => import("./SI-BIBw5Y4Z.js"),
+	"../localized/companyTypeExamples/SK.json": () => import("./SK-M9wg6on5.js"),
+	"../localized/companyTypeExamples/US.json": () => import("./US-D3s6UvEg.js")
+});
+var logger = createLogger();
+var getCompanyTypeExamplesForCountry = async (country) => {
+	const importForCountry = companyTypeExamples[`../localized/companyTypeExamples/${country}.json`];
+	if (!importForCountry) {
+		logger.warn(`No company type examples available for ${country}`);
+		return {};
+	}
+	return (await importForCountry()).default;
+};
+var useCompanyTypeExamples = (country) => {
+	const [examples, setExamples] = useState$1();
+	useEffect$1(() => {
+		getCompanyTypeExamplesForCountry(country).then(setExamples).catch(console.error);
+	}, [country]);
+	return examples;
+};
+//#endregion
+//#region src/components/Business/utils/companyTypeMetadata.ts
+var companyTypeMetadata = {
+	[CompanyTypesValues.PRIVATE_COMPANY]: {
+		id: CompanyTypesValues.PRIVATE_COMPANY,
+		name: "privateCompanyTitle",
+		description: "privateCompanyDescription"
+	},
+	[CompanyTypesValues.PUBLIC_COMPANY]: {
+		id: CompanyTypesValues.PUBLIC_COMPANY,
+		name: "publicCompanyTitle",
+		description: "publicCompanyDescription"
+	},
+	[CompanyTypesValues.INCORPORATED_PARTNERSHIP]: {
+		id: CompanyTypesValues.INCORPORATED_PARTNERSHIP,
+		name: "partnershipIncorporated",
+		description: "partnershipIncorporatedDescription"
+	},
+	[CompanyTypesValues.NON_PROFIT_OR_CHARITABLE]: {
+		id: CompanyTypesValues.NON_PROFIT_OR_CHARITABLE,
+		name: "nonProfitOrCharitableOrgTitle",
+		description: "nonProfitOrCharitableOrgDescription"
+	},
+	[CompanyTypesValues.GOVERNMENTAL_ORGANIZATION]: {
+		id: CompanyTypesValues.GOVERNMENTAL_ORGANIZATION,
+		name: "governmentalOrganizationTitle",
+		description: "governmentalOrganizationDescription"
+	},
+	[CompanyTypesValues.INCORPORATED_ASSOCIATION]: {
+		id: CompanyTypesValues.INCORPORATED_ASSOCIATION,
+		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 ? [
+		CompanyTypesValues.INCORPORATED_PARTNERSHIP,
+		CompanyTypesValues.INCORPORATED_ASSOCIATION,
+		CompanyTypesValues.GOVERNMENTAL_ORGANIZATION
+	] : [CompanyTypesValues.INCORPORATED_PARTNERSHIP, CompanyTypesValues.INCORPORATED_ASSOCIATION];
+	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 { isFeatureEnabled } = useToggleContext();
+	const formUtils = createFormUtils({ requiredFields: form.requiredFields?.companyStructure ?? [] }, 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: isFeatureEnabled("EnableUnifiedCompanySearch") ? registrationNumberType : void 0,
+		registrationNumberExempt: isFeatureEnabled("EnableUnifiedCompanySearch") ? registrationNumberExempt : void 0,
+		taxIdNumberType: isFeatureEnabled("EnableUnifiedCompanySearch") ? taxIdNumberType : void 0,
+		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", form.errors.companyStructure, fieldValidationErrors),
+				isValid: form.valid.companyStructure?.entityType,
+				children: (childProps) => /* @__PURE__ */ jsx(TileGroup, {
+					...childProps,
+					name: "entityType",
+					tiles: companyTiles,
+					selected: form.data.companyStructure?.entityType ?? "",
+					onChange: (value) => form.handleChangeFor("entityType", "companyStructure")(value),
+					isHorizontal: true,
+					"aria-required": true,
+					"aria-invalid": !form.valid.companyStructure?.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 handleChangeFor = useCallback$1((fieldName, mode) => form.handleChangeFor(fieldName, "companyFinancialInformation", mode), [form]);
+	const formUtils = useMemo$1(() => createFormUtils({
+		data: form.data.companyFinancialInformation ?? {},
+		fieldValidationErrors,
+		formVerificationErrors,
+		allFields: form.allFields?.companyFinancialInformation ?? [],
+		requiredFields: form.requiredFields?.companyFinancialInformation ?? [],
+		optionalFields: form.optionalFields?.companyFinancialInformation ?? [],
+		trustedFields: form.trustedFields?.companyFinancialInformation ?? [],
+		obscuredFields: form.obscuredFields?.companyFinancialInformation ?? [],
+		errors: form.errors.companyFinancialInformation ?? {},
+		valid: form.valid.companyFinancialInformation ?? {},
+		handleFieldChange: handleChangeFor
+	}, t), [
+		form,
+		handleChangeFor,
+		t,
+		fieldValidationErrors,
+		formVerificationErrors
+	]);
+	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(form.data.companyFinancialInformation ?? {}, NUMBER_OF_EMPLOYEES_FIELD),
+				errors: formUtils.getFieldErrors(form.errors.companyFinancialInformation ?? {}, form.fieldProblems.companyFinancialInformation, NUMBER_OF_EMPLOYEES_FIELD),
+				handleChangeFor,
+				labels: formUtils.getFieldLabels(NUMBER_OF_EMPLOYEES_FIELD),
+				readonly: formUtils.isReadOnly("numberOfEmployees"),
+				valid: formUtils.getFieldValid(form.valid.companyFinancialInformation ?? {}, NUMBER_OF_EMPLOYEES_FIELD)
+			}),
+			showField(FINANCIAL_REPORTING_DATE_FIELD) && /* @__PURE__ */ jsx(FinancialReportingDate, {
+				data: formUtils.getFieldData(form.data.companyFinancialInformation ?? {}, FINANCIAL_REPORTING_DATE_FIELD),
+				errors: formUtils.getFieldErrors(form.errors.companyFinancialInformation ?? {}, form.fieldProblems.companyFinancialInformation, FINANCIAL_REPORTING_DATE_FIELD),
+				handleChangeFor,
+				labels: formUtils.getFieldLabels(FINANCIAL_REPORTING_DATE_FIELD),
+				readonly: formUtils.isReadOnly("financialReportingDate"),
+				valid: formUtils.getFieldValid(form.valid.companyFinancialInformation ?? {}, FINANCIAL_REPORTING_DATE_FIELD)
+			}),
+			showField(CURRENCY_FIELD) && /* @__PURE__ */ jsx(Currency, {
+				country,
+				labels: { currency: t(($) => $["reportingCurrency"]) },
+				data: formUtils.getFieldData(form.data.companyFinancialInformation ?? {}, CURRENCY_FIELD),
+				errors: formUtils.getFieldErrors(form.errors.companyFinancialInformation ?? {}, form.fieldProblems.companyFinancialInformation, CURRENCY_FIELD),
+				handleChangeFor,
+				readonly: formUtils.isReadOnly("currency"),
+				valid: formUtils.getFieldValid(form.valid.companyFinancialInformation ?? {}, CURRENCY_FIELD)
+			}),
+			showField(REPORTED_VALUE_OPTION_FIELD) && /* @__PURE__ */ jsx(ReportedValueOptionField, {
+				data: formUtils.getFieldData(form.data.companyFinancialInformation ?? {}, REPORTED_VALUE_OPTION_FIELD),
+				valid: formUtils.getFieldValid(form.valid.companyFinancialInformation ?? {}, REPORTED_VALUE_OPTION_FIELD),
+				errors: formUtils.getFieldErrors(form.errors.companyFinancialInformation ?? {}, form.fieldProblems.companyFinancialInformation, REPORTED_VALUE_OPTION_FIELD),
+				handleChangeFor,
+				currency: form.data.companyFinancialInformation?.currency ?? defaultCurrency
+			})
+		]
+	});
+}
+//#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]: {
+		[CompanyTypesValues.PRIVATE_COMPANY]: {
+			header: "acceptedDocumentsForPrivateCompanies",
+			documents: [
+				"certificateOfIncorporation",
+				"certificateOfFormation",
+				"secretaryOfStateFiling__PR"
+			]
+		},
+		[CompanyTypesValues.PUBLIC_COMPANY]: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["certificateOfIncorporation", "certificateOfFormation"]
+		},
+		[CompanyTypesValues.UNLISTED_PUBLIC_COMPANY]: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["certificateOfIncorporation", "certificateOfFormation"]
+		},
+		[CompanyTypesValues.GOVERNMENTAL_ORGANIZATION]: {
+			header: "acceptedDocumentsForGovernment",
+			documents: ["charter"]
+		},
+		[CompanyTypesValues.NON_PROFIT_OR_CHARITABLE]: {
+			header: "acceptedDocumentsForNonProfit",
+			documents: [
+				"articlesOfIncorporation",
+				"meetingRecords",
+				"secretaryOfStateRegDoc__PR",
+				"certificateOfIncumbency"
+			]
+		},
+		[CompanyTypesValues.INCORPORATED_PARTNERSHIP]: {
+			header: "acceptedDocumentsForPartnerships",
+			documents: ["partnerShipAgreement", "secretaryOfStateFiling__PR"]
+		}
+	},
+	[CountryCodes.UnitedStates]: {
+		[CompanyTypesValues.PRIVATE_COMPANY]: {
+			header: "acceptedDocumentsForPrivateCompanies",
+			documents: [
+				"certificateOfIncorporation",
+				"certificateOfFormation",
+				"secretaryOfStateFiling"
+			]
+		},
+		[CompanyTypesValues.PUBLIC_COMPANY]: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["certificateOfIncorporation", "certificateOfFormation"]
+		},
+		[CompanyTypesValues.UNLISTED_PUBLIC_COMPANY]: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["certificateOfIncorporation", "certificateOfFormation"]
+		},
+		[CompanyTypesValues.GOVERNMENTAL_ORGANIZATION]: {
+			header: "acceptedDocumentsForGovernment",
+			documents: ["charter"]
+		},
+		[CompanyTypesValues.NON_PROFIT_OR_CHARITABLE]: {
+			header: "acceptedDocumentsForNonProfit",
+			documents: [
+				"articlesOfIncorporation",
+				"meetingRecords",
+				"secretaryOfStateRegDoc",
+				"certificateOfIncumbency"
+			]
+		},
+		[CompanyTypesValues.INCORPORATED_PARTNERSHIP]: {
+			header: "acceptedDocumentsForPartnerships",
+			documents: ["partnerShipAgreement", "secretaryOfStateFiling"]
+		}
+	}
+};
+//#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" ? /* @__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 = CompanyTypesValues.PRIVATE_COMPANY, ...props }) {
+	const { t } = useTranslation(["common", "business"]);
+	return /* @__PURE__ */ jsx(MemoizedDocumentUpload, {
+		...props,
+		id,
+		heading: t(($) => $["companyRegistrationDocumentFormHeading"], { ns: "business" }),
+		description: t(($) => $["companyRegistrationDocumentFormDescription"], { ns: "business" }),
+		documentField: "registrationDocument",
+		documentType: "registrationDocument",
+		guidanceContent: /* @__PURE__ */ jsx(GuidanceContent$1, {
+			country,
+			companyType,
+			t
+		}),
+		companyType,
+		country,
+		hidePageCount: true
+	});
+}
+//#endregion
+//#region src/components/Business/forms/TaxDocument/config.ts
+var ACCEPTED_DOCUMENTS_MAP = {
+	[CountryCodes.PuertoRico]: {
+		[CompanyTypesValues.PRIVATE_COMPANY]: {
+			header: "acceptedDocumentsForPrivateCompanies",
+			documents: ["irsCP575"]
+		},
+		[CompanyTypesValues.PUBLIC_COMPANY]: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["annualReport", "secForm10k"]
+		},
+		[CompanyTypesValues.UNLISTED_PUBLIC_COMPANY]: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["annualReport", "secForm10k"]
+		},
+		[CompanyTypesValues.NON_PROFIT_OR_CHARITABLE]: {
+			header: "acceptedDocumentsForNonProfit",
+			documents: ["annualReport"]
+		},
+		[CompanyTypesValues.INCORPORATED_PARTNERSHIP]: {
+			header: "acceptedDocumentsForPartnerships",
+			documents: ["irsScheduleK1"]
+		}
+	},
+	[CountryCodes.UnitedStates]: {
+		[CompanyTypesValues.PRIVATE_COMPANY]: {
+			header: "acceptedDocumentsForPrivateCompanies",
+			documents: ["irsCP575"]
+		},
+		[CompanyTypesValues.PUBLIC_COMPANY]: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["annualReport", "secForm10k"]
+		},
+		[CompanyTypesValues.UNLISTED_PUBLIC_COMPANY]: {
+			header: "acceptedDocumentsForPublicCompanies",
+			documents: ["annualReport", "secForm10k"]
+		},
+		[CompanyTypesValues.NON_PROFIT_OR_CHARITABLE]: {
+			header: "acceptedDocumentsForNonProfit",
+			documents: ["annualReport"]
+		},
+		[CompanyTypesValues.INCORPORATED_PARTNERSHIP]: {
+			header: "acceptedDocumentsForPartnerships",
+			documents: ["irsScheduleK1"]
+		}
+	}
+};
+//#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 = CompanyTypesValues.PRIVATE_COMPANY, ...props }) {
+	const { t } = useTranslation("business");
+	return /* @__PURE__ */ jsx(MemoizedDocumentUpload, {
+		...props,
+		id,
+		heading: t(($) => $["companyTaxDocumentFormHeading"]),
+		description: t(($) => $["companyTaxDocumentFormDescription"]),
+		documentField: "taxDocument",
+		documentType: "proofOfOrganizationTaxInfo",
+		guidanceContent: /* @__PURE__ */ jsx(GuidanceContent, {
+			country,
+			companyType
+		}),
+		companyType,
+		country,
+		hidePageCount: true
+	});
+}
+//#endregion
+//#region src/components/Business/forms/BusinessDetails/BusinessDetailsMultiform.tsx
+var VatDocument = ({ children }) => {
+	return children;
+};
+var EMPTY_OBJ$1 = {};
+function BusinessDetailsMultiform({ taskType, country, activeForm, shouldValidate, problems = EMPTY_OBJ$1, isTopLevelEntity }) {
+	const { t } = useTranslation(["common", "business"]);
+	const { form } = useFormContext();
+	const companyType = taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY ? CompanyTypesValues.SOLE_PROPRIETORSHIP : form.data.companyStructure?.entityType;
+	function handleChange(formName, fieldName, mode) {
+		return form.handleChangeFor(fieldName, formName, mode);
+	}
+	const renderActiveForm = (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 "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: LegalEntityTypes.SOLE_PROPRIETORSHIP,
+				country,
+				data: form.data.companyConstitutionalDocument,
+				errors: form.errors.companyConstitutionalDocument,
+				valid: form.valid.companyConstitutionalDocument,
+				allFields: form.allFields?.companyConstitutionalDocument,
+				requiredFields: form.requiredFields?.companyConstitutionalDocument,
+				optionalFields: form.optionalFields?.companyConstitutionalDocument,
+				trustedFields: form.trustedFields?.companyConstitutionalDocument,
+				handleFieldChange: (fieldName) => handleChange("companyConstitutionalDocument", fieldName),
+				shouldValidate,
+				fieldValidationErrors: problems.validationErrors?.[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/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 }) {
+	const { baseUrl, rootLegalEntityId } = useApiContext();
+	const userEvents = useAnalyticsContext();
+	const queryClient = useQueryClient();
+	const { mutateAsync: selectCompany } = useCompanySelection();
+	const { mutateAsync: clearCompanyData } = useClearCompanyData();
+	const logger = createLogger();
+	/**
+	* 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 ?? "";
+		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.setTinMatched(tinMatched);
+					if (companySearchStateModel.tinMatched.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 companySelectionResponse = await selectCompany({
+						state: multiForm.data.basicInformation?.stateOrProvince,
+						name: multiForm.data.basicInformation?.legalCompanyName,
+						tin,
+						id: searchResponse.results[0].resultId,
+						country
+					});
+					companySearchStateModel.selectCompany(companySelectionResponse, -1);
+					setLoadingStatus("success");
+					const tinMatched = !!companySelectionResponse.tinMatched;
+					switch (country) {
+						case CountryCodes.UnitedStates: if (tinMatched) {
+							companySearchStateModel.confirmCompany(multiForm, country);
+							skipBusinessSelection.value = true;
+							return getRequiredForms({
+								skipBusinessSelection: skipBusinessSelection.peek(),
+								skipCompanyStructure: !!companySearchStateModel.verifiedBusiness.value?.legalForm
+							});
+						} else {
+							clearCompanyData().then();
+							return currentForms;
+						}
+						default:
+							companySearchStateModel.confirmCompany(multiForm, country);
+							skipBusinessSelection.value = true;
+							return getRequiredForms({
+								skipBusinessSelection: skipBusinessSelection.peek(),
+								skipCompanyStructure: !!companySearchStateModel.verifiedBusiness.value?.legalForm
+							});
+					}
+				} catch (e) {
+					logger.error(e);
+					setLoadingStatus("error");
+					clearCompanyData().then();
+					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 === "US" && !companySearchStateModel.tinMatched.value) isTinMatched.value = false;
+				return getRequiredForms({});
+			default:
+				if (country === "US" && !companySearchStateModel.tinMatched.value) {
+					tinMismatchModalOpen.value = true;
+					return null;
+				}
+				companySearchStateModel.confirmCompany(multiForm, country);
+				return getRequiredForms({ skipCompanyStructure: !!companySearchStateModel.verifiedBusiness.value?.legalForm });
+		}
+	};
+	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(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(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, 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]
+		})
+	])).filter(Boolean);
+};
+var mapBusinessDetailsSchemaToLegalEntity = (data, accountHolder, isFeatureEnabled, taskType, matchingScenario, rootLegalEntity) => {
+	const requestObj = { ...formatObject(data, accountHolder === "mySoleProprietorName" ? solePropBusinessDetailsApiKeyMapping : businessDetailsApiKeyMapping) };
+	delete requestObj.organization?.legalFormDescription;
+	const canSaveRegNumberAbsentState = isFeatureEnabled("EnableRegistrationAndTaxAbsentStatesV4") && isRegistrationNumberAbsentStateV4Scenario(data.basicInformation?.country, data.companyStructure?.entityType);
+	const useBasicInformationForTaxAndRegistration = isFeatureEnabled("EnableUnifiedCompanySearch") || isUsingCompanySearch(data.basicInformation?.country, taskType);
+	const [taxData, registrationNumber] = useBasicInformationForTaxAndRegistration ? [data.basicInformation?.taxInformation, data.basicInformation?.registrationNumber] : [data.additionalInformation?.taxInformation, data.additionalInformation?.registrationNumber];
+	const registrationNumberType = useBasicInformationForTaxAndRegistration ? data.basicInformation?.registrationNumberType : data.additionalInformation?.registrationNumberType;
+	const localization = [mapSchemaFieldsToApiScriptLocalization(data.basicInformation ?? {}, "jaHani"), mapSchemaFieldsToApiScriptLocalization(data.basicInformation ?? {}, "jaKana")].filter(({ fields }) => !isEmpty$1(fields)).map(({ script, fields }) => ({
+		script,
+		fields: { legalName: fields.legalCompanyName }
+	}));
+	const doingBusinessAs = data.additionalInformation?.doingBusinessAs ?? "";
+	const entityObject = isEmpty$1(data.companyStructure) ? requestObj.soleProprietorship : requestObj.organization;
+	if (entityObject) {
+		if (taxData) entityObject.taxInformation = taxData;
+		if (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, CompanyTypesValues.PRIVATE_COMPANY);
+			entityObject.taxInformation = [{
+				country: taxCountry,
+				number: registrationNumber,
+				type: privateCompanyTaxOptions && privateCompanyTaxOptions.length > 0 ? privateCompanyTaxOptions[0]["id"] : ""
+			}];
+		}
+		if (!!requestObj.soleProprietorship && !!data.basicInformation?.country) requestObj.soleProprietorship.countryOfGoverningLaw = data.basicInformation.country;
+		if (registrationNumber) {
+			entityObject.registrationNumber = registrationNumber;
+			if (canSaveRegNumberAbsentState && requestObj.organization) requestObj.organization.registrationNumberAbsent = false;
+		}
+		if (requestObj.organization && localization.length > 0) entityObject.localization = localization;
+		if (data.additionalInformation?.exemptedFromRegistrationNumber && canSaveRegNumberAbsentState && requestObj.organization) requestObj.organization.registrationNumberAbsent = data.additionalInformation.exemptedFromRegistrationNumber;
+		if (data.additionalInformation?.vatAbsenceReason) entityObject.vatNumber = "";
+		if (isFeatureEnabled("EnableDoingBusinessAsNameV4")) {
+			if (typeof data.additionalInformation?.hasDoingBusinessAs !== "undefined") entityObject.doingBusinessAsAbsent = !data.additionalInformation.hasDoingBusinessAs;
+		} else {
+			entityObject.doingBusinessAs = doingBusinessAs || data.basicInformation?.legalCompanyName;
+			delete entityObject.doingBusinessAsAbsent;
+		}
+		if (data.additionalInformation?.operationalAddressIsSame === operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_SAME && entityObject.principalPlaceOfBusiness) entityObject.principalPlaceOfBusiness = entityObject.registeredAddress;
+		const addressLocalizations = mapJpAddressSchemaToAddressLocalizations(data.additionalInformation?.registrationAddress);
+		if (addressLocalizations.length > 0) entityObject.registeredAddress.localization = addressLocalizations;
+		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 = requestObj.organization ? LegalEntityTypes.ORGANIZATION : LegalEntityTypes.SOLE_PROPRIETORSHIP;
+	if (entityObject?.registeredAddress.country === "US") delete entityObject.registrationNumber;
+	if (!canSaveRegNumberAbsentState) 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, isFeatureEnabled }) => {
+	if (!data || !data.country) return;
+	const companyType = legalEntity?.type === "organization" ? legalEntity.organization?.type : void 0;
+	const isUen = mapIsUen(data.taxInformation, data.registrationNumber, data.country);
+	const registrationNumberType = getDefaultRegistrationNumberType(data.registrationNumber, data.country, void 0, isFeatureEnabled("EnableUnifiedCompanySearch"));
+	const registrationNumberExemption = !data.registrationNumber && !!companyType && isRegistrationExemptionAllowed(data.country) && (() => {
+		const allowedEntityTypes = REGISTRATION_NUMBER_EXEMPTION_RULES[data.country];
+		return allowedEntityTypes.length === 0 || allowedEntityTypes.includes(companyType);
+	})() ? { exemptedFromRegistrationNumber: true } : {};
+	if (isFeatureEnabled("EnableUnifiedCompanySearch")) 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
+	});
+	return isUsingCompanySearch(data.country, taskType) ? data : entriesOf(data).reduce((acc, [field]) => {
+		if (!FIELDS_NEEDED_FOR_COMPANY_SEARCH.includes(field)) return {
+			...acc,
+			[field]: data[field]
+		};
+		return acc;
+	}, {});
+};
+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 mapAdditionalInformation = ({ data, legalEntity, taskType, isFeatureEnabled }) => {
+	if (!data) return;
+	const entity = legalEntity.type === "organization" ? legalEntity.organization : legalEntity.soleProprietorship;
+	const currentCountry = entity?.registeredAddress.country;
+	const dbaNameFields = mapDbaName(legalEntity);
+	const isUen = mapIsUen(data.taxInformation, data.registrationNumber, currentCountry);
+	const companyType = legalEntity.type === "organization" ? legalEntity.organization?.type : CompanyTypesValues.SOLE_PROPRIETORSHIP;
+	const registrationNumberType = getDefaultRegistrationNumberType(entity?.registrationNumber, currentCountry, companyType);
+	const vatNumberType = getDefaultVatNumberType(entity?.vatNumber, currentCountry);
+	const operationalAddressIsSame = entity?.principalPlaceOfBusiness && !objectsDeepEqual(entity.principalPlaceOfBusiness, entity.registeredAddress) ? operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME : operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_SAME;
+	if (entity?.registeredAddress.localization) data.registrationAddress = {
+		...data.registrationAddress,
+		...mapAddressLocalizationToJpAddressSchema(entity.registeredAddress.localization)
+	};
+	if (entity?.principalPlaceOfBusiness?.localization) data.operationalAddress = {
+		...data.operationalAddress,
+		...mapAddressLocalizationToJpAddressSchema(entity.principalPlaceOfBusiness.localization)
+	};
+	const shouldStripCompanySearchFields = isUsingCompanySearch(currentCountry, taskType) || isFeatureEnabled("EnableUnifiedCompanySearch");
+	return {
+		...entriesOf(data).reduce((acc, [field]) => {
+			if (!shouldStripCompanySearchFields) return {
+				...acc,
+				[field]: data[field]
+			};
+			if (!FIELDS_NEEDED_FOR_COMPANY_SEARCH.includes(field)) return {
+				...acc,
+				[field]: data[field]
+			};
+			return acc;
+		}, {
+			operationalAddressIsSame,
+			registrationNumberType,
+			vatNumberType
+		}),
+		...dbaNameFields,
+		...isUen
+	};
+};
+var mapLegalNameLocalization = (data) => {
+	const localization = data.organization?.localization;
+	if (!localization) return {};
+	let result = {};
+	for (const { script, fields } of localization) {
+		const schemaFieldsFromLocalization = mapApiScriptLocalizationToSchemaFields({
+			script,
+			fields: { legalCompanyName: fields.legalName }
+		});
+		result = {
+			...result,
+			...schemaFieldsFromLocalization
+		};
+	}
+	return result;
+};
+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?.registrationAddress?.country ?? 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, businessDetailsComponentsKeyMapping),
+		businessSelection: {},
+		companyRegistrationDocument,
+		companyTaxDocument,
+		companyProofOfDirectorDocument,
+		companyProofOfSignatoryDocument,
+		companyProofOfOwnershipDocument,
+		companyFinancialInformation: {}
+	};
+	const businessDetailsSchema = legalEntity.type === "organization" ? orgSchema : buildSolePropSchema();
+	return entriesOf(businessDetailsSchema).reduce((componentData, [key]) => {
+		switch (key) {
+			case "basicInformation": return {
+				...componentData,
+				[key]: {
+					...mapBasicInformation({
+						data: businessDetailsSchema[key],
+						legalEntity,
+						taskType,
+						isFeatureEnabled
+					}),
+					...mapLegalNameLocalization(legalEntity)
+				}
+			};
+			case "businessSelection": return {
+				...componentData,
+				[key]: { selectedBusinessId: "" }
+			};
+			case "companyStructure": return {
+				...componentData,
+				[key]: { ...businessDetailsSchema[key] }
+			};
+			case "additionalInformation": return {
+				...componentData,
+				[key]: mapAdditionalInformation({
+					data: businessDetailsSchema[key],
+					legalEntity,
+					taskType,
+					isFeatureEnabled
+				})
+			};
+			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, LegalEntityTypes.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 === operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME
+		};
+		/**
+		* 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 return updateLegalEntity({
+				...drop("type").from(legalEntity),
+				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 await updateLegalEntity({
+				entityAssociations: [{
+					type: LegalEntityTypes.SOLE_PROPRIETORSHIP,
+					legalEntityId: legalEntity.id
+				}],
+				id: legalEntityResponse.id
+			});
+		};
+		const filteredData = setRemovedFieldsOnSchemaToDeletedValue(data, mapLegalEntityToBusinessDetailsSchema({
+			legalEntity: legalEntityResponse,
+			parentEntity: void 0,
+			taskType,
+			isFeatureEnabled
+		}));
+		if (filteredData.additionalInformation && !filteredData.additionalInformation.taxInformation) filteredData.additionalInformation.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 === LegalEntityTypes.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,
+				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"
+			});
+		} 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, 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, requestingBanking(legalEntity), "banking");
+	updateOrCreateBusinessLinesIfNeeded(issuingBusinessLines, requestingIssuing(legalEntity), "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/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
+	};
+}
+function getRegistrationNumberLabel(country, companyType, data) {
+	return resolveFieldMetadata(registrationNumberDefaultFieldConfig[country], {
+		companyType,
+		registrationNumberType: data.registrationNumber ? inferCompanyRegistrationNumberType(data.registrationNumber, country, companyType) : getCompanyRegistrationNumberOptions(country, companyType)?.[0]?.id
+	}, registrationNumberDefaultFieldMetadata).label ?? "";
+}
+function getTaxIdLabel(country) {
+	return resolveFieldMetadata(taxInformationDefaultFieldConfig[country], {
+		taxIdNumberType: countryToTaxInfoTypeMap[country] ?? void 0,
+		companyType: void 0
+	}, taxInformationDefaultFieldMetadata).label ?? "";
+}
+var formatBasicInformation = (data, datasetUtils, companyType, isCountryOfGoverningLawEnabled) => {
+	const country = data.country;
+	return {
+		legalCompanyName: data.legalCompanyName,
+		country: datasetUtils.getCountryName(data.country),
+		[getKeyForField("stateOrProvince", data.country)]: datasetUtils.getStateName(data.stateOrProvince, data.country),
+		[getTaxIdLabel(country)]: data.taxInformation?.find((taxId) => data.country === taxId.country)?.number,
+		[getRegistrationNumberLabel(country, companyType, data)]: data.registrationNumber,
+		countryOfGoverningLaw: datasetUtils.getCountryName(getCountryOfGoverningLaw(isCountryOfGoverningLawEnabled, data))
+	};
+};
+var formatAdditionalInformation = (data, country, companyType) => {
+	return {
+		businessStructure: data.legalFormLabel,
+		doingBusinessAs: data.doingBusinessAs,
+		industry: data.industryCodes?.[0].name,
+		[getRegistrationNumberLabel(country, companyType, data)]: data.registrationNumber,
+		[getTaxIdLabel(country)]: !data.isUen && data.taxInformation?.find((taxId) => country === taxId.country)?.number,
+		vatNumber: data.vatNumber,
+		vatAbsenceReason: data.vatAbsenceReason,
+		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], data.basicInformation?.country, data.companyStructure?.entityType);
+			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 "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(data.additionalInformation?.registrationAddress, 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 === operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME) {
+				const operationalAddressSummaryItems = translateAndFilterMappedSummary(formatAddress(data.additionalInformation?.operationalAddress, 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" },
+	registrationAddress: { rule: "REQUIRED" },
+	operationalAddressIsSame: { rule: "REQUIRED" },
+	operationalAddress: { rule: "OPTIONAL" },
+	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: "ifCountryUsAndTinFailed" },
+	industryCodes: { rule: "isIndustryCodeRequired" }
+};
+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: {},
+	L_REGDOC: { registrationDocument: { rule: "REQUIRED" } },
+	L_TAXDOC: { taxDocument: { rule: "REQUIRED" } },
+	L_BAFIN: { legalForm: { rule: "REQUIRED" } }
+};
+//#endregion
+//#region src/components/Business/assets/business-details.png
+var business_details_default = "data:image/png;base64,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";
+//#endregion
+//#region src/components/Business/tasks/BusinessDetailsDropin/BusinessDetailsGettingStarted.tsx
+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("img", {
+				src: business_details_default,
+				alt: "business details illustration",
+				style: {
+					maxWidth: 200,
+					maxHeight: 165
+				}
+			}),
+			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/mapping/businessDetails/mapOrganizationTypeToCompanyType.ts
+/**
+* This is a mapping from our Adyen internal organization type values in KYC to our SDK and LEM company type values
+*
+* @param organizationType - Organization type value from KYC
+* @returns CompanyTypesValue
+*/
+var mapOrganizationTypeToCompanyType = (organizationType) => {
+	switch (organizationType) {
+		case "BUSINESS": return CompanyTypesValues.PRIVATE_COMPANY;
+		case "NON_PROFIT": return CompanyTypesValues.NON_PROFIT_OR_CHARITABLE;
+		case "PUBLIC_COMPANY":
+		case "LISTED_PUBLIC_COMPANY": return CompanyTypesValues.PUBLIC_COMPANY;
+		case "UNLISTED_PUBLIC_COMPANY": return CompanyTypesValues.UNLISTED_PUBLIC_COMPANY;
+		case "GOVERNMENTAL_ORGANIZATION": return CompanyTypesValues.GOVERNMENTAL_ORGANIZATION;
+		case "SOLE_PROPRIETOR": return CompanyTypesValues.SOLE_PROPRIETORSHIP;
+		case "PARTNERSHIP_INCORPORATED": return CompanyTypesValues.INCORPORATED_PARTNERSHIP;
+		case "ASSOCIATION_INCORPORATED": return CompanyTypesValues.INCORPORATED_ASSOCIATION;
+		default: return CompanyTypesValues.PRIVATE_COMPANY;
+	}
+};
+//#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("numberOfEmployees", "companyFinancialInformation")(financialInformation.numberOfEmployees);
+		if (financialInformation.financialReportingDate) form.handleChangeFor("financialReportingDate", "companyFinancialInformation")(financialInformation.financialReportingDate);
+		if (financialInformation.currency) form.handleChangeFor("currency", "companyFinancialInformation")(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("reportedValueOption", "companyFinancialInformation")(selectedReportedValueOption);
+			form.handleChangeFor(selectedReportedValueOption, "companyFinancialInformation")(selectedReportedValue);
+			form.handleChangeFor(nonSelectedReportedValueOption, "companyFinancialInformation")(null);
+		}
+	}
+};
+var applyVerifiedBusinessData = (form, country, verifiedData) => {
+	if (!verifiedData) return;
+	form.handleChangeFor("legalCompanyName", "basicInformation")(verifiedData.name);
+	if (country !== CountryCodes.UnitedStates) form.handleChangeFor("registrationNumber", "basicInformation")(verifiedData.registrationNumber);
+	if (form.defaultData?.additionalInformation?.registrationAddress?.address || form.defaultData?.additionalInformation?.operationalAddress?.address) return;
+	form.handleChangeFor("entityType", "companyStructure")(mapOrganizationTypeToCompanyType(verifiedData.companyType));
+	const verifiedAddress = {
+		...verifiedData.registeredAddress && { registrationAddress: {
+			...mapAddressData(verifiedData.registeredAddress),
+			country
+		} },
+		...verifiedData.principalPlaceOfBusinessAddress && { operationalAddress: {
+			...mapAddressData(verifiedData.principalPlaceOfBusinessAddress),
+			country
+		} }
+	};
+	if (verifiedData.principalPlaceOfBusinessAddress) form.handleChangeFor("operationalAddressIsSame", "additionalInformation", "input")(operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME);
+	if (verifiedAddress.registrationAddress) form.handleChangeFor("registrationAddress", "additionalInformation")(verifiedAddress.registrationAddress);
+	if (verifiedAddress.operationalAddress) form.handleChangeFor("operationalAddress", "additionalInformation")(verifiedAddress.operationalAddress);
+	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 tinMatched = 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;
+		tinMatched.value = void 0;
+		disallowedSelectionReason.value = void 0;
+		selectedCompanyIdx.value = -1;
+	};
+	return {
+		companySearchName,
+		selectedCompany,
+		verifiedBusiness,
+		tinMatched,
+		disallowedSelectionReason,
+		resetCompanySearchData,
+		disallowSelection: (reason) => {
+			resetCompanySearchData();
+			disallowedSelectionReason.value = reason;
+		},
+		setTinMatched: (value) => {
+			resetCompanySearchData();
+			tinMatched.value = value;
+		},
+		selectCompany: (selected, idx) => {
+			resetCompanySearchData();
+			selectedCompany.value = selected;
+			tinMatched.value = selected.tinMatched;
+			/** `-1` indicates auto-selection, not a manual user interaction */
+			if (idx > -1) {
+				selectedCompanyIdx.value = idx;
+				selectBusinessAnalytics(userEvents, idx);
+			}
+		},
+		confirmCompany: (multiform, country) => {
+			verifiedBusiness.value = selectedCompany.value;
+			applyVerifiedBusinessData(multiform, country, selectedCompany.value);
+			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/Shared/fields/CountryOfGoverningLawField/validate.ts
+var CountryOfGoverningLawFieldValidation = () => ({ countryOfGoverningLaw: {
+	modes: ["blur"],
+	validate: (countryOfGoverningLaw) => !isEmpty(countryOfGoverningLaw),
+	errorMessage: "fieldIsRequired"
+} });
+//#endregion
+//#region src/components/Business/tasks/BusinessDetailsDropin/validate.ts
+function basicInformationValidators({ country, taxIdNumberType, companyType, registrationNumberType, state, isFeatureEnabled }) {
+	return {
+		country: CountryFieldValidation().country,
+		countryOfGoverningLaw: CountryOfGoverningLawFieldValidation().countryOfGoverningLaw,
+		legalCompanyName: resolveFieldMetadata(isFeatureEnabled("StrictNameAndAddressValidationV4") ? defaultFieldConfigV4[country] : defaultFieldConfig$2[country], {}, isFeatureEnabled("StrictNameAndAddressValidationV4") ? defaultFieldMetadataV4 : defaultFieldMetadata$2).validators,
+		taxInformation: resolveFieldMetadata(taxInformationDefaultFieldConfig[country], {
+			taxIdNumberType,
+			companyType
+		}, taxInformationDefaultFieldMetadata).validators,
+		stateOrProvince: resolveFieldMetadata(defaultFieldConfig[country], { isBusiness: true }, defaultFieldMetadata).validators,
+		registrationNumber: resolveFieldMetadata(registrationNumberDefaultFieldConfig[country], {
+			companyType,
+			registrationNumberType,
+			state,
+			isFeatureEnabled
+		}, registrationNumberDefaultFieldMetadata).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 additionalInformationValidators({ country, taxIdNumberType, companyType, registrationNumberType, vatNumberType, isFeatureEnabled }) {
+	return {
+		hasDoingBusinessAs: doingBusinessAsAbsentFieldMetadata.validators,
+		doingBusinessAs: doingBusinessAsFieldMetadata.validators,
+		registrationNumber: resolveFieldMetadata(registrationNumberDefaultFieldConfig[country], {
+			companyType,
+			registrationNumberType,
+			isFeatureEnabled
+		}, registrationNumberDefaultFieldMetadata).validators,
+		exemptedFromRegistrationNumber: exemptFromRegistrationNumberDefaultFieldMetadata.validators,
+		taxInformation: resolveFieldMetadata(taxInformationDefaultFieldConfig[country], {
+			taxIdNumberType,
+			companyType
+		}, taxInformationDefaultFieldMetadata).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
+	};
+}
+//#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, asModal = false }) {
+	const { t, i18n } = useTranslation(["common", "business"]);
+	const userEvents = useAnalyticsContext();
+	const { isFeatureEnabled } = useToggleContext();
+	const isBusinessDetailsModalEnabled = isFeatureEnabled("EnableBusinessDetailsModal") && taskType === TaskTypes.BUSINESS_DETAILS;
+	const { isSettingEnabled } = useSettingsContext();
+	const { accountHolder } = useAccountHolder();
+	const logger = createLogger();
+	/**
+	* Analytics
+	*/
+	useTaskLandedEvent(taskType);
+	const isAssociationTaskType = taskType !== TaskTypes.BUSINESS_DETAILS;
+	const legalEntityType = taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY ? LegalEntityTypes.SOLE_PROPRIETORSHIP : LegalEntityTypes.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 defaultForms = useMemo$1(() => getForms(country, taskType, isFeatureEnabled), [
+		country,
+		taskType,
+		isFeatureEnabled
+	]);
+	const { data: matchingScenario } = useScenarios(country, LegalEntityTypes.ORGANIZATION);
+	useEffect$1(() => {
+		if (!matchingScenario) return;
+		const isRequestingIssuing = requestingIssuing(legalEntityResponse), hasIssuingScenario = matchingScenario.includes("L_ISSUING");
+		if (isRequestingIssuing || hasIssuingScenario) {
+			const scenarioMatches = isRequestingIssuing && hasIssuingScenario;
+			userEvents.addTaskEvent(scenarioMatches ? "Success" : "Encountered error", {
+				actionType: "verify",
+				label: "issuingCapabilitiesMatchScenario"
+			});
+		}
+		const isRequestingBanking = requestingBanking(legalEntityResponse), hasBankingScenario = matchingScenario.includes("L_BANKING");
+		if (isRequestingBanking || hasBankingScenario) {
+			const scenarioMatches = isRequestingBanking && hasBankingScenario;
+			userEvents.addTaskEvent(scenarioMatches ? "Success" : "Encountered error", {
+				actionType: "verify",
+				label: "bankingCapabilitiesMatchScenario"
+			});
+		}
+	}, [
+		userEvents,
+		matchingScenario,
+		legalEntityResponse
+	]);
+	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 ?? data?.additionalInformation?.taxInformation;
+		const taxIdType = taxInfo?.length ? taxInfo.find((taxId) => taxId.country === country)?.type : void 0;
+		const regNumberType = data?.basicInformation?.registrationNumberType ?? data?.additionalInformation?.registrationNumberType;
+		const companyType = taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY ? CompanyTypesValues.SOLE_PROPRIETORSHIP : data?.companyStructure?.entityType;
+		return {
+			basicInformation: basicInformationValidators({
+				country,
+				state: data?.basicInformation?.stateOrProvince,
+				companyType,
+				taxIdNumberType: taxIdType,
+				registrationNumberType: regNumberType,
+				isFeatureEnabled
+			}),
+			businessSelection: businessSelectionValidators(),
+			companyStructure: CompanyStructureValidation,
+			additionalInformation: additionalInformationValidators({
+				country,
+				taxIdNumberType: taxIdType,
+				companyType,
+				registrationNumberType: regNumberType,
+				vatNumberType: data?.additionalInformation?.vatNumberType,
+				isFeatureEnabled
+			}),
+			companyFinancialInformation: financialInfoValidationWithEmployeesRules
+		};
+	}, [
+		country,
+		isFeatureEnabled,
+		taskType
+	]);
+	const multiForm = useMultiForm({
+		defaultData,
+		allFields: derivedProps?.allFields,
+		requiredFields: derivedProps?.requiredFields,
+		optionalFields: derivedProps?.optionalFields,
+		obscuredFields: derivedProps?.obscuredFields,
+		trustedFields: derivedProps?.trustedFields,
+		rules: buildFieldValidations
+	});
+	/**
+	* 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({
+		matchingScenario,
+		data: multiForm.data,
+		defaultData,
+		verifiedBusiness: companySearchStateModel.verifiedBusiness.value,
+		country,
+		taskType,
+		isFeatureEnabled,
+		isSettingEnabled,
+		accountHolder,
+		tinMatched: isTinMatched.value,
+		rootLegalEntity: legalEntityResponse
+	}), [
+		multiForm.data,
+		defaultData,
+		matchingScenario,
+		companySearchStateModel.verifiedBusiness.value,
+		country,
+		taskType,
+		isFeatureEnabled,
+		isSettingEnabled,
+		accountHolder,
+		isTinMatched.value,
+		legalEntityResponse
+	]);
+	useEffect$1(() => {
+		setDerivedProps(getPropsFromConfigurations({
+			scenarioConfiguration: fieldConfigurations,
+			forms: defaultForms,
+			remediationActions: problems.remediationActions ? Object.values(problems.remediationActions) : [],
+			dataMissingErrors: problems.missingData ?? [],
+			fieldsWithExistingData: subjectEntity ? subjectEntity.type === LegalEntityTypes.SOLE_PROPRIETORSHIP ? getFieldsWithExistingData(subjectEntity, solePropBusinessDetailsApiKeyMapping, solePropBusinessDetailsDocumentMapping) : getFieldsWithExistingData(subjectEntity, businessDetailsApiKeyMapping, businessDetailsDocumentMapping) : [],
+			customRules,
+			legalEntityType: subjectEntity?.type,
+			legalEntityTrustedFields: trustedFields
+		}));
+	}, [
+		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("entityType", "companyStructure")(null);
+	}
+	/**
+	* 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 (!isFeatureEnabled("EnableUnifiedCompanySearch") || taskType !== "BUSINESS_DETAILS") return void 0;
+		if (multiForm.data.companyStructure?.entityType && multiForm.data.companyStructure?.entityType === "associationIncorporated" || multiForm.data.companyStructure?.entityType === "partnershipIncorporated") return;
+		const registrationNumberType = multiForm.data.basicInformation?.registrationNumberType;
+		const taxIdNumberType = multiForm.data.basicInformation?.taxInformation?.find((taxInformation) => taxInformation.country === country)?.type;
+		const registrationNumberExempt = multiForm.data.basicInformation?.exemptedFromRegistrationNumber;
+		const availableCompanyStructures = getAvailableCompanyStructures({
+			country,
+			registrationNumberType,
+			registrationNumberExempt,
+			taxIdNumberType,
+			legalEntity: legalEntityResponse,
+			accountHolder,
+			isSettingEnabled
+		});
+		return availableCompanyStructures.length === 1 ? availableCompanyStructures[0] : void 0;
+	}, [
+		accountHolder,
+		country,
+		isFeatureEnabled,
+		isSettingEnabled,
+		legalEntityResponse,
+		multiForm.data.basicInformation?.exemptedFromRegistrationNumber,
+		multiForm.data.basicInformation?.registrationNumberType,
+		multiForm.data.basicInformation?.taxInformation,
+		multiForm.data.companyStructure?.entityType,
+		taskType
+	]);
+	const applyInferredCompanyStructure = () => {
+		if (!inferredCompanyStructure) return;
+		if (multiForm.data.companyStructure?.entityType === inferredCompanyStructure) return;
+		multiForm.handleChangeFor("entityType", "companyStructure")(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();
+			} catch (error) {
+				logger.error(error);
+			} finally {
+				setIsAddingBusinessDetails(false);
+				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 (companySearchStateModel.tinMatched.value === false) isTinMatched.value = false;
+		handleNextClick(getRequiredForms({
+			skipBusinessSelection: skipBusinessSelection.value,
+			skipCompanyStructure: !!companySearchStateModel.verifiedBusiness.value?.legalForm
+		}));
+	};
+	usePrefetchCompanySearch({
+		country,
+		multiForm,
+		activeFormId: activeForm.formId,
+		isUsingCompanySearch: isUsingCompanySearch(country, taskType)
+	});
+	const { attemptBusinessSearch, confirmBusinessSelection } = useCompanySearchNextClickOverrides({
+		country,
+		multiForm,
+		companySearchStateModel,
+		getRequiredForms,
+		skipBusinessSelection,
+		setLoadingStatus,
+		isTinMatched,
+		tinMismatchModalOpen,
+		legalArrangementModalOpen
+	});
+	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 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 defaultDataSummarySections = useMemo$1(() => formatDataForSummary(multiForm.defaultData ?? {}, forms, t, i18n.language, isFeatureEnabled), [
+		multiForm.defaultData,
+		forms,
+		t,
+		i18n.language,
+		isFeatureEnabled
+	]);
+	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;
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [isBusinessDetailsModalEnabled && /* @__PURE__ */ jsx(BusinessDetailsGettingStarted, {
+		openModal: () => {
+			setIsAddingBusinessDetails(true);
+			setHasEnteredFormFlowBefore(true);
+		},
+		handleCancelClick: () => handleHomeClick?.(),
+		data: defaultDataSummarySections,
+		t
+	}), (!isBusinessDetailsModalEnabled || isAddingBusinessDetails || shouldAutoOpenFormForErrors) && /* @__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 || asModal,
+			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(BusinessDetailsMultiform, {
+						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 })
+					})
+				]
+			})
+		})
+	})] });
+}
+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"
+	});
+}
+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"
+	});
+}
+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?.address && verifiedAddress.city && verifiedAddress.stateOrProvince && verifiedAddress.postalCode ? `${verifiedAddress.address} ${verifiedAddress.city} ${verifiedAddress.stateOrProvince} ${verifiedAddress.postalCode}` : verifiedAddress?.address;
+	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 LazyJpAddress = lazy(async () => (await import("./JpAddress-CCm4vAW3.js")).JpAddress);
+var ADDITIONAL_INFORMATION_FORM_ID = "additionalInformation";
+var ADDITIONAL_INFORMATION_FIELDS = [
+	...DBA_NAME_FIELD,
+	...BUSINESS_REGISTRATION_NUMBER_FIELD,
+	...TAX_INFORMATION_FIELD,
+	...VAT_NUMBER_FIELD,
+	...INDUSTRY_CODE_FIELD,
+	...DATE_OF_INCORPORATION_FIELD,
+	...STOCK_EXCHANGE_MIC_FIELD,
+	...STOCK_ISIN_FIELD,
+	...STOCK_TICKER_SYMBOL_FIELD,
+	...EINVOICING_CODE_FIELD,
+	"legalFormDescription",
+	...LEGAL_FORM_FIELDS,
+	...registrationAddressFields
+];
+var EMPTY_OBJ = {};
+function AdditionalInformation({ id, country, companyType, shouldValidate, fieldValidationErrors = EMPTY_OBJ, formVerificationErrors = EMPTY_OBJ }) {
+	const { t, i18n } = useTranslation(["common", "business"]);
+	const { t: businessT } = useTranslation("business");
+	const { form } = useFormContext();
+	const { isFeatureEnabled } = useToggleContext();
+	const { data: rootLegalEntity } = useLegalEntity(ROOT_LE);
+	const verifiedBusiness = useContext$1(CompanySearchStateContext).verifiedBusiness.value;
+	const showVerified = !!verifiedBusiness;
+	const showStockData = companyType === CompanyTypesValues.PUBLIC_COMPANY;
+	const addressSchema = getAddressSchemaForCountry(country).filter((field) => !COUNTRIES_WITH_STATES_DATASET.includes(country) ? field !== "stateOrProvince" : true);
+	const currentCountryTaxInformation = form.data.additionalInformation?.taxInformation?.find((taxId) => taxId.country === country);
+	const businessLineTypes = [];
+	if (requestingBanking(rootLegalEntity)) businessLineTypes.push("banking");
+	if (requestingIssuing(rootLegalEntity)) businessLineTypes.push("issuing");
+	const [addressToCheck, setAddressToCheck] = useDebouncedState(500);
+	const { data: cleansedRegistrationAddress } = useAddressCleanse({
+		text: addressToCheck,
+		country
+	}, { enabled: Boolean(addressToCheck) });
+	const mustProvideOperationalAddress = cleansedRegistrationAddress?.poBox ?? false;
+	useEffect$1(() => setAddressToCheck(formatAddressForCleanse(form.data.additionalInformation?.registrationAddress ?? {})), [form.data.additionalInformation?.registrationAddress, setAddressToCheck]);
+	/**
+	* 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 (form.defaultData?.additionalInformation?.registrationAddress?.address || form.defaultData?.additionalInformation?.operationalAddress?.address) return { override: { address: "" } };
+		return {
+			...verifiedBusiness.registeredAddress && { registrationAddress: mapAddressData(verifiedBusiness.registeredAddress) },
+			...verifiedBusiness.principalPlaceOfBusinessAddress && { operationalAddress: mapAddressData(verifiedBusiness.principalPlaceOfBusinessAddress) }
+		};
+	}, [
+		verifiedBusiness,
+		form.defaultData?.additionalInformation?.registrationAddress?.address,
+		form.defaultData?.additionalInformation?.operationalAddress?.address
+	]);
+	const registrationAddressValid = useRef$1(false);
+	const operationalAddressValid = useRef$1(false);
+	if (form.valid.additionalInformation?.registrationAddress !== registrationAddressValid.current) form.setValid("registrationAddress", registrationAddressValid.current, "additionalInformation");
+	if (form.data.additionalInformation?.operationalAddressIsSame === operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME && form.valid.additionalInformation?.operationalAddress !== operationalAddressValid.current) form.setValid("operationalAddress", operationalAddressValid.current, "additionalInformation");
+	const handleChangeFor = useCallback$1((fieldName, mode) => form.handleChangeFor(fieldName, "additionalInformation", mode), [form]);
+	const handleRegistrationAddressChange = (state) => {
+		handleChangeFor("registrationAddress")(state.data);
+		form.setValid("registrationAddress", Boolean(state.isValid), "additionalInformation");
+		registrationAddressValid.current = Boolean(state.isValid);
+	};
+	const handleOperationalAddressChange = (state) => {
+		handleChangeFor("operationalAddress")(state.data);
+		form.setValid("operationalAddress", Boolean(state.isValid), "additionalInformation");
+		operationalAddressValid.current = Boolean(state.isValid);
+	};
+	const handleOperationalAddressIsSameChange = useCallback$1((isChecked) => {
+		if (isChecked) {
+			handleChangeFor("operationalAddressIsSame")(operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_SAME);
+			form.setValid("operationalAddress", true, "additionalInformation");
+		} else handleChangeFor("operationalAddressIsSame")(operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME);
+	}, [form, handleChangeFor]);
+	if (form.data.additionalInformation?.operationalAddressIsSame === null) handleOperationalAddressIsSameChange(true);
+	useEffect$1(() => {
+		if (mustProvideOperationalAddress && form.data.additionalInformation?.operationalAddressIsSame !== operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME) handleOperationalAddressIsSameChange(false);
+	}, [
+		handleOperationalAddressIsSameChange,
+		mustProvideOperationalAddress,
+		form.data.additionalInformation?.operationalAddressIsSame
+	]);
+	const formUtils = useMemo$1(() => {
+		const initialProps = {
+			data: form.data.additionalInformation ?? {},
+			fieldValidationErrors,
+			formVerificationErrors,
+			allFields: form.allFields?.additionalInformation ?? [],
+			requiredFields: form.requiredFields?.additionalInformation ?? [],
+			optionalFields: form.optionalFields?.additionalInformation ?? [],
+			trustedFields: form.trustedFields?.additionalInformation ?? [],
+			obscuredFields: form.obscuredFields?.additionalInformation ?? [],
+			errors: form.errors.additionalInformation ?? {},
+			valid: form.valid.additionalInformation ?? {},
+			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 "registrationNumber": return mergeFieldMetadataIntoProps(field, resolveFieldMetadata(registrationNumberDefaultFieldConfig[country], { registrationNumberType: form.data.additionalInformation?.registrationNumberType }, registrationNumberDefaultFieldMetadata), acc);
+				case "taxInformation": return mergeFieldMetadataIntoProps(field, resolveFieldMetadata(taxInformationDefaultFieldConfig[country], {
+					taxIdNumberType: currentCountryTaxInformation?.type,
+					companyType
+				}, taxInformationDefaultFieldMetadata), acc);
+				case "vatNumber": return mergeFieldMetadataIntoProps(field, resolveFieldMetadata(defaultFieldConfig$1[country], { vatNumberType: form.data.additionalInformation?.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);
+	}, [
+		companyType,
+		country,
+		currentCountryTaxInformation?.type,
+		form.allFields?.additionalInformation,
+		form.data.additionalInformation,
+		form.errors.additionalInformation,
+		form.obscuredFields?.additionalInformation,
+		form.optionalFields?.additionalInformation,
+		form.requiredFields?.additionalInformation,
+		form.trustedFields?.additionalInformation,
+		form.valid.additionalInformation,
+		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) });
+	const datasetUtils = datasetUtilities(i18n.language);
+	const registrationAddressDescription = useMemo$1(() => {
+		return [
+			"US",
+			"NL",
+			"CZ"
+		].includes(country) ? t(($) => $["youBusinessOfficalAddressInTheCounty"], {
+			ns: "business",
+			country: datasetUtils.getCountryName(country)
+		}) : t(($) => $["youBusinessOfficalAddressInCounty"], {
+			ns: "business",
+			country: datasetUtils.getCountryName(country)
+		});
+	}, [
+		country,
+		datasetUtils,
+		t
+	]);
+	const showJapanLocalization = isJapanLocalizationEnabled(isFeatureEnabled, country);
+	let readOnlyAddressFields = [];
+	if (verifiedBusiness?.registeredAddress?.state && verifiedBusiness.registeredAddress.state === form.data.basicInformation?.stateOrProvince) readOnlyAddressFields = ["stateOrProvince"];
+	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(form.data.additionalInformation ?? {}, LEGAL_FORM_FIELDS).legalForm },
+							valid: formUtils.getFieldValid(form.valid.additionalInformation ?? {}, LEGAL_FORM_FIELDS),
+							errorMessage: form.errors.additionalInformation?.legalForm?.errorMessage,
+							handleChangeFor,
+							readonly: false,
+							label: formUtils.getLabel("legalForm", "businessStructure")
+						}),
+						showField(DBA_NAME_FIELD) && /* @__PURE__ */ jsx(DBANameField, {
+							data: formUtils.getFieldData(form.data.additionalInformation ?? {}, DBA_NAME_FIELD),
+							valid: formUtils.getFieldValid(form.valid.additionalInformation ?? {}, DBA_NAME_FIELD),
+							errors: formUtils.getFieldErrors(form.errors.additionalInformation ?? {}, fieldValidationErrors, DBA_NAME_FIELD),
+							readonly: formUtils.isReadOnly("doingBusinessAs"),
+							handleChangeFor
+						}),
+						showField(BUSINESS_REGISTRATION_NUMBER_FIELD) && /* @__PURE__ */ jsx(BusinessRegistrationNumberField, {
+							data: formUtils.getFieldData(form.data.additionalInformation ?? {}, BUSINESS_REGISTRATION_NUMBER_FIELD),
+							valid: formUtils.getFieldValid(form.valid.additionalInformation ?? {}, BUSINESS_REGISTRATION_NUMBER_FIELD),
+							errors: formUtils.getFieldErrors(form.errors.additionalInformation ?? {}, fieldValidationErrors, BUSINESS_REGISTRATION_NUMBER_FIELD),
+							helperText: getRegistrationNumberHelperText(businessT, {
+								country,
+								companyType
+							}),
+							readonly: formUtils.isReadOnly("registrationNumber"),
+							optional: formUtils.isOptionalField("registrationNumber"),
+							shouldValidate,
+							handleChangeFor,
+							country,
+							canExempt: showField(["exemptedFromRegistrationNumber"]),
+							companyType
+						}),
+						showField(TAX_INFORMATION_FIELD) && /* @__PURE__ */ jsx(TaxInformationField, {
+							data: formUtils.getFieldData(form.data.additionalInformation ?? {}, TAX_INFORMATION_FIELD),
+							valid: formUtils.getFieldValid(form.valid.additionalInformation ?? {}, TAX_INFORMATION_FIELD),
+							errors: formUtils.getFieldErrors(form.errors.additionalInformation ?? {}, fieldValidationErrors, TAX_INFORMATION_FIELD),
+							labels: formUtils.getFieldLabels(TAX_INFORMATION_FIELD, { exemptedFromTax: "iDontHaveATaxId" }),
+							mask: formUtils.getMask("taxInformation"),
+							readonly: formUtils.isReadOnly("taxInformation"),
+							shouldValidate,
+							handleChangeFor,
+							canExempt: showField(["exemptedFromTax"]),
+							country,
+							entityType: companyType,
+							defaultData: form.defaultData?.additionalInformation?.taxInformation,
+							registrationNumber: form.data.additionalInformation?.registrationNumber
+						}),
+						showField(VAT_NUMBER_FIELD) && /* @__PURE__ */ jsx(VatNumberField, {
+							data: formUtils.getFieldData(form.data.additionalInformation ?? {}, VAT_NUMBER_FIELD),
+							valid: formUtils.getFieldValid(form.valid.additionalInformation ?? {}, VAT_NUMBER_FIELD),
+							errors: formUtils.getFieldErrors(form.errors.additionalInformation ?? {}, 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
+						}),
+						formUtils.isRequiredField("eInvoicingCode", false) && /* @__PURE__ */ jsx(EInvoicingCodeField, {
+							data: formUtils.getFieldData(form.data.additionalInformation ?? {}, EINVOICING_CODE_FIELD),
+							valid: formUtils.getFieldValid(form.valid.additionalInformation ?? {}, EINVOICING_CODE_FIELD),
+							errors: formUtils.getFieldErrors(form.errors.additionalInformation ?? {}, 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(form.data.additionalInformation ?? {}, INDUSTRY_CODE_FIELD),
+							valid: formUtils.getFieldValid(form.valid.additionalInformation ?? {}, INDUSTRY_CODE_FIELD),
+							errors: formUtils.getFieldErrors(form.errors.additionalInformation ?? {}, 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(form.data.additionalInformation ?? {}, DATE_OF_INCORPORATION_FIELD),
+							valid: formUtils.getFieldValid(form.valid.additionalInformation ?? {}, DATE_OF_INCORPORATION_FIELD),
+							errors: formUtils.getFieldErrors(form.errors.additionalInformation ?? {}, fieldValidationErrors, DATE_OF_INCORPORATION_FIELD),
+							placeholder: t(($) => $["datePlaceholder"]),
+							readonly: formUtils.isReadOnly("dateOfIncorporation"),
+							handleChangeFor
+						})
+					] })] }),
+					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(form.data.additionalInformation ?? {}, STOCK_EXCHANGE_MIC_FIELD),
+							valid: formUtils.getFieldValid(form.valid.additionalInformation ?? {}, STOCK_EXCHANGE_MIC_FIELD),
+							errors: formUtils.getFieldErrors(form.errors.additionalInformation ?? {}, 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(form.data.additionalInformation ?? {}, STOCK_ISIN_FIELD),
+							valid: formUtils.getFieldValid(form.valid.additionalInformation ?? {}, STOCK_ISIN_FIELD),
+							errors: formUtils.getFieldErrors(form.errors.additionalInformation ?? {}, 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(form.data.additionalInformation ?? {}, STOCK_TICKER_SYMBOL_FIELD),
+							valid: formUtils.getFieldValid(form.valid.additionalInformation ?? {}, STOCK_TICKER_SYMBOL_FIELD),
+							errors: formUtils.getFieldErrors(form.errors.additionalInformation ?? {}, fieldValidationErrors, STOCK_TICKER_SYMBOL_FIELD),
+							mask: formUtils.getMask("stockTickerSymbol"),
+							readonly: formUtils.isReadOnly("stockTickerSymbol"),
+							shouldValidate,
+							handleChangeFor
+						})
+					] })] }),
+					/* @__PURE__ */ jsxs("section", {
+						"data-testid": "registeredBusinessAddress",
+						children: [/* @__PURE__ */ jsxs("div", {
+							className: AdditionalInformation_module_default.additionalInformationSectionHeading,
+							children: [/* @__PURE__ */ jsx(Typography, {
+								el: "h3",
+								variant: "title",
+								children: t(($) => $["registeredBusinessAddress"], { ns: "business" })
+							}), /* @__PURE__ */ jsx(Typography, {
+								el: "p",
+								variant: "body",
+								children: registrationAddressDescription
+							})]
+						}), showJapanLocalization ? /* @__PURE__ */ jsx(Suspense, {
+							fallback: /* @__PURE__ */ jsx(Loader, {}),
+							children: /* @__PURE__ */ jsx(LazyJpAddress, {
+								id: ADDITIONAL_INFORMATION_FORM_ID,
+								addressType: "registrationAddress",
+								data: {
+									...form.data.additionalInformation?.registrationAddress,
+									country
+								},
+								shouldValidate,
+								onChange: handleRegistrationAddressChange
+							})
+						}) : /* @__PURE__ */ jsx(Address, {
+							id: ADDITIONAL_INFORMATION_FORM_ID,
+							addressType: "registrationAddress",
+							data: {
+								...form.data.additionalInformation?.registrationAddress,
+								country
+							},
+							labels: getAddressSchemaLabelsByCountry(country),
+							requiredFields: addressSchema,
+							shouldValidate,
+							hideCountry: true,
+							optionalFields: ["otherAddressInformation"],
+							readOnlyFields: readOnlyAddressFields,
+							trustedFields: getNestedTrustedFields("registrationAddress", form.data.additionalInformation, form.trustedFields?.additionalInformation),
+							onChange: handleRegistrationAddressChange,
+							verifiedBusiness,
+							verifiedAddress: verifiedAddress?.registrationAddress,
+							condensed: true
+						})]
+					}),
+					/* @__PURE__ */ jsxs("section", {
+						"data-testid": "principalPlaceOfBusiness",
+						children: [
+							/* @__PURE__ */ jsxs("div", {
+								className: AdditionalInformation_module_default.additionalInformationSectionHeading,
+								children: [/* @__PURE__ */ jsx(Typography, {
+									el: "h3",
+									variant: "title",
+									children: t(($) => $["principalPlaceOfBusiness"], { ns: "business" })
+								}), /* @__PURE__ */ jsx(Typography, {
+									el: "p",
+									variant: "body",
+									children: t(($) => $["thePhysicalLocationWhereABusiness"], { ns: "business" })
+								})]
+							}),
+							!mustProvideOperationalAddress && /* @__PURE__ */ jsx(Field, {
+								el: "fieldset",
+								name: "operationalAddressIsSame",
+								errorMessage: form.errors.additionalInformation?.operationalAddressIsSame?.errorMessage,
+								isValid: form.valid.additionalInformation?.operationalAddressIsSame,
+								children: (childProps) => /* @__PURE__ */ jsx(Checkbox, {
+									...childProps,
+									"aria-required": formUtils.isRequiredField("operationalAddressIsSame"),
+									"aria-invalid": !form.valid.additionalInformation?.operationalAddressIsSame,
+									name: "operationalAddressIsSame",
+									label: formUtils.getLabel("sameAsRegisteredAddress"),
+									checked: form.data.additionalInformation?.operationalAddressIsSame ? form.data.additionalInformation.operationalAddressIsSame === operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_SAME : true,
+									onChange: handleOperationalAddressIsSameChange
+								})
+							}),
+							form.data.additionalInformation?.operationalAddressIsSame === operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME && (showJapanLocalization ? /* @__PURE__ */ jsx(Suspense, {
+								fallback: /* @__PURE__ */ jsx(Loader, {}),
+								children: /* @__PURE__ */ jsx(LazyJpAddress, {
+									id: ADDITIONAL_INFORMATION_FORM_ID,
+									addressType: "operationalAddress",
+									data: {
+										...form.data.additionalInformation.operationalAddress,
+										country
+									},
+									shouldValidate,
+									onChange: handleOperationalAddressChange
+								})
+							}) : /* @__PURE__ */ jsx(Address, {
+								id: ADDITIONAL_INFORMATION_FORM_ID,
+								addressType: "operationalAddress",
+								data: {
+									...form.defaultData?.additionalInformation?.operationalAddress,
+									country
+								},
+								labels: getAddressSchemaLabelsByCountry(country),
+								requiredFields: addressSchema,
+								shouldValidate,
+								hideCountry: true,
+								optionalFields: ["otherAddressInformation"],
+								trustedFields: getNestedTrustedFields("operationalAddress", form.data.additionalInformation, form.trustedFields?.additionalInformation),
+								onChange: handleOperationalAddressChange,
+								verifiedBusiness,
+								verifiedAddress: verifiedAddress?.operationalAddress,
+								condensed: true
+							}))
+						]
+					})
+				]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/Business/forms/BusinessDetails/forms.ts
+var FIELDS_NEEDED_FOR_COMPANY_SEARCH = [
+	...STATE_FIELD,
+	...TAX_INFORMATION_FIELD,
+	...BUSINESS_REGISTRATION_NUMBER_FIELD
+];
+var getBasicInformationFields = (country, taskType, isFeatureEnabled) => {
+	if (!isUsingCompanySearch(country, taskType)) return isFeatureEnabled("EnableUnifiedCompanySearch") ? BASIC_INFORMATION_FIELDS : BASIC_INFORMATION_FIELDS.filter((field) => !FIELDS_NEEDED_FOR_COMPANY_SEARCH.includes(field));
+	return BASIC_INFORMATION_FIELDS;
+};
+var getAdditionalInformationFields = (country, taskType, isFeatureEnabled) => {
+	if (isUsingCompanySearch(country, taskType) || isFeatureEnabled("EnableUnifiedCompanySearch")) return ADDITIONAL_INFORMATION_FIELDS.filter((field) => !FIELDS_NEEDED_FOR_COMPANY_SEARCH.includes(field));
+	return ADDITIONAL_INFORMATION_FIELDS;
+};
+var getFinancialInformationFields = (country) => {
+	return country === CountryCodes.UnitedKingdom ? financialInformationFields : financialInformationFieldsForEu;
+};
+var staticBusinessDetailsForms = {
+	businessSelection: {
+		formId: "businessSelection",
+		formName: "businessSelectionFormName",
+		fields: BUSINESS_SELECTION_FIELDS
+	},
+	companyStructure: {
+		formId: "companyStructure",
+		formName: "companyStructureFormName",
+		fields: COMPANY_STRUCTURE_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"]
+	},
+	companyProofOfOwnershipDocument: {
+		formId: "companyProofOfOwnershipDocument",
+		formName: "proofOfOwnershipFormName",
+		fields: ["proofOfOwnership"]
+	},
+	companyConstitutionalDocument: {
+		formId: "companyConstitutionalDocument",
+		formName: "constitutionalDocumentFormName",
+		fields: ["constitutionalDocument"]
+	}
+};
+var getForms = (country, taskType, isFeatureEnabled) => ({
+	basicInformation: {
+		formId: "basicInformation",
+		formName: "basicInformationFormName",
+		fields: getBasicInformationFields(country, taskType, isFeatureEnabled)
+	},
+	businessSelection: staticBusinessDetailsForms.businessSelection,
+	companyStructure: staticBusinessDetailsForms.companyStructure,
+	additionalInformation: {
+		formId: "additionalInformation",
+		formName: "additionalInformationFormName",
+		fields: getAdditionalInformationFields(country, taskType, isFeatureEnabled)
+	},
+	companyRegistrationDocument: staticBusinessDetailsForms.companyRegistrationDocument,
+	companyTaxDocument: staticBusinessDetailsForms.companyTaxDocument,
+	companyProofOfDirectorDocument: staticBusinessDetailsForms.companyProofOfDirectorDocument,
+	companyProofOfSignatoryDocument: staticBusinessDetailsForms.companyProofOfSignatoryDocument,
+	companyProofOfOwnershipDocument: staticBusinessDetailsForms.companyProofOfOwnershipDocument,
+	companyFinancialInformation: {
+		formId: "companyFinancialInformation",
+		formName: "financialInformation",
+		fields: getFinancialInformationFields(country)
+	},
+	companyConstitutionalDocument: staticBusinessDetailsForms.companyConstitutionalDocument
+});
+var documentFormsIds = [
+	"companyRegistrationDocument",
+	"companyTaxDocument",
+	"companyProofOfDirectorDocument",
+	"companyProofOfSignatoryDocument",
+	"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).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 };