@adyen/kyc-components 3.91.0 → 3.92.0

package/dist/OnboardingDropinComponent-DwKImil4.js

@@ -0,0 +1,2306 @@
+;
+{
+  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] = "8c61f19c-a17e-4ccf-8e10-dc882c7d3325", e._sentryDebugIdIdentifier = "sentry-dbid-8c61f19c-a17e-4ccf-8e10-dc882c7d3325");
+  } catch (e) {
+  }
+}
+;
+import { b as useApiContext, j as useQuery, k as httpPost, m as httpGet, o as useSettingsContext, p as useLocalStorage, g as getLegalEntityCountry, C as CountryCodes, q as isPartOfTrustFromLegalEntity, r as LegalEntityTypes, t as hasSolePropInLegalEntity, v as getLegalRepresentative, c as useLegalEntity, w as skipToken, x as doesLegalEntityRequiresLegalRepresentative, u as useTranslation, B as Button, y as Skeleton, z as translateStringOrObject, G as Typography, H as createLogger, J as TaskStatuses, K as hasOwnEntityAssociationOfType, M as isEmptyEntity, N as useAccountHolder, O as EntityTypes, P as DATA_MISSING_DECISION_MAKER_ERROR_CODE_MAPPING, U as TaskTypes, V as useAnalyticsContext, W as Icon, X as IconButton, Y as noop, Z as useExperimentsContext, $ as isInstantVerifiedAccount, a0 as getObscuredAccountNumber, a1 as useGetTaskStatus, R as ROOT_LE, L as Loader, a2 as useGlobalStore, a3 as isPartOfUnincorporatedPartnership, a4 as getOwnSignatories, a5 as getOwnDecisionMakersLegalEntityIds, a6 as getOwnSolePropProblems, a7 as getOwnTrustProblems, a8 as getOwnUnincorporatedPartnershipProblems, a9 as getOwnEntityAssociations, aa as TrustMemberTypes, ab as hasAllCapabilitiesResolved, ac as hasRejectedCapabilities, ad as objectsDeepEqual, a as addResourceBundles, _ as __variableDynamicImportRuntimeHelper } from "./StoreProvider-D9IR5HNN.js";
+import { jsx, jsxs, Fragment } from "preact/jsx-runtime";
+import { lazy, Suspense } from "preact/compat";
+import { useMemo, useReducer, useCallback, useEffect, useState, useRef } from "preact/hooks";
+import { S as SettingNames, T as TaskVerificationStatus } from "./TaskVerificationStatus-BLCkXEn6.js";
+import { T as TrustedFieldsProviders, I as Image, u as useCapabilityProblems } from "./Image-Cvb4hnru.js";
+import { g as getTrustedFieldsProvider, C as CompanyTypesValues, h as handleKeys, u as useSetting, i as isBafinSignatoryFlow, s as showIdNowModal } from "./bafinUtils-Wct4TWLH.js";
+import { u as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-ahBb64MW.js";
+import cx from "classnames";
+import { a as Alert } from "./Alert-TCEgDc2-.js";
+import { signal } from "@preact/signals";
+import { u as useTermsOfServiceStatus, a as useTermsOfServiceAcceptanceInfos } from "./useTermsOfServiceStatus-BnO0rXiL.js";
+import { u as useToastContext } from "./useToastContext-D6Lbxqj9.js";
+import { S as StackLayout, U as UnincorporatedPartnershipMemberTypes } from "./unincorporated-partnership-MeN1dp53.js";
+import { C as Card } from "./Card-Det7uTiv.js";
+import { d as downloadFile } from "./file-CiG1D0zy.js";
+import { V as VerificationErrorAlert, u as useDeleteTransferInstrument } from "./VerificationErrorAlert-DZ5OOTBN.js";
+import { A as Avatar } from "./Avatar-AC-D1DKh.js";
+import { L as LoaderWrapper } from "./LoaderWrapper-CUz5NRFr.js";
+import { C as Confirm } from "./Confirm-Ctfqp-1b.js";
+import { g as getLegalEntityNameBasedOnType } from "./getName-CzpJ9tV7.js";
+const getPciStatus = async (legalEntityId, baseUrl, data) => {
+  const filteredData = {
+    ...data,
+    additionalSalesChannels: data.additionalSalesChannels?.filter(
+      (channel) => channel !== "payByLink"
+    )
+  };
+  return httpPost(
+    {
+      baseUrl,
+      path: `legalEntities/${legalEntityId}/pci/signingRequired`
+    },
+    filteredData
+  );
+};
+const usePciStatus = (data, options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useQuery({
+    queryKey: ["pciStatus", data],
+    queryFn: () => getPciStatus(rootLegalEntityId.value, baseUrl.value, data),
+    staleTime: 0,
+    ...options
+  });
+};
+const getBusinessLines = async (legalEntityId, baseUrl) => {
+  return httpGet({
+    baseUrl,
+    path: `legalEntities/${legalEntityId}/businessLines`
+  });
+};
+const useBusinessLines = (businessLineType, options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useQuery({
+    queryKey: ["businessLines"],
+    queryFn: () => getBusinessLines(rootLegalEntityId.value, baseUrl.value),
+    select: (businessLines) => businessLines.filter((businessLine) => businessLineType.includes(businessLine.service)),
+    ...options
+  });
+};
+function useSalesChannels() {
+  const { isSettingEnabled } = useSettingsContext();
+  const { data: existingBusinessLines } = useBusinessLines(["paymentProcessing"]);
+  return useMemo(() => {
+    const settings = [];
+    const businessLinesSalesChannels = [
+      ...new Set(existingBusinessLines?.flatMap((item) => item.salesChannels ?? []))
+    ];
+    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 isSettingEnabled("allowBusinessLines") ? businessLinesSalesChannels : settings;
+  }, [existingBusinessLines, 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 };
+};
+async function convertToSingpassLinkResponse(openIdInitiateResponse) {
+  const response = await Promise.resolve(openIdInitiateResponse);
+  const item = { authUrl: response.authUrl, success: true };
+  return { item };
+}
+const useOpenIdAuthorizationLink = (options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useQuery({
+    queryKey: ["openIdAuthorizationLink"],
+    queryFn: () => getOpenIdAuthorizationLink(rootLegalEntityId.value, baseUrl.value),
+    ...options
+  });
+};
+const getOpenIdAuthorizationLink = async (legalEntityId, baseUrl) => {
+  return convertToSingpassLinkResponse(
+    httpPost({
+      baseUrl,
+      path: `/legalEntities/${legalEntityId}/openid/initiate`
+    })
+  );
+};
+const SingpassMyInfoLoginActionTypes = {
+  LOADING: "LOADING",
+  SUCCESS: "SUCCESS",
+  FAILURE: "FAILURE",
+  RESET: "RESET"
+};
+const defaultSingpassState = { isLoading: false, isSuccess: false };
+const singpassReducer = (state, action) => {
+  switch (action.type) {
+    case SingpassMyInfoLoginActionTypes.LOADING:
+      return { ...state, isLoading: true };
+    case SingpassMyInfoLoginActionTypes.SUCCESS:
+      return { isLoading: false, isSuccess: true };
+    case SingpassMyInfoLoginActionTypes.FAILURE:
+      return { isLoading: false, isSuccess: false, errorMessage: action.errorMessage };
+    case SingpassMyInfoLoginActionTypes.RESET:
+      return defaultSingpassState;
+    default:
+      return state;
+  }
+};
+const useSingpassMyInfoLogin = ({
+  legalEntity,
+  accountHolder
+}) => {
+  const existingProvider = getTrustedFieldsProvider(legalEntity);
+  const defaultState = {
+    isLoading: false,
+    isSuccess: existingProvider === TrustedFieldsProviders.SINGPASS
+  };
+  const [state, dispatch] = useReducer(
+    singpassReducer,
+    defaultState
+  );
+  const { refetch: fetchOpenIdAuthorizationLink } = useOpenIdAuthorizationLink({ enabled: false });
+  const isEligibleForSingpass = useMemo(() => {
+    if (!legalEntity) {
+      return false;
+    }
+    if (getLegalEntityCountry(legalEntity) !== CountryCodes.Singapore) {
+      return false;
+    }
+    if (accountHolder) {
+      return accountHolder === "theCompanyIWorkFor" || accountHolder === "myName";
+    }
+    const legalEntityType = legalEntity.type;
+    const isPartOfTrust = isPartOfTrustFromLegalEntity(legalEntity);
+    const isVanillaOrganization = legalEntityType === LegalEntityTypes.ORGANIZATION && !isPartOfTrust;
+    const hasSoleProprietor = hasSolePropInLegalEntity(legalEntity);
+    const isVanillaIndividual = legalEntityType === LegalEntityTypes.INDIVIDUAL && !hasSoleProprietor;
+    return isVanillaOrganization || isVanillaIndividual;
+  }, [legalEntity, accountHolder]);
+  const handleInitiateSingpassMyInfoLogin = async () => {
+    dispatch({ ...state, type: SingpassMyInfoLoginActionTypes.LOADING });
+    const { data } = await fetchOpenIdAuthorizationLink();
+    return data?.item.authUrl;
+  };
+  const handleSingpassMyInfoLoginSuccess = () => {
+    dispatch({ ...state, type: SingpassMyInfoLoginActionTypes.SUCCESS });
+  };
+  const handleSingpassMyInfoLoginFailure = (errorMessage) => {
+    dispatch({ ...state, errorMessage, type: SingpassMyInfoLoginActionTypes.FAILURE });
+  };
+  const handleSingpassMyInfoLoginReset = () => {
+    dispatch({ ...state, type: SingpassMyInfoLoginActionTypes.RESET });
+  };
+  return {
+    isEligibleForSingpass,
+    state,
+    handleInitiateSingpassMyInfoLogin,
+    handleSingpassMyInfoLoginSuccess,
+    handleSingpassMyInfoLoginFailure,
+    handleSingpassMyInfoLoginReset
+  };
+};
+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 = {
+  providerButton,
+  providerButtonDisplayName
+};
+const singpassLogo = lazy(
+  () => import("./singpass-logo-wY4xsmTX.js")
+);
+const ProviderButton = ({ provider, onClick }) => {
+  const { t } = useTranslation("ui");
+  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.providerButton, children: [
+    buttonLabel[provider],
+    /* @__PURE__ */ jsx("span", { className: styles.providerButtonDisplayName, children: providerDisplayName[provider] }),
+    /* @__PURE__ */ jsx(Image, { lazyLoadedImage: singpassLogo })
+  ] }) });
+};
+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, rootLegalEntityId } = useApiContext();
+  const singpassEventListener = useCallback(
+    (event) => {
+      if (event.origin !== new URL(baseUrl.value).origin) return;
+      if (event.data.legalEntityReference !== rootLegalEntityId.value) return;
+      onMessage({ data: { isSuccessful: event.data.isSuccessful } });
+    },
+    [baseUrl.value, rootLegalEntityId.value, onMessage]
+  );
+  useEffect(() => {
+    window.addEventListener("message", singpassEventListener);
+    return () => window.removeEventListener("message", singpassEventListener);
+  }, [singpassEventListener]);
+  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 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 logger$1 = 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$1.warn(`No task status for this account: ${accountId}`);
+    return payinPayoutTaskStatus?.status ?? TaskStatuses.PROCESSING;
+  }
+  return TaskStatuses[taskStatusEntry.status];
+};
+const normalizedTaskStatusStore = signal(void 0);
+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),
+    select: (data) => normalizeTaskStatuses(data),
+    ...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 (!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 (accountHolder) {
+    return accountHolder;
+  }
+  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 filterProblemsByTaskForms = (entityProblems, forms) => {
+  if (!entityProblems?.verificationErrors) return entityProblems;
+  const filteredEntityProblems = Object.entries(entityProblems.verificationErrors).reduce(
+    (acc, [formId, verificationErrors]) => {
+      if (!forms.includes(formId)) return acc;
+      return {
+        ...entityProblems,
+        verificationErrors: {
+          ...acc.verificationErrors,
+          [formId]: verificationErrors
+        }
+      };
+    },
+    {}
+  );
+  filteredEntityProblems.verificationErrors = Object.keys(filteredEntityProblems.verificationErrors ?? {}).length > 0 ? filteredEntityProblems.verificationErrors : void 0;
+  return filteredEntityProblems;
+};
+const businessFormIds = [
+  "basicInformation",
+  "businessSelection",
+  "companyStructure",
+  "additionalInformation",
+  "companyRegistrationDocument",
+  "companyTaxDocument",
+  "companyProofOfDirectorDocument",
+  "companyProofOfSignatoryDocument",
+  "companyProofOfOwnershipDocument",
+  "companyFinancialInformation",
+  "companyConstitutionalDocument"
+];
+const individualFormIds = [
+  "personalDetails",
+  "address",
+  "idVerificationMethod",
+  "idDocument",
+  "proofOfResidency",
+  "proofOfNationalId",
+  "proofOfRelationship"
+];
+const individualOnfidoFormIds = [
+  "signatoryQuestionnaire",
+  "uboQuestionnaire",
+  "basicDetails",
+  "idVerificationMethod",
+  "additionalPersonalDetails",
+  "manualIdUpload",
+  "proofOfResidency",
+  "proofOfNationalId",
+  "proofOfRelationship"
+];
+const TaskListItem = ({
+  titleKey,
+  title,
+  icon,
+  status,
+  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 isDownloadable = !!downloadHandler && status === TaskStatuses.DOWNLOAD;
+  const shouldShowErrorAlert = showErrorAlerts === "always" || showErrorAlerts === "onErrorStatus" && status === TaskStatuses.ERROR || !!problems?.verificationErrors;
+  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);
+  };
+  const getTaskAccessory = () => {
+    switch (status) {
+      case TaskStatuses.SIGN:
+        return t(($) => $["sign"]);
+      case TaskStatuses.DETAILS_REQUIRED:
+      case TaskStatuses.EMPTY:
+        return t(($) => $["add"]);
+      default:
+        return /* @__PURE__ */ jsx(TaskVerificationStatus, { status });
+    }
+  };
+  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: [
+                  getTaskAccessory(),
+                  isDownloadable && /* @__PURE__ */ jsx(
+                    IconButton,
+                    {
+                      ariaLabel: t(($) => $["download"]),
+                      icon: "download",
+                      onClick: downloadHandler,
+                      variant: "tertiary"
+                    }
+                  ),
+                  isDeletable && /* @__PURE__ */ jsx(
+                    IconButton,
+                    {
+                      ariaLabel: t(($) => $["delete"]),
+                      icon: "bin",
+                      variant: "tertiary",
+                      onClick: handleRemoveIntent,
+                      disabled: isConfirmShown
+                    }
+                  ),
+                  !isDownloadable && !isDeletable && /* @__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([
+    "paymentProcessing"
+  ]);
+  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 = useSalesChannels();
+  const { remediationMessages } = useDataMissingRemediations({
+    legalEntityId: legalEntityResponse.id,
+    problems: capabilityProblems
+  });
+  const { data: pciStatus } = usePciStatus({ additionalSalesChannels });
+  const { data: pciQuestionnaireList } = usePciQuestionnaireList();
+  const { data: termsOfServiceStatus } = useTermsOfServiceStatus();
+  const { data: termsOfServiceStatusAcceptanceInfos } = useTermsOfServiceAcceptanceInfos();
+  const { data: normalizedTasks } = 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 showCustomerSupportV4 = isExperimentEnabled("ShowCustomerSupportV4");
+  const transferInstrumentLimit = useSetting("transferInstrumentLimit");
+  const payinPayoutTaskStatus = normalizedTasks?.PAYOUT ?? normalizedTasks?.PAYIN;
+  const businessDetailsTaskStatus = normalizedTasks?.BUSINESS_DETAILS?.status ?? TaskStatuses.DETAILS_REQUIRED;
+  const businessLinesTaskStatus = normalizedTasks?.ACQUIRING_BUSINESS_LINE?.status ?? TaskStatuses.DETAILS_REQUIRED;
+  const rootLegalEntityProblems = capabilityProblems?.LegalEntity?.[legalEntityResponse.id];
+  const isReview = Boolean(rootLegalEntityProblems?.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 canDownloadPci = !pciStatus?.signingRequired && pciHasDocuments;
+  const hasCreatedBusinessLines = !!existingBusinessLines?.length;
+  const hasPciSigners = !!legalEntityResponse?.entityAssociations?.length;
+  const pciIsActionable = pciStatus?.signingRequired || canDownloadPci;
+  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 = isSettingEnabled("allowBusinessLines") ? tasks.includes("PCI_DSS") : tasks.includes("PCI_DSS") && pciIsActionable;
+  const shouldSignPciFirst = showServiceAgreementTask && showPciTask && !pciHasDocuments;
+  const pciTaskState = (() => {
+    if (!hasPciSigners) {
+      return { disabled: true, infoMessage: t(($) => $["requiresDecisionMakers"]) };
+    }
+    if (isSettingEnabled("allowBusinessLines") && !hasCreatedBusinessLines) {
+      return { disabled: true, infoMessage: t(($) => $["requiresBusinessLine"]) };
+    }
+    return { disabled: !pciStatus?.signingRequired, infoMessage: void 0 };
+  })();
+  const serviceAgreementTaskState = (() => {
+    if (isSettingEnabled("allowBusinessLines") && shouldSignPciFirst) {
+      return { disabled: true, infoMessage: t(($) => $["signPciFirst"]) };
+    }
+    if (!hasServiceAgreementSigners) {
+      return { disabled: true, infoMessage: t(($) => $["requiresSignatory"]) };
+    }
+    return { disabled: false, infoMessage: void 0 };
+  })();
+  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 fullIndividualFormIds = [...individualFormIds, ...individualOnfidoFormIds];
+  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: filterProblemsByTaskForms(rootLegalEntityProblems, fullIndividualFormIds)
+          }
+        ),
+        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: filterProblemsByTaskForms(rootLegalEntityProblems, businessFormIds)
+          }
+        ),
+        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,
+            problems: filterProblemsByTaskForms(rootLegalEntityProblems, ["customerSupport"])
+          }
+        )
+      ] }),
+      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()
+            }
+          )
+        }
+      ),
+      hasContractTasks && /* @__PURE__ */ jsxs(TaskListGroup, { title: t(($) => $["reviewAndSignLegalDisclosures"]), children: [
+        showPciTask && /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            onNavigateToTask: handleOnNavigateToPci,
+            icon: "pci",
+            titleKey: "pciDssQuestionnaire",
+            status: canDownloadPci ? TaskStatuses.DOWNLOAD : TaskStatuses.SIGN,
+            info: pciTaskState.infoMessage,
+            downloadHandler: onPciDownload,
+            disabled: pciTaskState.disabled
+          }
+        ),
+        showServiceAgreementTask && /* @__PURE__ */ jsx(
+          TaskListItem,
+          {
+            onNavigateToTask: handleOnNavigateToServiceAgreement,
+            icon: "contract",
+            titleKey: "signServiceAgreement",
+            disabled: serviceAgreementTaskState.disabled,
+            status: serviceAgreementTypes.length ? TaskStatuses.SIGN : TaskStatuses.SIGNED,
+            info: serviceAgreementTaskState.infoMessage
+          }
+        )
+      ] }),
+      isReview && /* @__PURE__ */ jsx(TaskListGroup, { title: t(($) => $["pleaseEnsureTheFollowing"]), children: /* @__PURE__ */ jsx(
+        TaskListItem,
+        {
+          onNavigateToTask: handleOnNavigateToTaskReview,
+          icon: "review",
+          titleKey: "submitReviewOfYourData",
+          status: TaskStatuses.SUBMIT,
+          problems: rootLegalEntityProblems,
+          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 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 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-DOxSVZ6X.js")).Introduction
+);
+const BusinessTypeSelectionPage = lazy(
+  async () => (await import("./BusinessTypeSelectionPage-6Ltt53Mu.js")).BusinessTypeSelectionPage
+);
+const SingpassSelection = lazy(
+  async () => (await import("./SingpassSelection-eruroIiQ.js")).SingpassSelection
+);
+const AccountSetupRejected = lazy(
+  async () => (await import("./AccountSetupRejected-LAVhMMBt.js")).AccountSetupRejected
+);
+const DecisionMakers = lazy(
+  async () => (await import("./DecisionMakers-B4qQ3M6Y.js")).DecisionMakers
+);
+const CustomerSupport = lazy(
+  async () => (await import("./CustomerSupport-DLfbNC-J.js")).CustomerSupport
+);
+const Review = lazy(async () => (await import("./Review-gkTjl3a8.js")).Review);
+const SignPCIComponent = lazy(
+  async () => (await import("./SignPCIComponent-DqElmjjG.js")).SignPCIComponent
+);
+const AcceptTermsOfService = lazy(
+  async () => (await import("./AcceptTermsOfServiceComponent-T7eWi57Z.js")).AcceptTermsOfServiceComponent
+);
+const TaxReportingDropin = lazy(
+  async () => (await import("./TaxReportingDropin-ajO0q4eZ.js")).TaxReportingDropin
+);
+const PayoutDetailsPage = lazy(
+  async () => (await import("./PayoutDetailsDropin-lYVb5WCQ.js").then((n) => n.a)).PayoutDetailsPage
+);
+const RootBusinessDetailsPage = lazy(
+  async () => (await import("./RootBusinessDetailsPage-DjwEzuLA.js")).RootBusinessDetailsPage
+);
+const RootBusinessLinesPage = lazy(
+  async () => (await import("./RootBusinessLinesPage-2-U3mf6i.js")).RootBusinessLinesPage
+);
+const SoleProprietorshipPage = lazy(
+  async () => (await import("./SoleProprietorshipPage-7YdzA7iH.js")).SoleProprietorshipPage
+);
+const TrustMemberCompanyPage = lazy(
+  async () => (await import("./TrustMemberCompanyPage-CJj2BpXu.js")).TrustMemberCompanyPage
+);
+const TrustMemberIndividualPage = lazy(
+  async () => (await import("./TrustMemberIndividualPage-BXp9RXDw.js")).TrustMemberIndividualPage
+);
+const TrustMemberRoleAndTypePage = lazy(
+  async () => (await import("./TrustMemberRoleAndTypePage-gYJ5U6RH.js")).TrustMemberRoleAndTypePage
+);
+const TrustMembersOverview = lazy(
+  async () => (await import("./TrustMembersOverview-Chmnt5jS.js")).TrustMembersOverview
+);
+const UnincorporatedPartnershipMemberCompanyPage = lazy(
+  async () => (await import("./UnincorporatedPartnershipMemberCompanyPage-Bx0A5Bit.js")).UnincorporatedPartnershipMemberCompanyPage
+);
+const UnincorporatedPartnershipIndividualPage = lazy(
+  async () => (await import("./UnincorporatedPartnershipIndividualPage-DckUiPPY.js")).UnincorporatedPartnershipIndividualPage
+);
+const UnincorporatedPartnershipMemberRoleAndTypePage = lazy(
+  async () => (await import("./UnincorporatedPartnershipMemberRoleAndTypePage-CEE1hzIn.js")).UnincorporatedPartnershipMemberRoleAndTypePage
+);
+const UnincorporatedPartnershipMembersOverview = lazy(
+  async () => (await import("./UnincorporatedPartnershipMembersOverview-wB8K9r6g.js")).UnincorporatedPartnershipMembersOverview
+);
+const BusinessFinancingPage = lazy(
+  async () => (await import("./BusinessFinancingPage-DtX8x3Zp.js")).BusinessFinancingPage
+);
+const TrustDetailsPage = lazy(
+  async () => (await import("./TrustDetailsPage-BWXZX4-u.js")).TrustDetailsPage
+);
+const SourceOfFundsPage = lazy(
+  async () => (await import("./SourceOfFundsPage-C_wiSoc4.js")).SourceOfFundsPage
+);
+const RootIndividualDetailsPage = lazy(
+  async () => (await import("./RootIndividualDetailsPage-BFYP63_i.js")).RootIndividualDetailsPage
+);
+const LegalRepresentativeDetailsPage = lazy(
+  async () => (await import("./LegalRepresentativeDetailsPage-DOP3L2r9.js")).LegalRepresentativeDetailsPage
+);
+const DecisionMakerDetailsPage = lazy(
+  async () => (await import("./DecisionMakerDetailsPage-BTR-hRwO.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
+  } = 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
+        }
+      ) });
+    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
+        }
+      ) });
+    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
+        }
+      ) });
+    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: () => {
+            userEvents.addPageEvent("Clicked button", {
+              actionType: "back",
+              label: "back"
+            });
+            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, [
+    { ns: "common", importFn: (lang) => __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "../../../language/locales/bg-BG.json": () => import("./bg-BG-DVjwfSz4.js"), "../../../language/locales/cs-CZ.json": () => import("./cs-CZ-CLY9qYTs.js"), "../../../language/locales/da-DK.json": () => import("./da-DK-uHPPFvD-.js"), "../../../language/locales/de-DE.json": () => import("./de-DE-SMf6w4NJ.js"), "../../../language/locales/el-GR.json": () => import("./el-GR-wv99Y9Yf.js"), "../../../language/locales/en-US.instructions.json": () => import("./en-US.instructions-Ddr7AO05.js"), "../../../language/locales/en-US.json": () => import("./StoreProvider-D9IR5HNN.js").then((n) => n.bN), "../../../language/locales/es-ES.json": () => import("./es-ES-BqpvBqmR.js"), "../../../language/locales/et-EE.json": () => import("./et-EE-CAuCY0qn.js"), "../../../language/locales/fi-FI.json": () => import("./fi-FI-DPegZzTc.js"), "../../../language/locales/fr-FR.json": () => import("./fr-FR-BPGwsLDa.js"), "../../../language/locales/hr-HR.json": () => import("./hr-HR-DdqNL1pQ.js"), "../../../language/locales/hu-HU.json": () => import("./hu-HU-C1LJENXO.js"), "../../../language/locales/it-IT.json": () => import("./it-IT-B1eJg9RL.js"), "../../../language/locales/ja-JP.json": () => import("./ja-JP-PnqAHl14.js"), "../../../language/locales/lt-LT.json": () => import("./lt-LT-BmRnIfWs.js"), "../../../language/locales/lv-LV.json": () => import("./lv-LV-CX9j9Dtv.js"), "../../../language/locales/nl-NL.json": () => import("./nl-NL-cVVIDG7s.js"), "../../../language/locales/no-NO.json": () => import("./no-NO-C_tmZ39d.js"), "../../../language/locales/pl-PL.json": () => import("./pl-PL-DFZFSKZX.js"), "../../../language/locales/pt-BR.json": () => import("./pt-BR-CMiGlY3k.js"), "../../../language/locales/pt-PT.json": () => import("./pt-PT-DmdQxN_1.js"), "../../../language/locales/ro-RO.json": () => import("./ro-RO-B0slmyWK.js"), "../../../language/locales/sk-SK.json": () => import("./sk-SK-BptPuon4.js"), "../../../language/locales/sl-SI.json": () => import("./sl-SI-C3nGkfNb.js"), "../../../language/locales/sv-SE.json": () => import("./sv-SE-CXn28ybc.js") }), `../../../language/locales/${lang}.json`, 6) },
+    { ns: "ui", importFn: (lang) => __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "../../ui/language/bg-BG.json": () => import("./bg-BG-CCwKQVVV.js"), "../../ui/language/cs-CZ.json": () => import("./cs-CZ-CVvNUABW.js"), "../../ui/language/da-DK.json": () => import("./da-DK-CoTdzXlA.js"), "../../ui/language/de-DE.json": () => import("./de-DE-z0cPgxGN.js"), "../../ui/language/el-GR.json": () => import("./el-GR-B9TRk3Pi.js"), "../../ui/language/en-US.json": () => import("./en-US-CjjPhkB5.js"), "../../ui/language/es-ES.json": () => import("./es-ES-DUn82eVS.js"), "../../ui/language/et-EE.json": () => import("./et-EE-CUXar-DY.js"), "../../ui/language/fi-FI.json": () => import("./fi-FI-C3TTCFBv.js"), "../../ui/language/fr-FR.json": () => import("./fr-FR-BbKadiaZ.js"), "../../ui/language/hr-HR.json": () => import("./hr-HR-D2LmWe5I.js"), "../../ui/language/hu-HU.json": () => import("./hu-HU-CFuBc8VP.js"), "../../ui/language/it-IT.json": () => import("./it-IT-CGhQqmiU.js"), "../../ui/language/ja-JP.json": () => import("./ja-JP-CvREJ56h.js"), "../../ui/language/lt-LT.json": () => import("./lt-LT-CZwu5zZ0.js"), "../../ui/language/lv-LV.json": () => import("./lv-LV-DVFCj1OR.js"), "../../ui/language/nl-NL.json": () => import("./nl-NL-OHlJx2bn.js"), "../../ui/language/no-NO.json": () => import("./no-NO-DEYydng4.js"), "../../ui/language/pl-PL.json": () => import("./pl-PL-DMbe5XnW.js"), "../../ui/language/pt-BR.json": () => import("./pt-BR-DWAziFjb.js"), "../../ui/language/pt-PT.json": () => import("./pt-PT-LP8g5mC9.js"), "../../ui/language/ro-RO.json": () => import("./ro-RO-BQSoJrlf.js"), "../../ui/language/sk-SK.json": () => import("./sk-SK-CwieqNyR.js"), "../../ui/language/sl-SI.json": () => import("./sl-SI-C5vfq7vv.js"), "../../ui/language/sv-SE.json": () => import("./sv-SE-BrO9NKWs.js") }), `../../ui/language/${lang}.json`, 5) }
+  ]);
+  const { data: legalEntityData } = useLegalEntity(ROOT_LE);
+  return !legalEntityData ? /* @__PURE__ */ jsx(Loader, {}) : /* @__PURE__ */ jsx(
+    DropinComposer,
+    {
+      legalEntityResponse: legalEntityData,
+      openBankingPartnerConfigId
+    }
+  );
+}
+export {
+  OnboardingDropinComponent as O,
+  TASK_STATUS_POLLING_INTERVAL_MS as T,
+  usePciStatus as a,
+  useCanSeeIntroduction as b,
+  useLegalEntityType as c,
+  allowIndividualWithoutSoleProp as d,
+  useDataMissingRemediations as e,
+  filterProblemsByTaskForms as f,
+  useBusinessLines as g,
+  useTaskStatus as h,
+  usePciQuestionnaireList as i,
+  useTrustMembers as j,
+  isNewEntity as k,
+  normalizedTaskStatusStore as n,
+  useSalesChannels as u
+};