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

package/dist/ConstitutionalDocument-D92EPGmG.js

@@ -1,1224 +0,0 @@
-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] = "451cdb73-afe3-470c-9823-7d6c2b9fed7b", e._sentryDebugIdIdentifier = "sentry-dbid-451cdb73-afe3-470c-9823-7d6c2b9fed7b");
-} catch (e) {}
-import { r as useTranslation } from "./translation-BOm4lmPx.js";
-import { T as datasetUtilities, j as useToggleContext } from "./resolveEnvironment-BYEL10Nc.js";
-import { t as Typography } from "./Typography-CAc_f5Iq.js";
-import { t as Loader } from "./Loader-BEpMlKm2.js";
-import { t as LegalEntityTypes } from "./legal-entity-type-0MfCGzUf.js";
-import { a as objectsDeepEqual } from "./genUtils-Ce61IJs8.js";
-import { t as CountryCodes } from "./country-code-CJk2hdPu.js";
-import { a as prefixCountryNameWithThe } from "./country-zZC2TAQB.js";
-import { t as InputText } from "./InputText-CTpVF0Mu.js";
-import { c as numericInputs, i as alphanumericInputs, l as spacer, m as resolveFieldMetadata, n as uppercase, o as makeMask, r as alphaInputs, s as nonInputs, u as MaskedInput } from "./form-rules-zzbZ2bV6.js";
-import { f as translateTranslatable, r as Field } from "./Select-ByVcS_J2.js";
-import { f as addressFields } from "./StateField-CsO_28Co.js";
-import { c as validatePatternOnBlur, s as validateNotEmptyOnBlur, t as RadioGroup } from "./RadioGroup-D8DRUJ2o.js";
-import { r as useDebouncedCallback, t as Checkbox } from "./Checkbox-B730k3Yy.js";
-import { U as isJapanLocalizationEnabled } from "./bafinUtils-M2AASP_e.js";
-import { a as getPrefixedAddressFieldNames, i as getNestedTrustedFields, n as ALL_ADDRESS_FIELDS, o as nestAddressSchema, t as AddressFields } from "./AddressFields-BsxEdBvQ.js";
-import { n as MemoizedDocumentUpload } from "./PatriotActDisclosure-ChZ_ePr2.js";
-import { a as useAddressCleanse, i as formatAddressForCleanse, n as formatDateObj, t as InputDate } from "./InputDate-Ci60MBrH.js";
-import { i as getPrefixedFieldProps } from "./getProps-DVqK7eRw.js";
-import { t as formatValidationError } from "./formatValidationError-BHvKLMYZ.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-C9MbL5XV.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 LegalEntityTypes.SOLE_PROPRIETORSHIP: 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 LegalEntityTypes.UNINCORPORATED_PARTNERSHIP: 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 LegalEntityTypes.SOLE_PROPRIETORSHIP: return "constitutionalDocumentSoleProprietorshipHeaderDescription";
-		case LegalEntityTypes.TRUST: return "constitutionalDocumentTrustHeaderDescription";
-		case LegalEntityTypes.UNINCORPORATED_PARTNERSHIP: return "constitutionalDocumentUnincorporatedPartnershipDescription";
-		default: return "constitutionalDocumentHeaderDescription";
-	}
-}
-var unincorporatedPartnershipRequirementsVariants = [
-	"Name",
-	"Details",
-	"UpToDate"
-];
-function ConstitutionalDocumentUpload({ id, legalEntityType, ...props }) {
-	const { t } = useTranslation(["common"]);
-	const isUnincorporatedPartnership = legalEntityType === LegalEntityTypes.UNINCORPORATED_PARTNERSHIP;
-	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 };