@adyen/kyc-components 4.24.1 → 4.25.0-beta.0

package/dist/{GlobalEntryModal-iZSUeMQf.js → GlobalEntryModal-DLC7METR.js}

@@ -1,58 +1,371 @@
 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] = "5f5a2983-bc2f-448b-bece-ce62f084780e", e._sentryDebugIdIdentifier = "sentry-dbid-5f5a2983-bc2f-448b-bece-ce62f084780e");
+	n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "a8a6b4fc-829a-4a1c-8661-6c7fca42e759", e._sentryDebugIdIdentifier = "sentry-dbid-a8a6b4fc-829a-4a1c-8661-6c7fca42e759");
 } catch (e) {}
 import { n as addResourceBundles, r as useTranslation } from "./translation-DbATp_35.js";
 import { t as createLogger } from "./logger-Z8AeTE4x.js";
 import { t as Typography } from "./Typography-CAc_f5Iq.js";
-import { t as Button } from "./Button-DPJ1k02w.js";
+import { t as Loader } from "./Loader-BVtlpTeo.js";
+import { t as Button } from "./Button-DpPFIUJx.js";
+import { s as useApiContext } from "./http-DsJtugN1.js";
 import { t as getLegalEntityCountry } from "./getLegalEntityCountry-BK-HHa65.js";
 import { t as useAccountHolder } from "./useAccountHolder-BpIX1iBG.js";
 import { s as keysOf } from "./genUtils-nphCwt1A.js";
+import { y as isEmpty } from "./validatorUtils-D2O6AAZn.js";
 import { t as useToggleContext } from "./useToggleContext-B_YexrbT.js";
 import { t as _rolldown_dynamic_import_helper_default } from "./_rolldown_dynamic_import_helper-sGNwd-kR.js";
 import { t as StackLayout } from "./StackLayout-IUdNMDgW.js";
 import { t as Header } from "./Header-DVLlJ6we.js";
 import { t as useAllowedCountries } from "./useAllowedCountries-qyvo-c6A.js";
 import { t as CountryCodes } from "./country-code-CJk2hdPu.js";
-import { t as Alert } from "./Alert-Cc7p0N5h.js";
+import { t as Alert } from "./Alert-Bv9M3wLb.js";
 import { y as reverseMapping } from "./processCapabilities-CWE5UFt8.js";
 import { t as TaskTypes } from "./taskTypes-3vSkMBDm.js";
 import { f as hasSolePropInLegalEntity, s as getOwnEntityAssociations } from "./entityAssociationUtil-CY0grcyH.js";
+import { t as useAnalyticsContext } from "./useAnalyticsContext-gSnRnYgV.js";
 import { t as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-BdcoiUby.js";
 import { t as Card } from "./Card-BCGLpdw7.js";
 import { t as useToastContext } from "./useToastContext-B6Mqc2HY.js";
+import { t as LoaderWrapper } from "./LoaderWrapper-Dc88hY-P.js";
+import { t as Confirm } from "./Confirm-D8WH4e1L.js";
+import { a as CountryOfGoverningLawField, c as useCompanyTypeExamples, d as companySearchQueryOptions, f as useCompanySearch, i as COUNTRY_OF_GOVERNING_LAW_FIELD, l as useCompanySelection, m as useClearCompanyData, n as COUNTRY_OF_GOVERNING_LAW_POSSIBLE, o as useLegalCompanyNameField, p as trackPerformance, r as isNormalizedStringMatch, t as CountryOfGoverningLawFieldValidation, u as verifyTinQueryOptions } from "./validate-C1ZPhUgV.js";
 import { t as useCreateLegalEntity } from "./useCreateLegalEntity-CYZd_62a.js";
 import { t as useUpdateLegalEntity } from "./useUpdateLegalEntity-B7LRg8m0.js";
-import { a as useFormComposer, i as FormFlow, o as FormContextProvider, r as useFormContext, t as addValidityToForms } from "./dropinUtils-DTBezwYT.js";
-import { i as getPropsFromConfigurations, t as createFormRules } from "./form-rules-B0RwhsVw.js";
+import { a as useFormComposer, i as FormFlow, o as FormContextProvider, r as useFormContext, t as addValidityToForms } from "./dropinUtils-DaA6mmQp.js";
+import { i as getPropsFromConfigurations, t as createFormRules } from "./form-rules-DhuNdiqF.js";
 import { t as List } from "./List-ywoRPg-q.js";
-import { n as summaryStep } from "./Summary-DM31WxLr.js";
-import { t as createFormUtils } from "./formUtils-DVDcdZsP.js";
-import { t as useMultiForm } from "./useMultiForm-BxASst0O.js";
-import { t as Field } from "./Field-DwDJQVSS.js";
-import { t as TileGroup } from "./TileGroup-D1-M64Ul.js";
-import { a as useLegalCompanyNameField, i as CountryOfGoverningLawField, n as COUNTRY_OF_GOVERNING_LAW_POSSIBLE, r as COUNTRY_OF_GOVERNING_LAW_FIELD, s as useCompanyTypeExamples, t as CountryOfGoverningLawFieldValidation } from "./validate-DKwCZSlM.js";
+import { t as StructuredList } from "./StructuredList-BHUmeWeh.js";
+import { n as summaryStep } from "./Summary-BxGf1dI5.js";
+import { t as createFormUtils } from "./formUtils-DAKrWwgL.js";
+import { t as useMultiForm } from "./useMultiForm-CM3lpilP.js";
+import { a as getValidCompanyTypesForRegistrationNumberType, l as registrationNumberDefaultFieldConfig, r as inferCompanyRegistrationNumberType, u as registrationNumberDefaultFieldMetadata } from "./getDefaultRegistrationNumberType-BzOpwR5x.js";
+import { A as mapLocalizationToJapaneseLegalNames, C as COUNTRIES_WITH_POSSIBLE_TRUSTEE_TAXID_ABSENT_V4, D as isRegistrationNumberAbsentStateV4Scenario, E as isRegistrationExemptionAllowed, O as isUsingCompanySearch, S as COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_SOLE_PROPS, T as TAX_ID_REQUIRED_COUNTRIES_ORGANIZATION, _ as COUNTRIES_THAT_DO_NOT_USE_TAX_ID_FOR_SOLE_PROP, b as COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER_SOLE_PROPS, c as taxInformationDefaultFieldConfig, f as getValidCompanyTypesForTaxIdNumberType, g as COUNTRIES_THAT_DONT_REQUIRE_SOLE_PROP_REGISTRATION, h as COUNTRIES_THAT_DONT_REQUIRE_COMPANY_REGISTRATION, k as mapJapaneseLegalNamesToLocalization, l as taxInformationDefaultFieldMetadata, s as getTaxInformationPlaceholderText, v as COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT, w as REGISTRATION_NUMBER_EXEMPTION_RULES, x as COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_COMPANIES, y as COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER } from "./utils-Dnwr-Kc0.js";
+import { t as Field } from "./Field-CBvXkDKh.js";
 import { t as getFormSlice } from "./getFormSlice-C1ma6Xd4.js";
-import { c as registrationNumberDefaultFieldMetadata, s as registrationNumberDefaultFieldConfig, u as getValidCompanyTypesForRegistrationNumberType } from "./getDefaultRegistrationNumberType-CIu4WMln.js";
-import { C as isRegistrationNumberAbsentStateV4Scenario, E as mapLocalizationToJapaneseLegalNames, S as isRegistrationExemptionAllowed, T as mapJapaneseLegalNamesToLocalization, _ as COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_COMPANIES, b as REGISTRATION_NUMBER_EXEMPTION_RULES, c as taxInformationDefaultFieldConfig, d as COUNTRIES_THAT_DONT_REQUIRE_COMPANY_REGISTRATION, f as COUNTRIES_THAT_DONT_REQUIRE_SOLE_PROP_REGISTRATION, g as COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER_SOLE_PROPS, h as COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER, k as getValidCompanyTypesForTaxIdNumberType, l as taxInformationDefaultFieldMetadata, m as COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT, p as COUNTRIES_THAT_DO_NOT_USE_TAX_ID_FOR_SOLE_PROP, s as getTaxInformationPlaceholderText, v as COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_SOLE_PROPS, w as isUsingCompanySearch, x as TAX_ID_REQUIRED_COUNTRIES_ORGANIZATION, y as COUNTRIES_WITH_POSSIBLE_TRUSTEE_TAXID_ABSENT_V4 } from "./utils-Ck_mZapQ.js";
-import { n as CountryField, t as COUNTRY_FIELD } from "./CountryField-DT6-Jr_b.js";
-import { c as COUNTRIES_WITH_STATES_DATASET } from "./utils-BWumuCvl.js";
-import { n as StateField, r as stateFieldMetadata, t as STATE_FIELD } from "./StateField-BpMwetvd.js";
+import { r as isBusinessSelectionLegalArrangementError } from "./validationError-CLDQ0Qwt.js";
 import { t as ListItem } from "./ListItem-CYTpdOMa.js";
-import { a as defaultFieldMetadata, i as defaultFieldConfigV4, o as defaultFieldMetadataV4, r as defaultFieldConfig, t as LEGAL_COMPANY_NAME_FIELD } from "./LegalCompanyNameField-Cosyjk52.js";
-import { t as InputText } from "./InputText-CFDEmEtp.js";
+import { t as TileGroup } from "./TileGroup-DKwpyGqw.js";
+import { n as CountryField, t as COUNTRY_FIELD } from "./CountryField-C7eHHmYk.js";
+import { c as COUNTRIES_WITH_STATES_DATASET } from "./utils-lIizXlcC.js";
+import { n as StateField, r as stateFieldMetadata, t as STATE_FIELD } from "./StateField-BYoE_vV0.js";
+import { a as defaultFieldMetadata, i as defaultFieldConfigV4, o as defaultFieldMetadataV4, r as defaultFieldConfig, t as LEGAL_COMPANY_NAME_FIELD } from "./LegalCompanyNameField-C3zITaw1.js";
+import { t as InputText } from "./InputText-CwPK55J0.js";
 import { t as resolveFieldMetadata } from "./fieldConfigurations-CZCFghnK.js";
-import { n as TaxInformationField, r as isJapanLocalizationEnabled, t as TAX_INFORMATION_FIELD } from "./TaxInformationField-Cc-NDAVo.js";
-import { n as BusinessRegistrationNumberField, t as BUSINESS_REGISTRATION_NUMBER_FIELD } from "./BusinessRegistrationNumberField-DKka8aVU.js";
+import { n as TaxInformationField, r as isJapanLocalizationEnabled, t as TAX_INFORMATION_FIELD } from "./TaxInformationField-DUjQEF-s.js";
+import { n as BusinessRegistrationNumberField, t as BUSINESS_REGISTRATION_NUMBER_FIELD } from "./BusinessRegistrationNumberField-CpRV1Keg.js";
 import { r as SOLE_PROP_COUNTRIES, t as ALLOWED_UNINCORPORATED_PARTNERSHIP_COUNTRIES } from "./legalArrangementUtils-C68JdH6I.js";
+import { t as DataConflictsModal } from "./DataConflictsModal-BqfTUq4v.js";
 import { r as formatObject } from "./utils-DdHbAadK.js";
-import { useCallback, useEffect, useMemo, useState } from "preact/compat";
+import { useCallback, useEffect, useMemo, useRef, useState } from "preact/compat";
+import { useContext as useContext$1, useMemo as useMemo$1, useRef as useRef$1 } from "preact/hooks";
 import { Fragment as Fragment$1, jsx, jsxs } from "preact/jsx-runtime";
-import { signal } from "@preact/signals";
+import { createModel, signal, useModel, useSignal } from "@preact/signals";
+import { useQueryClient } from "@tanstack/preact-query";
+import { createContext as createContext$1 } from "preact";
+import { Show } from "@preact/signals/utils";
 //#region src/components/GlobalEntry/globalEntryStore.ts
 var showGlobalEntryModal = signal(false);
 //#endregion
+//#region src/components/GlobalEntry/utils/applyVerifiedCompanyData.ts
+var mergeVerifiedCompanyData = (data, country, verifiedData, options) => {
+	const registrationInformation = {
+		...data.registrationInformation,
+		legalCompanyName: verifiedData.name
+	};
+	if (!options?.preserveRegistrationNumber && country !== CountryCodes.UnitedStates && verifiedData.registrationNumber) {
+		registrationInformation.registrationNumber = verifiedData.registrationNumber;
+		registrationInformation.registrationNumberType = inferCompanyRegistrationNumberType(verifiedData.registrationNumber, country, verifiedData.companyType);
+	}
+	const companyType = options?.companyTypeOverride ?? verifiedData.companyType;
+	return {
+		...data,
+		registrationInformation,
+		companyStructure: companyType ? { organizationType: companyType } : data.companyStructure
+	};
+};
+/**
+* Writes a confirmed provider selection into the form and hands back the data it wrote.
+*
+* Form writes only reach the state on the next render, so a caller that confirms a selection and
+* submits in the same tick would otherwise send the answers from before the confirmation. The
+* return value is those answers, saving the caller from deriving them a second time.
+*/
+var applyVerifiedCompanyData = (form, country, verifiedData, options) => {
+	if (!verifiedData) return form.data;
+	const confirmedData = mergeVerifiedCompanyData(form.data, country, verifiedData, options);
+	const confirmedRegistration = confirmedData.registrationInformation;
+	const confirmedCompanyType = confirmedData.companyStructure?.organizationType;
+	form.handleChangeFor("registrationInformation", "legalCompanyName")(confirmedRegistration?.legalCompanyName);
+	if (confirmedRegistration?.registrationNumber) form.handleChangeFor("registrationInformation", "registrationNumber")(confirmedRegistration?.registrationNumber);
+	if (confirmedRegistration?.registrationNumberType) form.handleChangeFor("registrationInformation", "registrationNumberType")(confirmedRegistration?.registrationNumberType);
+	if (confirmedCompanyType) form.handleChangeFor("companyStructure", "organizationType")(confirmedCompanyType);
+	return confirmedData;
+};
+//#endregion
+//#region src/components/GlobalEntry/companySearchStore.ts
+var CompanySearchStateModel = createModel((userEvents) => {
+	const companySearchName = signal();
+	const selectedCompany = signal(void 0);
+	const verifiedBusiness = signal(void 0);
+	const verificationMatched = signal(void 0);
+	/** We cannot allow selections in a few situations, this is used to track them */
+	const disallowedSelectionReason = signal(void 0);
+	/** Only used for MixPanel tracking, not meant to be exposed */
+	const selectedCompanyIdx = signal(-1);
+	/** Deliberately leaves `companySearchName` alone, so the results page can refetch its list */
+	const resetCompanySearchData = () => {
+		selectedCompany.value = void 0;
+		verifiedBusiness.value = void 0;
+		verificationMatched.value = void 0;
+		disallowedSelectionReason.value = void 0;
+		selectedCompanyIdx.value = -1;
+	};
+	return {
+		companySearchName,
+		selectedCompany,
+		verifiedBusiness,
+		verificationMatched,
+		disallowedSelectionReason,
+		resetCompanySearchData,
+		disallowSelection: (reason) => {
+			resetCompanySearchData();
+			disallowedSelectionReason.value = reason;
+		},
+		setVerificationMatched: (value) => {
+			resetCompanySearchData();
+			verificationMatched.value = value;
+		},
+		selectCompany: (selected, idx, country) => {
+			resetCompanySearchData();
+			selectedCompany.value = selected;
+			verificationMatched.value = country === CountryCodes.UnitedStates ? selected.tinMatched : selected.registrationNumberMatched;
+			/** `-1` indicates auto-selection, not a manual user interaction */
+			if (idx > -1) {
+				selectedCompanyIdx.value = idx;
+				selectBusinessAnalytics(userEvents, idx);
+			}
+		},
+		confirmCompany: (multiform, country, options) => {
+			verifiedBusiness.value = selectedCompany.value;
+			const confirmedData = applyVerifiedCompanyData(multiform, country, selectedCompany.value, options);
+			if (selectedCompanyIdx.value > -1) confirmBusinessAnalytics(userEvents, selectedCompanyIdx.value);
+			return confirmedData;
+		}
+	};
+});
+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/GlobalEntry/forms/BusinessSelection/BusinessInformationCard/BusinessInformationCard.tsx
+function BusinessInformation({ fetching, selectedBusiness }) {
+	const { t } = useTranslation(["common", "business"]);
+	const cardDetails = useMemo$1(() => {
+		if (!selectedBusiness) return [];
+		const address = selectedBusiness.registeredAddress ?? selectedBusiness.principalPlaceOfBusinessAddress;
+		const addressDetails = address && typeof address !== "string" && "fullAddress" in address ? address.fullAddress : void 0;
+		return [
+			{
+				term: t(($) => $["legalForm"], { ns: "common" }),
+				details: selectedBusiness.legalForm
+			},
+			{
+				term: t(($) => $["legalCompanyName"], { ns: "common" }),
+				details: selectedBusiness.name
+			},
+			{
+				term: t(($) => $["address"], { ns: "common" }),
+				details: addressDetails
+			}
+		].filter((item) => !!item.details);
+	}, [selectedBusiness, t]);
+	if (fetching) return /* @__PURE__ */ jsx(Loader, { size: "large" });
+	return /* @__PURE__ */ jsx(StructuredList, { items: cardDetails });
+}
+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/GlobalEntry/forms/BusinessSelection/BusinessSelection.tsx
+var BUSINESS_SELECTION_FIELDS = ["selectedBusinessId"];
+function BusinessSelection({ id, country }) {
+	const { t: businessT } = useTranslation("business");
+	const { t: commonT } = useTranslation("common");
+	const { baseUrl, rootLegalEntityId } = useApiContext();
+	const { form } = useFormContext();
+	const queryClient = useQueryClient();
+	const userEvents = useAnalyticsContext();
+	const logger = createLogger();
+	const companySearchStateModel = useContext$1(CompanySearchStateContext);
+	const { data, valid, errors, requiredFields, optionalFields, trustedFields, fieldProblems, handleChange: handleChangeFor } = getFormSlice(form, "businessSelection");
+	const { data: companySearchResponse, isLoading: searching } = useCompanySearch({
+		name: companySearchStateModel.companySearchName.value ?? "",
+		country,
+		state: form.data.entityInformation?.stateOrProvince,
+		registrationNumber: form.data.registrationInformation?.registrationNumber
+	});
+	const { data: selectData, error: selectError, mutateAsync: selectCompany, reset: resetSelectMutationState } = useCompanySelection();
+	const { mutateAsync: clearCompanyData } = useClearCompanyData();
+	const currentTin = form.data.registrationInformation?.taxInformation?.find((taxId) => taxId.country === country)?.number;
+	const currentRegistrationNumber = form.data.registrationInformation?.registrationNumber;
+	/**
+	* This ID is internal to this form, controlling selection for UI & data flow purposes. The
+	* multiform state is used to determine whether the form is set & valid, ready for the user to progress.
+	*/
+	const selectedId = useSignal("");
+	const isSelectPending = useSignal(false);
+	const selectedCompanyIdx = companySearchResponse?.results.findIndex((searchResult) => searchResult.resultId === selectedId.value);
+	/**
+	* Reset the selection when re-entering the form.
+	*
+	* The mutation makes this a bit awkward, as we won't have any data when re-entering. Whilst we
+	* could perhaps auto-select the result, without caching, we'd have another spinner & wait time for
+	* the user. Better to force a manual re-selection to work around our rough implementation details.
+	*/
+	const isInitializedRef = useRef$1(false);
+	if (!isInitializedRef.current) {
+		if (data?.selectedBusinessId) {
+			handleChangeFor("selectedBusinessId", "blur")("");
+			form.setErrors("businessSelection", "selectedBusinessId", null);
+		}
+		isInitializedRef.current = true;
+	}
+	const fetchCompanyData = async (result) => {
+		isSelectPending.value = true;
+		resetSelectMutationState();
+		try {
+			const companySelectionParams = {
+				id: result.resultId,
+				name: result.name,
+				tin: currentTin ?? "",
+				registrationNumber: currentRegistrationNumber ?? "",
+				country
+			};
+			const companySelectionResponse = await selectCompany(companySelectionParams);
+			handleChangeFor("selectedBusinessId", "blur")(result.resultId);
+			companySearchStateModel.selectCompany(companySelectionResponse, selectedCompanyIdx, country);
+		} catch (e) {
+			if (isBusinessSelectionLegalArrangementError(e)) {
+				companySearchStateModel.disallowSelection("LEGAL_ARRANGEMENT");
+				handleChangeFor("selectedBusinessId", "blur")("LEGAL_ARRANGEMENT_ERR");
+			} else logger.error(e);
+		} finally {
+			isSelectPending.value = false;
+		}
+	};
+	const handleSelectBusiness = (result) => {
+		selectedId.value = result.resultId;
+		companySearchStateModel.resetCompanySearchData();
+		fetchCompanyData(result);
+	};
+	const handleSelectNotListed = async () => {
+		selectedId.value = "notListed";
+		companySearchStateModel.resetCompanySearchData();
+		await clearCompanyData();
+		if (country !== CountryCodes.UnitedStates) return handleChangeFor("selectedBusinessId", "blur")("notListed");
+		try {
+			isSelectPending.value = true;
+			const tinVerificationParams = {
+				name: form.data.registrationInformation?.legalCompanyName ?? "",
+				tin: currentTin ?? ""
+			};
+			const { matched } = await queryClient.fetchQuery(verifyTinQueryOptions(rootLegalEntityId.peek(), baseUrl.peek(), tinVerificationParams, userEvents));
+			companySearchStateModel.setVerificationMatched(!!matched);
+		} catch (e) {
+			logger.error(e);
+			companySearchStateModel.setVerificationMatched(false);
+		} finally {
+			handleChangeFor("selectedBusinessId", "blur")("notListed");
+			isSelectPending.value = false;
+		}
+	};
+	const formUtils = createFormUtils({
+		requiredFields,
+		optionalFields,
+		trustedFields
+	}, commonT);
+	return /* @__PURE__ */ jsx("form", {
+		id,
+		children: /* @__PURE__ */ jsxs(LoaderWrapper, {
+			loaderSize: "large",
+			status: searching ? "loading" : "success",
+			children: [/* @__PURE__ */ jsx(Header, { title: businessT(($) => $["businessSelectionFormHeading"]) }), /* @__PURE__ */ jsx(Field, {
+				el: "fieldset",
+				name: "selectedBusinessId",
+				errorMessage: formUtils.getErrorMessage("selectedBusinessId", errors, fieldProblems),
+				isValid: valid?.selectedBusinessId,
+				children: () => /* @__PURE__ */ jsxs(StackLayout, { children: [companySearchResponse?.results.map((result) => /* @__PURE__ */ jsx(BusinessInformationCard, {
+					result,
+					isSelected: selectedId.value === result.resultId,
+					currentBusinessSelection: selectData,
+					fetching: isSelectPending.value,
+					error: selectError,
+					handleSelectBusiness: () => handleSelectBusiness(result),
+					retryCompanySelection: () => fetchCompanyData(result)
+				}, result.resultId)), /* @__PURE__ */ jsx(CompanyNotListedCard, {
+					isSelected: selectedId.value === "notListed",
+					handleSelectBusiness: handleSelectNotListed,
+					fetching: isSelectPending.value
+				})] })
+			})]
+		})
+	});
+}
+//#endregion
 //#region src/components/GlobalEntry/companyTypeMetadata.ts
 var companyTypeMetadata = {
 	privateCompany: {
@@ -600,6 +913,11 @@ var globalEntryForms = {
 		formName: "registrationInformationFormName",
 		fields: REGISTRATION_INFORMATION_FIELDS
 	},
+	businessSelection: {
+		formId: "businessSelection",
+		formName: "businessSelectionFormName",
+		fields: BUSINESS_SELECTION_FIELDS
+	},
 	companyStructure: {
 		formId: "companyStructure",
 		formName: "companyStructureFormName",
@@ -612,6 +930,141 @@ var globalEntryForms = {
 	}
 };
 //#endregion
+//#region src/components/GlobalEntry/hooks/useCompanySearchNextClickOverrides.ts
+function useCompanySearchNextClickOverrides({ country, multiForm, companySearchStateModel, getRequiredForms, skipBusinessSelection, setLoadingStatus, isTinMatched, tinMismatchModalOpen, legalArrangementModalOpen, registrationNumberMismatchModalOpen, confirmSelection }) {
+	const { baseUrl, rootLegalEntityId } = useApiContext();
+	const userEvents = useAnalyticsContext();
+	const queryClient = useQueryClient();
+	const { mutateAsync: selectCompany } = useCompanySelection();
+	const { mutateAsync: clearCompanyData } = useClearCompanyData();
+	const logger = createLogger();
+	const getInferredRegistrationNumberType = () => {
+		const selectedCompany = companySearchStateModel.selectedCompany.peek();
+		if (country === CountryCodes.UnitedStates || !selectedCompany?.registrationNumber) return;
+		return inferCompanyRegistrationNumberType(selectedCompany.registrationNumber, country, selectedCompany.companyType);
+	};
+	const isVerificationFailed = () => country === CountryCodes.UnitedStates ? !companySearchStateModel.verificationMatched.value : companySearchStateModel.verificationMatched.value === false;
+	/**
+	* Returns `null` for non-navs, such as showing the TIN mismatch modal for 0 or 1 results
+	*/
+	const attemptBusinessSearch = async () => {
+		const formsWithoutSearchResults = getRequiredForms({ skipBusinessSelection: true });
+		const legalCompanyName = multiForm.data.registrationInformation?.legalCompanyName;
+		if (!legalCompanyName) return formsWithoutSearchResults;
+		setLoadingStatus("loading");
+		companySearchStateModel.resetCompanySearchData();
+		let searchResponse = {
+			results: [],
+			provider: "NO_PROVIDER"
+		};
+		try {
+			companySearchStateModel.companySearchName.value = legalCompanyName;
+			const companySearchInput = {
+				name: legalCompanyName,
+				country,
+				state: multiForm.data.entityInformation?.stateOrProvince,
+				registrationNumber: multiForm.data.registrationInformation?.registrationNumber
+			};
+			searchResponse = await trackPerformance("companySearch", () => queryClient.fetchQuery(companySearchQueryOptions(rootLegalEntityId.peek(), baseUrl.peek(), companySearchInput, userEvents)), userEvents);
+		} catch (e) {
+			logger.error(e);
+			setLoadingStatus("error");
+			skipBusinessSelection.value = true;
+			return formsWithoutSearchResults;
+		}
+		const tin = multiForm.data.registrationInformation?.taxInformation?.find((taxId) => taxId.country === country)?.number ?? "";
+		const registrationNumber = multiForm.data.registrationInformation?.registrationNumber ?? "";
+		skipBusinessSelection.value = searchResponse.results.length === 0;
+		const currentForms = getRequiredForms({ skipBusinessSelection: skipBusinessSelection.peek() });
+		switch (searchResponse.results.length) {
+			case 0:
+				if (country === CountryCodes.UnitedStates) try {
+					const verifyTinQueryInput = {
+						name: legalCompanyName,
+						tin
+					};
+					const tinVerificationResponse = await queryClient.fetchQuery(verifyTinQueryOptions(rootLegalEntityId.peek(), baseUrl.peek(), verifyTinQueryInput, userEvents));
+					setLoadingStatus("success");
+					companySearchStateModel.setVerificationMatched(!!tinVerificationResponse.matched);
+					if (companySearchStateModel.verificationMatched.value) return currentForms;
+					tinMismatchModalOpen.value = true;
+					return null;
+				} catch (e) {
+					logger.error(e);
+					setLoadingStatus("error");
+					return currentForms;
+				}
+				setLoadingStatus("success");
+				return currentForms;
+			case 1:
+				if (!isNormalizedStringMatch(legalCompanyName, searchResponse.results[0].name)) {
+					setLoadingStatus("success");
+					return currentForms;
+				}
+				try {
+					const companySelectionResponse = await selectCompany({
+						name: legalCompanyName,
+						tin,
+						registrationNumber,
+						id: searchResponse.results[0].resultId,
+						country
+					});
+					companySearchStateModel.selectCompany(companySelectionResponse, -1, country);
+					setLoadingStatus("success");
+					if (isVerificationFailed()) {
+						await clearCompanyData();
+						return currentForms;
+					}
+					confirmSelection();
+					skipBusinessSelection.value = true;
+					return getRequiredForms({
+						skipBusinessSelection: skipBusinessSelection.peek(),
+						skipCompanyStructure: !!companySearchStateModel.verifiedBusiness.value?.legalForm || !!getInferredRegistrationNumberType()
+					});
+				} catch (e) {
+					logger.error(e);
+					setLoadingStatus("error");
+					await clearCompanyData();
+					return formsWithoutSearchResults;
+				}
+			default:
+				setLoadingStatus("success");
+				return currentForms;
+		}
+	};
+	const confirmBusinessSelection = async () => {
+		const selectedBusinessId = multiForm.data.businessSelection?.selectedBusinessId;
+		if (companySearchStateModel.disallowedSelectionReason.value) {
+			switch (companySearchStateModel.disallowedSelectionReason.value) {
+				case "LEGAL_ARRANGEMENT":
+					legalArrangementModalOpen.value = true;
+					break;
+				default:
+					logger.error("Unhandled disallowed selection reason");
+					break;
+			}
+			return null;
+		}
+		switch (selectedBusinessId) {
+			case "notListed":
+				if (country === CountryCodes.UnitedStates && isVerificationFailed()) isTinMatched.value = false;
+				return getRequiredForms({});
+			default:
+				if (isVerificationFailed()) {
+					if (country === CountryCodes.UnitedStates) tinMismatchModalOpen.value = true;
+					else registrationNumberMismatchModalOpen.value = true;
+					return null;
+				}
+				confirmSelection();
+				return getRequiredForms({ skipCompanyStructure: !!companySearchStateModel.verifiedBusiness.value?.legalForm || !!getInferredRegistrationNumberType() });
+		}
+	};
+	return {
+		attemptBusinessSearch,
+		confirmBusinessSelection
+	};
+}
+//#endregion
 //#region src/components/GlobalEntry/mapping/mapLegalEntityToGlobalEntrySchema.ts
 var determineEntitySetup = (legalEntity, accountHolder) => {
 	if (accountHolder === "anUnincorporatedPartnership" && legalEntity.type === "individual") return "partOfABusiness";
@@ -636,10 +1089,16 @@ var mapLegalEntityToGlobalEntrySchema = (legalEntity, accountHolder, associatedS
 		country,
 		companyType
 	}) ? true : legalEntity.organization?.registrationNumberAbsent;
+	const stateOrProvince = [
+		legalEntity.organization?.registeredAddress,
+		legalEntity.individual?.residentialAddress,
+		soleProprietorship?.registeredAddress
+	].find((address) => address?.street && address?.stateOrProvince)?.stateOrProvince;
 	return {
 		entityInformation: {
 			entitySetup: determineEntitySetup(legalEntity, accountHolder),
-			country: getLegalEntityCountry(legalEntity)
+			country: getLegalEntityCountry(legalEntity),
+			stateOrProvince
 		},
 		registrationInformation: {
 			...mapLocalizationToJapaneseLegalNames(legalEntity.organization?.localization),
@@ -657,6 +1116,71 @@ var mapLegalEntityToGlobalEntrySchema = (legalEntity, accountHolder, associatedS
 	};
 };
 //#endregion
+//#region src/components/GlobalEntry/modals/LegalArrangementModal.tsx
+/**
+* This component can likely be deleted when Global Entry is fully supported and search fully supports legal arrangements returned
+* from providers.
+*/
+function LegalArrangementModal({ onCancel, onConfirm }) {
+	const { t } = useTranslation(["common", "business"]);
+	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,
+		analyticsEventLabel: "legalArrangementModal"
+	});
+}
+//#endregion
+//#region src/components/GlobalEntry/modals/RegistrationNumberMismatchModal.tsx
+function RegistrationNumberMismatchModal({ companySearchStateModel, country, registrationNumberMismatchModalOpen, confirmDataSelection }) {
+	const { t } = useTranslation(["common", "business"]);
+	const { form } = useFormContext();
+	const { data } = getFormSlice(form, "registrationInformation");
+	const providedData = {
+		registrationNumber: data?.registrationNumber,
+		registrationNumberType: data?.registrationNumberType
+	};
+	const detectedData = {
+		registrationNumber: companySearchStateModel.selectedCompany.value?.registrationNumber,
+		registrationNumberType: void 0
+	};
+	const registrationNumberType = data?.exemptedFromRegistrationNumber ? "exempted" : data?.registrationNumberType;
+	const { label: registrationNumberLabel } = resolveFieldMetadata(registrationNumberDefaultFieldConfig[country], {
+		registrationNumberType: registrationNumberType === "exempted" ? void 0 : registrationNumberType,
+		state: form.data.entityInformation?.stateOrProvince || void 0
+	}, registrationNumberDefaultFieldMetadata);
+	return /* @__PURE__ */ jsx(DataConflictsModal, {
+		providedData,
+		detectedData,
+		conflictingProperties: ["registrationNumber"],
+		formatters: {},
+		labels: { registrationNumber: providedData.registrationNumberType === detectedData.registrationNumberType ? registrationNumberLabel : "registrationNumber" },
+		title: t(($) => $["verifyYourBusinesssDetails"], { ns: "business" }),
+		explanation: t(($) => $["selectTheOptionWithTheMostCorrectDetailsToContinue"], { ns: "business" }),
+		onCancel: () => registrationNumberMismatchModalOpen.value = false,
+		onContinue: confirmDataSelection,
+		listOnly: true
+	});
+}
+//#endregion
+//#region src/components/GlobalEntry/modals/TinMismatchModal.tsx
+function TinMismatchModal({ onCancel, onConfirm }) {
+	const { t } = useTranslation(["common", "business"]);
+	const modalDescriptionKey = typeof useContext$1(CompanySearchStateContext).selectedCompany.value === "undefined" ? "theEinDidntMatchLegalBusinessName" : "itLooksLikeThisBusinessUsesADifferentEIN";
+	return /* @__PURE__ */ jsx(Confirm, {
+		title: t(($) => $["employerIdentificationNumberDoesntMatch"], { ns: "business" }),
+		description: t(($) => $[modalDescriptionKey], { ns: "business" }),
+		cancelText: t(($) => $["close"], { ns: "common" }),
+		confirmText: t(($) => $["continue"], { ns: "common" }),
+		onCancel,
+		onConfirm,
+		analyticsEventLabel: "tinVerificationFailureModal"
+	});
+}
+//#endregion
 //#region src/components/GlobalEntry/rules.ts
 var globalEntryFieldRuleConfigurations = {
 	entitySetup: { rule: "entitySetupRequired" },
@@ -665,6 +1189,7 @@ var globalEntryFieldRuleConfigurations = {
 	country: { rule: "countryRequired" },
 	stateOrProvince: { rule: "requireStateOrProvinceForCompanySearch" },
 	countryOfGoverningLaw: { rule: "countryOfGoverningLawRequired" },
+	selectedBusinessId: { rule: "businessSelectionRequired" },
 	filedPaperwork: { rule: "filedPaperworkRequired" },
 	unincorporatedOrganizationType: { rule: "unincorporatedOrganizationTypeRequired" },
 	legalCompanyName: { rule: "legalCompanyNameRequired" },
@@ -676,7 +1201,7 @@ var globalEntryFieldRuleConfigurations = {
 	taxInformation: { rule: "taxInformationRequired" },
 	exemptedFromTax: { rule: "countryHasTaxExemptions" }
 };
-var globalEntryCustomRules = ({ accountHolder, data, isFeatureEnabled = () => false, country, taskType, rootLegalEntity }) => {
+var globalEntryCustomRules = ({ accountHolder, data, isFeatureEnabled = () => false, country, rootLegalEntity }) => {
 	const filedPaperwork = getFiledPaperwork(data);
 	const hasFiledPaperwork = filedPaperwork === "yes";
 	const hasAnsweredPaperworkQuestion = !!filedPaperwork;
@@ -690,8 +1215,9 @@ var globalEntryCustomRules = ({ accountHolder, data, isFeatureEnabled = () => fa
 		entitySetupRequired: () => "REQUIRED",
 		countryRequired: () => "REQUIRED",
 		requireStateOrProvinceForCompanySearch: () => {
-			if (isPartOfABusiness && isUsingCompanySearch(country, taskType) && COUNTRIES_WITH_STATES_DATASET.includes(country)) return "REQUIRED";
+			if (isPartOfABusiness && isUsingCompanySearch(country, TaskTypes.GLOBAL_ENTRY) && COUNTRIES_WITH_STATES_DATASET.includes(country)) return "REQUIRED";
 		},
+		businessSelectionRequired: () => isUsingCompanySearch(country, TaskTypes.GLOBAL_ENTRY) && isRegisteredOrganization ? "REQUIRED" : void 0,
 		organizationTypeRequired: () => isRegisteredOrganization ? "REQUIRED" : void 0,
 		countryOfGoverningLawRequired: () => {
 			if (isFeatureEnabled("EnableCountryOfGoverningLawForUKCompanies") && COUNTRY_OF_GOVERNING_LAW_POSSIBLE.includes(country) && (isPartOfABusiness || isSoleProp) && hasAnsweredPaperworkQuestion) return "REQUIRED";
@@ -792,12 +1318,16 @@ var globalEntryCustomRules = ({ accountHolder, data, isFeatureEnabled = () => fa
 //#region src/components/GlobalEntry/utils/buildRequiredForms.ts
 function buildRequiredForms({ config: { forms, requiredFields, optionalFields, isValid }, options }) {
 	/**
+	* Skip business selection if:
+	* - Company search is unavailable, or returned nothing to choose between
+	*
 	* Skip company structure if:
-	* - Only a single company structure is available
+	* - Only a single company structure is available, or a provider supplied a usable one
 	*/
 	const filteredForms = [];
 	for (const formId in forms) {
 		const form = forms[formId];
+		if (formId === "businessSelection" && options?.skipBusinessSelection) continue;
 		if (formId === "companyStructure" && options?.skipCompanyStructure) continue;
 		if (requiredFields || optionalFields) {
 			if (!requiredFields?.[formId] && !optionalFields?.[formId]) continue;
@@ -813,7 +1343,6 @@ function buildRequiredForms({ config: { forms, requiredFields, optionalFields, i
 */
 var globalEntryKeyMappingForOrgs = {
 	"entityInformation.country": "organization.registeredAddress.country",
-	"entityInformation.stateOrProvince": "organization.registeredAddress.stateOrProvince",
 	"registrationInformation.legalCompanyName": "organization.legalName",
 	"registrationInformation.registrationNumber": "organization.registrationNumber",
 	"registrationInformation.exemptedFromRegistrationNumber": "organization.registrationNumberAbsent",
@@ -821,13 +1350,9 @@ var globalEntryKeyMappingForOrgs = {
 	"registrationInformation.countryOfGoverningLaw": "organization.countryOfGoverningLaw",
 	"companyStructure.organizationType": "organization.type"
 };
-var globalEntryKeyMappingForIndividuals = {
-	"entityInformation.country": "individual.residentialAddress.country",
-	"entityInformation.stateOrProvince": "individual.residentialAddress.stateOrProvince"
-};
+var globalEntryKeyMappingForIndividuals = { "entityInformation.country": "individual.residentialAddress.country" };
 var globalEntryKeyMappingForSoleProps = {
 	"entityInformation.country": "soleProprietorship.registeredAddress.country",
-	"entityInformation.stateOrProvince": "soleProprietorship.registeredAddress.stateOrProvince",
 	"registrationInformation.legalCompanyName": "soleProprietorship.name",
 	"registrationInformation.registrationNumber": "soleProprietorship.registrationNumber",
 	"registrationInformation.taxInformation": "soleProprietorship.taxInformation",
@@ -925,6 +1450,11 @@ var globalEntryValidationRules = ({ data, legalEntity, isFeatureEnabled = () =>
 		state: data?.entityInformation?.stateOrProvince
 	}, registrationNumberDefaultFieldMetadata).validators;
 	return {
+		businessSelection: { selectedBusinessId: {
+			validate: (value) => !isEmpty(value),
+			modes: ["blur", "input"],
+			errorMessage: "fieldIsRequired"
+		} },
 		companyStructure: { organizationType: {
 			validate: (value) => !!value,
 			modes: ["blur", "input"]
@@ -960,6 +1490,10 @@ var GlobalEntry = ({ activeForm, legalEntity, shouldValidate, country }) => {
 			shouldValidate,
 			country
 		});
+		case globalEntryForms.businessSelection.formId: return /* @__PURE__ */ jsx(BusinessSelection, {
+			id: activeForm.formId,
+			country
+		});
 		case globalEntryForms.companyStructure.formId: return /* @__PURE__ */ jsx(CompanyStructure, {
 			id: activeForm.formId,
 			country,
@@ -971,43 +1505,59 @@ var GlobalEntry = ({ activeForm, legalEntity, shouldValidate, country }) => {
 };
 //#endregion
 //#region src/components/GlobalEntry/tasks/GlobalEntryModal.tsx
+var CompanySearchStateContext = createContext$1({});
 var GlobalEntryModal = ({ rootLegalEntity, onComplete }) => {
 	const { i18n, t } = useTranslation(["common", "globalEntry"]);
 	const { isFeatureEnabled } = useToggleContext();
 	const logger = createLogger();
 	const { showToast } = useToastContext();
 	const { accountHolder: accountHolderMaybe } = useAccountHolder();
+	const userEvents = useAnalyticsContext();
+	const { mutateAsync: clearCompanyData } = useClearCompanyData();
 	const [derivedProps, setDerivedProps] = useState();
 	const accountHolder = accountHolderMaybe ?? (rootLegalEntity.type === "individual" ? "myName" : "theCompanyIWorkFor");
+	const companySearchStateModel = useModel(() => new CompanySearchStateModel(userEvents));
+	const tinMismatchModalOpen = useSignal(false);
+	const legalArrangementModalOpen = useSignal(false);
+	const registrationNumberMismatchModalOpen = useSignal(false);
+	const skipBusinessSelection = useSignal(true);
+	const [searchStatus, setSearchStatus] = useState("success");
+	/**
+	* Distinct from the model's `verificationMatched`, which updates the moment the API answers. This
+	* only records the outcome once the user navigates forward, and it is deliberately inert: unlike
+	* Business Details, Global Entry has no tax document step to insert, so remediation is left to the
+	* task that does collect documents.
+	*/
+	const isTinMatched = useSignal(void 0);
 	addResourceBundles(i18n, [{
 		ns: "globalEntry",
 		importFn: (lang) => _rolldown_dynamic_import_helper_default(/* #__PURE__ */ Object.assign({
-			"../language/bg-BG.json": () => import("./bg-BG-BPzEcioF.js"),
-			"../language/cs-CZ.json": () => import("./cs-CZ-D4ml1o2f.js"),
-			"../language/da-DK.json": () => import("./da-DK-BoINgPRU.js"),
-			"../language/de-DE.json": () => import("./de-DE-By2U6vch.js"),
-			"../language/el-GR.json": () => import("./el-GR-CdTXa4cP.js"),
+			"../language/bg-BG.json": () => import("./bg-BG-ClMsmcda.js"),
+			"../language/cs-CZ.json": () => import("./cs-CZ-DyLd-erd.js"),
+			"../language/da-DK.json": () => import("./da-DK-Dhr4p-qj.js"),
+			"../language/de-DE.json": () => import("./de-DE-QDT6VVq9.js"),
+			"../language/el-GR.json": () => import("./el-GR-V2cZ5gjl.js"),
 			"../language/en-US.json": () => import("./en-US-Cz4JoU20.js"),
-			"../language/es-ES.json": () => import("./es-ES-DT39ZlR7.js"),
-			"../language/es-LA.json": () => import("./es-LA-DQGPNeqX.js"),
-			"../language/et-EE.json": () => import("./et-EE-S_MAXUF8.js"),
-			"../language/fi-FI.json": () => import("./fi-FI-ThDP-8F8.js"),
-			"../language/fr-FR.json": () => import("./fr-FR-D3maHIWS.js"),
-			"../language/hr-HR.json": () => import("./hr-HR-BUI-Ac0o.js"),
-			"../language/hu-HU.json": () => import("./hu-HU-BPjEsgnX.js"),
-			"../language/it-IT.json": () => import("./it-IT-W1FjGb6L.js"),
-			"../language/ja-JP.json": () => import("./ja-JP-avJECfKw.js"),
-			"../language/lt-LT.json": () => import("./lt-LT-wP0YuKeO.js"),
-			"../language/lv-LV.json": () => import("./lv-LV-DW_mgZjM.js"),
-			"../language/nl-NL.json": () => import("./nl-NL-7kT4I7Tj.js"),
-			"../language/no-NO.json": () => import("./no-NO-BoEKDB8U.js"),
-			"../language/pl-PL.json": () => import("./pl-PL-B6DeEX-m.js"),
-			"../language/pt-BR.json": () => import("./pt-BR-CsQI9W3I.js"),
-			"../language/pt-PT.json": () => import("./pt-PT-i_EH0CM6.js"),
-			"../language/ro-RO.json": () => import("./ro-RO-B7CJDsKz.js"),
-			"../language/sk-SK.json": () => import("./sk-SK-NU95U8E2.js"),
-			"../language/sl-SI.json": () => import("./sl-SI-B6Kv1DgA.js"),
-			"../language/sv-SE.json": () => import("./sv-SE-DKTrk_eI.js")
+			"../language/es-ES.json": () => import("./es-ES-SsReQJzQ.js"),
+			"../language/es-LA.json": () => import("./es-LA-DTXCg1tj.js"),
+			"../language/et-EE.json": () => import("./et-EE-Bg3WOS9m.js"),
+			"../language/fi-FI.json": () => import("./fi-FI-B1RyWVH2.js"),
+			"../language/fr-FR.json": () => import("./fr-FR-C3Zi7-JE.js"),
+			"../language/hr-HR.json": () => import("./hr-HR-CH9yGEPn.js"),
+			"../language/hu-HU.json": () => import("./hu-HU-DpUG3GwC.js"),
+			"../language/it-IT.json": () => import("./it-IT-BEEsgu4Z.js"),
+			"../language/ja-JP.json": () => import("./ja-JP-CcXk7Gcc.js"),
+			"../language/lt-LT.json": () => import("./lt-LT-CGgbFwbx.js"),
+			"../language/lv-LV.json": () => import("./lv-LV-Ck_aQ4ML.js"),
+			"../language/nl-NL.json": () => import("./nl-NL-_hbzuQ0h.js"),
+			"../language/no-NO.json": () => import("./no-NO-B_ijkAtf.js"),
+			"../language/pl-PL.json": () => import("./pl-PL-u6DrL8IY.js"),
+			"../language/pt-BR.json": () => import("./pt-BR-CPS77pGy.js"),
+			"../language/pt-PT.json": () => import("./pt-PT-DIKqQR6V.js"),
+			"../language/ro-RO.json": () => import("./ro-RO-Cg1nG9ns.js"),
+			"../language/sk-SK.json": () => import("./sk-SK-CRfiVN3e.js"),
+			"../language/sl-SI.json": () => import("./sl-SI-Dpr3StsS.js"),
+			"../language/sv-SE.json": () => import("./sv-SE-CH4wMrUZ.js")
 		}), `../language/${lang}.json`, 3)
 	}]);
 	addResourceBundles(i18n, [{
@@ -1115,41 +1665,55 @@ var GlobalEntryModal = ({ rootLegalEntity, onComplete }) => {
 	const inferredCompanyStructure = useMemo(() => {
 		return availableCompanyStructures.length === 1 ? availableCompanyStructures[0] : void 0;
 	}, [availableCompanyStructures]);
-	const [companyStructure, setCompanyStructure] = useState(data.companyStructure?.organizationType);
-	if (inferredCompanyStructure && companyStructure !== inferredCompanyStructure) {
-		setCompanyStructure(inferredCompanyStructure);
-		multiForm.handleChangeFor("companyStructure", "organizationType")(inferredCompanyStructure);
-	}
-	const forms = useMemo(() => {
-		return buildRequiredForms({
-			config: {
-				forms: globalEntryForms,
-				requiredFields: derivedProps?.requiredFields,
-				optionalFields: derivedProps?.optionalFields,
-				isValid: formValidity ?? {},
-				legalEntityResponse: rootLegalEntity
-			},
-			options: {
-				skipSummary: true,
-				skipCompanyStructure: !!inferredCompanyStructure
-			}
-		});
-	}, [
+	const getRequiredForms = useCallback((options) => buildRequiredForms({
+		config: {
+			forms: globalEntryForms,
+			requiredFields: derivedProps?.requiredFields,
+			optionalFields: derivedProps?.optionalFields,
+			isValid: formValidity ?? {},
+			legalEntityResponse: rootLegalEntity
+		},
+		options: {
+			skipSummary: true,
+			skipCompanyStructure: !!inferredCompanyStructure,
+			...options
+		}
+	}), [
 		derivedProps?.optionalFields,
 		derivedProps?.requiredFields,
 		formValidity,
-		rootLegalEntity,
+		inferredCompanyStructure,
+		rootLegalEntity
+	]);
+	const forms = useMemo(() => getRequiredForms({
+		skipBusinessSelection: skipBusinessSelection.value,
+		skipCompanyStructure: !!companySearchStateModel.verifiedBusiness.value?.legalForm || !!inferredCompanyStructure
+	}), [
+		getRequiredForms,
+		skipBusinessSelection.value,
+		companySearchStateModel.verifiedBusiness.value,
 		inferredCompanyStructure
 	]);
 	const { mutateAsync: updateLegalEntity, isPending: isUpdatingLegalEntity } = useUpdateLegalEntity();
 	const { mutateAsync: createLegalEntity, isPending: isCreatingLegalEntity } = useCreateLegalEntity();
 	const isLoading = isUpdatingLegalEntity || isCreatingLegalEntity || isLoadingAssociatedSoleProp;
+	/**
+	* Form writes only reach the state on the next render so this prevents
+	* outdated data from being submitted. In Global Entry, we submit the form
+	* on navigation so the re-render hasn't happened yet.
+	*/
+	const pendingSubmitData = useRef();
+	const confirmSelection = (options) => {
+		pendingSubmitData.current = companySearchStateModel.confirmCompany(multiForm, country, options);
+	};
 	const handleSubmit = async () => {
+		const submittedData = pendingSubmitData.current ?? data;
+		pendingSubmitData.current = void 0;
 		try {
 			const newAccountHolder = await submitGlobalEntry({
 				legalEntity: rootLegalEntity,
 				associatedSoleProp,
-				data,
+				data: submittedData,
 				updateLegalEntity,
 				createLegalEntity,
 				accountHolder,
@@ -1170,9 +1734,114 @@ var GlobalEntryModal = ({ rootLegalEntity, onComplete }) => {
 		forms,
 		triggerValidation
 	});
+	const { attemptBusinessSearch, confirmBusinessSelection } = useCompanySearchNextClickOverrides({
+		country,
+		multiForm,
+		companySearchStateModel,
+		getRequiredForms,
+		skipBusinessSelection,
+		setLoadingStatus: setSearchStatus,
+		isTinMatched,
+		tinMismatchModalOpen,
+		legalArrangementModalOpen,
+		registrationNumberMismatchModalOpen,
+		confirmSelection
+	});
+	const [companyStructure, setCompanyStructure] = useState(data.companyStructure?.organizationType);
+	if (inferredCompanyStructure && companyStructure !== inferredCompanyStructure && !companySearchStateModel.verifiedBusiness.value?.legalForm && activeForm?.formId === globalEntryForms.registrationInformation.formId) {
+		setCompanyStructure(inferredCompanyStructure);
+		multiForm.handleChangeFor("companyStructure", "organizationType")(inferredCompanyStructure);
+	}
+	/**
+	* Current country value must be kept in sync with what is selected in entityInformation form
+	*/
+	const [prevCountry, setPrevCountry] = useState(data.entityInformation?.country);
+	if (data.entityInformation?.country && prevCountry !== data.entityInformation.country) {
+		setPrevCountry(data.entityInformation.country);
+		companySearchStateModel.resetCompanySearchData();
+		multiForm.handleChangeFor("companyStructure", "organizationType")(void 0);
+	}
 	const overrideNextClick = async () => {
 		if (!activeForm.isValid) return handleNextClick();
-		return handleNextClick();
+		if (!(isUsingCompanySearch(country, TaskTypes.GLOBAL_ENTRY) && data.registrationInformation?.filedPaperwork === "yes")) return handleNextClick();
+		switch (activeForm.formId) {
+			case globalEntryForms.registrationInformation.formId: {
+				const currentForms = await attemptBusinessSearch();
+				if (currentForms === null) return;
+				return handleNextClick(currentForms);
+			}
+			case globalEntryForms.businessSelection.formId: {
+				const currentForms = await confirmBusinessSelection();
+				if (currentForms === null) return;
+				return handleNextClick(currentForms);
+			}
+			default: return handleNextClick();
+		}
+	};
+	const tinMismatchConfirm = async () => {
+		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 from under them, as nav
+		* gets strange when doing so. It's only dropped when they're still on registration information,
+		* the only other place this modal opens from.
+		*/
+		skipBusinessSelection.value = activeForm.formId !== globalEntryForms.businessSelection.formId;
+		confirmSelection();
+		if (country === CountryCodes.UnitedStates && companySearchStateModel.verificationMatched.value === false) isTinMatched.value = false;
+		handleNextClick(getRequiredForms({
+			skipBusinessSelection: skipBusinessSelection.peek(),
+			skipCompanyStructure: !!companySearchStateModel.verifiedBusiness.value?.legalForm
+		}));
+	};
+	/** Resolves the registration number mismatch modal */
+	const confirmDataSelection = async (resolvedData) => {
+		const userProvided = resolvedData.registrationNumber !== companySearchStateModel.selectedCompany.value?.registrationNumber;
+		userEvents.addPageEvent("Clicked button", {
+			actionType: "select",
+			label: "confirmCompanyConflictResolution",
+			additionalData: { selection: userProvided ? "manual" : "recommended" }
+		});
+		/**
+		* If the user is on 'Business Selection', we don't want to remove the page out from under them as
+		* nav can get a bit weird when doing so. Instead, we'll only remove it from the flow if the user is
+		* still on 'Basic Information', the only other place this modal is accessible from.
+		*/
+		skipBusinessSelection.value = activeForm.formId !== globalEntryForms.businessSelection.formId;
+		if (userProvided) {
+			registrationNumberMismatchModalOpen.value = false;
+			/**
+			* The user keeps their own registration number, but the rest of the provider's data
+			* (legal name, addresses, financial information) is still worth applying.
+			*
+			* The provider's company type can only be applied if it's compatible with the user's
+			* registration number — a GB charity number, for example, cannot belong to a
+			* `privateCompany`. When it isn't compatible we discard it and fall back to the company
+			* types the registration number allows: exactly one means we can infer it, otherwise the
+			* user picks it on the company structure step.
+			*/
+			const providerCompanyType = companySearchStateModel.selectedCompany.value?.companyType;
+			const resolvedCompanyType = !!providerCompanyType && availableCompanyStructures.includes(providerCompanyType) ? providerCompanyType : inferredCompanyStructure;
+			confirmSelection({
+				preserveRegistrationNumber: true,
+				companyTypeOverride: resolvedCompanyType
+			});
+			await clearCompanyData();
+			handleNextClick(getRequiredForms({
+				skipBusinessSelection: skipBusinessSelection.peek(),
+				skipCompanyStructure: !!resolvedCompanyType
+			}));
+			return;
+		} else {
+			confirmSelection();
+			registrationNumberMismatchModalOpen.value = false;
+			const inferredRegistrationNumberType = resolvedData.registrationNumber ? inferCompanyRegistrationNumberType(resolvedData.registrationNumber, country, companySearchStateModel.verifiedBusiness.value?.companyType) : void 0;
+			handleNextClick(getRequiredForms({
+				skipBusinessSelection: skipBusinessSelection.peek(),
+				skipCompanyStructure: !!companySearchStateModel.verifiedBusiness.value?.legalForm || !!inferredRegistrationNumberType
+			}));
+		}
 	};
 	return /* @__PURE__ */ jsx(FormContextProvider, {
 		form: multiForm,
@@ -1185,16 +1854,44 @@ var GlobalEntryModal = ({ rootLegalEntity, onComplete }) => {
 			forms,
 			gotoFormByFormIndex,
 			gotoFormByFormId,
-			loadingStatus: isLoading ? "loading" : "success",
+			loadingStatus: isLoading ? "loading" : searchStatus,
 			currentStep: steps.current,
 			totalSteps: steps.total,
 			isGlobalEntry: true,
 			disableNextButton: data?.registrationInformation?.unincorporatedOrganizationType === "unincorporatedAssociation",
-			children: /* @__PURE__ */ jsx(GlobalEntry, {
-				activeForm,
-				shouldValidate,
-				legalEntity: rootLegalEntity,
-				country
+			children: /* @__PURE__ */ jsxs(CompanySearchStateContext.Provider, {
+				value: companySearchStateModel,
+				children: [
+					/* @__PURE__ */ jsx(GlobalEntry, {
+						activeForm,
+						shouldValidate,
+						legalEntity: rootLegalEntity,
+						country
+					}),
+					/* @__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,
+							onConfirm: () => legalArrangementModalOpen.value = false
+						})
+					}),
+					/* @__PURE__ */ jsx(Show, {
+						when: registrationNumberMismatchModalOpen,
+						children: /* @__PURE__ */ jsx(RegistrationNumberMismatchModal, {
+							companySearchStateModel,
+							country,
+							registrationNumberMismatchModalOpen,
+							confirmDataSelection
+						})
+					})
+				]
 			})
 		})
 	});