@adyen/kyc-components 3.83.0 → 3.85.0-beta.1

package/dist/OnboardingDropinComponent-KKy3000L.js

@@ -0,0 +1,4274 @@
+;
+{
+  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] = "513c7a62-3e0a-47b9-9dd2-0a8bab72186d", e._sentryDebugIdIdentifier = "sentry-dbid-513c7a62-3e0a-47b9-9dd2-0a8bab72186d");
+  } catch (e) {
+  }
+}
+;
+import { b as useApiContext, j as useQuery, k as httpPost, m as useSettingsContext, o as httpGet, p as getLegalRepresentative, c as useLegalEntity, q as skipToken, r as doesLegalEntityRequiresLegalRepresentative, u as useTranslation, B as Button, t as Svg, v as Skeleton, w as translateStringOrObject, x as Typography, y as LegalEntityTypes, z as isPartOfTrustFromLegalEntity, C as hasSolePropInLegalEntity, G as hasOwnEntityAssociationOfType, H as isEmptyEntity, J as EntityTypes, K as DATA_MISSING_DECISION_MAKER_ERROR_CODE_MAPPING, M as TaskTypes, N as createLogger, O as TaskStatuses, P as useAnalyticsContext, U as Icon, V as IconButton, W as noop, X as useExperimentsContext, Y as isInstantVerifiedAccount, Z as getObscuredAccountNumber, $ as useGetTaskStatus, R as ROOT_LE, L as Loader, a0 as useGlobalStore, a1 as isPartOfUnincorporatedPartnership, a2 as getOwnSignatories, a3 as getOwnDecisionMakersLegalEntityIds, a4 as getOwnSolePropProblems, a5 as getOwnTrustProblems, a6 as getOwnUnincorporatedPartnershipProblems, a7 as getOwnEntityAssociations, a8 as TrustMemberTypes, a9 as CountryCodes, aa as isEmpty, a as addResourceBundles, _ as __variableDynamicImportRuntimeHelper, g as getLegalEntityCountry, ab as getDecisionMakerDescriptionMap, ac as TRUST_DEFAULT_DESCRIPTIONS_MAP, ad as Trans, ae as DEFAULT_TRUST_MEMBER_REQUIREMENTS, af as useI18nContext, ag as hasAllCapabilitiesResolved, ah as hasRejectedCapabilities, ai as objectsDeepEqual } from "./StoreProvider-DadhkEyO.js";
+import { jsx, jsxs, Fragment } from "preact/jsx-runtime";
+import { lazy, Suspense } from "preact/compat";
+import { useMemo, useCallback, useEffect, useState, useRef } from "preact/hooks";
+import { S as SettingNames, I as InputText } from "./InputText-zem7Kt4i.js";
+import { u as useLocalStorage, a as useAccountHolder, b as useCapabilityProblems, v as validateLegalCompanyName, c as validateNotEmptyOnBlur, d as validateLatinSpaceMarkPunctuationOnlyOnBlur, r as resolveFieldMetadata, R as RadioGroupCard, T as TextArea, C as ContextGuidance, e as TrustedFieldsProviders } from "./fieldConfigurations-BZuo2e0d.js";
+import { C as CompanyTypesValues, h as handleKeys, u as useSetting, n as nameFields, M as MultiSelectList, m as makeSelectItemForRole, N as Name, a as useSingpassMyInfoLogin, i as isBafinSignatoryFlow, s as showIdNowModal } from "./bafinUtils-CAVAvSFg.js";
+import { u as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-Cd77TYXt.js";
+import cx from "classnames";
+import { a as Alert } from "./Alert-Dz_jjJ1E.js";
+import { u as useTermsOfServiceStatus, a as useTermsOfServiceAcceptanceInfos } from "./useTermsOfServiceStatus-BugRyfkQ.js";
+import { u as useToastContext } from "./useToastContext-D58NfzLh.js";
+import { S as StackLayout, m as mergeFieldMetadataIntoProps, g as getFieldProps, H as Header, E as ErrorPanel, c as createFormUtils, C as CountryField, a as COUNTRY_FIELD, s as summaryItem, b as getRoleName, d as summaryStep, e as Summary, U as UnincorporatedPartnershipMemberTypes, f as getRoleTagVariant } from "./CountryField-DunKeW_n.js";
+import { C as Card, V as VerificationErrorAlert, u as useDeleteTransferInstrument } from "./Card-dFm_Z3TI.js";
+import { signal } from "@preact/signals";
+import { d as downloadFile } from "./file-CiG1D0zy.js";
+import { A as Avatar } from "./Avatar-CCed5bJE.js";
+import { L as LoaderWrapper, F as Field, a as useForm } from "./useForm-Aw38WiTE.js";
+import { C as Confirm } from "./useDataset-B-72Ufk7.js";
+import { T as TaskItemStatus } from "./TaskItemStatus-DuJ01Ng6.js";
+import { g as getLegalEntityNameBasedOnType } from "./getName-DwJ2SEhe.js";
+import { u as useCreateLegalEntity, a as useUpdateLegalEntity, R as RadioGroup } from "./RadioGroup-Br5v8w0a.js";
+import { F as FormNavigation, A as ActionBar } from "./FormNavigation-a9y0a0iw.js";
+import { K as KEYBOARD_KEYS } from "./Modal-DvB1odWq.js";
+import { T as Tag } from "./Tag-DdkVScyr.js";
+import { u as useUnincorporatedPartnershipMembers, d as deleteUnincorporatedPartnershipMember } from "./useUnincorporatedPartnershipMembers-BOfx-rWR.js";
+const getPciStatus = async (legalEntityId, baseUrl, data) => {
+  return httpPost(
+    {
+      baseUrl,
+      path: `legalEntities/${legalEntityId}/pci/signingRequired`
+    },
+    data
+  );
+};
+const usePciStatus = (data, options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useQuery({
+    queryKey: ["pciStatus", data],
+    queryFn: () => getPciStatus(rootLegalEntityId.value, baseUrl.value, data),
+    ...options
+  });
+};
+function useSalesChannelsSettings() {
+  const { isSettingEnabled } = useSettingsContext();
+  return useMemo(() => {
+    const settings = [];
+    if (isSettingEnabled(SettingNames.RequirePciSignEcommerce)) {
+      settings.push("eCommerce");
+    }
+    if (isSettingEnabled(SettingNames.RequirePciSignPos)) {
+      settings.push("pos");
+    }
+    if (isSettingEnabled(SettingNames.RequirePciSignEcomMoto)) {
+      settings.push("ecomMoto");
+    }
+    if (isSettingEnabled(SettingNames.RequirePciSignPosMoto)) {
+      settings.push("posMoto");
+    }
+    return settings;
+  }, [isSettingEnabled]);
+}
+const getTaskTypes = async (id, baseUrl) => {
+  return httpGet({
+    baseUrl,
+    path: `legalEntities/${id}/configurations/tasks`
+  });
+};
+const useTaskTypes = (options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useQuery({
+    queryKey: ["taskTypes"],
+    queryFn: () => getTaskTypes(rootLegalEntityId.value, baseUrl.value),
+    ...options
+  });
+};
+const getHasSeenIntroductionStorageKey = (legalEntityId) => `COMPLETED_INTRO-${legalEntityId}`;
+const useHasSeenIntroduction = ({ legalEntityId }) => {
+  const [hasSeenIntroduction, setHasSeenIntroduction] = useLocalStorage(
+    getHasSeenIntroductionStorageKey(legalEntityId),
+    false
+  );
+  return { hasSeenIntroduction, setHasSeenIntroduction };
+};
+const getHasSeenSingpassSelectionStorageKey = (legalEntityId) => `COMPLETED_SINGPASS_SELECTION-${legalEntityId}`;
+const useHasSeenSingpassSelection = ({
+  legalEntityId
+}) => {
+  const [hasSeenSingpassSelection, setHasSeenSingpassSelection] = useLocalStorage(
+    getHasSeenSingpassSelectionStorageKey(legalEntityId),
+    false
+  );
+  return { hasSeenSingpassSelection, setHasSeenSingpassSelection };
+};
+const useAssociatedLegalRepresentative = (legalEntity) => {
+  const matchingAssociation = useMemo(() => {
+    if (!legalEntity) return void 0;
+    return getLegalRepresentative(legalEntity);
+  }, [legalEntity]);
+  const { data } = useLegalEntity(
+    doesLegalEntityRequiresLegalRepresentative(legalEntity) && matchingAssociation?.legalEntityId ? matchingAssociation.legalEntityId : skipToken
+  );
+  return data;
+};
+const getCanSeeEntitySelectionStorageKey = (legalEntityId) => `ENTITY_SELECTION_SEEN-${legalEntityId}`;
+const useCanSeeEntitySelection = (legalEntityId) => {
+  const [canSeeEntitySelectionFromLocalStorage, setCanSeeEntitySelectionIntoLocalStorage] = useLocalStorage(getCanSeeEntitySelectionStorageKey(legalEntityId), true);
+  return {
+    canSeeEntitySelection: canSeeEntitySelectionFromLocalStorage,
+    setCanSeeEntitySelection: setCanSeeEntitySelectionIntoLocalStorage
+  };
+};
+const providerButton = "adyen-kyc-provider-button";
+const providerButtonDisplayName = "adyen-kyc-provider-button-display-name";
+const styles$4 = {
+  providerButton,
+  providerButtonDisplayName
+};
+const ProviderButton = ({ provider, onClick }) => {
+  const { t } = useTranslation("ui");
+  const providerLogo = {
+    singpassMyInfo: "singpass-logo",
+    singpassMyInfoBusiness: "singpass-logo"
+  };
+  const providerDisplayName = {
+    singpassMyInfo: "Singpass",
+    singpassMyInfoBusiness: "Singpass"
+  };
+  const buttonLabel = {
+    singpassMyInfo: t(($) => $["retrieveMyinfo"]),
+    singpassMyInfoBusiness: t(($) => $["retrieveMyinfoBusiness"])
+  };
+  return /* @__PURE__ */ jsx(Button, { onClick, fullWidth: true, variant: "secondary", children: /* @__PURE__ */ jsxs("div", { className: styles$4.providerButton, children: [
+    buttonLabel[provider],
+    /* @__PURE__ */ jsx("span", { className: styles$4.providerButtonDisplayName, children: providerDisplayName[provider] }),
+    /* @__PURE__ */ jsx(Svg, { name: providerLogo[provider], type: "image" })
+  ] }) });
+};
+const legalEntityTypeToSubtitleTranslationKey = {
+  [LegalEntityTypes.INDIVIDUAL]: "myInfoYouCanGetVerifiedDetails",
+  [LegalEntityTypes.ORGANIZATION]: "myInfoBusinessYouCanGetVerifiedDetails"
+};
+const legalEntityTypeToProviderButtonKey = {
+  [LegalEntityTypes.INDIVIDUAL]: "singpassMyInfo",
+  [LegalEntityTypes.ORGANIZATION]: "singpassMyInfoBusiness"
+};
+const successAlertTitleText = {
+  [LegalEntityTypes.INDIVIDUAL]: "myinfoDetailsRetrieved",
+  [LegalEntityTypes.ORGANIZATION]: "myinfoBusinessDetailsRetrieved"
+};
+const successAlertContentText = {
+  [LegalEntityTypes.INDIVIDUAL]: "yourDetailsArePreFilledInTheRelevantSections",
+  [LegalEntityTypes.ORGANIZATION]: "yourBusinesssDetailsArePreFilledInTheRelevantSections"
+};
+const SingpassBanner = ({
+  isLoading,
+  isSuccess,
+  errorMessage,
+  onClick,
+  onAlertClose,
+  onMessage,
+  legalEntityType
+}) => {
+  const { t } = useTranslation("common");
+  const { baseUrl } = useApiContext();
+  const singpassEventListener = useCallback(
+    (event) => {
+      if (event.origin !== new URL(baseUrl.value).origin) return;
+      onMessage({ data: { isSuccessful: event.data.isSuccessful } });
+    },
+    [baseUrl.value, onMessage]
+  );
+  useEffect(() => {
+    window.addEventListener("message", singpassEventListener);
+    return () => window.removeEventListener("message", singpassEventListener);
+  }, [singpassEventListener]);
+  const channel = new BroadcastChannel("sgidprovider");
+  useEffect(() => {
+    channel.onmessage = onMessage;
+    return () => channel.close();
+  }, [channel, onMessage]);
+  if (isLoading) {
+    return /* @__PURE__ */ jsx(Skeleton, {});
+  }
+  if (isSuccess) {
+    const successTitleText = successAlertTitleText[legalEntityType];
+    const successContentText = successAlertContentText[legalEntityType];
+    return /* @__PURE__ */ jsx(
+      Alert,
+      {
+        variant: "success",
+        title: successTitleText && t(($) => $[successTitleText]),
+        onClose: onAlertClose,
+        children: successContentText && t(($) => $[successContentText])
+      }
+    );
+  }
+  const providerName = legalEntityTypeToProviderButtonKey[legalEntityType];
+  if (errorMessage) {
+    return /* @__PURE__ */ jsx(
+      Alert,
+      {
+        variant: "warning",
+        title: translateStringOrObject(t, errorMessage),
+        onClose: onAlertClose,
+        children: /* @__PURE__ */ jsxs(Typography, { variant: "body", children: [
+          t(($) => $["tryAgainOrContinueEnteringTheDetailsYourself"]),
+          providerName && /* @__PURE__ */ jsx(ProviderButton, { provider: providerName, onClick })
+        ] })
+      }
+    );
+  }
+  const subtitleTranslationKey = legalEntityTypeToSubtitleTranslationKey[legalEntityType];
+  return /* @__PURE__ */ jsxs(
+    Alert,
+    {
+      className: cx("adyen-task-list-singpass-banner"),
+      icon: false,
+      title: t(($) => $["getSetUpInstantly"]),
+      children: [
+        subtitleTranslationKey && /* @__PURE__ */ jsx("div", { className: cx("adyen-task-list-singpass-banner__subtitle"), children: t(($) => $[subtitleTranslationKey]) }),
+        providerName && /* @__PURE__ */ jsx(ProviderButton, { provider: providerName, onClick })
+      ]
+    }
+  );
+};
+const getBusinessLines = async (legalEntityId, baseUrl) => {
+  return httpGet({
+    baseUrl,
+    path: `legalEntities/${legalEntityId}/businessLines`
+  });
+};
+const useBusinessLines = (options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useQuery({
+    queryKey: ["businessLines"],
+    queryFn: () => getBusinessLines(rootLegalEntityId.value, baseUrl.value),
+    ...options
+  });
+};
+const getPciQuestionnaire = async (legalEntityId, baseUrl, documentId) => {
+  return httpGet({
+    baseUrl,
+    path: `legalEntities/${legalEntityId}/pci/questionnaires/${documentId}`
+  });
+};
+const getPciQuestionnaireList = async (legalEntityId, baseUrl) => {
+  return httpGet({
+    baseUrl,
+    path: `legalEntities/${legalEntityId}/pci/questionnaires`
+  });
+};
+const usePciQuestionnaireList = (options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useQuery({
+    queryKey: ["pciQuestionnaireList"],
+    queryFn: () => getPciQuestionnaireList(rootLegalEntityId.value, baseUrl.value),
+    ...options
+  });
+};
+const getTaskStatus = async (legalEntityId, baseUrl) => {
+  return httpGet({
+    baseUrl,
+    path: `legalEntities/${legalEntityId}/taskStatus`
+  });
+};
+const useTaskStatus = (options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useQuery({
+    queryKey: ["taskStatus"],
+    queryFn: () => getTaskStatus(rootLegalEntityId.value, baseUrl.value),
+    ...options
+  });
+};
+const useLegalEntityType = ({
+  legalEntity
+}) => {
+  const isTrust = isPartOfTrustFromLegalEntity(legalEntity);
+  const isSoleProprietor = hasSolePropInLegalEntity(legalEntity);
+  const hasLegalAssociation = isTrust || isSoleProprietor;
+  switch (legalEntity.type) {
+    case LegalEntityTypes.INDIVIDUAL:
+    case LegalEntityTypes.ORGANIZATION:
+      if (!hasLegalAssociation) return legalEntity.type;
+      if (isSoleProprietor) return LegalEntityTypes.SOLE_PROPRIETORSHIP;
+      if (isTrust) return LegalEntityTypes.TRUST;
+      break;
+    default:
+      return void 0;
+  }
+};
+const useCanSeeIntroduction = ({ legalEntity }) => {
+  const legalEntityType = useLegalEntityType({ legalEntity });
+  const { isSettingEnabled } = useSettingsContext();
+  switch (legalEntityType) {
+    case LegalEntityTypes.INDIVIDUAL:
+      return !isSettingEnabled(SettingNames.HideOnboardingIntroductionIndividual);
+    case LegalEntityTypes.ORGANIZATION:
+      return !isSettingEnabled(SettingNames.HideOnboardingIntroductionOrganization);
+    case LegalEntityTypes.SOLE_PROPRIETORSHIP:
+      return !isSettingEnabled(SettingNames.HideOnboardingIntroductionSoleProprietor);
+    case LegalEntityTypes.TRUST:
+      return !isSettingEnabled(SettingNames.HideOnboardingIntroductionTrust);
+    default:
+      return false;
+  }
+};
+const capabilitiesToPreventTypeChange = [
+  "receivePayments",
+  "issueCard",
+  "useCard",
+  "withdrawFromAtm",
+  "withdrawFromAtmInRestrictedCountries",
+  "useCardInRestrictedCountries",
+  "useCardInRestrictedIndustries",
+  "issueBankAccount",
+  "sendToThirdParty",
+  "receiveFromThirdParty",
+  "getGrantOffers",
+  "receiveGrants"
+];
+const entityTypeToCorrespondingAccountHolderOption = {
+  [LegalEntityTypes.INDIVIDUAL]: "myName",
+  [LegalEntityTypes.ORGANIZATION]: "theCompanyIWorkFor",
+  [LegalEntityTypes.SOLE_PROPRIETORSHIP]: "mySoleProprietorName",
+  [LegalEntityTypes.TRUST]: "aTrust",
+  [LegalEntityTypes.UNINCORPORATED_PARTNERSHIP]: "anUnincorporatedPartnership"
+};
+const getDefaultAccountHolderType = (legalEntityResponse, isTypeChanging = false, accountHolder) => {
+  if (accountHolder) {
+    return accountHolder;
+  }
+  if (!legalEntityResponse?.type) return void 0;
+  if (hasOwnEntityAssociationOfType(
+    LegalEntityTypes.SOLE_PROPRIETORSHIP,
+    legalEntityResponse.entityAssociations,
+    legalEntityResponse.id
+  )) {
+    return "mySoleProprietorName";
+  }
+  if (hasOwnEntityAssociationOfType(
+    LegalEntityTypes.TRUST,
+    legalEntityResponse.entityAssociations,
+    legalEntityResponse.id
+  )) {
+    return "aTrust";
+  }
+  if (hasOwnEntityAssociationOfType(
+    LegalEntityTypes.UNINCORPORATED_PARTNERSHIP,
+    legalEntityResponse.entityAssociations,
+    legalEntityResponse.id
+  )) {
+    return "anUnincorporatedPartnership";
+  }
+  if (isTypeChanging || !isEmptyEntity(legalEntityResponse)) {
+    return entityTypeToCorrespondingAccountHolderOption[legalEntityResponse.type];
+  }
+};
+const allowIndividualWithoutSoleProp = (capabilities) => !capabilities?.map((c) => c.replace("Commercial", "").replace("Consumer", "")).some((c) => capabilitiesToPreventTypeChange.includes(c));
+const BusinessTypes = {
+  INDIVIDUAL: "individual",
+  COMPANY: "company",
+  INCORPORATED_PARTNERSHIP: "partnershipIncorporated",
+  UNINCORPORATED_PARTNERSHIP: "partnershipUnincorporated",
+  INDIVIDUAL_TRUSTEE: "individualTrustee",
+  COMPANY_TRUSTEE: "companyTrustee",
+  SOLE_PROPRIETORSHIP: "soleProprietorship",
+  INCORPORATE_ASSOCIATION: "associationIncorporated"
+};
+const businessTypeMapping = {
+  myName: {
+    [LegalEntityTypes.INDIVIDUAL]: BusinessTypes.INDIVIDUAL
+  },
+  theCompanyIWorkFor: {
+    [LegalEntityTypes.ORGANIZATION]: BusinessTypes.COMPANY
+  },
+  mySoleProprietorName: {
+    [LegalEntityTypes.INDIVIDUAL]: BusinessTypes.SOLE_PROPRIETORSHIP
+  },
+  aTrust: {
+    [LegalEntityTypes.INDIVIDUAL]: BusinessTypes.INDIVIDUAL_TRUSTEE,
+    [LegalEntityTypes.ORGANIZATION]: BusinessTypes.COMPANY_TRUSTEE
+  },
+  anUnincorporatedPartnership: {
+    [LegalEntityTypes.INDIVIDUAL]: BusinessTypes.UNINCORPORATED_PARTNERSHIP,
+    [LegalEntityTypes.ORGANIZATION]: BusinessTypes.UNINCORPORATED_PARTNERSHIP
+  }
+};
+const companyTypesMapping = {
+  [CompanyTypesValues.INCORPORATED_PARTNERSHIP]: BusinessTypes.INCORPORATED_PARTNERSHIP,
+  [CompanyTypesValues.INCORPORATED_ASSOCIATION]: BusinessTypes.INCORPORATE_ASSOCIATION,
+  [CompanyTypesValues.PUBLIC_COMPANY]: BusinessTypes.COMPANY,
+  [CompanyTypesValues.PRIVATE_COMPANY]: BusinessTypes.COMPANY,
+  [CompanyTypesValues.UNLISTED_PUBLIC_COMPANY]: BusinessTypes.COMPANY,
+  [CompanyTypesValues.GOVERNMENTAL_ORGANIZATION]: BusinessTypes.COMPANY,
+  [CompanyTypesValues.NON_PROFIT_OR_CHARITABLE]: BusinessTypes.COMPANY,
+  [CompanyTypesValues.SOLE_PROPRIETORSHIP]: BusinessTypes.SOLE_PROPRIETORSHIP
+};
+const useBusinessSetup = (legalEntityResponse) => {
+  const { accountHolder } = useAccountHolder();
+  const accountHolderType = accountHolder || getDefaultAccountHolderType(legalEntityResponse);
+  const organizationType = legalEntityResponse?.organization?.type;
+  const businessSetup = accountHolderType === "theCompanyIWorkFor" && organizationType ? companyTypesMapping[organizationType] : businessTypeMapping[accountHolderType]?.[legalEntityResponse?.type];
+  return businessSetup;
+};
+function useDataMissingRemediations({
+  legalEntityId,
+  problems
+}) {
+  const { t } = useTranslation("common");
+  const decisionMakersRemediationMessage = useMemo(() => {
+    const remediationCodes = problems[EntityTypes.LEGAL_ENTITY]?.[legalEntityId]?.missingData?.reduce((remediations, error) => {
+      const remediation = DATA_MISSING_DECISION_MAKER_ERROR_CODE_MAPPING[error.code];
+      return remediation ? [...remediations, remediation] : remediations;
+    }, []);
+    const uniqueRemediations = [...new Set(remediationCodes)];
+    switch (uniqueRemediations?.length) {
+      case void 0:
+      case 0:
+        return void 0;
+      case 1:
+        return uniqueRemediations[0] ? t(($) => $[`remediationMessage_${uniqueRemediations[0]}`]) : t(($) => $["missingMultipleDecisionMakers"]);
+      default:
+        return t(($) => $["missingMultipleDecisionMakers"]);
+    }
+  }, [problems, t, legalEntityId]);
+  return {
+    remediationMessages: {
+      [TaskTypes.DECISION_MAKER]: decisionMakersRemediationMessage
+    }
+  };
+}
+const logger$2 = createLogger();
+const normalizeTaskStatuses = (taskStatuses) => {
+  return taskStatuses?.statuses?.reduce((acc, currentTask) => {
+    const status = TaskStatuses[currentTask.status];
+    const statusEntries = currentTask.taskStatusEntries;
+    acc[currentTask.type] = {
+      status: status ?? TaskStatuses.DETAILS_REQUIRED,
+      taskStatusEntries: statusEntries
+    };
+    return acc;
+  }, {});
+};
+const TASK_STATUS_POLLING_INTERVAL_MS = 3e3;
+const TASK_STATUS_COMPLETED_POLLING_INTERVAL_MS = 6e3;
+const getAccountTaskStatus = (accountId, payinPayoutTaskStatus) => {
+  const taskStatusEntries = payinPayoutTaskStatus?.taskStatusEntries;
+  const taskStatusEntry = taskStatusEntries?.find((entry) => entry.id.includes(accountId));
+  if (!taskStatusEntry) {
+    logger$2.warn(`No task status for this account: ${accountId}`);
+    return payinPayoutTaskStatus?.status ?? TaskStatuses.PROCESSING;
+  }
+  return TaskStatuses[taskStatusEntry.status];
+};
+const normalizedTaskStatusStore = signal(void 0);
+const setNormalizedTaskStatusStore = (taskStatus) => {
+  normalizedTaskStatusStore.value = taskStatus;
+};
+const TaskListItem = ({
+  titleKey,
+  title,
+  icon,
+  status,
+  statusLabel,
+  onNavigateToTask,
+  disabled = false,
+  problems,
+  downloadHandler,
+  info,
+  loading = false,
+  showErrorAlerts = "onErrorStatus",
+  warningMessage,
+  deleteEntity,
+  testId,
+  enableTracking = true,
+  fallbackErrorMessage
+}) => {
+  const { t } = useTranslation("common");
+  const userEvents = useAnalyticsContext();
+  const [isConfirmShown, setIsConfirmShown] = useState(false);
+  const isDeletable = !!deleteEntity;
+  const shouldShowErrorAlert = showErrorAlerts === "always" || showErrorAlerts === "onErrorStatus" && status === TaskStatuses.ERROR;
+  const handleNavigateToTask = () => {
+    if (enableTracking) {
+      userEvents.addJourneyEvent("Clicked button", {
+        actionType: "open",
+        task: void 0,
+        label: titleKey
+      });
+    }
+    onNavigateToTask?.();
+  };
+  const avatarVariant = disabled ? "disabled" : "primary";
+  const handleRemoveIntent = (event) => {
+    event.stopPropagation();
+    setIsConfirmShown(true);
+  };
+  const dismissConfirm = () => {
+    setIsConfirmShown(false);
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      Card,
+      {
+        stateful: onNavigateToTask && !loading && !disabled,
+        warningMessage,
+        onClick: loading ? void 0 : handleNavigateToTask,
+        onKeyDown: handleKeys(["Enter"], handleNavigateToTask ?? noop),
+        className: "adyen-task",
+        disabled,
+        children: /* @__PURE__ */ jsxs(
+          LoaderWrapper,
+          {
+            status: loading ? "loading" : "success",
+            formOpacityWhenLoading: 0.3,
+            loaderSize: "medium",
+            children: [
+              /* @__PURE__ */ jsxs("div", { className: "adyen-task-item", "data-testid": testId, children: [
+                /* @__PURE__ */ jsxs("div", { className: "adyen-task-item__header", children: [
+                  /* @__PURE__ */ jsxs("div", { className: "adyen-task-item__heading", children: [
+                    /* @__PURE__ */ jsx(Avatar, { variant: avatarVariant, iconName: icon }),
+                    /* @__PURE__ */ jsx("div", { className: "adyen-task-item__body", children: /* @__PURE__ */ jsx("span", { className: "adyen-task-item__title", children: title || t(($) => $[titleKey]) }) })
+                  ] }),
+                  info && /* @__PURE__ */ jsxs("div", { className: "adyen-task-item__info", children: [
+                    /* @__PURE__ */ jsx(Icon, { name: "info-circle" }),
+                    /* @__PURE__ */ jsx("span", { children: info })
+                  ] })
+                ] }),
+                /* @__PURE__ */ jsxs("aside", { className: "adyen-task-item__status", children: [
+                  /* @__PURE__ */ jsx(
+                    TaskItemStatus,
+                    {
+                      status,
+                      statusLabel,
+                      downloadHandler
+                    }
+                  ),
+                  isDeletable ? /* @__PURE__ */ jsx(
+                    IconButton,
+                    {
+                      ariaLabel: t(($) => $["delete"]),
+                      icon: "bin",
+                      variant: "tertiary",
+                      onClick: handleRemoveIntent,
+                      disabled: isConfirmShown
+                    }
+                  ) : /* @__PURE__ */ jsx(Icon, { name: "chevron-right" })
+                ] })
+              ] }),
+              shouldShowErrorAlert && /* @__PURE__ */ jsx(
+                VerificationErrorAlert,
+                {
+                  className: "adyen-task-item-alert",
+                  problems,
+                  fallbackErrorMessage
+                }
+              )
+            ]
+          }
+        )
+      }
+    ),
+    isConfirmShown && isDeletable && /* @__PURE__ */ jsx(
+      Confirm,
+      {
+        title: t(($) => $["deleteItem"], { item: title }),
+        description: t(($) => $["thisActionIsPermanent"]),
+        onConfirm: deleteEntity,
+        confirmText: t(($) => $["delete"]),
+        onCancel: dismissConfirm,
+        critical: true
+      }
+    )
+  ] });
+};
+const PayoutAccountTaskListItem = ({
+  account,
+  capabilityProblems,
+  onNavigateToTask,
+  payinPayoutTaskStatus
+}) => {
+  const { t } = useTranslation("common");
+  const { showToast } = useToastContext();
+  const { isExperimentEnabled } = useExperimentsContext();
+  const { mutateAsync: deleteTransferInstrument } = useDeleteTransferInstrument();
+  const isInstantVerificationAccount = isInstantVerifiedAccount(account);
+  const obscuredAccountNumber = getObscuredAccountNumber(account);
+  const getTaskStatus2 = useGetTaskStatus();
+  const status = isExperimentEnabled("UseTaskStatusApiForPayout") ? getAccountTaskStatus(account.id, payinPayoutTaskStatus) : getTaskStatus2(TaskTypes.PAYOUT, account.id);
+  const handleDeleteTransferInstrument = async () => {
+    try {
+      await deleteTransferInstrument(account.id);
+      showToast({ label: t(($) => $["transferInstrumentDeleted"]), variant: "success" });
+    } catch {
+      showToast({ label: t(($) => $["failedToDeletePayoutAccount"]), variant: "error" });
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    TaskListItem,
+    {
+      disabled: isInstantVerificationAccount && status === TaskStatuses.PROCESSING,
+      onNavigateToTask: isInstantVerificationAccount ? void 0 : onNavigateToTask,
+      icon: "payout",
+      titleKey: "accountNumber",
+      title: obscuredAccountNumber,
+      status,
+      problems: capabilityProblems?.BankAccount?.[account.id],
+      fallbackErrorMessage: isInstantVerificationAccount ? t(($) => $["verificationErrorMessageTrustedTransferInstrument"]) : void 0,
+      deleteEntity: handleDeleteTransferInstrument
+    }
+  );
+};
+const TaskListGroup = ({ title, children }) => /* @__PURE__ */ jsxs("article", { className: "adyen-task-list-group", children: [
+  title && /* @__PURE__ */ jsx("header", { className: "adyen-task-list-group__header", children: /* @__PURE__ */ jsx(Typography, { el: "h4", variant: "body-stronger", color: "secondary", children: title }) }),
+  /* @__PURE__ */ jsx("div", { className: "adyen-kyc-card__body", children: /* @__PURE__ */ jsx(StackLayout, { gap: "xSmall", children }) })
+] });
+const LEGAL_ENTITY_BASE_TASKS = [
+  TaskTypes.INDIVIDUAL,
+  TaskTypes.BUSINESS_DETAILS,
+  TaskTypes.DECISION_MAKER_OVERVIEW
+];
+const CONTRACT_TASKS = [TaskTypes.SERVICE_AGREEMENT, TaskTypes.PCI_DSS];
+function TaskList({ onNavigateToTask, singpassComponent }) {
+  const { data: rootLe, isLoading } = useLegalEntity(ROOT_LE);
+  const { data: existingBusinessLines, isLoading: isLoadingBl } = useBusinessLines();
+  const capabilityProblems = useCapabilityProblems() ?? {};
+  if (isLoading || !rootLe || isLoadingBl) {
+    return /* @__PURE__ */ jsx(Loader, { size: "large" });
+  }
+  return /* @__PURE__ */ jsx(
+    TaskListInner,
+    {
+      onNavigateToTask,
+      singpassComponent,
+      legalEntityResponse: rootLe,
+      capabilityProblems,
+      existingBusinessLines
+    }
+  );
+}
+function TaskListInner({
+  onNavigateToTask,
+  legalEntityResponse,
+  capabilityProblems,
+  singpassComponent,
+  existingBusinessLines
+}) {
+  const userEvents = useAnalyticsContext();
+  const { t } = useTranslation("common");
+  const { showToast } = useToastContext();
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  const { isSettingEnabled } = useSettingsContext();
+  const { isExperimentEnabled } = useExperimentsContext();
+  const { accountHolder } = useAccountHolder();
+  const tasks = useGlobalStore().tasks.value;
+  const getTaskStatus2 = useGetTaskStatus();
+  const businessSetup = useBusinessSetup(legalEntityResponse);
+  const canSeeIntroduction = useCanSeeIntroduction({ legalEntity: legalEntityResponse });
+  const additionalSalesChannels = useSalesChannelsSettings();
+  const { remediationMessages } = useDataMissingRemediations({
+    legalEntityId: legalEntityResponse.id,
+    problems: capabilityProblems
+  });
+  const { data: pciStatus } = usePciStatus(
+    { additionalSalesChannels },
+    { enabled: tasks.includes(TaskTypes.PCI_DSS) }
+  );
+  const { data: pciQuestionnaireList } = usePciQuestionnaireList();
+  const { data: termsOfServiceStatus } = useTermsOfServiceStatus();
+  const { data: termsOfServiceStatusAcceptanceInfos } = useTermsOfServiceAcceptanceInfos();
+  const { data: taskStatuses } = useTaskStatus({
+    refetchInterval: (query) => {
+      const { data: response } = query.state || {};
+      const statuses = response?.statuses;
+      const areAllTasksFinishedOrEmpty = statuses?.length === 0 || statuses?.every((task) => task.status === "FINISHED");
+      return areAllTasksFinishedOrEmpty ? TASK_STATUS_COMPLETED_POLLING_INTERVAL_MS : TASK_STATUS_POLLING_INTERVAL_MS;
+    }
+  });
+  const canChangeEntityType = isSettingEnabled(SettingNames.AllowLegalEntityTypeChange);
+  const hidePayoutAccountTaskExperiment = isExperimentEnabled("HidePayoutAccountTask");
+  const hidePciTaskExperiment = isExperimentEnabled("HidePciTask");
+  const showCustomerSupportV4 = isExperimentEnabled("ShowCustomerSupportV4");
+  const EnableSignPCIBeforeTOS = isExperimentEnabled("EnableSignPCIBeforeTOS");
+  const transferInstrumentLimit = useSetting("transferInstrumentLimit");
+  const normalizedTasks = normalizeTaskStatuses(taskStatuses);
+  setNormalizedTaskStatusStore(normalizedTasks);
+  const payinPayoutTaskStatus = normalizedTasks?.PAYOUT ?? normalizedTasks?.PAYIN;
+  const businessDetailsTaskStatus = normalizedTasks?.BUSINESS_DETAILS?.status ?? TaskStatuses.DETAILS_REQUIRED;
+  const businessLinesTaskStatus = existingBusinessLines?.length ?? 0 > 0 ? TaskStatuses.FINISHED : TaskStatuses.EMPTY;
+  const isReview = Boolean(
+    capabilityProblems?.LegalEntity?.[legalEntityResponse.id]?.isReviewRequired
+  );
+  const hasTrust = accountHolder === "aTrust" || isPartOfTrustFromLegalEntity(legalEntityResponse);
+  const hasUnincorporatedPartnership = accountHolder === "anUnincorporatedPartnership" || isPartOfUnincorporatedPartnership(legalEntityResponse);
+  const hasSoleProprietorship = accountHolder === "mySoleProprietorName" || hasSolePropInLegalEntity(legalEntityResponse);
+  const isLegalRepresentativeRequired = isExperimentEnabled("EnableAgeVerification") && doesLegalEntityRequiresLegalRepresentative(legalEntityResponse);
+  const legalRepresentative = isLegalRepresentativeRequired && getLegalRepresentative(legalEntityResponse);
+  const transferInstruments = legalEntityResponse?.transferInstruments || [];
+  const canAddPayoutAccount = legalEntityResponse?.organization?.legalName || legalEntityResponse?.individual?.name;
+  const hasPayinTaskNotPayout = tasks.includes(TaskTypes.PAYIN) && !tasks.includes(TaskTypes.PAYOUT);
+  const payoutTaskDescriptionKey = isReview ? "payoutAccountsDescriptionReview" : "payoutAccountsDescription";
+  const pciHasDocuments = !!pciQuestionnaireList?.data?.length;
+  const canSignPci = (
+    // PCI requires decision makers to be added
+    legalEntityResponse.type === LegalEntityTypes.ORGANIZATION && !!legalEntityResponse?.entityAssociations?.length || legalEntityResponse.type === LegalEntityTypes.INDIVIDUAL && !!legalEntityResponse?.entityAssociations?.length
+  );
+  const canDownloadPci = !pciStatus?.signingRequired && pciHasDocuments;
+  const hasSignedPci = !pciStatus?.signingRequired && canSignPci;
+  const serviceAgreementTypes = termsOfServiceStatus?.termsOfServiceTypes ?? [];
+  const serviceAgreementAcceptanceInfos = termsOfServiceStatusAcceptanceInfos?.data ?? [];
+  const hasServiceAgreementSigners = legalEntityResponse.type === LegalEntityTypes.ORGANIZATION && getOwnSignatories(legalEntityResponse).length || Boolean(legalRepresentative) || legalEntityResponse.type === LegalEntityTypes.INDIVIDUAL && !!legalEntityResponse?.individual;
+  const hasTaskOfGroupAccountDetails = tasks.some((task) => LEGAL_ENTITY_BASE_TASKS.includes(task));
+  const hasContractTasks = tasks.some((task) => CONTRACT_TASKS.includes(task));
+  const hasFinancingTasks = tasks.includes(TaskTypes.BUSINESS_FINANCING) || tasks.includes(TaskTypes.SOURCE_OF_FUNDS);
+  const showServiceAgreementTask = tasks.includes(TaskTypes.SERVICE_AGREEMENT) && (serviceAgreementTypes.length > 0 || serviceAgreementAcceptanceInfos.length > 0);
+  const showPciTask = tasks.includes(TaskTypes.PCI_DSS) && (canDownloadPci || pciStatus?.signingRequired) && !hidePciTaskExperiment;
+  const showContractTasks = hasContractTasks && (showPciTask || showServiceAgreementTask);
+  const shouldSignPciFirst = showServiceAgreementTask && showPciTask && !hasSignedPci;
+  const areServiceAgreementTasksDisabled = EnableSignPCIBeforeTOS ? !hasServiceAgreementSigners || shouldSignPciFirst : !hasServiceAgreementSigners;
+  const isPciTaskDisabled = !pciStatus?.signingRequired || !canSignPci;
+  const getBusinessTaskListTitleKey = () => {
+    if (hasUnincorporatedPartnership) {
+      return "tellUsMoreAboutPrimaryPartner";
+    } else if (tasks.includes(TaskTypes.BUSINESS_DETAILS)) {
+      return isReview ? "businessAccountDetailsDescriptionReview" : "businessAccountDetailsDescription";
+    } else if (canChangeEntityType) {
+      return "provideFewDetailsAboutYourself";
+    } else {
+      return "accountDetailsDescription";
+    }
+  };
+  const getEmptyBankAccountProblems = () => {
+    const transferInstrumentId = legalEntityResponse?.transferInstruments?.[0]?.id;
+    return transferInstrumentId ? capabilityProblems?.BankAccount?.[transferInstrumentId] : void 0;
+  };
+  const onEditBusinessSetupClick = () => {
+    userEvents.addTaskEvent("Clicked button", {
+      task: TaskTypes.TASKS_OVERVIEW,
+      actionType: "edit"
+    });
+    onNavigateToTask(TaskTypes.BUSINESS_TYPE_SELECTION);
+  };
+  const onPciDownload = async () => {
+    try {
+      const response = await getPciQuestionnaireList(rootLegalEntityId.value, baseUrl.value);
+      if (!response.data) return;
+      await Promise.all(
+        response.data.map(async (pciQuestionnaireInfo) => {
+          const pciQuestionnaire = await getPciQuestionnaire(
+            rootLegalEntityId.value,
+            baseUrl.value,
+            pciQuestionnaireInfo.id
+          );
+          await downloadFile(pciQuestionnaire.content, `${pciQuestionnaire.id}.pdf`);
+        })
+      );
+    } catch {
+      showToast({ label: t(($) => $["failedToDownloadPci"]), variant: "error" });
+    } finally {
+      userEvents.addTaskEvent("Clicked button", {
+        task: TaskTypes.PCI_DSS,
+        actionType: "download"
+      });
+    }
+  };
+  const handleOnNavigateToTaskReview = () => onNavigateToTask(TaskTypes.REVIEW);
+  const handleOnNavigateToTaskIndividual = () => onNavigateToTask(TaskTypes.INDIVIDUAL);
+  const handleOnNavigateToTaskBusinessDetails = () => onNavigateToTask(TaskTypes.BUSINESS_DETAILS);
+  const handleOnNavigateToTaskBusinessLines = () => onNavigateToTask(TaskTypes.ACQUIRING_BUSINESS_LINE);
+  const handleOnNavigateToTaskCustomerSupport = () => onNavigateToTask(TaskTypes.CUSTOMER_SUPPORT);
+  const handleOnNavigateToTaskDecisionMaker = () => onNavigateToTask(TaskTypes.DECISION_MAKER_OVERVIEW);
+  const handleOnNavigateToTaskTrust = () => onNavigateToTask(TaskTypes.TRUST);
+  const handleOnNavigateToTaskTrustMember = () => onNavigateToTask(TaskTypes.TRUST_MEMBER_OVERVIEW);
+  const handleOnNavigateToTaskPayout = (id) => hasPayinTaskNotPayout ? onNavigateToTask(TaskTypes.PAYIN, id) : onNavigateToTask(TaskTypes.PAYOUT, id);
+  const handleOnNavigateToPci = () => !canDownloadPci && onNavigateToTask(TaskTypes.PCI_DSS);
+  const handleOnNavigateToSoleProp = () => onNavigateToTask(TaskTypes.SOLE_PROPRIETOR_COMPANY);
+  const handleOnNavigateToServiceAgreement = () => onNavigateToTask(TaskTypes.SERVICE_AGREEMENT);
+  const handleOnNavigateToTaskLegalRepresentative = () => onNavigateToTask(TaskTypes.LEGAL_REPRESENTATIVE_DETAILS);
+  const handleOnNavigateToSourceOfFunds = () => onNavigateToTask(TaskTypes.SOURCE_OF_FUNDS);
+  const handleOnNavigateToBusinessFinancing = () => onNavigateToTask(TaskTypes.BUSINESS_FINANCING);
+  const handleOnNavigateToTaxReporting = () => onNavigateToTask(TaskTypes.TAX_REPORTING);
+  const showDecisionMakersWarning = Boolean(
+    getOwnDecisionMakersLegalEntityIds(legalEntityResponse).length && remediationMessages.DECISION_MAKER
+  );
+  useEffect(() => {
+    if (showDecisionMakersWarning) {
+      userEvents.addTaskEvent("Encountered error", {
+        task: TaskTypes.TASKS_OVERVIEW,
+        actionType: "alert",
+        returnValue: "missingDecisionMaker"
+      });
+    }
+  }, [showDecisionMakersWarning, userEvents]);
+  return /* @__PURE__ */ jsxs("div", { className: "adyen-task-list__container", children: [
+    canSeeIntroduction && /* @__PURE__ */ jsx("div", { className: "adyen-task-list__nav", children: /* @__PURE__ */ jsx(Button, { variant: "link", onClick: () => onNavigateToTask(TaskTypes.INTRODUCTION), children: t(($) => $["goToIntroduction"]) }) }),
+    canChangeEntityType && /* @__PURE__ */ jsxs("header", { className: "adyen-task-list__heading", children: [
+      /* @__PURE__ */ jsx(Typography, { el: "h1", variant: "title-l", children: t(($) => $["setUpYourAccount"]) }),
+      /* @__PURE__ */ jsxs(Typography, { el: "p", variant: "title", className: "adyen-task-list__description", children: [
+        /* @__PURE__ */ jsx(Typography, { el: "span", variant: "body-strongest", children: t(($) => $["yourBusinessSetup"], {
+          businessSetup: businessSetup ? t(($) => $[businessSetup]) : t(($) => $["unknown"])
+        }) }),
+        /* @__PURE__ */ jsx(
+          IconButton,
+          {
+            ariaLabel: t(($) => $["editBusinessSetup"]),
+            icon: "edit",
+            variant: "tertiary",
+            onClick: onEditBusinessSetupClick
+          }
+        )
+      ] })
+    ] }),
+    singpassComponent,
+    /* @__PURE__ */ jsxs(StackLayout, { children: [
+      hasTaskOfGroupAccountDetails && /* @__PURE__ */ jsxs(TaskListGroup, { title: t(($) => $[getBusinessTaskListTitleKey()]), children: [
+        tasks.includes(TaskTypes.INDIVIDUAL) && /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            onNavigateToTask: handleOnNavigateToTaskIndividual,
+            icon: "decision-maker",
+            titleKey: hasTrust ? "trusteePersonalDetails" : hasUnincorporatedPartnership ? "primaryPartnerDetails" : "personalDetails",
+            status: getTaskStatus2(TaskTypes.INDIVIDUAL),
+            problems: capabilityProblems?.LegalEntity?.[legalEntityResponse.id]
+          }
+        ),
+        tasks.includes(TaskTypes.BUSINESS_DETAILS) && /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            testId: TaskTypes.BUSINESS_DETAILS,
+            onNavigateToTask: handleOnNavigateToTaskBusinessDetails,
+            icon: "company",
+            titleKey: hasTrust ? "businessTrusteeDetails" : hasUnincorporatedPartnership ? "primaryPartnerDetails" : "businessDetails",
+            status: businessDetailsTaskStatus,
+            problems: capabilityProblems?.LegalEntity?.[legalEntityResponse.id]
+          }
+        ),
+        hasSoleProprietorship && /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            onNavigateToTask: handleOnNavigateToSoleProp,
+            icon: "company",
+            titleKey: canChangeEntityType ? "soleProprietorshipDetails" : "soleProprietorDetails",
+            status: getTaskStatus2(TaskTypes.SOLE_PROPRIETOR_COMPANY),
+            problems: getOwnSolePropProblems(legalEntityResponse, capabilityProblems)
+          }
+        ),
+        isLegalRepresentativeRequired && /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            onNavigateToTask: handleOnNavigateToTaskLegalRepresentative,
+            icon: "decision-maker",
+            titleKey: "legalRepresentative",
+            status: getTaskStatus2(TaskTypes.LEGAL_REPRESENTATIVE_DETAILS)
+          }
+        ),
+        tasks.includes(TaskTypes.DECISION_MAKER_OVERVIEW) && /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            onNavigateToTask: handleOnNavigateToTaskDecisionMaker,
+            icon: "decision-maker",
+            titleKey: hasUnincorporatedPartnership ? "entityDecisionMakers" : "decisionMakers",
+            status: getTaskStatus2(TaskTypes.DECISION_MAKER_OVERVIEW),
+            warningMessage: showDecisionMakersWarning ? remediationMessages[TaskTypes.DECISION_MAKER] : void 0
+          }
+        ),
+        tasks.includes(TaskTypes.ACQUIRING_BUSINESS_LINE) && /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            testId: TaskTypes.ACQUIRING_BUSINESS_LINE,
+            onNavigateToTask: handleOnNavigateToTaskBusinessLines,
+            icon: "solutionPayments",
+            titleKey: "businessLines",
+            status: businessLinesTaskStatus
+          }
+        ),
+        showCustomerSupportV4 && tasks.includes(TaskTypes.CUSTOMER_SUPPORT) && /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            onNavigateToTask: handleOnNavigateToTaskCustomerSupport,
+            icon: "webinar",
+            titleKey: "customerSupport",
+            status: normalizedTasks?.CUSTOMER_SUPPORT?.status ?? TaskStatuses.DETAILS_REQUIRED
+          }
+        )
+      ] }),
+      hasTrust && /* @__PURE__ */ jsxs(TaskListGroup, { title: t(($) => $["trustDetailsDescription"]), children: [
+        /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            onNavigateToTask: handleOnNavigateToTaskTrust,
+            icon: "trust",
+            titleKey: "trustDetails",
+            status: getTaskStatus2(TaskTypes.TRUST),
+            problems: getOwnTrustProblems(legalEntityResponse, capabilityProblems)
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            onNavigateToTask: handleOnNavigateToTaskTrustMember,
+            icon: "decision-maker",
+            titleKey: "trustMembers",
+            status: getTaskStatus2(TaskTypes.TRUST_MEMBER_OVERVIEW)
+          }
+        )
+      ] }),
+      hasUnincorporatedPartnership && /* @__PURE__ */ jsxs(TaskListGroup, { title: t(($) => $["partnershipUnincorporated"]), children: [
+        /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            onNavigateToTask: () => onNavigateToTask(TaskTypes.UNINCORPORATED_PARTNERSHIP),
+            icon: "trust",
+            titleKey: "unincorporatedDetails",
+            status: getTaskStatus2(TaskTypes.UNINCORPORATED_PARTNERSHIP),
+            problems: getOwnUnincorporatedPartnershipProblems(
+              legalEntityResponse,
+              capabilityProblems
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            onNavigateToTask: () => {
+              if (!isPartOfUnincorporatedPartnership(legalEntityResponse)) {
+                onNavigateToTask(TaskTypes.UNINCORPORATED_PARTNERSHIP);
+              } else {
+                onNavigateToTask(TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_OVERVIEW);
+              }
+            },
+            icon: "decision-maker",
+            titleKey: "unincorporatedPartnershipMembers",
+            status: getTaskStatus2(TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_OVERVIEW)
+          }
+        )
+      ] }),
+      hasFinancingTasks && /* @__PURE__ */ jsxs(TaskListGroup, { children: [
+        tasks.includes(TaskTypes.SOURCE_OF_FUNDS) && /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            onNavigateToTask: handleOnNavigateToSourceOfFunds,
+            icon: "cash-stack",
+            titleKey: "fundingSources",
+            status: normalizedTasks?.SOURCE_OF_FUNDS?.status ?? TaskStatuses.DETAILS_REQUIRED
+          }
+        ),
+        tasks.includes(TaskTypes.BUSINESS_FINANCING) && /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            onNavigateToTask: handleOnNavigateToBusinessFinancing,
+            icon: "capital",
+            titleKey: "businessFinancing",
+            status: normalizedTasks?.BUSINESS_FINANCING?.status ?? TaskStatuses.DETAILS_REQUIRED
+          }
+        )
+      ] }),
+      tasks.includes(TaskTypes.TAX_REPORTING) && /* @__PURE__ */ jsx(TaskListGroup, { children: /* @__PURE__ */ jsx(
+        TaskListItem,
+        {
+          onNavigateToTask: handleOnNavigateToTaxReporting,
+          icon: "reporting",
+          titleKey: "taxReporting",
+          status: normalizedTasks?.TAX_REPORTING?.status ?? TaskStatuses.DETAILS_REQUIRED
+        }
+      ) }),
+      (tasks.includes(TaskTypes.PAYOUT) || tasks.includes(TaskTypes.PAYIN)) && !hidePayoutAccountTaskExperiment && /* @__PURE__ */ jsx(
+        TaskListGroup,
+        {
+          title: canChangeEntityType ? t(($) => $["payoutBankAccounts"]) : t(
+            ($) => $[hasPayinTaskNotPayout ? "payinAccountsDescription" : payoutTaskDescriptionKey]
+          ),
+          children: transferInstruments.length > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            transferInstruments.map((transferInstrument) => /* @__PURE__ */ jsx(
+              PayoutAccountTaskListItem,
+              {
+                account: transferInstrument,
+                capabilityProblems,
+                onNavigateToTask: () => handleOnNavigateToTaskPayout(transferInstrument.id),
+                payinPayoutTaskStatus
+              },
+              transferInstrument.id
+            )),
+            !transferInstrumentLimit || transferInstruments.length < transferInstrumentLimit ? /* @__PURE__ */ jsxs(
+              Card,
+              {
+                stateful: true,
+                onClick: () => handleOnNavigateToTaskPayout(),
+                className: "adyen-task adyen-kyc-add-payout",
+                disabled: !canAddPayoutAccount,
+                children: [
+                  /* @__PURE__ */ jsx(Icon, { name: "plus", className: "adyen-task-list__card-icon " }),
+                  /* @__PURE__ */ jsx("span", { children: canChangeEntityType ? t(($) => $["addExtraBankAccount"]) : t(
+                    ($) => $[hasPayinTaskNotPayout ? "addExtraPayinAccount" : "addExtraPayoutAccount"]
+                  ) })
+                ]
+              }
+            ) : null
+          ] }) : /* @__PURE__ */ jsx(
+            TaskListItem,
+            {
+              onNavigateToTask: () => handleOnNavigateToTaskPayout(),
+              icon: "payout",
+              titleKey: canChangeEntityType ? "bankAccountDetails" : hasPayinTaskNotPayout ? "payinDetails" : "payoutDetails",
+              status: TaskStatuses.DETAILS_REQUIRED,
+              disabled: !canAddPayoutAccount,
+              problems: getEmptyBankAccountProblems()
+            }
+          )
+        }
+      ),
+      showContractTasks && /* @__PURE__ */ jsxs(TaskListGroup, { title: t(($) => $["reviewAndSignLegalDisclosures"]), children: [
+        showPciTask && /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            onNavigateToTask: handleOnNavigateToPci,
+            icon: "pci",
+            titleKey: "pciDssQuestionnaire",
+            status: canDownloadPci ? TaskStatuses.DOWNLOAD : TaskStatuses.SIGN,
+            statusLabel: canDownloadPci ? t(($) => $["downloadACopy"]) : void 0,
+            downloadHandler: onPciDownload,
+            disabled: isPciTaskDisabled,
+            info: isPciTaskDisabled && !canDownloadPci ? t(($) => $["requiresDecisionMakers"]) : void 0
+          }
+        ),
+        showServiceAgreementTask && /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            onNavigateToTask: handleOnNavigateToServiceAgreement,
+            icon: "contract",
+            titleKey: "signServiceAgreement",
+            disabled: areServiceAgreementTasksDisabled,
+            status: serviceAgreementTypes.length ? TaskStatuses.SIGN : TaskStatuses.SIGNED,
+            info: EnableSignPCIBeforeTOS && shouldSignPciFirst ? t(($) => $["signPciFirst"]) : !hasServiceAgreementSigners ? t(($) => $["requiresSignatory"]) : void 0
+          }
+        )
+      ] }),
+      isReview && /* @__PURE__ */ jsx(TaskListGroup, { title: t(($) => $["pleaseEnsureTheFollowing"]), children: /* @__PURE__ */ jsx(
+        TaskListItem,
+        {
+          onNavigateToTask: handleOnNavigateToTaskReview,
+          icon: "review",
+          titleKey: "submitReviewOfYourData",
+          status: TaskStatuses.SUBMIT,
+          problems: capabilityProblems?.LegalEntity?.[legalEntityResponse.id],
+          showErrorAlerts: "always"
+        }
+      ) })
+    ] })
+  ] });
+}
+const isNewEntity = Symbol("isNewEntity");
+const useExemptSettlor = ({
+  trust
+}) => {
+  const matchingAssociation = useMemo(() => {
+    if (!trust) return void 0;
+    return getOwnEntityAssociations(trust).find(
+      (association) => association.type === TrustMemberTypes.SETTLOR && Boolean(association.settlorExemptionReason)
+    );
+  }, [trust]);
+  const { data } = useLegalEntity(matchingAssociation?.legalEntityId ?? skipToken);
+  return data;
+};
+const splitAtFirstOccurrence = (str, separator) => {
+  const firstOccurrence = str.indexOf(separator);
+  if (firstOccurrence === -1) return [str];
+  return [str.slice(0, firstOccurrence), str.slice(firstOccurrence + 1)];
+};
+const getTrustMemberOwnerId = (trustMemberId, entityAssociations) => entityAssociations.find((association) => association.associatorId === trustMemberId)?.legalEntityId;
+const getFallbackName = (exemptSettlorAssociation) => {
+  const [firstName, lastName] = splitAtFirstOccurrence(exemptSettlorAssociation.name ?? "", " ");
+  return {
+    firstName,
+    lastName
+  };
+};
+const convertEntityAssociationIntoTrustMember = (association, associations, exemptSettlorLE) => {
+  if (association.settlorExemptionReason) {
+    return {
+      trustMemberType: "exemptSettlor",
+      roles: [TrustMemberTypes.SETTLOR],
+      legalEntityType: association.entityType,
+      legalEntityId: association.legalEntityId,
+      settlorExemptionReason: association.settlorExemptionReason,
+      exemptSettlorName: association.entityType === LegalEntityTypes.INDIVIDUAL ? exemptSettlorLE?.individual?.name ?? getFallbackName(association) : void 0,
+      name: association.name
+    };
+  }
+  if (association.entityType === LegalEntityTypes.ORGANIZATION)
+    return {
+      trustMemberType: "company",
+      roles: [],
+      legalEntityType: LegalEntityTypes.ORGANIZATION,
+      legalEntityId: association.legalEntityId,
+      name: association.name,
+      ownerId: getTrustMemberOwnerId(association.legalEntityId, associations)
+    };
+  if (association.entityType === LegalEntityTypes.INDIVIDUAL)
+    return {
+      trustMemberType: "regular",
+      roles: [],
+      legalEntityType: LegalEntityTypes.INDIVIDUAL,
+      legalEntityId: association.legalEntityId,
+      name: association.name
+    };
+  throw new Error(`Not a valid trust member: ${JSON.stringify(association)}`);
+};
+const mapEntityAssociationsToTrustMembers = (trustEntityId, entityAssociations, exemptSettlorLE) => {
+  const mappedTrustMembers = entityAssociations.reduce(
+    (acc, entityAssociation) => {
+      if (!Object.values(TrustMemberTypes).includes(entityAssociation.type) || entityAssociation.associatorId !== trustEntityId || !entityAssociation.legalEntityId) {
+        return acc;
+      }
+      const trustMember = acc[entityAssociation.legalEntityId] ?? convertEntityAssociationIntoTrustMember(
+        entityAssociation,
+        entityAssociations,
+        exemptSettlorLE
+      );
+      const trustMemberType = entityAssociation.type;
+      acc[entityAssociation.legalEntityId] = {
+        ...trustMember,
+        roles: [.../* @__PURE__ */ new Set([...trustMember.roles, trustMemberType])]
+      };
+      return acc;
+    },
+    {}
+  );
+  return Object.values(mappedTrustMembers);
+};
+const mapRootLegalEntityToTrustMember = (rootLegalEntity) => ({
+  trustMemberType: "rootTrustee",
+  roles: [TrustMemberTypes.TRUSTEE],
+  legalEntityType: rootLegalEntity.type,
+  legalEntityId: rootLegalEntity.id,
+  name: getLegalEntityNameBasedOnType(rootLegalEntity)
+});
+const mapUndefinedBeneficiaryInfoToTrustMembers = (undefinedBeneficiaryInfo) => undefinedBeneficiaryInfo.map(({ reference, description }) => ({
+  trustMemberType: "undefinedBeneficiary",
+  roles: [TrustMemberTypes.UNDEFINED_BENEFICIARY],
+  reference,
+  description
+}));
+const getTrustMembers = (trustLE, rootLegalEntity, exemptSettlorLE) => [
+  mapRootLegalEntityToTrustMember(rootLegalEntity),
+  ...mapEntityAssociationsToTrustMembers(
+    trustLE.id,
+    trustLE.entityAssociations ?? [],
+    exemptSettlorLE
+  ),
+  ...mapUndefinedBeneficiaryInfoToTrustMembers(trustLE.trust?.undefinedBeneficiaryInfo ?? [])
+];
+const combineRootLegalEntityWithEntityAssociations = (rootLegalEntity, entityAssociations) => {
+  const allowedRolesForRootLegalEntity = [
+    TrustMemberTypes.SETTLOR,
+    TrustMemberTypes.PROTECTOR,
+    TrustMemberTypes.DEFINED_BENEFICIARY
+  ];
+  const roles = entityAssociations.map((entityAssociation) => entityAssociation.type).filter((role) => allowedRolesForRootLegalEntity.includes(role));
+  return {
+    trustMemberType: "rootTrustee",
+    roles: [...roles, TrustMemberTypes.TRUSTEE],
+    legalEntityType: rootLegalEntity.type,
+    legalEntityId: rootLegalEntity.id,
+    name: getLegalEntityNameBasedOnType(rootLegalEntity)
+  };
+};
+const getRootTrusteeTrustMembers = (trustLE, rootLegalEntity, exemptSettlorLE) => {
+  const entityAssociations = trustLE.entityAssociations ?? [];
+  const rootLegalEntityAssociations = entityAssociations.filter(
+    (a) => a.legalEntityId === rootLegalEntity.id
+  );
+  const nonRootLegalEntityAssociations = entityAssociations.filter(
+    (a) => a.legalEntityId !== rootLegalEntity.id
+  );
+  return [
+    combineRootLegalEntityWithEntityAssociations(rootLegalEntity, rootLegalEntityAssociations),
+    ...mapEntityAssociationsToTrustMembers(
+      trustLE.id,
+      nonRootLegalEntityAssociations ?? [],
+      exemptSettlorLE
+    ),
+    ...mapUndefinedBeneficiaryInfoToTrustMembers(trustLE.trust?.undefinedBeneficiaryInfo ?? [])
+  ];
+};
+function useTrustMembers() {
+  const { data: rootLegalEntity } = useLegalEntity(ROOT_LE);
+  const { data: trust } = useAssociatedLegalEntity(rootLegalEntity, LegalEntityTypes.TRUST);
+  const { isExperimentEnabled } = useExperimentsContext();
+  const exemptSettlor = useExemptSettlor({
+    trust
+  });
+  const allowMoreRolesForMainRootTrustee = isExperimentEnabled("AllowMoreRolesForMainRootTrustee");
+  return useMemo(() => {
+    if (!rootLegalEntity || !trust?.trust) return [];
+    return allowMoreRolesForMainRootTrustee ? getRootTrusteeTrustMembers(trust, rootLegalEntity, exemptSettlor) : getTrustMembers(trust, rootLegalEntity, exemptSettlor);
+  }, [rootLegalEntity, trust, exemptSettlor, allowMoreRolesForMainRootTrustee]);
+}
+const useTrustMemberNavigation = ({ navigateTo, trust }) => {
+  const { t } = useTranslation("trust");
+  const { showToast } = useToastContext();
+  const [trustMember, setTrustMember] = useState();
+  const { setTrustMembers } = useGlobalStore();
+  const trustMembers = useTrustMembers();
+  const memberId = trustMember?.trustMemberType === "undefinedBeneficiary" ? trustMember.reference : trustMember?.legalEntityId;
+  useEffect(() => setTrustMembers(trustMembers), [trustMembers]);
+  const onNavigateToTrustMemberEditDetails = async (tm) => {
+    try {
+      if (tm.legalEntityId === isNewEntity) {
+        setTrustMember(tm);
+      }
+      navigateTo(
+        tm.trustMemberType === "company" ? TaskTypes.TRUST_MEMBER_COMPANY : TaskTypes.TRUST_MEMBER_INDIVIDUAL
+      );
+    } catch {
+      showToast({ label: t(($) => $["failedToFetchTrustMemberDetails"]), variant: "error" });
+    }
+  };
+  const onNavigateToTrustMemberRoleAndType = (tm) => {
+    setTrustMember(tm === "new" ? void 0 : tm);
+    navigateTo(TaskTypes.TRUST_MEMBER_ROLE_AND_TYPE);
+  };
+  const onNavigateToTrust = async (task = TaskTypes.TRUST) => {
+    try {
+      if (trust) {
+        navigateTo(task);
+      } else {
+        navigateTo(TaskTypes.TRUST);
+      }
+    } catch {
+      showToast({ label: t(($) => $["failedToFetchTrustDetails"]), variant: "error" });
+    }
+  };
+  return {
+    trustMember,
+    trustMemberId: memberId === isNewEntity ? void 0 : memberId,
+    // Do not pass Symbol('isNewEntity') as trustMemberId
+    trustMembers,
+    onNavigateToTrust,
+    onNavigateToTrustMemberRoleAndType,
+    onNavigateToTrustMemberEditDetails
+  };
+};
+const DropinLayout = ({ content, footer }) => /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-dropin", children: [
+  /* @__PURE__ */ jsx("div", { className: "adyen-kyc-dropin__content", children: /* @__PURE__ */ jsx("div", { className: "adyen-kyc-dropin__content-main", children: content }) }),
+  footer && /* @__PURE__ */ jsx("div", { className: "adyen-kyc-dropin__footer-container", children: footer })
+] });
+const defaultFieldMetadata = {
+  label: "legalCompanyName",
+  helperText: "legalCompanyName__helperText",
+  validators: validateNotEmptyOnBlur
+};
+const defaultFieldConfig = {
+  [CountryCodes.Australia]: {
+    label: "legalCompanyName",
+    helperText: "legalCompanyName__helperText__AU",
+    validators: validateNotEmptyOnBlur
+  },
+  [CountryCodes.HongKong]: {
+    label: "legalCompanyName",
+    helperText: "legalCompanyName__helperText__HK",
+    validators: validateNotEmptyOnBlur
+  },
+  [CountryCodes.Netherlands]: {
+    label: "legalCompanyName",
+    helperText: "legalCompanyName__helperText__NL",
+    validators: validateNotEmptyOnBlur
+  },
+  [CountryCodes.Singapore]: {
+    label: "legalCompanyName",
+    helperText: "legalCompanyName__helperText__SG",
+    validators: validateNotEmptyOnBlur
+  },
+  [CountryCodes.UnitedStates]: ({ isBusiness }) => ({
+    label: "legalCompanyName__US",
+    helperText: isBusiness ? "legalCompanyName__helperText__US__business" : "legalCompanyName__helperText__US",
+    validators: validateNotEmptyOnBlur
+  })
+};
+const defaultFieldMetadataV4 = {
+  label: "legalCompanyName",
+  helperText: "legalCompanyName__helperText",
+  validators: validateLegalCompanyName
+};
+const defaultFieldConfigV4 = {
+  [CountryCodes.Australia]: {
+    label: "legalCompanyName",
+    helperText: "legalCompanyName__helperText__AU",
+    validators: validateLegalCompanyName
+  },
+  [CountryCodes.HongKong]: {
+    label: "legalCompanyName",
+    helperText: "legalCompanyName__helperText__HK",
+    validators: validateLegalCompanyName
+  },
+  [CountryCodes.Netherlands]: {
+    label: "legalCompanyName",
+    helperText: "legalCompanyName__helperText__NL",
+    validators: validateLegalCompanyName
+  },
+  [CountryCodes.Singapore]: {
+    label: "legalCompanyName",
+    helperText: "legalCompanyName__helperText__SG",
+    validators: validateLegalCompanyName
+  },
+  [CountryCodes.UnitedStates]: ({ isBusiness }) => ({
+    label: "legalCompanyName__US",
+    helperText: isBusiness ? "legalCompanyName__helperText__US__business" : "legalCompanyName__helperText__US",
+    validators: validateLegalCompanyName
+  }),
+  [CountryCodes.Japan]: {
+    label: "legalCompanyName__JP",
+    helperText: void 0,
+    validators: [...validateLegalCompanyName, validateLatinSpaceMarkPunctuationOnlyOnBlur]
+  }
+};
+const LEGAL_COMPANY_NAME_FIELD = [
+  "legalCompanyName"
+];
+function LegalCompanyNameField({
+  data,
+  valid,
+  errors,
+  labels,
+  helperText,
+  readonly,
+  handleChangeFor
+}) {
+  const handleKeyDown = (e) => {
+    if (e.key === KEYBOARD_KEYS.enter) {
+      e.preventDefault();
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    Field,
+    {
+      name: "legalCompanyName",
+      label: labels.legalCompanyName,
+      helper: helperText?.legalCompanyName,
+      errorMessage: errors.legalCompanyName,
+      isValid: valid.legalCompanyName,
+      children: (childProps) => /* @__PURE__ */ jsx(
+        InputText,
+        {
+          ...childProps,
+          "aria-required": true,
+          "aria-invalid": !valid.legalCompanyName,
+          name: "legalCompanyName",
+          value: data.legalCompanyName,
+          readonly,
+          onInput: handleChangeFor("legalCompanyName", "input"),
+          onBlur: handleChangeFor("legalCompanyName", "blur"),
+          onKeyDown: handleKeyDown
+        }
+      )
+    }
+  );
+}
+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 trustMemberLegalEntityTypes = [
+  LegalEntityTypes.INDIVIDUAL,
+  LegalEntityTypes.ORGANIZATION
+];
+const countriesWhereSettlorExemptionReasonNotApplicable = [CountryCodes.NewZealand];
+const settlorExemptionReasons = [
+  "contributionBelowThreshold",
+  "professionalServiceProvider",
+  "deceased"
+];
+const settlorExemptionReasonWithNoneOfTheAbove = [
+  ...settlorExemptionReasons,
+  "noneOfTheAbove"
+];
+const couldBeExemptSettlor = (data, country) => data.entityType === LegalEntityTypes.INDIVIDUAL && data.role !== void 0 && data.role.includes("settlor") && !data.role.some((role) => role !== "settlor") && (!country || !countriesWhereSettlorExemptionReasonNotApplicable.includes(country));
+const isExemptSettlor = (data) => data.settlorExemptionReason?.some((reason) => reason !== "noneOfTheAbove") ?? false;
+const isOrganizationAndSettlor = (data) => data.entityType === LegalEntityTypes.ORGANIZATION && data.role?.length === 1 && data.role[0] === "settlor";
+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$1 = {
+  [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.target;
+    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$1[option].id,
+            optionName: (option) => t(($) => $[leTypeCardDetails$1[option].name], { ns: "trust" }),
+            optionDescription: (option) => t(($) => $[leTypeCardDetails$1[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$3 = {
+  settlorExemptionReasonsList
+};
+const formatRolesForSummary = (roles, commonT) => roles.map((role) => commonT(($) => $[getRoleName(role)])).join(", ");
+const formatSettlorExemptionReasonsForSummary = (reasons, trustT) => /* @__PURE__ */ jsx("ul", { className: styles$3.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$1 = {
+  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$1;
+  switch (trustMember.trustMemberType) {
+    case "undefinedBeneficiary":
+      return undefinedBeneficiaryForms;
+    case "exemptSettlor":
+      return exemptSettlorForms;
+    case "rootTrustee":
+      return exemptSettlorForms;
+    case "regular":
+    case "company":
+      return regularForms$1;
+  }
+};
+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$1 = 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$1.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$1.warn(
+            `Updating trust member type "${updated.trustMemberType}" is not implemented.`
+          );
+      }
+      showToast({ label: commonT(($) => $["successfullyUpdatedDetails"]), variant: "success" });
+      navigateBack();
+    } catch (err) {
+      logger$1.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$1.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, i18n.language, [
+    { ns: "trust", importFn: () => __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "../language/bg-BG.json": () => import("./bg-BG-CepHap8j.js"), "../language/cs-CZ.json": () => import("./cs-CZ-BP7niQM9.js"), "../language/da-DK.json": () => import("./da-DK-Dc0QYG8m.js"), "../language/de-DE.json": () => import("./de-DE-Dz2OsS1F.js"), "../language/el-GR.json": () => import("./el-GR-BHG69mXl.js"), "../language/en-US.json": () => import("./en-US-D-B35AoN.js"), "../language/es-ES.json": () => import("./es-ES-BI_jdT67.js"), "../language/et-EE.json": () => import("./et-EE-C_PZO2aI.js"), "../language/fi-FI.json": () => import("./fi-FI-hwzizPnr.js"), "../language/fr-FR.json": () => import("./fr-FR-CYZXbwc9.js"), "../language/hr-HR.json": () => import("./hr-HR-bE6cvRCQ.js"), "../language/hu-HU.json": () => import("./hu-HU-DG-NUDx4.js"), "../language/it-IT.json": () => import("./it-IT-Erh1DIlj.js"), "../language/ja-JP.json": () => import("./ja-JP-ThzG9vIo.js"), "../language/lt-LT.json": () => import("./lt-LT-Nd1uRoIj.js"), "../language/lv-LV.json": () => import("./lv-LV-DKhV24CI.js"), "../language/nl-NL.json": () => import("./nl-NL-O9GCHMDA.js"), "../language/no-NO.json": () => import("./no-NO-CA1aR6Wh.js"), "../language/pl-PL.json": () => import("./pl-PL-BKDK0_G8.js"), "../language/pt-BR.json": () => import("./pt-BR-NtLaWlnZ.js"), "../language/pt-PT.json": () => import("./pt-PT-DSxxVA0f.js"), "../language/ro-RO.json": () => import("./ro-RO-Bybq8JFn.js"), "../language/sk-SK.json": () => import("./sk-SK-C6rMIxpz.js"), "../language/sl-SI.json": () => import("./sl-SI-tPwbFvOI.js"), "../language/sv-SE.json": () => import("./sv-SE-K1QT1cOt.js") }), `../language/${i18n.language}.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
+    }
+  );
+}
+const UNINCORPORATED_PARTNERSHIP__DEFAULT_DESCRIPTIONS_MAP = {
+  [UnincorporatedPartnershipMemberTypes.SECONDARY_PARTNER]: "provideAtLeastOneSecondaryPartner",
+  [UnincorporatedPartnershipMemberTypes.OWNER]: "provideAllOwners",
+  [UnincorporatedPartnershipMemberTypes.CONTROLLING_PERSON]: "ifNoOwnersSpecifyControllingPersons"
+};
+const iconStatus = (current, min) => {
+  const isSatisfied = current > 0 && current >= min;
+  return isSatisfied ? "satisfied" : "empty";
+};
+const getEntityStatusRuleDescription = (country, currentTask, entityLabel) => {
+  const defaultMessage = getDecisionMakerDescriptionMap(country)[entityLabel];
+  switch (currentTask) {
+    case TaskTypes.TRUST_MEMBER_OVERVIEW: {
+      return TRUST_DEFAULT_DESCRIPTIONS_MAP[entityLabel];
+    }
+    case TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_OVERVIEW: {
+      return UNINCORPORATED_PARTNERSHIP__DEFAULT_DESCRIPTIONS_MAP[entityLabel] || defaultMessage;
+    }
+    default: {
+      return defaultMessage;
+    }
+  }
+};
+const EntityStatusIcon = ({ status }) => {
+  switch (status) {
+    case "empty":
+      return /* @__PURE__ */ jsx(
+        Icon,
+        {
+          name: "checkmark-circle",
+          className: "adyen-kyc-entity-status__icon adyen-kyc-entity-status__icon--empty",
+          testId: "empty-icon"
+        }
+      );
+    case "satisfied":
+      return /* @__PURE__ */ jsx(
+        Icon,
+        {
+          name: "checkmark",
+          className: "adyen-kyc-entity-status__icon adyen-kyc-entity-status__icon--satisfied",
+          testId: "satisfied-icon"
+        }
+      );
+    default:
+      return /* @__PURE__ */ jsx(
+        Icon,
+        {
+          name: "circle",
+          className: "adyen-kyc-entity-status__icon adyen-kyc-entity-status__icon--empty",
+          testId: "empty-icon"
+        }
+      );
+  }
+};
+const EntityGuidanceStatus = ({
+  country,
+  currentTask,
+  entityLabel,
+  status
+}) => {
+  const { t } = useTranslation("common");
+  return /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-entity-status__container", children: [
+    /* @__PURE__ */ jsx(EntityStatusIcon, { status }),
+    /* @__PURE__ */ jsx(
+      Tag,
+      {
+        className: "adyen-kyc-entity-status__tag",
+        variant: getRoleTagVariant(entityLabel),
+        children: t(($) => $[getRoleName(entityLabel)])
+      },
+      entityLabel
+    ),
+    /* @__PURE__ */ jsx(
+      "span",
+      {
+        className: "adyen-kyc-entity-status--text",
+        "data-testid": `${entityLabel}-rule--description`,
+        children: /* @__PURE__ */ jsx(
+          Trans,
+          {
+            t,
+            i18nKey: ($) => $[getEntityStatusRuleDescription(country, currentTask, entityLabel)]
+          }
+        )
+      }
+    )
+  ] });
+};
+const deleteAssociatedTrustMember = async ({
+  associatedTrustMember,
+  trust,
+  asyncMutation
+}) => {
+  const ownEntityAssociations = getOwnEntityAssociations(trust);
+  const updatedTrustAssociations = {
+    entityAssociations: ownEntityAssociations.filter(
+      (entityAssociation) => entityAssociation.legalEntityId !== associatedTrustMember.legalEntityId
+    )
+  };
+  await asyncMutation({ ...updatedTrustAssociations, id: trust.id });
+};
+const deleteUndefinedBeneficiary = async ({
+  undefinedBeneficiary,
+  trust,
+  asyncMutation
+}) => {
+  const existingUndefinedBeneficiaries = trust.trust?.undefinedBeneficiaryInfo ?? [];
+  const updatedTrust = {
+    trust: {
+      undefinedBeneficiaryInfo: existingUndefinedBeneficiaries.filter(
+        (ub) => ub.reference !== undefinedBeneficiary.reference
+      )
+    }
+  };
+  await asyncMutation({ ...updatedTrust, id: trust.id });
+};
+function useClickAwayListener(ref, onClickAway) {
+  const handleClickAway = useCallback(
+    (event) => {
+      if (ref.current && !ref.current.contains(event.target)) {
+        onClickAway();
+      }
+    },
+    [ref, onClickAway]
+  );
+  useEffect(() => {
+    document.addEventListener("mousedown", handleClickAway);
+    return () => {
+      document.removeEventListener("mousedown", handleClickAway);
+    };
+  }, [handleClickAway]);
+}
+const ClickAwayWrapper = ({ children, onClickAway, ...divProps }) => {
+  const ref = useRef(null);
+  useClickAwayListener(ref, onClickAway);
+  return /* @__PURE__ */ jsx("div", { ref, ...divProps, children });
+};
+const actionsMenu = "adyen-kyc-actions-menu";
+const styles$2 = {
+  actionsMenu
+};
+const ActionsMenu = ({ options, open, setOpen }) => {
+  const menuItems = options.map(({ label, onSelect, icon }) => /* @__PURE__ */ jsx(
+    Button,
+    {
+      onClick: (event) => {
+        event.stopPropagation();
+        setOpen(false);
+        onSelect();
+      },
+      variant: "tertiary",
+      icon,
+      children: label
+    },
+    label
+  ));
+  return open ? /* @__PURE__ */ jsx(ClickAwayWrapper, { onClickAway: () => setOpen(false), className: styles$2.actionsMenu, role: "menu", children: menuItems }) : null;
+};
+const EntityAssociation = ({
+  name,
+  types,
+  status,
+  actions,
+  problems,
+  infoContent,
+  onNavigateToEntity,
+  deleteEntity,
+  isDeleteDisabled
+}) => {
+  const { t } = useTranslation("common");
+  const [showingActions, setShowingActions] = useState(false);
+  const [isConfirmShown, setIsConfirmShown] = useState(false);
+  const isDeletable = !!deleteEntity;
+  const handleRemoveIntent = (event) => {
+    event.stopPropagation();
+    setIsConfirmShown(true);
+  };
+  const dismissConfirm = () => {
+    setIsConfirmShown(false);
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs(
+      Card,
+      {
+        className: "adyen-kyc-entity-association",
+        stateful: Boolean(onNavigateToEntity),
+        onClick: onNavigateToEntity,
+        onKeyDown: handleKeys(["Enter"], onNavigateToEntity ?? noop),
+        children: [
+          /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-entity-association__top", children: [
+            /* @__PURE__ */ jsx("h3", { className: "adyen-kyc-entity-association__title", children: name }),
+            /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-entity-association__info", children: [
+              /* @__PURE__ */ jsx(TaskItemStatus, { status }),
+              actions && /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-entity-association__actions", children: [
+                /* @__PURE__ */ jsx(
+                  IconButton,
+                  {
+                    variant: "tertiary",
+                    icon: "more-horiz",
+                    onClick: (event) => {
+                      event.stopPropagation();
+                      setShowingActions(!showingActions);
+                    },
+                    ariaLabel: t(($) => $["toggleAssociationMenu"], { name })
+                  }
+                ),
+                /* @__PURE__ */ jsx(ActionsMenu, { options: actions, open: showingActions, setOpen: setShowingActions })
+              ] }),
+              isDeletable && /* @__PURE__ */ jsx(
+                IconButton,
+                {
+                  ariaLabel: t(($) => $["delete"]),
+                  icon: "bin",
+                  variant: "tertiary",
+                  onClick: handleRemoveIntent,
+                  disabled: isConfirmShown || isDeleteDisabled
+                }
+              )
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx("div", { children: types.map((type) => /* @__PURE__ */ jsx(
+            Tag,
+            {
+              className: "adyen-kyc-entity-association__tag",
+              variant: getRoleTagVariant(type),
+              children: t(($) => $[getRoleName(type)])
+            },
+            type
+          )) }),
+          status === TaskStatuses.ERROR && /* @__PURE__ */ jsx(
+            VerificationErrorAlert,
+            {
+              className: "adyen-kyc-entity-association-alert",
+              problems
+            }
+          ),
+          infoContent
+        ]
+      }
+    ),
+    isConfirmShown && isDeletable && /* @__PURE__ */ jsx(
+      Confirm,
+      {
+        title: t(($) => $["deleteItem"], { item: name }),
+        description: t(($) => $["thisActionIsPermanent"]),
+        onConfirm: deleteEntity,
+        confirmText: t(($) => $["delete"]),
+        onCancel: dismissConfirm,
+        critical: true
+      }
+    )
+  ] });
+};
+const CompanyTrustMemberTaskItem = ({
+  companyTrustMember,
+  taskStatus,
+  onEditOwner,
+  onAddOwner,
+  onEdit,
+  onDelete
+}) => {
+  const { t } = useTranslation(["trust", "common"]);
+  const actions = [
+    {
+      icon: "edit",
+      onSelect: onEdit,
+      label: t(($) => $["editTrustMember"], { trustMember: companyTrustMember.name })
+    },
+    companyTrustMember.ownerId ? {
+      icon: "edit",
+      onSelect: onEditOwner,
+      label: t(($) => $["editOwnerOfTrustMember"], {
+        trustMember: companyTrustMember.name
+      })
+    } : {
+      icon: "plus",
+      onSelect: onAddOwner,
+      label: t(($) => $["addOwnerToTrustMember"], {
+        trustMember: companyTrustMember.name
+      })
+    },
+    {
+      icon: "bin",
+      onSelect: onDelete,
+      label: t(($) => $["removeTrustMember"], { trustMember: companyTrustMember.name })
+    }
+  ];
+  const infoContent = companyTrustMember.ownerId ? void 0 : /* @__PURE__ */ jsx(
+    Alert,
+    {
+      title: /* @__PURE__ */ jsxs(Fragment, { children: [
+        t(($) => $["helpUsVerifyCompany"], { ns: "common" }),
+        " ",
+        /* @__PURE__ */ jsx(Button, { onClick: onAddOwner, variant: "link", children: t(($) => $["providePersonalDetailsOfOwner"]) })
+      ] }),
+      className: "add-owner-alert"
+    }
+  );
+  return /* @__PURE__ */ jsx(
+    EntityAssociation,
+    {
+      types: companyTrustMember.roles,
+      name: companyTrustMember.name,
+      status: taskStatus,
+      actions,
+      infoContent,
+      onNavigateToEntity: onEdit
+    },
+    companyTrustMember.legalEntityId
+  );
+};
+const ExemptSettlorTaskItem = ({
+  exemptSettlor,
+  taskStatus,
+  onEdit,
+  onDelete
+}) => {
+  const { t } = useTranslation("trust");
+  const settlorName = exemptSettlor.legalEntityType === LegalEntityTypes.INDIVIDUAL ? `${exemptSettlor.exemptSettlorName?.firstName} ${exemptSettlor.exemptSettlorName?.lastName}` : exemptSettlor.name ?? "";
+  const actions = [
+    {
+      icon: "edit",
+      onSelect: onEdit,
+      label: t(($) => $["editTrustMember"], { trustMember: settlorName })
+    },
+    {
+      icon: "bin",
+      onSelect: onDelete,
+      label: t(($) => $["removeTrustMember"], { trustMember: settlorName })
+    }
+  ];
+  return /* @__PURE__ */ jsx(
+    EntityAssociation,
+    {
+      types: exemptSettlor.roles,
+      name: settlorName,
+      status: taskStatus,
+      actions,
+      onNavigateToEntity: onEdit
+    },
+    exemptSettlor.legalEntityId
+  );
+};
+const RegularTrustMemberTaskItem = ({
+  trustMember,
+  taskStatus,
+  onEdit,
+  onDelete
+}) => {
+  const { t } = useTranslation("trust");
+  const actions = [
+    {
+      icon: "edit",
+      onSelect: onEdit,
+      label: t(($) => $["editTrustMember"], { trustMember: trustMember.name })
+    },
+    {
+      icon: "bin",
+      onSelect: onDelete,
+      label: t(($) => $["removeTrustMember"], { trustMember: trustMember.name })
+    }
+  ];
+  return /* @__PURE__ */ jsx(
+    EntityAssociation,
+    {
+      types: trustMember.roles,
+      name: trustMember.name,
+      status: taskStatus,
+      actions,
+      onNavigateToEntity: onEdit
+    },
+    trustMember.legalEntityId
+  );
+};
+const RootTrusteeTaskItem = ({
+  rootTrustee,
+  taskStatus,
+  onEdit
+}) => {
+  const { t } = useTranslation("trust");
+  const actions = [
+    {
+      icon: "edit",
+      onSelect: onEdit,
+      label: t(($) => $["editTrustMember"], { trustMember: rootTrustee.name })
+    }
+  ];
+  const { isExperimentEnabled } = useExperimentsContext();
+  const isAllowMoreRolesForMainRootTrustee = isExperimentEnabled(
+    "AllowMoreRolesForMainRootTrustee"
+  );
+  return /* @__PURE__ */ jsx(
+    EntityAssociation,
+    {
+      types: isExperimentEnabled("AllowMoreRolesForMainRootTrustee") ? rootTrustee.roles : [TrustMemberTypes.TRUSTEE],
+      name: rootTrustee.name,
+      status: taskStatus,
+      actions: isAllowMoreRolesForMainRootTrustee ? actions : void 0
+    }
+  );
+};
+const UndefinedBeneficiaryTaskItem = ({
+  undefinedBeneficiary,
+  onEdit,
+  onDelete
+}) => {
+  const { t } = useTranslation("trust");
+  const actions = [
+    {
+      icon: "edit",
+      onSelect: onEdit,
+      label: t(($) => $["editTrustMember"], {
+        trustMember: t(($) => $["undefinedBeneficiary"])
+      })
+    },
+    {
+      icon: "bin",
+      onSelect: onDelete,
+      label: t(($) => $["removeTrustMember"], {
+        trustMember: t(($) => $["undefinedBeneficiary"])
+      })
+    }
+  ];
+  return /* @__PURE__ */ jsx(
+    EntityAssociation,
+    {
+      name: undefinedBeneficiary.description,
+      types: [TrustMemberTypes.UNDEFINED_BENEFICIARY],
+      status: TaskStatuses.FINISHED,
+      actions,
+      onNavigateToEntity: onEdit
+    },
+    undefinedBeneficiary.reference
+  );
+};
+const TrustMembersOverview = ({
+  navigateBackToTaskList,
+  navigateToEditTrustMember,
+  navigateToEditTrustMemberOwner
+}) => {
+  const { t, i18n } = useTranslation("trust");
+  const { data: rootLe, isLoading } = useLegalEntity(ROOT_LE);
+  const { data: trustLe, refetch: refetchTrust } = useAssociatedLegalEntity(
+    rootLe,
+    LegalEntityTypes.TRUST
+  );
+  const trustMembers = useTrustMembers();
+  const { mutateAsync: updateLegalEntity } = useUpdateLegalEntity();
+  const { showToast } = useToastContext();
+  addResourceBundles(i18n, i18n.language, [
+    { ns: "trust", importFn: () => __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "../../language/bg-BG.json": () => import("./bg-BG-CepHap8j.js"), "../../language/cs-CZ.json": () => import("./cs-CZ-BP7niQM9.js"), "../../language/da-DK.json": () => import("./da-DK-Dc0QYG8m.js"), "../../language/de-DE.json": () => import("./de-DE-Dz2OsS1F.js"), "../../language/el-GR.json": () => import("./el-GR-BHG69mXl.js"), "../../language/en-US.json": () => import("./en-US-D-B35AoN.js"), "../../language/es-ES.json": () => import("./es-ES-BI_jdT67.js"), "../../language/et-EE.json": () => import("./et-EE-C_PZO2aI.js"), "../../language/fi-FI.json": () => import("./fi-FI-hwzizPnr.js"), "../../language/fr-FR.json": () => import("./fr-FR-CYZXbwc9.js"), "../../language/hr-HR.json": () => import("./hr-HR-bE6cvRCQ.js"), "../../language/hu-HU.json": () => import("./hu-HU-DG-NUDx4.js"), "../../language/it-IT.json": () => import("./it-IT-Erh1DIlj.js"), "../../language/ja-JP.json": () => import("./ja-JP-ThzG9vIo.js"), "../../language/lt-LT.json": () => import("./lt-LT-Nd1uRoIj.js"), "../../language/lv-LV.json": () => import("./lv-LV-DKhV24CI.js"), "../../language/nl-NL.json": () => import("./nl-NL-O9GCHMDA.js"), "../../language/no-NO.json": () => import("./no-NO-CA1aR6Wh.js"), "../../language/pl-PL.json": () => import("./pl-PL-BKDK0_G8.js"), "../../language/pt-BR.json": () => import("./pt-BR-NtLaWlnZ.js"), "../../language/pt-PT.json": () => import("./pt-PT-DSxxVA0f.js"), "../../language/ro-RO.json": () => import("./ro-RO-Bybq8JFn.js"), "../../language/sk-SK.json": () => import("./sk-SK-C6rMIxpz.js"), "../../language/sl-SI.json": () => import("./sl-SI-tPwbFvOI.js"), "../../language/sv-SE.json": () => import("./sv-SE-K1QT1cOt.js") }), `../../language/${i18n.language}.json`, 4) }
+  ]);
+  if (isLoading || !rootLe || !trustLe) {
+    return /* @__PURE__ */ jsx(Loader, { size: "large" });
+  }
+  const deleteTrustMember = async (trustMember) => {
+    try {
+      switch (trustMember.trustMemberType) {
+        case "regular":
+        case "exemptSettlor":
+        case "company":
+          await deleteAssociatedTrustMember({
+            associatedTrustMember: trustMember,
+            trust: trustLe,
+            asyncMutation: updateLegalEntity
+          });
+          break;
+        case "undefinedBeneficiary":
+          await deleteUndefinedBeneficiary({
+            undefinedBeneficiary: trustMember,
+            trust: trustLe,
+            asyncMutation: updateLegalEntity
+          });
+          break;
+        case "rootTrustee":
+          throw new Error("Cannot delete root trustee");
+      }
+      await refetchTrust();
+      showToast({ variant: "success", label: t(($) => $["successFullyRemovedTrustMember"]) });
+    } catch {
+      showToast({ variant: "error", label: t(($) => $["failedToRemoveTrustMember"]) });
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    TrustMembersOverviewInner,
+    {
+      trustMembers,
+      deleteTrustMember,
+      navigateBackToTaskList,
+      navigateToEditTrustMember,
+      navigateToEditTrustMemberOwner
+    }
+  );
+};
+const TrustMembersOverviewInner = ({
+  trustMembers,
+  deleteTrustMember,
+  navigateBackToTaskList,
+  navigateToEditTrustMember,
+  navigateToEditTrustMemberOwner
+}) => {
+  const { t } = useTranslation(["trust", "common"]);
+  const trustMemberRequirements = DEFAULT_TRUST_MEMBER_REQUIREMENTS;
+  const trustMembersWithOneOfGivenRoles = (roleTypes) => trustMembers.filter(
+    ({ roles }) => roleTypes.some((label) => roles.includes(label))
+  );
+  const { isExperimentEnabled } = useExperimentsContext();
+  const allowMoreRolesForMainRootTrustee = isExperimentEnabled("AllowMoreRolesForMainRootTrustee");
+  const getTaskStatus2 = useGetTaskStatus();
+  return /* @__PURE__ */ jsx(
+    DropinLayout,
+    {
+      content: /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-trust-members adyen-kyc-u-width-full", children: [
+        /* @__PURE__ */ jsx(
+          Header,
+          {
+            title: t(($) => $["trustMembers"]),
+            description: t(($) => $["trustMembersDescription"])
+          }
+        ),
+        /* @__PURE__ */ jsx("div", { className: "adyen-kyc-trust-members__container", children: trustMemberRequirements.map(({ roleTypes, min, label }) => /* @__PURE__ */ jsx(
+          EntityGuidanceStatus,
+          {
+            country: CountryCodes.Australia,
+            currentTask: TaskTypes.TRUST_MEMBER_OVERVIEW,
+            entityLabel: label,
+            status: iconStatus(trustMembersWithOneOfGivenRoles(roleTypes).length, min)
+          },
+          label
+        )) }),
+        /* @__PURE__ */ jsx(
+          ContextGuidance,
+          {
+            title: t(($) => $["whatIsTheDifferenceBetweenTheseRoles"]),
+            content: /* @__PURE__ */ jsx("ul", { className: "adyen-kyc-guidance-list", children: trustMemberRequirements.map(({ label }) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(Trans, { t, ns: "trust", i18nKey: ($) => $[`${label}GuideDescription`] }) }, label)) }),
+            titleId: "whatIsTheDifferenceBetweenTheseRoles",
+            contentId: "differenceBetweenTrustMemberRoles"
+          }
+        ),
+        /* @__PURE__ */ jsx(StackLayout, { gap: "small", children: trustMembers.map((trustMember) => {
+          switch (trustMember.trustMemberType) {
+            case "rootTrustee":
+              return /* @__PURE__ */ jsx(
+                RootTrusteeTaskItem,
+                {
+                  rootTrustee: trustMember,
+                  taskStatus: getTaskStatus2(
+                    trustMember.legalEntityType == "organization" ? TaskTypes.TRUST_MEMBER_COMPANY : TaskTypes.TRUST_MEMBER_INDIVIDUAL,
+                    String(trustMember.legalEntityId)
+                  ),
+                  onEdit: allowMoreRolesForMainRootTrustee ? () => navigateToEditTrustMember(trustMember) : () => {
+                  }
+                },
+                trustMember.legalEntityId
+              );
+            case "regular":
+              return /* @__PURE__ */ jsx(
+                RegularTrustMemberTaskItem,
+                {
+                  trustMember,
+                  taskStatus: getTaskStatus2(
+                    TaskTypes.TRUST_MEMBER_INDIVIDUAL,
+                    String(trustMember.legalEntityId)
+                  ),
+                  onEdit: () => navigateToEditTrustMember(trustMember),
+                  onDelete: () => deleteTrustMember(trustMember)
+                },
+                trustMember.legalEntityId
+              );
+            case "company":
+              return /* @__PURE__ */ jsx(
+                CompanyTrustMemberTaskItem,
+                {
+                  companyTrustMember: trustMember,
+                  taskStatus: getTaskStatus2(
+                    TaskTypes.TRUST_MEMBER_COMPANY,
+                    String(trustMember.legalEntityId)
+                  ),
+                  onEdit: () => navigateToEditTrustMember(trustMember),
+                  onDelete: () => deleteTrustMember(trustMember),
+                  onEditOwner: () => navigateToEditTrustMemberOwner(
+                    trustMember.ownerId,
+                    trustMember.legalEntityId
+                  ),
+                  onAddOwner: () => navigateToEditTrustMemberOwner("", trustMember.legalEntityId)
+                },
+                trustMember.legalEntityId
+              );
+            case "exemptSettlor":
+              return /* @__PURE__ */ jsx(
+                ExemptSettlorTaskItem,
+                {
+                  exemptSettlor: trustMember,
+                  taskStatus: getTaskStatus2(
+                    TaskTypes.TRUST_MEMBER_INDIVIDUAL,
+                    String(trustMember.legalEntityId)
+                  ),
+                  onEdit: () => navigateToEditTrustMember(trustMember),
+                  onDelete: () => deleteTrustMember(trustMember)
+                },
+                trustMember.legalEntityId
+              );
+            case "undefinedBeneficiary":
+              return /* @__PURE__ */ jsx(
+                UndefinedBeneficiaryTaskItem,
+                {
+                  undefinedBeneficiary: trustMember,
+                  onEdit: () => navigateToEditTrustMember(trustMember),
+                  onDelete: () => deleteTrustMember(trustMember)
+                },
+                trustMember.reference
+              );
+          }
+        }) }),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "secondary",
+            icon: "plus",
+            onClick: (e) => {
+              e.stopPropagation();
+              navigateToEditTrustMember("new");
+            },
+            children: t(($) => $["addTrustMember"])
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          ActionBar,
+          {
+            onHome: navigateBackToTaskList,
+            homeButtonLabel: t(($) => $["saveAndGoToOverview"], { ns: "common" })
+          }
+        )
+      ] })
+    }
+  );
+};
+const createDefaultMember = (selectedMember, selectedEntityType, selectedRoles) => {
+  const firstRole = selectedRoles?.[0];
+  return {
+    memberType: selectedMember?.memberType || firstRole,
+    roles: selectedRoles || selectedMember?.roles || [UnincorporatedPartnershipMemberTypes.SECONDARY_PARTNER],
+    legalEntityType: selectedEntityType,
+    legalEntityId: selectedMember?.legalEntityId || "",
+    name: selectedMember?.name || ""
+  };
+};
+const useUnincorporatedPartnershipNavigation = ({ navigateTo }) => {
+  const [activeMember, setActiveMember] = useState();
+  const { rootLegalEntityId } = useApiContext();
+  const onNavigateToMember = async ({
+    selectedMember,
+    selectedRoles,
+    selectedEntityType,
+    roleAndType
+  }) => {
+    const createdMember = createDefaultMember(selectedMember, selectedEntityType, selectedRoles);
+    setActiveMember(createdMember);
+    if (rootLegalEntityId.value === createdMember?.legalEntityId) {
+      navigateTo(
+        createdMember.legalEntityType === LegalEntityTypes.INDIVIDUAL ? TaskTypes.INDIVIDUAL : TaskTypes.BUSINESS_DETAILS
+      );
+      return;
+    }
+    if (roleAndType) {
+      navigateTo(TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_ROLE_AND_TYPE);
+      return;
+    }
+    navigateTo(
+      createdMember?.legalEntityType === LegalEntityTypes.ORGANIZATION ? TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY : TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_INDIVIDUAL
+    );
+  };
+  return {
+    onNavigateToMember,
+    activeMember,
+    setActiveMember
+  };
+};
+const adyenKycRoleAndTypeContainer = "adyen-kyc-adyen-kyc-role-and-type-container";
+const adyenKycRoleAndTypeActionBar = "adyen-kyc-adyen-kyc-role-and-type-action-bar";
+const inlineRadioGroup = "adyen-kyc-inline-radio-group";
+const styles$1 = {
+  adyenKycRoleAndTypeContainer,
+  adyenKycRoleAndTypeActionBar,
+  inlineRadioGroup
+};
+const UnincorporatedPartnershipRadioGroup = ({
+  memberType,
+  errorMessage,
+  handleChangeFor,
+  value
+}) => {
+  const { i18n } = useI18nContext();
+  return /* @__PURE__ */ jsx(
+    Field,
+    {
+      el: "fieldset",
+      name: memberType,
+      label: i18n.get(
+        memberType === UnincorporatedPartnershipMemberTypes.OWNER ? "ownerDescriptionAsPartner" : "controllerDescriptionAsPartner"
+      ),
+      className: styles$1.inlineRadioGroup,
+      errorMessage,
+      children: (childProps) => /* @__PURE__ */ jsx(
+        RadioGroup,
+        {
+          ...childProps,
+          name: memberType,
+          items: [
+            { id: "yes", name: "yes" },
+            { id: "no", name: "no" }
+          ],
+          value,
+          onChange: (id) => handleChangeFor(memberType)(
+            id
+          ),
+          horizontal: true
+        }
+      )
+    }
+  );
+};
+const unincorporatedPartnershipRoleAndTypeValidationRules = {
+  entityType: {
+    modes: ["blur"],
+    validate: (entityType) => !isEmpty(entityType),
+    errorMessage: "fieldIsRequired"
+  },
+  uboThroughControl: {
+    modes: ["blur"],
+    validate: (value) => !!value,
+    errorMessage: "fieldIsRequired"
+  },
+  uboThroughOwnership: {
+    modes: ["blur"],
+    validate: (value) => !!value,
+    errorMessage: "fieldIsRequired"
+  }
+};
+const regularForms = {
+  roleAndEntityType: {
+    formId: "roleAndEntityType",
+    formName: "roleAndEntityType",
+    fields: ["role", "entityType"]
+  },
+  memberDetails: {
+    formId: "memberDetails",
+    formName: "memberDetails"
+  }
+};
+const leTypeCardDetails = {
+  [LegalEntityTypes.INDIVIDUAL]: {
+    id: "individual",
+    name: "individualMember",
+    description: "partnerNotABusiness"
+  },
+  [LegalEntityTypes.ORGANIZATION]: {
+    id: "organization",
+    name: "companyMember",
+    description: "partnerIsABusiness"
+  }
+};
+function getUboStatus(roles, roleType, existingMember) {
+  if (!existingMember) {
+    return void 0;
+  }
+  return roles?.includes(roleType) ? "yes" : "no";
+}
+function UnincorporatedPartnershipRoleAndTypeDropin({
+  onNavigateToMember,
+  activeMember
+}) {
+  const { t } = useTranslation(["common"]);
+  const { t: unincorpPartnershipT } = useTranslation(["unincorpPartnership"]);
+  const [shouldValidate, setShouldValidate] = useState(false);
+  const activeForm = regularForms.roleAndEntityType;
+  const formUtils = createFormUtils(
+    {},
+    t
+  );
+  const formsWithValidity = Object.values(regularForms).map((form) => ({
+    formId: form.formId,
+    formName: form.formName,
+    isValid: false
+  }));
+  const existingMember = activeMember?.legalEntityId;
+  const defaultData = {
+    entityType: activeMember?.legalEntityType,
+    uboThroughControl: getUboStatus(
+      activeMember?.roles,
+      UnincorporatedPartnershipMemberTypes.CONTROLLING_PERSON,
+      existingMember
+    ),
+    uboThroughOwnership: getUboStatus(
+      activeMember?.roles,
+      UnincorporatedPartnershipMemberTypes.OWNER,
+      existingMember
+    )
+  };
+  const decideFields = (data2) => {
+    if (data2.entityType === LegalEntityTypes.INDIVIDUAL) {
+      return ["entityType", "uboThroughControl", "uboThroughOwnership"];
+    }
+    return ["entityType"];
+  };
+  const { data, schema, errors, fieldProblems, handleChangeFor } = useForm({
+    schema: decideFields,
+    rules: unincorporatedPartnershipRoleAndTypeValidationRules,
+    defaultData,
+    shouldValidate
+  });
+  const onNextClick = () => {
+    if (Object.values(data).some((fieldValue) => !fieldValue) && data.entityType !== LegalEntityTypes.ORGANIZATION) {
+      setShouldValidate(true);
+      return;
+    }
+    const selectedRoles = [
+      UnincorporatedPartnershipMemberTypes.SECONDARY_PARTNER
+    ];
+    if (data.entityType === LegalEntityTypes.INDIVIDUAL) {
+      if (data.uboThroughControl === "yes") {
+        selectedRoles.push(UnincorporatedPartnershipMemberTypes.CONTROLLING_PERSON);
+      }
+      if (data.uboThroughOwnership === "yes") {
+        selectedRoles.push(UnincorporatedPartnershipMemberTypes.OWNER);
+      }
+    }
+    onNavigateToMember({
+      selectedMember: activeMember,
+      selectedRoles,
+      selectedEntityType: data.entityType
+    });
+  };
+  return /* @__PURE__ */ jsxs("div", { className: styles$1.adyenKycRoleAndTypeContainer, children: [
+    /* @__PURE__ */ jsx("div", { className: "adyen-kyc-dropin__sidebar-wrapper", children: /* @__PURE__ */ jsx(
+      FormNavigation,
+      {
+        forms: formsWithValidity,
+        activeForm: formsWithValidity.find((form) => form.formId === activeForm.formId) || formsWithValidity?.[0],
+        taskName: "unincorporatedPartnershipMembers",
+        gotoForm: () => {
+        }
+      }
+    ) }),
+    /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-form-container", children: [
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: "adyen-kyc-form-wrapper",
+          children: /* @__PURE__ */ jsxs("form", { className: "adyen-kyc-trust__role-and-entity-type adyen-kyc-u-width-full", children: [
+            /* @__PURE__ */ jsx(
+              Header,
+              {
+                title: t(($) => $["roleAndEntityType"]),
+                description: unincorpPartnershipT(($) => $["partnerRoleDescription"])
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Field,
+              {
+                el: "fieldset",
+                name: "entityType",
+                label: formUtils.getLabel("entityType", "whatTypeOfEntityIsPartner"),
+                errorMessage: formUtils.getErrorMessage("entityType", errors, fieldProblems),
+                children: (childProps) => /* @__PURE__ */ jsx(
+                  RadioGroupCard,
+                  {
+                    ...childProps,
+                    name: "entityType",
+                    options: trustMemberLegalEntityTypes,
+                    selected: data?.entityType,
+                    onSelect: (option) => handleChangeFor("entityType")(option),
+                    optionId: (option) => leTypeCardDetails[option].id,
+                    optionName: (option) => unincorpPartnershipT(($) => $[leTypeCardDetails[option].name]),
+                    optionDescription: (option) => unincorpPartnershipT(($) => $[leTypeCardDetails[option].description]),
+                    "aria-required": true
+                  }
+                )
+              }
+            ),
+            schema.includes("uboThroughOwnership") && /* @__PURE__ */ jsx(
+              UnincorporatedPartnershipRadioGroup,
+              {
+                memberType: UnincorporatedPartnershipMemberTypes.OWNER,
+                handleChangeFor,
+                errorMessage: formUtils.getErrorMessage(
+                  UnincorporatedPartnershipMemberTypes.OWNER,
+                  errors,
+                  fieldProblems
+                ),
+                value: data?.uboThroughOwnership
+              }
+            ),
+            schema.includes("uboThroughControl") && /* @__PURE__ */ jsx(
+              UnincorporatedPartnershipRadioGroup,
+              {
+                memberType: UnincorporatedPartnershipMemberTypes.CONTROLLING_PERSON,
+                handleChangeFor,
+                errorMessage: formUtils.getErrorMessage(
+                  UnincorporatedPartnershipMemberTypes.CONTROLLING_PERSON,
+                  errors,
+                  fieldProblems
+                ),
+                value: data?.uboThroughControl
+              }
+            )
+          ] })
+        }
+      ),
+      /* @__PURE__ */ jsx("div", { className: styles$1.adyenKycRoleAndTypeActionBar, children: /* @__PURE__ */ jsx(Button, { onClick: onNextClick, children: t(($) => $["continue"]) }) })
+    ] })
+  ] });
+}
+function UnincorporatedPartnershipMemberRoleAndTypePage({
+  memberId,
+  onNavigateToMember,
+  navigateBack
+}) {
+  const { i18n } = useTranslation();
+  const { data: memberLe } = useLegalEntity(memberId || skipToken);
+  const unincorporatedPartnershipMembers = useUnincorporatedPartnershipMembers();
+  addResourceBundles(i18n, i18n.language, [
+    {
+      ns: "unincorpPartnership",
+      importFn: () => __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "../language/bg-BG.json": () => import("./bg-BG-er0t4jTs.js"), "../language/cs-CZ.json": () => import("./cs-CZ-CQNBae2b.js"), "../language/da-DK.json": () => import("./da-DK-gnPgzwrG.js"), "../language/de-DE.json": () => import("./de-DE-D3lLuF8z.js"), "../language/el-GR.json": () => import("./el-GR-XRux2Wpv.js"), "../language/en-US.json": () => import("./en-US-B96dpVon.js"), "../language/es-ES.json": () => import("./es-ES-CXDJLKAI.js"), "../language/et-EE.json": () => import("./et-EE--cL_YqWe.js"), "../language/fi-FI.json": () => import("./fi-FI-fArobrt5.js"), "../language/fr-FR.json": () => import("./fr-FR-CiwkAb3E.js"), "../language/hr-HR.json": () => import("./hr-HR-DtfHQVe0.js"), "../language/hu-HU.json": () => import("./hu-HU-I4-KFzvz.js"), "../language/it-IT.json": () => import("./it-IT-DIbH-udG.js"), "../language/ja-JP.json": () => import("./ja-JP-bz7ekGnF.js"), "../language/lt-LT.json": () => import("./lt-LT-BLsIcCtE.js"), "../language/lv-LV.json": () => import("./lv-LV-C7hMdPcY.js"), "../language/nl-NL.json": () => import("./nl-NL-NlkjOSYi.js"), "../language/no-NO.json": () => import("./no-NO-Crlsj6HG.js"), "../language/pl-PL.json": () => import("./pl-PL-DYxD6VJ_.js"), "../language/pt-BR.json": () => import("./pt-BR-BfxgHKY4.js"), "../language/pt-PT.json": () => import("./pt-PT-TKg5FLat.js"), "../language/ro-RO.json": () => import("./ro-RO-3rOfS17N.js"), "../language/sk-SK.json": () => import("./sk-SK-CjrLvDMx.js"), "../language/sl-SI.json": () => import("./sl-SI-C-C-KJCX.js"), "../language/sv-SE.json": () => import("./sv-SE-BHfydid5.js") }), `../language/${i18n.language}.json`, 3)
+    }
+  ]);
+  if (memberId && !memberLe) {
+    return /* @__PURE__ */ jsx(Loader, {});
+  }
+  const unincorporatedPartnershipMember = memberId ? unincorporatedPartnershipMembers.find((tm) => tm.legalEntityId === memberId) : void 0;
+  return /* @__PURE__ */ jsx(
+    UnincorporatedPartnershipRoleAndTypeDropin,
+    {
+      activeMember: unincorporatedPartnershipMember,
+      onNavigateToMember,
+      navigateBack
+    }
+  );
+}
+const alertHeader = "adyen-kyc-alert-header";
+const styles = {
+  alertHeader
+};
+const isPrimaryPartner = (member) => member?.roles?.includes("primaryPartner");
+const isMemberMissingOwner = (member) => {
+  return !isPrimaryPartner(member) && member.legalEntityType === LegalEntityTypes.ORGANIZATION && !member.ownerId;
+};
+const UnincorporatedPartnershipMembersOverview = ({
+  navigateBackToTaskList,
+  navigateToEditMember,
+  navigateToEditMemberOwner
+}) => {
+  const { t, i18n: i18next } = useTranslation(["unincorpPartnership", "common"]);
+  const { data: rootLe } = useLegalEntity(ROOT_LE);
+  const { data: partnershipLe, refetch: refetchPartnership } = useAssociatedLegalEntity(
+    rootLe,
+    LegalEntityTypes.UNINCORPORATED_PARTNERSHIP
+  );
+  const partnershipMembers = useUnincorporatedPartnershipMembers();
+  const { mutateAsync: updateLegalEntity } = useUpdateLegalEntity();
+  const { setUnincorporatedPartnershipMembers } = useGlobalStore();
+  addResourceBundles(i18next, i18next.language, [
+    {
+      ns: "unincorpPartnership",
+      importFn: () => __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "../../language/bg-BG.json": () => import("./bg-BG-er0t4jTs.js"), "../../language/cs-CZ.json": () => import("./cs-CZ-CQNBae2b.js"), "../../language/da-DK.json": () => import("./da-DK-gnPgzwrG.js"), "../../language/de-DE.json": () => import("./de-DE-D3lLuF8z.js"), "../../language/el-GR.json": () => import("./el-GR-XRux2Wpv.js"), "../../language/en-US.json": () => import("./en-US-B96dpVon.js"), "../../language/es-ES.json": () => import("./es-ES-CXDJLKAI.js"), "../../language/et-EE.json": () => import("./et-EE--cL_YqWe.js"), "../../language/fi-FI.json": () => import("./fi-FI-fArobrt5.js"), "../../language/fr-FR.json": () => import("./fr-FR-CiwkAb3E.js"), "../../language/hr-HR.json": () => import("./hr-HR-DtfHQVe0.js"), "../../language/hu-HU.json": () => import("./hu-HU-I4-KFzvz.js"), "../../language/it-IT.json": () => import("./it-IT-DIbH-udG.js"), "../../language/ja-JP.json": () => import("./ja-JP-bz7ekGnF.js"), "../../language/lt-LT.json": () => import("./lt-LT-BLsIcCtE.js"), "../../language/lv-LV.json": () => import("./lv-LV-C7hMdPcY.js"), "../../language/nl-NL.json": () => import("./nl-NL-NlkjOSYi.js"), "../../language/no-NO.json": () => import("./no-NO-Crlsj6HG.js"), "../../language/pl-PL.json": () => import("./pl-PL-DYxD6VJ_.js"), "../../language/pt-BR.json": () => import("./pt-BR-BfxgHKY4.js"), "../../language/pt-PT.json": () => import("./pt-PT-TKg5FLat.js"), "../../language/ro-RO.json": () => import("./ro-RO-3rOfS17N.js"), "../../language/sk-SK.json": () => import("./sk-SK-CjrLvDMx.js"), "../../language/sl-SI.json": () => import("./sl-SI-C-C-KJCX.js"), "../../language/sv-SE.json": () => import("./sv-SE-BHfydid5.js") }), `../../language/${i18next.language}.json`, 4)
+    }
+  ]);
+  useEffect(
+    () => setUnincorporatedPartnershipMembers(partnershipMembers),
+    [partnershipMembers, setUnincorporatedPartnershipMembers]
+  );
+  const getTaskStatus2 = useGetTaskStatus();
+  if (!rootLe || !partnershipLe) {
+    return /* @__PURE__ */ jsx(Loader, { size: "large" });
+  }
+  const deleteMember = async (member) => {
+    try {
+      await deleteUnincorporatedPartnershipMember({
+        associatedMember: member,
+        unincorporatedPartnership: partnershipLe,
+        updateLegalEntity
+      });
+      await refetchPartnership();
+    } catch (error) {
+      console.error(error);
+    }
+  };
+  const getActions = (member) => {
+    const baseActions = [
+      {
+        icon: "edit",
+        onSelect: () => navigateToEditMember(member),
+        label: t(($) => $["editTrustMember"], {
+          trustMember: member.name
+        })
+      }
+    ];
+    if (member.legalEntityType === LegalEntityTypes.ORGANIZATION && !isPrimaryPartner(member)) {
+      const missingOwner = isMemberMissingOwner(member);
+      baseActions.push({
+        icon: missingOwner ? "plus" : "edit",
+        onSelect: () => navigateToEditMemberOwner(member?.ownerId, member?.legalEntityId),
+        label: t(($) => $[missingOwner ? "addOwnerToTrustMember" : "editOwnerOfTrustMember"], {
+          trustMember: member.name
+        })
+      });
+    }
+    if (!isPrimaryPartner(member)) {
+      baseActions.push({
+        icon: "bin",
+        onSelect: () => deleteMember(member),
+        label: t(($) => $["removeTrustMember"], {
+          trustMember: member.name
+        })
+      });
+    }
+    return baseActions;
+  };
+  const infoContent = (member) => /* @__PURE__ */ jsx(
+    Alert,
+    {
+      className: styles.alertHeader,
+      title: /* @__PURE__ */ jsxs(Fragment, { children: [
+        t(($) => $["helpUsVerifyCompany"], { ns: "common" }),
+        " ",
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            onClick: (e) => {
+              e.preventDefault();
+              e.stopPropagation();
+              navigateToEditMemberOwner(member?.ownerId, member?.legalEntityId);
+            },
+            variant: "link",
+            children: t(($) => $["providePersonalDetailsOfOwner"])
+          }
+        )
+      ] })
+    }
+  );
+  return /* @__PURE__ */ jsx(
+    DropinLayout,
+    {
+      content: /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-u-width-full", children: [
+        /* @__PURE__ */ jsx(
+          Header,
+          {
+            title: t(($) => $["partnershipMembers"]),
+            description: t(($) => $["partnershipMembersDescription"])
+          }
+        ),
+        /* @__PURE__ */ jsxs(StackLayout, { children: [
+          partnershipMembers.map((member) => {
+            return /* @__PURE__ */ jsx(
+              EntityAssociation,
+              {
+                types: member.roles,
+                name: member.name,
+                status: getTaskStatus2(
+                  member.legalEntityType === LegalEntityTypes.INDIVIDUAL ? TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_INDIVIDUAL : TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY,
+                  member.legalEntityId
+                ),
+                actions: getActions(member),
+                onNavigateToEntity: () => navigateToEditMember(member),
+                infoContent: isMemberMissingOwner(member) ? infoContent(member) : void 0
+              },
+              member.legalEntityId
+            );
+          }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "secondary",
+              icon: "plus",
+              onClick: () => navigateToEditMember(void 0),
+              fullWidth: true,
+              children: t(($) => $["addPartner"])
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(
+          ActionBar,
+          {
+            onHome: navigateBackToTaskList,
+            homeButtonLabel: t(($) => $["saveAndGoToOverview"], { ns: "common" })
+          }
+        )
+      ] })
+    }
+  );
+};
+const useShouldShowIntroduction = ({
+  legalEntity
+}) => {
+  const canSeeIntroduction = useCanSeeIntroduction({ legalEntity });
+  const { hasSeenIntroduction } = useHasSeenIntroduction({ legalEntityId: legalEntity.id });
+  return canSeeIntroduction && !hasSeenIntroduction;
+};
+const useNavigation = ({ legalEntity, onNavigate }) => {
+  const { isSettingEnabled } = useSettingsContext();
+  const userEvents = useAnalyticsContext();
+  const showServiceAgreementsFirst = isSettingEnabled(SettingNames.ShowServiceAgreementsFirst);
+  const showBusinessFinancingFirst = isSettingEnabled(SettingNames.ShowBusinessFinancingFirst);
+  const canChangeEntityType = isSettingEnabled(SettingNames.AllowLegalEntityTypeChange);
+  const showIntroduction = useShouldShowIntroduction({ legalEntity });
+  const { hasSeenSingpassSelection } = useHasSeenSingpassSelection({
+    legalEntityId: legalEntity.id
+  });
+  const { accountHolder } = useAccountHolder();
+  const { canSeeEntitySelection } = useCanSeeEntitySelection(legalEntity.id);
+  const { isEligibleForSingpass } = useSingpassMyInfoLogin({
+    legalEntity,
+    accountHolder
+  });
+  const shouldShowSingpassSelection = isEligibleForSingpass && !hasSeenSingpassSelection;
+  const [taskHistory, setTaskHistory] = useState(["default"]);
+  const actualTasks = taskHistory.filter((task) => task !== "default");
+  const handleNavigation = useCallback(
+    (task) => {
+      userEvents.updateBaseTrackingPayload({ task });
+      onNavigate?.(task);
+    },
+    [onNavigate]
+  );
+  const navigateTo = useCallback(
+    (task, deletePreviousHistory = false) => {
+      const pushNewTask = () => setTaskHistory((taskHistory2) => deletePreviousHistory ? [task] : [...taskHistory2, task]);
+      if (task === "default") {
+        setTimeout(pushNewTask);
+      } else {
+        pushNewTask();
+        handleNavigation(task);
+      }
+    },
+    [handleNavigation]
+  );
+  const navigateBack = useCallback(
+    (stepCount = 1) => {
+      if (taskHistory.length <= 1) return;
+      const prevTask = taskHistory[taskHistory.length - (stepCount + 1)];
+      if (prevTask === "default") {
+        throw Error("Cannot navigate back to 'default' task");
+      }
+      if (prevTask === TaskTypes.TASKS_OVERVIEW) {
+        setTaskHistory([TaskTypes.TASKS_OVERVIEW]);
+        handleNavigation?.(TaskTypes.TASKS_OVERVIEW);
+        return;
+      }
+      setTaskHistory(taskHistory.slice(0, -1 * stepCount));
+      handleNavigation?.(prevTask);
+      userEvents.updateBaseTrackingPayload({ task: prevTask });
+    },
+    [taskHistory, handleNavigation]
+  );
+  useEffect(() => {
+    if (!window.history.state) window.history.pushState({}, "");
+    const handleBrowserBackButton = () => {
+      if (window.history.state === null) window.history.pushState({}, "");
+      navigateTo(TaskTypes.TASKS_OVERVIEW);
+    };
+    window.addEventListener("popstate", handleBrowserBackButton);
+    return () => {
+      window.removeEventListener("popstate", handleBrowserBackButton);
+    };
+  }, [navigateTo]);
+  useEffect(() => {
+    const pushedTask = taskHistory[taskHistory.length - 1];
+    if (pushedTask === "default") {
+      const defaultTask = getDefaultTask({
+        legalEntity,
+        canSeeEntitySelection,
+        showIntroduction,
+        canChangeEntityType,
+        shouldShowSingpassSelection,
+        showServiceAgreementsFirst,
+        showBusinessFinancingFirst
+      });
+      setTaskHistory([...taskHistory.slice(0, taskHistory.length - 1), defaultTask]);
+    }
+  }, [
+    legalEntity,
+    accountHolder,
+    showIntroduction,
+    canChangeEntityType,
+    shouldShowSingpassSelection,
+    showServiceAgreementsFirst,
+    taskHistory,
+    showBusinessFinancingFirst
+  ]);
+  return {
+    currentTask: actualTasks[actualTasks.length - 1],
+    previousTask: actualTasks[actualTasks.length - 2],
+    navigateBack,
+    navigateTo
+  };
+};
+const getDefaultTask = ({
+  legalEntity,
+  canSeeEntitySelection,
+  canChangeEntityType,
+  showIntroduction,
+  shouldShowSingpassSelection,
+  showServiceAgreementsFirst,
+  showBusinessFinancingFirst
+}) => {
+  const hasLegalEntityProgressedBeyondEntitySelection = hasProgressedBeyondEntitySelection(legalEntity);
+  if (showServiceAgreementsFirst) {
+    return TaskTypes.SERVICE_AGREEMENT;
+  }
+  if (showBusinessFinancingFirst) {
+    return TaskTypes.BUSINESS_FINANCING;
+  }
+  if (canChangeEntityType && canSeeEntitySelection && !hasLegalEntityProgressedBeyondEntitySelection)
+    return TaskTypes.BUSINESS_TYPE_SELECTION;
+  if (showIntroduction) return TaskTypes.INTRODUCTION;
+  if (shouldShowSingpassSelection) return TaskTypes.SINGPASS_SELECTION;
+  return TaskTypes.TASKS_OVERVIEW;
+};
+const hasProgressedBeyondEntitySelection = (legalEntity) => {
+  const hasOwnEntityAssocation = legalEntity.entityAssociations?.some(
+    (ea) => ea.associatorId === legalEntity.id
+  );
+  const hasOrganizationType = legalEntity.organization?.type;
+  return hasOwnEntityAssocation || !!hasOrganizationType;
+};
+const Introduction = lazy(
+  async () => (await import("./Introduction-DH4Tivyl.js")).Introduction
+);
+const BusinessTypeSelectionPage = lazy(
+  async () => (await import("./BusinessTypeSelectionPage-CQvrZNZZ.js")).BusinessTypeSelectionPage
+);
+const SingpassSelection = lazy(
+  async () => (await import("./SingpassSelection-DTOk81Y1.js")).SingpassSelection
+);
+const AccountSetupRejected = lazy(
+  async () => (await import("./AccountSetupRejected-B0RVdTUw.js")).AccountSetupRejected
+);
+const DecisionMakers = lazy(
+  async () => (await import("./DecisionMakers-DUjAziKs.js")).DecisionMakers
+);
+const CustomerSupport = lazy(
+  async () => (await import("./CustomerSupport-DyfNEq22.js")).CustomerSupport
+);
+const Review = lazy(async () => (await import("./Review-4b9BWdsh.js")).Review);
+const SignPCIComponent = lazy(
+  async () => (await import("./SignPCIComponent-4UrP4tNd.js")).SignPCIComponent
+);
+const AcceptTermsOfService = lazy(
+  async () => (await import("./AcceptTermsOfServiceComponent-BW8S5c-F.js")).AcceptTermsOfServiceComponent
+);
+const TaxReportingDropin = lazy(
+  async () => (await import("./TaxReportingDropin-2VcdfJvr.js")).TaxReportingDropin
+);
+const PayoutDetailsPage = lazy(
+  async () => (await import("./PayoutDetailsDropin-BFUH8RvF.js").then((n) => n.a)).PayoutDetailsPage
+);
+const RootBusinessDetailsPage = lazy(
+  async () => (await import("./RootBusinessDetailsPage-DO5202Yd.js")).RootBusinessDetailsPage
+);
+const RootBusinessLinesPage = lazy(
+  async () => (await import("./RootBusinessLinesPage-D0tGN2u3.js")).RootBusinessLinesPage
+);
+const SoleProprietorshipPage = lazy(
+  async () => (await import("./SoleProprietorshipPage-BL3u4nCi.js")).SoleProprietorshipPage
+);
+const TrustMemberCompanyPage = lazy(
+  async () => (await import("./TrustMemberCompanyPage-CwNG1bni.js")).TrustMemberCompanyPage
+);
+const UnincorporatedPartnershipMemberCompanyPage = lazy(
+  async () => (await import("./UnincorporatedPartnershipMemberCompanyPage-av-gOgOa.js")).UnincorporatedPartnershipMemberCompanyPage
+);
+const BusinessFinancingPage = lazy(
+  async () => (await import("./BusinessFinancingPage-DuRkxp4x.js")).BusinessFinancingPage
+);
+const TrustDetailsPage = lazy(
+  async () => (await import("./TrustDetailsPage-COIeKAk2.js")).TrustDetailsPage
+);
+const SourceOfFundsPage = lazy(
+  async () => (await import("./SourceOfFundsPage-HgGh-VDQ.js")).SourceOfFundsPage
+);
+const RootIndividualDetailsPage = lazy(
+  async () => (await import("./RootIndividualDetailsPage-2c_nvpAv.js")).RootIndividualDetailsPage
+);
+const LegalRepresentativeDetailsPage = lazy(
+  async () => (await import("./LegalRepresentativeDetailsPage-Dny2mD-G.js")).LegalRepresentativeDetailsPage
+);
+const TrustMemberIndividualPage = lazy(
+  async () => (await import("./TrustMemberIndividualPage-D57poDUv.js")).TrustMemberIndividualPage
+);
+const UnincorporatedPartnershipIndividualPage = lazy(
+  async () => (await import("./UnincorporatedPartnershipIndividualPage-oiEGWL8D.js")).UnincorporatedPartnershipIndividualPage
+);
+const DecisionMakerDetailsPage = lazy(
+  async () => (await import("./DecisionMakerDetailsPage-D-8hNnWf.js")).DecisionMakerDetailsPage
+);
+function isIn(values, x) {
+  return values.includes(x);
+}
+const PAGES_WITH_POLLING = [TaskTypes.DECISION_MAKER_OVERVIEW, TaskTypes.TASKS_OVERVIEW];
+const logger = createLogger();
+function DropinComposer({
+  legalEntityResponse,
+  onSubmit,
+  onNavigate = noop,
+  openBankingPartnerConfigId
+}) {
+  const { accountHolder, setAccountHolder } = useAccountHolder();
+  const { setCanSeeEntitySelection } = useCanSeeEntitySelection(legalEntityResponse.id);
+  const userEvents = useAnalyticsContext();
+  const { experiments } = useExperimentsContext();
+  const { setHasSeenSingpassSelection } = useHasSeenSingpassSelection({
+    legalEntityId: legalEntityResponse.id
+  });
+  const { setHasSeenIntroduction } = useHasSeenIntroduction({
+    legalEntityId: legalEntityResponse.id
+  });
+  const { currentTask, previousTask, navigateTo, navigateBack } = useNavigation({
+    legalEntity: legalEntityResponse,
+    onNavigate
+  });
+  const {
+    rootLegalEntity: rootLegalEntitySignal,
+    rootLegalEntityCountry: rootLegalEntityCountrySignal,
+    taskTypes: taskTypesSignal,
+    setRootLegalEntity,
+    setTaskTypes,
+    setAccountHolder: setAccountHolderInGlobalStore
+  } = useGlobalStore();
+  const rootLegalEntity = rootLegalEntitySignal.value;
+  const rootLegalEntityCountry = rootLegalEntityCountrySignal.value;
+  const taskTypes = taskTypesSignal.value;
+  const { data: rawTaskTypes, isLoading: isLoadingConfiguration } = useTaskTypes();
+  const { isSettingEnabled } = useSettingsContext();
+  useEffect(() => {
+    if (!rawTaskTypes) {
+      return;
+    }
+    let filteredTasks = rawTaskTypes;
+    if (!isSettingEnabled(SettingNames.AllowBusinessLines)) {
+      filteredTasks = rawTaskTypes?.filter((task) => task !== TaskTypes.ACQUIRING_BUSINESS_LINE);
+    }
+    setTaskTypes(filteredTasks);
+  }, [rawTaskTypes, setTaskTypes]);
+  const { data: legalEntityData, refetch: refetchLegalEntity } = useLegalEntity(
+    legalEntityResponse.id,
+    {
+      refetchInterval: (query) => {
+        const legalEntityData2 = query.state.data;
+        if (legalEntityData2) {
+          return !currentTask || !isIn(PAGES_WITH_POLLING, currentTask) || hasAllCapabilitiesResolved(legalEntityData2) || hasRejectedCapabilities(legalEntityData2) ? false : 3e3;
+        }
+        return 3e3;
+      }
+    }
+  );
+  useEffect(() => {
+    if (legalEntityData && !objectsDeepEqual(legalEntityData, rootLegalEntity)) {
+      setRootLegalEntity(legalEntityData);
+    }
+  }, [legalEntityData]);
+  const [currentTransferInstrumentId, setCurrentTransferInstrumentId] = useState();
+  const {
+    isEligibleForSingpass,
+    state: singpassLoginState,
+    handleInitiateSingpassMyInfoLogin,
+    handleSingpassMyInfoLoginSuccess,
+    handleSingpassMyInfoLoginFailure,
+    handleSingpassMyInfoLoginReset,
+    trustedFields: singpassTrustedFields,
+    trustedEntityAssociations
+  } = useSingpassMyInfoLogin({
+    legalEntity: rootLegalEntity,
+    accountHolder
+  });
+  const singpassTabRef = useRef(null);
+  const { data: trust, refetch: refetchTrust } = useAssociatedLegalEntity(
+    rootLegalEntity,
+    LegalEntityTypes.TRUST
+  );
+  const { data: unincorporatedPartnership, refetch: refetchUnincorporatedPartnership } = useAssociatedLegalEntity(rootLegalEntity, LegalEntityTypes.UNINCORPORATED_PARTNERSHIP);
+  const { data: soleProp } = useAssociatedLegalEntity(
+    rootLegalEntity,
+    LegalEntityTypes.SOLE_PROPRIETORSHIP
+  );
+  const [parentId, setParentId] = useState();
+  const [currentDecisionMakerId, setCurrentDecisionMakerId] = useState();
+  const { data: currentDecisionMaker } = useLegalEntity(currentDecisionMakerId ?? skipToken);
+  const associatedLegalRepresentative = useAssociatedLegalRepresentative(rootLegalEntity);
+  const [targetLegalEntityType, setTargetLegalEntityType] = useState();
+  const {
+    trustMember,
+    trustMemberId,
+    onNavigateToTrust,
+    onNavigateToTrustMemberRoleAndType,
+    onNavigateToTrustMemberEditDetails
+  } = useTrustMemberNavigation({
+    trust,
+    navigateTo
+  });
+  const {
+    onNavigateToMember,
+    activeMember: unincorporatedPartnershipMember,
+    setActiveMember
+  } = useUnincorporatedPartnershipNavigation({
+    navigateTo
+  });
+  const handleSingpassSelectionNextClick = async (method) => {
+    if (method === "singpass") {
+      try {
+        const authUrl = await handleInitiateSingpassMyInfoLogin();
+        if (!authUrl) {
+          throw new Error("OpenId authentication url not");
+        }
+        setHasSeenSingpassSelection(true);
+        singpassTabRef.current = window.open(authUrl, "_blank");
+        singpassTabRef.current?.focus();
+      } catch (e) {
+        logger.error(e);
+        if (typeof e === "string") handleSingpassMyInfoLoginFailure(e);
+      }
+    }
+    if (method === "manual") {
+      setHasSeenSingpassSelection(true);
+    }
+    navigateTo(TaskTypes.TASKS_OVERVIEW);
+  };
+  const onNavigateToDecisionMakerIndividual = async (task, id, parentId2) => {
+    setParentId(parentId2 ?? rootLegalEntity.id);
+    setCurrentDecisionMakerId(id);
+    navigateTo(task);
+  };
+  const onNavigateToPayinOrPayout = async (id, task = TaskTypes.PAYOUT) => {
+    if (id) {
+      try {
+        setCurrentTransferInstrumentId(id);
+      } finally {
+        navigateTo(task);
+      }
+    } else {
+      setCurrentTransferInstrumentId(void 0);
+      navigateTo(task);
+    }
+  };
+  const onNavigateToTask = async (task, id) => {
+    switch (task) {
+      case TaskTypes.PAYOUT:
+        await onNavigateToPayinOrPayout(id, TaskTypes.PAYOUT);
+        break;
+      case TaskTypes.PAYIN:
+        await onNavigateToPayinOrPayout(id, TaskTypes.PAYIN);
+        break;
+      case TaskTypes.TRUST: {
+        await onNavigateToTrust();
+        break;
+      }
+      case TaskTypes.TRUST_MEMBER_OVERVIEW: {
+        await onNavigateToTrust(TaskTypes.TRUST_MEMBER_OVERVIEW);
+        break;
+      }
+      case TaskTypes.SOLE_PROPRIETOR_COMPANY: {
+        await navigateTo(TaskTypes.SOLE_PROPRIETOR_COMPANY);
+        break;
+      }
+      default:
+        navigateTo(task);
+    }
+  };
+  const handleOnSubmit = async (data, backStepCount) => {
+    onSubmit?.(data);
+    await refetchLegalEntity();
+    navigateBack(backStepCount);
+  };
+  useEffect(() => {
+    userEvents.addJourneyEvent("Landed on page", { actionType: "start" });
+  }, []);
+  useEffect(() => {
+    userEvents.updateBaseTrackingPayload({ task: currentTask });
+  }, [currentTask]);
+  useEffect(() => {
+    if (hasRejectedCapabilities(rootLegalEntity)) {
+      navigateTo(TaskTypes.CAPABILITY_REJECTED, true);
+    }
+  }, [rootLegalEntity]);
+  useEffect(() => {
+    const newAccountHolder = getDefaultAccountHolderType(rootLegalEntity, false, accountHolder);
+    if (newAccountHolder !== accountHolder) setAccountHolder(newAccountHolder);
+  }, [accountHolder, rootLegalEntity]);
+  useEffect(() => setAccountHolderInGlobalStore(accountHolder), [accountHolder]);
+  const { rootLegalEntityId } = useApiContext();
+  rootLegalEntityId.value = rootLegalEntity.id;
+  useEffect(() => {
+    const enabledExperimentNames = Object.entries(experiments).filter(([key, value]) => key.includes("_") && value).map(([key]) => key);
+    if (!enabledExperimentNames.length) return;
+    enabledExperimentNames.forEach((experiment) => {
+      const [name, variant] = experiment.split("_");
+      userEvents.trackExperiment({ name, variant });
+    });
+  }, [experiments]);
+  const singpassBanner = isEligibleForSingpass ? /* @__PURE__ */ jsx(
+    SingpassBanner,
+    {
+      ...singpassLoginState,
+      onAlertClose: () => {
+        handleSingpassMyInfoLoginReset();
+      },
+      onClick: async () => {
+        try {
+          const authUrl = await handleInitiateSingpassMyInfoLogin();
+          singpassTabRef.current = window.open(authUrl);
+          singpassTabRef.current?.focus();
+        } catch (e) {
+          logger.error(e);
+          if (typeof e === "string") handleSingpassMyInfoLoginFailure(e);
+        }
+      },
+      onMessage: async ({ data: { isSuccessful } }) => {
+        if (isSuccessful) {
+          handleSingpassMyInfoLoginSuccess();
+          await refetchLegalEntity();
+          singpassTabRef.current?.close();
+        } else {
+          handleSingpassMyInfoLoginFailure(
+            legalEntityResponse.type === LegalEntityTypes.INDIVIDUAL ? "weCouldntConnectToMyinfo" : "weCouldntConnectToMyinfoBusiness"
+          );
+        }
+      },
+      legalEntityType: legalEntityResponse?.type
+    }
+  ) : void 0;
+  if (isLoadingConfiguration) {
+    return /* @__PURE__ */ jsx(Skeleton, {});
+  }
+  switch (currentTask) {
+    case TaskTypes.BUSINESS_TYPE_SELECTION:
+      return /* @__PURE__ */ jsx("div", { className: "adyen-kyc-u-display-flex adyen-kyc-u-justify-content-center", children: /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        BusinessTypeSelectionPage,
+        {
+          onComplete: async (newAccountHolder) => {
+            setAccountHolder(newAccountHolder);
+            setCanSeeEntitySelection(false);
+            await refetchLegalEntity();
+            navigateTo("default");
+          },
+          onBack: previousTask ? navigateBack : void 0
+        }
+      ) }) });
+    case TaskTypes.SINGPASS_SELECTION:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        SingpassSelection,
+        {
+          handleNextClick: handleSingpassSelectionNextClick,
+          accountHolder,
+          legalEntityType: rootLegalEntity.type
+        }
+      ) });
+    case TaskTypes.INTRODUCTION:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        Introduction,
+        {
+          onExitIntroduction: () => {
+            setHasSeenIntroduction(true);
+            navigateTo("default");
+          },
+          tasks: taskTypes
+        }
+      ) });
+    case TaskTypes.CAPABILITY_REJECTED:
+      return /* @__PURE__ */ jsxs(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: [
+        /* @__PURE__ */ jsx(AccountSetupRejected, {}),
+        ";"
+      ] });
+    case TaskTypes.TASKS_OVERVIEW:
+      return /* @__PURE__ */ jsx(TaskList, { onNavigateToTask, singpassComponent: singpassBanner });
+    case TaskTypes.DECISION_MAKER_OVERVIEW:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        DecisionMakers,
+        {
+          onNavigateToIndividual: (legalEntityId) => onNavigateToDecisionMakerIndividual(TaskTypes.DECISION_MAKER, legalEntityId),
+          navigateBackToTaskList: navigateBack,
+          trustedEntityAssociations
+        }
+      ) });
+    case TaskTypes.INDIVIDUAL:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        RootIndividualDetailsPage,
+        {
+          onSubmit: async (data) => {
+            onSubmit?.(data);
+            await refetchLegalEntity();
+            navigateTo(TaskTypes.TASKS_OVERVIEW);
+            setTargetLegalEntityType(void 0);
+          },
+          handleHomeClick: () => navigateTo(TaskTypes.TASKS_OVERVIEW),
+          isTargetLegalEntityType: targetLegalEntityType === LegalEntityTypes.INDIVIDUAL,
+          trustedFields: singpassTrustedFields,
+          trustedFieldsProvider: isEligibleForSingpass ? TrustedFieldsProviders.SINGPASS : void 0
+        }
+      ) });
+    case TaskTypes.CUSTOMER_SUPPORT:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        CustomerSupport,
+        {
+          country: rootLegalEntityCountry,
+          onSubmit: () => navigateTo(TaskTypes.TASKS_OVERVIEW)
+        }
+      ) });
+    case TaskTypes.REVIEW:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(Review, { handleHomeClick: () => navigateTo(TaskTypes.TASKS_OVERVIEW) }) });
+    case TaskTypes.DECISION_MAKER:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        DecisionMakerDetailsPage,
+        {
+          decisionMakerId: currentDecisionMaker?.id,
+          parentCompanyId: parentId,
+          onSubmit: async (data, scenario) => {
+            onSubmit?.(data);
+            await refetchLegalEntity();
+            if (isBafinSignatoryFlow({
+              taskType: TaskTypes.DECISION_MAKER,
+              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+              // @ts-ignore basicDetails will be there when it's IndividualOnfidoSchema
+              data,
+              scenarios: scenario
+            })) {
+              showIdNowModal.value = true;
+            } else {
+              navigateBack();
+            }
+          },
+          handleHomeClick: navigateBack,
+          trustedFields: singpassTrustedFields,
+          trustedFieldsProvider: isEligibleForSingpass ? TrustedFieldsProviders.SINGPASS : void 0,
+          trustedRoles: trustedEntityAssociations.find((ea) => ea.reference === currentDecisionMaker?.id)?.types || []
+        }
+      ) });
+    case TaskTypes.TRUST_MEMBER_COMPANY_OWNER:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        DecisionMakerDetailsPage,
+        {
+          taskType: TaskTypes.TRUST_MEMBER_COMPANY_OWNER,
+          parentCompanyId: parentId,
+          decisionMakerId: currentDecisionMakerId,
+          onSubmit: async (data) => {
+            await handleOnSubmit(data);
+            await refetchTrust();
+          },
+          handleHomeClick: navigateBack
+        }
+      ) });
+    case TaskTypes.TRUST_MEMBER_INDIVIDUAL:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        TrustMemberIndividualPage,
+        {
+          memberId: trustMemberId,
+          trustId: trust.id,
+          newMember: trustMember?.legalEntityId === isNewEntity ? trustMember : void 0,
+          onSubmit: async (data) => {
+            await handleOnSubmit(data, 2);
+            await refetchTrust();
+          },
+          handleBackClick: navigateBack,
+          handleHomeClick: () => navigateTo(TaskTypes.TRUST_MEMBER_OVERVIEW)
+        }
+      ) });
+    case TaskTypes.TRUST_MEMBER_COMPANY:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        TrustMemberCompanyPage,
+        {
+          trustId: trust.id,
+          trustMemberCompanyId: trustMemberId,
+          newMember: trustMember?.legalEntityId === isNewEntity ? trustMember : void 0,
+          onSubmit: async (data) => {
+            await handleOnSubmit(data, 2);
+            await refetchTrust();
+          },
+          handleHomeClick: navigateBack
+        }
+      ) });
+    case TaskTypes.BUSINESS_DETAILS:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        RootBusinessDetailsPage,
+        {
+          onSubmit: async (data) => {
+            onSubmit?.(data);
+            await refetchLegalEntity();
+            navigateTo(TaskTypes.TASKS_OVERVIEW);
+            setTargetLegalEntityType(void 0);
+          },
+          handleHomeClick: navigateBack,
+          isTargetLegalEntityType: targetLegalEntityType === LegalEntityTypes.ORGANIZATION
+        }
+      ) });
+    case TaskTypes.PAYOUT:
+    case TaskTypes.PAYIN:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        PayoutDetailsPage,
+        {
+          taskType: currentTask,
+          transferInstrumentId: currentTransferInstrumentId,
+          setTransferInstrumentId: setCurrentTransferInstrumentId,
+          handleHomeClick: navigateBack,
+          openBankingPartnerConfigId,
+          onSubmit: handleOnSubmit
+        }
+      ) });
+    case TaskTypes.TRUST:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        TrustDetailsPage,
+        {
+          taskType: TaskTypes.TRUST,
+          trustId: trust?.id,
+          onSubmit: (data) => handleOnSubmit(data, 1),
+          handleHomeClick: navigateBack
+        }
+      ) });
+    case TaskTypes.TRUST_MEMBER_OVERVIEW:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        TrustMembersOverview,
+        {
+          navigateBackToTaskList: navigateBack,
+          navigateToEditTrustMember: onNavigateToTrustMemberRoleAndType,
+          navigateToEditTrustMemberOwner: (trustMemberOwnerId, trustMemberId2) => onNavigateToDecisionMakerIndividual(
+            TaskTypes.TRUST_MEMBER_COMPANY_OWNER,
+            trustMemberOwnerId,
+            trustMemberId2
+          )
+        }
+      ) });
+    case TaskTypes.TRUST_MEMBER_ROLE_AND_TYPE:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        TrustMemberRoleAndTypePage,
+        {
+          trustId: trust.id,
+          memberId: trustMemberId,
+          navigateToFullDropinFor: onNavigateToTrustMemberEditDetails,
+          navigateBack: async () => {
+            await refetchTrust();
+            navigateBack();
+          }
+        }
+      ) });
+    case TaskTypes.UNINCORPORATED_PARTNERSHIP:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        TrustDetailsPage,
+        {
+          taskType: TaskTypes.UNINCORPORATED_PARTNERSHIP,
+          trustId: unincorporatedPartnership?.id,
+          onSubmit: (data) => handleOnSubmit(data, 1),
+          handleHomeClick: navigateBack
+        }
+      ) });
+    case TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_OVERVIEW:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        UnincorporatedPartnershipMembersOverview,
+        {
+          navigateBackToTaskList: navigateBack,
+          navigateToEditMember: (member) => onNavigateToMember({
+            selectedMember: member,
+            selectedEntityType: member?.legalEntityType,
+            selectedRoles: member?.roles,
+            roleAndType: true
+          }),
+          navigateToEditMemberOwner: (memberOwnerId, memberId) => {
+            setActiveMember({ legalEntityId: memberId });
+            onNavigateToDecisionMakerIndividual(
+              TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY_OWNER,
+              memberOwnerId,
+              memberId
+            );
+          }
+        }
+      ) });
+    case TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        UnincorporatedPartnershipMemberCompanyPage,
+        {
+          partnershipId: unincorporatedPartnership.id,
+          partnershipMemberCompanyId: unincorporatedPartnershipMember?.legalEntityId,
+          newMember: (
+            // empty string for legalEntityId means it's a new member
+            unincorporatedPartnershipMember?.legalEntityId === "" ? unincorporatedPartnershipMember : void 0
+          ),
+          onSubmit: (data) => handleOnSubmit(data, 2),
+          handleHomeClick: navigateBack
+        }
+      ) });
+    case TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY_OWNER:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        DecisionMakerDetailsPage,
+        {
+          taskType: TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY_OWNER,
+          parentCompanyId: unincorporatedPartnershipMember?.legalEntityId,
+          decisionMakerId: currentDecisionMakerId,
+          onSubmit: async (data) => {
+            await handleOnSubmit(data);
+            await refetchUnincorporatedPartnership();
+          },
+          handleHomeClick: navigateBack
+        }
+      ) });
+    case TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_INDIVIDUAL:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        UnincorporatedPartnershipIndividualPage,
+        {
+          memberId: unincorporatedPartnershipMember?.legalEntityId,
+          partnershipId: unincorporatedPartnership.id,
+          member: unincorporatedPartnershipMember,
+          onSubmit: (data) => {
+            handleOnSubmit(data, 2);
+            refetchUnincorporatedPartnership();
+          },
+          handleBackClick: navigateBack,
+          handleHomeClick: () => navigateTo(TaskTypes.TRUST_MEMBER_OVERVIEW)
+        }
+      ) });
+    case TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_ROLE_AND_TYPE:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        UnincorporatedPartnershipMemberRoleAndTypePage,
+        {
+          memberId: unincorporatedPartnershipMember?.legalEntityId,
+          onNavigateToMember,
+          navigateBack: async () => {
+            await refetchUnincorporatedPartnership();
+            navigateBack();
+          }
+        }
+      ) });
+    case TaskTypes.PCI_DSS:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(SignPCIComponent, { onClose: navigateBack }) });
+    case TaskTypes.SOLE_PROPRIETOR_COMPANY:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        SoleProprietorshipPage,
+        {
+          solePropId: soleProp?.id,
+          onSubmit: (data) => handleOnSubmit(data, 1),
+          handleHomeClick: navigateBack
+        }
+      ) });
+    case TaskTypes.SERVICE_AGREEMENT:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        AcceptTermsOfService,
+        {
+          legalEntityId: rootLegalEntity.id,
+          onClose: navigateBack,
+          asEmbedded: false,
+          handleAddSigner: () => {
+            onNavigateToDecisionMakerIndividual(TaskTypes.DECISION_MAKER);
+          }
+        }
+      ) });
+    case TaskTypes.LEGAL_REPRESENTATIVE_DETAILS:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        LegalRepresentativeDetailsPage,
+        {
+          legalRepresentativeId: associatedLegalRepresentative?.id,
+          onSubmit: handleOnSubmit,
+          handleHomeClick: navigateBack
+        }
+      ) });
+    case TaskTypes.SOURCE_OF_FUNDS:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        SourceOfFundsPage,
+        {
+          onSubmit: handleOnSubmit,
+          handleHomeClick: () => navigateTo(TaskTypes.TASKS_OVERVIEW)
+        }
+      ) });
+    case TaskTypes.BUSINESS_FINANCING:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(
+        BusinessFinancingPage,
+        {
+          onSubmit: async (data) => {
+            onSubmit?.(data);
+            await refetchLegalEntity();
+            navigateTo(TaskTypes.TASKS_OVERVIEW);
+          },
+          handleHomeClick: () => navigateTo(TaskTypes.TASKS_OVERVIEW)
+        }
+      ) });
+    case TaskTypes.TAX_REPORTING:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(TaxReportingDropin, { handleHomeClick: () => navigateTo(TaskTypes.TASKS_OVERVIEW) }) });
+    case TaskTypes.ACQUIRING_BUSINESS_LINE:
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(RootBusinessLinesPage, { handleHomeClick: () => navigateTo(TaskTypes.TASKS_OVERVIEW) }) });
+    default:
+      return null;
+  }
+}
+function OnboardingDropinComponent({
+  legalEntityId,
+  openBankingPartnerConfigId
+}) {
+  if (!legalEntityId) {
+    throw new Error("Must provide at-least legalEntityId");
+  }
+  const { i18n } = useTranslation();
+  addResourceBundles(i18n, i18n.language, [
+    {
+      ns: "common",
+      importFn: () => __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "../../../language/locales/bg-BG.json": () => import("./bg-BG-BPsOhDfg.js"), "../../../language/locales/cs-CZ.json": () => import("./cs-CZ-CHzJM-ii.js"), "../../../language/locales/da-DK.json": () => import("./da-DK-XNMYSp7w.js"), "../../../language/locales/de-DE.json": () => import("./de-DE-BI7AAdOv.js"), "../../../language/locales/el-GR.json": () => import("./el-GR-DoCIcce-.js"), "../../../language/locales/en-US.instructions.json": () => import("./en-US.instructions-Ddr7AO05.js"), "../../../language/locales/en-US.json": () => import("./StoreProvider-DadhkEyO.js").then((n) => n.bK), "../../../language/locales/es-ES.json": () => import("./es-ES-CnNU6AJv.js"), "../../../language/locales/et-EE.json": () => import("./et-EE-BR4OXRfV.js"), "../../../language/locales/fi-FI.json": () => import("./fi-FI-u5GxMZsq.js"), "../../../language/locales/fr-FR.json": () => import("./fr-FR-CMjrAkKl.js"), "../../../language/locales/hr-HR.json": () => import("./hr-HR-Bhsop3CT.js"), "../../../language/locales/hu-HU.json": () => import("./hu-HU-D2j1ISVk.js"), "../../../language/locales/it-IT.json": () => import("./it-IT-C7Sg1k4p.js"), "../../../language/locales/ja-JP.json": () => import("./ja-JP-GSbqID7o.js"), "../../../language/locales/lt-LT.json": () => import("./lt-LT-DSiutpRl.js"), "../../../language/locales/lv-LV.json": () => import("./lv-LV-C62XiDE5.js"), "../../../language/locales/nl-NL.json": () => import("./nl-NL-BOJ6zuBr.js"), "../../../language/locales/no-NO.json": () => import("./no-NO-CuwTDFSf.js"), "../../../language/locales/pl-PL.json": () => import("./pl-PL-1-MrLPXu.js"), "../../../language/locales/pt-BR.json": () => import("./pt-BR-Br_cHzGx.js"), "../../../language/locales/pt-PT.json": () => import("./pt-PT-cjbtYBUX.js"), "../../../language/locales/ro-RO.json": () => import("./ro-RO-CGhIjlpU.js"), "../../../language/locales/sk-SK.json": () => import("./sk-SK-Do6CKNU4.js"), "../../../language/locales/sl-SI.json": () => import("./sl-SI-cY-L2ma-.js"), "../../../language/locales/sv-SE.json": () => import("./sv-SE-BtwPrLEA.js") }), `../../../language/locales/${i18n.language}.json`, 6)
+    },
+    { ns: "ui", importFn: () => __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "../../ui/language/bg-BG.json": () => import("./bg-BG-Cs_1PU3v.js"), "../../ui/language/cs-CZ.json": () => import("./cs-CZ-B2WAqmaW.js"), "../../ui/language/da-DK.json": () => import("./da-DK-D-eeokQn.js"), "../../ui/language/de-DE.json": () => import("./de-DE-Dcs3W1fT.js"), "../../ui/language/el-GR.json": () => import("./el-GR-DBum-QDu.js"), "../../ui/language/en-US.json": () => import("./en-US-DdeSoN_2.js"), "../../ui/language/es-ES.json": () => import("./es-ES-C7XjLOHi.js"), "../../ui/language/et-EE.json": () => import("./et-EE-BUG05EDz.js"), "../../ui/language/fi-FI.json": () => import("./fi-FI-CEzjKgiz.js"), "../../ui/language/fr-FR.json": () => import("./fr-FR-DNJiLv9b.js"), "../../ui/language/hr-HR.json": () => import("./hr-HR-WMnlxMEY.js"), "../../ui/language/hu-HU.json": () => import("./hu-HU-B2nrl0pw.js"), "../../ui/language/it-IT.json": () => import("./it-IT-BRmX2jEi.js"), "../../ui/language/ja-JP.json": () => import("./ja-JP-gRRH8Eph.js"), "../../ui/language/lt-LT.json": () => import("./lt-LT-BJQDUanx.js"), "../../ui/language/lv-LV.json": () => import("./lv-LV-h3nTokkM.js"), "../../ui/language/nl-NL.json": () => import("./nl-NL-YzDSCWLL.js"), "../../ui/language/no-NO.json": () => import("./no-NO-Big2B13b.js"), "../../ui/language/pl-PL.json": () => import("./pl-PL-CL483jMb.js"), "../../ui/language/pt-BR.json": () => import("./pt-BR-DJOzf0y2.js"), "../../ui/language/pt-PT.json": () => import("./pt-PT-B3qoJ3Fr.js"), "../../ui/language/ro-RO.json": () => import("./ro-RO-Ct_BJvsc.js"), "../../ui/language/sk-SK.json": () => import("./sk-SK-FGK1FMMO.js"), "../../ui/language/sl-SI.json": () => import("./sl-SI-Cz28AFTz.js"), "../../ui/language/sv-SE.json": () => import("./sv-SE-DLl7OGxl.js") }), `../../ui/language/${i18n.language}.json`, 5) }
+  ]);
+  const { data: legalEntityData } = useLegalEntity(ROOT_LE);
+  return !legalEntityData ? /* @__PURE__ */ jsx(Loader, {}) : /* @__PURE__ */ jsx(
+    DropinComposer,
+    {
+      legalEntityResponse: legalEntityData,
+      openBankingPartnerConfigId
+    }
+  );
+}
+export {
+  DropinLayout as D,
+  EntityGuidanceStatus as E,
+  LEGAL_COMPANY_NAME_FIELD as L,
+  OnboardingDropinComponent as O,
+  usePciStatus as a,
+  useCanSeeIntroduction as b,
+  useLegalEntityType as c,
+  allowIndividualWithoutSoleProp as d,
+  useDataMissingRemediations as e,
+  EntityAssociation as f,
+  defaultFieldMetadataV4 as g,
+  defaultFieldMetadata as h,
+  iconStatus as i,
+  defaultFieldConfigV4 as j,
+  defaultFieldConfig as k,
+  useBusinessLines as l,
+  useTrustMembers as m,
+  normalizedTaskStatusStore as n,
+  useSalesChannelsSettings as u
+};