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

package/dist/bafinUtils-CsDthERR.js

@@ -0,0 +1,3548 @@
+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] = "f14a41a0-3e0a-4b1b-ac3c-1160ae1656c8", e._sentryDebugIdIdentifier = "sentry-dbid-f14a41a0-3e0a-4b1b-ac3c-1160ae1656c8");
+} catch (e) {}
+import { r as useTranslation } from "./translation-CpH8D2NK.js";
+import { P as listToRecord, mt as useAccountHolder, x as Alert } from "./resolveEnvironment-D8-1H8bU.js";
+import { t as Icon } from "./Icon-_YUEZg1p.js";
+import { t as Typography } from "./Typography-CAc_f5Iq.js";
+import { t as Button } from "./Button-Dwr6jvJZ.js";
+import { i as noop, s as keysOf } from "./genUtils-nphCwt1A.js";
+import { t as CountryCodes } from "./country-code-CJk2hdPu.js";
+import { t as TaskTypes } from "./taskTypes-3vSkMBDm.js";
+import { t as DecisionMakerTypes } from "./decisionMaker-CR0qaGWQ.js";
+import { t as Scenarios } from "./scenarios-nibtmpSb.js";
+import { i as useToggleContext, t as Checkbox } from "./Checkbox-zAGhz7rC.js";
+import { i as useAnalyticsContext, r as KEYBOARD_KEYS, t as Modal } from "./Modal-Dx_NESnV.js";
+import { t as useId } from "./useId-CEUET5IS.js";
+import { r as resolveFieldMetadata } from "./form-rules-HzaYJh36.js";
+import { f as translateTranslatable, r as Field } from "./Select-AiAom5JL.js";
+import { s as Confirm } from "./utils-Oc-YLiM0.js";
+import { A as nonInputs, C as validateNotEmptyOnBlur, D as alphanumericInputs, E as alphaInputs, M as spacer, O as customInputs, T as uppercase, a as MaskedInput, i as RadioWithLabel, j as numericInputs, k as makeMask, r as RadioGroup, w as validatePatternOnBlur } from "./dropinUtils-CSlRmPSn.js";
+import { useCallback, useEffect, useMemo, useRef, useState } from "preact/hooks";
+import cx from "classnames";
+import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
+import { computed, signal } from "@preact/signals";
+//#region src/types/datasets/state-code.ts
+var StateCodesUS = {
+	Alabama: "AL",
+	Alaska: "AK",
+	Arizona: "AZ",
+	Arkansas: "AR",
+	California: "CA",
+	Colorado: "CO",
+	Connecticut: "CT",
+	Delaware: "DE",
+	DistrictOfColumbia: "DC",
+	Florida: "FL",
+	Georgia: "GA",
+	Hawaii: "HI",
+	Idaho: "ID",
+	Illinois: "IL",
+	Indiana: "IN",
+	Iowa: "IA",
+	Kansas: "KS",
+	Kentucky: "KY",
+	Louisiana: "LA",
+	Maine: "ME",
+	Maryland: "MD",
+	Massachusetts: "MA",
+	Michigan: "MI",
+	Minnesota: "MN",
+	Mississippi: "MS",
+	Missouri: "MO",
+	Montana: "MT",
+	Nebraska: "NE",
+	Nevada: "NV",
+	NewHampshire: "NH",
+	NewJersey: "NJ",
+	NewMexico: "NM",
+	NewYork: "NY",
+	NorthCarolina: "NC",
+	NorthDakota: "ND",
+	Ohio: "OH",
+	Oklahoma: "OK",
+	Oregon: "OR",
+	Pennsylvania: "PA",
+	RhodeIsland: "RI",
+	SouthCarolina: "SC",
+	SouthDakota: "SD",
+	Tennessee: "TN",
+	Texas: "TX",
+	Utah: "UT",
+	Vermont: "VT",
+	Virginia: "VA",
+	Washington: "WA",
+	WestVirginia: "WV",
+	Wisconsin: "WI",
+	Wyoming: "WY",
+	ArmedForcesAmericas: "AA",
+	ArmedForcesEurope: "AE",
+	ArmedForcesPacific: "AP"
+};
+//#endregion
+//#region src/utils/masking/masks/businessRegistrationNumberMasks.ts
+var businessRegistrationNumberMasks = {
+	[CountryCodes.Austria]: {
+		firmenbuchnummer: { mask: makeMask({
+			type: "input",
+			allow: /[TF]/
+		}, {
+			type: "input",
+			allow: /N/,
+			optional: true
+		}, ...numericInputs(3), ...numericInputs(3, true), {
+			type: "input",
+			allow: /[a-z]/
+		}) },
+		ZVR: { mask: makeMask(...nonInputs("AT", { includeInValue: true }), spacer, ...nonInputs("-", { includeInValue: true }), spacer, ...nonInputs("ZVR", { includeInValue: true }), spacer, ...nonInputs("-", { includeInValue: true }), spacer, ...numericInputs(9), ...numericInputs(1, true)) }
+	},
+	[CountryCodes.Australia]: {
+		default: { mask: makeMask(...numericInputs(3), spacer, ...numericInputs(3), spacer, ...numericInputs(3)) },
+		associationIncorporated: {
+			mask: makeMask(...alphanumericInputs(3), ...alphanumericInputs(20, true)),
+			transformOnType: uppercase
+		}
+	},
+	[CountryCodes.Belgium]: { default: { mask: makeMask(...numericInputs(10)) } },
+	[CountryCodes.Brazil]: { default: { mask: makeMask(...numericInputs(2), ...nonInputs(" . "), ...numericInputs(3), ...nonInputs(" . "), ...numericInputs(3), ...nonInputs(" / "), ...numericInputs(4), ...nonInputs(" - "), ...numericInputs(2)) } },
+	[CountryCodes.Bulgaria]: { default: { mask: makeMask(...numericInputs(9)) } },
+	[CountryCodes.Canada]: { default: {
+		mask: makeMask(...alphanumericInputs(5), ...alphanumericInputs(5, true)),
+		transformOnType: uppercase
+	} },
+	[CountryCodes.Croatia]: {
+		default: { mask: makeMask(...numericInputs(9)) },
+		soleProprietorship: { mask: makeMask(...numericInputs(8)) }
+	},
+	[CountryCodes.Cyprus]: { default: {
+		mask: makeMask(...customInputs(1, /^[COP]$/), ...numericInputs(1), ...numericInputs(7, true)),
+		transformOnType: uppercase
+	} },
+	[CountryCodes.CzechRepublic]: { default: { mask: makeMask(...numericInputs(8), ...numericInputs(2, true)) } },
+	[CountryCodes.Denmark]: { default: { mask: makeMask(...numericInputs(8)) } },
+	[CountryCodes.Estonia]: { default: { mask: makeMask(...numericInputs(8)) } },
+	[CountryCodes.Finland]: { default: { mask: makeMask(...numericInputs(7), spacer, ...nonInputs("-", { includeInValue: true }), spacer, ...numericInputs(1)) } },
+	[CountryCodes.France]: {
+		SIRET: { mask: makeMask(...numericInputs(9), ...nonInputs(" - "), ...numericInputs(5)) },
+		RNA: { mask: makeMask(...nonInputs("W", { includeInValue: true }), ...numericInputs(1), ...alphanumericInputs(1), ...numericInputs(7)) }
+	},
+	[CountryCodes.Germany]: { default: {
+		mask: makeMask(...alphanumericInputs(3), ...customInputs(17, /[A-Z0-9-]/, true)),
+		transformOnType: uppercase
+	} },
+	[CountryCodes.Gibraltar]: { default: {
+		mask: makeMask(...alphanumericInputs(1), ...alphanumericInputs(7, true)),
+		transformOnType: uppercase
+	} },
+	[CountryCodes.Greece]: { default: { mask: makeMask(...numericInputs(12)) } },
+	[CountryCodes.Guernsey]: { default: { mask: makeMask(...numericInputs(1), ...numericInputs(8, true)) } },
+	[CountryCodes.HongKong]: { default: { mask: makeMask(...numericInputs(7)) } },
+	[CountryCodes.Hungary]: {
+		default: { mask: makeMask(...numericInputs(2), ...nonInputs(" - "), ...numericInputs(2), ...nonInputs(" - "), ...numericInputs(6)) },
+		nyilvantartasiSzam: { mask: makeMask(...numericInputs(10)) }
+	},
+	[CountryCodes.Ireland]: { default: { mask: makeMask(...numericInputs(1), ...numericInputs(7, true)) } },
+	[CountryCodes.IsleOfMan]: { default: {
+		mask: makeMask(...numericInputs(6), ...alphaInputs(1)),
+		transformOnType: uppercase
+	} },
+	[CountryCodes.Italy]: {
+		partitaIVA: { mask: makeMask(...numericInputs(11)) },
+		CCIAA: {
+			mask: makeMask(...alphaInputs(2), ...numericInputs(6), ...numericInputs(1, true)),
+			transformOnType: uppercase
+		}
+	},
+	[CountryCodes.Japan]: { default: { mask: makeMask(...numericInputs(12)) } },
+	[CountryCodes.Jersey]: { default: {
+		mask: makeMask(...alphanumericInputs(1), ...alphanumericInputs(8, true)),
+		transformOnType: uppercase
+	} },
+	[CountryCodes.Latvia]: { default: { mask: makeMask(...numericInputs(11)) } },
+	[CountryCodes.Liechtenstein]: { default: { mask: makeMask(...nonInputs("FL", { includeInValue: true }), spacer, ...nonInputs("-", { includeInValue: true }), spacer, ...numericInputs(4), spacer, ...nonInputs(".", { includeInValue: true }), spacer, ...numericInputs(3), spacer, ...nonInputs(".", { includeInValue: true }), spacer, ...numericInputs(3), spacer, ...nonInputs("-", { includeInValue: true }), spacer, ...numericInputs(1)) } },
+	[CountryCodes.Lithuania]: { default: { mask: makeMask(...numericInputs(6), ...numericInputs(3, true)) } },
+	[CountryCodes.Luxembourg]: { default: {
+		mask: makeMask(...alphaInputs(1), ...numericInputs(9, true)),
+		transformOnType: uppercase
+	} },
+	[CountryCodes.Malaysia]: { default: { mask: makeMask(...numericInputs(7), ...numericInputs(5, true)) } },
+	[CountryCodes.Malta]: { default: {
+		mask: makeMask(...customInputs(1, /[CP]/), spacer, ...numericInputs(4), ...numericInputs(2, true)),
+		transformOnType: uppercase
+	} },
+	[CountryCodes.Monaco]: {
+		default: {
+			mask: makeMask(...alphanumericInputs(8), ...alphanumericInputs(3, true)),
+			transformOnType: uppercase
+		},
+		soleProprietorship: {
+			mask: makeMask(...alphanumericInputs(8), ...alphanumericInputs(3, true)),
+			transformOnType: uppercase
+		}
+	},
+	[CountryCodes.Netherlands]: { default: { mask: makeMask(...numericInputs(8)) } },
+	[CountryCodes.NewZealand]: {
+		NZBN: { mask: makeMask(...numericInputs(13)) },
+		companyNumberNZ: { mask: makeMask(...numericInputs(7)) }
+	},
+	[CountryCodes.Norway]: { default: { mask: makeMask(...numericInputs(9)) } },
+	[CountryCodes.Poland]: {
+		krsNumber: { mask: makeMask(...numericInputs(10)) },
+		regon: { mask: makeMask(...numericInputs(9)) }
+	},
+	[CountryCodes.Portugal]: { default: { mask: makeMask(...numericInputs(9)) } },
+	[CountryCodes.Romania]: {
+		roRegNumberOldFormat: {
+			mask: makeMask(...alphaInputs(1), ...numericInputs(1), ...numericInputs(1, true), ...customInputs(1, /[/]/), ...numericInputs(1), ...numericInputs(8, true), ...customInputs(1, /[/]/), ...numericInputs(4)),
+			transformOnType: uppercase
+		},
+		roRegNumberNewFormat: {
+			mask: makeMask({
+				type: "input",
+				allow: /[JFC]/
+			}, ...numericInputs(13)),
+			transformOnType: uppercase
+		}
+	},
+	[CountryCodes.Singapore]: { default: {
+		mask: makeMask(...alphanumericInputs(9), ...alphanumericInputs(1, true)),
+		transformOnType: uppercase
+	} },
+	[CountryCodes.Slovakia]: { default: { mask: makeMask(...numericInputs(8)) } },
+	[CountryCodes.Slovenia]: { default: { mask: makeMask(...numericInputs(10)) } },
+	[CountryCodes.Spain]: { default: {
+		mask: makeMask(...alphaInputs(1), ...alphanumericInputs(8)),
+		transformOnType: uppercase
+	} },
+	[CountryCodes.Sweden]: { default: { mask: makeMask(...numericInputs(6), ...nonInputs(" - "), ...numericInputs(4)) } },
+	[CountryCodes.Switzerland]: { default: { mask: makeMask(...nonInputs("CHE", { includeInValue: true }), ...nonInputs(" - "), ...numericInputs(3), ...nonInputs(" . "), ...numericInputs(3), ...nonInputs(" . "), ...numericInputs(3)) } },
+	[CountryCodes.UnitedKingdom]: {
+		default: {
+			mask: makeMask(...alphanumericInputs(8)),
+			transformOnType: uppercase
+		},
+		nonProfit: {
+			mask: makeMask(...alphanumericInputs(6), ...customInputs(1, /[a-zA-Z0-9-]/, true), ...alphanumericInputs(1, true)),
+			transformOnType: uppercase
+		}
+	},
+	[CountryCodes.UnitedStates]: {
+		[StateCodesUS.Alabama]: {
+			mask: makeMask(...numericInputs(9), ...nonInputs(" "), ...nonInputs(StateCodesUS.Alabama)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Alaska]: {
+			mask: makeMask(...numericInputs(8), ...nonInputs(" "), ...nonInputs(StateCodesUS.Alaska)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Arizona]: {
+			mask: makeMask(...numericInputs(8), ...nonInputs(" "), ...nonInputs(StateCodesUS.Arizona)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Arkansas]: {
+			mask: makeMask({
+				type: "input",
+				allow: /[8]/
+			}, ...numericInputs(8), ...nonInputs(" "), ...nonInputs(StateCodesUS.Arkansas)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.California]: {
+			mask: makeMask(...numericInputs(7), ...numericInputs(5, true), ...nonInputs(" "), ...nonInputs(StateCodesUS.California)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Colorado]: {
+			mask: makeMask(...numericInputs(11), ...nonInputs(" "), ...nonInputs(StateCodesUS.Colorado)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Connecticut]: {
+			mask: makeMask(...numericInputs(7), ...nonInputs(" "), ...nonInputs(StateCodesUS.Connecticut)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Delaware]: {
+			mask: makeMask(...numericInputs(7), ...nonInputs(" "), ...nonInputs(StateCodesUS.Delaware)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Florida]: {
+			mask: makeMask(...numericInputs(6), ...numericInputs(6, true), ...nonInputs(" "), ...nonInputs(StateCodesUS.Florida)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Georgia]: {
+			mask: makeMask(...numericInputs(8), ...nonInputs(" "), ...nonInputs(StateCodesUS.Georgia)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Hawaii]: {
+			mask: makeMask(...numericInputs(5), ...numericInputs(3, true), {
+				type: "input",
+				allow: /[CDFLNPTZ]/
+			}, {
+				type: "input",
+				allow: /[1-8Z]/
+			}, ...nonInputs(" "), ...nonInputs(StateCodesUS.Hawaii)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Idaho]: {
+			mask: makeMask(...numericInputs(6), ...nonInputs(" "), ...nonInputs(StateCodesUS.Idaho)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Illinois]: {
+			mask: makeMask(...numericInputs(8), ...nonInputs(" "), ...nonInputs(StateCodesUS.Illinois)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Indiana]: {
+			mask: makeMask(...numericInputs(10), ...nonInputs(" "), ...nonInputs(StateCodesUS.Indiana)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Iowa]: {
+			mask: makeMask(...numericInputs(6), ...numericInputs(2, true), ...nonInputs(" "), ...nonInputs(StateCodesUS.Iowa)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Kansas]: {
+			mask: makeMask(...numericInputs(7), ...numericInputs(2, true), ...nonInputs(" "), ...nonInputs(StateCodesUS.Kansas)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Kentucky]: {
+			mask: makeMask(...numericInputs(9), ...numericInputs(1, true), ...nonInputs(" "), ...nonInputs(StateCodesUS.Kentucky)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Louisiana]: {
+			mask: makeMask(...numericInputs(9), ...numericInputs(1, true), ...nonInputs(" "), ...nonInputs(StateCodesUS.Louisiana)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Maine]: {
+			mask: makeMask(...numericInputs(8), ...nonInputs(" "), ...nonInputs(StateCodesUS.Maine)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Maryland]: {
+			mask: makeMask(...numericInputs(8), ...nonInputs(" "), ...nonInputs(StateCodesUS.Maryland)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Massachusetts]: {
+			mask: makeMask(...numericInputs(10), ...nonInputs(" "), ...nonInputs(StateCodesUS.Massachusetts)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Michigan]: {
+			mask: makeMask(...numericInputs(6), ...numericInputs(3, true), ...nonInputs(" "), ...nonInputs(StateCodesUS.Michigan)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Minnesota]: {
+			mask: makeMask(...numericInputs(7), ...nonInputs(" "), ...nonInputs(StateCodesUS.Minnesota)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Mississippi]: {
+			mask: makeMask(...numericInputs(7), ...numericInputs(3, true), ...nonInputs(" "), ...nonInputs(StateCodesUS.Mississippi)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Missouri]: {
+			mask: makeMask(...numericInputs(10), ...nonInputs(" "), ...nonInputs(StateCodesUS.Missouri)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Montana]: {
+			mask: makeMask(...numericInputs(7), ...nonInputs(" "), ...nonInputs(StateCodesUS.Montana)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Nebraska]: {
+			mask: makeMask(...numericInputs(9), ...numericInputs(2, true), ...nonInputs(" "), ...nonInputs(StateCodesUS.Nebraska)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Nevada]: {
+			mask: makeMask(...numericInputs(9), ...numericInputs(2, true), ...nonInputs(" "), ...nonInputs(StateCodesUS.Nevada)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.NewHampshire]: {
+			mask: makeMask(...numericInputs(9), ...nonInputs(" "), ...nonInputs(StateCodesUS.NewHampshire)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.NewJersey]: {
+			mask: makeMask(...numericInputs(10), ...nonInputs(" "), ...nonInputs(StateCodesUS.NewJersey)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.NewMexico]: {
+			mask: makeMask(...numericInputs(6), ...nonInputs(" "), ...nonInputs(StateCodesUS.NewMexico)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.NewYork]: {
+			mask: makeMask(...numericInputs(7), ...nonInputs(" "), ...nonInputs(StateCodesUS.NewYork)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.NorthCarolina]: {
+			mask: makeMask(...numericInputs(7), ...nonInputs(" "), ...nonInputs(StateCodesUS.NorthCarolina)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.NorthDakota]: {
+			mask: makeMask(...numericInputs(7), ...numericInputs(3, true), ...nonInputs(" "), ...nonInputs(StateCodesUS.NorthDakota)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Ohio]: {
+			mask: makeMask(...numericInputs(10), ...nonInputs(" "), ...nonInputs(StateCodesUS.Ohio)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Oklahoma]: {
+			mask: makeMask(...numericInputs(10), ...nonInputs(" "), ...nonInputs(StateCodesUS.Oklahoma)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Oregon]: {
+			mask: makeMask(...numericInputs(9), ...nonInputs(" "), ...nonInputs(StateCodesUS.Oregon)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Pennsylvania]: {
+			mask: makeMask(...numericInputs(7), ...nonInputs(" "), ...nonInputs(StateCodesUS.Pennsylvania)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.RhodeIsland]: {
+			mask: makeMask(...numericInputs(7), ...nonInputs(" "), ...nonInputs(StateCodesUS.RhodeIsland)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.SouthCarolina]: {
+			mask: makeMask(...numericInputs(7), ...nonInputs(" "), ...nonInputs(StateCodesUS.SouthCarolina)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.SouthDakota]: {
+			mask: makeMask(...numericInputs(7), ...nonInputs(" "), ...nonInputs(StateCodesUS.SouthDakota)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Tennessee]: {
+			mask: makeMask(...numericInputs(6), ...nonInputs(" "), ...nonInputs(StateCodesUS.Tennessee)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Texas]: {
+			mask: makeMask(...numericInputs(10), ...nonInputs(" "), ...nonInputs(StateCodesUS.Texas)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Utah]: {
+			mask: makeMask(...numericInputs(7), ...nonInputs(" "), ...nonInputs(StateCodesUS.Utah)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Vermont]: {
+			mask: makeMask(...numericInputs(6), ...nonInputs(" "), ...nonInputs(StateCodesUS.Vermont)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Virginia]: {
+			mask: makeMask(...numericInputs(7), ...nonInputs(" "), ...nonInputs(StateCodesUS.Virginia)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Washington]: {
+			mask: makeMask(...numericInputs(9), ...nonInputs(" "), ...nonInputs(StateCodesUS.Washington)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.WestVirginia]: {
+			mask: makeMask(...numericInputs(6), ...nonInputs(" "), ...nonInputs(StateCodesUS.WestVirginia)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Wisconsin]: {
+			mask: makeMask(...numericInputs(6), ...nonInputs(" "), ...nonInputs(StateCodesUS.Wisconsin)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.Wyoming]: {
+			mask: makeMask(...numericInputs(6), ...nonInputs(" "), ...nonInputs(StateCodesUS.Wyoming)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.DistrictOfColumbia]: {
+			mask: makeMask(...numericInputs(9)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.ArmedForcesAmericas]: {
+			mask: makeMask(...numericInputs(9)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.ArmedForcesEurope]: {
+			mask: makeMask(...numericInputs(9)),
+			transformOnType: uppercase
+		},
+		[StateCodesUS.ArmedForcesPacific]: {
+			mask: makeMask(...numericInputs(9)),
+			transformOnType: uppercase
+		},
+		default: {
+			mask: makeMask(...numericInputs(9)),
+			transformOnType: uppercase
+		}
+	}
+};
+var stateFormatGuidanceText = {
+	[StateCodesUS.Alabama]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "9",
+			example: "123456789 AL"
+		}
+	},
+	[StateCodesUS.Alaska]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "8",
+			example: "12345678 AK"
+		}
+	},
+	[StateCodesUS.Arizona]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "8",
+			example: "12345678 AZ"
+		}
+	},
+	[StateCodesUS.Arkansas]: {
+		key: "enterTheRemainingNDigitsForExample",
+		values: {
+			numDigits: "8",
+			example: "800000001 AR"
+		}
+	},
+	[StateCodesUS.California]: {
+		key: "enterXOrYDigitsForExample",
+		values: {
+			xDigits: "8",
+			yDigits: "12",
+			example: "12345678 CA"
+		}
+	},
+	[StateCodesUS.Colorado]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "11",
+			example: "12345678901 CO"
+		}
+	},
+	[StateCodesUS.Connecticut]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "7",
+			example: "1234567 CT"
+		}
+	},
+	[StateCodesUS.Delaware]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "7",
+			example: "1234567 DE"
+		}
+	},
+	[StateCodesUS.Florida]: {
+		key: "enterXOrYDigitsForExample",
+		values: {
+			xDigits: "6",
+			yDigits: "12",
+			example: "123456789012 FL"
+		}
+	},
+	[StateCodesUS.Georgia]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "8",
+			example: "12345678 GA"
+		}
+	},
+	[StateCodesUS.Hawaii]: {
+		key: "validationPleaseEnterAValidBusinessRegistrationNumberWithFormat",
+		values: { example: "12345678ZZ HI" }
+	},
+	[StateCodesUS.Idaho]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "6",
+			example: "123456 ID"
+		}
+	},
+	[StateCodesUS.Illinois]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "8",
+			example: "12345678 IL"
+		}
+	},
+	[StateCodesUS.Indiana]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "10",
+			example: "1234567890 IN"
+		}
+	},
+	[StateCodesUS.Iowa]: {
+		key: "enterXToYDigitsForExample",
+		values: {
+			minDigits: "6",
+			maxDigits: "8",
+			example: "12345678 IA"
+		}
+	},
+	[StateCodesUS.Kansas]: {
+		key: "enterXToYDigitsForExample",
+		values: {
+			minDigits: "7",
+			maxDigits: "9",
+			example: "1234567890 KS"
+		}
+	},
+	[StateCodesUS.Kentucky]: {
+		key: "enterXToYDigitsForExample",
+		values: {
+			minDigits: "9",
+			maxDigits: "10",
+			example: "1234567890 KY"
+		}
+	},
+	[StateCodesUS.Louisiana]: {
+		key: "enterXToYDigitsForExample",
+		values: {
+			minDigits: "9",
+			maxDigits: "10",
+			example: "1234567890 LA"
+		}
+	},
+	[StateCodesUS.Maine]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "8",
+			example: "12345678 ME"
+		}
+	},
+	[StateCodesUS.Maryland]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "8",
+			example: "12345678 MD"
+		}
+	},
+	[StateCodesUS.Massachusetts]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "10",
+			example: "1234567890 MA"
+		}
+	},
+	[StateCodesUS.Michigan]: {
+		key: "enterXOrYDigitsForExample",
+		values: {
+			xDigits: "6",
+			yDigits: "9",
+			example: "123456 MI"
+		}
+	},
+	[StateCodesUS.Minnesota]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "7",
+			example: "1234567 MN"
+		}
+	},
+	[StateCodesUS.Mississippi]: {
+		key: "enterXToYDigitsForExample",
+		values: {
+			minDigits: "7",
+			maxDigits: "10",
+			example: "1234567 MS"
+		}
+	},
+	[StateCodesUS.Missouri]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "10",
+			example: "1234567890 MO"
+		}
+	},
+	[StateCodesUS.Montana]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "7",
+			example: "1234567 MT"
+		}
+	},
+	[StateCodesUS.Nebraska]: {
+		key: "enterXToYDigitsForExample",
+		values: {
+			minDigits: "9",
+			maxDigits: "11",
+			example: "123456789 NE"
+		}
+	},
+	[StateCodesUS.Nevada]: {
+		key: "enterXToYDigitsForExample",
+		values: {
+			minDigits: "9",
+			maxDigits: "11",
+			example: "123456789 NV"
+		}
+	},
+	[StateCodesUS.NewHampshire]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "9",
+			example: "123456789 NH"
+		}
+	},
+	[StateCodesUS.NewJersey]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "10",
+			example: "1234567890 NJ"
+		}
+	},
+	[StateCodesUS.NewMexico]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "6",
+			example: "123456 NM"
+		}
+	},
+	[StateCodesUS.NewYork]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "7",
+			example: "1234567 NY"
+		}
+	},
+	[StateCodesUS.NorthCarolina]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "7",
+			example: "1234567 NC"
+		}
+	},
+	[StateCodesUS.NorthDakota]: {
+		key: "enterXToYDigitsForExample",
+		values: {
+			minDigits: "7",
+			maxDigits: "10",
+			example: "1234567 ND"
+		}
+	},
+	[StateCodesUS.Ohio]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "10",
+			example: "1234567890 OH"
+		}
+	},
+	[StateCodesUS.Oklahoma]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "10",
+			example: "1234567890 OK"
+		}
+	},
+	[StateCodesUS.Oregon]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "9",
+			example: "123456789 OR"
+		}
+	},
+	[StateCodesUS.Pennsylvania]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "7",
+			example: "1234567 PA"
+		}
+	},
+	[StateCodesUS.RhodeIsland]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "7",
+			example: "1234567 RI"
+		}
+	},
+	[StateCodesUS.SouthCarolina]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "7",
+			example: "1234567 SC"
+		}
+	},
+	[StateCodesUS.SouthDakota]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "7",
+			example: "1234567 SD"
+		}
+	},
+	[StateCodesUS.Tennessee]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "6",
+			example: "123456 TN"
+		}
+	},
+	[StateCodesUS.Texas]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "10",
+			example: "1234567890 TX"
+		}
+	},
+	[StateCodesUS.Utah]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "7",
+			example: "1234567 UT"
+		}
+	},
+	[StateCodesUS.Vermont]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "6",
+			example: "123456 VT"
+		}
+	},
+	[StateCodesUS.Virginia]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "7",
+			example: "1234567 VA"
+		}
+	},
+	[StateCodesUS.Washington]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "9",
+			example: "123456789 WA"
+		}
+	},
+	[StateCodesUS.WestVirginia]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "6",
+			example: "123456 WV"
+		}
+	},
+	[StateCodesUS.Wisconsin]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "6",
+			example: "123456 WI"
+		}
+	},
+	[StateCodesUS.Wyoming]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "6",
+			example: "123456 WY"
+		}
+	},
+	[StateCodesUS.DistrictOfColumbia]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "9",
+			example: "123456789"
+		}
+	},
+	[StateCodesUS.ArmedForcesAmericas]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "9",
+			example: "123456789"
+		}
+	},
+	[StateCodesUS.ArmedForcesEurope]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "9",
+			example: "123456789"
+		}
+	},
+	[StateCodesUS.ArmedForcesPacific]: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "9",
+			example: "123456789"
+		}
+	},
+	default: {
+		key: "enterNDigitsForExample",
+		values: {
+			numDigits: "9",
+			example: "123456789"
+		}
+	}
+};
+//#endregion
+//#region src/utils/regex/businessRegistrationNumberPatterns.ts
+var businessRegistrationNumberPatterns = {
+	[CountryCodes.Australia]: {
+		default: /^\d{9}$/,
+		associationIncorporated: /^[a-zA-Z0-9]{3,20}$/
+	},
+	[CountryCodes.Austria]: {
+		firmenbuchnummer: /^(FN|T)\d{3,6}[a-z]$/,
+		ZVR: /^(AT-ZVR-)\d{9,10}$/
+	},
+	[CountryCodes.Belgium]: { default: /^\d{10}$/ },
+	[CountryCodes.Brazil]: { default: /^\d{14}$/ },
+	[CountryCodes.Bulgaria]: { default: /^\d{9}$/ },
+	[CountryCodes.Canada]: { default: /^[a-zA-Z0-9]{5,10}$/ },
+	[CountryCodes.Croatia]: {
+		default: /^\d{9}$/,
+		soleProprietorship: /^\d{8}$/
+	},
+	[CountryCodes.Cyprus]: { default: /^[COP]{1}\d{1,8}$/ },
+	[CountryCodes.CzechRepublic]: { default: /^\d{8,10}$/ },
+	[CountryCodes.Denmark]: { default: /^\d{8}$/ },
+	[CountryCodes.Estonia]: { default: /^\d{8}$/ },
+	[CountryCodes.Finland]: { default: /^\d{7}-?\d$/ },
+	[CountryCodes.France]: {
+		SIRET: /^\d{9}-?\d{5}$/,
+		RNA: /^W(\d{9}|\d[A-Za-z]\d{7})$/
+	},
+	[CountryCodes.Gibraltar]: { default: /^[a-zA-Z0-9]{1,8}$/ },
+	[CountryCodes.Germany]: { default: /^[A-Z]{2,3}\d{1,6}[A-Z]{0,5}(?:-[A-Z]\d{4})?$/ },
+	[CountryCodes.Greece]: { default: /^\d{12}$/ },
+	[CountryCodes.Guernsey]: { default: /^\d{1,9}$/ },
+	[CountryCodes.HongKong]: { default: /^\d{7}$/ },
+	[CountryCodes.Hungary]: {
+		default: /^\d{10}$/,
+		nyilvantartasiSzam: /^\d{7,10}$/
+	},
+	[CountryCodes.Iceland]: { default: /^\d{10}$/ },
+	[CountryCodes.India]: { default: /^\d{21}$/ },
+	[CountryCodes.Indonesia]: { default: /^\d{12}$/ },
+	[CountryCodes.Ireland]: { default: /^[1-9]\d{1,7}$/ },
+	[CountryCodes.IsleOfMan]: { default: /^\d{6}[A-Z]$/ },
+	[CountryCodes.Italy]: {
+		partitaIVA: /^\d{11}$/,
+		CCIAA: /^[a-zA-Z]{2}\d{6,7}$/
+	},
+	[CountryCodes.Japan]: { default: /^\d{12}$/ },
+	[CountryCodes.Jersey]: { default: /^[a-zA-Z0-9]{1,9}$/ },
+	[CountryCodes.Korea]: { default: /^\d{10}$/ },
+	[CountryCodes.Latvia]: { default: /^\d{11}$/ },
+	[CountryCodes.Liechtenstein]: { default: /FL-[0-9]{4}[.][0-9]{3}[.][0-9]{3}-[0-9]$/ },
+	[CountryCodes.Lithuania]: { default: /^\d{6,9}$/ },
+	[CountryCodes.Luxembourg]: { default: /^[a-zA-Z]\d{1,9}$/ },
+	[CountryCodes.Malaysia]: { default: /^\d{7}$|^\d{12}$/ },
+	[CountryCodes.Malta]: { default: /^[CP]\s?\d{4,6}$/ },
+	[CountryCodes.Monaco]: {
+		default: /^[0-9]{2}[A-Z]{1,3}[0-9]{5}$/,
+		soleProprietorship: /^\d{2,4}[A-Z]\d{5}$/
+	},
+	[CountryCodes.Netherlands]: { default: /^\d{8}$/ },
+	[CountryCodes.NewZealand]: {
+		NZBN: /^\d{13}$/,
+		companyNumberNZ: /^\d{7}$/
+	},
+	[CountryCodes.Norway]: { default: /^\d{9}$/ },
+	[CountryCodes.Poland]: {
+		krsNumber: /^\d{10}$/,
+		regon: /^\d{9}$/
+	},
+	[CountryCodes.Portugal]: { default: /^\d{9}$/ },
+	[CountryCodes.Romania]: {
+		roRegNumberOldFormat: /^[A-Z]\d{1,2}\/\d{1,9}\/\d{4}$/,
+		roRegNumberNewFormat: /^[JFC]\d{13}$/
+	},
+	[CountryCodes.Singapore]: { default: /^[a-zA-Z0-9]{9,10}$/ },
+	[CountryCodes.Slovakia]: { default: /^\d{8}$/ },
+	[CountryCodes.Slovenia]: { default: /^\d{10}$/ },
+	[CountryCodes.Spain]: { default: /^[a-zA-Z][a-zA-Z0-9]{8}$/ },
+	[CountryCodes.Sweden]: { default: /^\d{10}$/ },
+	[CountryCodes.Switzerland]: { default: /^CHE\d{9}$|^CH\d{11}$/ },
+	[CountryCodes.UnitedKingdom]: {
+		default: /^[a-zA-Z0-9]{8}$/,
+		nonProfit: /^(?:(?:[A-Z]{2})?\d{6}|\d{6,8}|\d{6}-\d)$/
+	},
+	[CountryCodes.UnitedStates]: {
+		[StateCodesUS.Alabama]: /^\d{9}$/,
+		[StateCodesUS.Alaska]: /^\d{8}$/,
+		[StateCodesUS.Arizona]: /^\d{8}$/,
+		[StateCodesUS.Arkansas]: /^8\d{8}$/,
+		[StateCodesUS.California]: /^\d{7}$|^\d{12}$/,
+		[StateCodesUS.Colorado]: /^\d{11}$/,
+		[StateCodesUS.Connecticut]: /^\d{7}$/,
+		[StateCodesUS.Delaware]: /^\d{7}$/,
+		[StateCodesUS.Florida]: /^\d{6}$|^\d{12}$/,
+		[StateCodesUS.Georgia]: /^\d{8}$/,
+		[StateCodesUS.Hawaii]: /^\d{5,8}(C1|C2|C3|C4|C5|D1|D2|D3|D4|F1|F2|L1|L2|N1|N2|P1|P2|T1|T2|T3|T4|T5|T6|T7|T8|ZZ)$/,
+		[StateCodesUS.Idaho]: /^\d{6}$/,
+		[StateCodesUS.Illinois]: /^\d{8}$/,
+		[StateCodesUS.Indiana]: /^\d{10}$/,
+		[StateCodesUS.Iowa]: /^\d{6,8}$/,
+		[StateCodesUS.Kansas]: /^\d{7,9}$/,
+		[StateCodesUS.Kentucky]: /^\d{9,10}$/,
+		[StateCodesUS.Louisiana]: /^\d{9,10}$/,
+		[StateCodesUS.Maine]: /^\d{8}$/,
+		[StateCodesUS.Maryland]: /^\d{8}$/,
+		[StateCodesUS.Massachusetts]: /^\d{10}$/,
+		[StateCodesUS.Michigan]: /^\d{6}$|^\d{9}$/,
+		[StateCodesUS.Minnesota]: /^\d{7}$/,
+		[StateCodesUS.Mississippi]: /^\d{7,10}$/,
+		[StateCodesUS.Missouri]: /^\d{10}$/,
+		[StateCodesUS.Montana]: /^\d{7}$/,
+		[StateCodesUS.Nebraska]: /^\d{9,11}$/,
+		[StateCodesUS.Nevada]: /^\d{9,11}$/,
+		[StateCodesUS.NewHampshire]: /^\d{9}$/,
+		[StateCodesUS.NewJersey]: /^\d{10}$/,
+		[StateCodesUS.NewMexico]: /^\d{6}$/,
+		[StateCodesUS.NewYork]: /^\d{7}$/,
+		[StateCodesUS.NorthCarolina]: /^\d{7}$/,
+		[StateCodesUS.NorthDakota]: /^\d{7,10}$/,
+		[StateCodesUS.Ohio]: /^\d{10}$/,
+		[StateCodesUS.Oklahoma]: /^\d{10}$/,
+		[StateCodesUS.Oregon]: /^\d{9}$/,
+		[StateCodesUS.Pennsylvania]: /^\d{7}$/,
+		[StateCodesUS.RhodeIsland]: /^\d{7}$/,
+		[StateCodesUS.SouthCarolina]: /^\d{7}$/,
+		[StateCodesUS.SouthDakota]: /^\d{7}$/,
+		[StateCodesUS.Tennessee]: /^\d{6}$/,
+		[StateCodesUS.Texas]: /^\d{10}$/,
+		[StateCodesUS.Utah]: /^\d{7}$/,
+		[StateCodesUS.Vermont]: /^\d{6}$/,
+		[StateCodesUS.Virginia]: /^\d{7}$/,
+		[StateCodesUS.Washington]: /^\d{9}$/,
+		[StateCodesUS.WestVirginia]: /^\d{6}$/,
+		[StateCodesUS.Wisconsin]: /^\d{6}$/,
+		[StateCodesUS.Wyoming]: /^\d{6}$/,
+		[StateCodesUS.DistrictOfColumbia]: /^\d{9}$/,
+		[StateCodesUS.ArmedForcesAmericas]: /^\d{9}$/,
+		[StateCodesUS.ArmedForcesEurope]: /^\d{9}$/,
+		[StateCodesUS.ArmedForcesPacific]: /^\d{9}$/,
+		default: /^\d{9}$/
+	}
+};
+//#endregion
+//#region src/utils/mapScriptLocalization.ts
+/**
+* Takes a {@link ScriptLocalization} and converts it into a schema with matching field names.
+*
+* E.g.
+* ```ts
+* const scriptLocalization = {
+*   script: 'ja-Kana',
+*   fields: {
+*     firstName: 'アレキサンダー',
+*     lastName: 'パトリック',
+*   },
+* } as const;
+*
+* const schema = mapApiScriptLocalizationToSchemaFields(scriptLocalization);
+* console.log(schema);
+* // {
+* //   jaKanaFirstName: 'アレキサンダー',
+* //   jaKanaLastName: 'パトリック'
+* // }
+* ```
+*
+*/
+function mapApiScriptLocalizationToSchemaFields(localization) {
+	const schema = {};
+	const scriptNameInSchema = localization.script.replace("-", "");
+	for (const [field, value] of Object.entries(localization.fields)) schema[scriptNameInSchema + field[0].toUpperCase() + field.slice(1)] = value;
+	return schema;
+}
+/**
+* Given a schema and a script, takes the fields prefixed with that script and produces a {@link ScriptLocalization}.
+*
+* E.g.
+* ```ts
+* const schema = {
+*   firstName: 'Alex',
+*   lastName: 'Tompkins',
+*   jaKanaFirstName: 'アレキサンダー',
+*   jaKanaLastName: 'パトリック',
+*   jaHaniFirstName: 'pretend this is hiragana',
+*   jaHaniLastName: 'this too',
+* };
+*
+* const localization = mapSchemaFieldsToApiScriptLocalization(schema, 'jaKana');
+* console.log(localization);
+* // {
+* //   script: 'ja-Kana',
+* //   fields: { firstName: 'アレキサンダー', lastName: 'パトリック' },
+* // };
+* ```
+*/
+function mapSchemaFieldsToApiScriptLocalization(data, script) {
+	const fields = {};
+	for (const [schemaField, value] of Object.entries(data)) if (schemaField.startsWith(script)) {
+		let fieldName = schemaField.replace(script, "");
+		fieldName = fieldName[0].toLowerCase() + fieldName.slice(1);
+		fields[fieldName] = value;
+	}
+	return {
+		script: `${script.slice(0, 2)}-${script.slice(2)}`,
+		fields
+	};
+}
+//#endregion
+//#region src/utils/isEmpty.ts
+var isEmpty = (obj, ignoreEmptyProperties = true) => {
+	if (obj === null || obj === void 0) return true;
+	if (Array.isArray(obj)) return obj.length === 0;
+	if (typeof obj !== "object") return false;
+	return keysOf(obj).every((key) => !Object.hasOwn(obj, key) || ignoreEmptyProperties && isEmpty(obj[key], true));
+};
+//#endregion
+//#region src/utils/businessUtils.ts
+/**
+* @description Countries in this list use the provider-backed company search flow.
+* For these countries, business details can be prefilled from provider results,
+* and search/verification may require tax identifiers (for example TIN or VAT)
+* in addition to company name/registration details.
+*
+* If a country is in this list, it means it will attempt to make an api call for company search.
+* If the api doesnt have a provider for that country, it will return no results like below
+* ```
+* {
+*   "results": [],
+*   "provider": "NO_PROVIDER"
+* }
+* ```
+*/
+var COUNTRIES_USING_COMPANY_SEARCH = [
+	CountryCodes.UnitedStates,
+	CountryCodes.UnitedKingdom,
+	CountryCodes.Germany,
+	CountryCodes.France
+];
+/**
+* Source of truth for registration-number exemption eligibility in Business Details.
+*
+* This map defines which company types can use `exemptedFromRegistrationNumber`, grouped by
+* country. All exemption checks should be derived from this structure to keep behavior consistent
+* across form rules.
+*
+* Interpretation:
+* - Non-empty array: exemption is allowed only for the listed company types.
+* - Empty array: exemption is allowed for that country without company-type restrictions.
+*
+*/
+var REGISTRATION_NUMBER_EXEMPTION_RULES = {
+	[CountryCodes.Australia]: ["governmentalOrganization", "partnershipIncorporated"],
+	[CountryCodes.Austria]: ["soleProprietorship"],
+	[CountryCodes.Canada]: ["soleProprietorship"],
+	[CountryCodes.Denmark]: ["nonProfit"],
+	[CountryCodes.Finland]: ["soleProprietorship"],
+	[CountryCodes.Germany]: [
+		"governmentalOrganization",
+		"nonProfit",
+		"soleProprietorship"
+	],
+	[CountryCodes.HongKong]: [
+		"privateCompany",
+		"nonProfit",
+		"listedPublicCompany",
+		"unlistedPublicCompany",
+		"governmentalOrganization",
+		"partnershipIncorporated",
+		"associationIncorporated"
+	],
+	[CountryCodes.Lithuania]: ["soleProprietorship"],
+	[CountryCodes.Luxembourg]: ["soleProprietorship"],
+	[CountryCodes.NewZealand]: [],
+	[CountryCodes.Poland]: ["soleProprietorship"],
+	[CountryCodes.Sweden]: ["soleProprietorship"],
+	[CountryCodes.Switzerland]: ["soleProprietorship"]
+};
+/**
+* Determines whether a registration-number exemption can be offered for a country and company type.
+*
+* Provide `companyType` when checking a specific entity (including a sole proprietorship); this checks
+* that exact type against the country's rule. Omit it when deciding whether to show the exemption option
+* for all company types in that country; it is then available only when at least one
+* non-sole-proprietorship type is eligible.
+*
+* This distinction prevents sole-proprietorship-only countries from exposing the exemption to
+* businesses while still allowing unrestricted countries (an empty rule) for every entity type.
+*/
+var isRegistrationExemptionAllowed = ({ country, companyType }) => {
+	const allowedCompanyTypes = REGISTRATION_NUMBER_EXEMPTION_RULES[country];
+	if (!allowedCompanyTypes) return false;
+	if (allowedCompanyTypes.length === 0) return true;
+	return companyType ? allowedCompanyTypes.includes(companyType) : allowedCompanyTypes.some((allowedCompanyType) => allowedCompanyType !== "soleProprietorship");
+};
+var isRegistrationNumberAbsentStateV4Scenario = (country, entityType) => country === CountryCodes.Australia && (entityType === "governmentalOrganization" || entityType === "partnershipIncorporated") || country === CountryCodes.NewZealand;
+var COUNTRIES_THAT_DONT_REQUIRE_COMPANY_REGISTRATION = [
+	CountryCodes.HongKong,
+	CountryCodes.Mexico,
+	CountryCodes.PuertoRico,
+	CountryCodes.UnitedStates
+];
+var COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER = [CountryCodes.Canada, CountryCodes.UnitedStates];
+/**
+*  Also used to determine what documenttype needs to be used
+*  when uploading tax document in mapping.ts
+* */
+var COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT = [
+	CountryCodes.Australia,
+	CountryCodes.Canada,
+	CountryCodes.Gibraltar,
+	CountryCodes.HongKong,
+	CountryCodes.NewZealand,
+	CountryCodes.PuertoRico,
+	CountryCodes.Singapore,
+	CountryCodes.UnitedStates,
+	CountryCodes.Guernsey,
+	CountryCodes.Jersey,
+	CountryCodes.IsleOfMan,
+	CountryCodes.Mexico,
+	CountryCodes.Brazil,
+	CountryCodes.Japan
+];
+var COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_COMPANIES = [];
+var COUNTRIES_REQUIRING_FINANCIAL_INFORMATION = [
+	CountryCodes.Austria,
+	CountryCodes.Belgium,
+	CountryCodes.Croatia,
+	CountryCodes.Cyprus,
+	CountryCodes.Estonia,
+	CountryCodes.Finland,
+	CountryCodes.France,
+	CountryCodes.Germany,
+	CountryCodes.Greece,
+	CountryCodes.Ireland,
+	CountryCodes.Italy,
+	CountryCodes.Latvia,
+	CountryCodes.Lithuania,
+	CountryCodes.Luxembourg,
+	CountryCodes.Malta,
+	CountryCodes.Netherlands,
+	CountryCodes.Portugal,
+	CountryCodes.Slovakia,
+	CountryCodes.Slovenia,
+	CountryCodes.Spain,
+	CountryCodes.UnitedKingdom
+];
+var COUNTRIES_WITH_POSSIBLE_TRUSTEE_TAXID_ABSENT_V4 = [CountryCodes.Australia];
+var TAX_ID_REQUIRED_COUNTRIES_ORGANIZATION = [
+	CountryCodes.Austria,
+	CountryCodes.Belgium,
+	CountryCodes.Croatia,
+	CountryCodes.Cyprus,
+	CountryCodes.Germany,
+	CountryCodes.Greece,
+	CountryCodes.Ireland,
+	CountryCodes.Luxembourg,
+	CountryCodes.Malta,
+	CountryCodes.Netherlands,
+	CountryCodes.Slovakia,
+	CountryCodes.Slovenia
+];
+/**
+* Sole proprietorship specific rules
+*/
+var COUNTRIES_THAT_DONT_REQUIRE_SOLE_PROP_REGISTRATION = [
+	CountryCodes.Australia,
+	CountryCodes.Gibraltar,
+	CountryCodes.Guernsey,
+	CountryCodes.HongKong,
+	CountryCodes.Ireland,
+	CountryCodes.IsleOfMan,
+	CountryCodes.Jersey,
+	CountryCodes.Malta,
+	CountryCodes.Mexico,
+	CountryCodes.PuertoRico,
+	CountryCodes.Spain,
+	CountryCodes.UnitedKingdom,
+	CountryCodes.UnitedStates
+];
+var COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_SOLE_PROPS = [
+	CountryCodes.Canada,
+	CountryCodes.PuertoRico,
+	CountryCodes.UnitedStates
+];
+var COUNTRIES_THAT_DO_NOT_USE_TAX_ID_FOR_SOLE_PROP = [CountryCodes.Singapore];
+var COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER_SOLE_PROPS = [CountryCodes.Germany];
+var isUsingCompanySearch = (country, taskType) => {
+	if (taskType !== TaskTypes.BUSINESS_DETAILS && taskType !== TaskTypes.GLOBAL_ENTRY) return false;
+	return COUNTRIES_USING_COMPANY_SEARCH.includes(country);
+};
+/**
+* A Japanese business has a kanji legal name and a katakana reading of it, neither of which can be
+* derived from the roman one, so they travel beside it as script localizations.
+*
+* @param data the form section holding the localized name fields, whatever the task calls it
+* @returns the localizations that were filled in, so an empty array when neither was asked for
+*/
+var mapJapaneseLegalNamesToLocalization = (data) => [mapSchemaFieldsToApiScriptLocalization(data, "jaHani"), mapSchemaFieldsToApiScriptLocalization(data, "jaKana")].filter(({ fields }) => !isEmpty(fields)).map(({ script, fields }) => ({
+	script,
+	fields: { legalName: fields.legalCompanyName }
+}));
+/**
+* Reads the kanji and katakana legal names back out of the script localizations, so they can
+* prefill the fields they came from.
+*
+* @param localization the organization's script localizations, when it has any
+*/
+var mapLocalizationToJapaneseLegalNames = (localization) => (localization ?? []).reduce((schemaFields, { script, fields }) => ({
+	...schemaFields,
+	...mapApiScriptLocalizationToSchemaFields({
+		script,
+		fields: { legalCompanyName: fields?.legalName }
+	})
+}), {});
+var Tile_module_default = {
+	"tile-container": "_tile-container_17be3_1",
+	tileContainer: "_tile-container_17be3_1",
+	tile: "_tile_17be3_1",
+	"tile-icon": "_tile-icon_17be3_18",
+	tileIcon: "_tile-icon_17be3_18",
+	"tile-title": "_tile-title_17be3_35",
+	tileTitle: "_tile-title_17be3_35",
+	"tile-checkbox": "_tile-checkbox_17be3_49",
+	tileCheckbox: "_tile-checkbox_17be3_49",
+	"tile-container-horizontal": "_tile-container-horizontal_17be3_89",
+	tileContainerHorizontal: "_tile-container-horizontal_17be3_89",
+	"tile-label": "_tile-label_17be3_100",
+	tileLabel: "_tile-label_17be3_100"
+};
+//#endregion
+//#region src/components/ui/atoms/Tile/Tile.tsx
+function Tile({ checked, disabled, icon, id, inputType = "checkbox", isHorizontal, label, name, className, onChange, subTitle, value }) {
+	const inputNode = useRef(null);
+	const uniqId = useId("tile");
+	const idUse = id ?? uniqId;
+	const handleChange = (e) => {
+		if (disabled) return;
+		onChange?.(e.currentTarget.checked);
+		inputNode.current?.focus();
+	};
+	const handleClick = (e) => {
+		if (disabled || inputType === "radio") return;
+		if (checked) {
+			e.preventDefault();
+			onChange?.(false);
+			inputNode.current?.focus();
+		}
+	};
+	const handleOnKeyDown = (e) => {
+		if (e.key === KEYBOARD_KEYS.enter || e.key === KEYBOARD_KEYS.space) {
+			e.preventDefault();
+			if (disabled) return;
+			if (inputType === "radio" && !checked) {
+				onChange?.(true);
+				inputNode.current?.focus();
+			} else if (inputType === "checkbox") {
+				onChange?.(!checked);
+				inputNode.current?.focus();
+			}
+		}
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		className: cx(Tile_module_default.tileContainer, className, { [Tile_module_default.tileContainerHorizontal]: isHorizontal }),
+		children: [/* @__PURE__ */ jsx("input", {
+			ref: inputNode,
+			className: Tile_module_default.tileCheckbox,
+			disabled,
+			checked: !!checked,
+			value,
+			id: idUse,
+			name,
+			type: inputType,
+			onKeyDown: handleOnKeyDown,
+			onChange: handleChange,
+			onClick: handleClick,
+			"aria-disabled": disabled,
+			tabIndex: disabled ? -1 : 0
+		}), /* @__PURE__ */ jsxs("label", {
+			htmlFor: idUse,
+			className: Tile_module_default.tile,
+			children: [icon && /* @__PURE__ */ jsx("div", {
+				className: Tile_module_default.tileIcon,
+				children: /* @__PURE__ */ jsx(Icon, {
+					name: icon,
+					testId: icon
+				})
+			}), /* @__PURE__ */ jsxs("div", {
+				className: Tile_module_default.tileLabel,
+				children: [/* @__PURE__ */ jsx(Typography, {
+					el: "h4",
+					variant: "body-strongest",
+					className: Tile_module_default.tileTitle,
+					children: label
+				}), subTitle && /* @__PURE__ */ jsx(Typography, {
+					el: "p",
+					variant: "body",
+					children: subTitle
+				})]
+			})]
+		})]
+	});
+}
+var TileGroup_module_default = {
+	"tile-group": "_tile-group_6rtof_1",
+	tileGroup: "_tile-group_6rtof_1",
+	"tile-container": "_tile-container_6rtof_8",
+	tileContainer: "_tile-container_6rtof_8",
+	"tile-group-error": "_tile-group-error_6rtof_14",
+	tileGroupError: "_tile-group-error_6rtof_14",
+	"tile-group-error-icon": "_tile-group-error-icon_6rtof_27",
+	tileGroupErrorIcon: "_tile-group-error-icon_6rtof_27",
+	"tile-group-horizontal": "_tile-group-horizontal_6rtof_32",
+	tileGroupHorizontal: "_tile-group-horizontal_6rtof_32"
+};
+//#endregion
+//#region src/components/ui/atoms/TileGroup/TileGroup.tsx
+function TileGroup({ tiles, selected, allowMultiple = false, isHorizontal, name: nameProp, maxSelected = Infinity, errorMessage, onChange = noop, enableTracking = false, trackingFieldName }) {
+	const uniqName = useId("tile");
+	const name = nameProp ?? uniqName;
+	const finalName = allowMultiple ? `${name}[]` : name;
+	const inputType = allowMultiple ? "checkbox" : "radio";
+	const userEvents = useAnalyticsContext();
+	return /* @__PURE__ */ jsxs(Fragment, { children: [!!errorMessage?.message && /* @__PURE__ */ jsxs("div", {
+		"aria-live": "polite",
+		className: TileGroup_module_default.tileGroupError,
+		children: [/* @__PURE__ */ jsx("span", {
+			className: TileGroup_module_default.tileGroupErrorIcon,
+			children: /* @__PURE__ */ jsx(Icon, { name: "field-error" })
+		}), errorMessage.message]
+	}), /* @__PURE__ */ jsx("div", {
+		className: cx(TileGroup_module_default.tileGroup, { [TileGroup_module_default.tileGroupHorizontal]: isHorizontal }),
+		children: tiles.map((tile) => {
+			const { value, id, icon, subTitle, label, disabled } = tile;
+			const handleChange = (checked) => {
+				const newSelected = updateSelectedChoices(tile, checked, selected, allowMultiple);
+				if (enableTracking) userEvents.addFieldEvent("Interacted with form field", {
+					actionType: "input",
+					field: trackingFieldName ?? name,
+					returnValue: typeof newSelected === "string" ? newSelected : void 0
+				});
+				onChange(newSelected);
+			};
+			return /* @__PURE__ */ jsx(Tile, {
+				name: finalName,
+				className: TileGroup_module_default.tileContainer,
+				inputType,
+				isHorizontal,
+				checked: choiceIsSelected(tile, selected, allowMultiple),
+				label,
+				id,
+				subTitle,
+				icon,
+				disabled: !disabled && allowMultiple && selected.length >= maxSelected ? !choiceIsSelected(tile, selected, allowMultiple) : disabled,
+				value,
+				onChange: handleChange
+			}, id);
+		})
+	})] });
+}
+function choiceIsSelected({ value }, selected, allowMultiple) {
+	if (!allowMultiple) return value === selected;
+	return selected.includes(value);
+}
+function updateSelectedChoices({ value }, checked, selected, allowMultiple) {
+	if (!allowMultiple) return checked ? value : "";
+	if (Array.isArray(selected)) {
+		if (checked) return allowMultiple ? [...selected, value] : [value];
+		return selected.filter((selectedChoice) => selectedChoice !== value);
+	}
+	return [];
+}
+//#endregion
+//#region src/components/Shared/fields/TaxInformationField/taxIdNumberTypes.ts
+var restrictedEntityTypes = [
+	"soleProprietorship",
+	"trust",
+	"individual"
+];
+var isRestrictedEntityType = (entityType) => Boolean(entityType && restrictedEntityTypes.includes(entityType));
+var isApplicableOnlyForSingleRestrictedType = (option) => {
+	if (!option.applicableOnlyFor || option.applicableOnlyFor.length !== 1) return false;
+	return restrictedEntityTypes.includes(option.applicableOnlyFor[0]);
+};
+var taxIdNumberOptions = {
+	[CountryCodes.Australia]: [{
+		id: "ABN",
+		name: "australianBusinessNumberAbn"
+	}, {
+		id: "TFN",
+		name: "taxInformationNumber__AU_Individual",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Austria]: [{
+		id: "STEUERNUMMER",
+		name: "taxInformationNumber__AT"
+	}],
+	[CountryCodes.Belgium]: [{
+		id: "BUSINESS_NUMMER",
+		name: "businessNumber",
+		applicableOnlyFor: [
+			"soleProprietorship",
+			"privateCompany",
+			"governmentalOrganization",
+			"associationIncorporated",
+			"partnershipIncorporated",
+			"nonProfit",
+			"unincorporatedPartnership",
+			"unlistedPublicCompany"
+		]
+	}, {
+		id: "NUMERO_NATIONAL",
+		name: "taxInformationNumber__BE_Individual",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Brazil]: [{
+		id: "CNPJ",
+		name: "CNPJ"
+	}],
+	[CountryCodes.Bulgaria]: [{
+		id: "EGN",
+		name: "taxInformationNumber__BG",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Canada]: [{
+		id: "BUSINESS_NUMBER",
+		name: "businessNumber"
+	}, {
+		id: "SIN",
+		name: "taxInformationNumber__CA",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.China]: [{
+		id: "RESIDENT_IDENTITY_CARD_NUMBER",
+		name: "taxInformationNumber__CN",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Croatia]: [{
+		id: "OIB",
+		name: "taxInformationNumber__HR"
+	}],
+	[CountryCodes.Cyprus]: [{
+		id: "TIC",
+		name: "taxInformationNumber__CY"
+	}],
+	[CountryCodes.CzechRepublic]: [{
+		id: "RODNE_CISLO",
+		name: "taxInformationNumber__CZ",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Denmark]: [{
+		id: "CPR",
+		name: "taxInformationNumber__DK",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Estonia]: [{
+		id: "ISIKUKOOD",
+		name: "taxInformationNumber__ET_Individual",
+		applicableOnlyFor: ["individual"]
+	}, {
+		id: "REGISTRIKOOD",
+		name: "registrikood",
+		applicableOnlyFor: ["privateCompany"]
+	}],
+	[CountryCodes.Egypt]: [{
+		id: "TIN_EG",
+		name: "taxInformationNumber__EG",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Finland]: [{
+		id: "HENKILOTUNNUS",
+		name: "taxInformationNumber__FI",
+		applicableOnlyFor: ["individual"]
+	}, {
+		id: "YTUNNUS",
+		name: "YTunnus",
+		applicableOnlyFor: ["privateCompany"]
+	}],
+	[CountryCodes.France]: [{
+		id: "SIRET",
+		name: "siret",
+		applicableOnlyFor: ["privateCompany"]
+	}],
+	[CountryCodes.Germany]: [{
+		id: "STEUERNUMMER",
+		name: "taxInformationNumber__DE",
+		applicableOnlyFor: [
+			"soleProprietorship",
+			"privateCompany",
+			"governmentalOrganization",
+			"associationIncorporated",
+			"partnershipIncorporated",
+			"nonProfit",
+			"unincorporatedPartnership",
+			"unlistedPublicCompany"
+		]
+	}, {
+		id: "IDNR",
+		name: "taxInformationNumber__DE_Individual",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Gibraltar]: [{
+		id: "GI_TAXPAYER_REFERENCE_NUMBER",
+		name: "taxpayerReferenceNumber"
+	}],
+	[CountryCodes.Greece]: [{
+		id: "AFM",
+		name: "taxInformationNumber__GR"
+	}],
+	[CountryCodes.Guernsey]: [{
+		id: "GG_REGISTRATION_NUMBER",
+		name: "taxInformationNumber"
+	}, {
+		id: "TIN_GG",
+		name: "nationalInsuranceNumber",
+		applicableOnlyFor: ["soleProprietorship"]
+	}],
+	[CountryCodes.HongKong]: [{
+		id: "BRN",
+		name: "taxInformationNumber__HK"
+	}, {
+		id: "HKID",
+		name: "taxInformationNumber__HK_Individual",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Hungary]: [{
+		id: "ADOAZONOSITO_JEL",
+		name: "taxInformationNumber__HU",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Iceland]: [{
+		id: "KENNITALA",
+		name: "taxInformationNumber__IS",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.India]: [{
+		id: "PAN",
+		name: "taxInformationNumber__IN",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Ireland]: [{
+		id: "TRN",
+		name: "trnNumber",
+		applicableOnlyFor: ["privateCompany", "unincorporatedPartnership"]
+	}, {
+		id: "PERSONAL_PUBLIC_SERVICE_NUMBER",
+		name: "taxInformationNumber__IE_Individual",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.IsleOfMan]: [{
+		id: "IM_TAX_REFERENCE_NUMBER",
+		name: "taxReferenceNumber"
+	}],
+	[CountryCodes.Italy]: [{
+		id: "CODICE_FISCALE",
+		name: "taxInformationNumber__IT"
+	}],
+	[CountryCodes.Israel]: [{
+		id: "IL_MISPAR_ZEHUT",
+		name: "taxInformationNumber__IL",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Japan]: [{
+		id: "CORPORATE_NUMBER",
+		name: "taxInformationNumber"
+	}, {
+		id: "JP_MY_NUMBER",
+		name: "taxInformationNumber__JP_Individual",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Jersey]: [{
+		id: "TIN_JE",
+		name: "taxIdentificationNumber"
+	}, {
+		id: "SSN",
+		name: "socialSecurityNumber",
+		applicableOnlyFor: ["soleProprietorship"]
+	}],
+	[CountryCodes.Latvia]: [{
+		id: "PERSONAS_KODS",
+		name: "taxInformationNumber__LV",
+		applicableOnlyFor: ["individual"]
+	}, {
+		id: "REGISTRACIJAS_NUMURS",
+		name: "lvRegistrationNumber",
+		applicableOnlyFor: ["privateCompany"]
+	}],
+	[CountryCodes.Lithuania]: [{
+		id: "ASMENS_KODAS",
+		name: "taxInformationNumber__LT"
+	}],
+	[CountryCodes.Luxembourg]: [{
+		id: "NATIONAL_IDENTIFICATION_NUMBER",
+		name: "taxInformationNumber__LU_Individual",
+		applicableOnlyFor: ["individual"]
+	}, {
+		id: "NATIONAL_IDENTIFICATION_NUMBER",
+		name: "taxInformationNumber__LU_Org",
+		applicableOnlyFor: ["privateCompany"]
+	}],
+	[CountryCodes.Malta]: [
+		{
+			id: "UNIQUE_TAXPAYER_REFERENCE_NUMBER",
+			name: "taxInformationNumber__MT_Individual_UTRN",
+			applicableOnlyFor: ["individual"]
+		},
+		{
+			id: "IDENTITY_CARD_NUMBER",
+			name: "taxInformationNumber__MT_Individual",
+			applicableOnlyFor: ["individual"]
+		},
+		{
+			id: "INCOME_TAX_REGISTRATION_NUMBER",
+			name: "taxInformationNumber__MT_Org",
+			applicableOnlyFor: ["privateCompany"]
+		}
+	],
+	[CountryCodes.Mexico]: [{
+		id: "RFC",
+		name: "taxInformationNumber__MX",
+		applicableOnlyFor: [
+			"privateCompany",
+			"governmentalOrganization",
+			"associationIncorporated",
+			"partnershipIncorporated",
+			"nonProfit",
+			"unincorporatedPartnership",
+			"unlistedPublicCompany",
+			"listedPublicCompany"
+		]
+	}],
+	[CountryCodes.Netherlands]: [{
+		id: "RSIN",
+		name: "rsinNumber",
+		applicableOnlyFor: [
+			"privateCompany",
+			"governmentalOrganization",
+			"associationIncorporated",
+			"partnershipIncorporated",
+			"nonProfit",
+			"unincorporatedPartnership",
+			"unlistedPublicCompany"
+		]
+	}, {
+		id: "BSN",
+		name: "bsnNumber",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.NewZealand]: [{
+		id: "IRD",
+		name: "irdNumber"
+	}],
+	[CountryCodes.Norway]: [{
+		id: "D_NUMBER",
+		name: "taxInformationNumber__NO",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Poland]: [{
+		id: "PESEL_NUMBER",
+		name: "taxInformationNumber__PL",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Portugal]: [{
+		id: "NUMERO_ID_CIVIL",
+		name: "taxInformationNumber__PT",
+		applicableOnlyFor: ["individual"]
+	}, {
+		id: "NIPC",
+		name: "NIPC",
+		applicableOnlyFor: ["privateCompany"]
+	}],
+	[CountryCodes.PuertoRico]: [{
+		id: "EIN",
+		name: "ein"
+	}],
+	[CountryCodes.Romania]: [{
+		id: "CNP",
+		name: "taxInformationNumber__RO",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Singapore]: [
+		{
+			id: "GST",
+			name: "gst"
+		},
+		{
+			id: "UEN",
+			name: "uen"
+		},
+		{
+			id: "NRIC",
+			name: "taxInformationNumber__SG_Individual",
+			applicableOnlyFor: ["individual"]
+		}
+	],
+	[CountryCodes.Slovakia]: [{
+		id: "RODNE_CISLO",
+		name: "taxInformationNumber__SK_Individual",
+		applicableOnlyFor: ["individual"]
+	}, {
+		id: "NATIONAL_IDENTIFICATION_NUMBER",
+		name: "taxInformationNumber__SK_Org",
+		applicableOnlyFor: ["privateCompany"]
+	}],
+	[CountryCodes.Slovenia]: [{
+		id: "SI_TAX_NUMBER",
+		name: "taxInformationNumber__SI_Individual",
+		applicableOnlyFor: ["individual"]
+	}, {
+		id: "NATIONAL_IDENTIFICATION_NUMBER",
+		name: "taxInformationNumber__SI_Org",
+		applicableOnlyFor: ["privateCompany"]
+	}],
+	[CountryCodes.SouthAfrica]: [{
+		id: "INCOME_TAX_REFERENCE_NUMBER",
+		name: "taxInformationNumber__ZA",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Spain]: [
+		{
+			id: "DNI",
+			name: "dni",
+			applicableOnlyFor: ["individual"]
+		},
+		{
+			id: "NIE",
+			name: "nie",
+			applicableOnlyFor: ["individual"]
+		},
+		{
+			id: "NIF",
+			name: "NIF",
+			applicableOnlyFor: ["privateCompany"]
+		}
+	],
+	[CountryCodes.Sweden]: [{
+		id: "PERSONNUMMER",
+		name: "taxInformationNumber__SE",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.Switzerland]: [{
+		id: "AHV_NUMBER",
+		name: "taxInformationNumber__CH",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.UnitedArabEmirates]: [{
+		id: "EMIRATES_ID",
+		name: "taxInformationNumber__AE",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.UnitedKingdom]: [{
+		id: "UTR",
+		name: "utr"
+	}, {
+		id: "NINO",
+		name: "nationalInsuranceNumber",
+		applicableOnlyFor: ["individual"]
+	}],
+	[CountryCodes.UnitedStates]: [{
+		id: "EIN",
+		name: "ein"
+	}]
+};
+var getTaxIdNumberOptions = (country, companyType) => {
+	const optionsForCountry = taxIdNumberOptions[country];
+	if (!optionsForCountry) return optionsForCountry;
+	if (isRestrictedEntityType(companyType)) return optionsForCountry.filter((option) => option.applicableOnlyFor?.includes(companyType) ?? true);
+	return optionsForCountry.filter((option) => !isApplicableOnlyForSingleRestrictedType(option));
+};
+var getTaxIdNumberSelectorOptions = (country, companyType, exemptedOptionLabel) => {
+	const availableOptions = getTaxIdNumberOptions(country, companyType) ?? [];
+	if (availableOptions.length === 0 || !exemptedOptionLabel) return availableOptions;
+	return [...availableOptions, {
+		id: "exempted",
+		name: exemptedOptionLabel
+	}];
+};
+function getValidCompanyTypesForTaxIdNumberType(country, taxIdNumberType) {
+	if (!taxIdNumberType) return void 0;
+	const taxIdOption = taxIdNumberOptions[country]?.find((option) => option.id === taxIdNumberType);
+	if (!taxIdOption?.applicableOnlyFor) return void 0;
+	const validCompanyTypes = taxIdOption.applicableOnlyFor.filter((type) => type !== "individual" && type !== "trust" && type !== "unincorporatedPartnership");
+	return validCompanyTypes.length > 0 ? validCompanyTypes : void 0;
+}
+//#endregion
+//#region src/utils/japanSupportUtils.ts
+var isJapanLocalizationEnabled = (isSettingEnabled = () => false, country) => {
+	return country === CountryCodes.Japan && isSettingEnabled("enableJapanLocalization");
+};
+//#endregion
+//#region src/utils/textTransformation/toFullWidth.ts
+var applyDelta = (delta) => (char) => String.fromCharCode(char.charCodeAt(0) + delta);
+/**
+* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize#nfkc
+*/
+var standardNormalization = (input) => input.normalize("NFKC");
+/**
+* The order here does matter, since the characters matched by each converter may overlap.
+*/
+var converters = [
+	{
+		name: "latin",
+		match: /[!-~]/g,
+		convert: applyDelta(65248)
+	},
+	{
+		name: "hangul1",
+		match: /[ﾡ-ﾾ]/g,
+		convert: standardNormalization
+	},
+	{
+		name: "hangul2",
+		match: /[ￂ-ￜ]/g,
+		convert: standardNormalization
+	},
+	{
+		name: "katakana",
+		match: /[\uff60-\uff9f]+/g,
+		convert: standardNormalization
+	},
+	{
+		name: "extras",
+		match: /[¢£¬¯¦¥₩\u0020|←↑→↓■°]/g,
+		convert: (char) => {
+			return "￠￡￢￣￤￥￦　｜￩￪￫￬￭￮"["¢£¬¯¦¥₩ |←↑→↓■°".indexOf(char)];
+		}
+	}
+];
+/**
+* Replaces half-width characters with full-width characters.
+* Includes Latin characters, Katakana, Hangul and various symbols.
+*/
+var toFullWidth = (value) => {
+	let input = value;
+	for (const { match, convert } of converters) input = input.replaceAll(match, convert);
+	return input;
+};
+//#endregion
+//#region src/components/Shared/fields/TaxInformationField/fieldConfig.ts
+var taxInformationDefaultFieldMetadata = { label: "taxId" };
+var exemptedFromTaxDefaultFieldMetadata = { label: "iDontHaveATaxId" };
+/**
+* Mapping function to parse TaxInformation schemas to validate the string for TaxInformation.number
+*
+* @param validators - String validators for the TaxInformation.number
+* @param country - Country in the fieldConfig
+*/
+var mapValidators = (validators, country) => validators.map((validator) => ({
+	...validator,
+	validate: (taxInformation) => {
+		const taxInfo = taxInformation?.find((taxId) => country === taxId.country);
+		if (taxInfo?.numberAbsent) return true;
+		return taxInfo?.number ? validator.validate(taxInfo.number) : false;
+	}
+}));
+var taxInformationDefaultFieldConfig = {
+	[CountryCodes.Australia]: ({ taxIdNumberType }) => {
+		switch (taxIdNumberType) {
+			case "TFN": return {
+				label: "taxInformationNumber__AU_Individual",
+				validators: mapValidators([validatePatternOnBlur(/^\d{9}$/)], CountryCodes.Australia),
+				mask: { mask: makeMask(...numericInputs(9)) },
+				guidanceText: {
+					key: "enterNDigitsForExample",
+					values: {
+						numDigits: "9",
+						example: "123456789"
+					}
+				}
+			};
+			default: return {
+				label: "australianBusinessNumberAbn",
+				validators: mapValidators([validatePatternOnBlur(/^\d{11}$/)], CountryCodes.Australia),
+				mask: { mask: makeMask(...numericInputs(2), spacer, ...numericInputs(3), spacer, ...numericInputs(3), spacer, ...numericInputs(3)) },
+				guidanceText: {
+					key: "enterNDigitsForExample",
+					values: {
+						numDigits: "11",
+						example: "51 824 753 556"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Austria]: {
+		label: "taxInformationNumber__AT",
+		validators: mapValidators([validatePatternOnBlur(/^(?=(?:[^0-9]*\d){9}[^0-9]*$)[\d\-/]+$/)], CountryCodes.Austria),
+		mask: { mask: makeMask(...numericInputs(2), {
+			type: "input",
+			allow: /[-/]/,
+			optional: true
+		}, ...numericInputs(3), {
+			type: "input",
+			allow: /[-/]/,
+			optional: true
+		}, ...numericInputs(4)) },
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "9",
+				example: "931736581"
+			}
+		}
+	},
+	[CountryCodes.Belgium]: ({ taxIdNumberType }) => {
+		switch (taxIdNumberType) {
+			case "NUMERO_NATIONAL": return {
+				label: "taxInformationNumber__BE_Individual",
+				validators: mapValidators([validatePatternOnBlur(/^\d{11}$/)], CountryCodes.Belgium),
+				mask: { mask: makeMask(...numericInputs(11)) },
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "99999999999",
+						idType: "Numeró National"
+					}
+				}
+			};
+			default: return {
+				label: "taxInformationNumber__BE",
+				validators: mapValidators([validatePatternOnBlur(/^\d{10}$/)], CountryCodes.Belgium),
+				mask: { mask: makeMask(...numericInputs(10)) },
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "0123321123",
+						idType: "Business nummer"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Bulgaria]: {
+		label: "taxInformationNumber__BG",
+		validators: mapValidators([validatePatternOnBlur(/^\d{10}$/)], CountryCodes.Bulgaria),
+		mask: { mask: makeMask(...numericInputs(10)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "8001010000",
+				idType: "Edinen grazhdanski nomer / ЕГН"
+			}
+		}
+	},
+	[CountryCodes.Canada]: ({ taxIdNumberType }) => {
+		switch (taxIdNumberType) {
+			case "SIN": return {
+				label: "taxInformationNumber__CA",
+				validators: mapValidators([validatePatternOnBlur(/^\d{9}$/)], CountryCodes.Canada),
+				mask: { mask: makeMask(...numericInputs(9)) },
+				guidanceText: {
+					key: "enterNDigitsForExample",
+					values: {
+						numDigits: "9",
+						example: "123456789"
+					}
+				}
+			};
+			default: return {
+				label: "businessNumber",
+				validators: mapValidators([validatePatternOnBlur(/^\d{9}$/)], CountryCodes.Canada),
+				mask: { mask: makeMask(...numericInputs(9)) },
+				guidanceText: {
+					key: "enterNDigitsForExample",
+					values: {
+						numDigits: "9",
+						example: "123456789"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.China]: {
+		label: "taxInformationNumber__CN",
+		validators: mapValidators([validatePatternOnBlur(/^\d{17}[0-9X]$/)], CountryCodes.China),
+		mask: {
+			mask: makeMask(...numericInputs(17), ...customInputs(1, /[0-9X]/)),
+			transformOnType: uppercase
+		},
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "11010519491231002X",
+				idType: "Resident Identity Card Number (居民身份证号码)"
+			}
+		}
+	},
+	[CountryCodes.Croatia]: {
+		label: "taxInformationNumber__HR",
+		validators: mapValidators([validatePatternOnBlur(/^\d{11}$/)], CountryCodes.Croatia),
+		mask: { mask: makeMask(...numericInputs(11)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "94577403194",
+				idType: "OIB"
+			}
+		}
+	},
+	[CountryCodes.Cyprus]: {
+		label: "taxInformationNumber__CY",
+		validators: mapValidators([validatePatternOnBlur(/^\d{8,9}[A-Z]$/)], CountryCodes.Cyprus),
+		mask: {
+			mask: makeMask(...numericInputs(8), ...numericInputs(1, true), ...alphaInputs(1)),
+			transformOnType: uppercase
+		},
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "00123123T",
+				idType: "TIC"
+			}
+		}
+	},
+	[CountryCodes.CzechRepublic]: {
+		label: "taxInformationNumber__CZ",
+		validators: mapValidators([validatePatternOnBlur(/^\d{9,10}$/)], CountryCodes.CzechRepublic),
+		mask: { mask: makeMask(...numericInputs(6), ...nonInputs("/"), ...numericInputs(3), ...numericInputs(1, true)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "850523/1234",
+				idType: "Rodné číslo (RČ)"
+			}
+		}
+	},
+	[CountryCodes.Denmark]: {
+		label: "taxInformationNumber__DK",
+		validators: mapValidators([validatePatternOnBlur(/^\d{10}$/)], CountryCodes.Denmark),
+		mask: { mask: makeMask(...numericInputs(6), ...nonInputs("-"), ...numericInputs(4)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "120585-1234",
+				idType: "CPR-nummer (Personnummer)"
+			}
+		}
+	},
+	[CountryCodes.Egypt]: {
+		label: "taxInformationNumber__EG",
+		validators: mapValidators([validatePatternOnBlur(/^\d{9}$/)], CountryCodes.Egypt),
+		mask: { mask: makeMask(...numericInputs(9)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "123456789",
+				idType: "Tax Registration Number (رقم التسجيل الضريبي)"
+			}
+		}
+	},
+	[CountryCodes.Estonia]: {
+		label: "taxInformationNumber__ET_Individual",
+		validators: mapValidators([validatePatternOnBlur(/^\d{11}$/)], CountryCodes.Estonia),
+		mask: { mask: makeMask(...numericInputs(11)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "32708101201",
+				idType: "Isikukood"
+			}
+		}
+	},
+	[CountryCodes.Finland]: {
+		label: "taxInformationNumber__FI",
+		validators: mapValidators([validatePatternOnBlur(/^\d{6}[+\-A]\d{3}[0-9A-Y]$/)], CountryCodes.Finland),
+		mask: {
+			mask: makeMask(...numericInputs(6), {
+				type: "input",
+				allow: /[+\-A]/
+			}, ...numericInputs(3), {
+				type: "input",
+				allow: /[0-9A-Y]/
+			}),
+			transformOnType: uppercase
+		},
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "131052-308T",
+				idType: "Henkilötunnus"
+			}
+		}
+	},
+	[CountryCodes.France]: {
+		label: "taxInformationNumber__FR",
+		validators: mapValidators([validatePatternOnBlur(/^\s*(\d\s*){13}$/)], CountryCodes.France),
+		mask: { mask: makeMask(...numericInputs(2), spacer, ...numericInputs(2), spacer, ...numericInputs(3), spacer, ...numericInputs(3), spacer, ...numericInputs(3)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "30 23 217 600 053",
+				idType: "Numéro SPI"
+			}
+		}
+	},
+	[CountryCodes.Germany]: ({ taxIdNumberType }) => {
+		switch (taxIdNumberType) {
+			case "IDNR": return {
+				label: "taxInformationNumber__DE_Individual",
+				validators: mapValidators([validatePatternOnBlur(/^\d{11}$/)], CountryCodes.Germany),
+				mask: { mask: makeMask(...numericInputs(11)) },
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "26954371827",
+						idType: "IdNr"
+					}
+				}
+			};
+			default: return {
+				label: "taxInformationNumber__DE",
+				validators: mapValidators([validatePatternOnBlur(/^\d{10}$|^\d{11}$|^\d{13}$/)], CountryCodes.Germany),
+				mask: { mask: makeMask(...numericInputs(10), ...numericInputs(3, true)) },
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "14310260208",
+						idType: "Steuernummer"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Gibraltar]: {
+		label: "taxpayerReferenceNumber",
+		validators: mapValidators([validatePatternOnBlur(/^\d{1,7}$/)], CountryCodes.Gibraltar),
+		mask: { mask: makeMask(...numericInputs(1), ...numericInputs(6, true)) },
+		guidanceText: {
+			key: "enterAMaximumOfNDigitsForExample",
+			values: {
+				maxDigits: "7",
+				example: "123456"
+			}
+		}
+	},
+	[CountryCodes.Greece]: {
+		label: "taxInformationNumber__GR",
+		validators: mapValidators([validatePatternOnBlur(/^\d{9}$/)], CountryCodes.Greece),
+		mask: { mask: makeMask(...numericInputs(9)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "244709851",
+				idType: "AFM"
+			}
+		}
+	},
+	[CountryCodes.Guernsey]: ({ taxIdNumberType }) => {
+		switch (taxIdNumberType) {
+			case "TIN_GG": return {
+				label: "nationalInsuranceNumber",
+				validators: mapValidators([validatePatternOnBlur(/^GY\d{6}[A-D]$/)], CountryCodes.Guernsey),
+				mask: {
+					mask: makeMask(...nonInputs("GY", { includeInValue: true }), spacer, ...numericInputs(2), spacer, ...numericInputs(2), spacer, ...numericInputs(2), spacer, {
+						type: "input",
+						allow: /[A-D]/
+					}),
+					transformOnType: uppercase
+				},
+				guidanceText: {
+					key: "enterTheRemainingNCharactersForExample",
+					values: {
+						numChars: "7",
+						example: "GY 12 34 56 A"
+					}
+				}
+			};
+			default: return {
+				label: "taxInformationNumber",
+				mask: businessRegistrationNumberMasks[CountryCodes.Guernsey].default,
+				validators: mapValidators([validatePatternOnBlur(businessRegistrationNumberPatterns[CountryCodes.Guernsey].default)], CountryCodes.Guernsey),
+				guidanceText: {
+					key: "enterAMaximumOfNDigitsForExample",
+					values: {
+						maxDigits: "9",
+						example: "123456"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.HongKong]: ({ taxIdNumberType }) => {
+		switch (taxIdNumberType) {
+			case "HKID": return {
+				label: "taxInformationNumber__HK_Individual",
+				validators: mapValidators([validatePatternOnBlur(/^[A-Z]{1,2}[0-9]{6}[A-Z0-9]$/)], CountryCodes.HongKong),
+				mask: {
+					mask: makeMask(...alphaInputs(1), ...alphaInputs(1, true), ...numericInputs(6), ...nonInputs("(", { displayEagerly: false }), ...alphanumericInputs(1), ...nonInputs(")", { displayEagerly: true })),
+					transformOnType: uppercase
+				},
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "A123456(7)",
+						idType: "Hong Kong Identity Card Number (HKID)"
+					}
+				}
+			};
+			default: return {
+				label: "taxInformationNumber__HK",
+				validators: mapValidators([validatePatternOnBlur(/^\d{8}$/)], CountryCodes.HongKong),
+				mask: { mask: makeMask(...numericInputs(8)) },
+				guidanceText: {
+					key: "enterNDigitsForExample",
+					values: {
+						numDigits: "8",
+						example: "70569713"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Hungary]: {
+		label: "taxInformationNumber__HU",
+		validators: mapValidators([validatePatternOnBlur(/^\d{10}$/)], CountryCodes.Hungary),
+		mask: { mask: makeMask(...numericInputs(10)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "8123456789",
+				idType: "Adóazonosító jel"
+			}
+		}
+	},
+	[CountryCodes.Iceland]: {
+		label: "taxInformationNumber__IS",
+		validators: mapValidators([validatePatternOnBlur(/^\d{10}$/)], CountryCodes.Iceland),
+		mask: { mask: makeMask(...numericInputs(6), ...nonInputs("-"), ...numericInputs(4)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "120585-1234",
+				idType: "Kennitala"
+			}
+		}
+	},
+	[CountryCodes.Ireland]: ({ taxIdNumberType }) => {
+		switch (taxIdNumberType) {
+			case "PERSONAL_PUBLIC_SERVICE_NUMBER": return {
+				label: "taxInformationNumber__IE_Individual",
+				validators: mapValidators([validatePatternOnBlur(/^\d{7}[A-Z]$|^\d{7}[A-Z]{2}$/)], CountryCodes.Ireland),
+				mask: {
+					mask: makeMask(...numericInputs(7), ...alphaInputs(1), ...alphaInputs(1, true)),
+					transformOnType: uppercase
+				},
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "1234567T",
+						idType: "Personal Public Service Number"
+					}
+				}
+			};
+			default: return {
+				label: "trnNumber",
+				validators: mapValidators([validatePatternOnBlur(/^\d{7}[A-Z]$|^\d{7}[A-Z]{2}$/)], CountryCodes.Ireland),
+				mask: {
+					mask: makeMask(...numericInputs(7), ...alphaInputs(1), ...alphaInputs(1, true)),
+					transformOnType: uppercase
+				},
+				guidanceText: {
+					key: "enterXDigitsThenXToYLettersForExample",
+					values: {
+						numDigits: "7",
+						minLetters: "1",
+						maxLetters: "2",
+						example: "1497955KA"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.India]: {
+		label: "taxInformationNumber__IN",
+		validators: mapValidators([validatePatternOnBlur(/^[A-Z]{5}\d{4}[A-Z]$/)], CountryCodes.India),
+		mask: {
+			mask: makeMask(...alphaInputs(5), ...numericInputs(4), ...alphaInputs(1)),
+			transformOnType: uppercase
+		},
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "ABCDE1234F",
+				idType: "Permanent Account Number (PAN)"
+			}
+		}
+	},
+	[CountryCodes.Israel]: {
+		label: "taxInformationNumber__IL",
+		validators: mapValidators([validatePatternOnBlur(/^\d{9}$/)], CountryCodes.Israel),
+		mask: { mask: makeMask(...numericInputs(9)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "123456782",
+				idType: "Identity Number (Mispar Zehut / מספר זהות)"
+			}
+		}
+	},
+	[CountryCodes.Italy]: {
+		label: "codiceFiscale",
+		mask: { mask: makeMask(...numericInputs(11)) },
+		validators: mapValidators([validatePatternOnBlur(/^\d{11}$/)], CountryCodes.Italy),
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "11",
+				example: "12345678901"
+			}
+		}
+	},
+	[CountryCodes.IsleOfMan]: {
+		label: "taxReferenceNumber",
+		validators: mapValidators([validatePatternOnBlur(/^[HCX]\d{8}$/)], CountryCodes.IsleOfMan),
+		mask: {
+			mask: makeMask({
+				type: "input",
+				allow: /[HCX]/
+			}, ...numericInputs(6), ...nonInputs(" - "), ...numericInputs(2)),
+			transformOnType: uppercase
+		},
+		guidanceText: {
+			key: "enterNCharactersForExample",
+			values: {
+				numChars: "9",
+				example: "C155673-79"
+			}
+		}
+	},
+	[CountryCodes.Japan]: ({ taxIdNumberType }) => {
+		switch (taxIdNumberType) {
+			case "CORPORATE_NUMBER":
+			default: return {
+				label: "taxInformationNumber__JP",
+				validators: mapValidators([validatePatternOnBlur(/^\d{13}$/)], CountryCodes.Japan),
+				guidanceText: {
+					key: "enterNDigitsForExample",
+					values: {
+						numDigits: "13",
+						example: "2169151989941"
+					}
+				}
+			};
+			case "JP_MY_NUMBER": return {
+				label: "taxInformationNumber__JP_Individual",
+				validators: mapValidators([validatePatternOnBlur(/^\d{12}$/)], CountryCodes.Japan),
+				mask: { mask: makeMask(...numericInputs(12)) },
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "123456789012",
+						idType: "Individual Number / My Number (マイナンバー)"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Jersey]: ({ taxIdNumberType, companyType }) => {
+		switch (taxIdNumberType) {
+			case "SSN": return {
+				label: "socialSecurityNumber",
+				validators: mapValidators([validatePatternOnBlur(/^[A-Z]{2}\d{6}[A-Z]$/)], CountryCodes.Jersey),
+				mask: {
+					mask: makeMask(...alphaInputs(2), ...numericInputs(6), ...alphaInputs(1)),
+					transformOnType: uppercase
+				},
+				guidanceText: {
+					key: "enterNCharactersForExample",
+					values: {
+						numChars: "9",
+						example: "JY000000A"
+					}
+				}
+			};
+			default: switch (companyType) {
+				case "soleProprietorship": return {
+					label: "taxIdentificationNumber",
+					validators: mapValidators([validatePatternOnBlur(/^\d{10}$/)], CountryCodes.Jersey),
+					mask: { mask: makeMask(...numericInputs(3), ...nonInputs(" - "), ...numericInputs(3), ...nonInputs(" - "), ...numericInputs(4)) },
+					guidanceText: {
+						key: "enterNDigitsForExample",
+						values: {
+							numDigits: "10",
+							example: "100-100-1000"
+						}
+					}
+				};
+				default: return {
+					label: "taxIdentificationNumber",
+					validators: mapValidators([validatePatternOnBlur(/^[A-Z]{2}\d{5}$/)], CountryCodes.Jersey),
+					mask: {
+						mask: makeMask(...alphaInputs(2), ...numericInputs(5)),
+						transformOnType: uppercase
+					},
+					guidanceText: {
+						key: "enterNCharactersForExample",
+						values: {
+							numChars: "7",
+							example: "CC17261"
+						}
+					}
+				};
+			}
+		}
+	},
+	[CountryCodes.Latvia]: {
+		label: "taxInformationNumber__LV",
+		validators: mapValidators([validatePatternOnBlur(/^\d{11}$/)], CountryCodes.Latvia),
+		mask: { mask: makeMask(...numericInputs(11)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "32532963606",
+				idType: "Personas kods"
+			}
+		}
+	},
+	[CountryCodes.Lithuania]: {
+		label: "taxInformationNumber__LT",
+		validators: mapValidators([validatePatternOnBlur(/^\d{11}$/)], CountryCodes.Lithuania),
+		mask: { mask: makeMask(...numericInputs(11)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "33309240064",
+				idType: "Asmens kodas"
+			}
+		}
+	},
+	[CountryCodes.Luxembourg]: ({ companyType }) => {
+		switch (companyType) {
+			case "individual": return {
+				label: "taxInformationNumber__LU_Individual",
+				validators: mapValidators([validatePatternOnBlur(/^\d{13}$/)], CountryCodes.Luxembourg),
+				mask: { mask: makeMask(...numericInputs(13)) },
+				guidanceText: {
+					key: "enterNCharactersForExample",
+					values: {
+						numChars: "13",
+						example: "1893120105732"
+					}
+				}
+			};
+			default: return {
+				label: "taxInformationNumber__LU_Org",
+				validators: mapValidators([validatePatternOnBlur(/^\d{11}$/)], CountryCodes.Luxembourg),
+				mask: { mask: makeMask(...numericInputs(11)) },
+				guidanceText: {
+					key: "enterNCharactersForExample",
+					values: {
+						numChars: "11",
+						example: "19991201001"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Malta]: ({ taxIdNumberType }) => {
+		switch (taxIdNumberType) {
+			case "IDENTITY_CARD_NUMBER": return {
+				label: "taxInformationNumber__MT_Individual",
+				validators: mapValidators([validatePatternOnBlur(/^\d{7}[A-Z]$|^\d{9}$/)], CountryCodes.Malta),
+				mask: {
+					mask: makeMask(...numericInputs(7), ...alphanumericInputs(2)),
+					transformOnType: uppercase
+				},
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "1234567A",
+						idType: "Identity card number"
+					}
+				}
+			};
+			case "UNIQUE_TAXPAYER_REFERENCE_NUMBER": return {
+				label: "taxInformationNumber__MT_Individual_UTRN",
+				validators: mapValidators([validatePatternOnBlur(/^\d{9}$/)], CountryCodes.Malta),
+				mask: { mask: makeMask(...numericInputs(9)) },
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "999999999",
+						idType: "Unique taxpayer reference number"
+					}
+				}
+			};
+			default: return {
+				label: "taxInformationNumber__MT_Org",
+				validators: mapValidators([validatePatternOnBlur(/^\d{9}$/)], CountryCodes.Malta),
+				mask: { mask: makeMask(...numericInputs(9)) },
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "123456789",
+						idType: "Income Tax Registration Number"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Mexico]: ({ companyType }) => {
+		switch (companyType) {
+			case "soleProprietorship": return {
+				label: "taxInformationNumber__MX",
+				validators: mapValidators([validatePatternOnBlur(/^[a-zA-Z]{3,4}\d{6}[A-Za-z0-9]{3}$/)], CountryCodes.Mexico),
+				mask: { mask: makeMask(...alphanumericInputs(12), ...alphanumericInputs(1, true)) },
+				guidanceText: {
+					key: "enterXToYCharactersForExample",
+					values: {
+						minDigis: "12",
+						maxDigits: "13",
+						example: "LFM200817DGA, GOMJ850215AB3"
+					}
+				}
+			};
+			default: return {
+				label: "taxInformationNumber__MX",
+				validators: mapValidators([validatePatternOnBlur(/^[a-zA-Z]{3}\d{6}[A-Za-z0-9]{3}$/)], CountryCodes.Mexico),
+				mask: { mask: makeMask(...alphaInputs(3), ...numericInputs(6), ...alphanumericInputs(3)) },
+				guidanceText: {
+					key: "enterNCharactersForExample",
+					values: {
+						numDigits: "12",
+						example: "LFM200817DGA, MEL9507278ZA"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Netherlands]: ({ companyType }) => {
+		switch (companyType) {
+			case "individual": return {
+				label: "bsnNumber",
+				validators: mapValidators([validatePatternOnBlur(/^\d{9}$/)], CountryCodes.Netherlands),
+				mask: { mask: makeMask(...numericInputs(9)) },
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "999999999",
+						idType: "BSN"
+					}
+				}
+			};
+			default: return {
+				label: "rsinNumber",
+				validators: mapValidators([validatePatternOnBlur(/^\d{9}$/)], CountryCodes.Netherlands),
+				mask: { mask: makeMask(...numericInputs(9)) },
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "811786523",
+						idType: "RSIN"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.NewZealand]: {
+		label: "irdNumber",
+		validators: mapValidators([validatePatternOnBlur(/^\d{8,9}$/)], CountryCodes.NewZealand),
+		mask: { mask: makeMask(...numericInputs(8), ...numericInputs(1, true)) },
+		guidanceText: {
+			key: "enterXToYDigitsForExample",
+			values: {
+				minDigits: "8",
+				maxDigits: "9",
+				example: "12345678"
+			}
+		}
+	},
+	[CountryCodes.Norway]: {
+		label: "taxInformationNumber__NO",
+		validators: mapValidators([validatePatternOnBlur(/^\d{11}$/)], CountryCodes.Norway),
+		mask: { mask: makeMask(...numericInputs(11)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "12058512345",
+				idType: "Fødselsnummer (or D-nummer)"
+			}
+		}
+	},
+	[CountryCodes.Poland]: {
+		label: "taxInformationNumber__PL",
+		validators: mapValidators([validatePatternOnBlur(/^\d{11}$/)], CountryCodes.Poland),
+		mask: { mask: makeMask(...numericInputs(11)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "85052312345",
+				idType: "PESEL"
+			}
+		}
+	},
+	[CountryCodes.Portugal]: {
+		label: "taxInformationNumber__PT",
+		validators: mapValidators([validatePatternOnBlur(/^\d{9}$/)], CountryCodes.Portugal),
+		mask: { mask: makeMask(...numericInputs(9)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "299999998",
+				idType: "Numéro ID Civil"
+			}
+		}
+	},
+	[CountryCodes.PuertoRico]: {
+		label: "taxInformationNumber__US",
+		validators: mapValidators([validatePatternOnBlur(/^\d{9}$/)], CountryCodes.PuertoRico),
+		mask: { mask: makeMask(...numericInputs(2), ...nonInputs(" - "), ...numericInputs(7)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidEINWithFormat",
+			values: {
+				format: "XX-XXXXXXX",
+				example: "98-7654321"
+			}
+		}
+	},
+	[CountryCodes.Romania]: {
+		label: "taxInformationNumber__RO",
+		validators: mapValidators([validatePatternOnBlur(/^\d{13}$/)], CountryCodes.Romania),
+		mask: { mask: makeMask(...numericInputs(13)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "1234567890123",
+				idType: "Cod Numeric Personal (CNP)"
+			}
+		}
+	},
+	[CountryCodes.Singapore]: ({ taxIdNumberType }) => {
+		switch (taxIdNumberType) {
+			case "NRIC": return {
+				label: "taxInformationNumber__SG_Individual",
+				validators: mapValidators([validatePatternOnBlur(/^[A-Z]\d{7}[A-Z]$/)], CountryCodes.Singapore),
+				mask: {
+					mask: makeMask(...alphaInputs(1), ...numericInputs(7), ...alphaInputs(1)),
+					transformOnType: uppercase
+				},
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "S1234567A",
+						idType: "Tax Reference Number (NRIC / FIN)"
+					}
+				}
+			};
+			default: return {
+				label: "gst",
+				validators: mapValidators([validatePatternOnBlur(/^[A-Z0-9]{9,10}$/)], CountryCodes.Singapore),
+				mask: {
+					mask: makeMask(...alphanumericInputs(2), ...nonInputs(" - "), ...alphanumericInputs(7), ...nonInputs(" - "), ...alphanumericInputs(1)),
+					transformOnType: uppercase
+				},
+				guidanceText: {
+					key: "enterNCharactersForExample",
+					values: {
+						numChars: "10",
+						example: "M212345678"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Slovakia]: ({ companyType }) => {
+		switch (companyType) {
+			case "individual": return {
+				label: "taxInformationNumber__SK_Individual",
+				validators: mapValidators([validatePatternOnBlur(/^\d{9}$|^\d{10}$|^\d{11}$|^\d{6}\/\d{3}$|^\d{6}\/\d{4}$/)], CountryCodes.Slovakia),
+				mask: { mask: makeMask(...numericInputs(6), {
+					type: "input",
+					allow: /\//,
+					optional: true
+				}, ...numericInputs(4), ...numericInputs(1, true)) },
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "7711167420",
+						idType: "Rodne Cislo"
+					}
+				}
+			};
+			default: return {
+				label: "taxInformationNumber__SK_Org",
+				validators: mapValidators([validatePatternOnBlur(/^\d{10}$/)], CountryCodes.Slovakia),
+				mask: { mask: makeMask(...numericInputs(10)) },
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "2020123456",
+						idType: "Daňové identifikačné číslo (DIČ)"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Slovenia]: ({ companyType }) => {
+		switch (companyType) {
+			case "individual": return {
+				label: "taxInformationNumber__SI_Individual",
+				validators: mapValidators([validatePatternOnBlur(/^\d{8}$/)], CountryCodes.Slovenia),
+				mask: { mask: makeMask(...numericInputs(8)) },
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "15012557",
+						idType: "SI tax number"
+					}
+				}
+			};
+			default: return {
+				label: "taxInformationNumber__SI_Org",
+				validators: mapValidators([validatePatternOnBlur(/^\d{8}$/)], CountryCodes.Slovenia),
+				mask: { mask: makeMask(...numericInputs(8)) },
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "12345678",
+						idType: "Davčna številka"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.SouthAfrica]: {
+		label: "taxInformationNumber__ZA",
+		validators: mapValidators([validatePatternOnBlur(/^\d{10}$/)], CountryCodes.SouthAfrica),
+		mask: { mask: makeMask(...numericInputs(10)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "1234567890",
+				idType: "Income Tax Reference Number"
+			}
+		}
+	},
+	[CountryCodes.Sweden]: {
+		label: "taxInformationNumber__SE",
+		validators: mapValidators([validatePatternOnBlur(/^\d{10,12}$/)], CountryCodes.Sweden),
+		mask: { mask: makeMask(...numericInputs(6), ...numericInputs(2, true), ...nonInputs("-"), ...numericInputs(4)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "19850523-1234",
+				idType: "Personnummer"
+			}
+		}
+	},
+	[CountryCodes.Switzerland]: {
+		label: "taxInformationNumber__CH",
+		validators: mapValidators([validatePatternOnBlur(/^\d{13}$/)], CountryCodes.Switzerland),
+		mask: { mask: makeMask(...numericInputs(3), ...nonInputs("."), ...numericInputs(4), ...nonInputs("."), ...numericInputs(4), ...nonInputs("."), ...numericInputs(2)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "756.1234.5678.90",
+				idType: "AHV-Nummer / Numéro AVS / Numero AVS"
+			}
+		}
+	},
+	[CountryCodes.UnitedArabEmirates]: {
+		label: "taxInformationNumber__AE",
+		validators: mapValidators([validatePatternOnBlur(/^\d{15}$/)], CountryCodes.UnitedArabEmirates),
+		mask: { mask: makeMask(...numericInputs(3), ...nonInputs("-"), ...numericInputs(4), ...nonInputs("-"), ...numericInputs(7), ...nonInputs("-"), ...numericInputs(1)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidIdNumberWithExample",
+			values: {
+				example: "784-1985-1234567-1",
+				idType: "Emirates ID Number (رقم الهوية)"
+			}
+		}
+	},
+	[CountryCodes.UnitedKingdom]: ({ taxIdNumberType, companyType }) => {
+		switch (companyType) {
+			case "individual": switch (taxIdNumberType) {
+				case "NINO": return {
+					label: "nationalInsuranceNumber",
+					validators: mapValidators([validatePatternOnBlur(/^[A-Z]{2}\d{6}[A-D]$/)], CountryCodes.UnitedKingdom),
+					guidanceText: {
+						key: "validationPleaseEnterAValidIdNumberWithExample",
+						values: {
+							example: "AA123456C",
+							idType: "NINO"
+						}
+					}
+				};
+				default: return {
+					label: "utr",
+					validators: mapValidators([validatePatternOnBlur(/^\d{10}$/)], CountryCodes.UnitedKingdom),
+					mask: { mask: makeMask(...numericInputs(10)) },
+					guidanceText: {
+						key: "validationPleaseEnterAValidIdNumberWithExample",
+						values: {
+							example: "7172510005",
+							idType: "UTR"
+						}
+					}
+				};
+			}
+			default: return {
+				label: "utr",
+				validators: mapValidators([validatePatternOnBlur(/^\d{10}$/)], CountryCodes.UnitedKingdom),
+				mask: { mask: makeMask(...numericInputs(10)) },
+				guidanceText: {
+					key: "validationPleaseEnterAValidIdNumberWithExample",
+					values: {
+						example: "7172510005",
+						idType: "UTR"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.UnitedStates]: {
+		label: "taxInformationNumber__US",
+		validators: mapValidators([validateNotEmptyOnBlur, validatePatternOnBlur(/^\d{9}$/)], CountryCodes.UnitedStates),
+		mask: { mask: makeMask(...numericInputs(2), ...nonInputs(" - "), ...numericInputs(7)) },
+		guidanceText: {
+			key: "validationPleaseEnterAValidEINWithFormat",
+			values: {
+				format: "XX-XXXXXXX",
+				example: "98-7654321"
+			}
+		}
+	},
+	/**
+	* NOT YET SUPPORTED
+	* These are brought over from the old pattern files. We have no idea if they are accurate or not.
+	* See https://en.wikipedia.org/wiki/VAT_identification_number
+	*/
+	[CountryCodes.Philippines]: { validators: mapValidators([validatePatternOnBlur(/^\d{12}$/)], CountryCodes.Philippines) }
+};
+var exemptedFromTaxDefaultFieldConfig = { [CountryCodes.Australia]: { label: "thisBusinessIsntRequiredToHaveAnABN" } };
+var getTaxInformationPlaceholderText = ({ country, companyType, taxIdNumberType }) => {
+	switch (country) {
+		case CountryCodes.Austria: return "931736581";
+		case CountryCodes.Belgium: switch (companyType) {
+			case "individual": return "99999999999";
+			default: return "0123321123";
+		}
+		case CountryCodes.Croatia: return "94577403194";
+		case CountryCodes.Cyprus: return "00123123T";
+		case CountryCodes.Estonia: return "32708101201";
+		case CountryCodes.Ethiopia: return "32708101201";
+		case CountryCodes.Finland: return "131052-308T";
+		case CountryCodes.France: return "30 23 217 600 053";
+		case CountryCodes.Germany: switch (companyType) {
+			case "individual": return "26954371827";
+			default: return "14310260208";
+		}
+		case CountryCodes.Gibraltar: return "123456";
+		case CountryCodes.Greece: return "244709851";
+		case CountryCodes.Ireland: switch (companyType) {
+			case "individual": return "1234567T";
+			default: return "1497955KA";
+		}
+		case CountryCodes.Italy: return "12345678901";
+		case CountryCodes.IsleOfMan: return "C155673-79";
+		case CountryCodes.Latvia: return "32532963606";
+		case CountryCodes.Lithuania: return "33309240064";
+		case CountryCodes.Luxembourg: switch (companyType) {
+			case "individual": return "1893120105732";
+			default: return "19991201001";
+		}
+		case CountryCodes.Malta: switch (companyType) {
+			case "individual": switch (taxIdNumberType) {
+				case "UNIQUE_TAXPAYER_REFERENCE_NUMBER": return "999999999";
+				default: return "1234567A";
+			}
+			default: return "999999999";
+		}
+		case CountryCodes.Mexico: switch (companyType) {
+			case "soleProprietorship": return "ABCD123456AB9";
+			default: return "ABC123456AB9";
+		}
+		case CountryCodes.Netherlands: switch (companyType) {
+			case "individual": return "999999999";
+			default: return "811786523";
+		}
+		case CountryCodes.Portugal: return "299999998";
+		case CountryCodes.Slovakia: switch (companyType) {
+			case "individual": return "7711167420";
+			default: return "2020123456";
+		}
+		case CountryCodes.Slovenia: switch (companyType) {
+			case "individual": return "15012557";
+			default: return "12345678";
+		}
+		case CountryCodes.UnitedKingdom: return "7172510005";
+		case CountryCodes.Spain: return "99999999L";
+		case CountryCodes.PuertoRico:
+		case CountryCodes.UnitedStates: return "11-0000000";
+	}
+};
+//#endregion
+//#region src/components/Shared/fields/TaxInformationField/TaxIdNumberTypeSelector/findExistingTaxInformation.ts
+/**
+* Finds tax information for a specific country from an array of tax information objects.
+*
+* @param taxInformation - Array of tax information objects to search through
+* @param country - Country code to find tax information for
+* @returns The first matching tax information object or undefined if none found
+*/
+function findExistingTaxInformation(taxInformation, country) {
+	return taxInformation?.find((taxId) => taxId.country === country);
+}
+//#endregion
+//#region src/components/Shared/fields/TaxInformationField/TaxIdNumberTypeSelector/TaxIdNumberTypeSelector.tsx
+function TaxIdNumberTypeSelector({ country, companyType, selected, setSelected, exemptedOptionLabel, isUsSoleProp, errorMessage }) {
+	const { t } = useTranslation("common");
+	const handleSelect = useCallback((selectedStr) => {
+		const newSelected = selectedStr;
+		if (newSelected === "exempted") {
+			if (exemptedOptionLabel) setSelected(newSelected);
+			return;
+		}
+		setSelected(newSelected);
+	}, [exemptedOptionLabel, setSelected]);
+	const options = useMemo(() => getTaxIdNumberSelectorOptions(country, companyType, exemptedOptionLabel), [
+		country,
+		companyType,
+		exemptedOptionLabel
+	]);
+	useEffect(() => {
+		if (!isUsSoleProp && !selected && options.length > 0) handleSelect(options[0].id);
+	}, [
+		options,
+		selected,
+		handleSelect,
+		isUsSoleProp
+	]);
+	if (options.length <= 1) return null;
+	return /* @__PURE__ */ jsx(Field, {
+		el: "fieldset",
+		name: "taxIdNumberType",
+		label: t(($) => $["whichTaxpayerIdentificationNumberDoYouUse"]),
+		errorMessage,
+		children: (childProps) => /* @__PURE__ */ jsx(RadioGroup, {
+			...childProps,
+			name: "taxIdNumberType",
+			items: options,
+			value: selected,
+			onChange: handleSelect
+		})
+	});
+}
+//#endregion
+//#region src/components/Shared/fields/TaxInformationField/utils.ts
+/**
+* Immutably upserts a TaxInformation entry for a given country within the tax information array.
+* - If the array doesn't exist, creates a new one with the entry.
+* - If the country already has an entry, replaces it in-place.
+* - If the country has no entry yet, appends the new entry.
+*/
+function upsertTaxInfoForCountry(taxInformation, country, newEntry) {
+	if (!taxInformation) return [newEntry];
+	return (taxInformation.some((t) => t.country === country) ? taxInformation : [...taxInformation, newEntry]).map((t) => t.country === country ? newEntry : t);
+}
+/**
+* Removes all TaxInformation entries for the given country from the array.
+*/
+function removeTaxInfoForCountry(taxInformation, country) {
+	return taxInformation?.filter((t) => t.country !== country);
+}
+//#endregion
+//#region src/components/Shared/fields/TaxInformationField/TaxInformationField.tsx
+var TAX_INFORMATION_FIELD = [
+	"taxInformation",
+	"exemptedFromTax",
+	"isUen"
+];
+/**
+* Renders a dynamic form field for tax identification information, adapting its display
+* and behavior based on country and company type. It supports various tax ID input
+* scenarios, including two specialized handling for US Sole Proprietorships (where SSN option acts as exemption selection)
+* and Singapore Companies (where registration number (UEN) can be used for tax ID).
+*/
+function TaxInformationField({ data, valid, errors, placeholder, readonly, optional, shouldValidate, handleChangeFor, country, canExempt, registrationNumber, entityType, defaultData }) {
+	const { isFeatureEnabled } = useToggleContext();
+	const { t } = useTranslation("common");
+	const { accountHolder } = useAccountHolder();
+	const currentCountryTaxInformation = useMemo(() => data?.taxInformation?.find((taxInfo) => taxInfo.country === country) ?? (!data.exemptedFromTax ? defaultData?.find((taxInfo) => taxInfo.country === country) : void 0), [
+		data?.taxInformation,
+		data.exemptedFromTax,
+		defaultData,
+		country
+	]);
+	const isUsSoleProp = country === "US" && entityType === "soleProprietorship";
+	const options = getTaxIdNumberOptions(country, entityType);
+	const showTaxIdExemptedOptions = canExempt && (options?.length ?? 0) > 1 || isUsSoleProp;
+	const canSaveAbsentState = isFeatureEnabled("EnableRegistrationAndTaxAbsentStatesV4") && COUNTRIES_WITH_POSSIBLE_TRUSTEE_TAXID_ABSENT_V4.includes(country) && accountHolder === "aTrust";
+	const { label: resolvedExemptionLabel } = resolveFieldMetadata(exemptedFromTaxDefaultFieldConfig[country], {}, exemptedFromTaxDefaultFieldMetadata);
+	const exemptedFromTaxLabel = t(($) => $[resolvedExemptionLabel ?? "iDontHaveATaxId"]);
+	const exemptionLabel = isUsSoleProp ? t(($) => $["socialSecurityNumber"]) : exemptedFromTaxLabel;
+	const selectorOptions = getTaxIdNumberSelectorOptions(country, entityType, showTaxIdExemptedOptions ? exemptionLabel : void 0);
+	const shouldRenderInput = isUsSoleProp ? currentCountryTaxInformation?.type === "EIN" : !data.isUen;
+	const taxIdNumberType = useMemo(() => {
+		if (data.exemptedFromTax) return "exempted";
+		if (currentCountryTaxInformation?.type) return currentCountryTaxInformation.type;
+		if (isUsSoleProp) return void 0;
+		return findExistingTaxInformation(data.taxInformation, country)?.type;
+	}, [
+		country,
+		currentCountryTaxInformation?.type,
+		data.exemptedFromTax,
+		data.taxInformation,
+		entityType,
+		isUsSoleProp
+	]);
+	const shouldDisplayErrorOnSelector = selectorOptions.length > 1 && taxIdNumberType === void 0;
+	const selectorError = shouldDisplayErrorOnSelector ? errors.taxInformation : void 0;
+	const inputError = shouldDisplayErrorOnSelector ? void 0 : errors.taxInformation;
+	const { label, mask, guidanceText } = resolveFieldMetadata(taxInformationDefaultFieldConfig[country], {
+		taxIdNumberType: taxIdNumberType === "exempted" ? void 0 : taxIdNumberType,
+		companyType: entityType
+	}, taxInformationDefaultFieldMetadata);
+	const updateTaxInfo = useCallback((mode, newEntry) => {
+		const entry = canSaveAbsentState ? {
+			...newEntry,
+			numberAbsent: newEntry.numberAbsent ?? false
+		} : newEntry;
+		handleChangeFor("taxInformation", mode)(upsertTaxInfoForCountry(data.taxInformation, country, entry));
+	}, [
+		canSaveAbsentState,
+		country,
+		data.taxInformation,
+		handleChangeFor
+	]);
+	const updateTaxType = useCallback((type, mode) => {
+		updateTaxInfo(mode, {
+			country,
+			number: currentCountryTaxInformation?.number,
+			type
+		});
+	}, [
+		country,
+		currentCountryTaxInformation?.number,
+		updateTaxInfo
+	]);
+	const resetToDefaultData = useCallback(() => {
+		if (defaultData !== void 0) handleChangeFor("taxInformation", "input")(defaultData);
+	}, [defaultData, handleChangeFor]);
+	const removeCountryTaxInfo = useCallback(() => {
+		handleChangeFor("taxInformation", "input")(removeTaxInfoForCountry(data.taxInformation, country));
+	}, [
+		country,
+		data.taxInformation,
+		handleChangeFor
+	]);
+	const setUenAsTaxId = useCallback((uen) => {
+		updateTaxInfo("blur", {
+			country,
+			number: uen ?? "",
+			type: "UEN"
+		});
+	}, [country, updateTaxInfo]);
+	const addTaxAbsentStatus = useCallback((exempted) => {
+		handleChangeFor("taxInformation", "input")(upsertTaxInfoForCountry(data.taxInformation, country, {
+			country,
+			numberAbsent: exempted
+		}));
+	}, [
+		country,
+		data.taxInformation,
+		handleChangeFor
+	]);
+	const handleTaxNumberChange = useCallback((e, mode) => {
+		const value = e ? typeof e === "string" ? e : e.currentTarget.value : void 0;
+		const resolvedType = currentCountryTaxInformation?.type ?? (taxIdNumberType !== "exempted" ? taxIdNumberType : void 0);
+		updateTaxInfo(mode, {
+			country,
+			number: value,
+			type: resolvedType
+		});
+	}, [
+		country,
+		currentCountryTaxInformation?.type,
+		taxIdNumberType,
+		updateTaxInfo
+	]);
+	const handleTaxIdNumberTypeChange = useCallback((taxIdType) => {
+		if (!canExempt && taxIdType === "exempted") throw Error(`${country} does not allow tax exemptions`);
+		if (taxIdType === "exempted") {
+			handleChangeFor("exemptedFromTax")(true);
+			updateTaxType(void 0, "input");
+			return canSaveAbsentState ? addTaxAbsentStatus(true) : removeCountryTaxInfo();
+		}
+		handleChangeFor("exemptedFromTax")(false);
+		if (country === "SG") {
+			if (taxIdType === "UEN") {
+				handleChangeFor("isUen")(true);
+				setUenAsTaxId(registrationNumber);
+			} else {
+				handleChangeFor("isUen")(false);
+				removeCountryTaxInfo();
+			}
+		}
+		updateTaxType(taxIdType, "input");
+	}, [
+		addTaxAbsentStatus,
+		canExempt,
+		canSaveAbsentState,
+		country,
+		handleChangeFor,
+		updateTaxType,
+		registrationNumber,
+		removeCountryTaxInfo,
+		setUenAsTaxId
+	]);
+	const handleExemptedFromTaxChange = useCallback((exempted) => {
+		handleChangeFor("exemptedFromTax")(exempted);
+		if (canSaveAbsentState) addTaxAbsentStatus(exempted);
+		else removeCountryTaxInfo();
+	}, [
+		addTaxAbsentStatus,
+		canSaveAbsentState,
+		handleChangeFor,
+		removeCountryTaxInfo
+	]);
+	const prevCountryRef = useRef(country);
+	useEffect(() => {
+		if (!country || prevCountryRef.current === country) return;
+		prevCountryRef.current = country;
+		const hasSavedTaxId = defaultData?.find((taxId) => taxId.country === country);
+		if (currentCountryTaxInformation && !hasSavedTaxId) return;
+		if (entityType === "soleProprietorship") return;
+		resetToDefaultData();
+	}, [country]);
+	useEffect(() => {
+		if (country === "SG" && data.isUen && registrationNumber && registrationNumber !== currentCountryTaxInformation?.number) setUenAsTaxId(registrationNumber);
+	}, [
+		registrationNumber,
+		currentCountryTaxInformation?.number,
+		data.isUen,
+		country,
+		setUenAsTaxId
+	]);
+	const isInitialized = useRef(false);
+	if (!isInitialized.current && country === "SG" && !defaultData?.find((taxInfo) => taxInfo.country === country)?.number) {
+		isInitialized.current = true;
+		handleChangeFor("isUen")(false);
+	}
+	return /* @__PURE__ */ jsxs("div", { children: [
+		/* @__PURE__ */ jsx(TaxIdNumberTypeSelector, {
+			country,
+			companyType: entityType,
+			setSelected: handleTaxIdNumberTypeChange,
+			selected: taxIdNumberType,
+			exemptedOptionLabel: showTaxIdExemptedOptions ? exemptionLabel : void 0,
+			isUsSoleProp,
+			errorMessage: selectorError
+		}),
+		shouldRenderInput && /* @__PURE__ */ jsx(MaskedInput, {
+			type: "text",
+			"aria-required": true,
+			"aria-invalid": !valid.taxInformation,
+			name: "taxInformation",
+			label: t(($) => $[label ?? "taxId"]),
+			formatGuidance: translateTranslatable(t, guidanceText),
+			value: currentCountryTaxInformation?.number ?? "",
+			errorMessage: inputError,
+			placeholder,
+			isValid: Boolean(valid.taxInformation) && !!currentCountryTaxInformation,
+			onInput: (e) => handleTaxNumberChange(e, "input"),
+			onBlur: (e) => handleTaxNumberChange(e, "blur"),
+			disabled: data.exemptedFromTax || data.isUen,
+			readonly,
+			optional,
+			shouldValidate,
+			...mask
+		}),
+		canExempt && !showTaxIdExemptedOptions && /* @__PURE__ */ jsx(Field, {
+			name: "exemptedFromTax",
+			children: (childProps) => /* @__PURE__ */ jsx(Checkbox, {
+				...childProps,
+				"aria-required": false,
+				"aria-invalid": false,
+				name: "exemptedFromTax",
+				label: exemptedFromTaxLabel,
+				value: "exemptedFromTax",
+				checked: Boolean(data.exemptedFromTax),
+				onChange: handleExemptedFromTaxChange
+			})
+		})
+	] });
+}
+var ConflictRow_module_default = {
+	"conflict-row-table": "_conflict-row-table_y7ii4_1",
+	conflictRowTable: "_conflict-row-table_y7ii4_1",
+	"conflict-row-list": "_conflict-row-list_y7ii4_12",
+	conflictRowList: "_conflict-row-list_y7ii4_12",
+	"conflict-row-list-option-label": "_conflict-row-list-option-label_y7ii4_29",
+	conflictRowListOptionLabel: "_conflict-row-list-option-label_y7ii4_29"
+};
+//#endregion
+//#region src/components/Shared/DataConflictsModal/ConflictRow.tsx
+var ConflictRow = ({ provided, detected, label, formatter = (val) => val, selected, onSelect, showAs }) => {
+	const { t } = useTranslation("common");
+	const hasOnlyProvided = !isEmpty(provided) && isEmpty(detected);
+	const hasOnlyDetected = isEmpty(provided) && !isEmpty(detected);
+	useEffect(() => {
+		if (selected !== void 0) return;
+		if (hasOnlyProvided) onSelect("provided");
+		else if (hasOnlyDetected) onSelect("detected");
+	}, [
+		hasOnlyProvided,
+		hasOnlyDetected,
+		onSelect,
+		selected
+	]);
+	if (hasOnlyProvided || hasOnlyDetected) return;
+	return showAs === "listItem" ? /* @__PURE__ */ jsxs("div", {
+		className: ConflictRow_module_default.conflictRowList,
+		children: [/* @__PURE__ */ jsx("dt", { children: /* @__PURE__ */ jsx(Typography, {
+			variant: "caption",
+			children: t(($) => $[label])
+		}) }), /* @__PURE__ */ jsxs("dd", { children: [/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx(Typography, {
+			variant: "caption",
+			color: "tertiary",
+			className: ConflictRow_module_default.conflictRowListOptionLabel,
+			children: t(($) => $["youEntered"])
+		}), /* @__PURE__ */ jsx(RadioWithLabel, {
+			label: formatter(provided),
+			value: "provided",
+			checked: selected === "provided",
+			onClick: () => onSelect("provided")
+		})] }), /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx(Typography, {
+			variant: "caption",
+			color: "tertiary",
+			className: ConflictRow_module_default.conflictRowListOptionLabel,
+			children: t(($) => $["weDetected"])
+		}), /* @__PURE__ */ jsx(RadioWithLabel, {
+			label: formatter(detected),
+			value: "detected",
+			checked: selected === "detected",
+			onClick: () => onSelect("detected")
+		})] })] })]
+	}) : /* @__PURE__ */ jsxs("tr", {
+		className: ConflictRow_module_default.conflictRowTable,
+		children: [
+			/* @__PURE__ */ jsx("td", { children: /* @__PURE__ */ jsx(Typography, {
+				variant: "caption",
+				children: t(($) => $[label])
+			}) }),
+			/* @__PURE__ */ jsx("td", { children: /* @__PURE__ */ jsx(RadioWithLabel, {
+				label: formatter(provided),
+				value: "provided",
+				checked: selected === "provided",
+				onClick: () => onSelect("provided")
+			}) }),
+			/* @__PURE__ */ jsx("td", { children: /* @__PURE__ */ jsx(RadioWithLabel, {
+				label: formatter(detected),
+				value: "detected",
+				checked: selected === "detected",
+				onClick: () => onSelect("detected")
+			}) })
+		]
+	});
+};
+var DataConflictsModal_module_default = {
+	"data-conflicts-wrapper": "_data-conflicts-wrapper_c81aq_1",
+	dataConflictsWrapper: "_data-conflicts-wrapper_c81aq_1",
+	"data-conflicts-header": "_data-conflicts-header_c81aq_7",
+	dataConflictsHeader: "_data-conflicts-header_c81aq_7",
+	"data-conflicts-table": "_data-conflicts-table_c81aq_15",
+	dataConflictsTable: "_data-conflicts-table_c81aq_15",
+	"data-conflicts-list": "_data-conflicts-list_c81aq_26",
+	dataConflictsList: "_data-conflicts-list_c81aq_26",
+	"data-conflicts-list-forced": "_data-conflicts-list-forced_c81aq_46",
+	dataConflictsListForced: "_data-conflicts-list-forced_c81aq_46",
+	"data-conflicts-table-hidden": "_data-conflicts-table-hidden_c81aq_50",
+	dataConflictsTableHidden: "_data-conflicts-table-hidden_c81aq_50"
+};
+//#endregion
+//#region src/components/Shared/DataConflictsModal/DataConflictsModal.tsx
+/**
+* A modal component for resolving data conflicts between two data sources.
+*
+* This component is typically used in a KYC (Know Your Customer) flow where user-provided data
+* is compared against data extracted from a document (e.g., via OCR).
+*
+* It identifies differing fields, presents them to the user, and allows them to select the
+* correct version for each field before proceeding.
+*
+* @template Data The shape of the data objects being compared.
+* @template Property A union of keys from the `Data` object, constrained to `NsTranslationKey<'common'>`.
+*/
+var DataConflictsModal = ({ providedData, detectedData, conflictingProperties, formatters, title, explanation, onContinue, labels, onCancel, cancelConfirmation, listOnly = false }) => {
+	const { t: commonT } = useTranslation("common");
+	const [showCancelModal, setShowCancelModal] = useState(false);
+	const [showError, setShowError] = useState(false);
+	/**
+	* A record object that maps each conflicting property key to its `provided` and `detected` values.
+	* This is memoized for performance, as it's derived from `conflictingProperties` and only needs
+	* to be recalculated if the list of conflicts changes.
+	*
+	* @example
+	* // returns: { firstName: { provided: 'Jon', detected: 'John' } }
+	*/
+	const conflictItems = useMemo(() => listToRecord(conflictingProperties, (property) => ({
+		provided: providedData[property],
+		detected: detectedData[property]
+	})), [
+		conflictingProperties,
+		providedData,
+		detectedData
+	]);
+	const [resolutions, setResolutions] = useState(() => listToRecord(conflictingProperties, () => void 0));
+	const resolveProperty = useCallback((property, selected) => {
+		setShowError(false);
+		setResolutions((prev) => ({
+			...prev,
+			[property]: selected
+		}));
+	}, []);
+	return /* @__PURE__ */ jsxs(Modal, {
+		ariaLabel: title,
+		onClose: () => cancelConfirmation ? setShowCancelModal(true) : onCancel(),
+		inset: true,
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: DataConflictsModal_module_default.dataConflictsWrapper,
+			children: [
+				/* @__PURE__ */ jsxs("div", {
+					className: DataConflictsModal_module_default.dataConflictsHeader,
+					children: [/* @__PURE__ */ jsx(Typography, {
+						variant: "title-l",
+						el: "h1",
+						children: title
+					}), /* @__PURE__ */ jsx(Typography, {
+						variant: "body",
+						children: explanation
+					})]
+				}),
+				showError ? /* @__PURE__ */ jsx(Alert, {
+					variant: "error",
+					title: commonT(($) => $["chooseTheCorrectDetailsBeforeProceeding"])
+				}) : void 0,
+				/* @__PURE__ */ jsx("dl", {
+					className: cx(DataConflictsModal_module_default.dataConflictsList, { [DataConflictsModal_module_default.dataConflictsListForced]: listOnly }),
+					children: keysOf(conflictItems).map((property) => /* @__PURE__ */ jsx(ConflictRow, {
+						showAs: "listItem",
+						label: labels?.[property] ?? property,
+						formatter: formatters[property],
+						provided: conflictItems[property].provided,
+						detected: conflictItems[property].detected,
+						selected: resolutions[property],
+						onSelect: (selected) => resolveProperty(property, selected)
+					}, property))
+				}),
+				/* @__PURE__ */ jsxs("table", {
+					className: cx(DataConflictsModal_module_default.dataConflictsTable, { [DataConflictsModal_module_default.dataConflictsTableHidden]: listOnly }),
+					children: [/* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsxs("tr", { children: [
+						/* @__PURE__ */ jsx("th", {}),
+						/* @__PURE__ */ jsx("th", { children: /* @__PURE__ */ jsx(Typography, {
+							variant: "caption",
+							color: "tertiary",
+							children: commonT(($) => $["youEntered"])
+						}) }),
+						/* @__PURE__ */ jsx("th", { children: /* @__PURE__ */ jsx(Typography, {
+							variant: "caption",
+							color: "tertiary",
+							children: commonT(($) => $["weDetected"])
+						}) })
+					] }) }), /* @__PURE__ */ jsx("tbody", { children: keysOf(conflictItems).map((property) => /* @__PURE__ */ jsx(ConflictRow, {
+						showAs: "tableRow",
+						label: labels?.[property] ?? property,
+						formatter: formatters[property],
+						provided: conflictItems[property].provided,
+						detected: conflictItems[property].detected,
+						selected: resolutions[property],
+						onSelect: (selected) => resolveProperty(property, selected)
+					}, property)) })]
+				}),
+				/* @__PURE__ */ jsx(Button, {
+					fullWidth: true,
+					onClick: () => {
+						if (!conflictingProperties.every((p) => resolutions[p])) {
+							setShowError(true);
+							return;
+						}
+						/**
+						* 2. Build an object containing only the user's selections for the conflicting properties.
+						* This intermediate object will only contain the keys that had a mismatch.
+						*/
+						const resolvedConflicts = listToRecord(conflictingProperties, (property) => {
+							return resolutions[property] === "provided" ? providedData[property] : detectedData[property];
+						});
+						onContinue({
+							...providedData,
+							...resolvedConflicts
+						});
+					},
+					children: commonT(($) => $["confirmSelection"])
+				})
+			]
+		}), cancelConfirmation && showCancelModal && /* @__PURE__ */ jsx(Confirm, {
+			title: cancelConfirmation.title,
+			confirmText: cancelConfirmation.confirmText,
+			description: cancelConfirmation.description,
+			onConfirm: onCancel,
+			onCancel: () => setShowCancelModal(false),
+			critical: false
+		})]
+	});
+};
+//#endregion
+//#region src/components/Individual/forms/IdNowVerificationModal/isIdNowModalOpen.ts
+var showIdNowModal = signal(false);
+var idNowModalChildEntityId = signal();
+var idNowPostSubmit = signal(false);
+var shouldShowIdNowModal = computed(() => {
+	const idNowModalChildEntityIdValue = !!idNowModalChildEntityId.value;
+	return showIdNowModal.value && idNowModalChildEntityIdValue;
+});
+//#endregion
+//#region src/components/Individual/helpers/bafinUtils.ts
+/**
+* Checks whether the legal entity has both required data points for IDnow verification:
+* birth city (placeOfBirth) and nationality.
+*/
+var hasRequiredDataForIdNow = (legalEntity) => Boolean(legalEntity.individual?.birthData?.placeOfBirth && legalEntity.individual?.nationality);
+/**
+* For an IDnow-qualified BAFIN signatory, returns an object describing which of the required
+* data points (placeOfBirth, nationality) are still missing, or `{ missingSelfie: true }` when
+* both are present but the selfie verification is still needed, or `null` when no action is needed.
+*
+* Returns `null` when any of the following conditions are true:
+* - The entity is not a signatory, or the L_BAFIN scenario is not active
+* - The `2_215` (live-selfie) remediation code is absent from problems
+*/
+var getIdNowMissingDataPoints = (problems, legalEntity, scenarios, roles) => {
+	if (!roles.includes(DecisionMakerTypes.SIGNATORY) || !scenarios?.includes(Scenarios.L_BAFIN)) return null;
+	if (!problems) return null;
+	if (!problems.missingData?.some((item) => item.remediatingActions?.some((action) => action.code === "2_215"))) return null;
+	const missingPlaceOfBirth = !legalEntity.individual?.birthData?.placeOfBirth;
+	const missingNationality = !legalEntity.individual?.nationality;
+	if (!missingPlaceOfBirth && !missingNationality) return { missingSelfie: true };
+	return {
+		missingPlaceOfBirth,
+		missingNationality
+	};
+};
+/**
+* For the BAFIN signatory flow, certain ID verification errors and remediation actions are not applicable.
+* This utility function takes a problems object and returns a new, deeply cloned object with all
+* ID verification-related issues removed.
+*
+* Specifically, it removes:
+* - 'missingData' entries related to ID document upload ('1_301').
+* - The '1_301' remediation action from `remediationActions`.
+* - The entire `idVerificationMethod` object from `verificationErrors`.
+* - Any nested sub-errors with code '1_301' from `basicDetails` and `additionalPersonalDetails`.
+*
+* @param problems - The original entity problems object.
+* @returns A new `EntityProblems` object with BAFIN-specific modifications.
+*/
+var removeIdVerificationProblemsForBafinSignatory = (problems, decisionMakerLe) => {
+	const newProblems = structuredClone(problems);
+	if (newProblems.missingData?.some((item) => item.remediatingActions?.some((action) => action.code === "1_301" || action.code === "2_215"))) {
+		if (hasRequiredDataForIdNow(decisionMakerLe)) setTimeout(() => {
+			idNowModalChildEntityId.value = decisionMakerLe;
+			showIdNowModal.value = true;
+		}, 100);
+	}
+	if (Array.isArray(newProblems.missingData)) newProblems.missingData = newProblems.missingData.filter((item) => !item.remediatingActions?.some((action) => action.code === "1_301" || action.code === "2_215"));
+	if (newProblems.remediationActions?.["1_301"]) delete newProblems.remediationActions["1_301"];
+	if (newProblems.remediationActions?.["2_215"]) delete newProblems.remediationActions["2_215"];
+	if (newProblems.verificationErrors?.idVerificationMethod) delete newProblems.verificationErrors.idVerificationMethod;
+	["basicDetails", "additionalPersonalDetails"].forEach((formName) => {
+		const subErrors = newProblems.verificationErrors?.[formName]?.["1_30"]?.["1_3000"];
+		if (newProblems.verificationErrors?.[formName]?.["1_30"] && Array.isArray(subErrors)) newProblems.verificationErrors[formName]["1_30"]["1_3000"] = subErrors.filter((error) => error.code !== "1_301");
+	});
+	return newProblems;
+};
+/**
+* Type guard to check if the data object is a LegalEntityAssociationDto.
+*/
+var isLegalEntityAssociation = (data) => "legalEntityId" in data;
+/**
+* Checks if the current context matches the specific flow for a BAFIN signatory.
+* This is true when the task is for a decision maker, their role is 'signatory',
+* and the BAFIN scenario is active.
+*
+* @param params - The parameters for the check.
+* @returns `true` if the conditions for the BAFIN signatory flow are met.
+*/
+var isBafinSignatoryFlow = ({ taskType, data, scenarios }) => {
+	if (!data || !scenarios) return false;
+	const isSignatory = isLegalEntityAssociation(data) ? data.type === DecisionMakerTypes.SIGNATORY : data.basicDetails?.role?.includes(DecisionMakerTypes.SIGNATORY);
+	if (taskType === TaskTypes.DECISION_MAKER && isSignatory) return scenarios.includes(Scenarios.L_BAFIN);
+	return false;
+};
+//#endregion
+export { COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT as A, isUsingCompanySearch as B, getValidCompanyTypesForTaxIdNumberType as C, COUNTRIES_THAT_DONT_REQUIRE_COMPANY_REGISTRATION as D, COUNTRIES_REQUIRING_FINANCIAL_INFORMATION as E, COUNTRIES_WITH_POSSIBLE_TRUSTEE_TAXID_ABSENT_V4 as F, mapSchemaFieldsToApiScriptLocalization as G, mapLocalizationToJapaneseLegalNames as H, REGISTRATION_NUMBER_EXEMPTION_RULES as I, stateFormatGuidanceText as J, businessRegistrationNumberPatterns as K, TAX_ID_REQUIRED_COUNTRIES_ORGANIZATION as L, COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER_SOLE_PROPS as M, COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_COMPANIES as N, COUNTRIES_THAT_DONT_REQUIRE_SOLE_PROP_REGISTRATION as O, COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_SOLE_PROPS as P, isRegistrationExemptionAllowed as R, getTaxIdNumberOptions as S, TileGroup as T, isEmpty as U, mapJapaneseLegalNamesToLocalization as V, mapApiScriptLocalizationToSchemaFields as W, getTaxInformationPlaceholderText as _, idNowPostSubmit as a, toFullWidth as b, DataConflictsModal as c, removeTaxInfoForCountry as d, upsertTaxInfoForCountry as f, exemptedFromTaxDefaultFieldMetadata as g, exemptedFromTaxDefaultFieldConfig as h, idNowModalChildEntityId as i, COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER as j, COUNTRIES_THAT_DO_NOT_USE_TAX_ID_FOR_SOLE_PROP as k, TAX_INFORMATION_FIELD as l, findExistingTaxInformation as m, isBafinSignatoryFlow as n, shouldShowIdNowModal as o, TaxIdNumberTypeSelector as p, businessRegistrationNumberMasks as q, removeIdVerificationProblemsForBafinSignatory as r, showIdNowModal as s, getIdNowMissingDataPoints as t, TaxInformationField as u, taxInformationDefaultFieldConfig as v, taxIdNumberOptions as w, isJapanLocalizationEnabled as x, taxInformationDefaultFieldMetadata as y, isRegistrationNumberAbsentStateV4Scenario as z };