@adyen/kyc-components 4.0.0-compact.0 → 4.0.0

package/dist/TaxInformationField-DS0m73if.js

@@ -1,3062 +0,0 @@
-;
-{
-  try {
-    let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "a4c6961e-2100-4870-9ef0-29336a3953e8", e._sentryDebugIdIdentifier = "sentry-dbid-a4c6961e-2100-4870-9ef0-29336a3953e8");
-  } 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-BlaJzXSZ.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-C1DW3mPC.js";
-import { c as createFormUtils, F as FormHeader, E as ErrorPanel } from "./CountryField-D0YZrov9.js";
-import { T as TextArea, f as validatePatternOnBlur, c as validateNotEmptyOnBlur, a as useAccountHolder } from "./fieldConfigurations-B8bDFQ53.js";
-import { S as StateContextSetter } from "./validate-CvtamBXH.js";
-import { D as DocumentGuidance, u as uppercase } from "./mapExistingFile-DW5ktJzM.js";
-import { D as Dropzone } from "./Dropzone-D6dXhmL4.js";
-import { C as CompanyTypesValues } from "./bafinUtils-Bar3qiJA.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-BZ7t98eu.js";
-import { C as COUNTRIES_WITH_STATES_DATASET } from "./utils-CgOzbb9O.js";
-import { c as createFormRules } from "./form-rules-DhbF2mY4.js";
-import { i as isDateOlderThanAYear } from "./Address-DSwfzWFu.js";
-import { R as RadioGroup } from "./RadioGroup-CYDXrtrO.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
-};