@adyen/kyc-components 4.23.0 → 4.24.0-beta.0

package/dist/TrustDetailsPage-Byj68n3F.js

@@ -0,0 +1,1172 @@
+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] = "1b6a8457-2d82-486b-9ab5-6ed5c29a485b", e._sentryDebugIdIdentifier = "sentry-dbid-1b6a8457-2d82-486b-9ab5-6ed5c29a485b");
+} catch (e) {}
+import { n as addResourceBundles, r as useTranslation } from "./translation-DbATp_35.js";
+import { t as Typography } from "./Typography-CAc_f5Iq.js";
+import { t as Loader } from "./Loader-BVtlpTeo.js";
+import { s as useApiContext } from "./http-fdIO--pH.js";
+import { r as useLegalEntity, t as ROOT_LE } from "./useLegalEntity-DHA8TJeV.js";
+import { t as getLegalEntityCountry } from "./getLegalEntityCountry-BK-HHa65.js";
+import { a as objectsDeepEqual, r as drop } from "./genUtils-nphCwt1A.js";
+import { C as isValidMinLength, _ as hasText, a as NO_ALPHABET_REGEX, g as hasRepeatedCharacters, n as EMOJI_REGEX, s as OTHER_ENTITIES_VALID_CHAR_REGEX, w as matchesRegex, x as isInvalidName } from "./validatorUtils-D2O6AAZn.js";
+import { t as useToggleContext } from "./useToggleContext-B_YexrbT.js";
+import { t as _rolldown_dynamic_import_helper_default } from "./_rolldown_dynamic_import_helper-sGNwd-kR.js";
+import { t as Header } from "./Header-DVLlJ6we.js";
+import { t as CountryCodes } from "./country-code-CJk2hdPu.js";
+import { n as datasetUtilities } from "./datasetUtil-BdHPWsxZ.js";
+import { t as Alert } from "./Alert-Cc7p0N5h.js";
+import { a as trustComponentsKeyMapping, i as trustApiKeyMapping, o as trustDocumentMapping, y as reverseMapping } from "./processCapabilities-CWE5UFt8.js";
+import { t as TaskTypes } from "./taskTypes-3vSkMBDm.js";
+import { s as getOwnEntityAssociations } from "./entityAssociationUtil-CY0grcyH.js";
+import { t as getCountrySpecificTrustTypeOptions } from "./trustUtil-5cyXiJnX.js";
+import { t as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-DtZtKlls.js";
+import { t as useToastContext } from "./useToastContext-B6Mqc2HY.js";
+import { n as useCapabilityProblems, t as getProblemsForEntity } from "./getProblemsForEntity-Bn6dXidE.js";
+import { t as useCreateLegalEntity } from "./useCreateLegalEntity-qP7MeAmi.js";
+import { t as useUpdateLegalEntity } from "./useUpdateLegalEntity-CqmqXsbR.js";
+import { a as useFormComposer, i as FormFlow, n as getRequiredForms, o as FormContextProvider, r as useFormContext, t as addValidityToForms } from "./dropinUtils-DTBezwYT.js";
+import { i as getPropsFromConfigurations, n as augmentWithCountryConfigs, r as composePerScenarioFormConfigurations, t as createFormRules } from "./form-rules-B0RwhsVw.js";
+import { t as ErrorPanel } from "./ErrorPanel-D4JNFkvi.js";
+import { n as mergeFieldMetadataIntoProps, t as createFormUtils } from "./formUtils-DVDcdZsP.js";
+import { t as useMultiForm } from "./useMultiForm-BxASst0O.js";
+import { t as Field } from "./Field-DwDJQVSS.js";
+import { t as getFormSlice } from "./getFormSlice-C1ma6Xd4.js";
+import { a as exemptFromRegistrationNumberDefaultFieldMetadata, c as registrationNumberDefaultFieldMetadata, i as exemptFromRegistrationNumberDefaultFieldConfig, l as getCompanyRegistrationNumberOptions, n as inferCompanyRegistrationNumberType, s as registrationNumberDefaultFieldConfig, t as getDefaultRegistrationNumberType } from "./getDefaultRegistrationNumberType-CIu4WMln.js";
+import { A as taxIdNumberOptions, a as exemptedFromTaxDefaultFieldConfig, c as taxInformationDefaultFieldConfig, l as taxInformationDefaultFieldMetadata, m as COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT, o as exemptedFromTaxDefaultFieldMetadata } from "./utils-Ck_mZapQ.js";
+import { t as Select } from "./Select-phAxjMBQ.js";
+import { n as CountryField, t as COUNTRY_FIELD } from "./CountryField-DT6-Jr_b.js";
+import { a as mapAddressLabelsNewSummary, c as COUNTRIES_WITH_STATES_DATASET, t as getAddressSchemaForCountry } from "./utils-BWumuCvl.js";
+import { a as validateNotEmptyOnBlur } from "./patternValidators-DsrZkuOO.js";
+import { t as InputText } from "./InputText-CFDEmEtp.js";
+import { t as resolveFieldMetadata } from "./fieldConfigurations-CZCFghnK.js";
+import { n as TaxInformationField, t as TAX_INFORMATION_FIELD } from "./TaxInformationField-CV7SpMH1.js";
+import { n as BusinessRegistrationNumberField, t as BUSINESS_REGISTRATION_NUMBER_FIELD } from "./BusinessRegistrationNumberField-DKka8aVU.js";
+import { a as UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_REQUIRED, c as UNINCORPORATED_PARTNERSHIP_COUNTRIES_VAT_NUMBER_OPTIONAL, i as UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_OPTIONAL, n as LEGAL_ARRANGEMENT_COUNTRIES_REQUIRING_DATE_OF_INCORPORATION, o as UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_OPTIONAL, s as UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_REQUIRED, t as ALLOWED_UNINCORPORATED_PARTNERSHIP_COUNTRIES } from "./legalArrangementUtils-C68JdH6I.js";
+import { r as formatObject } from "./utils-DdHbAadK.js";
+import { o as nestAddressSchema } from "./AddressFields-BC3QHs2u.js";
+import { i as useScenarioConfiguration, r as getPageName, t as mapExistingFile } from "./mapExistingFile-BkwRTTRm.js";
+import { t as useTaskLandedEvent } from "./useTaskLandedEvent-DwZHcMEQ.js";
+import { n as isMaintenanceModeError, t as processValidationErrors } from "./processValidationErrors-CjsNfiRK.js";
+import { a as createDocumentRequest, o as documentApiUtils, s as getDocument } from "./validate-BZ1-ZeKr.js";
+import { i as getFieldsWithExistingData, t as PatriotActDisclosure } from "./PatriotActDisclosure-DqUZeLms.js";
+import { a as isValidationError } from "./validationError-DV6t8Ubb.js";
+import { t as NewSummary } from "./NewSummary-D55f70wB.js";
+import { _ as dateOfIncorporationFieldMetadata, a as defaultFieldConfig, c as REGISTRATION_AND_OPERATIONAL_ADDRESS_FIELDS, d as doingBusinessAsFieldMetadata, f as DBANameField, g as dateOfIncorporationFieldConfig, h as DateOfIncorporationField, i as getDefaultVatNumberType, l as RegistrationAndOperationalAddressFields, m as DATE_OF_INCORPORATION_FIELD, n as VAT_NUMBER_FIELD, o as defaultFieldMetadata, p as DBA_NAME_FIELD, r as VatNumberField, t as MemoizedConstitutionalDocument, u as doingBusinessAsAbsentFieldMetadata } from "./ConstitutionalDocument-Bxsr1hQb.js";
+import { useCallback, useEffect, useMemo, useState } from "preact/hooks";
+import { jsx, jsxs } from "preact/jsx-runtime";
+import { skipToken } from "@tanstack/preact-query";
+//#region src/components/Trust/mapping/mapApiDocumentToTrustDocument.ts
+var mapApiDocumentToTrustDocument = (entityId) => {
+	const constitutionalDocument = getDocument(entityId, "constitutionalDocument") || null;
+	return { trustConstitutionalDocument: constitutionalDocument ? { constitutionalDocument: [mapExistingFile(getPageName(constitutionalDocument))] } : void 0 };
+};
+//#endregion
+//#region src/components/UnincorporatedPartnership/mapping/unincorporatedPartnershipKeyMappings.ts
+var unincorporatedPartnershipBaseMapping = {
+	"trustRegistrationDetails.trustType": "unincorporatedPartnership.type",
+	"trustRegistrationDetails.legalName": "unincorporatedPartnership.name",
+	"trustRegistrationDetails.doingBusinessAs": "unincorporatedPartnership.doingBusinessAs",
+	"trustRegistrationDetails.hasDoingBusinessAs": "unincorporatedPartnership.doingBusinessAsAbsent",
+	"trustRegistrationDetails.country": "unincorporatedPartnership.countryOfGoverningLaw",
+	"trustRegistrationDetails.registrationNumber": "unincorporatedPartnership.registrationNumber",
+	"trustRegistrationDetails.taxInformation": "unincorporatedPartnership.taxInformation",
+	"trustRegistrationDetails.vatNumber": "unincorporatedPartnership.vatNumber",
+	"trustRegistrationDetails.dateOfIncorporation": "unincorporatedPartnership.dateOfIncorporation",
+	"trustRegistrationAddress.registrationAddressCity": "unincorporatedPartnership.registeredAddress.city",
+	"trustRegistrationAddress.registrationAddressCountry": "unincorporatedPartnership.registeredAddress.country",
+	"trustRegistrationAddress.registrationAddressPostalCode": "unincorporatedPartnership.registeredAddress.postalCode",
+	"trustRegistrationAddress.registrationAddressStateOrProvince": "unincorporatedPartnership.registeredAddress.stateOrProvince",
+	"trustRegistrationAddress.registrationAddressStreet": "unincorporatedPartnership.registeredAddress.street",
+	"trustRegistrationAddress.registrationAddressStreet2": "unincorporatedPartnership.registeredAddress.street2",
+	"trustRegistrationAddress.operationalAddressCity": "unincorporatedPartnership.principalPlaceOfBusiness.city",
+	"trustRegistrationAddress.operationalAddressCountry": "unincorporatedPartnership.principalPlaceOfBusiness.country",
+	"trustRegistrationAddress.operationalAddressPostalCode": "unincorporatedPartnership.principalPlaceOfBusiness.postalCode",
+	"trustRegistrationAddress.operationalAddressStateOrProvince": "unincorporatedPartnership.principalPlaceOfBusiness.stateOrProvince",
+	"trustRegistrationAddress.operationalAddressStreet": "unincorporatedPartnership.principalPlaceOfBusiness.street",
+	"trustRegistrationAddress.operationalAddressStreet2": "unincorporatedPartnership.principalPlaceOfBusiness.street2"
+};
+var unincorporatedPartnershipComponentsKeyMapping = {
+	"trustRegistrationDetails.exemptedFromVat": "unincorporatedPartnership.vatAbsenceReason",
+	...unincorporatedPartnershipBaseMapping
+};
+var unincorporatedPartnershipApiKeyMapping = { ...reverseMapping(unincorporatedPartnershipBaseMapping) };
+//#endregion
+//#region src/components/UnincorporatedPartnership/mapping/mapLegalEntityToUnincorporatedPartnership.ts
+var mapLegalEntityToUnincorporatedPartnership = (legalEntity, isFeatureEnabled) => {
+	if (!legalEntity.unincorporatedPartnership) throw new Error("LE missing unincorporatedPartnership field");
+	let trustCompData = formatObject(legalEntity, unincorporatedPartnershipComponentsKeyMapping);
+	if (!trustCompData?.trustRegistrationDetails) return {};
+	if (legalEntity.unincorporatedPartnership.countryOfGoverningLaw) trustCompData.trustRegistrationDetails.country = legalEntity.unincorporatedPartnership.countryOfGoverningLaw;
+	if (legalEntity.unincorporatedPartnership.description) trustCompData.trustRegistrationDetails.objectOfTrust = legalEntity.unincorporatedPartnership.description;
+	const operationalAddressIsSame = !(legalEntity.unincorporatedPartnership.principalPlaceOfBusiness && !objectsDeepEqual(legalEntity.unincorporatedPartnership.principalPlaceOfBusiness, legalEntity.unincorporatedPartnership.registeredAddress));
+	if (!trustCompData.trustRegistrationAddress) trustCompData.trustRegistrationAddress = {};
+	trustCompData.trustRegistrationAddress.operationalAddressIsSame = operationalAddressIsSame;
+	if (legalEntity.unincorporatedPartnership.taxInformation?.length) {
+		const { country } = legalEntity.unincorporatedPartnership.registeredAddress;
+		const countryTaxInformation = legalEntity.unincorporatedPartnership.taxInformation.find((info) => info.country === country);
+		if (countryTaxInformation?.type === "UEN") trustCompData.trustRegistrationDetails.isUen = true;
+		if (countryTaxInformation?.type === "GST") trustCompData.trustRegistrationDetails.isUen = false;
+		const taxNumberAbsent = countryTaxInformation?.numberAbsent;
+		if (taxNumberAbsent !== void 0) trustCompData.trustRegistrationDetails.exemptedFromTax = taxNumberAbsent;
+	}
+	if (legalEntity.documentDetails?.length) trustCompData = {
+		...trustCompData,
+		...mapApiDocumentToTrustDocument(legalEntity?.id)
+	};
+	if (isFeatureEnabled("EnableDoingBusinessAsNameV4")) {
+		if (typeof trustCompData.trustRegistrationDetails?.hasDoingBusinessAs === "boolean") {
+			trustCompData.trustRegistrationDetails.hasDoingBusinessAs = !legalEntity.unincorporatedPartnership.doingBusinessAsAbsent;
+			if (!trustCompData.trustRegistrationDetails.hasDoingBusinessAs) delete legalEntity.unincorporatedPartnership.doingBusinessAs;
+		}
+	} else {
+		trustCompData.trustRegistrationDetails.hasDoingBusinessAs = legalEntity.unincorporatedPartnership.doingBusinessAs ? legalEntity.unincorporatedPartnership.doingBusinessAs !== legalEntity.unincorporatedPartnership.name : void 0;
+		trustCompData.trustRegistrationDetails.doingBusinessAs = legalEntity.unincorporatedPartnership.doingBusinessAs;
+	}
+	return trustCompData;
+};
+//#endregion
+//#region src/components/UnincorporatedPartnership/mapping/mapUnincorporatedPartnershipToLegalEntity.ts
+var mapUnincorporatedPartnershipToLegalEntity = (data, isFeatureEnabled, existingLegalEntity) => {
+	const requestObj = { ...formatObject(data, unincorporatedPartnershipApiKeyMapping) };
+	if (!requestObj.unincorporatedPartnership) return requestObj;
+	if (requestObj.unincorporatedPartnership?.taxInformation?.[0]?.type === "GST") requestObj.unincorporatedPartnership.taxInformation[0].type = "UEN";
+	if (isFeatureEnabled("EnableDoingBusinessAsNameV4")) {
+		requestObj.unincorporatedPartnership.doingBusinessAsAbsent = typeof data.trustRegistrationDetails?.hasDoingBusinessAs !== "undefined" ? !data.trustRegistrationDetails?.hasDoingBusinessAs : void 0;
+		if (requestObj.unincorporatedPartnership.doingBusinessAsAbsent) requestObj.unincorporatedPartnership.doingBusinessAs = "";
+	} else {
+		delete requestObj.unincorporatedPartnership?.doingBusinessAsAbsent;
+		requestObj.unincorporatedPartnership.doingBusinessAs = data.trustRegistrationDetails?.doingBusinessAs || data.trustRegistrationDetails?.legalName;
+	}
+	if (data.trustRegistrationAddress?.operationalAddressIsSame) if (!existingLegalEntity?.unincorporatedPartnership?.principalPlaceOfBusiness) delete requestObj.unincorporatedPartnership.principalPlaceOfBusiness;
+	else requestObj.unincorporatedPartnership.principalPlaceOfBusiness = requestObj.unincorporatedPartnership.registeredAddress;
+	requestObj.type = "unincorporatedPartnership";
+	return requestObj;
+};
+//#endregion
+//#region src/components/Trust/forms/TrustRegistrationDetails/TrustRegistrationDetails.tsx
+var TRUST_REGISTRATION_DETAILS_FIELDS = [
+	"legalName",
+	...DBA_NAME_FIELD,
+	"country",
+	"trustType",
+	"objectOfTrust",
+	...TAX_INFORMATION_FIELD,
+	...BUSINESS_REGISTRATION_NUMBER_FIELD,
+	...VAT_NUMBER_FIELD,
+	...DATE_OF_INCORPORATION_FIELD
+];
+var ALLOWED_TRUST_COUNTRIES = [CountryCodes.Australia, CountryCodes.NewZealand];
+function TrustRegistrationDetails({ id, fieldValidationErrors = {}, formVerificationErrors = {}, shouldValidate, taskType, country: parentLegalEntityCountry }) {
+	const { t } = useTranslation(["common", "trust"]);
+	const { form } = useFormContext();
+	const { data, valid, errors, allFields, trustedFields, obscuredFields, optionalFields, requiredFields } = useMemo(() => {
+		return {
+			data: form.data.trustRegistrationDetails ?? {},
+			valid: form.valid.trustRegistrationDetails ?? {},
+			errors: form.errors.trustRegistrationDetails ?? {},
+			allFields: form.allFields?.trustRegistrationDetails ?? [],
+			trustedFields: form.trustedFields?.trustRegistrationDetails ?? [],
+			obscuredFields: form.obscuredFields?.trustRegistrationDetails ?? [],
+			optionalFields: form.optionalFields?.trustRegistrationDetails ?? [],
+			requiredFields: form.requiredFields?.trustRegistrationDetails ?? []
+		};
+	}, [form]);
+	const country = data?.country ?? parentLegalEntityCountry;
+	const trustTypeOptions = getCountrySpecificTrustTypeOptions(country) ?? [];
+	const isUnincorporatedPartnership = taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP;
+	const legalEntityType = isUnincorporatedPartnership ? "unincorporatedPartnership" : "trust";
+	const handleChange = (fieldName, mode) => form.handleChangeFor("trustRegistrationDetails", fieldName, mode);
+	const changeTrustType = (e) => {
+		handleChange("trustType", "blur")(e);
+		if (e.target.value !== "charitableTrust") form.setData("trustRegistrationDetails", "objectOfTrust", void 0);
+	};
+	const formUtils = useMemo(() => {
+		const initialProps = {
+			data,
+			valid,
+			errors,
+			fieldValidationErrors,
+			formVerificationErrors,
+			allFields,
+			trustedFields,
+			obscuredFields,
+			optionalFields,
+			requiredFields
+		};
+		const formUtilProps = initialProps?.allFields?.reduce((acc, field) => {
+			switch (field) {
+				case "hasDoingBusinessAs": return mergeFieldMetadataIntoProps("hasDoingBusinessAs", doingBusinessAsAbsentFieldMetadata, acc);
+				case "doingBusinessAs": return mergeFieldMetadataIntoProps("doingBusinessAs", doingBusinessAsFieldMetadata, acc);
+				case "registrationNumber": return mergeFieldMetadataIntoProps("registrationNumber", resolveFieldMetadata(registrationNumberDefaultFieldConfig[country], {
+					companyType: legalEntityType,
+					registrationNumberType: data.registrationNumberType
+				}, registrationNumberDefaultFieldMetadata), acc);
+				case "exemptedFromRegistrationNumber": return mergeFieldMetadataIntoProps("exemptedFromRegistrationNumber", resolveFieldMetadata(exemptFromRegistrationNumberDefaultFieldConfig[country], {}, exemptFromRegistrationNumberDefaultFieldMetadata), acc);
+				case "vatNumber": return mergeFieldMetadataIntoProps("vatNumber", resolveFieldMetadata(defaultFieldConfig[country], { vatNumberType: data?.vatNumberType }, defaultFieldMetadata), acc);
+				case "dateOfIncorporation": return mergeFieldMetadataIntoProps("dateOfIncorporation", resolveFieldMetadata(dateOfIncorporationFieldConfig[country], {}, dateOfIncorporationFieldMetadata), acc);
+				default: return acc;
+			}
+		}, initialProps);
+		return createFormUtils(formUtilProps ?? initialProps, t);
+	}, [
+		t,
+		allFields,
+		country,
+		data,
+		errors,
+		fieldValidationErrors,
+		formVerificationErrors,
+		legalEntityType,
+		obscuredFields,
+		optionalFields,
+		requiredFields,
+		trustedFields,
+		valid
+	]);
+	const showField = (fieldNames) => fieldNames.some((fieldName) => formUtils.isRequiredField(fieldName) || formUtils.isOptionalField(fieldName));
+	return /* @__PURE__ */ jsxs("form", {
+		id,
+		children: [
+			/* @__PURE__ */ jsx(Header, { title: t(($) => $["registrationDetails"], { ns: "common" }) }),
+			/* @__PURE__ */ jsx(ErrorPanel, {
+				verificationErrors: formVerificationErrors,
+				validationErrors: fieldValidationErrors,
+				formUtils,
+				id: "ariaErrorField"
+			}),
+			!isUnincorporatedPartnership && /* @__PURE__ */ jsx(Alert, {
+				variant: "info",
+				title: /* @__PURE__ */ jsx(Typography, {
+					variant: "caption",
+					color: "secondary",
+					children: t(($) => $["makeSureToHaveYourTrustDeed"], { ns: "trust" })
+				}),
+				className: "u-margin-bottom-16"
+			}),
+			showField(COUNTRY_FIELD) && /* @__PURE__ */ jsx(CountryField, {
+				data: formUtils.getFieldData(data, COUNTRY_FIELD),
+				valid: formUtils.getFieldValid(valid, COUNTRY_FIELD),
+				errors: formUtils.getFieldErrors(errors, fieldValidationErrors, COUNTRY_FIELD),
+				labels: formUtils.getFieldLabels(COUNTRY_FIELD, { country: "countryRegionOfEstablishment" }),
+				readonly: formUtils.isReadOnly("country"),
+				allowedCountries: isUnincorporatedPartnership ? ALLOWED_UNINCORPORATED_PARTNERSHIP_COUNTRIES : ALLOWED_TRUST_COUNTRIES,
+				handleChangeFor: () => (e) => {
+					handleChange("country", "input")(e);
+				}
+			}),
+			showField(["legalName"]) && /* @__PURE__ */ jsx(Field, {
+				name: "legalName",
+				label: formUtils.getLabel(isUnincorporatedPartnership ? "legalName" : "nameOfTrustAgreement"),
+				errorMessage: formUtils.getErrorMessage("legalName", errors, fieldValidationErrors),
+				isValid: valid?.legalName,
+				children: (childProps) => /* @__PURE__ */ jsx(InputText, {
+					...childProps,
+					name: "legalName",
+					value: data?.legalName,
+					readonly: formUtils.isReadOnly("legalName"),
+					onInput: handleChange("legalName", "input"),
+					onBlur: handleChange("legalName", "blur"),
+					"aria-required": true,
+					"aria-invalid": !valid?.legalName
+				})
+			}),
+			showField(["hasDoingBusinessAs"]) && /* @__PURE__ */ jsx(DBANameField, {
+				data: formUtils.getFieldData(data, DBA_NAME_FIELD),
+				valid: formUtils.getFieldValid(valid, DBA_NAME_FIELD),
+				errors: formUtils.getFieldErrors(errors, fieldValidationErrors, DBA_NAME_FIELD),
+				readonly: formUtils.isReadOnly("doingBusinessAs"),
+				handleChangeFor: handleChange
+			}),
+			showField(["trustType"]) && !isUnincorporatedPartnership && /* @__PURE__ */ jsx(Field, {
+				name: "trustType",
+				label: formUtils.getLabel("trustType", "typeOfTrustAgreement"),
+				errorMessage: formUtils.getErrorMessage("trustType", errors, fieldValidationErrors),
+				isValid: valid?.trustType,
+				dataTestId: "trust-type",
+				children: (childProps) => /* @__PURE__ */ jsx(Select, {
+					...childProps,
+					name: "trustType",
+					onChange: changeTrustType,
+					selected: data?.trustType,
+					items: trustTypeOptions.map((trust) => ({
+						id: trust,
+						name: t(($) => $[trust], { ns: "trust" })
+					})),
+					placeholder: t(($) => $["trustType"], { ns: "trust" })
+				})
+			}),
+			showField(["objectOfTrust"]) && /* @__PURE__ */ jsx(Field, {
+				name: "objectOfTrust",
+				label: formUtils.getLabel("objectOfCharitableTrust"),
+				helper: formUtils.getLabel("pleaseProvideThePurposeOfCharitableTrust"),
+				errorMessage: formUtils.getErrorMessage("objectOfTrust", errors, fieldValidationErrors),
+				isValid: valid?.objectOfTrust,
+				children: (childProps) => /* @__PURE__ */ jsx(InputText, {
+					...childProps,
+					name: "objectOfTrust",
+					value: data?.objectOfTrust,
+					readonly: formUtils.isReadOnly("objectOfTrust"),
+					onInput: handleChange("objectOfTrust", "input"),
+					onBlur: handleChange("objectOfTrust", "blur"),
+					"aria-required": true,
+					"aria-invalid": !valid?.objectOfTrust
+				})
+			}),
+			showField(TAX_INFORMATION_FIELD) && /* @__PURE__ */ jsx(TaxInformationField, {
+				data: formUtils.getFieldData(data, TAX_INFORMATION_FIELD),
+				valid: formUtils.getFieldValid(valid, TAX_INFORMATION_FIELD),
+				errors: formUtils.getFieldErrors(errors, fieldValidationErrors, TAX_INFORMATION_FIELD),
+				readonly: formUtils.isReadOnly("taxInformation"),
+				shouldValidate,
+				handleChangeFor: handleChange,
+				optional: formUtils.isOptionalField("taxInformation"),
+				canExempt: formUtils.isRequiredField("exemptedFromTax"),
+				country,
+				entityType: legalEntityType,
+				defaultData: data?.taxInformation,
+				registrationNumber: data.registrationNumber
+			}),
+			showField(BUSINESS_REGISTRATION_NUMBER_FIELD) && /* @__PURE__ */ jsx(BusinessRegistrationNumberField, {
+				data: formUtils.getFieldData(data, BUSINESS_REGISTRATION_NUMBER_FIELD),
+				valid: formUtils.getFieldValid(valid, BUSINESS_REGISTRATION_NUMBER_FIELD),
+				errors: formUtils.getFieldErrors(errors, fieldValidationErrors, BUSINESS_REGISTRATION_NUMBER_FIELD),
+				readonly: formUtils.isReadOnly("registrationNumber"),
+				optional: formUtils.isOptionalField("registrationNumber"),
+				shouldValidate,
+				handleChangeFor: handleChange,
+				country,
+				canExempt: formUtils.isRequiredField("exemptedFromRegistrationNumber"),
+				companyType: legalEntityType
+			}),
+			showField(VAT_NUMBER_FIELD) && /* @__PURE__ */ jsx(VatNumberField, {
+				data: formUtils.getFieldData(data, VAT_NUMBER_FIELD),
+				valid: formUtils.getFieldValid(valid, VAT_NUMBER_FIELD),
+				errors: formUtils.getFieldErrors(errors, fieldValidationErrors, VAT_NUMBER_FIELD),
+				labels: formUtils.getFieldLabels(VAT_NUMBER_FIELD, { exemptedFromVat: "iDontHaveAVatNumber" }),
+				optional: formUtils.isOptionalField("vatNumber"),
+				readonly: formUtils.isReadOnly("vatNumber"),
+				handleChangeFor: handleChange,
+				country,
+				canExempt: formUtils.isRequiredField("exemptedFromVat")
+			}),
+			showField(DATE_OF_INCORPORATION_FIELD) && /* @__PURE__ */ jsx(DateOfIncorporationField, {
+				data: formUtils.getFieldData(data, DATE_OF_INCORPORATION_FIELD),
+				valid: formUtils.getFieldValid(valid, DATE_OF_INCORPORATION_FIELD),
+				errors: formUtils.getFieldErrors(errors, fieldValidationErrors, DATE_OF_INCORPORATION_FIELD),
+				readonly: formUtils.isReadOnly("dateOfIncorporation"),
+				handleChangeFor: handleChange,
+				country
+			}),
+			country === "US" && /* @__PURE__ */ jsx(PatriotActDisclosure, {})
+		]
+	});
+}
+//#endregion
+//#region src/components/Trust/forms/Trust/forms.ts
+var trustForms = {
+	trustRegistrationDetails: {
+		formId: "trustRegistrationDetails",
+		formName: "registrationDetails",
+		fields: TRUST_REGISTRATION_DETAILS_FIELDS
+	},
+	trustRegistrationAddress: {
+		formId: "trustRegistrationAddress",
+		formName: "addressDetails",
+		fields: REGISTRATION_AND_OPERATIONAL_ADDRESS_FIELDS
+	},
+	trustConstitutionalDocument: {
+		formId: "trustConstitutionalDocument",
+		formName: "constitutionalDocument",
+		fields: ["constitutionalDocument"]
+	}
+};
+var trustRegistrationDetailsFormId = trustForms.trustRegistrationDetails.formId;
+var trustRegistrationAddressFormId = trustForms.trustRegistrationAddress.formId;
+var trustConstitutionalDocumentFormId = trustForms.trustConstitutionalDocument.formId;
+//#endregion
+//#region src/components/Trust/forms/Trust/rules.ts
+var COUNTRIES_THAT_USE_REGISTRATION_NUMBER = [CountryCodes.NewZealand];
+var rules = ({ data, country, taskType }) => {
+	const addressFieldRule = (field, isOperational) => {
+		if (isOperational && data.trustRegistrationAddress?.operationalAddressIsSame) return void 0;
+		if (field === "country") return "REQUIRED";
+		if (!getAddressSchemaForCountry(country).includes(field)) return void 0;
+		if (field === "street2") return "OPTIONAL";
+		if (field === "stateOrProvince") return COUNTRIES_WITH_STATES_DATASET.includes(country) ? "REQUIRED" : void 0;
+		return "REQUIRED";
+	};
+	return createFormRules({
+		countryUsesTaxId: () => {
+			if (taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP) {
+				if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_REQUIRED.includes(country)) return "REQUIRED";
+				if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_OPTIONAL.includes(country)) return "OPTIONAL";
+			}
+			if (country !== CountryCodes.NewZealand && COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT.includes(country)) return "REQUIRED";
+		},
+		countryRequiresRegistrationNumberForTrust: () => {
+			if (taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP) {
+				if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_REQUIRED.includes(country)) return "REQUIRED";
+				if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_OPTIONAL.includes(country)) return "OPTIONAL";
+			}
+			if (COUNTRIES_THAT_USE_REGISTRATION_NUMBER.includes(country)) return "REQUIRED";
+		},
+		registrationNumberType: () => {
+			if (taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP) {
+				if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_REQUIRED.includes(country)) return "OPTIONAL";
+				if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_OPTIONAL.includes(country)) return "OPTIONAL";
+			}
+			if (COUNTRIES_THAT_USE_REGISTRATION_NUMBER.includes(country)) return "OPTIONAL";
+		},
+		countryUsesVatNumber: () => {
+			if (taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP) {
+				if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_VAT_NUMBER_OPTIONAL.includes(country)) return "OPTIONAL";
+			}
+		},
+		trustTypeHasDescription: () => {
+			if (data?.trustRegistrationDetails?.trustType === "charitableTrust") return "REQUIRED";
+		},
+		requireDoingBusinessAsName: () => {
+			return data?.trustRegistrationDetails?.hasDoingBusinessAs ? "REQUIRED" : void 0;
+		},
+		requiresTrustType: () => {
+			if (taskType === TaskTypes.TRUST) return "REQUIRED";
+		},
+		requireDateOfIncorporation: () => {
+			if (LEGAL_ARRANGEMENT_COUNTRIES_REQUIRING_DATE_OF_INCORPORATION.includes(country)) return "REQUIRED";
+		},
+		registrationAddressStreetRequired: () => addressFieldRule("street", false),
+		registrationAddressStreet2Required: () => addressFieldRule("street2", false),
+		registrationAddressCityRequired: () => addressFieldRule("city", false),
+		registrationAddressPostalCodeRequired: () => addressFieldRule("postalCode", false),
+		registrationAddressStateOrProvinceRequired: () => addressFieldRule("stateOrProvince", false),
+		registrationAddressCountryRequired: () => addressFieldRule("country", false),
+		operationalAddressStreetRequired: () => addressFieldRule("street", true),
+		operationalAddressStreet2Required: () => addressFieldRule("street2", true),
+		operationalAddressCityRequired: () => addressFieldRule("city", true),
+		operationalAddressPostalCodeRequired: () => addressFieldRule("postalCode", true),
+		operationalAddressStateOrProvinceRequired: () => addressFieldRule("stateOrProvince", true),
+		operationalAddressCountryRequired: () => addressFieldRule("country", true)
+	});
+};
+var TrustRegistrationAddress_module_default = {
+	"additional-details-content": "_additional-details-content_nh4dq_1",
+	additionalDetailsContent: "_additional-details-content_nh4dq_1"
+};
+//#endregion
+//#region src/components/Trust/forms/TrustRegistrationAddress/TrustRegistrationAddress.tsx
+function TrustRegistrationAddress({ id, country, fieldValidationErrors, formVerificationErrors, taskType }) {
+	const { t } = useTranslation(["common", "trust"]);
+	const { form } = useFormContext();
+	const entityType = taskType === TaskTypes.TRUST ? "trust" : "partnership";
+	const { data, valid, errors, allFields, requiredFields, optionalFields, trustedFields, obscuredFields, handleChange: handleChangeFor } = getFormSlice(form, "trustRegistrationAddress");
+	const formUtils = useMemo(() => {
+		return createFormUtils({
+			data: data ?? {},
+			fieldValidationErrors,
+			formVerificationErrors,
+			allFields: allFields ?? [],
+			requiredFields: requiredFields ?? [],
+			optionalFields: optionalFields ?? [],
+			trustedFields: trustedFields ?? [],
+			obscuredFields: obscuredFields ?? [],
+			errors: errors ?? {},
+			valid: valid ?? {},
+			handleFieldChange: handleChangeFor
+		}, t);
+	}, [
+		allFields,
+		data,
+		errors,
+		fieldValidationErrors,
+		formVerificationErrors,
+		handleChangeFor,
+		obscuredFields,
+		optionalFields,
+		requiredFields,
+		t,
+		trustedFields,
+		valid
+	]);
+	return /* @__PURE__ */ jsxs("form", {
+		id,
+		children: [
+			/* @__PURE__ */ jsx(Header, {
+				title: t(($) => $["trustRegistrationAddressFormHeading"], { ns: "trust" }),
+				children: /* @__PURE__ */ jsx("div", {
+					slot: "description",
+					children: t(($) => $["trustRegistrationAddressFormDescription"], {
+						entityType,
+						ns: "trust"
+					})
+				})
+			}),
+			/* @__PURE__ */ jsx(ErrorPanel, {
+				id: "ariaErrorField",
+				verificationErrors: formVerificationErrors,
+				validationErrors: fieldValidationErrors,
+				formUtils
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: TrustRegistrationAddress_module_default.additionalDetailsContent,
+				children: /* @__PURE__ */ jsx(RegistrationAndOperationalAddressFields, {
+					entityType,
+					country,
+					data,
+					valid,
+					errors,
+					requiredFields,
+					optionalFields,
+					trustedFields,
+					fieldValidationErrors,
+					handleChangeFor,
+					formUtils
+				})
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/Trust/forms/Trust/Trust.tsx
+function Trust({ taskType, country, activeForm, shouldValidate, problems = {} }) {
+	const { form } = useFormContext();
+	const isUnincorporatedPartnership = taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP;
+	function handleChange(formName, fieldName, mode) {
+		return form.handleChangeFor(formName, fieldName, mode);
+	}
+	const fieldValidationErrors = problems.validationErrors?.[activeForm.formId];
+	const formVerificationErrors = problems.verificationErrors?.[activeForm.formId];
+	const renderActiveForm = (activeForm) => {
+		switch (activeForm.formId) {
+			case trustRegistrationDetailsFormId: return /* @__PURE__ */ jsx(TrustRegistrationDetails, {
+				id: activeForm.formId,
+				country,
+				shouldValidate,
+				taskType,
+				fieldValidationErrors,
+				formVerificationErrors
+			});
+			case trustRegistrationAddressFormId: return /* @__PURE__ */ jsx(TrustRegistrationAddress, {
+				id: trustRegistrationAddressFormId,
+				taskType,
+				country,
+				fieldValidationErrors,
+				formVerificationErrors
+			});
+			case trustConstitutionalDocumentFormId: return /* @__PURE__ */ jsx(MemoizedConstitutionalDocument, {
+				id: activeForm.formId,
+				legalEntityType: isUnincorporatedPartnership ? "unincorporatedPartnership" : "trust",
+				country,
+				data: form.data?.trustConstitutionalDocument,
+				errors: form.errors.trustConstitutionalDocument,
+				valid: form.valid.trustConstitutionalDocument,
+				allFields: form.allFields?.trustConstitutionalDocument,
+				requiredFields: form.requiredFields?.trustConstitutionalDocument,
+				optionalFields: form.optionalFields?.trustConstitutionalDocument,
+				trustedFields: form.trustedFields?.trustConstitutionalDocument,
+				handleFieldChange: () => handleChange("trustConstitutionalDocument", "constitutionalDocument"),
+				shouldValidate,
+				fieldValidationErrors,
+				formVerificationErrors
+			});
+			default: return null;
+		}
+	};
+	return /* @__PURE__ */ jsx("div", { children: renderActiveForm(activeForm) });
+}
+//#endregion
+//#region src/components/Trust/mapping/mapLegalEntityToTrust.ts
+var mapLegalEntityToTrust = (legalEntity, isFeatureEnabled) => {
+	if (!legalEntity.trust) throw new Error("LE missing trust field");
+	let trustCompData = formatObject(legalEntity, trustComponentsKeyMapping);
+	if (!trustCompData?.trustRegistrationDetails) return {};
+	const countryOfGoverningLaw = legalEntity.trust.countryOfGoverningLaw;
+	trustCompData.trustRegistrationDetails.vatNumberType = getDefaultVatNumberType(legalEntity.trust.vatNumber, countryOfGoverningLaw);
+	trustCompData.trustRegistrationDetails.registrationNumberType = getDefaultRegistrationNumberType(legalEntity.trust.registrationNumber, countryOfGoverningLaw, "trust");
+	trustCompData.trustRegistrationDetails.country = countryOfGoverningLaw;
+	if (legalEntity.trust.description) trustCompData.trustRegistrationDetails.objectOfTrust = legalEntity.trust.description;
+	const operationalAddressIsSame = !(legalEntity.trust.principalPlaceOfBusiness && !objectsDeepEqual(legalEntity.trust.principalPlaceOfBusiness, legalEntity.trust.registeredAddress));
+	if (!trustCompData.trustRegistrationAddress) trustCompData.trustRegistrationAddress = {};
+	trustCompData.trustRegistrationAddress.operationalAddressIsSame = operationalAddressIsSame;
+	if (legalEntity.trust.taxInformation?.length) {
+		const { country } = legalEntity.trust.registeredAddress;
+		const countryTaxInformation = legalEntity.trust.taxInformation.find((info) => info.country === country);
+		if (countryTaxInformation?.type === "UEN") trustCompData.trustRegistrationDetails.isUen = true;
+		if (countryTaxInformation?.type === "GST") trustCompData.trustRegistrationDetails.isUen = false;
+		const taxNumberAbsent = countryTaxInformation?.numberAbsent;
+		if (taxNumberAbsent !== void 0) trustCompData.trustRegistrationDetails.exemptedFromTax = taxNumberAbsent;
+	}
+	if (legalEntity.documentDetails?.length) trustCompData = {
+		...trustCompData,
+		...mapApiDocumentToTrustDocument(legalEntity?.id)
+	};
+	if (isFeatureEnabled("EnableDoingBusinessAsNameV4")) {
+		if (typeof trustCompData.trustRegistrationDetails?.hasDoingBusinessAs === "boolean") {
+			trustCompData.trustRegistrationDetails.hasDoingBusinessAs = !legalEntity.trust.doingBusinessAsAbsent;
+			if (!trustCompData.trustRegistrationDetails.hasDoingBusinessAs) delete legalEntity.trust?.doingBusinessAs;
+		}
+	} else {
+		trustCompData.trustRegistrationDetails.hasDoingBusinessAs = legalEntity.trust.doingBusinessAs ? legalEntity.trust.doingBusinessAs !== legalEntity.trust.name : void 0;
+		trustCompData.trustRegistrationDetails.doingBusinessAs = legalEntity.trust.doingBusinessAs;
+	}
+	return trustCompData;
+};
+//#endregion
+//#region src/components/Trust/mapping/mapTrustDocumentToApiDocument.ts
+var mapTrustDocumentToApiDocument = async (data, entityId) => {
+	const constitutionalDocument = data?.trustConstitutionalDocument?.constitutionalDocument;
+	if (!constitutionalDocument) throw new Error("Constitutional document missing");
+	const page1 = constitutionalDocument[0];
+	if (!page1) throw new Error("Document needs at least one page");
+	return await createDocumentRequest({
+		entityId,
+		entityType: "legalEntity",
+		documentType: "constitutionalDocument",
+		page1,
+		existingDocument: getDocument(entityId, "constitutionalDocument")
+	});
+};
+//#endregion
+//#region src/components/Trust/mapping/mapTrustToLegalEntity.ts
+var mapTrustToLegalEntity = (data, isFeatureEnabled, existingLegalEntity) => {
+	const requestObj = { ...formatObject(data, trustApiKeyMapping) };
+	if (!requestObj.trust) return requestObj;
+	if (data.trustRegistrationDetails?.objectOfTrust) requestObj.trust.description = data.trustRegistrationDetails.objectOfTrust;
+	if (isFeatureEnabled("EnableDoingBusinessAsNameV4")) {
+		requestObj.trust.doingBusinessAsAbsent = typeof data.trustRegistrationDetails?.hasDoingBusinessAs !== "undefined" ? !data.trustRegistrationDetails?.hasDoingBusinessAs : void 0;
+		if (requestObj.trust.doingBusinessAsAbsent) requestObj.trust.doingBusinessAs = "";
+	} else {
+		delete requestObj.trust?.doingBusinessAsAbsent;
+		requestObj.trust.doingBusinessAs = data.trustRegistrationDetails?.doingBusinessAs || data.trustRegistrationDetails?.legalName;
+	}
+	if (data.trustRegistrationAddress?.operationalAddressIsSame) if (!existingLegalEntity?.trust?.principalPlaceOfBusiness) delete requestObj.trust.principalPlaceOfBusiness;
+	else requestObj.trust.principalPlaceOfBusiness = requestObj.trust.registeredAddress;
+	requestObj.type = "trust";
+	return requestObj;
+};
+//#endregion
+//#region src/components/Trust/utils/formatDataForSummary.ts
+function createStructuredListItem(term, details, t) {
+	if (!details) return;
+	return {
+		term: t(($) => $[term], { ns: "common" }),
+		details
+	};
+}
+function formatTrustRegistrationDetails(data, datasetUtils, isUnincorporatedPartnership, t) {
+	const country = data.country;
+	const taxInfoForCountry = data.taxInformation?.find((taxInfo) => taxInfo.country === country);
+	let taxIdLabel = "taxInformationNumber";
+	if (country in taxIdNumberOptions) {
+		const numberOption = taxIdNumberOptions[country]?.find((taxOption) => taxOption.id === taxInfoForCountry?.type);
+		if (numberOption) taxIdLabel = numberOption.name;
+	}
+	const registrationNumberLabel = resolveFieldMetadata(registrationNumberDefaultFieldConfig[country], {
+		companyType: "trust",
+		registrationNumberType: data.registrationNumber ? inferCompanyRegistrationNumberType(data.registrationNumber, country, "trust") : getCompanyRegistrationNumberOptions(country, "trust")?.[0]?.id
+	}, registrationNumberDefaultFieldMetadata).label ?? "";
+	return {
+		[isUnincorporatedPartnership ? "legalName" : "nameOfTrustAgreement"]: data.legalName,
+		doingBusinessAs: data.doingBusinessAs,
+		countryRegionOfEstablishment: datasetUtils.getCountryName(country),
+		typeOfTrustAgreement: data.trustType && !isUnincorporatedPartnership ? t(($) => $[data.trustType], { ns: "trust" }) : void 0,
+		objectOfTrust: data.objectOfTrust,
+		[taxIdLabel]: taxInfoForCountry?.number,
+		[registrationNumberLabel]: data.registrationNumber,
+		[resolveFieldMetadata(dateOfIncorporationFieldConfig[country], {}, dateOfIncorporationFieldMetadata).label ?? "dateOfIncorporation"]: data.dateOfIncorporation
+	};
+}
+function formatDataForSummary(data, forms, t, language, taskType) {
+	const OMITTED_FORMS = ["summary"];
+	const datasetUtils = datasetUtilities(language);
+	const isUnincorporatedPartnership = taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP;
+	const getSummaryItemsForForm = (formId) => {
+		if (!data[formId]) return {};
+		switch (formId) {
+			case "trustRegistrationDetails": return formatTrustRegistrationDetails(data[formId], datasetUtils, isUnincorporatedPartnership, t);
+			case "trustConstitutionalDocument": return {
+				fileName: data[formId]?.constitutionalDocument?.[0]?.name,
+				description: data[formId].description
+			};
+			default: return {};
+		}
+	};
+	const translateAndFilterMappedSummary = (data) => {
+		const tmp = [];
+		for (const summaryItem in data) {
+			const item = createStructuredListItem(summaryItem, data[summaryItem], t);
+			if (item) tmp.push(item);
+		}
+		return tmp;
+	};
+	const summarySectionData = [];
+	for (const form of forms) {
+		if (OMITTED_FORMS.includes(form.formId)) continue;
+		const summaryItems = translateAndFilterMappedSummary(getSummaryItemsForForm(form.formId));
+		if (summaryItems.length > 0) summarySectionData.push({
+			formId: form.formId,
+			label: t(($) => $[form.formName], { ns: "common" }),
+			items: summaryItems
+		});
+		if (form.formId === "trustRegistrationAddress") {
+			const registrationAddressSummaryItems = translateAndFilterMappedSummary(mapAddressLabelsNewSummary(nestAddressSchema("registrationAddress", data.trustRegistrationAddress), datasetUtils));
+			if (registrationAddressSummaryItems.length > 0) summarySectionData.push({
+				formId: "registrationAddress",
+				label: t(($) => $["registrationAddress"], { ns: "common" }),
+				items: registrationAddressSummaryItems
+			});
+			if (!data[form.formId]?.operationalAddressIsSame) {
+				const operationalAddressSummaryItems = translateAndFilterMappedSummary(mapAddressLabelsNewSummary(nestAddressSchema("operationalAddress", data.trustRegistrationAddress), datasetUtils));
+				if (operationalAddressSummaryItems.length > 0) summarySectionData.push({
+					formId: "operationalAddress",
+					label: t(($) => $["operationalAddress"], { ns: "common" }),
+					items: operationalAddressSummaryItems
+				});
+			}
+		}
+	}
+	return summarySectionData;
+}
+//#endregion
+//#region src/components/Trust/tasks/TrustDropin/trustFormConfig.ts
+var trustBase = {
+	trustType: { rule: "requiresTrustType" },
+	objectOfTrust: { rule: "trustTypeHasDescription" },
+	legalName: { rule: "REQUIRED" },
+	hasDoingBusinessAs: { rule: "REQUIRED" },
+	doingBusinessAs: { rule: "requireDoingBusinessAsName" },
+	country: { rule: "REQUIRED" },
+	taxInformation: { rule: "countryUsesTaxId" },
+	constitutionalDocument: { rule: "REQUIRED" },
+	registrationNumber: { rule: "countryRequiresRegistrationNumberForTrust" },
+	registrationNumberType: { rule: "registrationNumberType" },
+	vatNumber: { rule: "countryUsesVatNumber" },
+	vatNumberType: { rule: "countryUsesVatNumber" },
+	dateOfIncorporation: { rule: "requireDateOfIncorporation" },
+	operationalAddressIsSame: { rule: "REQUIRED" },
+	registrationAddressStreet: { rule: "registrationAddressStreetRequired" },
+	registrationAddressStreet2: { rule: "registrationAddressStreet2Required" },
+	registrationAddressCity: { rule: "registrationAddressCityRequired" },
+	registrationAddressPostalCode: { rule: "registrationAddressPostalCodeRequired" },
+	registrationAddressStateOrProvince: { rule: "registrationAddressStateOrProvinceRequired" },
+	registrationAddressCountry: { rule: "registrationAddressCountryRequired" },
+	operationalAddressStreet: { rule: "operationalAddressStreetRequired" },
+	operationalAddressStreet2: { rule: "operationalAddressStreet2Required" },
+	operationalAddressCity: { rule: "operationalAddressCityRequired" },
+	operationalAddressPostalCode: { rule: "operationalAddressPostalCodeRequired" },
+	operationalAddressStateOrProvince: { rule: "operationalAddressStateOrProvinceRequired" },
+	operationalAddressCountry: { rule: "operationalAddressCountryRequired" }
+};
+var trustFieldsPerScenario = {
+	L0: { ...trustBase },
+	L1: { ...trustBase },
+	L: { ...trustBase }
+};
+var trustCountryConfig = {};
+//#endregion
+//#region src/components/Trust/forms/TrustRegistrationDetails/validate.ts
+var trustRegistrationDetailsValidations = {
+	trustType: {
+		modes: ["blur"],
+		validate: (trustType) => !!trustType,
+		errorMessage: "fieldIsRequired"
+	},
+	country: {
+		modes: ["blur"],
+		validate: (country) => !!country,
+		errorMessage: "fieldIsRequired"
+	},
+	legalName: {
+		modes: ["blur"],
+		validate: (legalName) => !!legalName,
+		errorMessage: "fieldIsRequired"
+	},
+	objectOfTrust: {
+		modes: ["blur"],
+		validate: (objectOfTrust) => !!objectOfTrust,
+		errorMessage: "fieldIsRequired"
+	},
+	hasDoingBusinessAs: validateNotEmptyOnBlur,
+	doingBusinessAs: validateNotEmptyOnBlur
+};
+var trustRegistrationDetailsValidationsV4 = {
+	trustType: {
+		modes: ["blur"],
+		validate: (trustType) => !!trustType,
+		errorMessage: "fieldIsRequired"
+	},
+	country: {
+		modes: ["blur"],
+		validate: (country) => !!country,
+		errorMessage: "fieldIsRequired"
+	},
+	legalName: [
+		{
+			modes: ["blur"],
+			validate: hasText,
+			errorMessage: "fieldIsRequired"
+		},
+		{
+			modes: ["blur"],
+			validate: (input) => !matchesRegex(NO_ALPHABET_REGEX, input),
+			errorMessage: "nameMustContainLetters"
+		},
+		{
+			modes: ["blur"],
+			validate: (input) => !matchesRegex(EMOJI_REGEX, input) && !hasRepeatedCharacters(input) && isValidMinLength(input, 3) && !isInvalidName(input) && matchesRegex(OTHER_ENTITIES_VALID_CHAR_REGEX, input),
+			errorMessage: "checkForTypos"
+		}
+	],
+	objectOfTrust: {
+		modes: ["blur"],
+		validate: (objectOfTrust) => !!objectOfTrust,
+		errorMessage: "fieldIsRequired"
+	},
+	hasDoingBusinessAs: validateNotEmptyOnBlur,
+	doingBusinessAs: validateNotEmptyOnBlur
+};
+//#endregion
+//#region src/components/Trust/tasks/TrustDropin/validate.ts
+function trustRegistrationDetailsValidators(country, trustRegistrationDetails = {}, isFeatureEnabled) {
+	const defaultTrustRegistrationDetailsValidators = isFeatureEnabled("StrictNameAndAddressValidationV4") ? trustRegistrationDetailsValidationsV4 : trustRegistrationDetailsValidations;
+	const { registrationNumberType, taxInformation, vatNumberType } = trustRegistrationDetails;
+	return {
+		...defaultTrustRegistrationDetailsValidators,
+		hasDoingBusinessAs: doingBusinessAsAbsentFieldMetadata.validators,
+		doingBusinessAs: doingBusinessAsFieldMetadata.validators,
+		dateOfIncorporation: dateOfIncorporationFieldMetadata.validators,
+		taxInformation: resolveFieldMetadata(taxInformationDefaultFieldConfig[country], {
+			taxIdNumberType: taxInformation?.find((taxId) => taxId.country === country)?.type,
+			companyType: "trust"
+		}, taxInformationDefaultFieldMetadata)?.validators,
+		exemptedFromTax: resolveFieldMetadata(exemptedFromTaxDefaultFieldConfig[country], {}, exemptedFromTaxDefaultFieldMetadata)?.validators,
+		registrationNumber: resolveFieldMetadata(registrationNumberDefaultFieldConfig[country], {
+			companyType: "trust",
+			registrationNumberType,
+			isFeatureEnabled
+		}, registrationNumberDefaultFieldMetadata)?.validators,
+		exemptedFromRegistrationNumber: resolveFieldMetadata(exemptFromRegistrationNumberDefaultFieldConfig[country], {}, exemptFromRegistrationNumberDefaultFieldMetadata)?.validators,
+		vatNumber: resolveFieldMetadata(defaultFieldConfig[country], { vatNumberType }, defaultFieldMetadata)?.validators
+	};
+}
+//#endregion
+//#region src/components/Trust/tasks/TrustDropin/TrustDropin.tsx
+var parseTrustScenarios = (scenarios, country) => augmentWithCountryConfigs(trustCountryConfig[country], composePerScenarioFormConfigurations(scenarios, trustFieldsPerScenario));
+var parseConfiguration = ({ scenarios, country }) => parseTrustScenarios(scenarios, country);
+function TrustDropin({ parentLegalEntity, country: countryProp, existingTrust, taskType, problems: problemsProp, onSubmit: externalOnSubmit, handleHomeClick }) {
+	const { baseUrl, rootLegalEntityId } = useApiContext();
+	const { t, i18n } = useTranslation(["common", "trust"]);
+	const [validationErrors, setValidationErrors] = useState();
+	const { isFeatureEnabled } = useToggleContext();
+	const { showToast } = useToastContext();
+	const [loadingStatus, setLoadingStatus] = useState("success");
+	const [country, setCountry] = useState(countryProp);
+	const isUnincorporatedPartnership = taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP;
+	const problems = useMemo(() => ({
+		...problemsProp,
+		validationErrors
+	}), [problemsProp, validationErrors]);
+	const [initialData, setInitialData] = useState(useMemo(() => {
+		if (!existingTrust) return { trustRegistrationDetails: { country: countryProp } };
+		return isUnincorporatedPartnership ? mapLegalEntityToUnincorporatedPartnership(existingTrust, isFeatureEnabled) : mapLegalEntityToTrust(existingTrust, isFeatureEnabled);
+	}, [
+		isFeatureEnabled,
+		existingTrust,
+		isUnincorporatedPartnership,
+		countryProp
+	]));
+	const documentUtils = documentApiUtils({
+		baseUrl: baseUrl.value,
+		rootLegalEntityId: rootLegalEntityId.value
+	});
+	/**
+	* Analytics
+	*/
+	useTaskLandedEvent(taskType);
+	useEffect(() => {
+		if (!existingTrust?.documentDetails?.length) return;
+		documentUtils.fetchDocuments(existingTrust.documentDetails, existingTrust.id).then(() => {
+			const mappedDocuments = mapApiDocumentToTrustDocument(existingTrust.id);
+			setInitialData((prev) => ({
+				...prev,
+				...mappedDocuments
+			}));
+		}).catch(() => {
+			showToast({
+				label: t(($) => $["failedToFetchRelevantDocuments"]),
+				variant: "error"
+			});
+		});
+	}, []);
+	const [derivedProps, setDerivedProps] = useState();
+	const buildTrustValidations = useCallback((data) => {
+		return { trustRegistrationDetails: trustRegistrationDetailsValidators(country, data?.trustRegistrationDetails, isFeatureEnabled) };
+	}, [country, isFeatureEnabled]);
+	const multiForm = useMultiForm({
+		defaultData: initialData,
+		allFields: derivedProps?.allFields,
+		requiredFields: derivedProps?.requiredFields,
+		optionalFields: derivedProps?.optionalFields,
+		obscuredFields: derivedProps?.obscuredFields,
+		trustedFields: derivedProps?.trustedFields,
+		rules: buildTrustValidations
+	});
+	/**
+	* Fetch Configurations
+	*/
+	const { fieldConfigurations } = useScenarioConfiguration({
+		parseConfiguration,
+		legalEntityType: "trust",
+		setLoadingStatus,
+		country
+	});
+	const fieldsFromCustomRules = useMemo(() => rules({
+		data: multiForm.data,
+		country,
+		taskType
+	}), [
+		country,
+		multiForm.data,
+		taskType
+	]);
+	useEffect(() => {
+		const props = getPropsFromConfigurations({
+			scenarioConfiguration: fieldConfigurations,
+			forms: trustForms,
+			remediationActions: problems?.remediationActions ? Object.values(problems?.remediationActions) : [],
+			dataMissingErrors: problems?.missingData ?? [],
+			fieldsWithExistingData: existingTrust ? getFieldsWithExistingData(existingTrust, trustApiKeyMapping, trustDocumentMapping) : [],
+			customRules: fieldsFromCustomRules,
+			legalEntityType: existingTrust?.type
+		});
+		setDerivedProps(props);
+	}, [
+		fieldConfigurations,
+		problems?.remediationActions,
+		problems?.missingData,
+		existingTrust,
+		fieldsFromCustomRules
+	]);
+	/**
+	* Current country value must be kept in sync with what is selected in basicInformation form
+	*/
+	const [prevCountry, setPrevCountry] = useState(multiForm.data.trustRegistrationDetails?.country);
+	if (multiForm.data.trustRegistrationDetails?.country && prevCountry !== multiForm.data.trustRegistrationDetails?.country) {
+		setCountry(multiForm.data?.trustRegistrationDetails?.country ?? countryProp);
+		setPrevCountry(multiForm.data.trustRegistrationDetails?.country);
+	}
+	const forms = useMemo(() => {
+		return addValidityToForms(getRequiredForms(trustForms, derivedProps?.requiredFields, derivedProps?.optionalFields), multiForm.isValid, problems);
+	}, [
+		derivedProps,
+		multiForm.isValid,
+		problems
+	]);
+	const onSubmitTrust = async () => {
+		setLoadingStatus("loading");
+		const trustDetails = mapTrustToLegalEntity(multiForm.data, isFeatureEnabled, existingTrust);
+		try {
+			const updatedTrust = await submitTrustDetails(trustDetails);
+			await submitDocuments({
+				forms,
+				legalEntity: updatedTrust,
+				dataSubmitted: multiForm.data
+			});
+			await attachTrustToParentLegalEntity(updatedTrust);
+			setLoadingStatus("success");
+			showToast({
+				label: t(($) => $["successfullyUpdatedDetails"]),
+				variant: "success"
+			});
+			externalOnSubmit?.(multiForm.data);
+		} catch (e) {
+			if (isValidationError(e)) setValidationErrors(processValidationErrors(e, taskType));
+			else if (isMaintenanceModeError(e)) showToast({
+				label: t(($) => $["maintenanceModeMessage"]),
+				variant: "error",
+				duration: "indefinite"
+			});
+			else showToast({
+				label: t(($) => $["failedToUpdateDetails"]),
+				variant: "error"
+			});
+			setLoadingStatus("success");
+		}
+	};
+	const onSubmitUnincorporatedPartnership = async () => {
+		setLoadingStatus("loading");
+		const unincorporatedPartnershipDetails = mapUnincorporatedPartnershipToLegalEntity(multiForm.data, isFeatureEnabled, existingTrust);
+		try {
+			const updatedUnincorporatedPartnershipDetails = await submitTrustDetails(unincorporatedPartnershipDetails);
+			await submitDocuments({
+				forms,
+				legalEntity: updatedUnincorporatedPartnershipDetails,
+				dataSubmitted: multiForm.data
+			});
+			await attachTrustToParentLegalEntity(updatedUnincorporatedPartnershipDetails);
+			setLoadingStatus("success");
+			showToast({
+				label: t(($) => $["successfullyUpdatedDetails"]),
+				variant: "success"
+			});
+			externalOnSubmit?.(multiForm.data);
+		} catch (e) {
+			if (isValidationError(e)) setValidationErrors(processValidationErrors(e, taskType));
+			else if (isMaintenanceModeError(e)) showToast({
+				label: t(($) => $["maintenanceModeMessage"]),
+				variant: "error",
+				duration: "indefinite"
+			});
+			else showToast({
+				label: t(($) => $["failedToUpdateDetails"]),
+				variant: "error"
+			});
+			setLoadingStatus("success");
+		}
+	};
+	const { mutateAsync: createLegalEntity } = useCreateLegalEntity();
+	const { mutateAsync: updateLegalEntity } = useUpdateLegalEntity();
+	const submitTrustDetails = async (legalEntity) => {
+		if (!existingTrust) return await createLegalEntity(legalEntity);
+		else return await updateLegalEntity({
+			...drop("type").from(legalEntity),
+			id: existingTrust.id
+		});
+	};
+	const submitDocuments = async ({ forms, legalEntity, dataSubmitted }) => {
+		if (isDocumentsRequired(forms)) {
+			const formattedDocument = await mapTrustDocumentToApiDocument(dataSubmitted, legalEntity.id);
+			if (formattedDocument) await documentUtils.uploadDocuments([formattedDocument], legalEntity.id);
+		}
+	};
+	const isDocumentsRequired = (forms) => forms.some((form) => form.formId === trustForms.trustConstitutionalDocument.formId);
+	const attachTrustToParentLegalEntity = async (trust) => {
+		if (existingTrust?.id) return;
+		const existingEntityAssociations = getOwnEntityAssociations(parentLegalEntity);
+		const updatedParentLegalEntity = { entityAssociations: [{
+			type: trust.type,
+			legalEntityId: trust.id
+		}, ...existingEntityAssociations] };
+		await updateLegalEntity({
+			...updatedParentLegalEntity,
+			id: parentLegalEntity.id
+		});
+	};
+	const { handleNextClick, handleBackClick, activeForm, shouldValidate, gotoFormByFormIndex, gotoFormByFormId, steps } = useFormComposer({
+		problems,
+		forms,
+		onSubmit: isUnincorporatedPartnership ? onSubmitUnincorporatedPartnership : onSubmitTrust,
+		triggerValidation: multiForm.triggerValidation
+	});
+	const summarySections = useMemo(() => {
+		if (activeForm.formId !== "summary") return [];
+		return formatDataForSummary(multiForm.data, forms, t, i18n.language, taskType);
+	}, [
+		activeForm.formId,
+		multiForm.data,
+		forms,
+		t,
+		i18n.language,
+		taskType
+	]);
+	const handleEditForm = (formId) => {
+		if (formId === "registrationAddress" || formId === "operationalAddress") {
+			const addressFormIdx = forms.findIndex((form) => form.formId === "trustRegistrationAddress");
+			if (addressFormIdx > -1) gotoFormByFormIndex(addressFormIdx);
+			return;
+		}
+		const formIdx = forms.findIndex((form) => form.formId === formId);
+		if (formIdx > -1) gotoFormByFormIndex(formIdx);
+	};
+	const allValidationErrors = {};
+	for (const form in problems.validationErrors) for (const validationError in problems.validationErrors[form]) allValidationErrors[validationError] = problems.validationErrors[form][validationError];
+	const allVerificationErrors = {};
+	for (const form in problems.verificationErrors) for (const verificationError in problems.verificationErrors[form]) allVerificationErrors[verificationError] = problems.verificationErrors[form][verificationError];
+	return /* @__PURE__ */ jsx(FormContextProvider, {
+		form: multiForm,
+		children: /* @__PURE__ */ jsx(FormFlow, {
+			summaryComponent: /* @__PURE__ */ jsx(NewSummary, {
+				sections: summarySections,
+				handleEditForm,
+				children: /* @__PURE__ */ jsx(ErrorPanel, {
+					validationErrors: allValidationErrors,
+					verificationErrors: allVerificationErrors,
+					formUtils: createFormUtils({ labels: {} }, t),
+					id: "ariaErrorField",
+					slot: "errorPanel"
+				})
+			}),
+			currentStep: steps.current,
+			totalSteps: steps.total,
+			forms,
+			activeForm,
+			gotoFormByFormIndex,
+			gotoFormByFormId,
+			handleNextClick,
+			handleBackClick,
+			handleCancelClick: handleHomeClick,
+			loadingStatus,
+			children: /* @__PURE__ */ jsx(Trust, {
+				taskType,
+				activeForm,
+				country,
+				shouldValidate,
+				problems
+			})
+		})
+	});
+}
+//#endregion
+//#region src/components/Trust/pages/TrustDetailsPage.tsx
+var TrustDetailsPage = ({ taskType, trustId, handleHomeClick, onSubmit }) => {
+	const { i18n } = useTranslation();
+	const { data: rootLe } = useLegalEntity(ROOT_LE);
+	const { data: associatedEntity, isLoading: isAssociatedEntityLoading } = useAssociatedLegalEntity(rootLe, taskType === "TRUST" ? "trust" : "unincorporatedPartnership");
+	const { data: trustLeFromProp, isLoading: isTrustLeFromPropLoading } = useLegalEntity(trustId ?? skipToken);
+	const trustLe = trustLeFromProp ?? associatedEntity;
+	addResourceBundles(i18n, [{
+		ns: "trust",
+		importFn: (lang) => _rolldown_dynamic_import_helper_default(/* #__PURE__ */ Object.assign({
+			"../language/bg-BG.json": () => import("./bg-BG-DFFyUYhz.js"),
+			"../language/cs-CZ.json": () => import("./cs-CZ-DbxpNCVt.js"),
+			"../language/da-DK.json": () => import("./da-DK-zLJRzcB1.js"),
+			"../language/de-DE.json": () => import("./de-DE-BMfqDClD.js"),
+			"../language/el-GR.json": () => import("./el-GR-RfSX8m4j.js"),
+			"../language/en-US.json": () => import("./en-US-CO9xzDL5.js"),
+			"../language/es-ES.json": () => import("./es-ES-CYw82sbG.js"),
+			"../language/es-LA.json": () => import("./es-LA-DDXEJd1M.js"),
+			"../language/et-EE.json": () => import("./et-EE-BlZkCwz8.js"),
+			"../language/fi-FI.json": () => import("./fi-FI-CNoPIGJP.js"),
+			"../language/fr-FR.json": () => import("./fr-FR-CQZLvhS1.js"),
+			"../language/hr-HR.json": () => import("./hr-HR-C6-nBPZJ.js"),
+			"../language/hu-HU.json": () => import("./hu-HU-CKm1kMo5.js"),
+			"../language/it-IT.json": () => import("./it-IT-DjUFw9e_.js"),
+			"../language/ja-JP.json": () => import("./ja-JP-Ce_xNqZj.js"),
+			"../language/lt-LT.json": () => import("./lt-LT-BQD7QWIk.js"),
+			"../language/lv-LV.json": () => import("./lv-LV-DHwdYWGZ.js"),
+			"../language/nl-NL.json": () => import("./nl-NL-Cdmgljzx.js"),
+			"../language/no-NO.json": () => import("./no-NO-MhaaDGft.js"),
+			"../language/pl-PL.json": () => import("./pl-PL-B0tX08_r.js"),
+			"../language/pt-BR.json": () => import("./pt-BR-CExpeuK1.js"),
+			"../language/pt-PT.json": () => import("./pt-PT-CedGAyU5.js"),
+			"../language/ro-RO.json": () => import("./ro-RO-C-lRWe1h.js"),
+			"../language/sk-SK.json": () => import("./sk-SK-D1duuBif.js"),
+			"../language/sl-SI.json": () => import("./sl-SI-iGtJR9Tk.js"),
+			"../language/sv-SE.json": () => import("./sv-SE-9GnBnxvb.js")
+		}), `../language/${lang}.json`, 3)
+	}]);
+	const capabilityProblems = useCapabilityProblems();
+	const problems = capabilityProblems && trustLe?.id ? getProblemsForEntity(capabilityProblems, "LegalEntity", trustLe.id) : void 0;
+	if (!rootLe || isAssociatedEntityLoading || isTrustLeFromPropLoading) return /* @__PURE__ */ jsx(Loader, {});
+	return /* @__PURE__ */ jsx(TrustDropin, {
+		taskType,
+		problems,
+		existingTrust: trustLe,
+		parentLegalEntity: rootLe,
+		country: getLegalEntityCountry(trustLe ?? rootLe),
+		handleHomeClick,
+		onSubmit
+	});
+};
+//#endregion
+export { TrustDetailsPage };