npm - @adyen/kyc-components - Versions diffs - 4.0.0-compact.0 → 4.0.0-compact.2 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (838) hide show

package/dist/TrustDetailsPage-C791Wu5u.js DELETED Viewed

@@ -1,1205 +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] = "86369c83-e0ea-4da6-9740-6a7a6d3eb707", e._sentryDebugIdIdentifier = "sentry-dbid-86369c83-e0ea-4da6-9740-6a7a6d3eb707");
-  } catch (e) {
-  }
-}
-;
-import { jsx, Fragment, jsxs } from "preact/jsx-runtime";
-import { aS as reverseMapping, y as LegalEntityTypes, M as TaskTypes, a8 as CountryCodes, an as hasText, ao as isValidMinLength, ap as matchesRegex, aq as NO_ALPHABET_REGEX, ar as EMOJI_REGEX, as as hasRepeatedCharacters, at as isInvalidName, au as OTHER_ENTITIES_VALID_CHAR_REGEX, a as useTranslation, u as useI18nContext, X as useExperimentsContext, x as Typography, bI as getCountrySpecificTrustTypeOptions, bJ as trustComponentsKeyMapping, bK as trustApiKeyMapping, b as useApiContext, U as useAnalyticsContext, bL as trustDocumentMapping, ay as cloneObject, g as getLegalEntityCountry, a9 as isEmpty$1, b1 as drop, a6 as getOwnEntityAssociations, c as useLegalEntity, q as skipToken, R as ROOT_LE, L as Loader, aD as keysOf, J as EntityTypes } from "./StoreProvider-BlaJzXSZ.js";
-import { c as validateNotEmptyOnBlur, r as resolveFieldMetadata, b as useCapabilityProblems, g as getProblemsForEntity } from "./fieldConfigurations-B8bDFQ53.js";
-import { j as COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT, c as TAX_INFORMATION_FIELD, t as taxInformationDefaultFieldMetadata, b as taxInformationDefaultFieldConfig, e as exemptedFromTaxDefaultFieldMetadata, d as exemptedFromTaxDefaultFieldConfig, T as TaxInformationField, g as getFieldsWithExistingData, k as getCompanyRegistrationNumberOptions, l as countryToTaxInfoTypeMap, u as useCapabilities } from "./TaxInformationField-DS0m73if.js";
-import { useMemo, useCallback, useEffect, useState, useRef } from "preact/hooks";
-import { u as useCreateLegalEntity, a as useUpdateLegalEntity } from "./RadioGroup-CYDXrtrO.js";
-import { h as hasDataChanged } from "./hasDataChanged-BgvxL-Hx.js";
-import { u as useGlobalDataSlice, c as useStateContext, F as FormWrapper } from "./useGlobalData-jb7ua9I6.js";
-import { u as useToastContext } from "./useToastContext-DGMeMy5R.js";
-import { g as getAssociatedLeAnalyticsPayload } from "./analytics-3-a-Od7Z.js";
-import { a as getDocument, c as createDocumentRequest, d as documentApiUtils, b as getPropsFromConfigurations, k as augmentWithCountryConfigs, e as composePerScenarioFormConfigurations } from "./validate-CvtamBXH.js";
-import { g as getRequiredForms, a as addValidityToForms, u as useFormComposer } from "./dropinUtils-DHp5v5jB.js";
-import { m as mapExistingFile, g as getPageName, b as useScenarioConfiguration } from "./mapExistingFile-DW5ktJzM.js";
-import { D as DBA_NAME_FIELD, B as BUSINESS_REGISTRATION_NUMBER_FIELD, V as VAT_NUMBER_FIELD, e as doingBusinessAsAbsentFieldMetadata, c as doingBusinessAsFieldMetadata, r as registrationNumberDefaultFieldMetadata, b as registrationNumberDefaultFieldConfig, i as exemptFromRegistrationNumberDefaultFieldMetadata, l as exemptFromRegistrationNumberDefaultFieldConfig, d as defaultFieldMetadata, a as defaultFieldConfig, f as DBANameField, g as BusinessRegistrationNumberField, h as VatNumberField, j as registrationAddressFields, R as RegistrationAddress, M as MemoizedConstitutionalDocument, k as getDefaultVatNumberType, m as getDefaultRegistrationNumberType, n as inferCompanyRegistrationNumberType } from "./RegistrationAddress-qtMZa31b.js";
-import { m as mapAddressLabels } from "./utils-CgOzbb9O.js";
-import { i as isValidationError, p as processValidationErrors, a as isMaintenanceModeError } from "./validationError-DOCbfk7K.js";
-import { a as datasetUtilities } from "./useDataset-BgvQQEKd.js";
-import { f as formatObject, g as getProp } from "./utils-DNSfZiio.js";
-import { o as operationalAddressIsSameIds } from "./Address-DSwfzWFu.js";
-import { c as createFormRules } from "./form-rules-DhbF2mY4.js";
-import { U as UNINCORPORATED_PARTNERSHIP_COUNTRIES_VAT_NUMBER_OPTIONAL, a as UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_REQUIRED, b as UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_OPTIONAL, c as UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_REQUIRED, d as UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_OPTIONAL, A as ALLOWED_UNINCORPORATED_PARTNERSHIP_COUNTRIES } from "./types-CP1NRoE8.js";
-import { m as mergeFieldMetadataIntoProps, c as createFormUtils, F as FormHeader, E as ErrorPanel, C as CountryField, a as COUNTRY_FIELD, f as getFormProps, i as getNestedOuterFormPropsFromOuterFormProps } from "./CountryField-D0YZrov9.js";
-import { a as useForm, F as Field, c as Select } from "./useForm-C1DW3mPC.js";
-import { a as Alert } from "./Alert-C24s_Ygs.js";
-import { I as InputText } from "./InputText-BX5sG9WJ.js";
-import { i as isEmpty } from "./isEmpty-CuQFhMf0.js";
-const mapApiDocumentToTrustDocument = (entityId) => {
-  const constitutionalDocument = getDocument(entityId, "constitutionalDocument") || null;
-  return {
-    trustConstitutionalDocument: constitutionalDocument ? { constitutionalDocument: [mapExistingFile(getPageName(constitutionalDocument))] } : void 0
-  };
-};
-const unincorporatedPartnershipBaseMapping = {
-  "trustRegistrationDetails.trustType": "unincorporatedPartnership.type",
-  "trustRegistrationDetails.legalName": "unincorporatedPartnership.name",
-  "trustRegistrationDetails.doingBusinessAs": "unincorporatedPartnership.doingBusinessAs",
-  "trustRegistrationDetails.hasDoingBusinessAs": "unincorporatedPartnership.doingBusinessAsAbsent",
-  "trustRegistrationDetails.country": "unincorporatedPartnership.countryOfGoverningLaw",
-  "trustRegistrationDetails.registrationNumber": "unincorporatedPartnership.registrationNumber",
-  "trustRegistrationDetails.taxInformation": "unincorporatedPartnership.taxInformation",
-  "trustRegistrationDetails.vatNumber": "unincorporatedPartnership.vatNumber",
-  "trustRegistrationAddress.registrationAddress.city": "unincorporatedPartnership.registeredAddress.city",
-  "trustRegistrationAddress.registrationAddress.country": "unincorporatedPartnership.registeredAddress.country",
-  "trustRegistrationAddress.registrationAddress.postalCode": "unincorporatedPartnership.registeredAddress.postalCode",
-  "trustRegistrationAddress.registrationAddress.stateOrProvince": "unincorporatedPartnership.registeredAddress.stateOrProvince",
-  "trustRegistrationAddress.registrationAddress.address": "unincorporatedPartnership.registeredAddress.street",
-  "trustRegistrationAddress.registrationAddress.otherAddressInformation": "unincorporatedPartnership.registeredAddress.street2",
-  "trustRegistrationAddress.operationalAddress.city": "unincorporatedPartnership.principalPlaceOfBusiness.city",
-  "trustRegistrationAddress.operationalAddress.country": "unincorporatedPartnership.principalPlaceOfBusiness.country",
-  "trustRegistrationAddress.operationalAddress.postalCode": "unincorporatedPartnership.principalPlaceOfBusiness.postalCode",
-  "trustRegistrationAddress.operationalAddress.stateOrProvince": "unincorporatedPartnership.principalPlaceOfBusiness.stateOrProvince",
-  "trustRegistrationAddress.operationalAddress.address": "unincorporatedPartnership.principalPlaceOfBusiness.street",
-  "trustRegistrationAddress.operationalAddress.otherAddressInformation": "unincorporatedPartnership.principalPlaceOfBusiness.street2"
-};
-const unincorporatedPartnershipComponentsKeyMapping = {
-  "trustRegistrationDetails.exemptedFromVat": "unincorporatedPartnership.vatAbsenceReason",
-  ...unincorporatedPartnershipBaseMapping
-};
-const unincorporatedPartnershipApiKeyMapping = {
-  ...reverseMapping(unincorporatedPartnershipBaseMapping)
-};
-const mapLegalEntityToUnincorporatedPartnership = (legalEntity, isExperimentEnabled) => {
-  if (!legalEntity.unincorporatedPartnership)
-    throw new Error("LE missing unincorporatedPartnership field");
-  let trustCompData = formatObject(
-    legalEntity,
-    unincorporatedPartnershipComponentsKeyMapping
-  );
-  if (!trustCompData?.trustRegistrationDetails) return {};
-  trustCompData.trustRegistrationDetails.country = legalEntity.unincorporatedPartnership.countryOfGoverningLaw;
-  if (legalEntity.unincorporatedPartnership.description) {
-    trustCompData.trustRegistrationDetails.objectOfTrust = legalEntity.unincorporatedPartnership.description;
-  }
-  if (legalEntity.unincorporatedPartnership.principalPlaceOfBusiness) {
-    trustCompData.trustRegistrationAddress.operationalAddressIsSame = operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME;
-  } else {
-    if (!trustCompData.trustRegistrationAddress) {
-      trustCompData.trustRegistrationAddress = {};
-    }
-    trustCompData.trustRegistrationAddress.operationalAddressIsSame = operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_SAME;
-  }
-  if (legalEntity.unincorporatedPartnership.taxInformation?.length) {
-    const { country } = legalEntity.unincorporatedPartnership.registeredAddress;
-    const countryTaxInformation = legalEntity.unincorporatedPartnership.taxInformation.find(
-      (info) => info.country === country
-    );
-    if (countryTaxInformation?.type === "UEN") {
-      trustCompData.trustRegistrationDetails.isUen = true;
-    }
-    if (countryTaxInformation?.type === "GST") {
-      trustCompData.trustRegistrationDetails.isUen = false;
-    }
-    const taxNumberAbsent = countryTaxInformation?.numberAbsent;
-    if (taxNumberAbsent !== void 0) {
-      trustCompData.trustRegistrationDetails.exemptedFromTax = taxNumberAbsent;
-    }
-  }
-  if (legalEntity.documentDetails?.length) {
-    trustCompData = {
-      ...trustCompData,
-      ...mapApiDocumentToTrustDocument(legalEntity?.id)
-    };
-  }
-  if (isExperimentEnabled("EnableDoingBusinessAsNameV4")) {
-    if (typeof trustCompData.trustRegistrationDetails?.hasDoingBusinessAs === "boolean") {
-      trustCompData.trustRegistrationDetails.hasDoingBusinessAs = !legalEntity.unincorporatedPartnership.doingBusinessAsAbsent;
-      if (!trustCompData.trustRegistrationDetails.hasDoingBusinessAs)
-        delete legalEntity.unincorporatedPartnership.doingBusinessAs;
-    }
-  } else {
-    trustCompData.trustRegistrationDetails.hasDoingBusinessAs = legalEntity.unincorporatedPartnership.doingBusinessAs ? legalEntity.unincorporatedPartnership.doingBusinessAs !== legalEntity.unincorporatedPartnership.name : void 0;
-    trustCompData.trustRegistrationDetails.doingBusinessAs = legalEntity.unincorporatedPartnership.doingBusinessAs;
-  }
-  return trustCompData;
-};
-const mapUnincorporatedPartnershipToLegalEntity = (data, isExperimentEnabled) => {
-  const requestObj = {
-    ...formatObject(data, unincorporatedPartnershipApiKeyMapping)
-  };
-  if (!requestObj.unincorporatedPartnership) return requestObj;
-  if (requestObj.unincorporatedPartnership?.taxInformation?.[0]?.type === "GST") {
-    requestObj.unincorporatedPartnership.taxInformation[0].type = "UEN";
-  }
-  if (isExperimentEnabled("EnableDoingBusinessAsNameV4")) {
-    if (typeof data.trustRegistrationDetails?.hasDoingBusinessAs !== "undefined") {
-      requestObj.unincorporatedPartnership.doingBusinessAsAbsent = !data.trustRegistrationDetails?.hasDoingBusinessAs;
-    }
-  } else {
-    requestObj.unincorporatedPartnership.doingBusinessAs = data.trustRegistrationDetails?.doingBusinessAs || data.trustRegistrationDetails?.legalName || "";
-    delete requestObj.unincorporatedPartnership.doingBusinessAsAbsent;
-  }
-  requestObj.type = LegalEntityTypes.UNINCORPORATED_PARTNERSHIP;
-  return requestObj;
-};
-const COUNTRIES_THAT_USE_REGISTRATION_NUMBER = [CountryCodes.NewZealand];
-const rules = ({
-  data,
-  country,
-  isExperimentEnabled,
-  taskType
-}) => createFormRules({
-  countryUsesTaxId: () => {
-    if (taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP) {
-      if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_REQUIRED.includes(country)) {
-        return "REQUIRED";
-      }
-      if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_OPTIONAL.includes(country)) {
-        return "OPTIONAL";
-      }
-    }
-    if (country !== CountryCodes.NewZealand && COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT.includes(country)) {
-      return "REQUIRED";
-    }
-  },
-  countryRequiresRegistrationNumberForTrust: () => {
-    if (taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP) {
-      if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_REQUIRED.includes(country)) {
-        return "REQUIRED";
-      }
-      if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_OPTIONAL.includes(country)) {
-        return "OPTIONAL";
-      }
-    }
-    if (COUNTRIES_THAT_USE_REGISTRATION_NUMBER.includes(country)) {
-      return "REQUIRED";
-    }
-  },
-  registrationNumberType: () => {
-    if (taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP) {
-      if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_REQUIRED.includes(country)) {
-        return "OPTIONAL";
-      }
-      if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_OPTIONAL.includes(country)) {
-        return "OPTIONAL";
-      }
-    }
-    if (COUNTRIES_THAT_USE_REGISTRATION_NUMBER.includes(country)) {
-      return "OPTIONAL";
-    }
-  },
-  countryUsesVatNumber: () => {
-    if (taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP) {
-      if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_VAT_NUMBER_OPTIONAL.includes(country)) {
-        return "OPTIONAL";
-      }
-    }
-  },
-  trustTypeHasDescription: () => {
-    if (data?.trustRegistrationDetails?.trustType === "charitableTrust") {
-      return "REQUIRED";
-    }
-  },
-  hasDoingBusinessAs: () => {
-    if (isExperimentEnabled?.("EnableDoingBusinessAsNameV4")) {
-      return "REQUIRED";
-    }
-  }
-});
-const trustRegistrationDetailsValidations = {
-  trustType: {
-    modes: ["blur"],
-    validate: (trustType) => !!trustType,
-    errorMessage: "fieldIsRequired"
-  },
-  country: {
-    modes: ["blur"],
-    validate: (country) => !!country,
-    errorMessage: "fieldIsRequired"
-  },
-  legalName: {
-    modes: ["blur"],
-    validate: (legalName) => !!legalName,
-    errorMessage: "fieldIsRequired"
-  },
-  objectOfTrust: {
-    modes: ["blur"],
-    validate: (objectOfTrust) => !!objectOfTrust,
-    errorMessage: "fieldIsRequired"
-  },
-  hasDoingBusinessAs: validateNotEmptyOnBlur,
-  doingBusinessAs: validateNotEmptyOnBlur
-};
-const trustRegistrationDetailsValidationsV4 = {
-  trustType: {
-    modes: ["blur"],
-    validate: (trustType) => !!trustType,
-    errorMessage: "fieldIsRequired"
-  },
-  country: {
-    modes: ["blur"],
-    validate: (country) => !!country,
-    errorMessage: "fieldIsRequired"
-  },
-  legalName: [
-    {
-      modes: ["blur"],
-      validate: hasText,
-      errorMessage: "fieldIsRequired"
-    },
-    {
-      modes: ["blur"],
-      validate: (input) => !matchesRegex(NO_ALPHABET_REGEX, input),
-      errorMessage: "nameMustContainLetters"
-    },
-    {
-      modes: ["blur"],
-      validate: (input) => !matchesRegex(EMOJI_REGEX, input) && !hasRepeatedCharacters(input) && isValidMinLength(input, 3) && !isInvalidName(input) && matchesRegex(OTHER_ENTITIES_VALID_CHAR_REGEX, input),
-      errorMessage: "checkForTypos"
-    }
-  ],
-  objectOfTrust: {
-    modes: ["blur"],
-    validate: (objectOfTrust) => !!objectOfTrust,
-    errorMessage: "fieldIsRequired"
-  },
-  hasDoingBusinessAs: validateNotEmptyOnBlur,
-  doingBusinessAs: validateNotEmptyOnBlur
-};
-const trustRegistrationDetailsFields = [
-  "legalName",
-  ...DBA_NAME_FIELD,
-  "country",
-  "trustType",
-  "objectOfTrust",
-  ...TAX_INFORMATION_FIELD,
-  ...BUSINESS_REGISTRATION_NUMBER_FIELD,
-  ...VAT_NUMBER_FIELD
-];
-const ALLOWED_TRUST_COUNTRIES = [CountryCodes.Australia, CountryCodes.NewZealand];
-function TrustRegistrationDetails(props) {
-  let mergedProps = props;
-  const TRUST_REGISTRATION_DETAILS = mergedProps.id || trustForms.trustRegistrationDetails.formId;
-  const { t } = useTranslation("common");
-  const { i18n } = useI18nContext();
-  const { isExperimentEnabled } = useExperimentsContext();
-  const { updateStateSlice, sliceData } = useGlobalDataSlice(TRUST_REGISTRATION_DETAILS);
-  const isStrictNameAndAddressValidationEnabled = isExperimentEnabled(
-    "StrictNameAndAddressValidationV4"
-  );
-  const { taskType } = props;
-  const isUnincorporatedPartnership = taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP;
-  const country = sliceData?.country ?? mergedProps.country;
-  const defaultData = useMemo(
-    () => ({ ...mergedProps.data, country }),
-    [country, mergedProps.data]
-  );
-  const requiredFields = isEmpty(mergedProps.requiredFields) ? trustRegistrationDetailsFields : mergedProps.requiredFields;
-  mergedProps = mergeFieldMetadataIntoProps(
-    "hasDoingBusinessAs",
-    doingBusinessAsAbsentFieldMetadata,
-    mergedProps
-  );
-  mergedProps = mergeFieldMetadataIntoProps(
-    "doingBusinessAs",
-    doingBusinessAsFieldMetadata,
-    mergedProps
-  );
-  mergedProps = mergeFieldMetadataIntoProps(
-    "taxInformation",
-    resolveFieldMetadata(
-      taxInformationDefaultFieldConfig[country],
-      {
-        taxIdNumberType: sliceData?.taxInformation?.find((taxId) => taxId.country === country)?.type,
-        companyType: LegalEntityTypes.TRUST
-      },
-      taxInformationDefaultFieldMetadata
-    ),
-    mergedProps
-  );
-  mergedProps = mergeFieldMetadataIntoProps(
-    "exemptedFromTax",
-    resolveFieldMetadata(
-      exemptedFromTaxDefaultFieldConfig[country],
-      {},
-      exemptedFromTaxDefaultFieldMetadata
-    ),
-    mergedProps
-  );
-  mergedProps = mergeFieldMetadataIntoProps(
-    "registrationNumber",
-    resolveFieldMetadata(
-      registrationNumberDefaultFieldConfig[country],
-      {
-        companyType: LegalEntityTypes.TRUST,
-        registrationNumberType: sliceData?.registrationNumberType,
-        isExperimentEnabled
-      },
-      registrationNumberDefaultFieldMetadata
-    ),
-    mergedProps
-  );
-  mergedProps = mergeFieldMetadataIntoProps(
-    "exemptedFromRegistrationNumber",
-    resolveFieldMetadata(
-      exemptFromRegistrationNumberDefaultFieldConfig[country],
-      {},
-      exemptFromRegistrationNumberDefaultFieldMetadata
-    ),
-    mergedProps
-  );
-  mergedProps = mergeFieldMetadataIntoProps(
-    "vatNumber",
-    resolveFieldMetadata(
-      defaultFieldConfig[country],
-      { vatNumberType: sliceData?.vatNumberType },
-      defaultFieldMetadata
-    ),
-    mergedProps
-  );
-  mergedProps.validators = {
-    ...mergedProps.validators,
-    legalName: isStrictNameAndAddressValidationEnabled ? trustRegistrationDetailsValidationsV4.legalName : trustRegistrationDetailsValidations.legalName
-  };
-  const getFormSchema = useCallback(
-    (currentData) => {
-      const fieldsToRemove = [];
-      if (!currentData.hasDoingBusinessAs) {
-        fieldsToRemove.push("doingBusinessAs");
-      }
-      return requiredFields.filter((field) => !fieldsToRemove.includes(field));
-    },
-    [requiredFields]
-  );
-  const { handleChangeFor, data, valid, errors, setData, fieldProblems, schema } = useForm({
-    ...mergedProps,
-    schema: getFormSchema,
-    defaultData,
-    rules: mergedProps.validators || (isStrictNameAndAddressValidationEnabled ? trustRegistrationDetailsValidationsV4 : trustRegistrationDetailsValidations),
-    fieldProblems: mergedProps.fieldValidationErrors
-  });
-  const formUtils = createFormUtils(
-    {
-      ...mergedProps,
-      requiredFields,
-      fieldValidationErrors: mergedProps.fieldValidationErrors,
-      formVerificationErrors: mergedProps.formVerificationErrors
-    },
-    t
-  );
-  useEffect(() => {
-    updateStateSlice({
-      schema,
-      data,
-      errors,
-      valid,
-      fieldProblems
-    });
-  }, [data, errors, fieldProblems, schema, updateStateSlice, valid]);
-  const changeTrustType = (e) => {
-    handleChangeFor("trustType", "blur")(e);
-    if (e.target.value !== "charitableTrust") {
-      setData("objectOfTrust", void 0);
-    }
-  };
-  const trustTypeOptions = getCountrySpecificTrustTypeOptions(country) ?? [];
-  const showField = (field) => formUtils.isRequiredField(field) || formUtils.isOptionalField(field);
-  return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsxs("form", { id: TRUST_REGISTRATION_DETAILS, className: "adyen-kyc-trust__registration-details", children: [
-    /* @__PURE__ */ jsx(FormHeader, { heading: mergedProps.heading }),
-    /* @__PURE__ */ jsx(
-      ErrorPanel,
-      {
-        verificationErrors: mergedProps.formVerificationErrors,
-        validationErrors: mergedProps.fieldValidationErrors,
-        formUtils,
-        id: "ariaErrorField"
-      }
-    ),
-    !isUnincorporatedPartnership && /* @__PURE__ */ jsx(
-      Alert,
-      {
-        variant: "info",
-        title: /* @__PURE__ */ jsx(Typography, { variant: "caption", color: "secondary", children: i18n.get("makeSureToHaveYourTrustDeed") }),
-        className: "adyen-kyc-u-margin-bottom-16"
-      }
-    ),
-    formUtils.isRequiredField("country") && /* @__PURE__ */ jsx(
-      CountryField,
-      {
-        data: formUtils.getFieldData(data, COUNTRY_FIELD),
-        valid: formUtils.getFieldValid(valid, COUNTRY_FIELD),
-        errors: formUtils.getFieldErrors(errors, fieldProblems, COUNTRY_FIELD),
-        labels: formUtils.getFieldLabels(COUNTRY_FIELD, {
-          country: "countryRegionOfEstablishment"
-        }),
-        readonly: formUtils.isReadOnly("country"),
-        allowedCountries: isUnincorporatedPartnership ? ALLOWED_UNINCORPORATED_PARTNERSHIP_COUNTRIES : ALLOWED_TRUST_COUNTRIES,
-        handleChangeFor: () => (e) => {
-          handleChangeFor("country", "input")(e);
-          if (mergedProps.onCountryChange) mergedProps.onCountryChange(e);
-        }
-      }
-    ),
-    formUtils.isRequiredField("legalName") && /* @__PURE__ */ jsx(
-      Field,
-      {
-        name: "legalName",
-        label: formUtils.getLabel(
-          !isUnincorporatedPartnership ? "nameOfTrustAgreement" : "legalName"
-        ),
-        errorMessage: formUtils.getErrorMessage("legalName", errors, fieldProblems),
-        isValid: valid.legalName,
-        children: (childProps) => /* @__PURE__ */ jsx(
-          InputText,
-          {
-            ...childProps,
-            name: "legalName",
-            value: data.legalName,
-            readonly: formUtils.isReadOnly("legalName"),
-            onInput: handleChangeFor("legalName", "input"),
-            onBlur: handleChangeFor("legalName", "blur"),
-            "aria-required": true,
-            "aria-invalid": !valid.legalName
-          }
-        )
-      }
-    ),
-    formUtils.isRequiredField("hasDoingBusinessAs") && /* @__PURE__ */ jsx(
-      DBANameField,
-      {
-        data: formUtils.getFieldData(data, DBA_NAME_FIELD),
-        valid: formUtils.getFieldValid(valid, DBA_NAME_FIELD),
-        errors: formUtils.getFieldErrors(errors, fieldProblems, DBA_NAME_FIELD),
-        labels: formUtils.getFieldLabels(DBA_NAME_FIELD, {
-          hasDoingBusinessAs: "hasDba"
-        }),
-        readonly: formUtils.isReadOnly("doingBusinessAs"),
-        handleChangeFor
-      }
-    ),
-    formUtils.isRequiredField("trustType") && !isUnincorporatedPartnership && /* @__PURE__ */ jsx(
-      Field,
-      {
-        name: "trustType",
-        label: formUtils.getLabel("trustType", "typeOfTrustAgreement"),
-        errorMessage: formUtils.getErrorMessage("trustType", errors, fieldProblems),
-        isValid: valid.trustType,
-        dataTestId: "trust-type",
-        children: (childProps) => /* @__PURE__ */ jsx(
-          Select,
-          {
-            ...childProps,
-            name: "trustType",
-            onChange: changeTrustType,
-            selected: data.trustType,
-            items: trustTypeOptions.map((trust) => ({
-              id: trust,
-              name: i18n.get(trust)
-            })),
-            placeholder: i18n.get("trustType")
-          }
-        )
-      }
-    ),
-    formUtils.isRequiredField("objectOfTrust") && /* @__PURE__ */ jsx(
-      Field,
-      {
-        name: "objectOfTrust",
-        label: formUtils.getLabel("objectOfCharitableTrust"),
-        helper: formUtils.getLabel("pleaseProvideThePurposeOfCharitableTrust"),
-        errorMessage: formUtils.getErrorMessage("objectOfTrust", errors, fieldProblems),
-        isValid: valid.objectOfTrust,
-        children: (childProps) => /* @__PURE__ */ jsx(
-          InputText,
-          {
-            ...childProps,
-            name: "objectOfTrust",
-            value: data.objectOfTrust,
-            readonly: formUtils.isReadOnly("objectOfTrust"),
-            onInput: handleChangeFor("objectOfTrust", "input"),
-            onBlur: handleChangeFor("objectOfTrust", "blur"),
-            "aria-required": true,
-            "aria-invalid": !valid.objectOfTrust
-          }
-        )
-      }
-    ),
-    showField("taxInformation") && /* @__PURE__ */ jsx(
-      TaxInformationField,
-      {
-        data: formUtils.getFieldData(data, TAX_INFORMATION_FIELD),
-        valid: formUtils.getFieldValid(valid, TAX_INFORMATION_FIELD),
-        errors: formUtils.getFieldErrors(errors, fieldProblems, TAX_INFORMATION_FIELD),
-        labels: formUtils.getFieldLabels(TAX_INFORMATION_FIELD, {
-          exemptedFromTax: "iDontHaveATaxId"
-        }),
-        mask: formUtils.getMask("taxInformation"),
-        guidanceText: formUtils.getFieldGuidanceText(TAX_INFORMATION_FIELD),
-        readonly: formUtils.isReadOnly("taxInformation"),
-        shouldValidate: mergedProps.shouldValidate,
-        handleChangeFor,
-        optional: formUtils.isOptionalField("taxInformation"),
-        canExempt: formUtils.isRequiredField("exemptedFromTax"),
-        country,
-        entityType: LegalEntityTypes.TRUST,
-        defaultData: mergedProps.data?.taxInformation,
-        registrationNumber: data.registrationNumber
-      }
-    ),
-    showField("registrationNumber") && /* @__PURE__ */ jsx(
-      BusinessRegistrationNumberField,
-      {
-        data: formUtils.getFieldData(data, BUSINESS_REGISTRATION_NUMBER_FIELD),
-        valid: formUtils.getFieldValid(valid, BUSINESS_REGISTRATION_NUMBER_FIELD),
-        errors: formUtils.getFieldErrors(
-          errors,
-          fieldProblems,
-          BUSINESS_REGISTRATION_NUMBER_FIELD
-        ),
-        labels: formUtils.getFieldLabels(BUSINESS_REGISTRATION_NUMBER_FIELD, {
-          exemptedFromRegistrationNumber: "iDontHaveARegistrationNumber"
-        }),
-        mask: formUtils.getMask("registrationNumber"),
-        guidanceText: formUtils.getFieldGuidanceText(BUSINESS_REGISTRATION_NUMBER_FIELD),
-        placeholders: formUtils.getFieldPlaceholders(BUSINESS_REGISTRATION_NUMBER_FIELD),
-        helperText: formUtils.getFieldHelperText(BUSINESS_REGISTRATION_NUMBER_FIELD),
-        readonly: formUtils.isReadOnly("registrationNumber"),
-        optional: formUtils.isOptionalField("registrationNumber"),
-        shouldValidate: mergedProps.shouldValidate,
-        handleChangeFor,
-        country,
-        canExempt: formUtils.isRequiredField("exemptedFromRegistrationNumber"),
-        companyType: LegalEntityTypes.TRUST
-      }
-    ),
-    showField("vatNumber") && /* @__PURE__ */ jsx(
-      VatNumberField,
-      {
-        data: formUtils.getFieldData(data, VAT_NUMBER_FIELD),
-        valid: formUtils.getFieldValid(valid, VAT_NUMBER_FIELD),
-        errors: formUtils.getFieldErrors(errors, fieldProblems, VAT_NUMBER_FIELD),
-        labels: formUtils.getFieldLabels(VAT_NUMBER_FIELD, {
-          exemptedFromVat: "iDontHaveAVatNumber"
-        }),
-        guidanceText: formUtils.getFieldGuidanceText(VAT_NUMBER_FIELD),
-        placeholders: formUtils.getFieldPlaceholders(VAT_NUMBER_FIELD),
-        optional: formUtils.isOptionalField("vatNumber"),
-        readonly: formUtils.isReadOnly("vatNumber"),
-        handleChangeFor,
-        country,
-        canExempt: formUtils.isRequiredField("exemptedFromVat"),
-        shouldValidate: mergedProps.shouldValidate
-      }
-    )
-  ] }) });
-}
-const trustForms = {
-  trustRegistrationDetails: {
-    formId: "trustRegistrationDetails",
-    formName: "registrationDetails",
-    fields: [...trustRegistrationDetailsFields]
-  },
-  trustRegistrationAddress: {
-    formId: "trustRegistrationAddress",
-    formName: "addressDetails",
-    fields: registrationAddressFields
-  },
-  trustConstitutionalDocument: {
-    formId: "trustConstitutionalDocument",
-    formName: "constitutionalDocument",
-    fields: ["constitutionalDocument"]
-  }
-};
-const trustRegistrationAddressFormId = trustForms.trustRegistrationAddress.formId;
-const trustRegistrationDetailsFormId = trustForms.trustRegistrationDetails.formId;
-const trustConstitutionalDocumentFormId = trustForms.trustConstitutionalDocument.formId;
-function Trust(props) {
-  const { i18n } = useI18nContext();
-  const { country, activeForm, taskType } = props;
-  const trustRegistrationDetailsFormProps = getFormProps(props, trustRegistrationDetailsFormId);
-  const trustRegistrationAddressFormProps = getNestedOuterFormPropsFromOuterFormProps(props, trustRegistrationAddressFormId);
-  const trustDocumentFormProps = getFormProps(props, trustConstitutionalDocumentFormId);
-  const isUnincorporatedPartnership = taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP;
-  const renderActiveForm = (activeForm2) => /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-trust", children: [
-    /* @__PURE__ */ jsx(
-      "div",
-      {
-        className: activeForm2.formId !== trustRegistrationDetailsFormId ? "adyen-kyc-form-wrapper adyen-kyc-form-wrapper--hidden" : "adyen-kyc-form-wrapper",
-        children: /* @__PURE__ */ jsx(
-          TrustRegistrationDetails,
-          {
-            ...trustRegistrationDetailsFormProps,
-            heading: i18n.get("registrationDetails"),
-            id: trustRegistrationDetailsFormId,
-            country,
-            taskType
-          }
-        )
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      "div",
-      {
-        className: activeForm2.formId !== trustRegistrationAddressFormId ? "adyen-kyc-form-wrapper adyen-kyc-form-wrapper--hidden" : "adyen-kyc-form-wrapper",
-        children: /* @__PURE__ */ jsx(
-          RegistrationAddress,
-          {
-            ...trustRegistrationAddressFormProps,
-            heading: i18n.get("addressDetails"),
-            description: !isUnincorporatedPartnership ? i18n.get("registeredAddressTrustHeaderDescription") : i18n.get("registeredAddressUnincorporatedPartnershipHeaderDescription"),
-            id: trustRegistrationAddressFormId,
-            country,
-            problems: props?.problems,
-            labels: {
-              operationalAddressIsSame: !isUnincorporatedPartnership ? "isTrustOperationAddressSame" : "isPartnershipOperationAddressSame"
-            }
-          }
-        )
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      "div",
-      {
-        className: activeForm2.formId !== trustConstitutionalDocumentFormId ? "adyen-kyc-form-wrapper adyen-kyc-form-wrapper--hidden" : "adyen-kyc-form-wrapper",
-        children: /* @__PURE__ */ jsx(
-          MemoizedConstitutionalDocument,
-          {
-            ...trustDocumentFormProps,
-            id: trustConstitutionalDocumentFormId,
-            legalEntityType: isUnincorporatedPartnership ? LegalEntityTypes.UNINCORPORATED_PARTNERSHIP : LegalEntityTypes.TRUST,
-            country
-          }
-        )
-      }
-    )
-  ] });
-  return /* @__PURE__ */ jsx("div", { className: "adyen-kyc-trust", children: renderActiveForm(activeForm || trustForms.trustRegistrationDetails) });
-}
-const mapLegalEntityToTrust = (legalEntity, isExperimentEnabled) => {
-  if (!legalEntity.trust) throw new Error("LE missing trust field");
-  let trustCompData = formatObject(legalEntity, trustComponentsKeyMapping);
-  if (!trustCompData?.trustRegistrationDetails) return {};
-  trustCompData.trustRegistrationDetails.vatNumberType = getDefaultVatNumberType(
-    legalEntity.trust.vatNumber,
-    legalEntity.trust.countryOfGoverningLaw
-  );
-  trustCompData.trustRegistrationDetails.registrationNumberType = getDefaultRegistrationNumberType(
-    legalEntity.trust.registrationNumber,
-    legalEntity.trust.countryOfGoverningLaw,
-    LegalEntityTypes.TRUST
-  );
-  trustCompData.trustRegistrationDetails.country = legalEntity.trust.countryOfGoverningLaw;
-  if (legalEntity.trust.description) {
-    trustCompData.trustRegistrationDetails.objectOfTrust = legalEntity.trust.description;
-  }
-  if (legalEntity.trust.principalPlaceOfBusiness) {
-    trustCompData.trustRegistrationAddress.operationalAddressIsSame = operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME;
-  } else {
-    if (!trustCompData.trustRegistrationAddress) {
-      trustCompData.trustRegistrationAddress = {};
-    }
-    trustCompData.trustRegistrationAddress.operationalAddressIsSame = operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_SAME;
-  }
-  if (legalEntity.trust.taxInformation?.length) {
-    const { country } = legalEntity.trust.registeredAddress;
-    const countryTaxInformation = legalEntity.trust.taxInformation.find(
-      (info) => info.country === country
-    );
-    if (countryTaxInformation?.type === "UEN") {
-      trustCompData.trustRegistrationDetails.isUen = true;
-    }
-    if (countryTaxInformation?.type === "GST") {
-      trustCompData.trustRegistrationDetails.isUen = false;
-    }
-    const taxNumberAbsent = countryTaxInformation?.numberAbsent;
-    if (taxNumberAbsent !== void 0) {
-      trustCompData.trustRegistrationDetails.exemptedFromTax = taxNumberAbsent;
-    }
-  }
-  if (legalEntity.documentDetails?.length) {
-    trustCompData = {
-      ...trustCompData,
-      ...mapApiDocumentToTrustDocument(legalEntity?.id)
-    };
-  }
-  if (isExperimentEnabled("EnableDoingBusinessAsNameV4")) {
-    if (typeof trustCompData.trustRegistrationDetails?.hasDoingBusinessAs === "boolean") {
-      trustCompData.trustRegistrationDetails.hasDoingBusinessAs = !legalEntity.trust.doingBusinessAsAbsent;
-      if (!trustCompData.trustRegistrationDetails.hasDoingBusinessAs)
-        delete legalEntity.trust?.doingBusinessAs;
-    }
-  } else {
-    trustCompData.trustRegistrationDetails.hasDoingBusinessAs = legalEntity.trust.doingBusinessAs ? legalEntity.trust.doingBusinessAs !== legalEntity.trust.name : void 0;
-    trustCompData.trustRegistrationDetails.doingBusinessAs = legalEntity.trust.doingBusinessAs;
-  }
-  return trustCompData;
-};
-const mapTrustDocumentToApiDocument = async (data, entityId) => {
-  const constitutionalDocument = data?.trustConstitutionalDocument?.constitutionalDocument;
-  if (!constitutionalDocument) {
-    throw new Error("Constitutional document missing");
-  }
-  const page1 = constitutionalDocument[0];
-  if (!page1) {
-    throw new Error("Document needs at least one page");
-  }
-  const existingDocument = getDocument(entityId, "constitutionalDocument");
-  return await createDocumentRequest({
-    entityId,
-    entityType: "legalEntity",
-    documentType: "constitutionalDocument",
-    page1,
-    existingDocument
-  });
-};
-const mapTrustToLegalEntity = (data, isExperimentEnabled) => {
-  const requestObj = {
-    ...formatObject(data, trustApiKeyMapping)
-  };
-  if (!requestObj.trust) return requestObj;
-  if (data.trustRegistrationDetails?.objectOfTrust) {
-    requestObj.trust.description = data.trustRegistrationDetails.objectOfTrust;
-  }
-  if (isExperimentEnabled("EnableDoingBusinessAsNameV4")) {
-    requestObj.trust.doingBusinessAsAbsent = typeof data.trustRegistrationDetails?.hasDoingBusinessAs !== "undefined" ? !data.trustRegistrationDetails?.hasDoingBusinessAs : void 0;
-    if (requestObj.trust.doingBusinessAsAbsent) {
-      requestObj.trust.doingBusinessAs = "";
-    }
-  } else {
-    delete requestObj.trust?.doingBusinessAsAbsent;
-    requestObj.trust.doingBusinessAs = data.trustRegistrationDetails?.doingBusinessAs || data.trustRegistrationDetails?.legalName;
-  }
-  requestObj.type = LegalEntityTypes.TRUST;
-  return requestObj;
-};
-const MANDATORY_FIELDS_TRUST = [
-  "trustRegistrationDetails.legalName",
-  "trustRegistrationDetails.country"
-];
-const trustBase = {
-  trustType: {
-    rule: "REQUIRED"
-  },
-  objectOfTrust: {
-    rule: "trustTypeHasDescription"
-  },
-  legalName: {
-    rule: "REQUIRED"
-  },
-  hasDoingBusinessAs: {
-    rule: "hasDoingBusinessAs"
-  },
-  doingBusinessAs: {
-    rule: "hasDoingBusinessAs"
-  },
-  country: {
-    rule: "REQUIRED"
-  },
-  taxInformation: {
-    rule: "countryUsesTaxId"
-  },
-  registrationAddress: {
-    rule: "REQUIRED"
-  },
-  operationalAddress: {
-    rule: "OPTIONAL"
-  },
-  constitutionalDocument: {
-    rule: "REQUIRED"
-  },
-  registrationNumber: { rule: "countryRequiresRegistrationNumberForTrust" },
-  registrationNumberType: { rule: "registrationNumberType" },
-  vatNumber: { rule: "countryUsesVatNumber" },
-  vatNumberType: { rule: "countryUsesVatNumber" }
-};
-const trustFieldsPerScenario = {
-  L0: {
-    ...trustBase
-  },
-  L1: {
-    ...trustBase
-  },
-  L: {
-    ...trustBase
-  }
-};
-const trustCountryConfig = {};
-const parseTrustScenarios = (scenarios, country) => augmentWithCountryConfigs(
-  trustCountryConfig[country],
-  composePerScenarioFormConfigurations(scenarios, trustFieldsPerScenario)
-);
-const parseConfiguration = ({ scenarios, country }) => parseTrustScenarios(scenarios, country);
-function TrustDropin({
-  parentLegalEntity,
-  capabilities,
-  country: countryProp,
-  existingTrust,
-  taskType,
-  problems: problemsProp,
-  onSubmit: externalOnSubmit,
-  onChange,
-  hideSidebar,
-  handleHomeClick
-}) {
-  const {
-    state: { currentState }
-  } = useStateContext();
-  const formValidity = currentState.validityByForm;
-  useEffect(() => {
-    onChange?.(currentState);
-  }, [currentState, onChange]);
-  const { baseUrl, rootLegalEntityId } = useApiContext();
-  const { i18n } = useI18nContext();
-  const userEvents = useAnalyticsContext();
-  const [validationErrors, setValidationErrors] = useState();
-  const datasetUtils = datasetUtilities(i18n.locale);
-  const { isExperimentEnabled } = useExperimentsContext();
-  const { showToast } = useToastContext();
-  const [loadingStatus, setLoadingStatus] = useState("success");
-  const formRef = useRef(null);
-  const isUnincorporatedPartnership = taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP;
-  const problems = useMemo(
-    () => ({
-      ...problemsProp,
-      validationErrors
-    }),
-    [problemsProp, validationErrors]
-  );
-  const trustData = useMemo(() => {
-    if (!existingTrust) return {};
-    return isUnincorporatedPartnership ? mapLegalEntityToUnincorporatedPartnership(existingTrust, isExperimentEnabled) : mapLegalEntityToTrust(existingTrust, isExperimentEnabled);
-  }, [isExperimentEnabled, existingTrust, isUnincorporatedPartnership]);
-  const currentCountry = useMemo(
-    () => currentState.data.trustRegistrationDetails?.country ?? countryProp,
-    [countryProp, currentState.data.trustRegistrationDetails?.country]
-  );
-  const [initialData, setInitialData] = useState(trustData);
-  const associatedLeTrackingParams = getAssociatedLeAnalyticsPayload({
-    associatedLegalEntity: existingTrust
-  });
-  useEffect(() => {
-    userEvents.updateBaseTrackingPayload({ task: taskType });
-    userEvents.addTaskEvent("Landed on page", {
-      actionType: "start",
-      ...associatedLeTrackingParams
-    });
-    if (!existingTrust?.documentDetails?.length) return;
-    try {
-      documentUtils.fetchDocuments(existingTrust.documentDetails, existingTrust.id).then(() => {
-        const mappedDocuments = mapApiDocumentToTrustDocument(existingTrust.id);
-        setInitialData({
-          ...initialData,
-          ...mappedDocuments
-        });
-      }).catch(() => {
-        showToast({ label: i18n.get("failedToFetchRelevantDocuments"), variant: "error" });
-      });
-    } catch {
-      showToast({ label: i18n.get("failedToFetchRelevantDocuments"), variant: "error" });
-    }
-  }, []);
-  const { fieldConfigurations, requiredFields } = useScenarioConfiguration({
-    parseConfiguration,
-    legalEntityType: LegalEntityTypes.TRUST,
-    setLoadingStatus,
-    country: currentCountry
-  });
-  const fieldsFromCustomRules = useMemo(
-    () => rules({
-      data: currentState.data,
-      country: currentCountry,
-      taskType,
-      isExperimentEnabled
-    }),
-    [currentCountry, currentState.data, taskType, requiredFields, isExperimentEnabled]
-  );
-  const derivedProps = useMemo(
-    () => getPropsFromConfigurations({
-      scenarioConfiguration: fieldConfigurations,
-      forms: trustForms,
-      remediationActions: problems?.remediationActions ? Object.values(problems?.remediationActions) : [],
-      dataMissingErrors: problems?.missingData ?? [],
-      fieldsWithExistingData: existingTrust ? getFieldsWithExistingData(existingTrust, trustApiKeyMapping, trustDocumentMapping) : [],
-      customRules: fieldsFromCustomRules,
-      legalEntityType: existingTrust?.type
-    }),
-    [
-      fieldConfigurations,
-      problems?.remediationActions,
-      problems?.missingData,
-      existingTrust,
-      fieldsFromCustomRules
-    ]
-  );
-  const forms = useMemo(() => {
-    const requiredForms = getRequiredForms(
-      trustForms,
-      derivedProps?.requiredFields,
-      derivedProps?.optionalFields
-    );
-    return addValidityToForms(requiredForms, formValidity, problems);
-  }, [derivedProps, formValidity, problems]);
-  const onSubmitTrust = async () => {
-    setLoadingStatus("loading");
-    const trustDetails = mapTrustToLegalEntity(currentState.data, isExperimentEnabled);
-    try {
-      const updatedTrust = await submitTrustDetails(trustDetails);
-      await submitDocuments({ forms, legalEntity: updatedTrust, dataSubmitted: currentState.data });
-      await attachTrustToParentLegalEntity(updatedTrust);
-      setLoadingStatus("success");
-      showToast({ label: i18n.get("successfullyUpdatedDetails"), variant: "success" });
-      externalOnSubmit?.(currentState.data);
-    } catch (e) {
-      showToast({ label: i18n.get("failedToUpdateDetails"), variant: "error" });
-      if (isValidationError(e)) {
-        setValidationErrors(processValidationErrors(e, taskType));
-      } else if (isMaintenanceModeError(e)) {
-        showToast({
-          label: i18n.get("maintenanceModeMessage"),
-          variant: "error",
-          duration: "indefinite"
-        });
-      }
-      setLoadingStatus("success");
-    }
-  };
-  const onSubmitUnincorporatedPartnership = async () => {
-    setLoadingStatus("loading");
-    const unincorporatedPartnershipDetails = mapUnincorporatedPartnershipToLegalEntity(
-      currentState.data,
-      isExperimentEnabled
-    );
-    try {
-      const updatedUnincorporatedPartnershipDetails = await submitTrustDetails(
-        unincorporatedPartnershipDetails
-      );
-      await submitDocuments({
-        forms,
-        legalEntity: updatedUnincorporatedPartnershipDetails,
-        dataSubmitted: currentState.data
-      });
-      await attachTrustToParentLegalEntity(updatedUnincorporatedPartnershipDetails);
-      setLoadingStatus("success");
-      showToast({ label: i18n.get("successfullyUpdatedDetails"), variant: "success" });
-      externalOnSubmit?.(currentState.data);
-    } catch (e) {
-      showToast({ label: i18n.get("failedToUpdateDetails"), variant: "error" });
-      if (isValidationError(e)) {
-        setValidationErrors(processValidationErrors(e, taskType));
-      } else if (isMaintenanceModeError(e)) {
-        showToast({
-          label: i18n.get("maintenanceModeMessage"),
-          variant: "error",
-          duration: "indefinite"
-        });
-      }
-      setLoadingStatus("success");
-    }
-  };
-  const { mutateAsync: createLegalEntity } = useCreateLegalEntity();
-  const { mutateAsync: updateLegalEntity } = useUpdateLegalEntity();
-  const submitTrustDetails = async (legalEntity) => {
-    if (!existingTrust) {
-      return await createLegalEntity(legalEntity);
-    } else {
-      return await updateLegalEntity({
-        ...drop("type").from(legalEntity),
-        id: existingTrust.id
-      });
-    }
-  };
-  const documentUtils = documentApiUtils({
-    baseUrl: baseUrl.value,
-    rootLegalEntityId: rootLegalEntityId.value
-  });
-  const submitDocuments = async ({
-    forms: forms2,
-    legalEntity,
-    dataSubmitted
-  }) => {
-    if (isDocumentsRequired(forms2)) {
-      const formattedDocument = await mapTrustDocumentToApiDocument(dataSubmitted, legalEntity.id);
-      if (formattedDocument) {
-        await documentUtils.uploadDocuments([formattedDocument], legalEntity.id);
-      }
-    }
-  };
-  const isDocumentsRequired = (forms2) => forms2.some((form) => form.formId === trustForms.trustConstitutionalDocument.formId);
-  const attachTrustToParentLegalEntity = async (trust) => {
-    if (existingTrust?.id) {
-      return;
-    }
-    const existingEntityAssociations = getOwnEntityAssociations(parentLegalEntity);
-    const updatedParentLegalEntity = {
-      entityAssociations: [
-        {
-          type: trust.type,
-          legalEntityId: trust.id
-        },
-        ...existingEntityAssociations
-      ]
-    };
-    await updateLegalEntity({ ...updatedParentLegalEntity, id: parentLegalEntity.id });
-  };
-  const formatDataForSummary = (formData, forms2) => {
-    let summaryData = cloneObject(formData) || {};
-    const country = formData.trustRegistrationDetails?.country ?? (existingTrust ? getLegalEntityCountry(existingTrust) : getLegalEntityCountry(parentLegalEntity));
-    if (formData.trustRegistrationDetails) {
-      const trustCountry = formData.trustRegistrationDetails.country && datasetUtils.getCountryName(formData.trustRegistrationDetails.country);
-      const trustType = formData.trustRegistrationDetails.trustType && i18n.get(formData.trustRegistrationDetails.trustType);
-      const registrationNumberLabel = resolveFieldMetadata(
-        registrationNumberDefaultFieldConfig[country],
-        {
-          companyType: LegalEntityTypes.TRUST,
-          registrationNumberType: formData.trustRegistrationDetails.registrationNumber ? inferCompanyRegistrationNumberType(
-            formData.trustRegistrationDetails.registrationNumber,
-            country,
-            LegalEntityTypes.TRUST
-          ) : getCompanyRegistrationNumberOptions(country, LegalEntityTypes.TRUST)?.[0]?.id
-        },
-        registrationNumberDefaultFieldMetadata
-      ).label;
-      const taxIdLabel = resolveFieldMetadata(
-        taxInformationDefaultFieldConfig[country],
-        {
-          companyType: LegalEntityTypes.TRUST,
-          taxIdNumberType: countryToTaxInfoTypeMap[country]
-        },
-        taxInformationDefaultFieldMetadata
-      ).label;
-      summaryData.trustRegistrationDetails = {
-        [isUnincorporatedPartnership ? "legalName" : "nameOfTrustAgreement"]: formData.trustRegistrationDetails?.legalName,
-        doingBusinessAs: formData.trustRegistrationDetails?.doingBusinessAs,
-        countryRegionOfEstablishment: trustCountry,
-        typeOfTrustAgreement: isUnincorporatedPartnership ? void 0 : trustType,
-        objectOfTrust: formData.trustRegistrationDetails?.objectOfTrust,
-        [taxIdLabel]: formData.trustRegistrationDetails?.taxInformation?.find(
-          (taxId) => country === taxId.country
-        )?.number,
-        [registrationNumberLabel]: formData.trustRegistrationDetails.registrationNumber
-      };
-    }
-    if (formData.trustRegistrationAddress?.registrationAddress) {
-      summaryData.trustRegistrationAddress.hasInnerForms = true;
-      summaryData.trustRegistrationAddress.registrationAddress = mapAddressLabels(
-        formData.trustRegistrationAddress.registrationAddress,
-        datasetUtils
-      );
-    }
-    if (formData.trustRegistrationAddress?.operationalAddress) {
-      summaryData.trustRegistrationAddress.operationalAddress = mapAddressLabels(
-        formData.trustRegistrationAddress.operationalAddress,
-        datasetUtils
-      );
-    }
-    if (isDocumentsRequired(forms2)) {
-      summaryData = {
-        ...summaryData,
-        ...formatFileSummaryData(formData.trustConstitutionalDocument)
-      };
-    } else {
-      delete summaryData[trustConstitutionalDocumentFormId];
-    }
-    return summaryData;
-  };
-  const formatFileSummaryData = (trustConstitutionalDocument) => {
-    const constitutionalDocument = trustConstitutionalDocument?.constitutionalDocument?.[0];
-    return {
-      ...constitutionalDocument && {
-        trustConstitutionalDocument: {
-          fileName: constitutionalDocument.name
-        }
-      }
-    };
-  };
-  const canSubmit = (formData) => MANDATORY_FIELDS_TRUST.every((detail) => {
-    const value = getProp(formData, detail);
-    return !isEmpty$1(value);
-  });
-  const {
-    handleNextClick,
-    handleBackClick,
-    activeForm,
-    shouldValidate,
-    setShouldValidate,
-    gotoFormByFormIndex,
-    steps
-  } = useFormComposer({
-    problems,
-    navigationTrackingParams: associatedLeTrackingParams,
-    forms,
-    onSubmit: isUnincorporatedPartnership ? onSubmitUnincorporatedPartnership : onSubmitTrust
-  });
-  return /* @__PURE__ */ jsx(
-    FormWrapper,
-    {
-      taskName: isUnincorporatedPartnership ? "unincorporatedDetails" : "trustDetails",
-      handleNextClick,
-      handleBackClick,
-      gotoFormByFormIndex,
-      loadingStatus,
-      forms,
-      activeForm,
-      navigationTrackingParams: associatedLeTrackingParams,
-      onSubmit: isUnincorporatedPartnership ? onSubmitUnincorporatedPartnership : onSubmitTrust,
-      hideSidebar,
-      handleHomeClick,
-      validateForm: () => setShouldValidate(true),
-      canSubmit: canSubmit(currentState.data) && hasDataChanged(initialData, currentState.data),
-      problems,
-      summary: {
-        data: formatDataForSummary(currentState.data, forms),
-        omitted: {
-          keys: ["operationalAddressIsSame"]
-        }
-      },
-      steps,
-      children: /* @__PURE__ */ jsx(
-        Trust,
-        {
-          ...derivedProps,
-          activeForm,
-          capabilities,
-          data: initialData,
-          country: currentCountry,
-          problems,
-          shouldValidate,
-          ref: formRef,
-          taskType
-        }
-      )
-    }
-  );
-}
-const TrustDetailsPage = ({
-  taskType,
-  trustId,
-  handleHomeClick,
-  onSubmit
-}) => {
-  const { data: trustLe } = useLegalEntity(trustId ?? skipToken);
-  const { data: rootLe } = useLegalEntity(ROOT_LE);
-  const capabilities = useCapabilities();
-  const capabilityNames = capabilities ? keysOf(capabilities) : [];
-  const capabilityProblems = useCapabilityProblems();
-  const problems = capabilityProblems && trustId ? getProblemsForEntity(capabilityProblems, EntityTypes.LEGAL_ENTITY, trustId) : void 0;
-  if (trustId && !trustLe || !rootLe) {
-    return /* @__PURE__ */ jsx(Loader, {});
-  }
-  const country = getLegalEntityCountry(trustLe ?? rootLe);
-  return /* @__PURE__ */ jsx(
-    TrustDropin,
-    {
-      taskType,
-      problems,
-      existingTrust: trustLe,
-      parentLegalEntity: rootLe,
-      capabilities: capabilityNames,
-      country,
-      handleHomeClick,
-      onSubmit
-    }
-  );
-};
-export {
-  TrustDetailsPage
-};