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

package/dist/ConstitutionalDocument-Bxsr1hQb.js

@@ -0,0 +1,1229 @@
+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] = "580fc178-c1e2-4aa8-969f-4173c84f0375", e._sentryDebugIdIdentifier = "sentry-dbid-580fc178-c1e2-4aa8-969f-4173c84f0375");
+} catch (e) {}
+import { r as useTranslation } from "./translation-DbATp_35.js";
+import { t as Typography } from "./Typography-CAc_f5Iq.js";
+import { t as Loader } from "./Loader-BVtlpTeo.js";
+import { a as objectsDeepEqual } from "./genUtils-nphCwt1A.js";
+import { t as useToggleContext } from "./useToggleContext-B_YexrbT.js";
+import { t as CountryCodes } from "./country-code-CJk2hdPu.js";
+import { n as datasetUtilities } from "./datasetUtil-BdHPWsxZ.js";
+import { a as prefixCountryNameWithThe } from "./country-BEZkohEO.js";
+import { r as translateTranslatable } from "./utils-CYUYe54m.js";
+import { t as Field } from "./Field-DwDJQVSS.js";
+import { n as useDebouncedCallback } from "./debouncedInputEvent-Fwwp_K_-.js";
+import { t as Checkbox } from "./Checkbox-qfdF12cF.js";
+import { l as addressFields } from "./utils-BWumuCvl.js";
+import { a as validateNotEmptyOnBlur, o as validatePatternOnBlur } from "./patternValidators-DsrZkuOO.js";
+import { t as InputText } from "./InputText-CFDEmEtp.js";
+import { t as resolveFieldMetadata } from "./fieldConfigurations-CZCFghnK.js";
+import { r as isJapanLocalizationEnabled } from "./TaxInformationField-CV7SpMH1.js";
+import { a as nonInputs, c as MaskedInput, i as makeMask, n as alphanumericInputs, o as numericInputs, s as spacer, t as alphaInputs } from "./maskHelpers-C0wnCoJl.js";
+import { t as uppercase } from "./uppercase-DvjwUM0n.js";
+import { t as RadioGroup } from "./RadioGroup-Bf3DlQnZ.js";
+import { a as getPrefixedAddressFieldNames, i as getNestedTrustedFields, n as ALL_ADDRESS_FIELDS, o as nestAddressSchema, t as AddressFields } from "./AddressFields-BC3QHs2u.js";
+import { n as MemoizedDocumentUpload } from "./PatriotActDisclosure-DqUZeLms.js";
+import { a as useAddressCleanse, i as formatAddressForCleanse, n as formatDateObj, t as InputDate } from "./InputDate-Bq3Sb-ZW.js";
+import { i as getPrefixedFieldProps } from "./getProps-DVqK7eRw.js";
+import { t as formatValidationError } from "./formatValidationError-q_w9DTrl.js";
+import { Suspense, lazy, memo } from "preact/compat";
+import { useCallback as useCallback$1, useEffect as useEffect$1, useMemo as useMemo$1, useState as useState$1 } from "preact/hooks";
+import { Fragment as Fragment$1, jsx, jsxs } from "preact/jsx-runtime";
+//#region src/components/Shared/fields/DateOfIncorporationField/fieldConfig.ts
+var validateDateOfIncorporation = (dateOfIncorporation) => {
+	if (!dateOfIncorporation) return false;
+	const date = new Date(dateOfIncorporation);
+	return date < /* @__PURE__ */ new Date() && date > new Date(1900, 0, 1);
+};
+var dateOfIncorporationFieldMetadata = {
+	label: "dateOfIncorporation",
+	validators: [validateNotEmptyOnBlur, {
+		modes: ["blur"],
+		validate: validateDateOfIncorporation,
+		errorMessage: "invalidDateOfIncorporation"
+	}]
+};
+var dateOfIncorporationFieldConfig = {
+	HK: {
+		...dateOfIncorporationFieldMetadata,
+		label: "dateOfFormation"
+	},
+	SG: {
+		...dateOfIncorporationFieldMetadata,
+		label: "dateOfFormation"
+	}
+};
+//#endregion
+//#region src/components/Shared/fields/DateOfIncorporationField/DateOfIncorporationField.tsx
+var DATE_OF_INCORPORATION_FIELD = ["dateOfIncorporation"];
+function DateOfIncorporationField({ data, valid, errors, placeholder, readonly, handleChangeFor, country }) {
+	const { t } = useTranslation("common");
+	const fieldMetaData = resolveFieldMetadata(dateOfIncorporationFieldConfig[country], {}, dateOfIncorporationFieldMetadata);
+	const placeholderValue = placeholder ?? t(($) => $["datePlaceholder"]);
+	return /* @__PURE__ */ jsx(Field, {
+		name: "dateOfIncorporation",
+		label: t(($) => $[fieldMetaData.label ?? "dateOfIncorporation"]),
+		errorMessage: errors.dateOfIncorporation,
+		isValid: valid.dateOfIncorporation,
+		children: (childProps) => /* @__PURE__ */ jsx(InputDate, {
+			...childProps,
+			"aria-required": true,
+			"aria-invalid": !valid.dateOfIncorporation,
+			name: "dateOfIncorporation",
+			value: data.dateOfIncorporation,
+			placeholder: placeholderValue,
+			readonly,
+			onInput: handleChangeFor("dateOfIncorporation", "input"),
+			onBlur: handleChangeFor("dateOfIncorporation", "blur"),
+			max: formatDateObj(/* @__PURE__ */ new Date()),
+			min: formatDateObj(new Date(1900, 0, 1))
+		})
+	});
+}
+//#endregion
+//#region src/components/Shared/fields/DBANameField/DBANameField.tsx
+var DBA_NAME_FIELD = ["hasDoingBusinessAs", "doingBusinessAs"];
+function DBANameField({ data, valid, errors, readonly, handleChangeFor }) {
+	const { t } = useTranslation("common");
+	const hasDoingBusinessAsValue = useMemo$1(() => {
+		if (typeof data.hasDoingBusinessAs !== "boolean") return void 0;
+		return data.hasDoingBusinessAs ? "yes" : "no";
+	}, [data.hasDoingBusinessAs]);
+	const handleHasDoingBusinessAsChange = (val) => {
+		handleChangeFor("hasDoingBusinessAs")(val === "yes" ? true : false);
+	};
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Field, {
+		el: "fieldset",
+		name: "hasDoingBusinessAsName",
+		label: t(($) => $["hasDba"]),
+		helper: t(($) => $["hasDba__helperText"]),
+		isValid: valid.hasDoingBusinessAs,
+		errorMessage: errors.hasDoingBusinessAs,
+		children: (childProps) => /* @__PURE__ */ jsx(RadioGroup, {
+			...childProps,
+			name: "hasDoingBusinessAs",
+			items: [{
+				id: "yes",
+				name: "yes"
+			}, {
+				id: "no",
+				name: "no"
+			}],
+			value: hasDoingBusinessAsValue,
+			onChange: handleHasDoingBusinessAsChange,
+			horizontal: true
+		})
+	}), data.hasDoingBusinessAs && /* @__PURE__ */ jsx(Field, {
+		name: "doingBusinessAs",
+		label: t(($) => $["doingBusinessAs"]),
+		errorMessage: errors.doingBusinessAs,
+		isValid: valid.doingBusinessAs,
+		children: (childProps) => /* @__PURE__ */ jsx(InputText, {
+			...childProps,
+			"aria-required": true,
+			"aria-invalid": !valid.doingBusinessAs,
+			name: "doingBusinessAs",
+			value: data.doingBusinessAs,
+			readonly,
+			onInput: handleChangeFor("doingBusinessAs", "input"),
+			onBlur: handleChangeFor("doingBusinessAs", "blur")
+		})
+	})] });
+}
+//#endregion
+//#region src/components/Shared/fields/DBANameField/fieldConfig.ts
+var doingBusinessAsAbsentFieldMetadata = { validators: [validateNotEmptyOnBlur] };
+var doingBusinessAsFieldMetadata = { validators: [validateNotEmptyOnBlur] };
+//#endregion
+//#region src/utils/useDebouncedState.ts
+/**
+* Like {@link useState}, but waits for the given amount of time before applying *only* the most recent update.
+*
+* @param wait the time to wait, in milliseconds
+* @param initialState (optional) the default value
+*/
+function useDebouncedState(wait, initialState) {
+	const [state, _setState] = useState$1(initialState);
+	return [state, useDebouncedCallback(_setState, wait)];
+}
+var RegistrationAndOperationalAddressFields_module_default = {
+	"section-heading": "_section-heading_nb4mz_1",
+	sectionHeading: "_section-heading_nb4mz_1"
+};
+//#endregion
+//#region src/components/Shared/fields/RegistrationAndOperationalAddressFields/RegistrationAndOperationalAddressFields.tsx
+var LazyJpAddressFields = lazy(async () => (await import("./JpAddressFields-F1YCOcbO.js")).JpAddressFields);
+var REGISTRATION_AND_OPERATIONAL_ADDRESS_FIELDS = [
+	"operationalAddressIsSame",
+	...getPrefixedAddressFieldNames("registrationAddress"),
+	...getPrefixedAddressFieldNames("operationalAddress")
+];
+function RegistrationAndOperationalAddressFields({ country, readOnlyAddressFields, entityType, data, valid, errors, requiredFields, optionalFields, trustedFields, fieldValidationErrors, handleChangeFor, formUtils }) {
+	const { t, i18n } = useTranslation("common");
+	const { isFeatureEnabled } = useToggleContext();
+	const showJapanLocalization = isJapanLocalizationEnabled(isFeatureEnabled, country);
+	const showField = (fieldKeys) => fieldKeys.some((field) => formUtils.isRequiredField(field) || formUtils.isOptionalField(field));
+	useEffect$1(() => {
+		if (data?.registrationAddressCountry !== country) handleChangeFor("registrationAddressCountry")(country);
+		if (data?.operationalAddressCountry !== country) handleChangeFor("operationalAddressCountry")(country);
+	}, [
+		data?.registrationAddressCountry,
+		data?.operationalAddressCountry,
+		country,
+		handleChangeFor
+	]);
+	const handleOperationalAddressIsSameChange = useCallback$1((isChecked) => {
+		handleChangeFor("operationalAddressIsSame")(isChecked);
+	}, [handleChangeFor]);
+	const handleResidentialAddressIndicatorChange = useCallback$1((isChecked) => handleChangeFor("residentialAddressIndicator")(isChecked), [handleChangeFor]);
+	if (data?.operationalAddressIsSame === null) handleOperationalAddressIsSameChange(true);
+	const [addressToCheck, setAddressToCheck] = useDebouncedState(500);
+	const { data: cleansedRegistrationAddress } = useAddressCleanse({
+		text: addressToCheck,
+		country
+	}, { enabled: Boolean(addressToCheck) });
+	const mustProvideOperationalAddress = cleansedRegistrationAddress?.poBox ?? false;
+	const currentRegistrationAddress = nestAddressSchema("registrationAddress", data);
+	useEffect$1(() => setAddressToCheck(formatAddressForCleanse(currentRegistrationAddress)), [currentRegistrationAddress, setAddressToCheck]);
+	useEffect$1(() => {
+		if (mustProvideOperationalAddress && data?.operationalAddressIsSame) handleOperationalAddressIsSameChange(false);
+	}, [
+		handleOperationalAddressIsSameChange,
+		mustProvideOperationalAddress,
+		data?.operationalAddressIsSame
+	]);
+	const datasetUtils = datasetUtilities(i18n.language);
+	const registrationAddressDescription = useMemo$1(() => {
+		const translationKey = prefixCountryNameWithThe(country) ? "theOfficialAddressInTheCountry" : "theOfficialAddressInCountry";
+		return t(($) => $[translationKey], {
+			entityType,
+			country: datasetUtils.getCountryName(country)
+		});
+	}, [
+		entityType,
+		country,
+		datasetUtils,
+		t
+	]);
+	const formProps = {
+		data,
+		valid,
+		errors,
+		requiredFields,
+		optionalFields,
+		fieldValidationErrors,
+		handleFieldChange: handleChangeFor
+	};
+	const buildJpProps = (prefix) => getPrefixedFieldProps(formProps, prefix, ALL_ADDRESS_FIELDS);
+	const buildProps = (prefix) => getPrefixedFieldProps(formProps, prefix, addressFields);
+	const addressFieldProps = showJapanLocalization ? {
+		showJapanLocalization: true,
+		registrationAddress: buildJpProps("registrationAddress"),
+		operationalAddress: buildJpProps("operationalAddress")
+	} : {
+		showJapanLocalization: false,
+		registrationAddress: buildProps("registrationAddress"),
+		operationalAddress: buildProps("operationalAddress")
+	};
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs("section", { children: [
+		/* @__PURE__ */ jsxs("div", {
+			className: RegistrationAndOperationalAddressFields_module_default.sectionHeading,
+			children: [/* @__PURE__ */ jsx(Typography, {
+				el: "h3",
+				variant: "title",
+				children: t(($) => $["registeredBusinessAddress"])
+			}), /* @__PURE__ */ jsx(Typography, {
+				el: "p",
+				variant: "body",
+				children: registrationAddressDescription
+			})]
+		}),
+		addressFieldProps.showJapanLocalization ? /* @__PURE__ */ jsx(Suspense, {
+			fallback: /* @__PURE__ */ jsx(Loader, {}),
+			children: /* @__PURE__ */ jsx(LazyJpAddressFields, {
+				...addressFieldProps.registrationAddress,
+				addressType: "registrationAddress"
+			})
+		}) : /* @__PURE__ */ jsx(AddressFields, {
+			...addressFieldProps.registrationAddress,
+			addressType: "registrationAddress",
+			readOnlyFields: readOnlyAddressFields,
+			trustedFields: getNestedTrustedFields("registrationAddress", trustedFields),
+			hideCountry: true
+		}),
+		showField(["residentialAddressIndicator"]) && /* @__PURE__ */ jsx(Field, {
+			el: "fieldset",
+			name: "residentialAddressIndicator",
+			errorMessage: formatValidationError(errors?.residentialAddressIndicator?.errorMessage, t),
+			isValid: valid?.residentialAddressIndicator,
+			children: (childProps) => /* @__PURE__ */ jsx(Checkbox, {
+				...childProps,
+				name: "residentialAddressIndicator",
+				label: t(($) => $["thisIsAPersonalAddress"]),
+				helper: t(($) => $["businessAddressesCanShowOwnReceipts"]),
+				checked: !!data?.residentialAddressIndicator,
+				onChange: handleResidentialAddressIndicatorChange
+			})
+		})
+	] }), /* @__PURE__ */ jsxs("section", { children: [
+		/* @__PURE__ */ jsxs("div", {
+			className: RegistrationAndOperationalAddressFields_module_default.sectionHeading,
+			children: [/* @__PURE__ */ jsx(Typography, {
+				el: "h3",
+				variant: "title",
+				children: t(($) => $["principalPlaceOfBusiness"])
+			}), /* @__PURE__ */ jsx(Typography, {
+				el: "p",
+				variant: "body",
+				children: t(($) => $["thePhysicalLocationWhereThisOrganization"])
+			})]
+		}),
+		!mustProvideOperationalAddress && /* @__PURE__ */ jsx(Field, {
+			el: "fieldset",
+			name: "operationalAddressIsSame",
+			errorMessage: formatValidationError(errors?.operationalAddressIsSame?.errorMessage, t),
+			isValid: valid?.operationalAddressIsSame,
+			children: (childProps) => /* @__PURE__ */ jsx(Checkbox, {
+				...childProps,
+				"aria-required": formUtils.isRequiredField("operationalAddressIsSame"),
+				"aria-invalid": !valid?.operationalAddressIsSame,
+				name: "operationalAddressIsSame",
+				label: t(($) => $["sameAsRegisteredAddress"]),
+				checked: !!data?.operationalAddressIsSame,
+				onChange: handleOperationalAddressIsSameChange
+			})
+		}),
+		!data?.operationalAddressIsSame && (addressFieldProps.showJapanLocalization ? /* @__PURE__ */ jsx(Suspense, {
+			fallback: /* @__PURE__ */ jsx(Loader, {}),
+			children: /* @__PURE__ */ jsx(LazyJpAddressFields, {
+				...addressFieldProps.operationalAddress,
+				addressType: "operationalAddress"
+			})
+		}) : /* @__PURE__ */ jsx(AddressFields, {
+			...addressFieldProps.operationalAddress,
+			addressType: "operationalAddress",
+			trustedFields: getNestedTrustedFields("operationalAddress", trustedFields),
+			hideCountry: true
+		}))
+	] })] });
+}
+//#endregion
+//#region src/components/Shared/fields/VatNumberField/fieldConfig.ts
+var vatAbsenceReasonMetadata = { validators: [validateNotEmptyOnBlur] };
+var defaultFieldMetadata = { label: "vatNumber" };
+var defaultFieldConfig = {
+	[CountryCodes.Austria]: {
+		label: "UST-ID",
+		validators: validatePatternOnBlur(/^ATU\d{8}$/),
+		mask: { mask: makeMask(...nonInputs("ATU", { includeInValue: true }), spacer, ...numericInputs(8)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "8",
+				example: "ATU51507409"
+			}
+		}
+	},
+	[CountryCodes.Belgium]: {
+		label: "euVatNumber",
+		validators: validatePatternOnBlur(/^BE[10]\d{9}$/),
+		mask: { mask: makeMask(...nonInputs("BE", { includeInValue: true }), spacer, ...numericInputs(10)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "10",
+				example: "BE1234567890"
+			}
+		}
+	},
+	[CountryCodes.Bulgaria]: {
+		label: "identifikacionenNomerDDS",
+		validators: validatePatternOnBlur(/^BG\d{9,10}$/),
+		mask: { mask: makeMask(...nonInputs("BG", { includeInValue: true }), spacer, ...numericInputs(9), ...numericInputs(1, true)) },
+		guidanceText: {
+			key: "enterTheRemainingXToYDigitsForExample",
+			values: {
+				minDigits: "9",
+				maxDigits: "10",
+				example: "BG1234567890"
+			}
+		}
+	},
+	[CountryCodes.Croatia]: {
+		label: "PDVIdBrojOIB",
+		validators: validatePatternOnBlur(/^HR\d{11}$/),
+		mask: { mask: makeMask(...nonInputs("HR", { includeInValue: true }), spacer, ...numericInputs(11)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "11",
+				example: "HR94577403194"
+			}
+		}
+	},
+	[CountryCodes.Cyprus]: {
+		label: "arithmosEngraphes",
+		validators: validatePatternOnBlur(/^CY[A-Z0-9]{9}$/),
+		mask: {
+			mask: makeMask(...nonInputs("CY", { includeInValue: true }), spacer, ...alphanumericInputs(9)),
+			transformOnType: uppercase
+		},
+		guidanceText: {
+			key: "enterTheRemainingNCharactersForExample",
+			values: {
+				numChars: "9",
+				example: "CY12345678X"
+			}
+		}
+	},
+	[CountryCodes.CzechRepublic]: {
+		label: "DIC",
+		validators: validatePatternOnBlur(/^CZ\d{8,10}$/),
+		mask: { mask: makeMask(...nonInputs("CZ", { includeInValue: true }), spacer, ...numericInputs(8), ...numericInputs(2, true)) },
+		guidanceText: {
+			key: "enterTheRemainingXToYDigitsForExample",
+			values: {
+				minDigits: "8",
+				maxDigits: "10",
+				example: "CZ00177041"
+			}
+		}
+	},
+	[CountryCodes.Denmark]: ({ vatNumberType }) => {
+		switch (vatNumberType) {
+			case "stamregister": return {
+				label: "stamregister",
+				validators: validatePatternOnBlur(/^SE\d{8}$/),
+				mask: { mask: makeMask(...nonInputs("SE", { includeInValue: true }), spacer, ...numericInputs(8)) },
+				guidanceText: {
+					key: "enterTheRemainingNDigitsForExample",
+					values: {
+						numDigits: "8",
+						example: "SE12345678"
+					}
+				}
+			};
+			default: return {
+				label: "momsregistreringsnummerCVR",
+				validators: validatePatternOnBlur(/^DK\d{8}$/),
+				mask: { mask: makeMask(...nonInputs("DK", { includeInValue: true }), spacer, ...numericInputs(8)) },
+				guidanceText: {
+					key: "enterTheRemainingNDigitsForExample",
+					values: {
+						numDigits: "8",
+						example: "DK12345678"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Estonia]: {
+		label: "kaibemaksukohustuslaseNumber",
+		validators: validatePatternOnBlur(/^EE\d{9}$/),
+		mask: { mask: makeMask(...nonInputs("EE", { includeInValue: true }), spacer, ...numericInputs(9)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "9",
+				example: "EE100254507"
+			}
+		}
+	},
+	[CountryCodes.Finland]: {
+		label: "arvonlisaveronumeroMervardesskattenummer",
+		validators: validatePatternOnBlur(/^FI\d{8}$/),
+		mask: { mask: makeMask(...nonInputs("FI", { includeInValue: true }), spacer, ...numericInputs(8)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "9",
+				example: "FI12345678"
+			}
+		}
+	},
+	[CountryCodes.France]: ({ vatNumberType }) => {
+		const sharedMetadata = {
+			validators: validatePatternOnBlur(/^FR\d{11}$/),
+			mask: { mask: makeMask(...nonInputs("FR", { includeInValue: true }), spacer, ...numericInputs(11)) }
+		};
+		switch (vatNumberType) {
+			case "NumeroDeTVA": return {
+				...sharedMetadata,
+				label: "NumeroDeTVA",
+				guidanceText: {
+					key: "enterTheRemainingNDigitsForExample",
+					values: {
+						numDigits: "11",
+						example: "FR12999999999"
+					}
+				}
+			};
+			default: return {
+				...sharedMetadata,
+				label: "numeroDIdentificationALATaxe",
+				guidanceText: {
+					key: "enterTheRemainingNDigitsForExample",
+					values: {
+						numDigits: "11",
+						example: "FR12345678901"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Germany]: {
+		label: "USt-IdNr",
+		validators: validatePatternOnBlur(/^DE\d{9}$/),
+		mask: { mask: makeMask(...nonInputs("DE", { includeInValue: true }), spacer, ...numericInputs(9)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "9",
+				example: "DE115235681"
+			}
+		}
+	},
+	[CountryCodes.Greece]: {
+		label: "grTaxId",
+		validators: validatePatternOnBlur(/^EL\d{9}$/),
+		mask: { mask: makeMask(...nonInputs("EL", { includeInValue: true }), spacer, ...numericInputs(9)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "9",
+				example: "EL123456789"
+			}
+		}
+	},
+	[CountryCodes.Hungary]: {
+		label: "huTaxId",
+		validators: validatePatternOnBlur(/^HU\d{8}$/),
+		mask: { mask: makeMask(...nonInputs("HU", { includeInValue: true }), spacer, ...numericInputs(8)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "8",
+				example: "HU12345678"
+			}
+		}
+	},
+	[CountryCodes.Ireland]: {
+		label: "vatNumber",
+		validators: validatePatternOnBlur(/^IE[A-Z0-9]{8,9}$/),
+		mask: {
+			mask: makeMask(...nonInputs("IE", { includeInValue: true }), spacer, ...alphanumericInputs(8), ...alphanumericInputs(1, true)),
+			transformOnType: uppercase
+		},
+		guidanceText: {
+			key: "enterTheRemainingXToYCharactersForExample",
+			values: {
+				minChars: "8",
+				maxChars: "9",
+				example: "IE999999XX"
+			}
+		}
+	},
+	[CountryCodes.Italy]: {
+		label: "vatNumber",
+		validators: validatePatternOnBlur(/^IT\d{11}$/),
+		mask: { mask: makeMask(...nonInputs("IT", { includeInValue: true }), spacer, ...numericInputs(11)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "11",
+				example: "IT47040001100"
+			}
+		}
+	},
+	[CountryCodes.Latvia]: {
+		label: "lvTaxId",
+		validators: validatePatternOnBlur(/^LV\d{11}$/),
+		mask: { mask: makeMask(...nonInputs("LV", { includeInValue: true }), spacer, ...numericInputs(11)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "11",
+				example: "LV43603021620"
+			}
+		}
+	},
+	[CountryCodes.Liechtenstein]: {
+		label: "vatRegistrationNumber",
+		validators: validatePatternOnBlur(/^[0-9]{1,6}$/),
+		mask: { mask: makeMask(...numericInputs(1), ...numericInputs(5, true)) },
+		guidanceText: {
+			key: "enterAMaximumOfNDigitsForExample",
+			values: {
+				maxDigits: "6",
+				example: "123456"
+			}
+		}
+	},
+	[CountryCodes.Lithuania]: {
+		label: "PVMmoketojoKodas",
+		validators: validatePatternOnBlur(/^LT\d{9,12}$/),
+		mask: { mask: makeMask(...nonInputs("LT", { includeInValue: true }), spacer, ...numericInputs(9), ...numericInputs(3, true)) },
+		guidanceText: {
+			key: "enterTheRemainingXToYDigitsForExample",
+			values: {
+				minDigits: "9",
+				maxDigits: "12",
+				example: "LT664517219"
+			}
+		}
+	},
+	[CountryCodes.Luxembourg]: {
+		label: "numeroDIdentificationALATaxe",
+		validators: validatePatternOnBlur(/^LU\d{8}$/),
+		mask: { mask: makeMask(...nonInputs("LU", { includeInValue: true }), spacer, ...numericInputs(8)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "8",
+				example: "LU18928066"
+			}
+		}
+	},
+	[CountryCodes.Malaysia]: {
+		label: "SST",
+		validators: validatePatternOnBlur(/^([A-Z]\d{2}[-]\d{4}[-]\d{8}|\d{12})$/),
+		guidanceText: {
+			key: "enterXOrYCharactersForExample",
+			values: {
+				xChars: "12",
+				yChars: "14",
+				example: "123456789012, D11-1808-20032117"
+			}
+		}
+	},
+	[CountryCodes.Malta]: {
+		label: "vatNumber",
+		validators: validatePatternOnBlur(/^MT\d{8}$/),
+		mask: { mask: makeMask(...nonInputs("MT", { includeInValue: true }), spacer, ...numericInputs(8)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "8",
+				example: "MT12345678"
+			}
+		}
+	},
+	[CountryCodes.Monaco]: {
+		label: "numeroDIdentificationALATaxe",
+		validators: validatePatternOnBlur(/^FR[0-9]{11}$/),
+		mask: { mask: makeMask(...nonInputs("FR", { includeInValue: true }), spacer, ...numericInputs(11)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "11",
+				example: "FR12345678999"
+			}
+		}
+	},
+	[CountryCodes.Netherlands]: {
+		label: "btwNummer",
+		validators: validatePatternOnBlur(/^NL\d{9}B\d{2}$/),
+		mask: {
+			mask: makeMask(...nonInputs("NL", { includeInValue: true }), spacer, ...numericInputs(9), spacer, ...nonInputs("B", { includeInValue: true }), spacer, ...numericInputs(2)),
+			transformOnType: uppercase
+		},
+		guidanceText: {
+			key: "enterTheRemainingNCharactersForExample",
+			values: {
+				numChars: "12",
+				example: "NL123456789B01"
+			}
+		}
+	},
+	[CountryCodes.Norway]: {
+		label: "mvanummer",
+		validators: validatePatternOnBlur(/^\d{9}MVA$/),
+		mask: { mask: makeMask(...numericInputs(9), ...nonInputs("MVA", {
+			includeInValue: true,
+			displayEagerly: true
+		})) },
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "9",
+				example: "123456789MVA"
+			}
+		}
+	},
+	[CountryCodes.Poland]: {
+		label: "NIP",
+		validators: validatePatternOnBlur(/^PL\d{10}$/),
+		mask: { mask: makeMask(...nonInputs("PL", { includeInValue: true }), spacer, ...numericInputs(10)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "10",
+				example: "PL1234567890"
+			}
+		}
+	},
+	[CountryCodes.Portugal]: {
+		label: "numerodeIVA",
+		validators: validatePatternOnBlur(/^PT\d{9}$/),
+		mask: { mask: makeMask(...nonInputs("PT", { includeInValue: true }), spacer, ...numericInputs(9)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "9",
+				example: "PT123456789"
+			}
+		}
+	},
+	[CountryCodes.Romania]: {
+		label: "codulDeIdentificareFiscala",
+		validators: validatePatternOnBlur(/^RO\d{2,12}$/),
+		mask: { mask: makeMask(...nonInputs("RO", { includeInValue: true }), spacer, ...numericInputs(2), ...numericInputs(8, true)) },
+		guidanceText: {
+			key: "enterTheRemainingXToYDigitsForExample",
+			values: {
+				minDigits: "2",
+				maxDigits: "10",
+				example: "RO12345678"
+			}
+		}
+	},
+	[CountryCodes.Slovakia]: {
+		label: "skTaxId",
+		validators: validatePatternOnBlur(/^SK\d{10}$/),
+		mask: { mask: makeMask(...nonInputs("SK", { includeInValue: true }), spacer, ...numericInputs(10)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "10",
+				example: "SK1234567890"
+			}
+		}
+	},
+	[CountryCodes.Slovenia]: {
+		label: "siTaxId",
+		validators: validatePatternOnBlur(/^SI\d{8}$/),
+		mask: { mask: makeMask(...nonInputs("SI", { includeInValue: true }), spacer, ...numericInputs(8)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "8",
+				example: "SI12345678"
+			}
+		}
+	},
+	[CountryCodes.Spain]: {
+		label: "NIFdeIVA",
+		validators: validatePatternOnBlur(/^ES[A-Z0-9]\d{7}[A-Z0-9]$/),
+		mask: {
+			mask: makeMask(...nonInputs("ES", { includeInValue: true }), spacer, ...alphanumericInputs(9)),
+			transformOnType: uppercase
+		},
+		guidanceText: {
+			key: "enterTheRemainingNCharactersForExample",
+			values: {
+				numChars: "9",
+				example: "ES12345678X"
+			}
+		}
+	},
+	[CountryCodes.Sweden]: {
+		label: "vatNummerMomsregistreringsnummerOrMomsnummer",
+		validators: validatePatternOnBlur(/^SE\d{12}$/),
+		mask: { mask: makeMask(...nonInputs("SE", { includeInValue: true }), spacer, ...numericInputs(12)) },
+		guidanceText: {
+			key: "enterTheRemainingNDigitsForExample",
+			values: {
+				numDigits: "12",
+				example: "SE123456789001"
+			}
+		}
+	},
+	[CountryCodes.Switzerland]: {
+		label: "Mehrwertsteuernummer",
+		validators: validatePatternOnBlur(/^CHE\d{9}(TVA|MWST|IVA)$/),
+		mask: {
+			mask: makeMask(...nonInputs("CHE", { includeInValue: true }), ...nonInputs(" - "), ...numericInputs(3), ...nonInputs(" . "), ...numericInputs(3), ...nonInputs(" . "), ...numericInputs(3), spacer, ...alphaInputs(3), ...alphaInputs(1, true)),
+			transformOnType: uppercase
+		},
+		guidanceText: {
+			key: "enterTheRemainingNDigitsThenXToYLettersForExample",
+			values: {
+				numDigits: "9",
+				minLetters: "3",
+				maxLetters: "4",
+				example: "CHE-123.456.789 TVA"
+			}
+		}
+	},
+	[CountryCodes.UnitedArabEmirates]: {
+		label: "vatRegistrationNumber",
+		validators: validateNotEmptyOnBlur
+	},
+	[CountryCodes.UnitedKingdom]: {
+		label: "vatRegistrationNumber",
+		validators: validatePatternOnBlur(/^GB\d{9,12}$/),
+		mask: { mask: makeMask(...nonInputs("GB", { includeInValue: true }), spacer, ...numericInputs(9), ...numericInputs(3, true)) },
+		guidanceText: {
+			key: "enterTheRemainingXToYDigitsForExample",
+			values: {
+				minDigits: "9",
+				maxDigits: "12",
+				example: "GB1234567890"
+			}
+		}
+	},
+	/**
+	* 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.Albania]: { validators: validatePatternOnBlur(/^[JKLM][A-Z0-9]{8}[A-Z]$/) },
+	[CountryCodes.Belarus]: { validators: validatePatternOnBlur(/^\d{9}$/) },
+	[CountryCodes.RussianFederation]: { validators: validatePatternOnBlur(/^(\d{10}|\d{12})$/) },
+	[CountryCodes.SanMarino]: { validators: validatePatternOnBlur(/^\d{5}$/) },
+	[CountryCodes.Serbia]: { validators: validatePatternOnBlur(/^\d{9}$/) },
+	[CountryCodes.Turkey]: { validators: validatePatternOnBlur(/^\d{10}$/) },
+	[CountryCodes.Ukraine]: { validators: validatePatternOnBlur(/^\d{12}$/) },
+	[CountryCodes.Argentina]: { validators: validatePatternOnBlur(/^\d{11}$/) },
+	[CountryCodes.Chile]: { validators: validatePatternOnBlur(/^\d{9}$/) },
+	[CountryCodes.Colombia]: { validators: validatePatternOnBlur(/^\d{10}$/) },
+	[CountryCodes.CostaRica]: { validators: validatePatternOnBlur(/^\d{9,12}$/) },
+	[CountryCodes.Ecuador]: { validators: validatePatternOnBlur(/^\d{13}$/) },
+	[CountryCodes.Guatemala]: { validators: validatePatternOnBlur(/^\d{8}$/) },
+	[CountryCodes.Peru]: { validators: validatePatternOnBlur(/^\d{11}$/) },
+	[CountryCodes.Venezuela]: { validators: validatePatternOnBlur(/^[JGVE]-\d{8}-?\d$/) }
+};
+//#endregion
+//#region src/components/Shared/fields/VatNumberField/vatNumberTypes.ts
+var vatNumberOptions = {
+	[CountryCodes.Austria]: [{
+		id: "UST-ID",
+		name: "UST-ID"
+	}],
+	[CountryCodes.Belgium]: [{
+		id: "euVatNumber",
+		name: "euVatNumber"
+	}],
+	[CountryCodes.Bulgaria]: [{
+		id: "identifikacionenNomerDDS",
+		name: "identifikacionenNomerDDS"
+	}],
+	[CountryCodes.Croatia]: [{
+		id: "PDVIdBrojOIB",
+		name: "PDVIdBrojOIB"
+	}],
+	[CountryCodes.Cyprus]: [{
+		id: "arithmosEngraphes",
+		name: "arithmosEngraphes"
+	}],
+	[CountryCodes.CzechRepublic]: [{
+		id: "DIC",
+		name: "DIC"
+	}],
+	[CountryCodes.Denmark]: [{
+		id: "momsregistreringsnummerCVR",
+		name: "momsregistreringsnummerCVR"
+	}, {
+		id: "stamregister",
+		name: "stamregister"
+	}],
+	[CountryCodes.Estonia]: [{
+		id: "kaibemaksukohustuslaseNumber",
+		name: "kaibemaksukohustuslaseNumber"
+	}],
+	[CountryCodes.Finland]: [{
+		id: "arvonlisaveronumeroMervardesskattenummer",
+		name: "arvonlisaveronumeroMervardesskattenummer"
+	}],
+	[CountryCodes.France]: [{
+		id: "numeroDIdentificationALATaxe",
+		name: "numeroDIdentificationALATaxe"
+	}, {
+		id: "NumeroDeTVA",
+		name: "NumeroDeTVA"
+	}],
+	[CountryCodes.Germany]: [{
+		id: "USt-IdNr",
+		name: "USt-IdNr"
+	}],
+	[CountryCodes.Greece]: [{
+		id: "grTaxId",
+		name: "grTaxId"
+	}],
+	[CountryCodes.Hungary]: [{
+		id: "huTaxId",
+		name: "huTaxId"
+	}],
+	[CountryCodes.Ireland]: [{
+		id: "vatNumber",
+		name: "vatNumber"
+	}],
+	[CountryCodes.Italy]: [{
+		id: "partitaIVA",
+		name: "partitaIVA"
+	}],
+	[CountryCodes.Latvia]: [{
+		id: "lvTaxId",
+		name: "lvTaxId"
+	}],
+	[CountryCodes.Liechtenstein]: [{
+		id: "vatRegistrationNumber",
+		name: "vatRegistrationNumber"
+	}],
+	[CountryCodes.Lithuania]: [{
+		id: "PVMmoketojoKodas",
+		name: "PVMmoketojoKodas"
+	}],
+	[CountryCodes.Luxembourg]: [{
+		id: "numeroDIdentificationALATaxe",
+		name: "numeroDIdentificationALATaxe"
+	}],
+	[CountryCodes.Malaysia]: [{
+		id: "SST",
+		name: "SST"
+	}],
+	[CountryCodes.Malta]: [{
+		id: "vatNumber",
+		name: "vatNumber"
+	}],
+	[CountryCodes.Monaco]: [{
+		id: "numeroDIdentificationALATaxe",
+		name: "numeroDIdentificationALATaxe"
+	}],
+	[CountryCodes.Netherlands]: [{
+		id: "btwNummer",
+		name: "btwNummer"
+	}],
+	[CountryCodes.Norway]: [{
+		id: "mvanummer",
+		name: "mvanummer"
+	}],
+	[CountryCodes.Poland]: [{
+		id: "NIP",
+		name: "NIP"
+	}],
+	[CountryCodes.Portugal]: [{
+		id: "numerodeIVA",
+		name: "numerodeIVA"
+	}],
+	[CountryCodes.Romania]: [{
+		id: "codulDeIdentificareFiscala",
+		name: "codulDeIdentificareFiscala"
+	}],
+	[CountryCodes.Slovakia]: [{
+		id: "skTaxId",
+		name: "skTaxId"
+	}],
+	[CountryCodes.Slovenia]: [{
+		id: "siTaxId",
+		name: "siTaxId"
+	}],
+	[CountryCodes.Spain]: [{
+		id: "NIFdeIVA",
+		name: "NIFdeIVA"
+	}],
+	[CountryCodes.Sweden]: [{
+		id: "vatNummerMomsregistreringsnummerOrMomsnummer",
+		name: "vatNummerMomsregistreringsnummerOrMomsnummer"
+	}],
+	[CountryCodes.Switzerland]: [{
+		id: "Mehrwertsteuernummer",
+		name: "Mehrwertsteuernummer"
+	}],
+	[CountryCodes.UnitedArabEmirates]: [{
+		id: "vatRegistrationNumber",
+		name: "vatRegistrationNumber"
+	}],
+	[CountryCodes.UnitedKingdom]: [{
+		id: "vatRegistrationNumber",
+		name: "vatRegistrationNumber"
+	}]
+};
+var getVatNumberOptions = (country, companyType) => {
+	const optionsForCountry = vatNumberOptions[country];
+	if (!companyType || !optionsForCountry) return optionsForCountry;
+	return optionsForCountry.filter((option) => option.applicableOnlyFor?.includes(companyType) ?? true);
+};
+//#endregion
+//#region src/components/Shared/fields/VatNumberField/VatNumberTypeSelector/inferVatNumberType.ts
+var inferVatNumberType = (vatNumber, country) => {
+	const optionsForCountry = vatNumberOptions[country];
+	const metadataFn = defaultFieldConfig[country];
+	if (!optionsForCountry || !metadataFn) return void 0;
+	for (const option of optionsForCountry) {
+		const fieldMetadata = typeof metadataFn === "function" ? metadataFn({ vatNumberType: option.id }) : metadataFn;
+		if (!fieldMetadata.validators) continue;
+		if ((Array.isArray(fieldMetadata.validators) ? fieldMetadata.validators : [fieldMetadata.validators]).every((validator) => validator.validate(vatNumber))) return option.id;
+	}
+};
+//#endregion
+//#region src/components/Shared/fields/VatNumberField/VatNumberTypeSelector/getDefaultVatNumberType.ts
+/**
+* Determines the default VAT number type based on exisiting information and country.
+* This function follows a priority order:
+* 1. Infer the type from the number if possible
+* 2. Otherwise, use the first available VAT number type for the country
+*
+* @param vatNumber - VAT number value
+* @param country  - Country code to determine the VAT number type
+* @returns The determined VAT number type or undefined if none can be determined
+*/
+function getDefaultVatNumberType(vatNumber, country) {
+	return vatNumber ? inferVatNumberType(vatNumber, country) : vatNumberOptions[country]?.[0]?.id;
+}
+//#endregion
+//#region src/components/Shared/fields/VatNumberField/VatNumberTypeSelector/VatNumberTypeSelector.tsx
+function VatNumberTypeSelector({ country, companyType, selected, setSelected, exemptedOptionLabel }) {
+	const { t } = useTranslation("common");
+	const handleSelect = useCallback$1((selectedStr) => {
+		const newSelected = selectedStr;
+		if (newSelected === "exempted") {
+			if (exemptedOptionLabel) setSelected(newSelected, true);
+			return;
+		}
+		setSelected(newSelected, false);
+	}, [exemptedOptionLabel, setSelected]);
+	const options = useMemo$1(() => {
+		const availableOptions = getVatNumberOptions(country, companyType) ?? [];
+		if (availableOptions.length === 0 || !exemptedOptionLabel) return availableOptions;
+		return [...availableOptions, {
+			id: "exempted",
+			name: exemptedOptionLabel
+		}];
+	}, [
+		country,
+		companyType,
+		exemptedOptionLabel
+	]);
+	useEffect$1(() => {
+		if (!selected && options.length > 0) handleSelect(options[0].id);
+	}, [
+		options,
+		selected,
+		handleSelect
+	]);
+	if (options.length <= 1) return null;
+	return /* @__PURE__ */ jsx(Field, {
+		el: "fieldset",
+		name: "vatNumberType",
+		label: t(($) => $["whichTypeOfTaxIdNumberDoYouHave"]),
+		children: (childProps) => /* @__PURE__ */ jsx(RadioGroup, {
+			...childProps,
+			name: "vatNumberType",
+			items: options,
+			value: selected,
+			onChange: handleSelect
+		})
+	});
+}
+//#endregion
+//#region src/components/Shared/fields/VatNumberField/VatNumberField.tsx
+var VAT_NUMBER_FIELD = [
+	"vatNumber",
+	"vatNumberType",
+	"exemptedFromVat",
+	"vatAbsenceReason"
+];
+function VatNumberField({ data, valid, errors, labels, mask, readonly, optional, shouldValidate, handleChangeFor, canExempt, country }) {
+	const { t } = useTranslation("common");
+	const { isFeatureEnabled } = useToggleContext();
+	const options = vatNumberOptions[country];
+	const defaultType = getDefaultVatNumberType(data.vatNumber, country);
+	const vatAbsenceReasons = isFeatureEnabled("ShowExtraTaxExemptionReasons") ? [
+		"belowTaxThreshold",
+		"industryExemption",
+		"countryWithoutVatOrGstSystem"
+	] : ["belowTaxThreshold", "industryExemption"];
+	const showVatExemptedOptions = canExempt && options?.length > 1;
+	const vatNumberType = data.exemptedFromVat ? "exempted" : data.vatNumberType ? data.vatNumberType : defaultType;
+	const fieldMetadata = resolveFieldMetadata(defaultFieldConfig[country], { vatNumberType: vatNumberType === "exempted" ? void 0 : vatNumberType }, defaultFieldMetadata);
+	const handleVatNumberChange = (e, mode) => {
+		const value = typeof e === "string" ? e : e.currentTarget.value;
+		handleChangeFor("vatNumber", mode)(value);
+		handleChangeFor("vatNumberType")(vatNumberType);
+	};
+	const handleVatNumberTypeChange = (vatType, exemptValue) => {
+		if (vatType === "exempted") {
+			if (!canExempt) throw Error(`${country} does not allow VAT exemptions`);
+			handleChangeFor("vatNumber")(null);
+			handleChangeFor("vatNumberType")(void 0);
+			handleChangeFor("exemptedFromVat")(exemptValue);
+			return;
+		}
+		if (canExempt) handleChangeFor("exemptedFromVat")(exemptValue);
+		handleChangeFor("vatNumberType")(vatType);
+	};
+	if (vatNumberType && vatNumberType !== "exempted") {
+		if (!options?.find((option) => option.id === vatNumberType)) handleChangeFor("vatNumberType")(defaultType);
+	}
+	if (data.exemptedFromVat === false && data.vatAbsenceReason) handleChangeFor("vatAbsenceReason")(null);
+	return /* @__PURE__ */ jsxs("div", { children: [
+		/* @__PURE__ */ jsx(VatNumberTypeSelector, {
+			country,
+			setSelected: handleVatNumberTypeChange,
+			selected: vatNumberType,
+			exemptedOptionLabel: showVatExemptedOptions ? labels.exemptedFromVat : void 0
+		}),
+		/* @__PURE__ */ jsx(MaskedInput, {
+			type: "text",
+			"aria-required": true,
+			"aria-invalid": !valid.vatNumber,
+			name: "vatNumber",
+			value: data?.vatNumber ?? "",
+			label: labels.vatNumber ?? "",
+			formatGuidance: translateTranslatable(t, fieldMetadata.guidanceText),
+			errorMessage: errors.vatNumber,
+			isValid: Boolean(valid.vatNumber),
+			onInput: (e) => handleVatNumberChange(e, "input"),
+			onBlur: (e) => handleVatNumberChange(e, "blur"),
+			disabled: data.exemptedFromVat,
+			readonly,
+			optional,
+			shouldValidate,
+			...mask
+		}),
+		canExempt && !showVatExemptedOptions && /* @__PURE__ */ jsx(Field, {
+			name: "exemptedFromVat",
+			children: (childProps) => /* @__PURE__ */ jsx(Checkbox, {
+				...childProps,
+				"aria-required": false,
+				"aria-invalid": false,
+				name: "exemptedFromVat",
+				label: labels?.exemptedFromVat,
+				value: "exemptedFromVat",
+				checked: Boolean(data.exemptedFromVat),
+				onChange: (e) => handleVatNumberTypeChange("exempted", e)
+			})
+		}),
+		data.exemptedFromVat && /* @__PURE__ */ jsx(Field, {
+			el: "fieldset",
+			name: "vatAbsenceReason",
+			label: labels?.vatAbsenceReason,
+			errorMessage: errors.vatAbsenceReason,
+			isValid: valid.vatAbsenceReason,
+			children: (childProps) => /* @__PURE__ */ jsx(RadioGroup, {
+				...childProps,
+				name: "vatAbsenceReason",
+				onChange: handleChangeFor("vatAbsenceReason"),
+				value: data.vatAbsenceReason,
+				items: vatAbsenceReasons.map((reason) => ({
+					id: reason,
+					name: reason
+				}))
+			})
+		})
+	] });
+}
+//#endregion
+//#region src/components/Shared/forms/ConstitutionalDocument/types.ts
+var ConstitutionalDocumentTypes = {
+	BUSINESS_NAME_FILING: "doingBusinessAsNameFiling",
+	TAX_FILING: "taxFiling",
+	EMPLOYER_IDENTIFICATION_NUMBER_VERIFICATION_LETTER: "einVerificationLetter",
+	BUSINESS_REGISTRATION_DOCUMENT: "businessRegistrationDocument",
+	TRUST_DEED: "trustDeed",
+	TRUST_INSTRUMENT: "trustInstrument",
+	PARTNERSHIP_AGREEMENT: "partnershipAgreement",
+	MEETING_MINUTES: "meetingMinutes"
+};
+//#endregion
+//#region src/components/Shared/forms/ConstitutionalDocument/ConstitutionalDocument.tsx
+var getConstitutionDocumentTypeOptionsMapping = (legalEntityType, country) => {
+	switch (legalEntityType) {
+		case "soleProprietorship": switch (country) {
+			case "FR": return [
+				{
+					id: ConstitutionalDocumentTypes.BUSINESS_NAME_FILING,
+					name: "doingBusinessAsNameFiling__FR"
+				},
+				{
+					id: ConstitutionalDocumentTypes.TAX_FILING,
+					name: "taxFiling"
+				},
+				{
+					id: ConstitutionalDocumentTypes.BUSINESS_REGISTRATION_DOCUMENT,
+					name: "businessRegistrationDocument__FR"
+				}
+			];
+			case "US": return [
+				{
+					id: ConstitutionalDocumentTypes.BUSINESS_NAME_FILING,
+					name: "doingBusinessAsNameFiling__US"
+				},
+				{
+					id: ConstitutionalDocumentTypes.TAX_FILING,
+					name: "taxFiling__US"
+				},
+				{
+					id: ConstitutionalDocumentTypes.EMPLOYER_IDENTIFICATION_NUMBER_VERIFICATION_LETTER,
+					name: "einVerificationLetter"
+				}
+			];
+			default: return [{
+				id: ConstitutionalDocumentTypes.BUSINESS_NAME_FILING,
+				name: "doingBusinessAsNameFiling"
+			}, {
+				id: ConstitutionalDocumentTypes.TAX_FILING,
+				name: "taxFiling"
+			}];
+		}
+		case "unincorporatedPartnership": return [{
+			id: ConstitutionalDocumentTypes.PARTNERSHIP_AGREEMENT,
+			name: "partnershipAgreement"
+		}, {
+			id: ConstitutionalDocumentTypes.MEETING_MINUTES,
+			name: "meetingMinutes"
+		}];
+		default: return [{
+			id: ConstitutionalDocumentTypes.TRUST_DEED,
+			name: "trustDeed"
+		}, {
+			id: ConstitutionalDocumentTypes.TRUST_INSTRUMENT,
+			name: "trustInstrument"
+		}];
+	}
+};
+function getLegalEntityTypeBasedConstitutionalDocumentHeaderDescriptionTranslationkey(legalEntityType) {
+	switch (legalEntityType) {
+		case "soleProprietorship": return "constitutionalDocumentSoleProprietorshipHeaderDescription";
+		case "trust": return "constitutionalDocumentTrustHeaderDescription";
+		case "unincorporatedPartnership": return "constitutionalDocumentUnincorporatedPartnershipDescription";
+		default: return "constitutionalDocumentHeaderDescription";
+	}
+}
+var unincorporatedPartnershipRequirementsVariants = [
+	"Name",
+	"Details",
+	"UpToDate"
+];
+function ConstitutionalDocumentUpload({ id, legalEntityType, ...props }) {
+	const { t } = useTranslation(["common"]);
+	const isUnincorporatedPartnership = legalEntityType === "unincorporatedPartnership";
+	const constitutionalDocumentRequirements = getConstitutionDocumentTypeOptionsMapping(legalEntityType, props.country);
+	const guidanceContent = /* @__PURE__ */ jsxs("div", {
+		className: "adyen-kyc-upload-field__guidance u-margin-bottom-24",
+		children: [
+			/* @__PURE__ */ jsx("strong", { children: t(($) => $["uploadOneOfTheseDocuments"]) }),
+			/* @__PURE__ */ jsx("ul", { children: constitutionalDocumentRequirements?.map(({ name }, i) => /* @__PURE__ */ jsx("li", { children: t(($) => $[name]) }, i)) }),
+			isUnincorporatedPartnership && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("strong", { children: t(($) => $["documentRequirements"]) }), /* @__PURE__ */ jsx("ul", { children: unincorporatedPartnershipRequirementsVariants.map((item, i) => /* @__PURE__ */ jsx("li", { children: t(($) => $[`documentRequirementsUnincorporatedPartnership${item}`], { ns: "common" }) }, i)) })] }),
+			props.country !== "US" && !isUnincorporatedPartnership && /* @__PURE__ */ jsx("div", {
+				className: "u-margin-y-16",
+				children: /* @__PURE__ */ jsxs("span", { children: [t(($) => $["infoInUploadedDocumentIsTrue"]), " "] })
+			})
+		]
+	});
+	return /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(MemoizedDocumentUpload, {
+		...props,
+		documentType: "constitutionalDocument",
+		documentField: "constitutionalDocument",
+		heading: t(($) => $["constitutionalDocumentHeader"]),
+		description: t(($) => $[getLegalEntityTypeBasedConstitutionalDocumentHeaderDescriptionTranslationkey(legalEntityType)], { ns: "common" }),
+		guidanceContent,
+		id,
+		hidePageCount: true
+	}) });
+}
+var MemoizedConstitutionalDocument = memo(ConstitutionalDocumentUpload, (prevProps, nextProps) => objectsDeepEqual(prevProps.requiredFields, nextProps.requiredFields) && objectsDeepEqual(prevProps.data, nextProps.data) && objectsDeepEqual(prevProps.formVerificationErrors, nextProps.formVerificationErrors) && objectsDeepEqual(prevProps.fieldValidationErrors, nextProps.fieldValidationErrors) && prevProps.shouldValidate === nextProps.shouldValidate);
+//#endregion
+export { dateOfIncorporationFieldMetadata as _, defaultFieldConfig as a, REGISTRATION_AND_OPERATIONAL_ADDRESS_FIELDS as c, doingBusinessAsFieldMetadata as d, DBANameField as f, dateOfIncorporationFieldConfig as g, DateOfIncorporationField as h, getDefaultVatNumberType as i, RegistrationAndOperationalAddressFields as l, DATE_OF_INCORPORATION_FIELD as m, VAT_NUMBER_FIELD as n, defaultFieldMetadata as o, DBA_NAME_FIELD as p, VatNumberField as r, vatAbsenceReasonMetadata as s, MemoizedConstitutionalDocument as t, doingBusinessAsAbsentFieldMetadata as u };