@adyen/kyc-components 4.10.0-beta.1 → 4.11.0-beta.0

package/dist/useUnincorporatedPartnershipMembers-rr3GdonJ.js

@@ -0,0 +1,70 @@
+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] = "4527662d-139b-4458-9c6a-4e94e29b7a01", e._sentryDebugIdIdentifier = "sentry-dbid-4527662d-139b-4458-9c6a-4e94e29b7a01");
+} catch (e) {}
+import { r as useLegalEntity, t as ROOT_LE } from "./useLegalEntity-CJD0bWSj.js";
+import { t as LegalEntityTypes } from "./legal-entity-type-VIfNYnJP.js";
+import { s as getOwnEntityAssociations } from "./entityAssociationUtil-C0gX4Ewv.js";
+import { t as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-BGQ6cYIB.js";
+import { n as getLegalEntityNameBasedOnType } from "./getName-ODLD6UPV.js";
+import { t as UnincorporatedPartnershipMemberTypes } from "./unincorporated-partnership-CtwHVLzp.js";
+import { useMemo } from "preact/hooks";
+//#region src/components/UnincorporatedPartnership/utils/unincorporatedPartnershipMembers.ts
+var getMemberOwnerId = (memberId, entityAssociations) => entityAssociations.find((association) => association.associatorId === memberId)?.legalEntityId;
+var 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)}`);
+};
+/**
+* In the API response, there are multiple {@link LegalEntityAssociation}s for the same associated entity;
+* one for each role e.g. 'secondaryPartner', 'uboThroughControl', 'uboThroughOwnersghip'...
+*
+* Therefore we need to combine these into one {@link UnincorporatedPartnershipMember} with multiple roles.
+*/
+var 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: [...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,
+		roles: ["primaryPartner"]
+	};
+	return Object.values(mappedUnincorporatedPartnershipMembers)?.sort((member) => member?.legalEntityId !== rootLegalEntity?.id ? 1 : -1);
+};
+var deleteUnincorporatedPartnershipMember = async ({ associatedMember, unincorporatedPartnership, updateLegalEntity }) => {
+	const ownEntityAssociations = getOwnEntityAssociations(unincorporatedPartnership);
+	await updateLegalEntity({
+		id: unincorporatedPartnership.id,
+		entityAssociations: ownEntityAssociations.filter((entityAssociation) => entityAssociation.legalEntityId !== associatedMember.legalEntityId)
+	});
+};
+//#endregion
+//#region src/hooks/useUnincorporatedPartnershipMembers.ts
+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]);
+}
+//#endregion
+export { deleteUnincorporatedPartnershipMember as n, useUnincorporatedPartnershipMembers as t };

package/dist/useUpdateBusinessLines-Cb4l4EVO.js

@@ -0,0 +1,271 @@
+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] = "1fbe754c-115a-4d97-a2e1-4e25be99a56b", e._sentryDebugIdIdentifier = "sentry-dbid-1fbe754c-115a-4d97-a2e1-4e25be99a56b");
+} catch (e) {}
+import { r as useTranslation } from "./translation-hEYGx0ZB.js";
+import { n as IconButton } from "./Button-CAoywEKy.js";
+import { r as httpPost, s as useApiContext } from "./http-j2zqU8vS.js";
+import { y as isEmpty } from "./validatorUtils-D5MKiGfL.js";
+import { t as useToggleContext } from "./useToggleContext-CLfowItk.js";
+import { t as List } from "./List-DLrcpMVd.js";
+import { t as Field } from "./Field-BD_0HjiI.js";
+import { t as Select } from "./Select-CAso7Gvi.js";
+import { useEffect, useMemo, useRef, useState } from "preact/hooks";
+import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
+import { signal } from "@preact/signals";
+import { useMutation } from "@tanstack/preact-query";
+//#region src/components/Shared/fields/IndustryCodeField/validate.ts
+var industryCodeFieldValidation = () => ({ industryCodes: {
+	modes: ["blur"],
+	validate: (industryCode) => !isEmpty(industryCode),
+	errorMessage: "fieldIsRequired"
+} });
+//#endregion
+//#region src/components/Shared/fields/IndustryCodeField/fieldConfig.ts
+var industryCodeFieldMetadata = { validators: [industryCodeFieldValidation().industryCodes] };
+//#endregion
+//#region src/components/BusinessLines/tasks/BusinessLines/BusinessLinesStore.ts
+var selectedBusinessLine = signal(void 0);
+var shouldSignNewPci = signal(false);
+var IndustryCodeField_module_default = {
+	"industry-codes-content": "adyen-kyc-industry-codes-content",
+	industryCodesContent: "adyen-kyc-industry-codes-content",
+	"industry-codes-selection": "adyen-kyc-industry-codes-selection",
+	industryCodesSelection: "adyen-kyc-industry-codes-selection"
+};
+//#endregion
+//#region src/components/Shared/fields/IndustryCodeField/IndustryCodeField.tsx
+var 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, readonly, handleChangeFor, guidanceText, setErrors, setValid, businessLineTypes, single = false, industryCodes, existingBusinessLines }) {
+	const { t } = useTranslation("ui");
+	const industryCodesRef = useRef(null);
+	const { isFeatureEnabled } = useToggleContext();
+	const singleIndustryCode = single || !!selectedBusinessLine.value || isFeatureEnabled("EnableLimitToSingleBusinessLine");
+	const allIndustryCodeSelectItems = useMemo(() => industryCodes?.map((entry) => ({
+		id: entry.code,
+		name: `${entry.code} - ${entry.description}`
+	})) ?? [], [industryCodes]);
+	/** Not allowing business lines with duplicate industry codes in HO */
+	const selectableIndustryCodes = useMemo(() => {
+		if (!businessLineTypes.includes("acquiring")) return allIndustryCodeSelectItems;
+		const selectedIds = data.industryCodes?.map((c) => c.id);
+		const existingIds = (existingBusinessLines ?? []).map((b) => b.industryCode);
+		return allIndustryCodeSelectItems.filter((item) => {
+			return !(selectedIds?.includes(item.id) || existingIds?.includes(item.id));
+		});
+	}, [
+		allIndustryCodeSelectItems,
+		businessLineTypes,
+		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
+			};
+			if (newItems.some((item) => item.value.id === "")) {
+				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: t(($) => $["industry"]),
+		errorMessage: errors.industryCodes,
+		isValid: valid.industryCodes,
+		formatGuidance: guidanceText,
+		showErrorIcon: false,
+		children: (childProps) => /* @__PURE__ */ jsx(Wrapper, {
+			single: singleIndustryCode,
+			children: /* @__PURE__ */ jsx("div", {
+				className: IndustryCodeField_module_default.industryCodesContent,
+				ref: industryCodesRef,
+				"data-testid": "industryCode",
+				children: items.map((code, index) => {
+					const isInvalid = code.touched && code.value.id === "";
+					return /* @__PURE__ */ jsxs("div", {
+						className: IndustryCodeField_module_default.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
+	});
+}
+//#endregion
+//#region src/components/BusinessLines/constants.ts
+var salesChannelsWithWebData = ["eCommerce", "ecomMoto"];
+var SALES_CHANNELS_FIELD = ["salesChannels"];
+var WEB_DATA_FIELD = ["webAddress", "webExempt"];
+var INDUSTRY_CODE_FIELD = ["industryCodes"];
+var SCTA_FIELD = ["sctaUrl", "sctaExempt"];
+var businessLinesConfigurations = {
+	industryCodes: { rule: "REQUIRED" },
+	salesChannels: { rule: "REQUIRED" },
+	webAddress: { rule: "webAddressRequired" },
+	webExempt: { rule: "OPTIONAL" },
+	sctaUrl: { rule: "sctaUrlRequired" },
+	sctaExempt: { rule: "OPTIONAL" }
+};
+var 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
+	}
+};
+var businessLineTypes = ["acquiring"];
+//#endregion
+//#region src/api/businessLines/useCreateBusinessLine.ts
+var createBusinessLine = async (legalEntityId, baseUrl, data) => {
+	return httpPost({
+		baseUrl,
+		path: `legalEntities/${legalEntityId}/businessLines`
+	}, data);
+};
+/**
+* @param options additional options passed to Tanstack Query, eg; refetchInterval for polling
+*/
+var useCreateBusinessLine = (options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	return useMutation({
+		mutationFn: (data) => createBusinessLine(rootLegalEntityId.value, baseUrl.value, data),
+		...options
+	});
+};
+//#endregion
+//#region src/api/businessLines/useUpdateBusinessLines.ts
+var updateBusinessLine = async (legalEntityId, baseUrl, data) => {
+	return httpPost({
+		baseUrl,
+		path: `legalEntities/${legalEntityId}/businessLines/${data.id}`
+	}, data);
+};
+/**
+* @param options additional options passed to Tanstack Query, eg; refetchInterval for polling
+*/
+var useUpdateBusinessLine = (options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	return useMutation({
+		mutationFn: (data) => updateBusinessLine(rootLegalEntityId.value, baseUrl.value, data),
+		...options
+	});
+};
+//#endregion
+export { SCTA_FIELD as a, businessLinesConfigurations as c, IndustryCodeField as d, selectedBusinessLine as f, SALES_CHANNELS_FIELD as i, businessLinesForms as l, industryCodeFieldMetadata as m, useCreateBusinessLine as n, WEB_DATA_FIELD as o, shouldSignNewPci as p, INDUSTRY_CODE_FIELD as r, businessLineTypes as s, useUpdateBusinessLine as t, salesChannelsWithWebData as u };

package/dist/useUpdateLegalEntity-24uhTBvq.js

@@ -0,0 +1,29 @@
+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] = "8e34a2b2-234d-4f80-9bac-e057e10a2ba4", e._sentryDebugIdIdentifier = "sentry-dbid-8e34a2b2-234d-4f80-9bac-e057e10a2ba4");
+} catch (e) {}
+import { r as httpPost, s as useApiContext } from "./http-j2zqU8vS.js";
+import { t as useInvalidateRootLegalEntity } from "./invalidateRootLegalEntity-_CrcBcVy.js";
+import { useMutation, useQueryClient } from "@tanstack/preact-query";
+//#region src/api/legalEntity/useUpdateLegalEntity.ts
+var updateLegalEntity = async (rootLegalEntityId, baseUrl, data) => {
+	return httpPost({
+		baseUrl,
+		path: `legalEntities/${rootLegalEntityId}`
+	}, data);
+};
+var 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
+	});
+};
+//#endregion
+export { useUpdateLegalEntity as t };

package/dist/utils-BbusgEMl.js

@@ -0,0 +1,32 @@
+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] = "24b2cbe4-7781-4733-9480-2ef86972addc", e._sentryDebugIdIdentifier = "sentry-dbid-24b2cbe4-7781-4733-9480-2ef86972addc");
+} catch (e) {}
+var getNestedTrustedFields = (field, data, trustedFields) => {
+	if (trustedFields && data?.[field] && typeof data[field] === "object") return trustedFields.reduce((fields, trustedField) => {
+		const splitField = trustedField.split(".");
+		if (splitField[0] === field) return [...fields, splitField[1]];
+		return fields;
+	}, []);
+	return [];
+};
+var mapAddressData = (verifiedBusiness) => ({
+	address: verifiedBusiness.street ?? "",
+	otherAddressInformation: verifiedBusiness.street2 ?? "",
+	city: verifiedBusiness.city ?? "",
+	postalCode: verifiedBusiness.postalCode ?? "",
+	stateOrProvince: verifiedBusiness.state ?? ""
+});
+var isDateOlderThanAYear = (dateString) => {
+	if (!dateString) return false;
+	const inputDate = new Date(dateString);
+	if (isNaN(inputDate.getTime())) {
+		console.error(`Error: Invalid date format or value for: ${dateString}`);
+		return false;
+	}
+	const oneYearAgo = /* @__PURE__ */ new Date();
+	oneYearAgo.setFullYear(oneYearAgo.getFullYear() - 1);
+	return inputDate.getTime() < oneYearAgo.getTime();
+};
+//#endregion
+export { isDateOlderThanAYear as n, mapAddressData as r, getNestedTrustedFields as t };

package/dist/utils-BkkjRLzb.js

@@ -0,0 +1,188 @@
+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] = "0da3bb5b-a4de-4515-a3e2-a317b4ddf479", e._sentryDebugIdIdentifier = "sentry-dbid-0da3bb5b-a4de-4515-a3e2-a317b4ddf479");
+} catch (e) {}
+import { t as LegalEntityTypes } from "./legal-entity-type-VIfNYnJP.js";
+import { t as getLegalEntityCountry } from "./getLegalEntityCountry-C6bSV6sB.js";
+import { t as CountryCodes } from "./country-code-D3oCpE4i.js";
+import { t as getCapabilities } from "./processCapabilities-CDSEJpB8.js";
+import { d as hasOwnEntityAssociationOfType } from "./entityAssociationUtil-C0gX4Ewv.js";
+import { t as CompanyTypesValues } from "./company-types-value-B-1b0hXg.js";
+import { t as allowIndividualWithoutSoleProp } from "./accountHolderUtils-DvIn173h.js";
+import { r as SOLE_PROP_COUNTRIES } from "./Individual.rules-96yFA3BD.js";
+import { t as ALLOWED_UNINCORPORATED_PARTNERSHIP_COUNTRIES } from "./types-DFnOnn2u.js";
+//#region src/components/Shared/forms/BusinessTypeSelection/utils.ts
+var TRUST_COUNTRIES = [CountryCodes.Australia, CountryCodes.NewZealand];
+var BUSINESS_BANK_ACCOUNT_COUNTRIES = [
+	CountryCodes.UnitedStates,
+	CountryCodes.UnitedKingdom,
+	CountryCodes.Netherlands,
+	CountryCodes.France,
+	CountryCodes.Germany,
+	CountryCodes.Spain,
+	CountryCodes.Belgium
+];
+/**
+* this is messy business logic
+* we determine the legal entity type by the account holder
+* however we have partnershipIncorporated;
+* which shares the same account holder type as company (a subtype of company)
+* we have to force the result of this function to 'legalArrangement' should organization.type is partnershipIncorporated
+* could possibly be more of such cases in the future.
+*
+* @param businessTypeItems - list of BusinessTypeModel
+* @param accountHolder - the entity we payout to
+* @param legalEntityType - the type of legal entity
+* @param companyTypesValue - the subtype of an organization see CompanyValuesType
+*/
+var organizationTypesToSkipCompanyStructureForm = ["partnershipIncorporated", "associationIncorporated"];
+var getBusinessType = (businessTypeItems, country, accountHolder, legalEntityType, companyTypesValue, capabilities = []) => {
+	const findBusinessType = (id) => businessTypeItems[id];
+	if (organizationTypesToSkipCompanyStructureForm.includes(companyTypesValue ?? "")) return businessTypeItems.legalArrangement;
+	if (accountHolder) {
+		if ([
+			"aTrust",
+			"partnershipUnincorporated",
+			"anAssociation"
+		].includes(accountHolder)) return businessTypeItems.legalArrangement;
+		return Object.values(businessTypeItems).find((businessTypeItem) => businessTypeItem.accountHolder === accountHolder);
+	}
+	switch (legalEntityType) {
+		case LegalEntityTypes.ORGANIZATION: return findBusinessType("company");
+		case LegalEntityTypes.INDIVIDUAL:
+			if (allowIndividualWithoutSoleProp(capabilities)) return findBusinessType("individual");
+			if (SOLE_PROP_COUNTRIES.includes(country)) return findBusinessType("soleProprietorship");
+			return findBusinessType("company");
+		default:
+	}
+};
+var businessTypeMetadata = {
+	individual: {
+		id: "individual",
+		accountHolder: "myName",
+		name: "individual",
+		description: "youAreNotSoleProprietorAndUseBankAccount"
+	},
+	soleProprietorship: {
+		id: "soleProprietorship",
+		accountHolder: "mySoleProprietorName",
+		name: "soleProprietorship",
+		description: "youAreRegisteredSoleProprietorAndUseBankAccount"
+	},
+	company: {
+		id: "company",
+		accountHolder: "theCompanyIWorkFor",
+		name: "company",
+		description: "yourBusinessIsRegisteredAsASeparateLegalEntityFromItsOwners"
+	},
+	legalArrangement: {
+		id: "legalArrangement",
+		name: "trustPartnershipOrAssociation",
+		description: "youAreIndividualOrCompanyAndUseBankAccountInNameOfTrustPartnershipOrAssociation"
+	}
+};
+var businessTypeIcons = {
+	individual: "user",
+	soleProprietorship: "user-business",
+	company: "company-2",
+	legalArrangement: "users-3"
+};
+var createAllowBusinessTypeOptionDecider = (country, capabilities) => (option) => {
+	switch (option) {
+		case "individual": return allowIndividualWithoutSoleProp(capabilities);
+		case "soleProprietorship": return SOLE_PROP_COUNTRIES.includes(country);
+		default: return true;
+	}
+};
+var getBusinessTypeOptionsAndMetadata = (country, capabilities) => {
+	const shouldAllowBusinessTypeOption = createAllowBusinessTypeOptionDecider(country, capabilities);
+	const allowedBusinessTypeMetadata = {};
+	Object.entries(businessTypeMetadata).forEach(([key, value]) => {
+		const businessType = key;
+		if (shouldAllowBusinessTypeOption(businessType)) allowedBusinessTypeMetadata[businessType] = value;
+	});
+	const adjustedBusinessTypeMetadata = {
+		...allowedBusinessTypeMetadata,
+		...!TRUST_COUNTRIES.includes(country) ? { legalArrangement: {
+			id: "legalArrangement",
+			name: "partnershipOrAssociation",
+			description: "youAreIndividualOrCompanyAndUseBankAccountInNameOfPartnershipOrAssociation"
+		} } : {}
+	};
+	if (capabilities?.includes("issueBankAccount") && BUSINESS_BANK_ACCOUNT_COUNTRIES.includes(country)) {
+		delete adjustedBusinessTypeMetadata?.legalArrangement;
+		delete adjustedBusinessTypeMetadata?.individual;
+	}
+	return adjustedBusinessTypeMetadata;
+};
+var legalArrangementMetadata = {
+	aTrust: {
+		id: "aTrust",
+		accountHolder: "aTrust",
+		name: "trust",
+		description: "youAreTrusteeManagingTheTrustForBeneficiaries"
+	},
+	partnershipIncorporated: {
+		id: "partnershipIncorporated",
+		accountHolder: "theCompanyIWorkFor",
+		name: "partnershipIncorporated",
+		description: "partnershipIncorporatedDescription"
+	},
+	partnershipUnincorporated: {
+		id: "partnershipUnincorporated",
+		accountHolder: "anUnincorporatedPartnership",
+		name: "partnershipUnincorporated",
+		description: "partnershipUnincorporatedDescription"
+	},
+	associationIncorporated: {
+		id: "associationIncorporated",
+		accountHolder: "theCompanyIWorkFor",
+		name: "associationIncorporated",
+		description: "yourAssociationIsRegisteredItWasSetUpForNonCommercialPurpose"
+	}
+};
+var legalArragementOptions = Object.keys(legalArrangementMetadata);
+var getLegalArrangementOptions = (country) => legalArragementOptions.filter((option) => {
+	if (option === "partnershipIncorporated" || option === "associationIncorporated") return true;
+	if (option === "partnershipUnincorporated") return ALLOWED_UNINCORPORATED_PARTNERSHIP_COUNTRIES.includes(country);
+	return TRUST_COUNTRIES.includes(country);
+});
+var useSelectionOptions = (legalEntityResponse) => {
+	const country = getLegalEntityCountry(legalEntityResponse);
+	return {
+		adjustedBusinessTypeMetadata: getBusinessTypeOptionsAndMetadata(country, getCapabilities(legalEntityResponse)),
+		legalArrangementOptions: getLegalArrangementOptions(country)
+	};
+};
+var mapLegalArrangementOptionToCompanyTypesValue = (legalArrangement) => {
+	switch (legalArrangement) {
+		case "partnershipIncorporated": return CompanyTypesValues.INCORPORATED_PARTNERSHIP;
+		case "associationIncorporated": return CompanyTypesValues.INCORPORATED_ASSOCIATION;
+		default: return;
+	}
+};
+var determineOrganizationTypeToUpdate = (targetLegalArrangement, currentCompanyTypeValue) => {
+	if (targetLegalArrangement === "aTrust") return;
+	if (!targetLegalArrangement) {
+		if (currentCompanyTypeValue === CompanyTypesValues.INCORPORATED_ASSOCIATION || currentCompanyTypeValue === CompanyTypesValues.INCORPORATED_PARTNERSHIP) return CompanyTypesValues.PRIVATE_COMPANY;
+	}
+	return mapLegalArrangementOptionToCompanyTypesValue(targetLegalArrangement);
+};
+var getDefaultLegalArrangementOrSuborganizationType = (legalEntityResponse, accountHolder) => {
+	const entityAssociations = legalEntityResponse?.entityAssociations;
+	const suborganizationType = legalEntityResponse?.organization?.type;
+	if (hasOwnEntityAssociationOfType(LegalEntityTypes.TRUST, entityAssociations, legalEntityResponse?.id) || accountHolder === "aTrust") return "aTrust";
+	if (hasOwnEntityAssociationOfType(LegalEntityTypes.UNINCORPORATED_PARTNERSHIP, entityAssociations, legalEntityResponse?.id) || accountHolder === "anUnincorporatedPartnership") return "partnershipUnincorporated";
+	if (suborganizationType === CompanyTypesValues.INCORPORATED_PARTNERSHIP) return "partnershipIncorporated";
+	if (suborganizationType === CompanyTypesValues.INCORPORATED_ASSOCIATION) return "associationIncorporated";
+};
+var getTargetLegalEntityType = (businessType, legalArrangement, trusteeType, currentLegalEntityType) => {
+	const trustOrUnincorporatedPartnership = legalArrangement === "aTrust" || legalArrangement === "partnershipUnincorporated";
+	if (businessType === "legalArrangement" && trustOrUnincorporatedPartnership && trusteeType === "company" || businessType === "company") return LegalEntityTypes.ORGANIZATION;
+	if (businessType === "legalArrangement" && trustOrUnincorporatedPartnership && trusteeType === "individual" || businessType === "individual" || businessType === "soleProprietorship") return LegalEntityTypes.INDIVIDUAL;
+	if (legalArrangement && isLegalArrangementOrganizationSubtype(legalArrangement)) return LegalEntityTypes.ORGANIZATION;
+	return currentLegalEntityType;
+};
+var isLegalArrangementOrganizationSubtype = (legalArrangementOption) => legalArrangementOption === "partnershipIncorporated" || legalArrangementOption === "associationIncorporated";
+//#endregion
+export { getTargetLegalEntityType as a, useSelectionOptions as c, getDefaultLegalArrangementOrSuborganizationType as i, determineOrganizationTypeToUpdate as n, legalArrangementMetadata as o, getBusinessType as r, organizationTypesToSkipCompanyStructureForm as s, businessTypeIcons as t };