@adyen/kyc-components 4.19.1 → 4.20.0-beta.0

package/dist/{TrustDetailsPage-k3accZEy.js → TrustDetailsPage-BQjA8lmD.js}

@@ -1,66 +1,48 @@
 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] = "6ec54be0-1e66-423b-9da3-61dc6c1470fc", e._sentryDebugIdIdentifier = "sentry-dbid-6ec54be0-1e66-423b-9da3-61dc6c1470fc");
+	n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "df2067d0-a883-477c-95e4-896fdfcf999b", e._sentryDebugIdIdentifier = "sentry-dbid-df2067d0-a883-477c-95e4-896fdfcf999b");
 } catch (e) {}
-import { i as Typography, n as addResourceBundles, r as useTranslation } from "./translation-CcKrUksA.js";
-import { $ as hasRepeatedCharacters, A as _rolldown_dynamic_import_helper_default, D as useCapabilities, H as NO_ALPHABET_REGEX, T as datasetUtilities, W as OTHER_ENTITIES_VALID_CHAR_REGEX, et as hasText, h as getCountrySpecificTrustTypeOptions, it as isInvalidName, j as useToggleContext, k as Header, ot as isValidMinLength, st as matchesRegex, x as Alert, z as EMOJI_REGEX } from "./resolveEnvironment-C1htMD-5.js";
-import { r as Loader } from "./Button-BuhgDsyo.js";
-import { s as useApiContext } from "./http-CFac2y4i.js";
-import { r as useLegalEntity, t as ROOT_LE } from "./useLegalEntity-BqO7Fmt0.js";
+import { i as Typography, n as addResourceBundles, r as useTranslation } from "./translation-DH4IlMCP.js";
+import { $ as hasRepeatedCharacters, A as _rolldown_dynamic_import_helper_default, D as useCapabilities, H as NO_ALPHABET_REGEX, T as datasetUtilities, W as OTHER_ENTITIES_VALID_CHAR_REGEX, et as hasText, h as getCountrySpecificTrustTypeOptions, it as isInvalidName, j as useToggleContext, k as Header, ot as isValidMinLength, st as matchesRegex, x as Alert, z as EMOJI_REGEX } from "./resolveEnvironment-df20S4SQ.js";
+import { r as Loader } from "./Button-Cm7cT6BX.js";
+import { s as useApiContext } from "./http-D6AdUBhO.js";
+import { r as useLegalEntity, t as ROOT_LE } from "./useLegalEntity-DR51Q4mE.js";
 import { t as LegalEntityTypes } from "./legal-entity-type-0MfCGzUf.js";
 import { t as getLegalEntityCountry } from "./getLegalEntityCountry-BHh7Ux8v.js";
-import { c as keysOf, i as drop, n as cloneObject } from "./AnalyticsContext-BnRQ9H1u.js";
+import { c as keysOf, i as drop, o as objectsDeepEqual } from "./AnalyticsContext-BnRQ9H1u.js";
 import { t as CountryCodes } from "./country-code-CJk2hdPu.js";
-import { C as EntityTypes, a as trustComponentsKeyMapping, i as trustApiKeyMapping, o as trustDocumentMapping, y as reverseMapping } from "./processCapabilities-zti_0yUx.js";
+import { C as EntityTypes, a as trustComponentsKeyMapping, i as trustApiKeyMapping, o as trustDocumentMapping, y as reverseMapping } from "./processCapabilities-BSpmJOEd.js";
 import { t as TaskTypes } from "./taskTypes-3vSkMBDm.js";
 import { s as getOwnEntityAssociations } from "./entityAssociationUtil-DLXInibJ.js";
-import { i as getPropsFromConfigurations, n as augmentWithCountryConfigs, r as composePerScenarioFormConfigurations, t as createFormRules } from "./form-rules-wh_oE1AN.js";
-import { t as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-DB8HCSwp.js";
-import { r as useToastContext } from "./useId-DpmZnb6I.js";
-import { n as useCapabilityProblems, t as getProblemsForEntity } from "./getProblemsForEntity-set4Krmx.js";
-import { r as Field, t as Select } from "./Select-yOtg-61e.js";
-import { C as FormContextProvider, a as getRequiredForms, b as createFormUtils, c as useMultiForm, d as useFormComposer, i as addValidityToForms, n as CountryField, o as FormFlow, r as useFormContext, t as COUNTRY_FIELD, x as mergeFieldMetadataIntoProps } from "./CountryField-uue7DBeg.js";
-import { t as ErrorPanel } from "./ErrorPanel-CCn1oJPR.js";
-import { t as useCreateLegalEntity } from "./useCreateLegalEntity-CVBjJUw_.js";
-import { t as useUpdateLegalEntity } from "./useUpdateLegalEntity-CsXfjS5u.js";
-import { i as useScenarioConfiguration, r as getPageName, t as mapExistingFile } from "./mapExistingFile-BOXehUNN.js";
-import { t as useTaskLandedEvent } from "./useTaskLandedEvent-BTVaABDA.js";
-import { i as mapAddressLabels } from "./utils-G00RnEDX.js";
-import { n as isMaintenanceModeError, t as processValidationErrors } from "./processValidationErrors-J6ltKXc4.js";
-import { a as createDocumentRequest, o as documentApiUtils, s as getDocument } from "./validate-K01plHbc.js";
+import { i as getPropsFromConfigurations, n as augmentWithCountryConfigs, r as composePerScenarioFormConfigurations, t as createFormRules } from "./form-rules-DV3hxYqZ.js";
+import { t as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-CzQlHWXy.js";
+import { r as useToastContext } from "./useId-po-YSdTw.js";
+import { n as useCapabilityProblems, t as getProblemsForEntity } from "./getProblemsForEntity-DStlTvE-.js";
+import { r as Field, t as Select } from "./Select-B5Mo0Bpw.js";
+import { C as FormContextProvider, a as getRequiredForms, b as createFormUtils, c as useMultiForm, d as useFormComposer, i as addValidityToForms, n as CountryField, o as FormFlow, r as useFormContext, t as COUNTRY_FIELD, x as mergeFieldMetadataIntoProps } from "./CountryField-DQnWXgAu.js";
+import { t as ErrorPanel } from "./ErrorPanel-C2hG0lLe.js";
+import { t as getFormSlice } from "./getFormSlice-C1ma6Xd4.js";
+import { t as useCreateLegalEntity } from "./useCreateLegalEntity-Ctdmk3Ky.js";
+import { t as useUpdateLegalEntity } from "./useUpdateLegalEntity-CH4xp654.js";
+import { i as useScenarioConfiguration, r as getPageName, t as mapExistingFile } from "./mapExistingFile-LvvzPjnk.js";
+import { t as useTaskLandedEvent } from "./useTaskLandedEvent-C7fcguXK.js";
+import { a as mapAddressLabelsNewSummary, c as COUNTRIES_WITH_STATES_DATASET, t as getAddressSchemaForCountry } from "./utils-C8WDAzsL.js";
+import { n as isMaintenanceModeError, t as processValidationErrors } from "./processValidationErrors-PJV6CPG2.js";
+import { a as createDocumentRequest, o as documentApiUtils, s as getDocument } from "./validate-BNu91k9j.js";
 import { r as formatObject } from "./utils-DdHbAadK.js";
-import { n as TAX_INFORMATION_FIELD, o as getFieldsWithExistingData, r as TaxInformationField, t as PatriotActDisclosure } from "./PatriotActDisclosure-DO1km-aw.js";
-import { a as isValidationError } from "./validationError-vnqptK-a.js";
-import { a as validateNotEmptyOnBlur } from "./patternValidators-D8HZxfV2.js";
-import { A as taxInformationDefaultFieldMetadata, D as exemptedFromTaxDefaultFieldMetadata, E as exemptedFromTaxDefaultFieldConfig, d as COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT, k as taxInformationDefaultFieldConfig } from "./utils-BfxOnNjg.js";
+import { n as TAX_INFORMATION_FIELD, o as getFieldsWithExistingData, r as TaxInformationField, t as PatriotActDisclosure } from "./PatriotActDisclosure-CB0N3iIz.js";
+import { a as isValidationError } from "./validationError-1dpZJlAz.js";
+import { a as validateNotEmptyOnBlur } from "./patternValidators-tRq-KPvW.js";
+import { A as taxInformationDefaultFieldMetadata, D as exemptedFromTaxDefaultFieldMetadata, E as exemptedFromTaxDefaultFieldConfig, T as taxIdNumberOptions, d as COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT, k as taxInformationDefaultFieldConfig } from "./utils-BbBPfcNK.js";
 import { t as resolveFieldMetadata } from "./fieldConfigurations-CZCFghnK.js";
-import "./Dropzone-CvQDmVPr.js";
-import "./useForm-DgKB0Jpl.js";
-import { r as getFormProps } from "./getProps-DVqK7eRw.js";
-import { t as InputText } from "./InputText-CRkApOKK.js";
-import { t as RadioGroup } from "./RadioGroup-B9MFxAgn.js";
-import { t as Address } from "./Address-B_QN7vdN.js";
-import { t as ContextGuidance } from "./ContextGuidance-BBQsTVLG.js";
-import { c as getRegistrationNumberHelperText, i as getCompanyRegistrationNumberOptions, l as registrationNumberDefaultFieldConfig, n as getDefaultRegistrationNumberType, o as exemptFromRegistrationNumberDefaultFieldConfig, r as inferCompanyRegistrationNumberType, s as exemptFromRegistrationNumberDefaultFieldMetadata, u as registrationNumberDefaultFieldMetadata } from "./CompanyRegistrationNumberTypeSelector-DYJ2XeCC.js";
-import { _ as doingBusinessAsFieldMetadata, c as BusinessRegistrationNumberField, d as VatNumberField, f as getDefaultVatNumberType, g as doingBusinessAsAbsentFieldMetadata, l as MemoizedConstitutionalDocument, m as defaultFieldMetadata, p as defaultFieldConfig, s as BUSINESS_REGISTRATION_NUMBER_FIELD, t as countryToTaxInfoTypeMap, u as VAT_NUMBER_FIELD, v as DBANameField, y as DBA_NAME_FIELD } from "./utils-CLsECypA.js";
+import { t as InputText } from "./InputText-Cf9ccCaj.js";
+import { t as NewSummary } from "./NewSummary-DDwQJV7w.js";
+import { c as getRegistrationNumberHelperText, i as getCompanyRegistrationNumberOptions, l as registrationNumberDefaultFieldConfig, n as getDefaultRegistrationNumberType, o as exemptFromRegistrationNumberDefaultFieldConfig, r as inferCompanyRegistrationNumberType, s as exemptFromRegistrationNumberDefaultFieldMetadata, u as registrationNumberDefaultFieldMetadata } from "./CompanyRegistrationNumberTypeSelector-KkPiHDQk.js";
+import { _ as DBA_NAME_FIELD, a as VatNumberField, c as defaultFieldMetadata, d as RegistrationAndOperationalAddressFields, g as DBANameField, h as doingBusinessAsFieldMetadata, i as VAT_NUMBER_FIELD, m as doingBusinessAsAbsentFieldMetadata, n as BusinessRegistrationNumberField, o as getDefaultVatNumberType, p as nestAddressSchema, r as MemoizedConstitutionalDocument, s as defaultFieldConfig, t as BUSINESS_REGISTRATION_NUMBER_FIELD, u as REGISTRATION_AND_OPERATIONAL_ADDRESS_FIELDS } from "./BusinessRegistrationNumberField-DGBqMCwU.js";
 import { a as UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_REQUIRED, i as UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_OPTIONAL, n as UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_OPTIONAL, o as UNINCORPORATED_PARTNERSHIP_COUNTRIES_VAT_NUMBER_OPTIONAL, r as UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_REQUIRED, t as ALLOWED_UNINCORPORATED_PARTNERSHIP_COUNTRIES } from "./types-Bm4RGrSI.js";
-import { useCallback, useEffect, useMemo, useRef, useState } from "preact/hooks";
-import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState } from "preact/hooks";
+import { jsx, jsxs } from "preact/jsx-runtime";
 import { skipToken } from "@tanstack/preact-query";
-import "preact";
-//#region src/components/Shared/forms/RegistrationAddress/types.ts
-var operationalAddressIsSameIds = {
-	OPERATIONAL_ADDRESS_IS_SAME: "OperationAddressAnswerYes",
-	OPERATIONAL_ADDRESS_IS_NOT_SAME: "OperationAddressAnswerNo"
-};
-var operationalAddressIsSameItems = [{
-	id: operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_SAME,
-	name: "operationalAddressIsSameItemName"
-}, {
-	id: operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME,
-	name: "operationalAddressIsNotSameItemName"
-}];
-//#endregion
 //#region src/components/Trust/mapping/mapApiDocumentToTrustDocument.ts
 var mapApiDocumentToTrustDocument = (entityId) => {
 	const constitutionalDocument = getDocument(entityId, "constitutionalDocument") || null;
@@ -77,18 +59,18 @@ var unincorporatedPartnershipBaseMapping = {
 	"trustRegistrationDetails.registrationNumber": "unincorporatedPartnership.registrationNumber",
 	"trustRegistrationDetails.taxInformation": "unincorporatedPartnership.taxInformation",
 	"trustRegistrationDetails.vatNumber": "unincorporatedPartnership.vatNumber",
-	"trustRegistrationAddress.registrationAddress.city": "unincorporatedPartnership.registeredAddress.city",
-	"trustRegistrationAddress.registrationAddress.country": "unincorporatedPartnership.registeredAddress.country",
-	"trustRegistrationAddress.registrationAddress.postalCode": "unincorporatedPartnership.registeredAddress.postalCode",
-	"trustRegistrationAddress.registrationAddress.stateOrProvince": "unincorporatedPartnership.registeredAddress.stateOrProvince",
-	"trustRegistrationAddress.registrationAddress.street": "unincorporatedPartnership.registeredAddress.street",
-	"trustRegistrationAddress.registrationAddress.street2": "unincorporatedPartnership.registeredAddress.street2",
-	"trustRegistrationAddress.operationalAddress.city": "unincorporatedPartnership.principalPlaceOfBusiness.city",
-	"trustRegistrationAddress.operationalAddress.country": "unincorporatedPartnership.principalPlaceOfBusiness.country",
-	"trustRegistrationAddress.operationalAddress.postalCode": "unincorporatedPartnership.principalPlaceOfBusiness.postalCode",
-	"trustRegistrationAddress.operationalAddress.stateOrProvince": "unincorporatedPartnership.principalPlaceOfBusiness.stateOrProvince",
-	"trustRegistrationAddress.operationalAddress.street": "unincorporatedPartnership.principalPlaceOfBusiness.street",
-	"trustRegistrationAddress.operationalAddress.street2": "unincorporatedPartnership.principalPlaceOfBusiness.street2"
+	"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",
@@ -103,11 +85,9 @@ var mapLegalEntityToUnincorporatedPartnership = (legalEntity, isFeatureEnabled)
 	if (!trustCompData?.trustRegistrationDetails) return {};
 	trustCompData.trustRegistrationDetails.country = legalEntity.unincorporatedPartnership.countryOfGoverningLaw;
 	if (legalEntity.unincorporatedPartnership.description) trustCompData.trustRegistrationDetails.objectOfTrust = legalEntity.unincorporatedPartnership.description;
-	if (legalEntity.unincorporatedPartnership.principalPlaceOfBusiness) trustCompData.trustRegistrationAddress.operationalAddressIsSame = operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME;
-	else {
-		if (!trustCompData.trustRegistrationAddress) trustCompData.trustRegistrationAddress = {};
-		trustCompData.trustRegistrationAddress.operationalAddressIsSame = operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_SAME;
-	}
+	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);
@@ -133,59 +113,84 @@ var mapLegalEntityToUnincorporatedPartnership = (legalEntity, isFeatureEnabled)
 };
 //#endregion
 //#region src/components/UnincorporatedPartnership/mapping/mapUnincorporatedPartnershipToLegalEntity.ts
-var mapUnincorporatedPartnershipToLegalEntity = (data, isFeatureEnabled) => {
+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")) {
-		if (typeof data.trustRegistrationDetails?.hasDoingBusinessAs !== "undefined") requestObj.unincorporatedPartnership.doingBusinessAsAbsent = !data.trustRegistrationDetails?.hasDoingBusinessAs;
+		requestObj.unincorporatedPartnership.doingBusinessAsAbsent = typeof data.trustRegistrationDetails?.hasDoingBusinessAs !== "undefined" ? !data.trustRegistrationDetails?.hasDoingBusinessAs : void 0;
+		if (requestObj.unincorporatedPartnership.doingBusinessAsAbsent) requestObj.unincorporatedPartnership.doingBusinessAs = "";
 	} else {
-		requestObj.unincorporatedPartnership.doingBusinessAs = data.trustRegistrationDetails?.doingBusinessAs || data.trustRegistrationDetails?.legalName || "";
-		delete requestObj.unincorporatedPartnership.doingBusinessAsAbsent;
+		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 = LegalEntityTypes.UNINCORPORATED_PARTNERSHIP;
 	return requestObj;
 };
 //#endregion
 //#region src/components/Trust/forms/Trust/rules.ts
 var COUNTRIES_THAT_USE_REGISTRATION_NUMBER = [CountryCodes.NewZealand];
-var rules = ({ data, country, taskType }) => 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";
-	}
-});
+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";
+		},
+		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)
+	});
+};
 //#endregion
 //#region src/components/Trust/mapping/mapLegalEntityToTrust.ts
 var mapLegalEntityToTrust = (legalEntity, isFeatureEnabled) => {
@@ -196,11 +201,9 @@ var mapLegalEntityToTrust = (legalEntity, isFeatureEnabled) => {
 	trustCompData.trustRegistrationDetails.registrationNumberType = getDefaultRegistrationNumberType(legalEntity.trust.registrationNumber, legalEntity.trust.countryOfGoverningLaw, LegalEntityTypes.TRUST);
 	trustCompData.trustRegistrationDetails.country = legalEntity.trust.countryOfGoverningLaw;
 	if (legalEntity.trust.description) trustCompData.trustRegistrationDetails.objectOfTrust = legalEntity.trust.description;
-	if (legalEntity.trust.principalPlaceOfBusiness) trustCompData.trustRegistrationAddress.operationalAddressIsSame = operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME;
-	else {
-		if (!trustCompData.trustRegistrationAddress) trustCompData.trustRegistrationAddress = {};
-		trustCompData.trustRegistrationAddress.operationalAddressIsSame = operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_SAME;
-	}
+	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);
@@ -241,7 +244,7 @@ var mapTrustDocumentToApiDocument = async (data, entityId) => {
 };
 //#endregion
 //#region src/components/Trust/mapping/mapTrustToLegalEntity.ts
-var mapTrustToLegalEntity = (data, isFeatureEnabled) => {
+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;
@@ -252,139 +255,169 @@ var mapTrustToLegalEntity = (data, isFeatureEnabled) => {
 		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 = LegalEntityTypes.TRUST;
 	return requestObj;
 };
 //#endregion
-//#region src/components/Shared/forms/RegistrationAddress/RegistrationAddress.tsx
-var registrationAddressFields = [
-	"registrationAddress",
-	"operationalAddress",
-	"operationalAddressIsSame"
-];
-var registrationAddressForms = {
-	registrationAddress: {
-		formId: "registrationAddress",
-		formName: "registeredAddress",
-		fields: ["address"]
-	},
-	operationalAddress: {
-		formId: "operationalAddress",
-		formName: "operationalAddressHeader",
-		fields: ["address"]
-	}
-};
-registrationAddressForms.registrationAddress.formId;
-registrationAddressForms.operationalAddress.formId;
-//#endregion
-//#region src/components/Shared/forms/RegistrationAddress/RegistrationAddressMultiform.tsx
-var registrationAddressFormID = {
-	registrationAddress: {
-		formId: "registrationAddress",
-		formName: "registeredAddress",
-		fields: ["address"]
-	},
-	operationalAddress: {
-		formId: "operationalAddress",
-		formName: "operationalAddressHeader",
-		fields: ["address"]
+//#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;
 	}
-}.registrationAddress.formId;
-function RegistrationAddressMultiform(props) {
-	const { t } = useTranslation("common");
-	const { id, heading, description, country, problems } = props;
-	const { form } = useFormContext();
-	const data = form.data.trustRegistrationAddress;
-	const { requiredFields: registrationAddressRequiredFields, optionalFields: registrationAddressOptionalFields, readOnlyFields: registrationAddressReadOnlyFields, obscuredFields: registrationAddressObscuredFields, verifyFields: registrationAddressVerifyFields, trustedFields: registrationAddressTrustedFields } = getFormProps(props, registrationAddressFormID);
-	const formUtils = createFormUtils({
-		...props,
-		requiredFields: registrationAddressRequiredFields,
-		optionalFields: registrationAddressOptionalFields,
-		readOnlyFields: registrationAddressReadOnlyFields,
-		obscuredFields: registrationAddressObscuredFields,
-		verifyFields: registrationAddressVerifyFields,
-		trustedFields: registrationAddressTrustedFields
-	}, t);
-	const isOperationAddressNotSame = () => data?.operationalAddressIsSame === operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME;
-	const registrationAddressValidRef = useRef(Boolean(form.valid.trustRegistrationAddress?.registrationAddress));
-	const operationalAddressValidRef = useRef(Boolean(form.valid.trustRegistrationAddress?.operationalAddress));
-	useEffect(() => {
-		if (form.valid.trustRegistrationAddress?.registrationAddress !== registrationAddressValidRef.current) form.setValid("trustRegistrationAddress", "registrationAddress", registrationAddressValidRef.current);
-		if (isOperationAddressNotSame() && form.valid.trustRegistrationAddress?.operationalAddress !== operationalAddressValidRef.current) form.setValid("trustRegistrationAddress", "operationalAddress", operationalAddressValidRef.current);
-	}, [form.valid.trustRegistrationAddress]);
-	const handleChangeFor = useCallback((fieldName, mode) => form.handleChangeFor("trustRegistrationAddress", fieldName, mode), [form]);
-	const handleRegistrationAddressChange = (state) => {
-		handleChangeFor("registrationAddress")(state.data);
-		registrationAddressValidRef.current = Boolean(state.isValid);
+	const registrationNumberLabel = resolveFieldMetadata(registrationNumberDefaultFieldConfig[country], {
+		companyType: LegalEntityTypes.TRUST,
+		registrationNumberType: data.registrationNumber ? inferCompanyRegistrationNumberType(data.registrationNumber, country, LegalEntityTypes.TRUST) : getCompanyRegistrationNumberOptions(country, LegalEntityTypes.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
 	};
-	const handleOperationalAddressChange = (state) => {
-		handleChangeFor("operationalAddress")(state.data);
-		operationalAddressValidRef.current = Boolean(state.isValid);
+}
+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 handleOperationalAddressIsSameChange = (value) => {
-		handleChangeFor("operationalAddressIsSame")(value);
-		if (value === "OperationAddressAnswerYes") form.setValid("trustRegistrationAddress", "operationalAddress", true);
+	const translateAndFilterMappedSummary = (data) => {
+		const tmp = [];
+		for (const summaryItem in data) {
+			const item = createStructuredListItem(summaryItem, data[summaryItem], t);
+			if (item) tmp.push(item);
+		}
+		return tmp;
 	};
-	return /* @__PURE__ */ jsxs(Fragment, { children: [
-		heading && /* @__PURE__ */ jsx(Header, {
-			title: heading,
-			description
-		}),
-		/* @__PURE__ */ jsx(ErrorPanel, {
-			verificationErrors: id ? problems?.verificationErrors?.[id] : void 0,
-			validationErrors: id ? problems?.validationErrors?.[id] : void 0,
-			formUtils,
-			id: "ariaErrorField"
-		}),
-		/* @__PURE__ */ jsx(ContextGuidance, {
-			titleId: "whyDoINeedToFillInThisInformation",
-			contentId: "reasonForFillingCompanyAddressDetails",
-			title: t(($) => $["whyDoINeedToFillInThisInformation"]),
-			content: t(($) => $["reasonForFillingCompanyAddressDetails"])
-		}),
-		/* @__PURE__ */ jsx(Address, {
-			data: {
-				...form.data?.trustRegistrationAddress?.registrationAddress,
-				country
-			},
-			hideCountry: true,
-			id,
-			addressType: "registrationAddress",
-			optionalFields: ["street2"],
-			onChange: handleRegistrationAddressChange
-		}),
-		/* @__PURE__ */ jsx(Header, {
-			title: t(($) => $["operationalAddressHeader"]),
-			secondary: true
-		}),
-		/* @__PURE__ */ jsx(Field, {
-			el: "fieldset",
-			name: "operationalAddressIsSame",
-			label: formUtils.getLabel("operationalAddressIsSame"),
-			errorMessage: form.errors.trustRegistrationAddress?.operationalAddressIsSame?.errorMessage,
-			children: (childProps) => /* @__PURE__ */ jsx(RadioGroup, {
-				...childProps,
-				name: "operationalAddressIsSame",
-				items: operationalAddressIsSameItems,
-				value: data?.operationalAddressIsSame,
-				disabled: formUtils.isReadOnly("operationalAddressIsSame"),
-				onChange: handleOperationalAddressIsSameChange,
-				"aria-required": true,
-				"aria-invalid": !form.valid.trustRegistrationAddress?.operationalAddressIsSame
+	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;
+}
+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
+				})
 			})
-		}),
-		isOperationAddressNotSame() && /* @__PURE__ */ jsx(Address, {
-			data: {
-				...form.data?.trustRegistrationAddress?.operationalAddress,
-				country
-			},
-			hideCountry: true,
-			id,
-			optionalFields: ["street2"],
-			addressType: "operationalAddress",
-			onChange: handleOperationalAddressChange
-		}, "operationalAddress")
-	] });
+		]
+	});
 }
 //#endregion
 //#region src/components/Trust/forms/TrustRegistrationDetails/TrustRegistrationDetails.tsx
@@ -419,6 +452,7 @@ function TrustRegistrationDetails({ fieldValidationErrors = {}, formVerification
 	const country = data?.country ?? parentLegalEntityCountry;
 	const trustTypeOptions = getCountrySpecificTrustTypeOptions(country) ?? [];
 	const isUnincorporatedPartnership = taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP;
+	const legalEntityType = isUnincorporatedPartnership ? LegalEntityTypes.UNINCORPORATED_PARTNERSHIP : LegalEntityTypes.TRUST;
 	const handleChange = (fieldName, mode) => form.handleChangeFor(TRUST_REGISTRATION_DETAILS, fieldName, mode);
 	const changeTrustType = (e) => {
 		handleChange("trustType", "blur")(e);
@@ -443,11 +477,11 @@ function TrustRegistrationDetails({ fieldValidationErrors = {}, formVerification
 				case "doingBusinessAs": return mergeFieldMetadataIntoProps("doingBusinessAs", doingBusinessAsFieldMetadata, acc);
 				case "taxInformation": return mergeFieldMetadataIntoProps("taxInformation", resolveFieldMetadata(taxInformationDefaultFieldConfig[country], {
 					taxIdNumberType: data.taxInformation?.find((taxId) => taxId.country === country)?.type,
-					companyType: LegalEntityTypes.TRUST
+					companyType: legalEntityType
 				}, taxInformationDefaultFieldMetadata), acc);
 				case "exemptedFromTax": return mergeFieldMetadataIntoProps("exemptedFromTax", resolveFieldMetadata(exemptedFromTaxDefaultFieldConfig[country], {}, exemptedFromTaxDefaultFieldMetadata), acc);
 				case "registrationNumber": return mergeFieldMetadataIntoProps("registrationNumber", resolveFieldMetadata(registrationNumberDefaultFieldConfig[country], {
-					companyType: LegalEntityTypes.TRUST,
+					companyType: legalEntityType,
 					registrationNumberType: data.registrationNumberType
 				}, registrationNumberDefaultFieldMetadata), acc);
 				case "exemptedFromRegistrationNumber": return mergeFieldMetadataIntoProps("exemptedFromRegistrationNumber", resolveFieldMetadata(exemptFromRegistrationNumberDefaultFieldConfig[country], {}, exemptFromRegistrationNumberDefaultFieldMetadata), acc);
@@ -464,6 +498,7 @@ function TrustRegistrationDetails({ fieldValidationErrors = {}, formVerification
 		errors,
 		fieldValidationErrors,
 		formVerificationErrors,
+		legalEntityType,
 		obscuredFields,
 		optionalFields,
 		requiredFields,
@@ -571,7 +606,7 @@ function TrustRegistrationDetails({ fieldValidationErrors = {}, formVerification
 				optional: formUtils.isOptionalField("taxInformation"),
 				canExempt: formUtils.isRequiredField("exemptedFromTax"),
 				country,
-				entityType: LegalEntityTypes.TRUST,
+				entityType: legalEntityType,
 				defaultData: data?.taxInformation,
 				registrationNumber: data.registrationNumber
 			}),
@@ -581,7 +616,7 @@ function TrustRegistrationDetails({ fieldValidationErrors = {}, formVerification
 				errors: formUtils.getFieldErrors(errors, fieldValidationErrors, BUSINESS_REGISTRATION_NUMBER_FIELD),
 				helperText: getRegistrationNumberHelperText(trustT, {
 					country,
-					companyType: LegalEntityTypes.TRUST
+					companyType: legalEntityType
 				}),
 				readonly: formUtils.isReadOnly("registrationNumber"),
 				optional: formUtils.isOptionalField("registrationNumber"),
@@ -589,7 +624,7 @@ function TrustRegistrationDetails({ fieldValidationErrors = {}, formVerification
 				handleChangeFor: handleChange,
 				country,
 				canExempt: formUtils.isRequiredField("exemptedFromRegistrationNumber"),
-				companyType: LegalEntityTypes.TRUST
+				companyType: legalEntityType
 			}),
 			showField("vatNumber") && /* @__PURE__ */ jsx(VatNumberField, {
 				data: formUtils.getFieldData(data, VAT_NUMBER_FIELD),
@@ -617,7 +652,7 @@ var trustForms = {
 	trustRegistrationAddress: {
 		formId: "trustRegistrationAddress",
 		formName: "addressDetails",
-		fields: registrationAddressFields
+		fields: REGISTRATION_AND_OPERATIONAL_ADDRESS_FIELDS
 	},
 	trustConstitutionalDocument: {
 		formId: "trustConstitutionalDocument",
@@ -636,6 +671,8 @@ function Trust(props) {
 	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, {
@@ -645,14 +682,12 @@ function Trust(props) {
 				shouldValidate,
 				country
 			});
-			case trustRegistrationAddressFormId: return /* @__PURE__ */ jsx(RegistrationAddressMultiform, {
-				heading: t(($) => $["addressDetails"]),
-				description: !isUnincorporatedPartnership ? t(($) => $["registeredAddressTrustHeaderDescription"], { ns: "trust" }) : t(($) => $["registeredAddressUnincorporatedPartnershipHeaderDescription"], { ns: "trust" }),
+			case trustRegistrationAddressFormId: return /* @__PURE__ */ jsx(TrustRegistrationAddress, {
 				id: trustRegistrationAddressFormId,
+				taskType,
 				country,
-				problems,
-				labels: { operationalAddressIsSame: !isUnincorporatedPartnership ? "isTrustOperationAddressSame" : "isPartnershipOperationAddressSame" },
-				shouldValidate
+				fieldValidationErrors,
+				formVerificationErrors
 			});
 			case trustConstitutionalDocumentFormId: return /* @__PURE__ */ jsx(MemoizedConstitutionalDocument, {
 				id: activeForm.formId,
@@ -685,14 +720,24 @@ var trustBase = {
 	doingBusinessAs: { rule: "requireDoingBusinessAsName" },
 	country: { rule: "REQUIRED" },
 	taxInformation: { rule: "countryUsesTaxId" },
-	registrationAddress: { rule: "REQUIRED" },
-	operationalAddress: { rule: "OPTIONAL" },
 	constitutionalDocument: { rule: "REQUIRED" },
 	registrationNumber: { rule: "countryRequiresRegistrationNumberForTrust" },
 	registrationNumberType: { rule: "registrationNumberType" },
 	vatNumber: { rule: "countryUsesVatNumber" },
 	vatNumberType: { rule: "countryUsesVatNumber" },
-	operationalAddressIsSame: { rule: "REQUIRED" }
+	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 },
@@ -793,7 +838,6 @@ function TrustDropin({ parentLegalEntity, country: countryProp, existingTrust, t
 	const { baseUrl, rootLegalEntityId } = useApiContext();
 	const { t, i18n } = useTranslation(["common", "trust"]);
 	const [validationErrors, setValidationErrors] = useState();
-	const datasetUtils = datasetUtilities(i18n.language);
 	const { isFeatureEnabled } = useToggleContext();
 	const { showToast } = useToastContext();
 	const [loadingStatus, setLoadingStatus] = useState("success");
@@ -851,7 +895,7 @@ function TrustDropin({ parentLegalEntity, country: countryProp, existingTrust, t
 	/**
 	* Fetch Configurations
 	*/
-	const { fieldConfigurations, requiredFields } = useScenarioConfiguration({
+	const { fieldConfigurations } = useScenarioConfiguration({
 		parseConfiguration,
 		legalEntityType: LegalEntityTypes.TRUST,
 		setLoadingStatus,
@@ -860,13 +904,11 @@ function TrustDropin({ parentLegalEntity, country: countryProp, existingTrust, t
 	const fieldsFromCustomRules = useMemo(() => rules({
 		data: multiForm.data,
 		country,
-		taskType,
-		requiredFields
+		taskType
 	}), [
 		country,
 		multiForm.data,
-		taskType,
-		requiredFields
+		taskType
 	]);
 	useEffect(() => {
 		setDerivedProps(getPropsFromConfigurations({
@@ -902,7 +944,7 @@ function TrustDropin({ parentLegalEntity, country: countryProp, existingTrust, t
 	]);
 	const onSubmitTrust = async () => {
 		setLoadingStatus("loading");
-		const trustDetails = mapTrustToLegalEntity(multiForm.data, isFeatureEnabled);
+		const trustDetails = mapTrustToLegalEntity(multiForm.data, isFeatureEnabled, existingTrust);
 		try {
 			const updatedTrust = await submitTrustDetails(trustDetails);
 			await submitDocuments({
@@ -933,7 +975,7 @@ function TrustDropin({ parentLegalEntity, country: countryProp, existingTrust, t
 	};
 	const onSubmitUnincorporatedPartnership = async () => {
 		setLoadingStatus("loading");
-		const unincorporatedPartnershipDetails = mapUnincorporatedPartnershipToLegalEntity(multiForm.data, isFeatureEnabled);
+		const unincorporatedPartnershipDetails = mapUnincorporatedPartnershipToLegalEntity(multiForm.data, isFeatureEnabled, existingTrust);
 		try {
 			const updatedUnincorporatedPartnershipDetails = await submitTrustDetails(unincorporatedPartnershipDetails);
 			await submitDocuments({
@@ -989,69 +1031,50 @@ function TrustDropin({ parentLegalEntity, country: countryProp, existingTrust, t
 			id: parentLegalEntity.id
 		});
 	};
-	const formatDataForSummary = useCallback((formData, forms) => {
-		let summaryData = cloneObject(formData) || {};
-		const country = formData.trustRegistrationDetails?.country ?? (existingTrust ? getLegalEntityCountry(existingTrust) : getLegalEntityCountry(parentLegalEntity));
-		if (formData.trustRegistrationDetails) {
-			const trustCountry = formData.trustRegistrationDetails.country && datasetUtils.getCountryName(formData.trustRegistrationDetails.country);
-			const trustType = formData.trustRegistrationDetails.trustType && t(($) => $[formData.trustRegistrationDetails.trustType], { ns: "trust" });
-			const registrationNumberLabel = resolveFieldMetadata(registrationNumberDefaultFieldConfig[country], {
-				companyType: LegalEntityTypes.TRUST,
-				registrationNumberType: formData.trustRegistrationDetails.registrationNumber ? inferCompanyRegistrationNumberType(formData.trustRegistrationDetails.registrationNumber, country, LegalEntityTypes.TRUST) : getCompanyRegistrationNumberOptions(country, LegalEntityTypes.TRUST)?.[0]?.id
-			}, registrationNumberDefaultFieldMetadata).label;
-			const taxIdLabel = resolveFieldMetadata(taxInformationDefaultFieldConfig[country], {
-				companyType: LegalEntityTypes.TRUST,
-				taxIdNumberType: countryToTaxInfoTypeMap[country]
-			}, taxInformationDefaultFieldMetadata).label;
-			summaryData.trustRegistrationDetails = {
-				[isUnincorporatedPartnership ? "legalName" : "nameOfTrustAgreement"]: formData.trustRegistrationDetails?.legalName,
-				doingBusinessAs: formData.trustRegistrationDetails?.doingBusinessAs,
-				countryRegionOfEstablishment: trustCountry,
-				typeOfTrustAgreement: isUnincorporatedPartnership ? void 0 : trustType,
-				objectOfTrust: formData.trustRegistrationDetails?.objectOfTrust,
-				[taxIdLabel]: formData.trustRegistrationDetails?.taxInformation?.find((taxId) => country === taxId.country)?.number,
-				[registrationNumberLabel]: formData.trustRegistrationDetails.registrationNumber
-			};
-		}
-		if (formData.trustRegistrationAddress?.registrationAddress) {
-			summaryData.trustRegistrationAddress.hasInnerForms = true;
-			summaryData.trustRegistrationAddress.registrationAddress = mapAddressLabels(formData.trustRegistrationAddress.registrationAddress, datasetUtils);
-		}
-		if (formData.trustRegistrationAddress?.operationalAddress) summaryData.trustRegistrationAddress.operationalAddress = mapAddressLabels(formData.trustRegistrationAddress.operationalAddress, datasetUtils);
-		if (isDocumentsRequired(forms)) summaryData = {
-			...summaryData,
-			...formatFileSummaryData(formData.trustConstitutionalDocument)
-		};
-		else delete summaryData[trustConstitutionalDocumentFormId];
-		return summaryData;
-	}, [
-		datasetUtils,
-		existingTrust,
-		isUnincorporatedPartnership,
-		parentLegalEntity,
-		t
-	]);
-	const formatFileSummaryData = (trustConstitutionalDocument) => {
-		const constitutionalDocument = trustConstitutionalDocument?.constitutionalDocument?.[0];
-		return { ...constitutionalDocument && { trustConstitutionalDocument: { fileName: constitutionalDocument.name } } };
-	};
 	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, {
-			summary: {
-				data: useMemo(() => formatDataForSummary(multiForm.data, forms), [
-					formatDataForSummary,
-					multiForm.data,
-					forms
-				]),
-				omitted: { keys: ["operationalAddressIsSame"] }
-			},
+			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,
@@ -1088,9 +1111,9 @@ var TrustDetailsPage = ({ taskType, trustId, handleHomeClick, onSubmit }) => {
 			"../language/da-DK.json": () => import("./da-DK-CXZXQspY.js"),
 			"../language/de-DE.json": () => import("./de-DE-BRJ0jBty.js"),
 			"../language/el-GR.json": () => import("./el-GR-BMGYrO4V.js"),
-			"../language/en-US.json": () => import("./en-US-CWDI7JKT.js"),
+			"../language/en-US.json": () => import("./en-US-BFM81i9K.js"),
 			"../language/es-ES.json": () => import("./es-ES-pt4yy_U2.js"),
-			"../language/es-LA.json": () => import("./es-LA-DU9jNyAv.js"),
+			"../language/es-LA.json": () => import("./es-LA-CGrMi4rR.js"),
 			"../language/et-EE.json": () => import("./et-EE-dDMeDiTJ.js"),
 			"../language/fi-FI.json": () => import("./fi-FI-iRb7nS7X.js"),
 			"../language/fr-FR.json": () => import("./fr-FR-DUrcyeOg.js"),