@adyen/kyc-components 4.0.0 → 4.2.0-beta.0

package/dist/useTrustMembers-BvFhj1PW.js

@@ -0,0 +1,163 @@
+;
+{
+  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] = "bd29e08f-228a-4ec0-98b2-43dbbd0e05f5", e._sentryDebugIdIdentifier = "sentry-dbid-bd29e08f-228a-4ec0-98b2-43dbbd0e05f5");
+  } catch (e) {
+  }
+}
+;
+import { useMemo } from "preact/hooks";
+import { ae as getOwnEntityAssociations, bo as TrustMemberTypes, c as useLegalEntity, o as LegalEntityTypes, R as ROOT_LE, v as useExperimentsContext } from "./StoreProvider-qjyWZhxu.js";
+import { u as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-jaSfQ9rQ.js";
+import { skipToken } from "@tanstack/preact-query";
+import { g as getLegalEntityNameBasedOnType } from "./getName-BIUEu4TI.js";
+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]);
+}
+export {
+  useTrustMembers as u
+};

package/dist/useUnincorporatedPartnershipMembers-wCGUg18Y.js

@@ -0,0 +1,99 @@
+;
+{
+  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] = "1ba0f3b2-a9c6-4094-8f78-ecf8d2a0042b", e._sentryDebugIdIdentifier = "sentry-dbid-1ba0f3b2-a9c6-4094-8f78-ecf8d2a0042b");
+  } catch (e) {
+  }
+}
+;
+import { useMemo } from "preact/hooks";
+import { o as LegalEntityTypes, ae as getOwnEntityAssociations, c as useLegalEntity, R as ROOT_LE } from "./StoreProvider-qjyWZhxu.js";
+import { u as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-jaSfQ9rQ.js";
+import { U as UnincorporatedPartnershipMemberTypes } from "./unincorporated-partnership-MeN1dp53.js";
+import { g as getLegalEntityNameBasedOnType } from "./getName-BIUEu4TI.js";
+const getMemberOwnerId = (memberId, entityAssociations) => entityAssociations.find((association) => association.associatorId === memberId)?.legalEntityId;
+const convertEntityAssociationIntoUnincorporatedPartnershipMember = (association) => {
+  if (association.entityType === LegalEntityTypes.INDIVIDUAL || association.entityType === LegalEntityTypes.ORGANIZATION)
+    return {
+      memberType: association.type,
+      roles: [],
+      legalEntityType: association.entityType,
+      legalEntityId: association.legalEntityId || "",
+      name: association.name || ""
+    };
+  throw new Error(`Not a valid member: ${JSON.stringify(association)}`);
+};
+const mapEntityAssociationsToUnincorporatedPartnershipMembers = (entityId, entityAssociations, rootLegalEntity) => {
+  const mappedUnincorporatedPartnershipMembers = entityAssociations.reduce(
+    (acc, entityAssociation) => {
+      if (!Object.values(UnincorporatedPartnershipMemberTypes).includes(
+        entityAssociation.type
+      ) || entityAssociation.associatorId !== entityId || !entityAssociation.legalEntityId) {
+        return acc;
+      }
+      const unincorporatedPartnershipMember = acc[entityAssociation.legalEntityId] ?? convertEntityAssociationIntoUnincorporatedPartnershipMember(entityAssociation);
+      const unincorporatedPartnershipMemberType = entityAssociation.type;
+      const memberOwnerId = getMemberOwnerId(entityAssociation.legalEntityId, entityAssociations);
+      if (memberOwnerId) {
+        unincorporatedPartnershipMember.ownerId = memberOwnerId;
+      }
+      acc[entityAssociation.legalEntityId] = {
+        ...unincorporatedPartnershipMember,
+        roles: [
+          .../* @__PURE__ */ new Set([
+            ...unincorporatedPartnershipMember.roles,
+            unincorporatedPartnershipMemberType
+          ])
+        ]
+      };
+      return acc;
+    },
+    {}
+  );
+  if (rootLegalEntity) {
+    mappedUnincorporatedPartnershipMembers[rootLegalEntity.id] = {
+      legalEntityId: rootLegalEntity.id,
+      legalEntityType: rootLegalEntity.type,
+      name: getLegalEntityNameBasedOnType(rootLegalEntity),
+      memberType: UnincorporatedPartnershipMemberTypes.SECONDARY_PARTNER,
+      // Overriding role as primaryPartner to display in the UI, but type does not exist in the backend
+      roles: ["primaryPartner"]
+    };
+  }
+  return Object.values(mappedUnincorporatedPartnershipMembers)?.sort(
+    (member) => member?.legalEntityId !== rootLegalEntity?.id ? 1 : -1
+  );
+};
+const deleteUnincorporatedPartnershipMember = async ({
+  associatedMember,
+  unincorporatedPartnership,
+  updateLegalEntity
+}) => {
+  const ownEntityAssociations = getOwnEntityAssociations(unincorporatedPartnership);
+  await updateLegalEntity({
+    id: unincorporatedPartnership.id,
+    entityAssociations: ownEntityAssociations.filter(
+      (entityAssociation) => entityAssociation.legalEntityId !== associatedMember.legalEntityId
+    )
+  });
+};
+function useUnincorporatedPartnershipMembers() {
+  const { data: rootLegalEntity } = useLegalEntity(ROOT_LE);
+  const { data: unincorporatedPartnership } = useAssociatedLegalEntity(
+    rootLegalEntity,
+    LegalEntityTypes.UNINCORPORATED_PARTNERSHIP
+  );
+  return useMemo(() => {
+    if (!rootLegalEntity || !unincorporatedPartnership?.unincorporatedPartnership) return [];
+    return mapEntityAssociationsToUnincorporatedPartnershipMembers(
+      unincorporatedPartnership.id,
+      unincorporatedPartnership.entityAssociations ?? [],
+      rootLegalEntity
+    );
+  }, [rootLegalEntity, unincorporatedPartnership]);
+}
+export {
+  deleteUnincorporatedPartnershipMember as d,
+  useUnincorporatedPartnershipMembers as u
+};

package/dist/useUpdateBusinessLines-DAHY8qXu.js

@@ -0,0 +1,339 @@
+;
+{
+  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] = "2856a03a-295c-4168-b162-a60a1033e5bf", e._sentryDebugIdIdentifier = "sentry-dbid-2856a03a-295c-4168-b162-a60a1033e5bf");
+  } catch (e) {
+  }
+}
+;
+import { useQuery, useMutation } from "@tanstack/preact-query";
+import { b as useApiContext, k as httpGet, ai as isEmpty, u as useTranslation, v as useExperimentsContext, t as IconButton, $ as httpPost } from "./StoreProvider-qjyWZhxu.js";
+import { jsx, jsxs, Fragment } from "preact/jsx-runtime";
+import { useRef, useMemo, useState, useEffect } from "preact/hooks";
+import { F as Field } from "./Field-CpaVW2RZ.js";
+import { L as List } from "./List-BAzyC6sw.js";
+import { S as Select } from "./Select-Cb77B0ji.js";
+import { signal } from "@preact/signals";
+const fetchIndustryCodes = async (legalEntityId, baseUrl, businessLineTypes2, locale) => {
+  const results = await Promise.all(
+    businessLineTypes2.map((businessLineType) => {
+      return httpGet({
+        baseUrl,
+        path: `legalEntities/${legalEntityId}/businessLines/${businessLineType}/industryCodes?locale=${locale}`
+      });
+    })
+  );
+  const deduped = [];
+  for (const result of results) {
+    for (const industryCodeDTO of result) {
+      const found = deduped.find((item) => item.code === industryCodeDTO.code);
+      if (!found) {
+        deduped.push(industryCodeDTO);
+      }
+    }
+  }
+  return deduped;
+};
+const useIndustryCodes = (businessLineTypes2, locale, options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useQuery({
+    queryKey: ["industryCodes", businessLineTypes2.join(","), locale],
+    queryFn: () => fetchIndustryCodes(rootLegalEntityId.value, baseUrl.value, businessLineTypes2, locale),
+    ...options
+  });
+};
+const industryCodeFieldValidation = () => ({
+  industryCodes: {
+    modes: ["blur"],
+    validate: (industryCode) => !isEmpty(industryCode),
+    errorMessage: "fieldIsRequired"
+  }
+});
+const industryCodeFieldMetadata = {
+  label: "industry",
+  validators: [
+    industryCodeFieldValidation().industryCodes
+  ]
+};
+const selectedBusinessLine = signal(void 0);
+const shouldSignNewPci = signal(false);
+const industryCodesContent = "adyen-kyc-industry-codes-content";
+const industryCodesSelection = "adyen-kyc-industry-codes-selection";
+const styles$1 = {
+  industryCodesContent,
+  industryCodesSelection
+};
+const mapSelectedCodes = (selectedCodes) => {
+  return selectedCodes && selectedCodes.length > 0 ? selectedCodes.map((i) => {
+    return {
+      value: i,
+      touched: !!i.id
+    };
+  }) : [{ value: { id: "", name: "" }, touched: false }];
+};
+function IndustryCodeField({
+  data,
+  valid,
+  errors,
+  labels,
+  readonly,
+  handleChangeFor,
+  guidanceText,
+  setErrors,
+  // need to manually set errors due to nested select components
+  setValid,
+  // need to manually set validation due to nested select components
+  businessLineTypes: businessLineTypes2,
+  single = false,
+  industryCodes,
+  existingBusinessLines
+}) {
+  const { t } = useTranslation("ui");
+  const industryCodesRef = useRef(null);
+  const { isExperimentEnabled } = useExperimentsContext();
+  const singleIndustryCode = single || !!selectedBusinessLine.value || // when editing a business line, only single dropdown should render
+  isExperimentEnabled("EnableLimitToSingleBusinessLine");
+  const allIndustryCodeSelectItems = useMemo(
+    () => industryCodes?.map((entry) => ({
+      id: entry.code,
+      name: `${entry.code} - ${entry.description}`
+    })) ?? [],
+    [industryCodes]
+  );
+  const selectableIndustryCodes = useMemo(() => {
+    if (!businessLineTypes2.includes("acquiring")) return allIndustryCodeSelectItems;
+    const selectedIds = data.industryCodes?.map((c) => c.id);
+    const existingIds = (existingBusinessLines ?? []).map((b) => b.industryCode);
+    return allIndustryCodeSelectItems.filter((item) => {
+      const isDuplicate = selectedIds?.includes(item.id) || existingIds?.includes(item.id);
+      return !isDuplicate;
+    });
+  }, [allIndustryCodeSelectItems, businessLineTypes2, data.industryCodes, existingBusinessLines]);
+  const selectedCodes = data.industryCodes;
+  const [items, setItems] = useState(mapSelectedCodes(selectedCodes));
+  useEffect(() => {
+    setItems(mapSelectedCodes(selectedCodes));
+  }, [selectedCodes]);
+  const updateIndustryCodes = (value) => {
+    handleChangeFor("industryCodes")(value);
+  };
+  const addIndustryCodeField = (e) => {
+    if (items[items.length - 1].value.id === "") {
+      handleIndustryCodeFocusOut(e, items.length - 1);
+      return;
+    }
+    const newItems = [...items, { value: { id: "", name: "" }, touched: false }];
+    setItems(newItems);
+    updateIndustryCodes(newItems.map((item) => item.value));
+  };
+  const removeField = (indexToRemove) => {
+    const newItems = items.filter((_, index) => index !== indexToRemove);
+    setItems(newItems);
+    updateIndustryCodes(newItems.map((item) => item.value));
+  };
+  const handleSelectIndustryCode = (indexToUpdate, selectedItem) => {
+    setItems((prevItems) => {
+      const newItems = [...prevItems];
+      newItems[indexToUpdate] = {
+        value: {
+          id: selectedItem.id,
+          name: selectedItem.name
+        },
+        touched: true
+      };
+      updateIndustryCodes(
+        newItems.map((item) => {
+          return {
+            id: item.value.id,
+            name: item.value.name
+          };
+        })
+      );
+      return newItems;
+    });
+  };
+  const handleIndustryCodeFocusOut = (e, index) => {
+    if (industryCodesRef.current && !industryCodesRef.current.contains(e.relatedTarget)) {
+      setItems((prevItems) => {
+        if (prevItems[index].value.id || prevItems[index].touched) {
+          return prevItems;
+        }
+        const newItems = [...prevItems];
+        newItems[index] = { ...newItems[index], touched: true };
+        const isGroupInvalid = newItems.some((item) => item.value.id === "");
+        if (isGroupInvalid) {
+          setErrors?.(
+            "industryCodes",
+            {
+              isValid: false,
+              errorMessage: "fieldIsRequired",
+              hasError: true
+            },
+            "industryCodesForm"
+          );
+          setValid?.("industryCodes", false, "industryCodesForm");
+        } else {
+          setErrors?.("industryCodes", null, "industryCodesForm");
+          setValid?.("industryCodes", true, "industryCodesForm");
+        }
+        return newItems;
+      });
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    Field,
+    {
+      name: "industryCodes",
+      label: labels?.industryCodes || t(($) => $["industry"]),
+      errorMessage: errors.industryCodes,
+      isValid: valid.industryCodes,
+      formatGuidance: guidanceText.industryCodes,
+      showErrorIcon: false,
+      children: (childProps) => /* @__PURE__ */ jsx(Wrapper, { single: singleIndustryCode, children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: styles$1.industryCodesContent,
+          ref: industryCodesRef,
+          "data-testid": "industryCode",
+          children: items.map((code, index) => {
+            const isInvalid = code.touched && code.value.id === "";
+            return /* @__PURE__ */ jsxs("div", { className: styles$1.industryCodesSelection, children: [
+              /* @__PURE__ */ jsx(
+                Select,
+                {
+                  ...childProps,
+                  id: `industryCodeSelection-${index}`,
+                  name: `industryCodeSelection-${index}`,
+                  selected: code.value,
+                  placeholder: t(($) => $["industryCode__placeholder"]),
+                  items: allIndustryCodeSelectItems,
+                  excludedValues: allIndustryCodeSelectItems.filter(
+                    (i) => !selectableIndustryCodes.includes(i)
+                  ),
+                  readonly: !!data.industryCodes && readonly || !!industryCodes && selectableIndustryCodes.length === 0,
+                  onSelect: (selectedItem) => handleSelectIndustryCode(index, selectedItem),
+                  isInvalid,
+                  onBlur: (e) => handleIndustryCodeFocusOut(e, index)
+                }
+              ),
+              !singleIndustryCode && /* @__PURE__ */ jsxs(Fragment, { children: [
+                /* @__PURE__ */ jsx(
+                  IconButton,
+                  {
+                    ariaLabel: t(($) => $["removeIndustryCode"]),
+                    variant: "tertiary",
+                    icon: "minusCircleFilled",
+                    circle: true,
+                    onClick: () => removeField(index),
+                    disabled: items.length === 1 || readonly
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  IconButton,
+                  {
+                    ariaLabel: t(($) => $["addIndustryCode"]),
+                    variant: "tertiary",
+                    icon: "plusCircleFilled",
+                    circle: true,
+                    onClick: addIndustryCodeField,
+                    disabled: readonly || code.value.id === "" || code.value.id !== "" && index !== items.length - 1 || selectableIndustryCodes.length === 0
+                  }
+                )
+              ] })
+            ] }, code.value.id);
+          })
+        }
+      ) })
+    }
+  );
+}
+function Wrapper({ single, children }) {
+  return single ? children : /* @__PURE__ */ jsx(List, { dividers: false, variant: "grouped-primary", children });
+}
+const salesChannelsWithWebData = ["eCommerce", "ecomMoto"];
+const SALES_CHANNELS_FIELD = ["salesChannels"];
+const WEB_DATA_FIELD = ["webAddress", "webExempt"];
+const INDUSTRY_CODE_FIELD = ["industryCodes"];
+const SCTA_FIELD = ["sctaUrl", "sctaExempt"];
+const businessLinesConfigurations = {
+  industryCodes: { rule: "REQUIRED" },
+  salesChannels: { rule: "REQUIRED" },
+  webAddress: { rule: "webAddressRequired" },
+  webExempt: { rule: "OPTIONAL" },
+  sctaUrl: { rule: "sctaUrlRequired" },
+  sctaExempt: { rule: "OPTIONAL" }
+};
+const businessLinesForms = {
+  industryCodesForm: {
+    formId: "industryCodesForm",
+    formName: "industryCodesForm",
+    fields: INDUSTRY_CODE_FIELD
+  },
+  salesChannelsForm: {
+    formId: "salesChannelsForm",
+    formName: "paymentProcessing",
+    fields: [...SALES_CHANNELS_FIELD, ...WEB_DATA_FIELD]
+  },
+  sctaForm: {
+    formId: "sctaForm",
+    formName: "japaneseCommercialDisclosure",
+    fields: SCTA_FIELD
+  }
+};
+const businessLineTypes = ["acquiring"];
+const divider = "adyen-kyc-divider";
+const styles = {
+  divider
+};
+const Divider = () => /* @__PURE__ */ jsx("hr", { className: styles.divider });
+const createBusinessLine = async (legalEntityId, baseUrl, data) => {
+  return httpPost(
+    {
+      baseUrl,
+      path: `legalEntities/${legalEntityId}/businessLines`
+    },
+    data
+  );
+};
+const useCreateBusinessLine = (options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useMutation({
+    mutationFn: (data) => createBusinessLine(rootLegalEntityId.value, baseUrl.value, data),
+    ...options
+  });
+};
+const updateBusinessLine = async (legalEntityId, baseUrl, data) => {
+  return httpPost(
+    {
+      baseUrl,
+      path: `legalEntities/${legalEntityId}/businessLines/${data.id}`
+    },
+    data
+  );
+};
+const useUpdateBusinessLine = (options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useMutation({
+    mutationFn: (data) => updateBusinessLine(rootLegalEntityId.value, baseUrl.value, data),
+    ...options
+  });
+};
+export {
+  Divider as D,
+  INDUSTRY_CODE_FIELD as I,
+  SALES_CHANNELS_FIELD as S,
+  WEB_DATA_FIELD as W,
+  IndustryCodeField as a,
+  useCreateBusinessLine as b,
+  useUpdateBusinessLine as c,
+  businessLineTypes as d,
+  shouldSignNewPci as e,
+  SCTA_FIELD as f,
+  selectedBusinessLine as g,
+  businessLinesConfigurations as h,
+  industryCodeFieldMetadata as i,
+  businessLinesForms as j,
+  salesChannelsWithWebData as s,
+  useIndustryCodes as u
+};

package/dist/useUpdateLegalEntity-B7VJAlhD.js

@@ -0,0 +1,40 @@
+;
+{
+  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] = "070b513e-e932-4eae-9148-c773d9c3d1a0", e._sentryDebugIdIdentifier = "sentry-dbid-070b513e-e932-4eae-9148-c773d9c3d1a0");
+  } catch (e) {
+  }
+}
+;
+import { useQueryClient, useMutation } from "@tanstack/preact-query";
+import { a as useInvalidateRootLegalEntity } from "./useToastContext-CYdZ2BD2.js";
+import { b as useApiContext, $ as httpPost } from "./StoreProvider-qjyWZhxu.js";
+const updateLegalEntity = async (rootLegalEntityId, baseUrl, data) => {
+  return httpPost(
+    {
+      baseUrl,
+      path: `legalEntities/${rootLegalEntityId}`
+    },
+    data
+  );
+};
+const useUpdateLegalEntity = (options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  const invalidateRootLegalEntity = useInvalidateRootLegalEntity();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (payload) => updateLegalEntity(rootLegalEntityId.value, baseUrl.value, payload),
+    onSuccess: async (response, payload) => {
+      if (response.id === rootLegalEntityId.value) {
+        await invalidateRootLegalEntity();
+      } else {
+        queryClient.setQueryData(["legalEntity", payload.id], response);
+      }
+    },
+    ...options
+  });
+};
+export {
+  useUpdateLegalEntity as u
+};