@adyen/kyc-components 4.0.0-beta.5 → 4.0.0-beta.7

package/dist/TaxInformationField-Cc4iBLBk.js

@@ -0,0 +1,3062 @@
+;
+{
+  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] = "2faa1728-14bc-4cb2-bc6a-091c71d19c5d", e._sentryDebugIdIdentifier = "sentry-dbid-2faa1728-14bc-4cb2-bc6a-091c71d19c5d");
+  } catch (e) {
+  }
+}
+;
+import { bx as getNestedPropertyKeys, af as objectsDeepEqual, a as useTranslation, c as useLegalEntity, R as ROOT_LE, a8 as CountryCodes, y as LegalEntityTypes, M as TaskTypes, aD as keysOf, X as useExperimentsContext } from "./StoreProvider-_YW7glEh.js";
+import { jsxs, jsx, Fragment } from "preact/jsx-runtime";
+import { memo } from "preact/compat";
+import { useState, useRef, useEffect, useCallback, useMemo } from "preact/hooks";
+import { a as useForm, F as Field, c as Select, C as Checkbox } from "./useForm-C66YXYZG.js";
+import { c as createFormUtils, F as FormHeader, E as ErrorPanel } from "./CountryField-ziRVRc5r.js";
+import { T as TextArea, f as validatePatternOnBlur, c as validateNotEmptyOnBlur, a as useAccountHolder } from "./fieldConfigurations-Bct_fXIF.js";
+import { S as StateContextSetter } from "./validate-ZwWxhap7.js";
+import { D as DocumentGuidance, u as uppercase } from "./mapExistingFile-qQ4y79Lm.js";
+import { D as Dropzone } from "./Dropzone-DwdkWB-s.js";
+import { C as CompanyTypesValues } from "./bafinUtils-DJvocoVP.js";
+import { m as makeMask, n as numericInputs, a as nonInputs, d as alphanumericInputs, c as customInputs, b as alphaInputs, s as spacer, M as MaskedInput } from "./MaskedInput-CMGa4-AZ.js";
+import { C as COUNTRIES_WITH_STATES_DATASET } from "./utils-DgGLUM4O.js";
+import { c as createFormRules } from "./form-rules-DhbF2mY4.js";
+import { i as isDateOlderThanAYear } from "./Address-BxCJg97r.js";
+import { R as RadioGroup } from "./RadioGroup-CnXRr_Ap.js";
+const getFieldsWithExistingData = (legalEntity, keyMapping, documentMapping, knownProblematicFields = []) => {
+  const apiFieldsWithExistingData = getNestedPropertyKeys(legalEntity);
+  const nonDocumentFields = apiFieldsWithExistingData.map((field) => keyMapping[field]).filter(Boolean).filter((field) => !knownProblematicFields.includes(field));
+  if (documentMapping && legalEntity.documentDetails?.length) {
+    const documentFields = legalEntity.documentDetails.map((document) => documentMapping[document.type]).filter(Boolean);
+    return [...nonDocumentFields, ...documentFields];
+  }
+  return nonDocumentFields;
+};
+const descriptionField = "adyen-kyc-description-field";
+const styles = {
+  descriptionField
+};
+const DESCRIPTION_CHARACTERS_LIMIT = 200;
+function DocumentUpload({
+  documentType,
+  documentField,
+  guidanceHeader,
+  documentTypeSelect,
+  guidanceContent,
+  handleFieldChange,
+  requiredFields,
+  data: dataProp,
+  valid: validProp,
+  errors: errorProp,
+  fieldValidationErrors: propFieldValidationErrors,
+  supportsMultipleUploads,
+  maxNumberOfFiles = 1,
+  label,
+  extraDropzoneDescription,
+  hidePageCount,
+  ...props
+}) {
+  const { t } = useTranslation("common");
+  const [document, setDocument] = useState();
+  const form = useForm({
+    ...props,
+    schema: ["description"],
+    defaultData: dataProp,
+    rules: props.validators,
+    fieldProblems: propFieldValidationErrors
+  });
+  const { handleChangeFor, triggerValidation, setData } = form;
+  let { data, errors, valid, fieldProblems } = form;
+  const formUtils = createFormUtils(props, t);
+  const stateRef = useRef({ setState: null });
+  const isOptional = !(props?.formVerificationErrors && Object.keys(props?.formVerificationErrors)?.length === 0);
+  useEffect(() => {
+    if (isOptional) {
+      triggerValidation();
+    }
+  }, [dataProp]);
+  useEffect(() => {
+    stateRef.current.setState?.({
+      type: "addToState",
+      value: {
+        data,
+        valid,
+        errors,
+        fieldProblems,
+        dataStoreId: props.id,
+        schema: requiredFields
+      }
+    });
+  }, [data, valid, errors, fieldProblems]);
+  useEffect(() => {
+    setDocument({
+      [documentField]: dataProp?.[documentField]
+    });
+    setData("description", dataProp?.description);
+    triggerValidation();
+  }, [dataProp]);
+  if (handleFieldChange && requiredFields && propFieldValidationErrors) {
+    data = dataProp ?? {};
+    errors = errorProp;
+    valid = validProp;
+    fieldProblems = propFieldValidationErrors;
+  }
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `adyen-kyc-company-document-upload adyen-kyc-company-document-upload--${documentField}`,
+      children: [
+        /* @__PURE__ */ jsx(StateContextSetter, { owner: props.id, stateRef }),
+        /* @__PURE__ */ jsx(FormHeader, { heading: props.heading, description: props.description }),
+        /* @__PURE__ */ jsx(
+          ErrorPanel,
+          {
+            verificationErrors: props?.formVerificationErrors,
+            validationErrors: propFieldValidationErrors,
+            formUtils,
+            id: "ariaErrorField"
+          }
+        ),
+        formUtils.isRequiredField(documentField) && /* @__PURE__ */ jsxs(Fragment, { children: [
+          guidanceHeader,
+          documentTypeSelect && /* @__PURE__ */ jsx(Field, { name: "documentType", label: t(($) => $["selectDocumentType"]), children: (childProps) => /* @__PURE__ */ jsx(
+            Select,
+            {
+              ...childProps,
+              onChange: (e) => documentTypeSelect.setSelectedType(e.target.value),
+              name: "documentType",
+              placeholder: t(($) => $["selectDocument"]),
+              selected: documentTypeSelect.selectedType,
+              items: documentTypeSelect.options.map(({ id, name }) => ({
+                id,
+                name: t(($) => $[name])
+              }))
+            }
+          ) }),
+          /* @__PURE__ */ jsx("div", { children: guidanceContent }),
+          /* @__PURE__ */ jsx(DocumentGuidance, { type: documentType, className: "adyen-kyc-u-margin-bottom-24" }),
+          /* @__PURE__ */ jsx(
+            Dropzone,
+            {
+              defaultData: document ?? data,
+              id: props.id,
+              isOptional: isOptional || formUtils.isOptionalField(documentField),
+              maxSize: documentType === "constitutionalDocument" ? 31457280 : void 0,
+              name: documentField,
+              shouldValidate: props.shouldValidate,
+              handleFieldChange,
+              errors,
+              fieldValidationErrors: fieldProblems,
+              valid,
+              multiple: supportsMultipleUploads,
+              maxNumberOfFiles: maxNumberOfFiles ?? 1,
+              label,
+              extraDropzoneDescription,
+              hidePageCount
+            }
+          )
+        ] }),
+        formUtils.isRequiredField("description") && /* @__PURE__ */ jsx("div", { className: styles.descriptionField, children: /* @__PURE__ */ jsx(
+          Field,
+          {
+            name: "description",
+            label: formUtils.getLabel("descriptionOptional"),
+            errorMessage: formUtils.getErrorMessage("description", errors, fieldProblems),
+            isValid: valid.description,
+            children: (childProps) => /* @__PURE__ */ jsx(
+              TextArea,
+              {
+                ...childProps,
+                name: "description",
+                value: data.description,
+                maxLength: DESCRIPTION_CHARACTERS_LIMIT,
+                onInput: handleChangeFor("description"),
+                "aria-invalid": !valid.description,
+                handleFieldChange: handleFieldChange?.("description"),
+                errors,
+                fieldValidationErrors: fieldProblems,
+                valid
+              }
+            )
+          }
+        ) })
+      ]
+    }
+  );
+}
+const MemoizedDocumentUpload = memo(
+  DocumentUpload,
+  (prevProps, nextProps) => prevProps.shouldValidate === nextProps.shouldValidate && objectsDeepEqual(prevProps.requiredFields, nextProps.requiredFields) && objectsDeepEqual(prevProps.errors, nextProps.errors) && objectsDeepEqual(prevProps.optionalFields, nextProps.optionalFields) && objectsDeepEqual(prevProps.data, nextProps.data) && objectsDeepEqual(prevProps.formVerificationErrors, nextProps.formVerificationErrors) && objectsDeepEqual(prevProps.fieldValidationErrors, nextProps.fieldValidationErrors) && objectsDeepEqual(prevProps.documentTypeSelect, nextProps.documentTypeSelect) && prevProps.documentField === nextProps.documentField && prevProps.name === nextProps.name && prevProps.country === nextProps.country && prevProps.companyType === nextProps.companyType
+);
+const useCapabilities = () => {
+  const { data: rootLegalEntity } = useLegalEntity(ROOT_LE);
+  return rootLegalEntity?.capabilities;
+};
+const companyRegistrationNumberOptions = {
+  [CountryCodes.Australia]: [
+    {
+      id: "incorporatedAssociationRegistrationNumber",
+      name: "incorporatedAssociationRegistrationNumber",
+      applicableOnlyFor: [CompanyTypesValues.INCORPORATED_ASSOCIATION]
+    },
+    { id: "australianBusinessNumberAcn", name: "australianBusinessNumberAcn" }
+  ],
+  [CountryCodes.Austria]: [
+    {
+      id: "firmenbuchnummer",
+      name: "firmenbuchnummer"
+    },
+    {
+      id: "ZVR",
+      name: "zentralesVereinsregisterId",
+      applicableOnlyFor: [
+        CompanyTypesValues.NON_PROFIT_OR_CHARITABLE,
+        CompanyTypesValues.INCORPORATED_ASSOCIATION
+      ]
+    }
+  ],
+  [CountryCodes.Croatia]: [
+    { id: "MBO", name: "MBO" },
+    { id: "MBS", name: "MBS" }
+  ],
+  [CountryCodes.France]: [
+    {
+      id: "SIRET",
+      name: "siret"
+    },
+    {
+      id: "RNA",
+      name: "rnaNumber",
+      applicableOnlyFor: [CompanyTypesValues.NON_PROFIT_OR_CHARITABLE]
+    }
+  ],
+  [CountryCodes.Hungary]: [
+    {
+      id: "nyilvantartasiSzam",
+      name: "huRegistrationNumberForSoleProp",
+      applicableOnlyFor: [CompanyTypesValues.SOLE_PROPRIETORSHIP]
+    }
+  ],
+  [CountryCodes.Italy]: [
+    {
+      id: "partitaIVA",
+      name: "codiceFiscalePartitaIVA"
+    },
+    {
+      id: "CCIAA",
+      name: "CCIAA"
+    }
+  ],
+  [CountryCodes.Monaco]: [
+    {
+      id: "mcRegistrationNumberSoleProp",
+      name: "mcRegistrationNumberSoleProp",
+      applicableOnlyFor: [CompanyTypesValues.SOLE_PROPRIETORSHIP]
+    },
+    {
+      id: "mcRegistrationNumber",
+      name: "mcRegistrationNumber",
+      applicableOnlyFor: [
+        CompanyTypesValues.PRIVATE_COMPANY,
+        CompanyTypesValues.GOVERNMENTAL_ORGANIZATION,
+        CompanyTypesValues.INCORPORATED_ASSOCIATION,
+        CompanyTypesValues.INCORPORATED_PARTNERSHIP,
+        CompanyTypesValues.NON_PROFIT_OR_CHARITABLE,
+        CompanyTypesValues.UNINCORPORATED_PARTNERSHIP,
+        CompanyTypesValues.UNLISTED_PUBLIC_COMPANY
+      ]
+    }
+  ],
+  [CountryCodes.NewZealand]: [
+    {
+      id: "NZBN",
+      name: "NZBN"
+    },
+    {
+      id: "companyNumberNZ",
+      name: "companyNumberNZ",
+      applicableOnlyFor: [
+        CompanyTypesValues.PRIVATE_COMPANY,
+        CompanyTypesValues.PUBLIC_COMPANY,
+        CompanyTypesValues.UNLISTED_PUBLIC_COMPANY
+      ]
+    }
+  ],
+  [CountryCodes.Romania]: [
+    {
+      id: "roRegNumberNewFormat",
+      name: "roRegNumberNewFormat_label"
+    },
+    {
+      id: "roRegNumberOldFormat",
+      name: "roRegNumberOldFormat_label"
+    }
+  ],
+  [CountryCodes.Poland]: [
+    {
+      id: "regon",
+      name: "regon"
+    },
+    {
+      id: "krsNumber",
+      name: "krsNumber"
+    }
+  ],
+  [CountryCodes.UnitedKingdom]: [
+    {
+      id: "charity",
+      name: "charityNumber",
+      applicableOnlyFor: [CompanyTypesValues.NON_PROFIT_OR_CHARITABLE]
+    },
+    {
+      id: "companyNumber",
+      name: "companyNumber",
+      applicableOnlyFor: [
+        CompanyTypesValues.PRIVATE_COMPANY,
+        CompanyTypesValues.GOVERNMENTAL_ORGANIZATION,
+        CompanyTypesValues.INCORPORATED_ASSOCIATION,
+        CompanyTypesValues.INCORPORATED_PARTNERSHIP,
+        CompanyTypesValues.NON_PROFIT_OR_CHARITABLE,
+        CompanyTypesValues.UNINCORPORATED_PARTNERSHIP,
+        CompanyTypesValues.UNLISTED_PUBLIC_COMPANY,
+        CompanyTypesValues.PUBLIC_COMPANY
+      ]
+    }
+  ]
+};
+const getCompanyRegistrationNumberOptions = (country, companyType) => {
+  const optionsForCountry = companyRegistrationNumberOptions[country];
+  if (!companyType || !optionsForCountry) return optionsForCountry;
+  return optionsForCountry.filter(
+    (option) => option.applicableOnlyFor?.includes(companyType) ?? true
+  );
+};
+const individualIdNumberOptions = {
+  [CountryCodes.Spain]: [
+    {
+      id: "dni",
+      name: "dni"
+    },
+    {
+      id: "nie",
+      name: "nie"
+    }
+  ]
+};
+const additionallIdNumberOptions = {
+  [CountryCodes.NewZealand]: [
+    {
+      id: "driversLicense",
+      name: "driversLicense"
+    },
+    {
+      id: "passport",
+      name: "passportNumber"
+    }
+  ],
+  [CountryCodes.HongKong]: [
+    {
+      id: "proofOfIdentityCard",
+      name: "stateIssuedProofOfIdentityCard"
+    },
+    {
+      id: "driversLicense",
+      name: "driversLicense"
+    },
+    {
+      id: "passport",
+      name: "passportNumber"
+    }
+  ],
+  [CountryCodes.Australia]: [
+    {
+      id: "driversLicense",
+      name: "driversLicense"
+    },
+    {
+      id: "passport",
+      name: "passportNumber"
+    }
+  ]
+};
+const taxIdNumberOptions = {
+  [CountryCodes.Australia]: [
+    {
+      id: "ABN",
+      name: "australianBusinessNumberAbn"
+    }
+  ],
+  [CountryCodes.Belgium]: [
+    {
+      id: "BUSINESS_NUMMER",
+      name: "businessNumber",
+      applicableOnlyFor: [
+        CompanyTypesValues.SOLE_PROPRIETORSHIP,
+        CompanyTypesValues.PRIVATE_COMPANY,
+        CompanyTypesValues.GOVERNMENTAL_ORGANIZATION,
+        CompanyTypesValues.INCORPORATED_ASSOCIATION,
+        CompanyTypesValues.INCORPORATED_PARTNERSHIP,
+        CompanyTypesValues.NON_PROFIT_OR_CHARITABLE,
+        CompanyTypesValues.UNINCORPORATED_PARTNERSHIP,
+        CompanyTypesValues.UNLISTED_PUBLIC_COMPANY
+      ]
+    },
+    {
+      id: "NUMERO_NATIONAL",
+      name: "taxInformationNumber__BE_Individual",
+      applicableOnlyFor: [LegalEntityTypes.INDIVIDUAL]
+    }
+  ],
+  [CountryCodes.Brazil]: [{ id: "CNPJ", name: "CNPJ" }],
+  [CountryCodes.Canada]: [{ id: "BUSINESS_NUMBER", name: "businessNumber" }],
+  [CountryCodes.Germany]: [
+    {
+      id: "STEUERNUMMER",
+      name: "taxInformationNumber__DE",
+      applicableOnlyFor: [
+        CompanyTypesValues.SOLE_PROPRIETORSHIP,
+        CompanyTypesValues.PRIVATE_COMPANY,
+        CompanyTypesValues.GOVERNMENTAL_ORGANIZATION,
+        CompanyTypesValues.INCORPORATED_ASSOCIATION,
+        CompanyTypesValues.INCORPORATED_PARTNERSHIP,
+        CompanyTypesValues.NON_PROFIT_OR_CHARITABLE,
+        CompanyTypesValues.UNINCORPORATED_PARTNERSHIP,
+        CompanyTypesValues.UNLISTED_PUBLIC_COMPANY
+      ]
+    },
+    {
+      id: "IDNR",
+      name: "taxInformationNumber__DE_Individual",
+      applicableOnlyFor: [LegalEntityTypes.INDIVIDUAL]
+    }
+  ],
+  [CountryCodes.Gibraltar]: [
+    { id: "GI_TAXPAYER_REFERENCE_NUMBER", name: "taxpayerReferenceNumber" }
+  ],
+  [CountryCodes.Guernsey]: [
+    { id: "GG_REGISTRATION_NUMBER", name: "taxInformationNumber" },
+    {
+      id: "TIN_GG",
+      name: "nationalInsuranceNumber",
+      applicableOnlyFor: [CompanyTypesValues.SOLE_PROPRIETORSHIP]
+    }
+  ],
+  [CountryCodes.HongKong]: [
+    {
+      id: "BRN",
+      name: "taxInformationNumber__HK"
+    }
+  ],
+  [CountryCodes.Ireland]: [
+    {
+      id: "TRN",
+      name: "trnNumber",
+      applicableOnlyFor: [CompanyTypesValues.UNINCORPORATED_PARTNERSHIP]
+    }
+  ],
+  [CountryCodes.IsleOfMan]: [{ id: "IM_TAX_REFERENCE_NUMBER", name: "taxReferenceNumber" }],
+  [CountryCodes.Japan]: [{ id: "CORPORATE_NUMBER", name: "taxInformationNumber" }],
+  [CountryCodes.Jersey]: [
+    {
+      id: "TIN_JE",
+      name: "taxIdentificationNumber"
+    },
+    {
+      id: "SSN",
+      name: "socialSecurityNumber",
+      applicableOnlyFor: [CompanyTypesValues.SOLE_PROPRIETORSHIP]
+    }
+  ],
+  [CountryCodes.Netherlands]: [
+    {
+      id: "RSIN",
+      name: "rsinNumber",
+      applicableOnlyFor: [
+        CompanyTypesValues.PRIVATE_COMPANY,
+        CompanyTypesValues.GOVERNMENTAL_ORGANIZATION,
+        CompanyTypesValues.INCORPORATED_ASSOCIATION,
+        CompanyTypesValues.INCORPORATED_PARTNERSHIP,
+        CompanyTypesValues.NON_PROFIT_OR_CHARITABLE,
+        CompanyTypesValues.UNINCORPORATED_PARTNERSHIP,
+        CompanyTypesValues.UNLISTED_PUBLIC_COMPANY
+      ]
+    },
+    {
+      id: "BSN",
+      name: "bsnNumber",
+      applicableOnlyFor: [LegalEntityTypes.INDIVIDUAL]
+    }
+  ],
+  [CountryCodes.NewZealand]: [
+    {
+      id: "IRD",
+      name: "irdNumber"
+    }
+  ],
+  [CountryCodes.PuertoRico]: [
+    {
+      id: "EIN",
+      name: "ein"
+    }
+  ],
+  [CountryCodes.Singapore]: [
+    {
+      id: "GST",
+      name: "gst"
+    },
+    {
+      id: "UEN",
+      name: "uen"
+    }
+  ],
+  [CountryCodes.Spain]: [
+    {
+      id: "dni",
+      name: "dni",
+      applicableOnlyFor: [LegalEntityTypes.INDIVIDUAL]
+    },
+    {
+      id: "nie",
+      name: "nie",
+      applicableOnlyFor: [LegalEntityTypes.INDIVIDUAL]
+    }
+  ],
+  [CountryCodes.UnitedKingdom]: [
+    {
+      id: "UTR",
+      name: "utr"
+    },
+    {
+      id: "NINO",
+      name: "nationalInsuranceNumber",
+      applicableOnlyFor: [LegalEntityTypes.INDIVIDUAL]
+    }
+  ],
+  [CountryCodes.UnitedStates]: [
+    {
+      id: "EIN",
+      name: "ein"
+    }
+  ]
+};
+const 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" }]
+};
+const getTaxIdNumberOptions = (country, companyType) => {
+  const optionsForCountry = taxIdNumberOptions[country];
+  if (!companyType || !optionsForCountry) return optionsForCountry;
+  return optionsForCountry.filter(
+    (option) => option.applicableOnlyFor?.includes(companyType) ?? true
+  );
+};
+const getVatNumberOptions = (country, companyType) => {
+  const optionsForCountry = vatNumberOptions[country];
+  if (!companyType || !optionsForCountry) return optionsForCountry;
+  return optionsForCountry.filter(
+    (option) => option.applicableOnlyFor?.includes(companyType) ?? true
+  );
+};
+const 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"
+};
+const 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))
+    },
+    [CompanyTypesValues.SOLE_PROPRIETORSHIP]: {
+      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.Mexico]: { default: { mask: makeMask(...alphanumericInputs(12)) } },
+  [CountryCodes.Monaco]: {
+    default: {
+      mask: makeMask(...alphanumericInputs(8), ...alphanumericInputs(3, true)),
+      transformOnType: uppercase
+    },
+    [CompanyTypesValues.SOLE_PROPRIETORSHIP]: {
+      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
+    },
+    default: {
+      mask: makeMask(...numericInputs(9)),
+      transformOnType: uppercase
+    }
+  }
+};
+const 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"
+    }
+  },
+  default: {
+    key: "enterNDigitsForExample",
+    values: {
+      numDigits: "9",
+      example: "123456789"
+    }
+  }
+};
+const 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.Mexico]: { default: /^\D{3}\d{6}\w{3}$/ },
+  [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}$/,
+    default: /^\d{9}$/
+  }
+};
+const taxInformationDefaultFieldMetadata = {
+  label: "taxId"
+};
+const exemptedFromTaxDefaultFieldMetadata = {
+  label: "iDontHaveATaxId"
+};
+const mapValidators = (validators, country) => {
+  return 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;
+      }
+    })
+  );
+};
+const taxInformationDefaultFieldConfig = {
+  [CountryCodes.Australia]: {
+    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.Belgium]: ({ companyType }) => {
+    switch (companyType) {
+      case LegalEntityTypes.INDIVIDUAL:
+        return {
+          label: "taxInformationNumber__BE_Individual",
+          placeholder: "taxInformationNumber__placeHolder__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",
+          placeholder: "taxInformationNumber__placeHolder__BE",
+          validators: mapValidators([validatePatternOnBlur(/^\d{10}$/)], CountryCodes.Belgium),
+          mask: { mask: makeMask(...numericInputs(10)) },
+          guidanceText: {
+            key: "validationPleaseEnterAValidIdNumberWithExample",
+            values: {
+              example: "0123321123",
+              idType: "Business nummer"
+            }
+          }
+        };
+    }
+  },
+  [CountryCodes.Canada]: {
+    label: "businessNumber",
+    validators: mapValidators([validatePatternOnBlur(/^\d{9}$/)], CountryCodes.Canada),
+    mask: { mask: makeMask(...numericInputs(9)) },
+    guidanceText: {
+      key: "enterNDigitsForExample",
+      values: {
+        numDigits: "9",
+        example: "123456789"
+      }
+    }
+  },
+  [CountryCodes.France]: {
+    label: "taxInformationNumber__FR",
+    placeholder: "taxInformationNumber__placeHolder__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]: ({ companyType }) => {
+    switch (companyType) {
+      case LegalEntityTypes.INDIVIDUAL:
+        return {
+          label: "taxInformationNumber__DE_Individual",
+          placeholder: "taxInformationNumber__placeHolder__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",
+          placeholder: "taxInformationNumber__placeHolder__DE",
+          validators: mapValidators([validatePatternOnBlur(/^\d{10,11}$/)], CountryCodes.Germany),
+          mask: { mask: makeMask(...numericInputs(11)) },
+          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.Guernsey]: ({ companyType }) => {
+    switch (companyType) {
+      case CompanyTypesValues.SOLE_PROPRIETORSHIP:
+        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]: {
+    label: "taxInformationNumber__HK",
+    validators: mapValidators([validatePatternOnBlur(/^\d{8}$/)], CountryCodes.HongKong),
+    mask: { mask: makeMask(...numericInputs(8)) },
+    guidanceText: {
+      key: "enterNDigitsForExample",
+      values: {
+        numDigits: "8",
+        example: "70569713"
+      }
+    }
+  },
+  [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"
+            }
+          }
+        };
+      case "TIN_JE":
+      default:
+        switch (companyType) {
+          case CompanyTypesValues.SOLE_PROPRIETORSHIP:
+            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.Ireland]: {
+    label: "trnNumber",
+    validators: mapValidators(
+      [validatePatternOnBlur(/^(\d{7})([a-zA-Z])([a-zA-Z]?)$/)],
+      CountryCodes.Ireland
+    ),
+    mask: {
+      mask: makeMask(...numericInputs(7), ...alphaInputs(1), ...alphaInputs(1, true))
+    },
+    guidanceText: {
+      key: "enterXDigitsThenXToYLettersForExample",
+      values: {
+        numDigits: "7",
+        minLetters: "1",
+        maxLetters: "2",
+        example: "1497955KA"
+      }
+    }
+  },
+  [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.Netherlands]: ({ companyType }) => {
+    switch (companyType) {
+      case LegalEntityTypes.INDIVIDUAL:
+        return {
+          label: "bsnNumber",
+          placeholder: "taxInformationNumber__placeHolder__NL",
+          validators: mapValidators([validatePatternOnBlur(/^\d{9}$/)], CountryCodes.Netherlands),
+          mask: { mask: makeMask(...numericInputs(9)) },
+          guidanceText: {
+            key: "validationPleaseEnterAValidIdNumberWithExample",
+            values: {
+              example: "999999999",
+              idType: "BSN"
+            }
+          }
+        };
+      default:
+        return {
+          label: "rsinNumber",
+          placeholder: "taxInformationNumber__placeHolder__NL",
+          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"
+      }
+    }
+  },
+  // Special case for SG in which we also save the registration number as the TaxID if that selection has been made
+  [CountryCodes.Singapore]: {
+    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.PuertoRico]: {
+    // should exactly match CountryCodes.UnitedStates
+    label: "taxInformationNumber__US",
+    helperText: "taxInformationNumber__helperText__US",
+    placeholder: "taxInformationNumber__placeHolder__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.UnitedKingdom]: ({ taxIdNumberType, companyType }) => {
+    switch (companyType) {
+      case LegalEntityTypes.INDIVIDUAL:
+        switch (taxIdNumberType) {
+          case "NINO":
+            return {
+              label: "nationalInsuranceNumber",
+              placeholder: "taxInformationNumber__placeHolder__GB",
+              validators: mapValidators(
+                [validatePatternOnBlur(/^[A-Z]{2}\d{6}[A-D]$/)],
+                CountryCodes.UnitedKingdom
+              ),
+              guidanceText: {
+                key: "validationPleaseEnterAValidIdNumberWithExample",
+                values: {
+                  example: "AA123456C",
+                  idType: "NINO"
+                }
+              }
+            };
+          default:
+            return {
+              label: "utr",
+              placeholder: "taxInformationNumber__placeHolder__GB",
+              validators: mapValidators(
+                [validatePatternOnBlur(/^\d{10}$/)],
+                CountryCodes.UnitedKingdom
+              ),
+              mask: { mask: makeMask(...numericInputs(10)) },
+              guidanceText: {
+                key: "validationPleaseEnterAValidIdNumberWithExample",
+                values: {
+                  example: "6669863459",
+                  idType: "UTR"
+                }
+              }
+            };
+        }
+      default:
+        return {
+          label: "utr",
+          placeholder: "taxInformationNumber__placeHolder__GB",
+          validators: mapValidators(
+            [validatePatternOnBlur(/^\d{10}$/)],
+            CountryCodes.UnitedKingdom
+          ),
+          mask: { mask: makeMask(...numericInputs(10)) },
+          guidanceText: {
+            key: "validationPleaseEnterAValidIdNumberWithExample",
+            values: {
+              example: "6669863459",
+              idType: "UTR"
+            }
+          }
+        };
+    }
+  },
+  [CountryCodes.UnitedStates]: {
+    label: "taxInformationNumber__US",
+    helperText: "taxInformationNumber__helperText__US",
+    placeholder: "taxInformationNumber__placeHolder__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.India]: {
+    validators: mapValidators([validatePatternOnBlur(/^[A-Z0-9]{15}$/)], CountryCodes.India)
+  },
+  [CountryCodes.Japan]: {
+    label: "taxInformationNumber__JP",
+    validators: mapValidators([validatePatternOnBlur(/^\d{13}$/)], CountryCodes.Japan)
+  },
+  [CountryCodes.Philippines]: {
+    validators: mapValidators([validatePatternOnBlur(/^\d{12}$/)], CountryCodes.Philippines)
+  }
+};
+const exemptedFromTaxDefaultFieldConfig = {
+  [CountryCodes.Australia]: {
+    label: "doNotHaveAbn"
+  }
+};
+const countryToTaxInfoTypeMap = {
+  US: "EIN",
+  AU: "ABN",
+  NZ: "IRD",
+  HK: "BRN",
+  SG: "GST"
+};
+const isFinancialInformationRequired = (isFinancialInformationExperimentEnabled, taskType, country, capabilities, legalEntityType) => {
+  const isOrganization = legalEntityType === LegalEntityTypes.ORGANIZATION;
+  if (!isFinancialInformationExperimentEnabled || !COUNTRIES_REQUIRING_FINANCIAL_INFORMATION.includes(country)) {
+    return void 0;
+  }
+  if (country === CountryCodes.UnitedKingdom && (taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY || taskType === TaskTypes.BUSINESS_DETAILS)) {
+    return "REQUIRED";
+  }
+  if (taskType === TaskTypes.BUSINESS_DETAILS && isOrganization) {
+    if (keysOf(capabilities ?? {}).some((capability) => capability === "issueBankAccount")) {
+      return "REQUIRED";
+    }
+  }
+  return void 0;
+};
+const COUNTRIES_THAT_DONT_REQUIRE_SOLE_PROP_REGISTRATION = [
+  CountryCodes.Australia,
+  CountryCodes.Gibraltar,
+  CountryCodes.Guernsey,
+  CountryCodes.HongKong,
+  CountryCodes.Ireland,
+  CountryCodes.IsleOfMan,
+  CountryCodes.Jersey,
+  CountryCodes.Malta,
+  CountryCodes.PuertoRico,
+  CountryCodes.Spain,
+  CountryCodes.UnitedKingdom,
+  CountryCodes.UnitedStates
+];
+const COUNTRIES_THAT_DONT_REQUIRE_COMPANY_REGISTRATION = [
+  CountryCodes.HongKong,
+  CountryCodes.PuertoRico,
+  CountryCodes.UnitedStates
+];
+const COUNTRIES_WITH_POSSIBLE_REGISTRATION_EXEMPTIONS_FOR_ORGANIZATIONS = [];
+const COUNTRIES_WITH_POSSIBLE_REGISTRATION_EXEMPTIONS_FOR_SOLE_PROPS = [
+  CountryCodes.Austria,
+  CountryCodes.Canada,
+  CountryCodes.Finland,
+  CountryCodes.Germany,
+  CountryCodes.Lithuania,
+  CountryCodes.Luxembourg,
+  CountryCodes.NewZealand,
+  CountryCodes.Poland,
+  CountryCodes.Sweden,
+  CountryCodes.Switzerland
+];
+const COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER = [
+  CountryCodes.Canada,
+  CountryCodes.UnitedStates
+];
+const 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
+];
+const COUNTRIES_THAT_DO_NOT_USE_TAX_ID_FOR_SOLE_PROP = [
+  CountryCodes.Singapore
+];
+const COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_COMPANIES = [
+  // strictly a subset of countries which use tax ID
+  // right now in all countries companies must provide a tax ID - but maybe there will be exemptions in future?
+];
+const COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_SOLE_PROPS = [
+  // strictly a subset of countries which use tax ID
+  CountryCodes.Canada,
+  CountryCodes.PuertoRico,
+  CountryCodes.UnitedStates
+];
+const COUNTRIES_THAT_REQUIRE_DATE_OF_INCORPORATION = [
+  CountryCodes.HongKong,
+  CountryCodes.Singapore
+];
+const COUNTRIES_THAT_USES_UEN_OR_GST = [CountryCodes.Singapore];
+const COUNTRIES_USING_COMPANY_SEARCH = [
+  CountryCodes.UnitedStates
+];
+const COUNTRY_OF_GOVERNING_LAW_POSSIBLE = [
+  CountryCodes.UnitedKingdom
+];
+const COUNTRIES_REQUIRING_FINANCIAL_INFORMATION = [
+  CountryCodes.UnitedKingdom,
+  CountryCodes.Netherlands,
+  CountryCodes.France,
+  CountryCodes.Germany,
+  CountryCodes.Spain,
+  CountryCodes.Belgium
+];
+const COUNTRIES_REQUIRING_E_INVOICING_CODE = [
+  /**
+   * @description These are the countries for which E-Invoicing code is a compliance requirement. There will be more in the future.
+   */
+  CountryCodes.Italy
+];
+const COUNTRIES_WITH_POSSIBLE_TRUSTEE_TAXID_ABSENT_V4 = [
+  CountryCodes.Australia
+];
+const TAX_ID_REQUIRED_COUNTRIES_ORGANIZATION = [
+  CountryCodes.UnitedKingdom,
+  CountryCodes.Netherlands,
+  CountryCodes.Germany,
+  CountryCodes.Belgium
+];
+const isRegistrationNumberAbsentStateV4Scenario = (country, entityType) => {
+  return country === CountryCodes.Australia && (entityType === CompanyTypesValues.GOVERNMENTAL_ORGANIZATION || entityType === CompanyTypesValues.INCORPORATED_PARTNERSHIP) || country === CountryCodes.NewZealand;
+};
+const rules = ({
+  data,
+  country,
+  taskType,
+  isExperimentEnabled = () => false,
+  accountHolder,
+  rootLegalEntity,
+  tinMatched
+}) => {
+  const countryRequiresDateOfIncorporationForCompanies = () => {
+    if (COUNTRIES_THAT_REQUIRE_DATE_OF_INCORPORATION.includes(country)) {
+      return "REQUIRED";
+    }
+  };
+  const countryRequiresFinancialInformation = () => {
+    if (isExperimentEnabled("EnableFinancialInformationComponentV4") && COUNTRIES_REQUIRING_FINANCIAL_INFORMATION.includes(country)) {
+      const isFinancialInformationExperimentEnabled = isExperimentEnabled(
+        "EnableFinancialInformationComponentV4"
+      );
+      const leType = rootLegalEntity?.type;
+      return isFinancialInformationRequired(
+        isFinancialInformationExperimentEnabled,
+        taskType,
+        country,
+        rootLegalEntity?.capabilities,
+        leType
+      );
+    }
+  };
+  return createFormRules({
+    requireDoingBusinessAsName: () => {
+      if (isExperimentEnabled("EnableBusinessDetailsMultiForm")) {
+        return data.additionalInformation?.hasDoingBusinessAs ? "REQUIRED" : void 0;
+      }
+    },
+    countryRequiresStateOrProvince: () => {
+      if (COUNTRIES_WITH_STATES_DATASET.includes(country)) {
+        return "REQUIRED";
+      }
+    },
+    ifPubliclyTradedCompany: () => {
+      if (data.companyStructure?.entityType === CompanyTypesValues.PUBLIC_COMPANY) {
+        return "REQUIRED";
+      }
+    },
+    countryUsesVat: () => {
+      if (!COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT.includes(country)) {
+        return Boolean(data.additionalInformation?.exemptedFromVat) === true ? "OPTIONAL" : "REQUIRED";
+      }
+    },
+    vatNumberType: () => {
+      if (!COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT.includes(country)) {
+        return "OPTIONAL";
+      }
+    },
+    isVatExempt: () => {
+      if (!COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT.includes(country)) {
+        return Boolean(data.additionalInformation?.exemptedFromVat) === true ? "REQUIRED" : "OPTIONAL";
+      }
+    },
+    countryUsesTaxId: () => {
+      const isExemptFromTax = Boolean(
+        data.basicInformation?.exemptedFromTax ?? data.additionalInformation?.exemptedFromTax
+      );
+      if (isExperimentEnabled("EnableTaxIdRequiredForBusinessAccountsScenarios") && TAX_ID_REQUIRED_COUNTRIES_ORGANIZATION.includes(country) && rootLegalEntity?.type === "organization" && // SOE-5931 - TODO: investigate L scenario returned to show this on the backend
+      keysOf(rootLegalEntity?.capabilities ?? {}).includes("issueBankAccount")) {
+        return isExemptFromTax ? "OPTIONAL" : "REQUIRED";
+      }
+      if (COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT.includes(country) && !(taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY && COUNTRIES_THAT_DO_NOT_USE_TAX_ID_FOR_SOLE_PROP.includes(country))) {
+        return isExemptFromTax ? "OPTIONAL" : "REQUIRED";
+      }
+    },
+    companyRegistrationNumberExemptionAllowed: () => {
+      const isExemptFromRegistrationNumber = Boolean(
+        data.basicInformation?.exemptedFromRegistrationNumber ?? data.additionalInformation?.exemptedFromRegistrationNumber
+      );
+      if (isExperimentEnabled("EnableRegistrationAndTaxAbsentStatesV4") && isRegistrationNumberAbsentStateV4Scenario(country, data.companyStructure?.entityType)) {
+        return isExemptFromRegistrationNumber ? "REQUIRED" : "OPTIONAL";
+      }
+      switch (taskType) {
+        case TaskTypes.SOLE_PROPRIETOR_COMPANY: {
+          if (!COUNTRIES_WITH_POSSIBLE_REGISTRATION_EXEMPTIONS_FOR_SOLE_PROPS.includes(country))
+            return;
+          return isExemptFromRegistrationNumber ? "REQUIRED" : "OPTIONAL";
+        }
+        default: {
+          switch (country) {
+            case CountryCodes.Germany: {
+              if (data.companyStructure?.entityType === CompanyTypesValues.GOVERNMENTAL_ORGANIZATION || data.companyStructure?.entityType === CompanyTypesValues.NON_PROFIT_OR_CHARITABLE) {
+                return isExemptFromRegistrationNumber ? "REQUIRED" : "OPTIONAL";
+              }
+              return;
+            }
+            case CountryCodes.Denmark: {
+              if (data.companyStructure?.entityType === CompanyTypesValues.NON_PROFIT_OR_CHARITABLE) {
+                return isExemptFromRegistrationNumber ? "REQUIRED" : "OPTIONAL";
+              }
+              return;
+            }
+            default: {
+              if (!COUNTRIES_WITH_POSSIBLE_REGISTRATION_EXEMPTIONS_FOR_ORGANIZATIONS.includes(country))
+                return;
+              return isExemptFromRegistrationNumber ? "REQUIRED" : "OPTIONAL";
+            }
+          }
+        }
+      }
+    },
+    countryOfGoverningLawRequired: () => {
+      if (isExperimentEnabled("EnableCountryOfGoverningLawForUKCompanies") && COUNTRY_OF_GOVERNING_LAW_POSSIBLE.includes(data.basicInformation?.country)) {
+        return "REQUIRED";
+      }
+    },
+    countryRequiresRegistrationNumber: () => {
+      const isExemptFromRegistrationNumber = Boolean(
+        data.basicInformation?.exemptedFromRegistrationNumber ?? data.additionalInformation?.exemptedFromRegistrationNumber
+      );
+      switch (taskType) {
+        case TaskTypes.SOLE_PROPRIETOR_COMPANY: {
+          if (COUNTRIES_THAT_DONT_REQUIRE_SOLE_PROP_REGISTRATION.includes(country)) return;
+          return isExemptFromRegistrationNumber ? "OPTIONAL" : "REQUIRED";
+        }
+        default: {
+          if (COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER.includes(country)) {
+            return "OPTIONAL";
+          }
+          if (!COUNTRIES_THAT_DONT_REQUIRE_COMPANY_REGISTRATION.includes(country)) {
+            return isExemptFromRegistrationNumber ? "OPTIONAL" : "REQUIRED";
+          }
+        }
+      }
+    },
+    registrationNumberType: () => {
+      switch (taskType) {
+        case TaskTypes.SOLE_PROPRIETOR_COMPANY: {
+          if (COUNTRIES_THAT_DONT_REQUIRE_SOLE_PROP_REGISTRATION.includes(country)) return;
+          return "OPTIONAL";
+        }
+        default: {
+          if (COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER.includes(country)) {
+            return "OPTIONAL";
+          }
+          if (COUNTRIES_THAT_DONT_REQUIRE_COMPANY_REGISTRATION.includes(country)) return;
+          return "OPTIONAL";
+        }
+      }
+    },
+    countryUsesUenOrGst: () => {
+      if (taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY) {
+        return;
+      }
+      if (COUNTRIES_THAT_USES_UEN_OR_GST.includes(country)) {
+        return "REQUIRED";
+      }
+    },
+    countryHasTaxExemptions: () => {
+      const isExemptFromTax = Boolean(
+        data.basicInformation?.exemptedFromTax ?? data.additionalInformation?.exemptedFromTax
+      );
+      switch (taskType) {
+        case TaskTypes.SOLE_PROPRIETOR_COMPANY: {
+          if (!COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_SOLE_PROPS.includes(country)) return;
+          return isExemptFromTax ? "REQUIRED" : "OPTIONAL";
+        }
+        default: {
+          if (isExperimentEnabled("EnableRegistrationAndTaxAbsentStatesV4") && COUNTRIES_WITH_POSSIBLE_TRUSTEE_TAXID_ABSENT_V4.includes(country) && accountHolder === "aTrust") {
+            return isExemptFromTax ? "REQUIRED" : "OPTIONAL";
+          }
+          if (COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_COMPANIES.includes(country)) {
+            return isExemptFromTax ? "REQUIRED" : "OPTIONAL";
+          }
+        }
+      }
+    },
+    countryUsingCompanySearch: () => {
+      if (taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY) {
+        return;
+      }
+      if (COUNTRIES_USING_COMPANY_SEARCH.includes(country)) {
+        return "REQUIRED";
+      }
+    },
+    countryRequiresFinancialInformation,
+    isDateOfIncorporationRequired: () => {
+      if (isExperimentEnabled("EnableIncorporationDateBasedFinancialValidationForHO")) {
+        return countryRequiresDateOfIncorporationForCompanies() || countryRequiresFinancialInformation();
+      }
+      return countryRequiresDateOfIncorporationForCompanies();
+    },
+    isFinancialReportingFieldsRequired: () => {
+      if (isExperimentEnabled("EnableIncorporationDateBasedFinancialValidationForHO")) {
+        return countryRequiresFinancialInformation() === "REQUIRED" && isDateOlderThanAYear(data.additionalInformation?.dateOfIncorporation) ? "REQUIRED" : void 0;
+      }
+      return countryRequiresFinancialInformation();
+    },
+    annualTurnoverRequired: () => {
+      if (isExperimentEnabled("EnableBusinessDetailsMultiForm") && data.companyFinancialInformation?.reportedValueOption === "annualTurnover") {
+        return "REQUIRED";
+      }
+    },
+    netAssetsRequired: () => {
+      if (isExperimentEnabled("EnableBusinessDetailsMultiForm") && data.companyFinancialInformation?.reportedValueOption === "netAssets") {
+        return "REQUIRED";
+      }
+    },
+    balanceSheetTotalRequired: () => {
+      if (isExperimentEnabled("EnableBusinessDetailsMultiForm") && data.companyFinancialInformation?.reportedValueOption === "balanceSheetTotal") {
+        return "REQUIRED";
+      }
+    },
+    isEInvoicingCodeEnabled: () => {
+      if (isExperimentEnabled("EnableEInvoicingCodeField") && COUNTRIES_REQUIRING_E_INVOICING_CODE.includes(country)) {
+        return "REQUIRED";
+      }
+    },
+    ifCountryUsAndTinFailed: () => {
+      if (taskType === TaskTypes.SOLE_PROPRIETOR_COMPANY) {
+        return;
+      }
+      if (tinMatched === false && country === CountryCodes.UnitedStates) {
+        return "REQUIRED";
+      }
+    },
+    businessRequiresCompanyType: () => {
+      if (taskType !== TaskTypes.SOLE_PROPRIETOR_COMPANY) {
+        return "REQUIRED";
+      }
+    },
+    japaneseLegalCompanyName: () => {
+      if (country === CountryCodes.Japan) {
+        return "REQUIRED";
+      }
+    },
+    requireBusinessSelection: () => {
+      if (taskType !== TaskTypes.SOLE_PROPRIETOR_COMPANY && COUNTRIES_USING_COMPANY_SEARCH.includes(country) && isExperimentEnabled("EnableBusinessDetailsMultiForm")) {
+        return "REQUIRED";
+      }
+    }
+  });
+};
+const inferTaxIdNumberType = (taxInformation, country, companyType) => {
+  if (!taxInformation) return void 0;
+  const optionsForCountry = getTaxIdNumberOptions(country, companyType);
+  const metadataFn = taxInformationDefaultFieldConfig[country];
+  if (!optionsForCountry || !metadataFn) return void 0;
+  if (optionsForCountry.length === 1) return optionsForCountry[0].id;
+  const allMetaData = optionsForCountry.reduce(
+    (acc, option) => {
+      const meta = typeof metadataFn === "function" ? metadataFn({
+        taxIdNumberType: option.id,
+        companyType
+      }) : metadataFn;
+      if (meta.label && !acc[meta.label]) {
+        acc[meta.label] = meta;
+      }
+      return acc;
+    },
+    {}
+  );
+  for (const option of optionsForCountry) {
+    const fieldMetadata = allMetaData[option.name];
+    if (!fieldMetadata?.validators) continue;
+    const validators = Array.isArray(fieldMetadata.validators) ? fieldMetadata.validators : [fieldMetadata.validators];
+    if (validators.every((validator) => validator.validate(taxInformation))) {
+      return option.id;
+    }
+  }
+};
+function findExistingTaxInformation(taxInformation, country) {
+  return taxInformation?.find((taxId) => taxId.country === country);
+}
+function getDefaultTaxIdNumberType(taxInformation, country, entityType) {
+  const existingTaxInformation = findExistingTaxInformation(taxInformation, country);
+  return (
+    // First check if we already have a type set
+    existingTaxInformation?.type ?? (existingTaxInformation?.number ? (
+      // If we have a number but no type, try to infer it
+      inferTaxIdNumberType(taxInformation, country, entityType)
+    ) : (
+      // Otherwise use the first available tax ID option for this country and entity type
+      getTaxIdNumberOptions(country, entityType)?.[0]?.id
+    ))
+  );
+}
+function TaxIdNumberTypeSelector({
+  country,
+  companyType,
+  selected,
+  setSelected,
+  exemptedOption,
+  isUsSoleProp,
+  errorMessage
+}) {
+  const { t } = useTranslation("common");
+  const handleSelect = useCallback(
+    (selectedStr) => {
+      const newSelected = selectedStr;
+      if (newSelected === "exempted") {
+        if (exemptedOption) {
+          setSelected(newSelected);
+        }
+        return;
+      }
+      setSelected(newSelected);
+    },
+    [exemptedOption, setSelected]
+  );
+  const options = useMemo(() => {
+    const availableOptions = getTaxIdNumberOptions(country, companyType) ?? [];
+    if (availableOptions.length === 0 || !exemptedOption) return availableOptions;
+    return [
+      ...availableOptions,
+      {
+        id: "exempted",
+        name: exemptedOption
+      }
+    ];
+  }, [country, companyType, exemptedOption]);
+  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: !!errorMessage,
+      children: (childProps) => /* @__PURE__ */ jsx(
+        RadioGroup,
+        {
+          ...childProps,
+          name: "taxIdNumberType",
+          items: options,
+          value: selected,
+          onChange: handleSelect
+        }
+      )
+    }
+  );
+}
+const TAX_INFORMATION_FIELD = [
+  "taxInformation",
+  "exemptedFromTax",
+  "isUen"
+];
+function TaxInformationField({
+  data,
+  valid,
+  errors,
+  labels,
+  mask,
+  guidanceText,
+  placeholders,
+  readonly,
+  optional,
+  shouldValidate,
+  handleChangeFor,
+  country,
+  canExempt,
+  registrationNumber,
+  entityType,
+  defaultData
+}) {
+  const { isExperimentEnabled } = useExperimentsContext();
+  const { t } = useTranslation("common");
+  const { accountHolder } = useAccountHolder();
+  const currentCountryTaxInformation = useMemo(
+    () => data?.taxInformation?.find((taxInfo) => taxInfo.country === country),
+    [data, country]
+  );
+  const isUsSoleProp = country === "US" && entityType === CompanyTypesValues.SOLE_PROPRIETORSHIP;
+  const exemptionLabel = isUsSoleProp ? t(($) => $["socialSecurityNumber"]) : labels.exemptedFromTax;
+  const shouldRenderInput = isUsSoleProp ? currentCountryTaxInformation?.type === "EIN" : !data.isUen;
+  const options = getTaxIdNumberOptions(country, entityType);
+  const showTaxIdExemptedOptions = canExempt && (options?.length ?? 0) > 1 || isUsSoleProp;
+  const canSaveAbsentState = isExperimentEnabled("EnableRegistrationAndTaxAbsentStatesV4") && COUNTRIES_WITH_POSSIBLE_TRUSTEE_TAXID_ABSENT_V4.includes(country) && accountHolder === "aTrust";
+  const taxIdNumberType = useMemo(() => {
+    if (isUsSoleProp) {
+      return data.exemptedFromTax ? "exempted" : currentCountryTaxInformation?.type ? currentCountryTaxInformation?.type : void 0;
+    }
+    return data.exemptedFromTax ? "exempted" : currentCountryTaxInformation?.type ? currentCountryTaxInformation?.type : getDefaultTaxIdNumberType(data.taxInformation, country, entityType);
+  }, [
+    country,
+    currentCountryTaxInformation?.type,
+    data.exemptedFromTax,
+    data.taxInformation,
+    entityType,
+    isUsSoleProp
+  ]);
+  const handleTaxInformationChange = (e, key, mode) => {
+    const value = e ? typeof e === "string" ? e : e?.target?.value : void 0;
+    switch (key) {
+      case "number": {
+        const newTaxInformation = canSaveAbsentState ? {
+          country,
+          number: value,
+          type: currentCountryTaxInformation?.type ?? taxIdNumberType,
+          numberAbsent: false
+        } : {
+          country,
+          number: value,
+          type: currentCountryTaxInformation?.type ?? taxIdNumberType
+        };
+        if (!data.taxInformation) {
+          return handleChangeFor("taxInformation", mode)([newTaxInformation]);
+        }
+        const taxInformation = currentCountryTaxInformation ? data.taxInformation : [...data.taxInformation, newTaxInformation];
+        const updatedTaxInformation = taxInformation.map((taxInfo) => {
+          if (taxInfo.country !== country) return taxInfo;
+          return newTaxInformation;
+        });
+        return handleChangeFor("taxInformation", mode)(updatedTaxInformation);
+      }
+      case "type": {
+        const newTaxInformation = canSaveAbsentState ? {
+          country,
+          number: currentCountryTaxInformation?.number,
+          type: value,
+          numberAbsent: false
+        } : {
+          country,
+          number: currentCountryTaxInformation?.number,
+          type: value
+        };
+        if (!data.taxInformation) {
+          return handleChangeFor("taxInformation", mode)([newTaxInformation]);
+        }
+        const taxInformation = currentCountryTaxInformation ? data.taxInformation : [...data.taxInformation, newTaxInformation];
+        const updatedTaxInformation = taxInformation.map((taxInfo) => {
+          if (taxInfo.country !== country) return taxInfo;
+          return newTaxInformation;
+        });
+        return handleChangeFor("taxInformation", mode)(updatedTaxInformation);
+      }
+    }
+  };
+  useEffect(() => {
+    const hasSavedTaxId = defaultData?.find((taxId) => taxId.country === country);
+    if (currentCountryTaxInformation?.country === country) return;
+    if (currentCountryTaxInformation && !hasSavedTaxId) return;
+    if (entityType === CompanyTypesValues.SOLE_PROPRIETORSHIP) return;
+    handleChangeFor("taxInformation", "input")(defaultData);
+    const newCountryOptions = getTaxIdNumberOptions(country, entityType);
+    if (newCountryOptions && newCountryOptions.length > 0) {
+      handleTaxInformationChange(newCountryOptions[0].id, "type", "input");
+    } else {
+      handleTaxInformationChange(void 0, "type", "input");
+    }
+  }, [country]);
+  const removeCurrentCountryTaxInformation = () => {
+    const filterdTaxInformation = data.taxInformation?.filter((taxId) => taxId.country !== country);
+    handleChangeFor("taxInformation", "input")(filterdTaxInformation);
+  };
+  const setUenAsTaxId = (uen) => {
+    if (!data.taxInformation) {
+      return handleChangeFor(
+        "taxInformation",
+        "blur"
+      )([
+        {
+          country,
+          number: uen ?? "",
+          type: "UEN"
+        }
+      ]);
+    }
+    const taxInformation = currentCountryTaxInformation ? data.taxInformation : [
+      ...data.taxInformation,
+      {
+        country,
+        number: uen ?? "",
+        type: "UEN"
+      }
+    ];
+    const updatedTaxInformation = taxInformation.map((taxInfo) => {
+      if (taxInfo.country !== country) return taxInfo;
+      return {
+        country,
+        number: uen ?? "",
+        type: "UEN"
+      };
+    });
+    return handleChangeFor("taxInformation", "blur")(updatedTaxInformation);
+  };
+  useEffect(() => {
+    if (country === "SG" && data.isUen && currentCountryTaxInformation?.number !== registrationNumber) {
+      setUenAsTaxId(registrationNumber);
+    }
+  }, [registrationNumber]);
+  const addTaxAbsentStatus = (exempted) => {
+    if (!data.taxInformation) {
+      const updatedTaxInformation2 = [
+        {
+          country,
+          numberAbsent: exempted
+        }
+      ];
+      return handleChangeFor("taxInformation", "input")(updatedTaxInformation2);
+    }
+    const taxInformation = currentCountryTaxInformation ? data.taxInformation : [
+      ...data.taxInformation,
+      {
+        country,
+        numberAbsent: exempted
+      }
+    ];
+    const updatedTaxInformation = taxInformation.map((taxInfo) => {
+      if (taxInfo.country !== country) return taxInfo;
+      return {
+        country,
+        numberAbsent: exempted
+      };
+    });
+    return handleChangeFor("taxInformation", "input")(updatedTaxInformation);
+  };
+  const handleTaxIdNumberTypeChange = (taxIdType) => {
+    if (!canExempt && taxIdType === "exempted") {
+      throw Error(`${country} does not allow tax exemptions`);
+    }
+    switch (taxIdType) {
+      case "exempted":
+        handleChangeFor("exemptedFromTax")(true);
+        handleTaxInformationChange(void 0, "type", "input");
+        return canSaveAbsentState ? addTaxAbsentStatus(true) : removeCurrentCountryTaxInformation();
+      default:
+        handleChangeFor("exemptedFromTax")(false);
+    }
+    if (country === "SG") {
+      if (taxIdType === "UEN") {
+        handleChangeFor("isUen")(true);
+        setUenAsTaxId(registrationNumber);
+      } else {
+        handleChangeFor("isUen")(false);
+        removeCurrentCountryTaxInformation();
+      }
+    }
+    handleTaxInformationChange(taxIdType, "type", "input");
+  };
+  const handleExemptedFromTaxChange = (exempted) => {
+    if (canSaveAbsentState) {
+      addTaxAbsentStatus(exempted);
+      handleChangeFor("exemptedFromTax")(exempted);
+    } else {
+      handleChangeFor("exemptedFromTax")(exempted);
+      removeCurrentCountryTaxInformation();
+    }
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-field__tax-information", children: [
+    /* @__PURE__ */ jsx(
+      TaxIdNumberTypeSelector,
+      {
+        country,
+        companyType: entityType,
+        setSelected: handleTaxIdNumberTypeChange,
+        selected: taxIdNumberType,
+        exemptedOption: showTaxIdExemptedOptions ? exemptionLabel : false,
+        isUsSoleProp,
+        errorMessage: isUsSoleProp ? errors.taxInformation : false
+      }
+    ),
+    shouldRenderInput && /* @__PURE__ */ jsx(
+      MaskedInput,
+      {
+        type: "text",
+        "aria-required": true,
+        "aria-invalid": !valid.taxInformation,
+        name: "taxInformation",
+        label: labels.taxInformation ?? "",
+        formatGuidance: guidanceText?.taxInformation ?? "",
+        value: currentCountryTaxInformation?.number ?? "",
+        errorMessage: errors.taxInformation,
+        placeholder: placeholders?.taxInformation,
+        isValid: Boolean(valid.taxInformation) && !!currentCountryTaxInformation,
+        onInput: (e) => handleTaxInformationChange(e, "number", "input"),
+        onBlur: (e) => handleTaxInformationChange(e, "number", "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: labels.exemptedFromTax,
+        value: "exemptedFromTax",
+        checked: Boolean(data.exemptedFromTax),
+        onChange: handleExemptedFromTaxChange
+      }
+    ) })
+  ] });
+}
+export {
+  COUNTRIES_USING_COMPANY_SEARCH as C,
+  MemoizedDocumentUpload as M,
+  StateCodesUS as S,
+  TaxInformationField as T,
+  additionallIdNumberOptions as a,
+  taxInformationDefaultFieldConfig as b,
+  TAX_INFORMATION_FIELD as c,
+  exemptedFromTaxDefaultFieldConfig as d,
+  exemptedFromTaxDefaultFieldMetadata as e,
+  COUNTRY_OF_GOVERNING_LAW_POSSIBLE as f,
+  getFieldsWithExistingData as g,
+  isRegistrationNumberAbsentStateV4Scenario as h,
+  individualIdNumberOptions as i,
+  COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT as j,
+  getCompanyRegistrationNumberOptions as k,
+  countryToTaxInfoTypeMap as l,
+  businessRegistrationNumberMasks as m,
+  businessRegistrationNumberPatterns as n,
+  getVatNumberOptions as o,
+  rules as r,
+  stateFormatGuidanceText as s,
+  taxInformationDefaultFieldMetadata as t,
+  useCapabilities as u,
+  vatNumberOptions as v
+};