@adyen/kyc-components 4.0.0-compact.3 → 4.0.0-compact.7

package/dist/TrustMemberRoleAndTypePage-C_NPNe6_.js

@@ -1,985 +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] = "d37d4836-3f11-472e-8782-2afa42fbb940", e._sentryDebugIdIdentifier = "sentry-dbid-d37d4836-3f11-472e-8782-2afa42fbb940");
-  } catch (e) {
-  }
-}
-;
-import { r as LegalEntityTypes, ag as TrustMemberTypes, W as isEmpty, u as useTranslation, X as useExperimentsContext, c as useLegalEntity, w as skipToken, af as getOwnEntityAssociations, C as CountryCodes, P as createLogger, a as addResourceBundles, L as Loader, g as getLegalEntityCountry, _ as __variableDynamicImportRuntimeHelper } from "./StoreProvider-jtUYKLRz.js";
-import { jsxs, jsx, Fragment } from "preact/jsx-runtime";
-import { Q as defaultFieldMetadata, S as defaultFieldConfig, ad as isNewEntity, ae as LegalCompanyNameField, af as LEGAL_COMPANY_NAME_FIELD, ac as useTrustMembers } from "./OnboardingDropinComponent-D3dYF_4W.js";
-import { useEffect, useState } from "preact/hooks";
-import { u as useCreateLegalEntity } from "./useCreateLegalEntity-BvvwB9r0.js";
-import { u as useUpdateLegalEntity } from "./useUpdateLegalEntity-Q3Icdeo6.js";
-import { a as useToastContext } from "./useToastContext-FI3dwzzs.js";
-import { A as ActionBar } from "./ActionBar-Dzrzolec.js";
-import { D as DropinLayout } from "./DropinLayout-CBP_cHLC.js";
-import { F as FormNavigation } from "./FormNavigation-DL47b_QR.js";
-import { s as summaryStep, S as Summary } from "./Summary-COehg8IT.js";
-import { u as useForm, F as Field } from "./useForm-DLxHtZTP.js";
-import { m as mergeFieldMetadataIntoProps, d as getFieldProps, H as Header, E as ErrorPanel, c as createFormUtils, C as CountryField, b as COUNTRY_FIELD, s as summaryItem, f as getRoleName } from "./CountryField-CzRN1OE8.js";
-import { a3 as MultiSelectList, a4 as makeSelectItemForRole, a5 as Name, a6 as nameFields } from "./IndividualOnfido-CmmyKC7J.js";
-import { r as resolveFieldMetadata, R as RadioGroupCard, t as TextArea } from "./Spacer-D4I0f08n.js";
-import { t as trustMemberLegalEntityTypes, i as isOrganizationAndSettlor, s as settlorExemptionReasonWithNoneOfTheAbove, c as couldBeExemptSettlor, a as isExemptSettlor } from "./types-BnnF5_7m.js";
-const convertExistingSettlorExemptionReasons = (existingReasons) => {
-  if (!existingReasons || !existingReasons.length) return ["noneOfTheAbove"];
-  return existingReasons;
-};
-const convertExistingTrustMember = (trustMember) => {
-  switch (trustMember.trustMemberType) {
-    case "undefinedBeneficiary":
-      return {
-        entityType: LegalEntityTypes.INDIVIDUAL,
-        role: ["undefinedBeneficiary"],
-        descriptionUndefinedBeneficiary: trustMember.description
-      };
-    case "regular":
-    case "company":
-      return {
-        entityType: trustMember.legalEntityType,
-        role: trustMember.roles,
-        settlorExemptionReason: ["noneOfTheAbove"],
-        country: trustMember.trustMemberType === "company" ? trustMember.country : void 0,
-        legalCompanyName: trustMember.trustMemberType === "company" ? trustMember.name : void 0
-      };
-    case "rootTrustee":
-      return {
-        trustMemberType: trustMember.trustMemberType,
-        entityType: trustMember.legalEntityType,
-        role: trustMember.roles,
-        settlorExemptionReason: ["noneOfTheAbove"]
-      };
-    case "exemptSettlor":
-      return {
-        entityType: trustMember.legalEntityType,
-        role: ["settlor"],
-        settlorExemptionReason: convertExistingSettlorExemptionReasons(
-          trustMember.settlorExemptionReason
-        ),
-        firstName: trustMember.exemptSettlorName?.firstName,
-        lastName: trustMember.exemptSettlorName?.lastName,
-        legalCompanyName: trustMember.name,
-        country: trustMember.country
-      };
-  }
-};
-const convertRootTrusteeTrustMember = (trustMember) => ({
-  trustMemberType: trustMember.trustMemberType,
-  entityType: trustMember.legalEntityType,
-  role: trustMember.roles,
-  settlorExemptionReason: ["noneOfTheAbove"]
-});
-const allowedCrossoverRolesMatrix = {
-  settlor: ["secondaryTrustee", "protector"],
-  secondaryTrustee: ["settlor", "protector", "definedBeneficiary"],
-  protector: ["settlor", "secondaryTrustee", "definedBeneficiary"],
-  definedBeneficiary: ["secondaryTrustee", "protector"],
-  undefinedBeneficiary: []
-};
-const allowedCrossoverRolesMatrixByTrustMemberAndLegalEntityType = {
-  rootTrustee: {
-    [LegalEntityTypes.INDIVIDUAL]: {
-      settlor: ["secondaryTrustee", "protector"],
-      secondaryTrustee: ["settlor", "protector", "definedBeneficiary"],
-      protector: ["settlor", "secondaryTrustee", "definedBeneficiary"],
-      definedBeneficiary: ["secondaryTrustee", "protector"],
-      undefinedBeneficiary: []
-    },
-    [LegalEntityTypes.ORGANIZATION]: {
-      settlor: ["secondaryTrustee", "protector"],
-      secondaryTrustee: ["settlor", "protector"],
-      protector: ["settlor", "secondaryTrustee"],
-      definedBeneficiary: [],
-      undefinedBeneficiary: []
-    }
-  }
-};
-const getAllowedCrossoverRolesMatrixByTrustMemberAndLegalEntityType = (trustMember) => {
-  const { trustMemberType } = trustMember;
-  if (trustMemberType === "undefinedBeneficiary") {
-    return allowedCrossoverRolesMatrix;
-  }
-  const crossoverRolesByTrustMember = allowedCrossoverRolesMatrixByTrustMemberAndLegalEntityType[trustMemberType];
-  if (!crossoverRolesByTrustMember) {
-    return allowedCrossoverRolesMatrix;
-  }
-  const crossoverRoles = crossoverRolesByTrustMember[trustMember.legalEntityType];
-  if (!crossoverRoles) {
-    return allowedCrossoverRolesMatrix;
-  }
-  return crossoverRoles;
-};
-const availablesRolesByTrustMemberTypeAndLegalEntityType = {
-  rootTrustee: {
-    [LegalEntityTypes.INDIVIDUAL]: ["settlor", "protector", "definedBeneficiary"],
-    [LegalEntityTypes.ORGANIZATION]: ["settlor", "protector"]
-  }
-};
-const getAvailableRolesByTrustMemberTypeAndLegalEntityType = (currentRoles, trustMember) => {
-  if (!currentRoles?.length) {
-    const { trustMemberType, legalEntityType } = trustMember;
-    const availableRolesByTrustMemberType = availablesRolesByTrustMemberTypeAndLegalEntityType[trustMemberType];
-    if (!availableRolesByTrustMemberType) {
-      return Object.values(TrustMemberTypes);
-    }
-    const availableRoles = availableRolesByTrustMemberType[legalEntityType];
-    if (!availableRoles) {
-      return Object.values(TrustMemberTypes);
-    }
-    return availableRoles;
-  }
-  const crossoverRolesMatrix = trustMember ? getAllowedCrossoverRolesMatrixByTrustMemberAndLegalEntityType(trustMember) : allowedCrossoverRolesMatrix;
-  const roles = currentRoles.map((role) => [role, ...crossoverRolesMatrix[role]]).reduce(
-    (existingAllowed, allowedForRole) => existingAllowed.filter((role) => allowedForRole.includes(role))
-  );
-  return roles.filter((r) => r !== "secondaryTrustee");
-};
-const getAvailableRoles = (currentRoles) => {
-  if (!currentRoles?.length) return Object.values(TrustMemberTypes);
-  return currentRoles.map((role) => [role, ...allowedCrossoverRolesMatrix[role]]).reduce(
-    (existingAllowed, allowedForRole) => existingAllowed.filter((role) => allowedForRole.includes(role))
-  );
-};
-const roleAndTypeValidationRules = {
-  entityType: {
-    modes: ["blur"],
-    validate: (entityType) => !isEmpty(entityType),
-    errorMessage: "fieldIsRequired"
-  },
-  role: {
-    modes: ["blur"],
-    validate: (role) => !!role?.length,
-    errorMessage: "fieldIsRequired"
-  },
-  descriptionUndefinedBeneficiary: {
-    modes: ["blur"],
-    validate: (description) => !isEmpty(description),
-    errorMessage: "fieldIsRequired"
-  },
-  settlorExemptionReason: {
-    modes: ["blur"],
-    validate: (reasons) => Boolean(reasons?.length),
-    errorMessage: "fieldIsRequired"
-  },
-  country: {
-    modes: ["blur"],
-    validate: (country) => !!country,
-    errorMessage: "fieldIsRequired"
-  },
-  legalCompanyName: {
-    modes: ["blur"],
-    validate: (name) => !!name,
-    errorMessage: "fieldIsRequired"
-  }
-};
-const CHARACTERS_LIMIT = 256;
-const leTypeCardDetails = {
-  [LegalEntityTypes.INDIVIDUAL]: {
-    id: "individual",
-    name: "naturalPersonTitle",
-    description: "naturalPersonDescription"
-  },
-  [LegalEntityTypes.ORGANIZATION]: {
-    id: "organization",
-    name: "businessEntityTitle",
-    description: "businessEntityDescription"
-  }
-};
-const convertExistingTrustMemberToDefaultData = (trustMember, allowMoreRolesForMainRootTrusteeEnabled) => {
-  if (!trustMember) {
-    return {};
-  }
-  if (allowMoreRolesForMainRootTrusteeEnabled && trustMember.trustMemberType === "rootTrustee") {
-    return convertRootTrusteeTrustMember(trustMember);
-  }
-  return convertExistingTrustMember(trustMember);
-};
-const TrustRoleAndEntityType = (props) => {
-  const { t } = useTranslation(["common", "trust"]);
-  const {
-    existingTrustMember,
-    isOrganizationSettlorWithExemptionEnabled,
-    onChange,
-    id,
-    country,
-    fieldValidationErrors,
-    formVerificationErrors
-  } = props;
-  const trustRoleAndEntityTypeCountry = country;
-  let mergedProps = props;
-  mergedProps = mergeFieldMetadataIntoProps(
-    "legalCompanyName",
-    resolveFieldMetadata(
-      defaultFieldConfig[trustRoleAndEntityTypeCountry],
-      { isBusiness: false },
-      defaultFieldMetadata
-    ),
-    mergedProps
-  );
-  const { isExperimentEnabled } = useExperimentsContext();
-  const allowMoreRolesForMainRootTrusteeEnabled = isExperimentEnabled(
-    "AllowMoreRolesForMainRootTrustee"
-  );
-  const defaultData = convertExistingTrustMemberToDefaultData(
-    existingTrustMember,
-    allowMoreRolesForMainRootTrusteeEnabled
-  );
-  const formUtils = createFormUtils(mergedProps, t);
-  const decideFields = (data2) => {
-    if (data2.role?.includes("undefinedBeneficiary")) {
-      return ["role", "descriptionUndefinedBeneficiary"];
-    }
-    if (data2.role?.length) {
-      if (isOrganizationSettlorWithExemptionEnabled && isOrganizationAndSettlor(data2)) {
-        return ["role", "entityType", "settlorExemptionReason", "country", "legalCompanyName"];
-      }
-      if (couldBeExemptSettlor(data2, country)) {
-        return isExemptSettlor(data2) ? ["role", "entityType", "settlorExemptionReason", "firstName", "lastName"] : ["role", "entityType", "settlorExemptionReason"];
-      }
-      return allowMoreRolesForMainRootTrusteeEnabled ? ["role", "entityType", "trustMemberType"] : ["role", "entityType"];
-    }
-    return ["role"];
-  };
-  const { data, valid, schema, errors, fieldProblems, handleChangeFor, isValid } = useForm({
-    ...props,
-    schema: decideFields,
-    rules: roleAndTypeValidationRules,
-    defaultData,
-    fieldProblems: fieldValidationErrors
-  });
-  const availableRoles = allowMoreRolesForMainRootTrusteeEnabled && existingTrustMember?.trustMemberType === "rootTrustee" ? getAvailableRolesByTrustMemberTypeAndLegalEntityType(data.role, existingTrustMember) : getAvailableRoles(data.role);
-  const { data: exemptSettlorLe } = useLegalEntity(
-    isOrganizationSettlorWithExemptionEnabled && existingTrustMember && existingTrustMember.trustMemberType === "exemptSettlor" && existingTrustMember.legalEntityId !== isNewEntity && existingTrustMember.roles !== void 0 && existingTrustMember.roles.length === 1 && existingTrustMember.roles[0] === "settlor" ? existingTrustMember.legalEntityId : skipToken
-  );
-  useEffect(() => {
-    if (exemptSettlorLe && exemptSettlorLe.organization) {
-      handleChangeFor("country")(exemptSettlorLe.organization.registeredAddress.country);
-    }
-  }, [exemptSettlorLe]);
-  useEffect(() => {
-    onChange?.({
-      schema,
-      data,
-      errors,
-      valid,
-      isValid,
-      dataStoreId: id,
-      fieldProblems
-    });
-  }, [schema, data, isValid, t, errors, valid, id, fieldProblems]);
-  const onInputDescription = (e) => {
-    const { value } = e.currentTarget;
-    handleChangeFor("descriptionUndefinedBeneficiary")(value);
-  };
-  const changeRoles = (roles) => {
-    handleChangeFor("role")(roles);
-    if (roles.includes("undefinedBeneficiary")) {
-      handleChangeFor("entityType")(void 0);
-    } else {
-      handleChangeFor("descriptionUndefinedBeneficiary")(void 0);
-    }
-  };
-  const changeSettlorExemptionReasons = (exemptionReasons) => {
-    if (exemptionReasons.includes("noneOfTheAbove")) {
-      handleChangeFor("settlorExemptionReason")(
-        data.settlorExemptionReason?.includes("noneOfTheAbove") ? exemptionReasons.filter((reason) => reason !== "noneOfTheAbove") : ["noneOfTheAbove"]
-      );
-      return;
-    }
-    handleChangeFor("settlorExemptionReason")(exemptionReasons);
-  };
-  const nameProps = getFieldProps(props, nameFields);
-  const onEntityTypeChange = (value) => {
-    if (isOrganizationSettlorWithExemptionEnabled && value === LegalEntityTypes.ORGANIZATION && data.role?.length === 1 && data.role[0] === "settlor") {
-      changeSettlorExemptionReasons(["professionalServiceProvider"]);
-    }
-    handleChangeFor("entityType")(value);
-  };
-  return /* @__PURE__ */ jsxs("form", { className: "adyen-kyc-trust__role-and-entity-type adyen-kyc-u-width-full", children: [
-    /* @__PURE__ */ jsx(Header, { title: t(($) => $["roleAndEntityType"]) }),
-    /* @__PURE__ */ jsx(
-      ErrorPanel,
-      {
-        verificationErrors: formVerificationErrors,
-        validationErrors: fieldValidationErrors,
-        formUtils,
-        id: "ariaErrorField"
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      Field,
-      {
-        el: "fieldset",
-        name: "role",
-        label: formUtils.getLabel("role", "selectTheApplicableRoles"),
-        errorMessage: formUtils.getErrorMessage("role", errors, fieldProblems),
-        isValid: valid.role,
-        disabled: availableRoles.length === 0,
-        showErrorIconBottom: true,
-        children: (childProps) => /* @__PURE__ */ jsx(
-          MultiSelectList,
-          {
-            ...childProps,
-            options: Object.values(TrustMemberTypes),
-            selected: data.role ?? [],
-            onSelect: changeRoles,
-            mapToSelectItem: (role) => ({
-              ...makeSelectItemForRole(role, t),
-              disabled: !availableRoles.includes(role)
-            })
-          }
-        )
-      }
-    ),
-    schema?.includes("entityType") && /* @__PURE__ */ jsx(
-      Field,
-      {
-        el: "fieldset",
-        name: "entityType",
-        errorMessage: formUtils.getErrorMessage("entityType", errors, fieldProblems),
-        label: formUtils.getLabel("entityType", "whatTypeOfYourMembersEntity"),
-        classNameModifiers: ["entityType"],
-        disabled: Boolean(existingTrustMember),
-        children: (childProps) => /* @__PURE__ */ jsx(
-          RadioGroupCard,
-          {
-            ...childProps,
-            name: "entityType",
-            options: trustMemberLegalEntityTypes,
-            onSelect: onEntityTypeChange,
-            selected: data.entityType,
-            optionId: (option) => leTypeCardDetails[option].id,
-            optionName: (option) => t(($) => $[leTypeCardDetails[option].name], { ns: "trust" }),
-            optionDescription: (option) => t(($) => $[leTypeCardDetails[option].description], { ns: "trust" }),
-            "aria-required": true,
-            "aria-invalid": !valid.entityType,
-            floatingRadio: true
-          }
-        )
-      }
-    ),
-    schema?.includes("descriptionUndefinedBeneficiary") && /* @__PURE__ */ jsx(
-      Field,
-      {
-        name: "descriptionUndefinedBeneficiary",
-        label: formUtils.getLabel("description"),
-        isValid: valid.descriptionUndefinedBeneficiary,
-        errorMessage: formUtils.getErrorMessage(
-          "descriptionUndefinedBeneficiary",
-          errors,
-          fieldProblems
-        ),
-        children: (childProps) => /* @__PURE__ */ jsx(
-          TextArea,
-          {
-            ...childProps,
-            name: "descriptionUndefinedBeneficiary",
-            value: data.descriptionUndefinedBeneficiary,
-            maxLength: CHARACTERS_LIMIT,
-            onInput: onInputDescription,
-            helper: t(($) => $["describeWhoIsABeneficiaryInYourTrust"], { ns: "trust" }),
-            "aria-required": true,
-            "aria-invalid": !valid.descriptionUndefinedBeneficiary
-          }
-        )
-      }
-    ),
-    schema?.includes("settlorExemptionReason") && !isOrganizationAndSettlor(data) && /* @__PURE__ */ jsx(
-      Field,
-      {
-        el: "fieldset",
-        name: "settlorExemptionReason",
-        label: formUtils.getLabel("settlorExemptionReason", "whichOfTheseApplyToTheSettlor"),
-        isValid: valid.settlorExemptionReason,
-        errorMessage: formUtils.getErrorMessage("settlorExemptionReason", errors, fieldProblems),
-        showErrorIconBottom: true,
-        children: (childProps) => /* @__PURE__ */ jsx(
-          MultiSelectList,
-          {
-            ...childProps,
-            options: settlorExemptionReasonWithNoneOfTheAbove,
-            selected: data.settlorExemptionReason ?? [],
-            onSelect: changeSettlorExemptionReasons,
-            mapToSelectItem: (reason) => ({
-              id: reason,
-              name: t(($) => $[reason], { ns: "trust" })
-            })
-          }
-        )
-      }
-    ),
-    data.trustMemberType !== "rootTrustee" && (schema.includes("firstName") || schema.includes("lastName")) ? /* @__PURE__ */ jsx(
-      Name,
-      {
-        ...nameProps,
-        data: {
-          firstName: defaultData.firstName,
-          lastName: defaultData.lastName
-        },
-        requiredFields: schema.filter(
-          (field) => nameFields.includes(field)
-        ),
-        labels: {
-          firstName: "firstNameOfSettlor",
-          lastName: "lastNameOfSettlor",
-          enterNameExactlyAsAppearInID: "enterSettlorsFirstNameExactlyAsItAppearsInID",
-          enterLastNameExactlyAsAppearInID: "enterSettlorsLastNameExactlyAsItAppearsInID"
-        },
-        errors,
-        fieldValidationErrors: fieldProblems,
-        handleFieldChange: handleChangeFor,
-        valid,
-        dataStoreId: id
-      }
-    ) : void 0,
-    isOrganizationSettlorWithExemptionEnabled && schema?.includes("country") && schema?.includes("legalCompanyName") ? /* @__PURE__ */ jsxs(Fragment, { children: [
-      /* @__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),
-          readonly: false,
-          allowedCountries: void 0,
-          handleChangeFor
-        }
-      ),
-      /* @__PURE__ */ jsx(
-        LegalCompanyNameField,
-        {
-          data: formUtils.getFieldData(data, LEGAL_COMPANY_NAME_FIELD),
-          valid: formUtils.getFieldValid(valid, LEGAL_COMPANY_NAME_FIELD),
-          errors: formUtils.getFieldErrors(errors, fieldProblems, LEGAL_COMPANY_NAME_FIELD),
-          labels: formUtils.getFieldLabels(LEGAL_COMPANY_NAME_FIELD),
-          helperText: formUtils.getFieldHelperText(LEGAL_COMPANY_NAME_FIELD, {
-            legalCompanyName: "legalCompanyName__helperText"
-          }),
-          readonly: false,
-          handleChangeFor
-        }
-      )
-    ] }) : void 0
-  ] });
-};
-const mapTrustMemberToEntityAssociations = (trustMember) => {
-  if (trustMember.legalEntityId === isNewEntity) {
-    throw Error("Cannot map a new trust member, you must create it first");
-  }
-  if (trustMember.trustMemberType === "exemptSettlor")
-    return [
-      {
-        legalEntityId: trustMember.legalEntityId,
-        entityType: trustMember.legalEntityType,
-        type: TrustMemberTypes.SETTLOR,
-        settlorExemptionReason: trustMember.settlorExemptionReason,
-        name: trustMember.legalEntityType === LegalEntityTypes.INDIVIDUAL ? `${trustMember.exemptSettlorName?.firstName} ${trustMember.exemptSettlorName?.lastName}` : trustMember.name ?? ""
-      }
-    ];
-  return trustMember.roles.map((role) => ({
-    legalEntityId: trustMember.legalEntityId,
-    type: role
-  }));
-};
-const addOrUpdateAssociatedTrustMember = async ({
-  newOrUpdated,
-  trust,
-  updateLegalEntity
-}) => {
-  const otherAssociations = getOwnEntityAssociations(trust).filter(
-    (existingAssociation) => existingAssociation.legalEntityId !== newOrUpdated.legalEntityId
-  );
-  const updatedAssociations = mapTrustMemberToEntityAssociations(newOrUpdated);
-  const patchLE = {
-    entityAssociations: [...otherAssociations, ...updatedAssociations]
-  };
-  await updateLegalEntity({ ...patchLE, id: trust.id });
-};
-const updateRootTrusteeTrustMember = async ({
-  trustMember,
-  trust,
-  updateLegalEntity
-}) => {
-  const otherAssociations = getOwnEntityAssociations(trust).filter(
-    (existingAssociation) => existingAssociation.legalEntityId !== trustMember.legalEntityId
-  );
-  const updatedAssociations = mapRootTrustMemberToEntityAssociations(trustMember);
-  const patchLE = {
-    entityAssociations: [...otherAssociations, ...updatedAssociations]
-  };
-  await updateLegalEntity({ ...patchLE, id: trust.id });
-};
-const mapRootTrustMemberToEntityAssociations = (trustMember) => trustMember.roles.filter((r) => r !== "secondaryTrustee").map((role) => ({
-  legalEntityId: trustMember.legalEntityId,
-  type: role
-}));
-const addOrUpdateUndefinedBeneficiary = async ({
-  newOrUpdated,
-  trust,
-  updateLegalEntity
-}) => {
-  const otherUndefinedBeneficiaries = trust.trust?.undefinedBeneficiaryInfo?.filter(
-    (ub) => ub.reference !== newOrUpdated.reference
-  ) ?? [];
-  const patchLE = {
-    trust: {
-      undefinedBeneficiaryInfo: [
-        ...otherUndefinedBeneficiaries,
-        newOrUpdated.reference === isNewEntity ? {
-          description: newOrUpdated.description
-        } : {
-          reference: newOrUpdated.reference,
-          description: newOrUpdated.description
-        }
-      ]
-    }
-  };
-  await updateLegalEntity({ ...patchLE, id: trust.id });
-};
-const createExemptSettlor = async ({
-  exemptSettlor,
-  trust,
-  handleCreateLegalEntity
-}) => {
-  const exemptSettlorLE = {
-    type: LegalEntityTypes.INDIVIDUAL,
-    individual: {
-      name: {
-        firstName: exemptSettlor.exemptSettlorName?.firstName ?? "",
-        lastName: exemptSettlor.exemptSettlorName?.lastName ?? ""
-      },
-      residentialAddress: {
-        country: trust.trust.registeredAddress.country
-      }
-    }
-  };
-  return handleCreateLegalEntity(exemptSettlorLE);
-};
-const createOrganizationExemptSettlor = async ({
-  exemptSettlor,
-  handleCreateLegalEntity
-}) => {
-  const exemptSettlorLE = {
-    type: LegalEntityTypes.ORGANIZATION,
-    organization: {
-      legalName: exemptSettlor.name ?? "",
-      registeredAddress: {
-        country: exemptSettlor.country ?? "NL"
-      }
-    }
-  };
-  return handleCreateLegalEntity(exemptSettlorLE);
-};
-const exemptSettlorNamesTheSame = (existingSettlor, newSettlor) => JSON.stringify(existingSettlor.exemptSettlorName) === JSON.stringify(newSettlor.exemptSettlorName);
-const updateExemptSettlorName = async ({
-  exemptSettlor,
-  updateLegalEntity
-}) => {
-  const exemptSettlorPatch = {
-    individual: {
-      name: {
-        firstName: exemptSettlor.exemptSettlorName?.firstName,
-        lastName: exemptSettlor.exemptSettlorName?.lastName
-      }
-    }
-  };
-  return updateLegalEntity({
-    ...exemptSettlorPatch,
-    id: exemptSettlor.legalEntityId
-  });
-};
-const updateOrganizationExemptSettlorName = async ({
-  exemptSettlor,
-  updateLegalEntity
-}) => {
-  const exemptSettlorPatch = {
-    organization: {
-      legalName: exemptSettlor.name,
-      registeredAddress: {
-        country: exemptSettlor.country
-      }
-    }
-  };
-  return updateLegalEntity({
-    ...exemptSettlorPatch,
-    id: exemptSettlor.legalEntityId
-  });
-};
-const settlorExemptionReasonsList = "adyen-kyc-settlor-exemption-reasons-list";
-const styles = {
-  settlorExemptionReasonsList
-};
-const formatRolesForSummary = (roles, commonT) => roles.map((role) => commonT(($) => $[getRoleName(role)])).join(", ");
-const formatSettlorExemptionReasonsForSummary = (reasons, trustT) => /* @__PURE__ */ jsx("ul", { className: styles.settlorExemptionReasonsList, children: reasons.map((reason) => /* @__PURE__ */ jsx("li", { children: trustT(($) => $[reason]) }, reason)) });
-const formatRoleAndEntityTypeSummary = (data, commonT, trustT, isOrganizationSettlorWithExemptionEnabled) => {
-  const { trustMemberType, roles } = data;
-  const role = formatRolesForSummary(roles, commonT);
-  switch (trustMemberType) {
-    case "undefinedBeneficiary":
-      return {
-        role,
-        descriptionUndefinedBeneficiary: data.description
-      };
-    case "exemptSettlor":
-      return {
-        role,
-        entityType: trustT(($) => $[data.legalEntityType]),
-        firstName: data.exemptSettlorName?.firstName,
-        lastName: data.exemptSettlorName?.lastName,
-        country: isOrganizationSettlorWithExemptionEnabled ? data.country : void 0,
-        legalCompanyName: isOrganizationSettlorWithExemptionEnabled ? data.name : void 0,
-        settlorExemptionReason: summaryItem(
-          "otherInformation",
-          formatSettlorExemptionReasonsForSummary(data.settlorExemptionReason ?? [], trustT)
-        )
-      };
-    case "company":
-    case "rootTrustee":
-    case "regular":
-      return {};
-  }
-};
-const summary = {
-  formId: "summary",
-  formName: "summary"
-};
-const regularForms = {
-  roleAndEntityType: {
-    formId: "roleAndEntityType",
-    formName: "roleAndEntityType",
-    fields: ["role", "entityType"]
-  },
-  memberDetails: {
-    formId: "memberDetails",
-    formName: "memberDetails"
-  },
-  summary
-};
-const undefinedBeneficiaryForms = {
-  roleAndEntityType: {
-    formId: "roleAndEntityType",
-    formName: "roleAndEntityType",
-    fields: ["role", "entityType", "descriptionUndefinedBeneficiary"]
-  },
-  summary
-};
-const exemptSettlorForms = {
-  roleAndEntityType: {
-    formId: "roleAndEntityType",
-    formName: "roleAndEntityType",
-    fields: ["role", "entityType", "settlorExemptionReason"]
-  },
-  summary
-};
-const decideForms = (trustMember) => {
-  if (trustMember === "incomplete") return regularForms;
-  switch (trustMember.trustMemberType) {
-    case "undefinedBeneficiary":
-      return undefinedBeneficiaryForms;
-    case "exemptSettlor":
-      return exemptSettlorForms;
-    case "rootTrustee":
-      return exemptSettlorForms;
-    case "regular":
-    case "company":
-      return regularForms;
-  }
-};
-const convertDataToTrustMember = (data, existingTrustMember, isOrganizationSettlorWithExemptionReasonEnabled = false) => {
-  const existingId = existingTrustMember ? existingTrustMember.trustMemberType === "undefinedBeneficiary" ? existingTrustMember.reference : existingTrustMember.legalEntityId : void 0;
-  if (data.trustMemberType === "rootTrustee") {
-    return {
-      trustMemberType: "rootTrustee",
-      roles: data.role ?? [],
-      legalEntityType: data.entityType ?? LegalEntityTypes.ORGANIZATION,
-      legalEntityId: "",
-      name: data.firstName ?? ""
-    };
-  }
-  if (data.role?.length) {
-    if (isExemptSettlor(data)) {
-      if (isOrganizationSettlorWithExemptionReasonEnabled && data.entityType === LegalEntityTypes.ORGANIZATION) {
-        return {
-          trustMemberType: "exemptSettlor",
-          roles: [TrustMemberTypes.SETTLOR],
-          legalEntityType: LegalEntityTypes.ORGANIZATION,
-          legalEntityId: existingId ?? isNewEntity,
-          name: data.legalCompanyName ?? "",
-          settlorExemptionReason: ["professionalServiceProvider"],
-          country: data.country
-        };
-      }
-      return {
-        trustMemberType: "exemptSettlor",
-        roles: [TrustMemberTypes.SETTLOR],
-        legalEntityType: LegalEntityTypes.INDIVIDUAL,
-        settlorExemptionReason: data.settlorExemptionReason.filter(
-          (reason) => reason !== "noneOfTheAbove"
-        ),
-        exemptSettlorName: {
-          firstName: data.firstName ?? "",
-          lastName: data.lastName ?? ""
-        },
-        legalEntityId: existingId ?? isNewEntity
-      };
-    }
-    if (data.role.includes("undefinedBeneficiary"))
-      return {
-        trustMemberType: "undefinedBeneficiary",
-        roles: [TrustMemberTypes.UNDEFINED_BENEFICIARY],
-        description: data.descriptionUndefinedBeneficiary ?? "",
-        reference: existingId ?? isNewEntity
-      };
-    if (data.entityType === LegalEntityTypes.ORGANIZATION) {
-      return {
-        trustMemberType: "company",
-        roles: data.role,
-        legalEntityType: LegalEntityTypes.ORGANIZATION,
-        legalEntityId: existingId ?? isNewEntity,
-        name: data.legalCompanyName ?? "",
-        country: data.country
-      };
-    }
-    if (data.entityType === LegalEntityTypes.INDIVIDUAL)
-      return {
-        trustMemberType: "regular",
-        roles: data.role,
-        legalEntityType: LegalEntityTypes.INDIVIDUAL,
-        legalEntityId: existingId ?? isNewEntity,
-        name: ""
-      };
-  }
-  return "incomplete";
-};
-const logger = createLogger();
-function RoleAndTypeDropin({
-  trust,
-  trustMemberLe,
-  existingTrustMember,
-  navigateToFullDropinFor,
-  navigateBack,
-  country
-}) {
-  const { t: commonT } = useTranslation("common");
-  const { t: trustT } = useTranslation("trust");
-  const { isExperimentEnabled } = useExperimentsContext();
-  const allowMoreRolesForMainRootTrustee = isExperimentEnabled("AllowMoreRolesForMainRootTrustee");
-  const [trustMember, setTrustMember] = useState(
-    existingTrustMember ?? "incomplete"
-  );
-  const [shouldValidate, setShouldValidate] = useState(false);
-  const { showToast } = useToastContext();
-  const isOrganizationSettlorWithExemptionReasonEnabled = (country2) => country2 === CountryCodes.Australia;
-  const isOrganizationSettlorWithExemptionEnabled = isOrganizationSettlorWithExemptionReasonEnabled(
-    trust?.trust?.countryOfGoverningLaw
-  );
-  const formList = decideForms(trustMember);
-  const forms = Object.values(formList);
-  const [formValidity, setFormValidity] = useState({
-    roleAndEntityType: false
-  });
-  const [activeForm, setActiveForm] = useState(regularForms.roleAndEntityType);
-  const isSummaryStep = activeForm.formId === summaryStep.formId;
-  const { mutateAsync: createLegalEntity } = useCreateLegalEntity();
-  const { mutateAsync: updateLegalEntity } = useUpdateLegalEntity();
-  const addOrUpdateTrustMember = async (updated, existing) => {
-    if (trust === void 0) {
-      throw new Error("No associated trust");
-    }
-    try {
-      switch (updated.trustMemberType) {
-        case "undefinedBeneficiary":
-          await addOrUpdateUndefinedBeneficiary({
-            newOrUpdated: updated,
-            trust,
-            updateLegalEntity
-          });
-          break;
-        case "exemptSettlor":
-          if (!existing) {
-            const newSettlorLE = isOrganizationSettlorWithExemptionEnabled && updated.legalEntityType === "organization" ? await createOrganizationExemptSettlor({
-              exemptSettlor: updated,
-              handleCreateLegalEntity: createLegalEntity
-            }) : await createExemptSettlor({
-              exemptSettlor: updated,
-              trust,
-              handleCreateLegalEntity: createLegalEntity
-            });
-            updated.legalEntityId = newSettlorLE.id;
-          }
-          if (existing && !exemptSettlorNamesTheSame(existing, updated)) ;
-          if (existing && isOrganizationSettlorWithExemptionEnabled && updated.legalEntityType === "organization") ;
-          await addOrUpdateAssociatedTrustMember({
-            newOrUpdated: updated,
-            trust,
-            updateLegalEntity
-          });
-          break;
-        case "regular":
-        case "company":
-          await addOrUpdateAssociatedTrustMember({
-            newOrUpdated: updated,
-            trust,
-            updateLegalEntity
-          });
-          break;
-        case "rootTrustee":
-          if (allowMoreRolesForMainRootTrustee && existing) ;
-          break;
-        default:
-          logger.warn(
-            `Updating trust member type "${updated.trustMemberType}" is not implemented.`
-          );
-      }
-      showToast({ label: commonT(($) => $["successfullyUpdatedDetails"]), variant: "success" });
-      navigateBack();
-    } catch (err) {
-      logger.error(err);
-      showToast({ label: commonT(($) => $["failedToUpdateDetails"]), variant: "error" });
-    }
-  };
-  const summaryData = trustMember === "incomplete" ? {} : {
-    roleAndEntityType: formatRoleAndEntityTypeSummary(
-      trustMember,
-      commonT,
-      trustT,
-      isOrganizationSettlorWithExemptionEnabled
-    )
-  };
-  const onNavigateToNextStep = () => {
-    if (isSummaryStep && trustMember !== "incomplete") {
-      addOrUpdateTrustMember(trustMember);
-      return;
-    }
-    gotoFormByFormIndex(forms.findIndex((form) => form.formId === activeForm.formId) + 1);
-  };
-  const onTrustMemberChange = ({
-    data,
-    isValid = false,
-    dataStoreId = void 0
-  }) => {
-    if (dataStoreId) {
-      setFormValidity({ ...formValidity, [dataStoreId]: isValid });
-    }
-    setTrustMember(
-      convertDataToTrustMember(
-        data,
-        existingTrustMember,
-        isOrganizationSettlorWithExemptionEnabled
-      )
-    );
-  };
-  const saveRolesAndNavigate = async () => {
-    if (trustMember === "incomplete") return;
-    if (hasRolesChanged(trustMember.roles, existingTrustMember?.roles)) {
-      addOrUpdateTrustMember(trustMember);
-    }
-    navigateBack();
-  };
-  const hasRolesChanged = (newRoles = [], existingRoles = []) => newRoles.length !== existingRoles.length || !newRoles.every((newRole) => existingRoles.includes(newRole));
-  const formsWithValidity = forms.map((form) => ({
-    formId: form.formId,
-    formName: form.formName,
-    isValid: formValidity[form.formId]
-  }));
-  const gotoFormByFormIndex = (formIndex) => {
-    const targetForm = forms[formIndex];
-    if (!formValidity.roleAndEntityType || trustMember === "incomplete") {
-      setShouldValidate(true);
-      return;
-    }
-    if (trustMember.trustMemberType === "regular" || trustMember.trustMemberType === "company") {
-      if (targetForm.formId === regularForms.memberDetails.formId) {
-        navigateToFullDropinFor(trustMember);
-        return;
-      }
-      if (targetForm.formId === summaryStep.formId) return;
-    }
-    setActiveForm(targetForm);
-  };
-  const content = /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx("div", { className: "adyen-kyc-dropin__sidebar-wrapper", children: /* @__PURE__ */ jsx(
-      FormNavigation,
-      {
-        forms: formsWithValidity,
-        activeForm: formsWithValidity.find((form) => form.formId === activeForm.formId),
-        taskName: "trustMembers",
-        gotoForm: gotoFormByFormIndex
-      }
-    ) }),
-    /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-form-container", children: [
-      /* @__PURE__ */ jsx(
-        "div",
-        {
-          className: activeForm.formId !== "roleAndEntityType" ? "adyen-kyc-form-wrapper adyen-kyc-form-wrapper--hidden" : "adyen-kyc-form-wrapper",
-          children: /* @__PURE__ */ jsx(
-            TrustRoleAndEntityType,
-            {
-              id: "roleAndEntityType",
-              existingTrustMember,
-              onChange: onTrustMemberChange,
-              shouldValidate,
-              isOrganizationSettlorWithExemptionEnabled,
-              country
-            }
-          )
-        }
-      ),
-      isSummaryStep && /* @__PURE__ */ jsx("div", { className: "adyen-kyc-form-wrapper", children: /* @__PURE__ */ jsx(
-        Summary,
-        {
-          data: summaryData,
-          forms: [undefinedBeneficiaryForms.roleAndEntityType],
-          gotoForm: gotoFormByFormIndex
-        }
-      ) }),
-      /* @__PURE__ */ jsx(
-        ActionBar,
-        {
-          onNext: onNavigateToNextStep,
-          onHome: saveRolesAndNavigate,
-          nextButtonLabel: isSummaryStep ? commonT(($) => $["submit"]) : commonT(($) => $["continue"]),
-          homeButtonLabel: commonT(($) => $["saveAndGoToOverview"])
-        }
-      )
-    ] })
-  ] });
-  return /* @__PURE__ */ jsx(DropinLayout, { content });
-}
-function TrustMemberRoleAndTypePage({
-  trustId,
-  memberId,
-  navigateToFullDropinFor,
-  navigateBack
-}) {
-  const { i18n } = useTranslation();
-  const { data: memberLe } = useLegalEntity(memberId ?? skipToken);
-  const { data: trustLe } = useLegalEntity(trustId);
-  const trustMembers = useTrustMembers();
-  addResourceBundles(i18n, [
-    { ns: "trust", importFn: (lang) => __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "../language/da-DK.json": () => import("./da-DK-Dc0QYG8m.js"), "../language/de-DE.json": () => import("./de-DE-Dz2OsS1F.js"), "../language/en-US.json": () => import("./en-US-D-B35AoN.js"), "../language/es-ES.json": () => import("./es-ES-BI_jdT67.js"), "../language/fi-FI.json": () => import("./fi-FI-hwzizPnr.js"), "../language/fr-FR.json": () => import("./fr-FR-CYZXbwc9.js"), "../language/it-IT.json": () => import("./it-IT-Erh1DIlj.js"), "../language/nl-NL.json": () => import("./nl-NL-O9GCHMDA.js"), "../language/no-NO.json": () => import("./no-NO-CA1aR6Wh.js"), "../language/pt-BR.json": () => import("./pt-BR-NtLaWlnZ.js"), "../language/pt-PT.json": () => import("./pt-PT-DSxxVA0f.js"), "../language/sv-SE.json": () => import("./sv-SE-K1QT1cOt.js") }), `../language/${lang}.json`, 3) }
-  ]);
-  if (!trustLe || memberId && !memberLe) {
-    return /* @__PURE__ */ jsx(Loader, {});
-  }
-  const country = getLegalEntityCountry(memberLe ?? trustLe);
-  const trustMember = memberId ? trustMembers.find(
-    (tm) => tm.trustMemberType !== "undefinedBeneficiary" && tm.legalEntityId === memberId
-  ) : void 0;
-  return /* @__PURE__ */ jsx(
-    RoleAndTypeDropin,
-    {
-      trust: trustLe,
-      trustMemberLe: memberLe,
-      existingTrustMember: trustMember,
-      country,
-      navigateToFullDropinFor,
-      navigateBack
-    }
-  );
-}
-export {
-  TrustMemberRoleAndTypePage
-};