udp-react-enterprise-component-library 25.18.1-beta.36 → 25.18.1-beta.37

package/dist/{UdpTransactionTypesPage-CmsWZHM4.js → UdpTransactionTypesPage-Do_tl8J2.js}

@@ -5,9 +5,10 @@ import { t as arrayMutators } from "./form-Dj1zVw6K.js";
 import { t as FluentButton } from "./FluentButton-BexKrnAp.js";
 import { t as useUser } from "./useUser-wpHGo6jU.js";
 import { t as apiMutate } from "./useAxiosMutate-DcLxzykX.js";
-import { B as UdpTransactionActionEnums } from "./unitySystemEnums-DM5vXR_m.js";
-import { n as getSuccessAction } from "./actionUtils-DylNlciX.js";
+import { V as UdpTransactionActionEnums, a as EMPTY_GUID } from "./unitySystemEnums-e5F9Jr7m.js";
+import { n as getSuccessAction } from "./actionUtils-DREj3J3H.js";
 import { t as useCatalogStore } from "./catalogStore-DP2GxpTJ.js";
+import { t as LayoutUnit } from "./LayoutUnit-D4jJvonh.js";
 import { n as SideSheet } from "./SideSheet-C-rILQqR.js";
 import { t as useAxiosGet } from "./useAxiosGet-vvPjwB4W.js";
 import { t as FluentDialog } from "./FluentDialog-B5ZxvX1E.js";
@@ -46,8 +47,11 @@ const UdpTransactionTypeForm = (props, ref) => {
 					form.change("domainFields", []);
 				}
 			};
+			const handleDomainFieldTypeChange = (value) => {
+				if (!value) form.change("domainFieldValue", "");
+			};
 			const hasRevision = !!form.getState().values?.hasRevision;
-			const hasDomainTypeField = !!form.getState().values?.domainTypeField;
+			const hasDomainFieldType = !!form.getState().values?.domainFieldType;
 			const parseHasRevision = (value) => {
 				const nextValue = value?.target ? !!value.target.checked : !!value;
 				if (!nextValue) form.change("revisionField", null);
@@ -66,7 +70,7 @@ const UdpTransactionTypeForm = (props, ref) => {
 				initialValue: initialData?.name || ""
 			}), /* @__PURE__ */ React.createElement(Field$1, {
 				component: AmbientAutoComplete,
-				label: t("Domain Name"),
+				label: t("Domain"),
 				id: "domainName",
 				name: "domainName",
 				variant: "outlined",
@@ -78,7 +82,29 @@ const UdpTransactionTypeForm = (props, ref) => {
 				additionalOnChangeAction: handleDomainNameChange
 			}), /* @__PURE__ */ React.createElement(Field$1, {
 				component: AmbientAutoComplete,
-				label: "Domain Fields",
+				label: "Sub-Type",
+				id: "domainFieldType",
+				name: "domainFieldType",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				initialValue: initialData?.domainFieldType,
+				options: domainFieldOptions || [],
+				getOptionLabelFunction: (option) => option,
+				additionalOnChangeAction: handleDomainFieldTypeChange
+			}), hasDomainFieldType && /* @__PURE__ */ React.createElement(Field$1, {
+				component: FluentTextField,
+				label: t("Sub-Type Value"),
+				id: "domainFieldValue",
+				name: "domainFieldValue",
+				fullWidth: true,
+				variant: "outlined",
+				margin: "normal",
+				size: "small",
+				initialValue: initialData?.domainFieldValue || ""
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: "Grid Columns",
 				id: "domainFields",
 				name: "domainFields",
 				variant: "outlined",
@@ -87,7 +113,27 @@ const UdpTransactionTypeForm = (props, ref) => {
 				initialValue: initialData?.domainFields,
 				options: domainFieldOptions || [],
 				getOptionLabelFunction: (option) => option
-			}), /* @__PURE__ */ React.createElement(FormControlLabel, {
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("Field Label"),
+				id: "domainFieldLabel",
+				name: "domainFieldLabel",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				initialValue: initialData?.domainFieldLabel,
+				options: domainFieldOptions || [],
+				getOptionLabelFunction: (option) => option
+			}), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "nudge" }), /* @__PURE__ */ React.createElement(FormControlLabel, {
+				control: /* @__PURE__ */ React.createElement(Field$1, {
+					component: Switch,
+					id: "enabled",
+					name: "enabled",
+					type: "checkbox",
+					initialValue: !!initialData?.enabled
+				}),
+				label: t("Enabled")
+			}), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "nudge" }), /* @__PURE__ */ React.createElement(FormControlLabel, {
 				control: /* @__PURE__ */ React.createElement(Field$1, {
 					component: Switch,
 					id: "hasRevision",
@@ -96,7 +142,7 @@ const UdpTransactionTypeForm = (props, ref) => {
 					initialValue: !!initialData?.hasRevision,
 					parse: parseHasRevision
 				}),
-				label: t("Has Revision?")
+				label: t("Allow Revisions")
 			}), hasRevision && /* @__PURE__ */ React.createElement(Field$1, {
 				component: AmbientAutoComplete,
 				label: "Revision Field",
@@ -108,27 +154,6 @@ const UdpTransactionTypeForm = (props, ref) => {
 				initialValue: initialData?.revisionField,
 				options: domainFieldOptions || [],
 				getOptionLabelFunction: (option) => option
-			}), /* @__PURE__ */ React.createElement(Field$1, {
-				component: AmbientAutoComplete,
-				label: "Domain Type Field",
-				id: "domainTypeField",
-				name: "domainTypeField",
-				variant: "outlined",
-				isMultiple: false,
-				disableCloseOnSelect: false,
-				initialValue: initialData?.domainTypeField,
-				options: domainFieldOptions || [],
-				getOptionLabelFunction: (option) => option
-			}), hasDomainTypeField && /* @__PURE__ */ React.createElement(Field$1, {
-				component: FluentTextField,
-				label: t("Domain Type Value"),
-				id: "domainTypeValue",
-				name: "domainTypeValue",
-				fullWidth: true,
-				variant: "outlined",
-				margin: "normal",
-				size: "small",
-				initialValue: initialData?.domainTypeValue || ""
 			}));
 		}
 	});
@@ -202,7 +227,17 @@ const UdpTransactionTypeStatusForm = (props, ref) => {
 				size: "small",
 				required: true,
 				initialValue: initialData?.name || ""
-			}), /* @__PURE__ */ React.createElement(FormControlLabel, {
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: FluentTextField,
+				label: t("Code"),
+				id: "code",
+				name: "code",
+				fullWidth: true,
+				variant: "outlined",
+				margin: "normal",
+				size: "small",
+				initialValue: initialData?.code || ""
+			}), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "nudge" }), /* @__PURE__ */ React.createElement(FormControlLabel, {
 				control: /* @__PURE__ */ React.createElement(Field$1, {
 					component: Switch,
 					id: "isDefault",
@@ -210,8 +245,8 @@ const UdpTransactionTypeStatusForm = (props, ref) => {
 					type: "checkbox",
 					initialValue: !!initialData?.isDefault
 				}),
-				label: t("Default?")
-			}), /* @__PURE__ */ React.createElement(FormControlLabel, {
+				label: t("Default")
+			}), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "nudge" }), /* @__PURE__ */ React.createElement(FormControlLabel, {
 				control: /* @__PURE__ */ React.createElement(Field$1, {
 					component: Switch,
 					id: "isClosedStatus",
@@ -219,7 +254,16 @@ const UdpTransactionTypeStatusForm = (props, ref) => {
 					type: "checkbox",
 					initialValue: !!initialData?.isClosedStatus
 				}),
-				label: t("Closed Status?")
+				label: t("Closed Status")
+			}), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "nudge" }), /* @__PURE__ */ React.createElement(FormControlLabel, {
+				control: /* @__PURE__ */ React.createElement(Field$1, {
+					component: Switch,
+					id: "isCancelledStatus",
+					name: "isCancelledStatus",
+					type: "checkbox",
+					initialValue: !!initialData?.isCancelledStatus
+				}),
+				label: t("Cancelled Status")
 			}));
 		}
 	});
@@ -240,7 +284,7 @@ const UdpTransactionTypeStatusCreateAndEditSidesheet = (props) => {
 	return /* @__PURE__ */ React.createElement(SideSheet, {
 		open: isSideSheetOpen,
 		width: 500,
-		title: isEditing ? t("Edit Transaction Type Status") : t("Create Transaction Type Status"),
+		title: isEditing ? t("Edit Status") : t("Create Status"),
 		onClose: () => handleSideSheet(false),
 		buttonLabel: isEditing ? t("Save") : t("Create"),
 		onSubmit: () => {
@@ -274,17 +318,30 @@ const UdpTransactionTypeStatusSidesheet = (props, ref) => {
 			{
 				headerName: t("Default"),
 				field: "isDefault",
-				resizable: false,
+				resizable: true,
 				sortable: false,
 				cellDataType: "boolean"
 			},
 			{
-				headerName: t("Is Closed Status"),
+				headerName: t("Closed Status"),
 				field: "isClosedStatus",
-				resizable: false,
+				resizable: true,
+				sortable: false,
+				cellDataType: "boolean"
+			},
+			{
+				headerName: t("Cancelled Status"),
+				field: "isCancelledStatus",
+				resizable: true,
 				sortable: false,
 				cellDataType: "boolean"
 			},
+			{
+				headerName: t("Code"),
+				field: "code",
+				resizable: true,
+				sortable: false
+			},
 			{
 				headerName: t("Actions"),
 				field: "actions",
@@ -351,8 +408,8 @@ const UdpTransactionTypeStatusSidesheet = (props, ref) => {
 	}, [transactionType]);
 	return /* @__PURE__ */ React.createElement(SideSheet, {
 		open: isSideSheetOpen,
-		width: 800,
-		title: t("Transaction Type Statuses"),
+		width: 900,
+		title: t("Manage Statuses"),
 		onClose: () => handleTransactionTypeStatusSideSheet(false)
 	}, /* @__PURE__ */ React.createElement(SearchMethodUdpGrid, {
 		searchMethodConfig,
@@ -373,7 +430,7 @@ var UdpTransactionTypeStatusSidesheet_default = forwardRef(UdpTransactionTypeSta
 
 //#endregion
 //#region src/udp/pages/UdpTransactionTypesPage/forms/UdpTransactionTypeTransactionActionFormFields.jsx
-const useStyles$1 = makeStyles((theme) => ({
+const useStyles$2 = makeStyles((theme) => ({
 	domainFields: {
 		display: "flex",
 		flexDirection: "row",
@@ -398,7 +455,7 @@ const useStyles$1 = makeStyles((theme) => ({
 const UdpTransactionTypeTransactionActionFormFields = (props) => {
 	const { transactionActionOptions, catalogObjectProperties, actionApiOptions, pageOptions, transactionTypeStatusOptions, showMandatoryFields, showHiddenFields, showToStatusField, showActionApiField, showPageField, showDomainDataToUpdateFields, pushToFieldArray } = props;
 	const { t } = useTranslation();
-	const classes = useStyles$1();
+	const classes = useStyles$2();
 	const form = useForm();
 	const { values } = useFormState();
 	useEffect(() => {
@@ -592,8 +649,8 @@ const UdpTransactionTypeTransactionActionForm = (props, ref) => {
 			const showMandatoryFields = transactionActionName === UdpTransactionActionEnums.Set_Mandatory_Fields;
 			const showHiddenFields = transactionActionName === UdpTransactionActionEnums.Set_Fields_Hidden;
 			const showToStatusField = [...baseActionsList, UdpTransactionActionEnums.Update_Status].includes(transactionActionName);
-			const showActionApiField = [...baseActionsList, UdpTransactionActionEnums.Execute_Api].includes(transactionActionName);
-			const showPageField = [...baseActionsList, UdpTransactionActionEnums.Execute_Api].includes(transactionActionName);
+			const showActionApiField = [...baseActionsList, UdpTransactionActionEnums.Product_Action].includes(transactionActionName);
+			const showPageField = [...baseActionsList, UdpTransactionActionEnums.Product_Action].includes(transactionActionName);
 			const showDomainDataToUpdateFields = [...baseActionsList, UdpTransactionActionEnums.Update_Domain].includes(transactionActionName);
 			return /* @__PURE__ */ React.createElement(UdpTransactionTypeTransactionActionFormFields_default, {
 				transactionActionOptions,
@@ -650,20 +707,15 @@ var UdpTransactionTypeTransactionActionCreateAndEditSidesheet_default = UdpTrans
 //#endregion
 //#region src/udp/pages/UdpTransactionTypesPage/sidesheets/UdpTransactionTypeTransactionActionSidesheet.jsx
 const UdpTransactionTypeTransactionActionSidesheet = (props, ref) => {
-	const { transactionType, transactionTypeTransactionAction, isSideSheetOpen, isTransactionTypeTransactionActionCreateOrEditSidesheetOpen, handleTransactionTypeTransactionActionSidesheet, handleCreateOrEditTransactionTypeTransactionActionSidesheet, handleCreateTransactionTypeTransactionAction, handleUpdateTransactionTypeTransactionAction, handleDeleteTransactionTypeTransactionAction, transactionActions, catalogObjectProperties, actionApis, pages, searchTransactionTypeStatusByTransactionTypeId } = props;
+	const { transactionType, transactionTypeTransactionAction, isSideSheetOpen, isTransactionTypeTransactionActionCreateOrEditSidesheetOpen, handleTransactionTypeTransactionActionSidesheet, handleCreateOrEditTransactionTypeTransactionActionSidesheet, handleCreateTransactionTypeTransactionAction, handleUpdateTransactionTypeTransactionAction, handleDeleteTransactionTypeTransactionAction, transactionActions, catalogObjectProperties, actionApis, pages, ttstatuses } = props;
 	const transactionTypeTransactionActionGridApiRef = useRef(null);
 	const { t } = useTranslation();
-	const [ttstatuses, setTTStatuses] = useState([]);
-	useEffect(() => {
-		if (!transactionType?.transactionTypeId) return;
-		const loadTTStatuses = async () => {
-			const ttsResponse = await searchTransactionTypeStatusByTransactionTypeId(transactionType?.transactionTypeId);
-			if (ttsResponse?.status === 200) setTTStatuses(ttsResponse.data?.pageList);
-		};
-		loadTTStatuses();
-	}, [searchTransactionTypeStatusByTransactionTypeId, transactionType?.transactionTypeId]);
+	const filteredTransactionActions = useMemo(() => {
+		if (!transactionActions) return [];
+		return transactionActions.filter((ta) => ta?.name !== UdpTransactionActionEnums.Send_Email && ta?.name !== UdpTransactionActionEnums.Custom_Client_Action);
+	}, [transactionActions]);
 	useImperativeHandle(ref, () => ({ refreshServerSide: () => {
-		transactionTypeTransactionActionGridApiRef?.current?.refreshServerSide();
+		transactionTypeTransactionActionGridApiRef.current?.refreshServerSide();
 	} }));
 	const getTransactionActionName = useCallback((transactionActionId) => {
 		if (!transactionActions) return "";
@@ -763,7 +815,7 @@ const UdpTransactionTypeTransactionActionSidesheet = (props, ref) => {
 	return /* @__PURE__ */ React.createElement(SideSheet, {
 		open: isSideSheetOpen,
 		width: 800,
-		title: t("Actions"),
+		title: t("Manage Actions"),
 		onClose: () => handleTransactionTypeTransactionActionSidesheet(false)
 	}, /* @__PURE__ */ React.createElement(SearchMethodUdpGrid, {
 		searchMethodConfig,
@@ -778,7 +830,7 @@ const UdpTransactionTypeTransactionActionSidesheet = (props, ref) => {
 		handleCreateTransactionTypeTransactionAction,
 		handleUpdateTransactionTypeTransactionAction,
 		handleSideSheet: handleCreateOrEditTransactionTypeTransactionActionSidesheet,
-		transactionActions,
+		transactionActions: filteredTransactionActions,
 		catalogObjectProperties,
 		actionApis,
 		pages,
@@ -856,11 +908,13 @@ const UdpTransactionUiActionCreateAndEditSidesheet = (props) => {
 	};
 	const filterAvailableTUATypes = useCallback((allTUATypes, transactionUiActions, currentTransactionUiActionTypeId = null) => {
 		const allTUATypesArray = normalizeToArray(allTUATypes);
-		const usedTUATypeIds = normalizeToArray(transactionUiActions?.pageList).map((action) => action.transactionUiActionTypeId).filter((id) => id !== void 0 && id !== currentTransactionUiActionTypeId);
+		const transactionUiActionsArray = normalizeToArray(transactionUiActions?.pageList);
+		if (!transactionUiActions) return allTUATypesArray;
+		const usedTUATypeIds = transactionUiActionsArray.map((action) => action.transactionUiActionTypeId).filter((id) => id !== void 0 && id !== currentTransactionUiActionTypeId);
 		return allTUATypesArray.filter((type) => !usedTUATypeIds.includes(type.transactionUiActionTypeId));
 	}, []);
 	const availableTUATypeOptions = useMemo(() => {
-		if (!transactionUiActionTypes || !tUiActionsList) return [];
+		if (!transactionUiActionTypes) return [];
 		return filterAvailableTUATypes(transactionUiActionTypes, tUiActionsList, initialTransactionUiAction ? initialTransactionUiAction.transactionUiActionTypeId : null);
 	}, [
 		transactionUiActionTypes,
@@ -875,7 +929,7 @@ const UdpTransactionUiActionCreateAndEditSidesheet = (props) => {
 	return /* @__PURE__ */ React.createElement(SideSheet, {
 		open: isSideSheetOpen,
 		width: 600,
-		title: isEditing ? t("Edit Transaction UI Action") : t("Create Transaction UI Action"),
+		title: isEditing ? t("Edit UI Action") : t("Create UI Action"),
 		onClose: () => handleSideSheet(false),
 		buttonLabel: isEditing ? t("Save") : t("Create"),
 		onSubmit: () => {
@@ -896,10 +950,10 @@ var UdpTransactionUiActionCreateAndEditSidesheet_default = UdpTransactionUiActio
 //#region src/udp/pages/UdpTransactionTypesPage/sidesheets/UdpTransactionUiActionSidesheet.jsx
 const UdpTransactionUiActionSidesheet = (props, ref) => {
 	const { transactionType, transactionUiAction, isSideSheetOpen, handleTransactionUiActionSidesheet, isCreateOrEditTransactionUiActionSidesheetOpen, handleCreateOrEditTransactionUiActionSidesheet, handleCreateTransactionUiAction, handleUpdateTransactionUiAction, handleDeleteTransactionUiAction, transactionUiActionTypes, actionApis, pages, tUiActionsList } = props;
-	const transactonUiActionGridApiRef = useRef(null);
+	const transactionUiActionGridApiRef = useRef(null);
 	const { t } = useTranslation();
 	useImperativeHandle(ref, () => ({ refreshServerSide: () => {
-		transactonUiActionGridApiRef?.current?.refreshServerSide();
+		transactionUiActionGridApiRef?.current?.refreshServerSide();
 	} }));
 	const getTransactionUiActionTypeName = useCallback((transactionUiActionTypeId) => {
 		if (!transactionUiActionTypes) return "";
@@ -911,7 +965,8 @@ const UdpTransactionUiActionSidesheet = (props, ref) => {
 				headerName: t("TransactionUiActionId"),
 				field: "transactionUiActionId",
 				resizable: true,
-				sortable: false
+				sortable: false,
+				hide: true
 			},
 			{
 				headerName: t("Type"),
@@ -952,7 +1007,7 @@ const UdpTransactionUiActionSidesheet = (props, ref) => {
 		getTransactionUiActionTypeName
 	]);
 	const headerConfig = {
-		title: t("Transaction UI Actions"),
+		title: t("Form / Page Overrides"),
 		primaryActionButton: {
 			label: t("Add"),
 			iconName: "add",
@@ -970,25 +1025,28 @@ const UdpTransactionUiActionSidesheet = (props, ref) => {
 		return { pagination: true };
 	}, []);
 	const handleGridApiCallback = (api) => {
-		transactonUiActionGridApiRef.current = api;
+		transactionUiActionGridApiRef.current = api;
 	};
 	const searchMethodConfig = useMemo(() => {
 		let filterElements = [];
-		if (transactionType?.transactionTypeId) filterElements = [{
-			searchField: "TransactionTypeId",
-			searchOperator: "=",
-			searchValue: transactionType?.transactionTypeId,
-			groupId: 1
-		}];
-		return {
-			requestUrl: `${process.env.REACT_APP_PRODUCT_API_BASE}/UdpTransactionUiAction/search`,
-			customSearchObject: { filterElements }
-		};
+		if (transactionType?.transactionTypeId) {
+			filterElements = [{
+				searchField: "TransactionTypeId",
+				searchOperator: "=",
+				searchValue: transactionType?.transactionTypeId,
+				groupId: 1
+			}];
+			return {
+				requestUrl: `${process.env.REACT_APP_PRODUCT_API_BASE}/UdpTransactionUiAction/search`,
+				customSearchObject: { filterElements }
+			};
+		}
+		return {};
 	}, [transactionType]);
 	return /* @__PURE__ */ React.createElement(SideSheet, {
 		open: isSideSheetOpen,
 		width: 800,
-		title: t("Transaction UI Actions"),
+		title: t("Manage Form / Page Overrides"),
 		onClose: () => handleTransactionUiActionSidesheet(false)
 	}, /* @__PURE__ */ React.createElement(SearchMethodUdpGrid, {
 		searchMethodConfig,
@@ -1012,152 +1070,1017 @@ const UdpTransactionUiActionSidesheet = (props, ref) => {
 var UdpTransactionUiActionSidesheet_default = forwardRef(UdpTransactionUiActionSidesheet);
 
 //#endregion
-//#region src/udp/pages/UdpTransactionTypesPage/UdpTransactionTypesPage.jsx
-const baseSearchPayload = {
-	pageNumber: 1,
-	pageSize: 100,
-	filterElements: [],
-	filterGroups: [],
-	orderElements: [],
-	groupingType: "",
-	groupProperty: [],
-	groupOperationList: [],
-	eagerLoad: false,
-	logicalSearchOperator: 1
+//#region src/udp/pages/UdpTransactionTypesPage/forms/UdpTransactionTypeConfigurationForm.jsx
+const useStyles$1 = makeStyles((theme) => ({
+	domainFields: {
+		display: "flex",
+		flexDirection: "row",
+		alignItems: "flex-end",
+		justifyContent: "flex-start",
+		"& > *": { marginRight: theme.spacing(2) }
+	},
+	addRemoveButtons: {
+		display: "flex",
+		flexDirection: "row",
+		alignItems: "center",
+		justifyContent: "flex-start",
+		margin: `${theme.spacing(2)}px  0  0 ${-theme.spacing(2)}px`,
+		"& > *": { margin: `0 ${theme.spacing(2)}px` }
+	},
+	removeIcon: {
+		fontSize: theme.spacing(3.5),
+		marginTop: theme.spacing(1)
+	},
+	noRemoveIcon: { marginLeft: theme.spacing(3.5) }
+}));
+const noStatus = {
+	name: "No Status",
+	transactionTypeStatusId: EMPTY_GUID
 };
-const useStyles = makeStyles((theme) => ({ loadingBar: {
-	bottom: theme.spacing(-.5),
-	marginLeft: theme.spacing(.5),
-	marginRight: theme.spacing(.5)
-} }));
-const UdpTransactionTypesPage = () => {
-	const user = useUser();
+const UdpTransactionTypeConfigurationForm = (props, ref) => {
+	const { onSubmit, initialData, transactionRuleTypes, catalogObjectProperties, transactionTypeStatusOptions, roles } = props;
+	const handleSubmitRef = useRef();
 	const { t } = useTranslation();
-	const classes = useStyles();
-	const { enqueueSnackbar, closeSnackbar } = useSnackbar();
-	const successAction = getSuccessAction(closeSnackbar);
-	const gridApiRef = useRef(null);
-	const ttsGridApiRef = useRef(null);
-	const tttaGridApiRef = useRef(null);
-	const tuaGridApiRef = useRef(null);
-	const [searchObject, setSearchObject] = useState(baseSearchPayload);
-	const [selectedTransactionType, setSelectedTransactionType] = useState(null);
-	const [isTransactionTypeSideSheetOpen, setIsTransactionTypeSideSheetOpen] = useState(false);
-	const [isTransactionTypeSidesheetLoading, setIsTransactionTypeSidesheetLoading] = useState(false);
-	const [isDeleteTransactionTypeDialogOpen, setIsDeleteTransactionTypeDialogOpen] = useState(false);
-	const [selectedDomainName, setSelectedDomainName] = useState("");
-	const [isTransactionTypeStatusSidesheetOpen, setIsTransactionTypeStatusSidesheetOpen] = useState(false);
-	const [isDeleteTransactionTypeStatusDialogOpen, setIsDeleteTransactionTypeStatusDialogOpen] = useState(false);
-	const [selectedTransactionTypeStatus, setSelectedTransactionTypeStatus] = useState(null);
-	const [isCreateOrEditTransactionTypeStatusSidesheetOpen, setIsCreateOrEditTransactionTypeStatusSidesheetOpen] = useState(false);
-	const [isTransactionTypeTransactionActionSidesheetOpen, setIsTransactionTypeTransactionActionSidesheetOpen] = useState(false);
-	const [selectedTransactionTypeTransactionAction, setSelectedTransactionTypeTransactionAction] = useState(null);
-	const [isCreateOrEditTransactionTypeTransactionActionSidesheetOpen, setIsCreateOrEditTransactionTypeTransactionActionSidesheetOpen] = useState(false);
-	const [isDeleteTransactionTypeTransactionActionDialogOpen, setIsDeleteTransactionTypeTransactionActionDialogOpen] = useState(false);
-	const [isTransactionUiActionSidesheetOpen, setIsTransactionUiActionSidesheetOpen] = useState(false);
-	const [selectedTransactionUiAction, setSelectedTransactionUiAction] = useState(false);
-	const [isCreateOrEditTransactionUiActionSidesheetOpen, setIsCreateOrEditTransactionUiActionSidesheetOpen] = useState(false);
-	const [isDeleteTransactionUiActionDialogOpen, setIsDeleteTransactionUiActionDialogOpen] = useState(false);
-	const hasDefaultAndClosedTransactionTypeStatus = useCallback((transactionTypeStatuses, checkHasDefault = false, checkHasClosedStatus = false) => {
-		if (!transactionTypeStatuses) return false;
-		return transactionTypeStatuses?.some((record) => {
-			if (record.transactionTypeStatusId !== selectedTransactionTypeStatus?.transactionTypeStatusId) {
-				const isDefault = record?.isDefault;
-				const isClosedStatus = record?.isClosedStatus;
-				if (checkHasDefault && isDefault) return true;
-				if (checkHasClosedStatus && isClosedStatus) return true;
-			}
-			return false;
-		});
-	}, [selectedTransactionTypeStatus]);
-	/** TransactionType */
-	const postCreateTransactionType = async (transactionType) => {
-		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionType`, { method: "POST" }, { data: transactionType });
-	};
-	const putUpdateTransactionType = async (transactionTypeId, transactionType) => {
-		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionType/${transactionTypeId}`, { method: "PUT" }, { data: transactionType });
-	};
-	const deleteTransactionType = async (transactionTypeId) => {
-		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionType/${transactionTypeId}`, { method: "DELETE" });
-	};
-	/** TransactionTypeStatus */
-	const postCreateTransactionTypeStatus = async (transactionTypeStatus) => {
-		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeStatus`, { method: "POST" }, { data: transactionTypeStatus });
-	};
-	const putUpdateTransactionTypeStatus = async (transactionTypeStatusId, transactionTypeStatus) => {
-		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeStatus/${transactionTypeStatusId}`, { method: "PUT" }, { data: transactionTypeStatus });
-	};
-	const deleteTransactionTypeStatus = async (transactionTypeStatusId) => {
-		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeStatus/${transactionTypeStatusId}`, { method: "DELETE" });
-	};
-	const searchTransactionTypeStatusByTransactionTypeId = useCallback(async (transactionTypeId) => {
-		const searchPayload = {
-			filterElements: [{
-				searchField: "TransactionTypeId",
-				searchOperator: "=",
-				searchValue: transactionTypeId,
-				groupId: 1
-			}],
-			getAll: true
+	const classes = useStyles$1();
+	const ttstatusesWithNostatusOption = useMemo(() => {
+		let ttstatuses;
+		if (!transactionTypeStatusOptions) return;
+		ttstatuses = [...transactionTypeStatusOptions, noStatus];
+		return ttstatuses;
+	}, [transactionTypeStatusOptions]);
+	const formInitialValues = useMemo(() => {
+		let formattedData;
+		if (!initialData) return;
+		formattedData = {
+			...initialData,
+			transactionRuleType: transactionRuleTypes?.find((trt) => trt?.transactionRuleTypeId === initialData?.transactionRuleTypeId),
+			currentStatus: ttstatusesWithNostatusOption?.find((tts) => tts?.transactionTypeStatusId === initialData?.configuration?.currentStatusId),
+			tenantUserRoles: roles?.filter((role) => initialData?.configuration?.tenantUserRoleIds?.includes(role?.roleId)),
+			currentDomainValue: initialData?.configuration?.currentDomainValue ? Object.entries(initialData?.configuration?.currentDomainValue) : [[]]
 		};
-		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeStatus/search`, { method: "POST" }, { data: searchPayload });
-	}, []);
-	/** TransactionAction */
-	const [{ data: transactionActions }] = useAxiosGet(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionAction`, { method: "GET" }, false, false);
-	/** ActionApis */
-	const [{ data: actionApis }] = useAxiosGet(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionWorkflowActionApi`, { method: "GET" }, false, false);
-	/** PageIds */
-	const [{ data: pages }] = useAxiosGet(process.env.REACT_APP_TENANTS_API_BASE, `Page?tenantId=${user?.currentTenantId}`, { method: "GET" }, !!!user?.currentTenantId, false);
-	/** TransactionTypeTransactionAction */
-	const postCreateTransactionTypeTransactionAction = async (transactionTypeTransactionAction) => {
-		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeTransactionAction`, { method: "POST" }, { data: transactionTypeTransactionAction });
-	};
-	const putUpdateTransactionTypeTransactionAction = async (transactionTypeTransactionActionId, transactionTypeTransactionAction) => {
-		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeTransactionAction/${transactionTypeTransactionActionId}`, { method: "PUT" }, { data: transactionTypeTransactionAction });
-	};
-	const deleteTransactionTypeTransactionAction = async (transactionTypeTransactionActionId) => {
-		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeTransactionAction/${transactionTypeTransactionActionId}`, { method: "DELETE" });
-	};
-	/** TransactionUiAction */
-	const postCreateTransactionUiAction = async (transactionUiAction) => {
-		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionUiAction`, { method: "POST" }, { data: transactionUiAction });
-	};
-	const putUpdateTransactionUiAction = async (transactionUiActionId, transactionUiAction) => {
-		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionUiAction/${transactionUiActionId}`, { method: "PUT" }, { data: transactionUiAction });
-	};
-	const deleteTransactionUiAction = async (transactionUiActionId) => {
-		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionUiAction/${transactionUiActionId}`, { method: "DELETE" });
-	};
-	const [{ data: tUiActionsList }, fetchTUiActionsList] = useAxiosGet(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionUiAction/search`, {
-		method: "post",
-		data: {
-			filterElements: [{
-				searchField: "TransactionTypeId",
-				searchOperator: "=",
-				searchValue: selectedTransactionType?.transactionTypeId,
-				groupId: 1
-			}],
-			getAll: true
-		}
-	}, !!!selectedTransactionType?.transactionTypeId, false);
-	/** TransactionUiActionType */
-	const [{ data: transactionUiActionTypes }] = useAxiosGet(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionUiActionType`, { method: "GET" }, false, false);
-	const currentApiCatalogId = useCatalogStore((state) => state.currentApiCatalogId);
-	const { data: catalogObjects } = useApiCatalog(currentApiCatalogId);
-	const catalogObjectProperties = useMemo(() => {
-		const catalogObjectList = catalogObjects?.ctlg?.catalogObjectList;
-		if (!catalogObjectList) return [];
-		const catalogObject = catalogObjectList?.find((obj) => (obj.catalogObjectName === selectedTransactionType?.domainName || obj.catalogObjectName === selectedDomainName) && obj.apiCatalogId === currentApiCatalogId);
-		if (!catalogObject) return [];
-		return catalogObject?.properties.filter((property) => property.name !== "businessObjectKey" && property.name !== null).map((property) => property.name);
+		return formattedData;
 	}, [
-		catalogObjects,
-		selectedTransactionType,
-		selectedDomainName,
-		currentApiCatalogId
+		initialData,
+		transactionRuleTypes,
+		roles,
+		ttstatusesWithNostatusOption
 	]);
-	/** Sidesheet handlers */
-	const handleSideSheet = useCallback((isOpen, transactionType) => {
+	useImperativeHandle(ref, () => ({ submit: () => {
+		handleSubmitRef?.current();
+	} }));
+	const handleSubmit = useCallback((formData) => {
+		onSubmit(formData, initialData);
+	}, [initialData, onSubmit]);
+	return /* @__PURE__ */ React.createElement(Form$1, {
+		onSubmit: handleSubmit,
+		mutators: { ...arrayMutators },
+		initialValues: { ...formInitialValues },
+		render: ({ handleSubmit: handleSubmit$1, form }) => {
+			handleSubmitRef.current = handleSubmit$1;
+			const push = form?.mutators?.push ?? (() => {});
+			return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Field$1, {
+				component: FluentTextField,
+				label: t("Name"),
+				id: "name",
+				name: "name",
+				fullWidth: true,
+				variant: "outlined",
+				margin: "normal",
+				size: "small"
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("Transaction Rule Type"),
+				id: "transactionRuleType",
+				name: "transactionRuleType",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: transactionRuleTypes || [],
+				getOptionLabelFunction: (option) => option.name,
+				valueForChange: (value) => {
+					return value;
+				},
+				required: true
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: FluentTextField,
+				label: t("Order"),
+				id: "order",
+				name: "order",
+				fullWidth: true,
+				variant: "outlined",
+				margin: "normal",
+				size: "small",
+				type: "number",
+				required: true
+			}), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "nudge" }), /* @__PURE__ */ React.createElement(FormControlLabel, {
+				control: /* @__PURE__ */ React.createElement(Field$1, {
+					component: Switch,
+					id: "enabled",
+					name: "enabled",
+					type: "checkbox",
+					defaultValue: true
+				}),
+				label: t("Enabled")
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("Current Status"),
+				id: "currentStatus",
+				name: "currentStatus",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: ttstatusesWithNostatusOption || [],
+				getOptionLabelFunction: (option) => option.name
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("Allowed Roles"),
+				id: "tenantUserRoles",
+				name: "tenantUserRoles",
+				variant: "outlined",
+				isMultiple: true,
+				disableCloseOnSelect: true,
+				options: roles || [],
+				getOptionLabelFunction: (option) => option.name
+			}), /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("div", { className: classes.addRemoveButtons }, /* @__PURE__ */ React.createElement(FluentButton, {
+				variant: "contained",
+				color: "primary",
+				onClick: () => push("currentDomainValue", void 0)
+			}, t("Add a Domain Field"))), /* @__PURE__ */ React.createElement(FieldArray, { name: "currentDomainValue" }, ({ fields }) => fields.map((name, index) => /* @__PURE__ */ React.createElement("div", {
+				key: `${name}${index}`,
+				className: classes.domainFields
+			}, /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: index === 0 && t("Field"),
+				name: `${name}[0]`,
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: catalogObjectProperties || [],
+				getOptionLabelFunction: (option) => option,
+				onChange: () => {}
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: FluentTextField,
+				label: index === 0 && t("Value"),
+				name: `${name}[1]`,
+				fullWidth: true,
+				variant: "outlined",
+				margin: "normal",
+				size: "small",
+				onChange: () => {}
+			}), /* @__PURE__ */ React.createElement("span", {
+				onClick: () => fields.remove(index),
+				style: { cursor: "pointer" },
+				className: classes.removeIcon
+			}, /* @__PURE__ */ React.createElement(StatusCircleErrorXIcon, null)))))));
+		}
+	});
+};
+var UdpTransactionTypeConfigurationForm_default = forwardRef(UdpTransactionTypeConfigurationForm);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/sidesheets/UdpTransactionTypeConfigurationCreateAndEditSidesheet.jsx
+const UdpTransactionTypeConfigurationCreateAndEditSidesheet = (props) => {
+	const { initialTransactionTypeConfiguration, isSideSheetOpen, handleSideSheet, handleCreateTransactionTypeConfiguration, handleUpdateTransactionTypeConfiguration, transactionRuleTypes, catalogObjectProperties, ttstatuses, roles } = props;
+	const isEditing = !!initialTransactionTypeConfiguration;
+	const formRef = useRef();
+	const { t } = useTranslation();
+	const onSubmitForm = useCallback(async (values, initialData) => {
+		if (initialData) await handleUpdateTransactionTypeConfiguration(values, initialData);
+		else await handleCreateTransactionTypeConfiguration(values);
+	}, [handleCreateTransactionTypeConfiguration, handleUpdateTransactionTypeConfiguration]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 500,
+		title: isEditing ? t("Edit Rule") : t("Create Rule"),
+		onClose: () => handleSideSheet(false),
+		buttonLabel: isEditing ? t("Save") : t("Create"),
+		onSubmit: () => {
+			formRef?.current?.submit();
+		}
+	}, /* @__PURE__ */ React.createElement(UdpTransactionTypeConfigurationForm_default, {
+		ref: formRef,
+		onSubmit: onSubmitForm,
+		initialData: initialTransactionTypeConfiguration,
+		transactionRuleTypes,
+		catalogObjectProperties,
+		transactionTypeStatusOptions: ttstatuses,
+		roles
+	}));
+};
+var UdpTransactionTypeConfigurationCreateAndEditSidesheet_default = UdpTransactionTypeConfigurationCreateAndEditSidesheet;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/forms/UdpTransactionTypeConfigurationTransactionActionForm.jsx
+const UdpTransactionTypeConfigurationTransactionActionForm = (props, ref) => {
+	const { onSubmit, initialData, transactionTypeTransactionActionOptions, isEditing } = props;
+	const { t } = useTranslation();
+	const handleSubmitRef = useRef();
+	useImperativeHandle(ref, () => ({ submit: () => {
+		handleSubmitRef?.current();
+	} }));
+	const handleSubmit = useCallback((formData) => {
+		onSubmit(formData, initialData);
+	}, [initialData, onSubmit]);
+	return /* @__PURE__ */ React.createElement(Form$1, {
+		onSubmit: handleSubmit,
+		render: ({ handleSubmit: handleSubmit$1 }) => {
+			handleSubmitRef.current = handleSubmit$1;
+			return /* @__PURE__ */ React.createElement(React.Fragment, null, isEditing && /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("TransactionTypeTransactionActions"),
+				id: "transactionTypeTransactionAction",
+				name: "transactionTypeTransactionAction",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: transactionTypeTransactionActionOptions || [],
+				getOptionLabelFunction: (option) => option.name,
+				initialValue: transactionTypeTransactionActionOptions?.find((ttta) => ttta?.transactionTypeTransactionActionId === initialData?.transactionTypeTransactionActionId) || null,
+				required: true
+			}), !!!isEditing && /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("Actions to Link"),
+				id: "transactionTypeTransactionActions",
+				name: "transactionTypeTransactionActions",
+				variant: "outlined",
+				isMultiple: true,
+				disableCloseOnSelect: true,
+				options: transactionTypeTransactionActionOptions || [],
+				getOptionLabelFunction: (option) => option.name,
+				required: true
+			}));
+		}
+	});
+};
+var UdpTransactionTypeConfigurationTransactionActionForm_default = forwardRef(UdpTransactionTypeConfigurationTransactionActionForm);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/sidesheets/UdpTransactionTypeConfigurationTransactionActionCreateAndEditSidesheet.jsx
+const UdpTransactionTypeConfigurationTransactionActionCreateAndEditSidesheet = (props) => {
+	const { initialTransactionTypeConfigurationTransactionAction, isSideSheetOpen, handleSideSheet, handleCreateTransactionTypeConfigurationTransactionAction, handleUpdateTransactionTypeConfigurationTransactionAction, transactionTypeTransactionActions, existingTtctaList } = props;
+	const isEditing = !!initialTransactionTypeConfigurationTransactionAction;
+	const formRef = useRef();
+	const { t } = useTranslation();
+	const normalizeToArray = (source) => {
+		if (Array.isArray(source)) return source;
+		return [];
+	};
+	const filterAvailableTTTActions = useCallback((allTTTActions, existingTTCTActions, currentTransactionTypeTransactionActionId = null) => {
+		const allTTTActionsArray = normalizeToArray(allTTTActions);
+		const usedTTTActionIds = normalizeToArray(existingTTCTActions?.pageList).map((action) => action.transactionTypeTransactionActionId).filter((id) => id !== void 0 && id !== currentTransactionTypeTransactionActionId);
+		return allTTTActionsArray.filter((type) => !usedTTTActionIds.includes(type.transactionTypeTransactionActionId));
+	}, []);
+	const availableTTTActionOptions = useMemo(() => {
+		if (!transactionTypeTransactionActions || !existingTtctaList) return [];
+		return filterAvailableTTTActions(transactionTypeTransactionActions, existingTtctaList, initialTransactionTypeConfigurationTransactionAction ? initialTransactionTypeConfigurationTransactionAction.transactionTypeTransactionActionId : null);
+	}, [
+		transactionTypeTransactionActions,
+		existingTtctaList,
+		initialTransactionTypeConfigurationTransactionAction,
+		filterAvailableTTTActions
+	]);
+	const onSubmitForm = useCallback(async (values, initialData) => {
+		if (initialData) await handleUpdateTransactionTypeConfigurationTransactionAction(values, initialData);
+		else await handleCreateTransactionTypeConfigurationTransactionAction(values);
+	}, [handleCreateTransactionTypeConfigurationTransactionAction, handleUpdateTransactionTypeConfigurationTransactionAction]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 500,
+		title: isEditing ? t("Edit Linked Action") : t("Create Linked Action"),
+		onClose: () => handleSideSheet(false),
+		buttonLabel: isEditing ? t("Save") : t("Create"),
+		onSubmit: () => {
+			formRef?.current?.submit();
+		}
+	}, /* @__PURE__ */ React.createElement(UdpTransactionTypeConfigurationTransactionActionForm_default, {
+		ref: formRef,
+		onSubmit: onSubmitForm,
+		initialData: initialTransactionTypeConfigurationTransactionAction,
+		transactionTypeTransactionActionOptions: availableTTTActionOptions,
+		isEditing
+	}));
+};
+var UdpTransactionTypeConfigurationTransactionActionCreateAndEditSidesheet_default = UdpTransactionTypeConfigurationTransactionActionCreateAndEditSidesheet;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/sidesheets/UdpTransactionTypeConfigurationTransactionActionSidesheet.jsx
+const UdpTransactionTypeConfigurationTransactionActionSidesheet = (props, ref) => {
+	const { transactionTypeConfiguration, transactionTypeConfigurationTransactionAction, isSideSheetOpen, handleTransactionTypeConfigurationTransactionActionSidesheet, isCreateOrEditSidesheetOpen, handleCreateOrEditTransactionTypeConfigurationTransactionActionSidesheet, handleCreateTransactionTypeConfigurationTransactionAction, handleUpdateTransactionTypeConfigurationTransactionAction, handleDeleteTransactionTypeConfigurationTransactionAction, tttactions, ttctaList } = props;
+	const ttctaGridApiRef = useRef(null);
+	const { t } = useTranslation();
+	useImperativeHandle(ref, () => ({ refreshServerSide: () => {
+		ttctaGridApiRef?.current?.refreshServerSide();
+	} }));
+	const getTTTActionName = useCallback((transactionTypeTransactionActionId) => {
+		if (!tttactions?.length) return "";
+		return tttactions.find((ttta) => ttta.transactionTypeTransactionActionId === transactionTypeTransactionActionId)?.name || "";
+	}, [tttactions]);
+	const columnDefs = useMemo(() => {
+		return [
+			{
+				headerName: t("TransactionTypeConfiguration"),
+				field: "transactionTypeConfigurationId",
+				resizable: true,
+				sortable: false,
+				hide: true
+			},
+			{
+				headerName: t("TransactionTypeTransactionAction"),
+				field: "transactionTypeTransactionActionId",
+				resizable: false,
+				sortable: false,
+				hide: true
+			},
+			{
+				headerName: t("Name"),
+				field: "name",
+				resizable: true,
+				sortable: false,
+				valueGetter: (params) => getTTTActionName(params?.data?.transactionTypeTransactionActionId)
+			},
+			{
+				headerName: t("Actions"),
+				field: "actions",
+				cellRenderer: "actionsRenderer",
+				cellRendererParams: { actionList: [{
+					id: 1,
+					title: t("Delete"),
+					iconName: "trashCan",
+					handleOnClick: (e, transactionTypeConfigurationTransactionAction$1) => {
+						handleDeleteTransactionTypeConfigurationTransactionAction(transactionTypeConfigurationTransactionAction$1?.data);
+					}
+				}] },
+				suppressMenu: true,
+				sortable: false,
+				filter: false,
+				valueGetter: (params) => params.data
+			}
+		];
+	}, [
+		t,
+		handleDeleteTransactionTypeConfigurationTransactionAction,
+		getTTTActionName
+	]);
+	const headerConfig = {
+		title: t("Linked Actions"),
+		primaryActionButton: {
+			label: t("Add"),
+			iconName: "add",
+			onClick: () => handleCreateOrEditTransactionTypeConfigurationTransactionActionSidesheet(true)
+		}
+	};
+	const gridFunctions = [
+		{ name: "agGridSizeColumnsToFit" },
+		{ name: "agGridAutoSizeColumns" },
+		{ name: "agGridResetColumns" },
+		{ name: "agGridHideShowColumns" }
+	];
+	const gridOptions = useMemo(() => {
+		return { pagination: true };
+	}, []);
+	const handleGridApiCallback = (api) => {
+		ttctaGridApiRef.current = api;
+	};
+	const searchMethodConfig = useMemo(() => {
+		let filterElements = [];
+		if (transactionTypeConfiguration?.transactionTypeConfigurationId) filterElements = [{
+			searchField: "TransactionTypeConfigurationId",
+			searchOperator: "=",
+			searchValue: transactionTypeConfiguration?.transactionTypeConfigurationId,
+			groupId: 1
+		}];
+		return {
+			requestUrl: `${process.env.REACT_APP_PRODUCT_API_BASE}/UdpTransactionTypeConfigurationTransactionAction/search`,
+			customSearchObject: { filterElements }
+		};
+	}, [transactionTypeConfiguration]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 700,
+		title: t("Manage Linked Actions"),
+		onClose: () => handleTransactionTypeConfigurationTransactionActionSidesheet(false)
+	}, /* @__PURE__ */ React.createElement(SearchMethodUdpGrid, {
+		searchMethodConfig,
+		columnDefs,
+		gridHeaderConfig: headerConfig,
+		gridOptions,
+		gridApiCallback: handleGridApiCallback,
+		gridFunctions
+	}), /* @__PURE__ */ React.createElement(UdpTransactionTypeConfigurationTransactionActionCreateAndEditSidesheet_default, {
+		initialTransactionTypeConfigurationTransactionAction: transactionTypeConfigurationTransactionAction,
+		isSideSheetOpen: isCreateOrEditSidesheetOpen,
+		handleCreateTransactionTypeConfigurationTransactionAction,
+		handleUpdateTransactionTypeConfigurationTransactionAction,
+		handleSideSheet: handleCreateOrEditTransactionTypeConfigurationTransactionActionSidesheet,
+		transactionTypeTransactionActions: tttactions,
+		existingTtctaList: ttctaList
+	}));
+};
+var UdpTransactionTypeConfigurationTransactionActionSidesheet_default = forwardRef(UdpTransactionTypeConfigurationTransactionActionSidesheet);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/sidesheets/UdpTransactionTypeConfigurationSidesheet.jsx
+const UdpTransactionTypeConfigurationSidesheet = (props, ref) => {
+	const { transactionType, transactionTypeConfiguration, isSideSheetOpen, isCreateOrEditTransactionTypeConfigurationSidesheetOpen, handleTransactionTypeConfigurationSidesheet, handleCreateOrEditTransactionTypeConfigurationSidesheet, handleCreateTransactionTypeConfiguration, handleUpdateTransactionTypeConfiguration, handleDeleteTransactionTypeConfiguration, transactionRuleTypes, catalogObjectProperties, ttstatuses, roles, transactionTypeConfigurationTransactionAction, isTransactionTypeConfigurationTransactionActionSidesheetOpen, handleTransactionTypeConfigurationTransactionActionSidesheet, handleCreateOrEditTransactionTypeConfigurationTransactionActionSidesheet, isCreateOrEditTransactionTypeConfigurationTransactionActionSidesheetOpen, tttactions, handleCreateTransactionTypeConfigurationTransactionAction, handleUpdateTransactionTypeConfigurationTransactionAction, handleDeleteTransactionTypeConfigurationTransactionAction, ttctaList, ttctaGridApiRef } = props;
+	const transactionTypeConfigurationGridApiRef = useRef(null);
+	const { t } = useTranslation();
+	useImperativeHandle(ref, () => ({ refreshServerSide: () => {
+		transactionTypeConfigurationGridApiRef?.current?.refreshServerSide();
+	} }));
+	const getTransactionRuleTypeName = useCallback((transactionRuleTypeId) => {
+		if (!transactionRuleTypes) return "";
+		return (transactionRuleTypes?.find((transactionRuleType) => transactionRuleType?.transactionRuleTypeId === transactionRuleTypeId))?.name || "";
+	}, [transactionRuleTypes]);
+	const columnDefs = useMemo(() => {
+		return [
+			{
+				headerName: t("TransactionTypeConfigurationId"),
+				field: "transactionTypeConfigurationId",
+				resizable: true,
+				sortable: false,
+				hide: true
+			},
+			{
+				headerName: t("Name"),
+				field: "name",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Order"),
+				field: "order",
+				resizable: false,
+				sortable: false
+			},
+			{
+				headerName: t("Enabled"),
+				field: "enabled",
+				resizable: false,
+				sortable: false,
+				cellDataType: "boolean"
+			},
+			{
+				headerName: t("Rule Type"),
+				resizable: false,
+				sortable: false,
+				valueGetter: (params) => getTransactionRuleTypeName(params?.data?.transactionRuleTypeId)
+			},
+			{
+				headerName: t("Actions"),
+				field: "actions",
+				cellRenderer: "actionsRenderer",
+				cellRendererParams: { actionList: [
+					{
+						id: 0,
+						title: t("Edit"),
+						iconName: "edit",
+						handleOnClick: (e, transactionTypeConfiguration$1) => {
+							handleCreateOrEditTransactionTypeConfigurationSidesheet(true, transactionTypeConfiguration$1?.data);
+						}
+					},
+					{
+						id: 1,
+						title: t("Delete"),
+						iconName: "trashCan",
+						handleOnClick: (e, transactionTypeConfiguration$1) => {
+							handleDeleteTransactionTypeConfiguration(transactionTypeConfiguration$1?.data);
+						}
+					},
+					{
+						id: 2,
+						title: t("Link"),
+						iconName: "link",
+						handleOnClick: (e, transactionTypeConfiguration$1) => {
+							handleTransactionTypeConfigurationTransactionActionSidesheet(true, transactionTypeConfiguration$1?.data);
+						}
+					}
+				] },
+				suppressMenu: true,
+				sortable: false,
+				filter: false,
+				valueGetter: (params) => params.data
+			}
+		];
+	}, [
+		t,
+		handleCreateOrEditTransactionTypeConfigurationSidesheet,
+		handleDeleteTransactionTypeConfiguration,
+		getTransactionRuleTypeName,
+		handleTransactionTypeConfigurationTransactionActionSidesheet
+	]);
+	const headerConfig = {
+		title: t("Rules"),
+		primaryActionButton: {
+			label: t("Add"),
+			iconName: "add",
+			onClick: () => handleCreateOrEditTransactionTypeConfigurationSidesheet(true)
+		}
+	};
+	const gridFunctions = [
+		{ name: "agGridSizeColumnsToFit" },
+		{ name: "agGridAutoSizeColumns" },
+		{ name: "agGridResetColumns" },
+		{ name: "agGridHideShowColumns" }
+	];
+	const gridOptions = useMemo(() => {
+		return { pagination: true };
+	}, []);
+	const handleGridApiCallback = (api) => {
+		transactionTypeConfigurationGridApiRef.current = api;
+	};
+	const searchMethodConfig = useMemo(() => {
+		let filterElements = [];
+		if (transactionType?.transactionTypeId) filterElements = [{
+			searchField: "TransactionTypeId",
+			searchOperator: "=",
+			searchValue: transactionType?.transactionTypeId,
+			groupId: 1
+		}];
+		return {
+			requestUrl: `${process.env.REACT_APP_PRODUCT_API_BASE}/UdpTransactionTypeConfiguration/search`,
+			customSearchObject: { filterElements }
+		};
+	}, [transactionType]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 800,
+		title: t("Manage Rules"),
+		onClose: () => handleTransactionTypeConfigurationSidesheet(false)
+	}, /* @__PURE__ */ React.createElement(SearchMethodUdpGrid, {
+		searchMethodConfig,
+		columnDefs,
+		gridHeaderConfig: headerConfig,
+		gridOptions,
+		gridApiCallback: handleGridApiCallback,
+		gridFunctions
+	}), /* @__PURE__ */ React.createElement(UdpTransactionTypeConfigurationCreateAndEditSidesheet_default, {
+		initialTransactionTypeConfiguration: transactionTypeConfiguration,
+		isSideSheetOpen: isCreateOrEditTransactionTypeConfigurationSidesheetOpen,
+		handleCreateTransactionTypeConfiguration,
+		handleUpdateTransactionTypeConfiguration,
+		handleSideSheet: handleCreateOrEditTransactionTypeConfigurationSidesheet,
+		transactionRuleTypes,
+		catalogObjectProperties,
+		ttstatuses,
+		roles
+	}), /* @__PURE__ */ React.createElement(UdpTransactionTypeConfigurationTransactionActionSidesheet_default, {
+		ref: ttctaGridApiRef,
+		transactionTypeConfiguration,
+		transactionTypeConfigurationTransactionAction,
+		isSideSheetOpen: isTransactionTypeConfigurationTransactionActionSidesheetOpen,
+		handleTransactionTypeConfigurationTransactionActionSidesheet,
+		handleCreateOrEditTransactionTypeConfigurationTransactionActionSidesheet,
+		isCreateOrEditSidesheetOpen: isCreateOrEditTransactionTypeConfigurationTransactionActionSidesheetOpen,
+		tttactions,
+		handleCreateTransactionTypeConfigurationTransactionAction,
+		handleUpdateTransactionTypeConfigurationTransactionAction,
+		handleDeleteTransactionTypeConfigurationTransactionAction,
+		ttctaList
+	}));
+};
+var UdpTransactionTypeConfigurationSidesheet_default = forwardRef(UdpTransactionTypeConfigurationSidesheet);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/forms/UdpTransactionAttachmentTypeForm.jsx
+const UdpTransactionAttachmentTypeForm = (props, ref) => {
+	const { onSubmit, initialData } = props;
+	const handleSubmitRef = useRef();
+	const { t } = useTranslation();
+	useImperativeHandle(ref, () => ({ submit: () => {
+		handleSubmitRef?.current();
+	} }));
+	const handleSubmit = useCallback((formData) => {
+		onSubmit(formData, initialData);
+	}, [initialData, onSubmit]);
+	return /* @__PURE__ */ React.createElement(Form$1, {
+		onSubmit: handleSubmit,
+		render: ({ handleSubmit: handleSubmit$1 }) => {
+			handleSubmitRef.current = handleSubmit$1;
+			return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Field$1, {
+				component: FluentTextField,
+				label: t("Name"),
+				id: "name",
+				name: "name",
+				fullWidth: true,
+				variant: "outlined",
+				margin: "normal",
+				size: "small",
+				required: true,
+				initialValue: initialData?.name || ""
+			}));
+		}
+	});
+};
+var UdpTransactionAttachmentTypeForm_default = forwardRef(UdpTransactionAttachmentTypeForm);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/sidesheets/UdpTransactionAttachmentTypeCreateAndEditSidesheet.jsx
+const UdpTransactionAttachmentTypeCreateAndEditSidesheet = (props) => {
+	const { initialTransactionAttachmentType, isSideSheetOpen, handleCreateTransactionAttachmentType, handleUpdateTransactionAttachmentType, handleSideSheet } = props;
+	const isEditing = !!initialTransactionAttachmentType;
+	const formRef = useRef();
+	const { t } = useTranslation();
+	const onSubmitForm = useCallback(async (values, initialData) => {
+		if (initialData) await handleUpdateTransactionAttachmentType(values, initialData);
+		else await handleCreateTransactionAttachmentType(values);
+	}, [handleCreateTransactionAttachmentType, handleUpdateTransactionAttachmentType]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 500,
+		title: isEditing ? t("Edit Attachment Type") : t("Create Attachment Type"),
+		onClose: () => handleSideSheet(false),
+		buttonLabel: isEditing ? t("Save") : t("Create"),
+		onSubmit: () => {
+			formRef?.current?.submit();
+		}
+	}, /* @__PURE__ */ React.createElement(UdpTransactionAttachmentTypeForm_default, {
+		ref: formRef,
+		onSubmit: onSubmitForm,
+		initialData: initialTransactionAttachmentType
+	}));
+};
+var UdpTransactionAttachmentTypeCreateAndEditSidesheet_default = UdpTransactionAttachmentTypeCreateAndEditSidesheet;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/sidesheets/UdpTransactionAttachmentTypeSidesheet.jsx
+const UdpTransactionAttachmentTypeSidesheet = (props, ref) => {
+	const { transactionType, transactionAttachmentType, isSideSheetOpen, isTransactionAttachmentTypeCreateOrEditSidesheetOpen, handleTransactionAttachmentTypeSidesheet, handleCreateOrEditTransactionAttachmentTypeSidesheet, handleCreateTransactionAttachmentType, handleUpdateTransactionAttachmentType, handleDeleteTransactionAttachmentType } = props;
+	const transactionAttachmentTypeGridApiRef = useRef(null);
+	const { t } = useTranslation();
+	useImperativeHandle(ref, () => ({ refreshServerSide: () => {
+		transactionAttachmentTypeGridApiRef?.current?.refreshServerSide();
+	} }));
+	const columnDefs = useMemo(() => {
+		return [
+			{
+				headerName: t("Attachment Type Id"),
+				field: "transactionAttachmentTypeId",
+				resizable: true,
+				sortable: false,
+				hide: true
+			},
+			{
+				headerName: t("Name"),
+				field: "name",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Actions"),
+				field: "actions",
+				cellRenderer: "actionsRenderer",
+				cellRendererParams: { actionList: [{
+					id: 0,
+					title: t("Edit"),
+					iconName: "edit",
+					handleOnClick: (e, transactionAttachmentType$1) => {
+						handleCreateOrEditTransactionAttachmentTypeSidesheet(true, transactionAttachmentType$1?.data);
+					}
+				}, {
+					id: 1,
+					title: t("Delete"),
+					iconName: "trashCan",
+					handleOnClick: (e, transactionAttachmentType$1) => {
+						handleDeleteTransactionAttachmentType(transactionAttachmentType$1?.data);
+					}
+				}] },
+				suppressMenu: true,
+				sortable: false,
+				filter: false,
+				valueGetter: (params) => params.data
+			}
+		];
+	}, [
+		t,
+		handleCreateOrEditTransactionAttachmentTypeSidesheet,
+		handleDeleteTransactionAttachmentType
+	]);
+	const headerConfig = {
+		title: t("Attachment Types"),
+		primaryActionButton: {
+			label: t("Add"),
+			iconName: "add",
+			onClick: () => handleCreateOrEditTransactionAttachmentTypeSidesheet(true)
+		}
+	};
+	const gridFunctions = [
+		{ name: "agGridExport" },
+		{ name: "agGridSizeColumnsToFit" },
+		{ name: "agGridAutoSizeColumns" },
+		{ name: "agGridResetColumns" },
+		{ name: "agGridHideShowColumns" }
+	];
+	const gridOptions = useMemo(() => {
+		return { pagination: true };
+	}, []);
+	const handleGridApiCallback = (api) => {
+		transactionAttachmentTypeGridApiRef.current = api;
+	};
+	const searchMethodConfig = useMemo(() => {
+		let filterElements = [];
+		if (transactionType?.transactionTypeId) filterElements = [{
+			searchField: "TransactionTypeId",
+			searchOperator: "=",
+			searchValue: transactionType?.transactionTypeId,
+			groupId: 1
+		}];
+		return {
+			requestUrl: `${process.env.REACT_APP_PRODUCT_API_BASE}/UdpTransactionAttachmentType/search`,
+			customSearchObject: { filterElements }
+		};
+	}, [transactionType]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 800,
+		title: t("Manage Attachment Types"),
+		onClose: () => handleTransactionAttachmentTypeSidesheet(false)
+	}, /* @__PURE__ */ React.createElement(SearchMethodUdpGrid, {
+		searchMethodConfig,
+		columnDefs,
+		gridHeaderConfig: headerConfig,
+		gridOptions,
+		gridApiCallback: handleGridApiCallback,
+		gridFunctions
+	}), /* @__PURE__ */ React.createElement(UdpTransactionAttachmentTypeCreateAndEditSidesheet_default, {
+		initialTransactionAttachmentType: transactionAttachmentType,
+		isSideSheetOpen: isTransactionAttachmentTypeCreateOrEditSidesheetOpen,
+		handleCreateTransactionAttachmentType,
+		handleUpdateTransactionAttachmentType,
+		handleSideSheet: handleCreateOrEditTransactionAttachmentTypeSidesheet
+	}));
+};
+var UdpTransactionAttachmentTypeSidesheet_default = forwardRef(UdpTransactionAttachmentTypeSidesheet);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/UdpTransactionTypesPage.jsx
+const baseSearchPayload = {
+	pageNumber: 1,
+	pageSize: 100,
+	filterElements: [],
+	filterGroups: [],
+	orderElements: [],
+	groupingType: "",
+	groupProperty: [],
+	groupOperationList: [],
+	eagerLoad: false,
+	logicalSearchOperator: 1
+};
+const useStyles = makeStyles((theme) => ({ loadingBar: {
+	bottom: theme.spacing(-.5),
+	marginLeft: theme.spacing(.5),
+	marginRight: theme.spacing(.5)
+} }));
+/**
+* This function formats the 'Configuration' data into a specific format that can be
+* used by the external library jsonLogic. The formatted data is stored in the
+* udp.TransactionTypeConfiguration table in the ExpressionLogic column.
+*/
+const formatTransactionTypeConfigurationIntoExpressionLogic = (configurationObj) => {
+	if (!configurationObj || typeof configurationObj !== "object") return "";
+	const { CurrentStatus, CurrentDomainValue, TenantUserRoleIds } = configurationObj;
+	const andConditions = [];
+	if (CurrentStatus) andConditions.push({ "==": [{ var: "currentStatusId" }, CurrentStatus?.transactionTypeStatusId === EMPTY_GUID ? null : CurrentStatus?.transactionTypeStatusId] });
+	if (CurrentDomainValue && typeof CurrentDomainValue === "object") Object.entries(CurrentDomainValue).forEach(([field, value]) => {
+		if (!field || value === void 0) return;
+		andConditions.push({ "==": [{ var: `currentDomainValue.${field}` }, value] });
+	});
+	if (Array.isArray(TenantUserRoleIds) && TenantUserRoleIds.length > 0) andConditions.push({ some: [{ var: "tenantUserRoleIds" }, { in: [{ var: "" }, TenantUserRoleIds] }] });
+	if (!andConditions.length) return "";
+	return { and: andConditions };
+};
+const UdpTransactionTypesPage = () => {
+	const user = useUser();
+	const { t } = useTranslation();
+	const classes = useStyles();
+	const { enqueueSnackbar, closeSnackbar } = useSnackbar();
+	const successAction = getSuccessAction(closeSnackbar);
+	const gridApiRef = useRef(null);
+	const ttsGridApiRef = useRef(null);
+	const tttaGridApiRef = useRef(null);
+	const tuaGridApiRef = useRef(null);
+	const ttcGridApiRef = useRef(null);
+	const ttctaGridApiRef = useRef(null);
+	const tatGridApiRef = useRef(null);
+	const [searchObject, setSearchObject] = useState(baseSearchPayload);
+	const [selectedTransactionType, setSelectedTransactionType] = useState(null);
+	const [isTransactionTypeSideSheetOpen, setIsTransactionTypeSideSheetOpen] = useState(false);
+	const [isTransactionTypeSidesheetLoading, setIsTransactionTypeSidesheetLoading] = useState(false);
+	const [isDeleteTransactionTypeDialogOpen, setIsDeleteTransactionTypeDialogOpen] = useState(false);
+	const [selectedDomainName, setSelectedDomainName] = useState("");
+	const [isTransactionTypeStatusSidesheetOpen, setIsTransactionTypeStatusSidesheetOpen] = useState(false);
+	const [isDeleteTransactionTypeStatusDialogOpen, setIsDeleteTransactionTypeStatusDialogOpen] = useState(false);
+	const [selectedTransactionTypeStatus, setSelectedTransactionTypeStatus] = useState(null);
+	const [isCreateOrEditTransactionTypeStatusSidesheetOpen, setIsCreateOrEditTransactionTypeStatusSidesheetOpen] = useState(false);
+	const [ttstatuses, setTTStatuses] = useState([]);
+	const [isTransactionTypeTransactionActionSidesheetOpen, setIsTransactionTypeTransactionActionSidesheetOpen] = useState(false);
+	const [selectedTransactionTypeTransactionAction, setSelectedTransactionTypeTransactionAction] = useState(null);
+	const [isCreateOrEditTransactionTypeTransactionActionSidesheetOpen, setIsCreateOrEditTransactionTypeTransactionActionSidesheetOpen] = useState(false);
+	const [isDeleteTransactionTypeTransactionActionDialogOpen, setIsDeleteTransactionTypeTransactionActionDialogOpen] = useState(false);
+	const [tttactions, setTTTActions] = useState([]);
+	const [isTransactionUiActionSidesheetOpen, setIsTransactionUiActionSidesheetOpen] = useState(false);
+	const [selectedTransactionUiAction, setSelectedTransactionUiAction] = useState(null);
+	const [isCreateOrEditTransactionUiActionSidesheetOpen, setIsCreateOrEditTransactionUiActionSidesheetOpen] = useState(false);
+	const [isDeleteTransactionUiActionDialogOpen, setIsDeleteTransactionUiActionDialogOpen] = useState(false);
+	const [isTransactionTypeConfigurationSidesheetOpen, setIsTransactionTypeConfigurationSidesheetOpen] = useState(false);
+	const [selectedTransactionTypeConfiguration, setSelectedTransactionTypeConfiguration] = useState(null);
+	const [isCreateOrEditTransactionTypeConfigurationSidesheetOpen, setIsCreateOrEditTransactionTypeConfigurationSidesheetOpen] = useState(false);
+	const [isDeleteTransactionTypeConfigurationDialogOpen, setIsDeleteTransactionTypeConfigurationDialogOpen] = useState(false);
+	const [isTransactionTypeConfigurationTransactionActionSidesheetOpen, setIsTransactionTypeConfigurationTransactionActionSidesheetOpen] = useState(false);
+	const [selectedTransactionTypeConfigurationTransactionAction, setSelectedTransactionTypeConfigurationTransactionAction] = useState(null);
+	const [isCreateOrEditTransactionTypeConfigurationTransactionActionSidesheetOpen, setIsCreateOrEditTransactionTypeConfigurationTransactionActionSidesheetOpen] = useState(false);
+	const [isDeleteTransactionTypeConfigurationTransactionActionDialogOpen, setIsDeleteTransactionTypeConfigurationTransactionActionDialogOpen] = useState(false);
+	const [isTransactionAttachmentTypeSidesheetOpen, setIsTransactionAttachmentTypeSidesheetOpen] = useState(false);
+	const [selectedTransactionAttachmentType, setSelectedTransactionAttachmentType] = useState(null);
+	const [isCreateOrEditTransactionAttachmentTypeSidesheetOpen, setIsCreateOrEditTransactionAttachmentTypeSidesheetOpen] = useState(false);
+	const [isDeleteTransactionAttachmentTypeDialogOpen, setIsDeleteTransactionAttachmentTypeDialogOpen] = useState(false);
+	const hasDefaultAndClosedTransactionTypeStatus = useCallback((transactionTypeStatuses, checkHasDefault = false, checkHasClosedStatus = false, checkHasCancelledStatus = false) => {
+		if (!transactionTypeStatuses) return false;
+		return transactionTypeStatuses?.some((record) => {
+			if (record.transactionTypeStatusId !== selectedTransactionTypeStatus?.transactionTypeStatusId) {
+				const isDefault = record?.isDefault;
+				const isClosedStatus = record?.isClosedStatus;
+				const isCancelledStatus = record?.isCancelledStatus;
+				if (checkHasDefault && isDefault) return true;
+				if (checkHasClosedStatus && isClosedStatus) return true;
+				if (checkHasCancelledStatus && isCancelledStatus) return true;
+			}
+			return false;
+		});
+	}, [selectedTransactionTypeStatus]);
+	/** TransactionType */
+	const postCreateTransactionType = async (transactionType) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionType`, { method: "POST" }, { data: transactionType });
+	};
+	const putUpdateTransactionType = async (transactionTypeId, transactionType) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionType/${transactionTypeId}`, { method: "PUT" }, { data: transactionType });
+	};
+	const deleteTransactionType = async (transactionTypeId) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionType/${transactionTypeId}`, { method: "DELETE" });
+	};
+	const [{ data: transactionsByTransactionTypeId, loading: getTransactionsByTransactionIdLoading }, fetchTransactionsByTransactionTypeId] = useAxiosGet(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransaction/search`, {
+		method: "post",
+		data: {
+			filterElements: [{
+				searchField: "TransactionTypeId",
+				searchOperator: "=",
+				searchValue: selectedTransactionType?.transactionTypeId,
+				groupId: 1
+			}],
+			getAll: true
+		}
+	}, !!!selectedTransactionType?.transactionTypeId || !!!isDeleteTransactionTypeDialogOpen, false);
+	/** TransactionTypeStatus */
+	const postCreateTransactionTypeStatus = async (transactionTypeStatus) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeStatus`, { method: "POST" }, { data: transactionTypeStatus });
+	};
+	const putUpdateTransactionTypeStatus = async (transactionTypeStatusId, transactionTypeStatus) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeStatus/${transactionTypeStatusId}`, { method: "PUT" }, { data: transactionTypeStatus });
+	};
+	const deleteTransactionTypeStatus = async (transactionTypeStatusId) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeStatus/${transactionTypeStatusId}`, { method: "DELETE" });
+	};
+	const searchTransactionTypeStatusByTransactionTypeId = useCallback(async (transactionTypeId) => {
+		const searchPayload = {
+			filterElements: [{
+				searchField: "TransactionTypeId",
+				searchOperator: "=",
+				searchValue: transactionTypeId,
+				groupId: 1
+			}],
+			getAll: true
+		};
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeStatus/search`, { method: "POST" }, { data: searchPayload });
+	}, []);
+	useEffect(() => {
+		if (!selectedTransactionType?.transactionTypeId) return;
+		const loadTTStatuses = async () => {
+			const ttsResponse = await searchTransactionTypeStatusByTransactionTypeId(selectedTransactionType?.transactionTypeId);
+			if (ttsResponse?.status === 200) setTTStatuses(ttsResponse.data?.pageList);
+		};
+		loadTTStatuses();
+	}, [searchTransactionTypeStatusByTransactionTypeId, selectedTransactionType?.transactionTypeId]);
+	/** TransactionAction */
+	const [{ data: transactionActions }] = useAxiosGet(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionAction`, { method: "GET" }, false, false);
+	/** ActionApis */
+	const [{ data: actionApis }] = useAxiosGet(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionWorkflowActionApi`, { method: "GET" }, false, false);
+	/** PageIds */
+	const [{ data: pages }] = useAxiosGet(process.env.REACT_APP_TENANTS_API_BASE, `Page?tenantId=${user?.currentTenantId}`, { method: "GET" }, !!!user?.currentTenantId, false);
+	/** TransactionTypeTransactionAction */
+	const postCreateTransactionTypeTransactionAction = async (transactionTypeTransactionAction) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeTransactionAction`, { method: "POST" }, { data: transactionTypeTransactionAction });
+	};
+	const putUpdateTransactionTypeTransactionAction = async (transactionTypeTransactionActionId, transactionTypeTransactionAction) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeTransactionAction/${transactionTypeTransactionActionId}`, { method: "PUT" }, { data: transactionTypeTransactionAction });
+	};
+	const deleteTransactionTypeTransactionAction = async (transactionTypeTransactionActionId) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeTransactionAction/${transactionTypeTransactionActionId}`, { method: "DELETE" });
+	};
+	const searchTransactionTypeTransactionActionByTransactionTypeId = useCallback(async (transactionTypeId) => {
+		const searchPayload = {
+			filterElements: [{
+				searchField: "TransactionTypeId",
+				searchOperator: "=",
+				searchValue: transactionTypeId,
+				groupId: 1
+			}],
+			getAll: true
+		};
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeTransactionAction/search`, { method: "POST" }, { data: searchPayload });
+	}, []);
+	useEffect(() => {
+		if (!selectedTransactionType?.transactionTypeId) return;
+		const loadTTTActions = async () => {
+			const tttaResponse = await searchTransactionTypeTransactionActionByTransactionTypeId(selectedTransactionType?.transactionTypeId);
+			if (tttaResponse?.status === 200) setTTTActions(tttaResponse.data?.pageList);
+		};
+		loadTTTActions();
+	}, [searchTransactionTypeTransactionActionByTransactionTypeId, selectedTransactionType?.transactionTypeId]);
+	/** TransactionUiAction */
+	const postCreateTransactionUiAction = async (transactionUiAction) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionUiAction`, { method: "POST" }, { data: transactionUiAction });
+	};
+	const putUpdateTransactionUiAction = async (transactionUiActionId, transactionUiAction) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionUiAction/${transactionUiActionId}`, { method: "PUT" }, { data: transactionUiAction });
+	};
+	const deleteTransactionUiAction = async (transactionUiActionId) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionUiAction/${transactionUiActionId}`, { method: "DELETE" });
+	};
+	const [{ data: tUiActionsList }, fetchTUiActionsList] = useAxiosGet(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionUiAction/search`, {
+		method: "post",
+		data: {
+			filterElements: [{
+				searchField: "TransactionTypeId",
+				searchOperator: "=",
+				searchValue: selectedTransactionType?.transactionTypeId,
+				groupId: 1
+			}],
+			getAll: true
+		}
+	}, !!!isTransactionUiActionSidesheetOpen, false);
+	/** TransactionUiActionType */
+	const [{ data: transactionUiActionTypes }] = useAxiosGet(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionUiActionType`, { method: "GET" }, false, false);
+	/** TransactionTypeConfiguration */
+	const postCreateTransactionTypeConfiguration = async (transactionTypeConfiguration) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeConfiguration`, { method: "POST" }, { data: transactionTypeConfiguration });
+	};
+	const putUpdateTransactionTypeConfiguration = async (transactionTypeConfigurationId, transactionTypeConfiguration) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeConfiguration/${transactionTypeConfigurationId}`, { method: "PUT" }, { data: transactionTypeConfiguration });
+	};
+	const deleteTransactionTypeConfiguration = async (transactionTypeConfigurationId) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeConfiguration/${transactionTypeConfigurationId}`, { method: "DELETE" });
+	};
+	/** TransactionRuleType */
+	const [{ data: transactionRuleTypes }] = useAxiosGet(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionRuleType`, { method: "GET" }, false, false);
+	/** Roles */
+	const [{ data: roles }] = useAxiosGet(process.env.REACT_APP_TENANTS_API_BASE, `Roles?tenantId=${user?.currentTenantId}`, { method: "GET" }, !!!user?.currentTenantId, false);
+	/** TransactionTypeConfigurationTransactionAction */
+	const postCreateTransactionTypeConfigurationTransactionAction = async (ttcta) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeConfigurationTransactionAction/createBulk`, { method: "POST" }, { data: ttcta });
+	};
+	const putUpdateTransactionTypeConfigurationTransactionAction = async (transactionTypeConfigurationId, transactionTypeTransactionActionId, transactionTypeConfigurationTransactionAction) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeConfigurationTransactionAction/${transactionTypeConfigurationId}/${transactionTypeTransactionActionId}`, { method: "PUT" }, { data: transactionTypeConfigurationTransactionAction });
+	};
+	const deleteTransactionTypeConfigurationTransactionAction = async (transactionTypeConfigurationId, transactionTypeTransactionActionId) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeConfigurationTransactionAction/${transactionTypeConfigurationId}/${transactionTypeTransactionActionId}`, { method: "DELETE" });
+	};
+	const [{ data: ttctaList }, fetchTtctaList] = useAxiosGet(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeConfigurationTransactionAction/search`, {
+		method: "post",
+		data: {
+			filterElements: [{
+				searchField: "TransactionTypeConfigurationId",
+				searchOperator: "=",
+				searchValue: selectedTransactionTypeConfiguration?.transactionTypeConfigurationId,
+				groupId: 1
+			}],
+			getAll: true
+		}
+	}, !!!selectedTransactionTypeConfiguration?.transactionTypeConfigurationId, false);
+	/** TransactionAttachmenType */
+	const postCreateTransactionAttachmentType = async (transactionAttachmentType) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionAttachmentType`, { method: "POST" }, { data: transactionAttachmentType });
+	};
+	const putUpdateTransactionAttachmentType = async (transactionAttachmentTypeId, transactionAttachmentType) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionAttachmentType/${transactionAttachmentTypeId}`, { method: "PUT" }, { data: transactionAttachmentType });
+	};
+	const deleteTransactionAttachmentType = async (transactionAttachmentTypeId) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionAttachmentType/${transactionAttachmentTypeId}`, { method: "DELETE" });
+	};
+	const currentApiCatalogId = useCatalogStore((state) => state.currentApiCatalogId);
+	const { data: catalogObjects } = useApiCatalog(currentApiCatalogId);
+	const catalogObjectProperties = useMemo(() => {
+		const catalogObjectList = catalogObjects?.ctlg?.catalogObjectList;
+		if (!catalogObjectList) return [];
+		const catalogObject = catalogObjectList?.find((obj) => (obj.catalogObjectName === selectedTransactionType?.domainName || obj.catalogObjectName === selectedDomainName) && obj.apiCatalogId === currentApiCatalogId);
+		if (!catalogObject) return [];
+		return catalogObject?.properties.filter((property) => property.name !== "businessObjectKey" && property.name !== null).map((property) => property.name);
+	}, [
+		catalogObjects,
+		selectedTransactionType,
+		selectedDomainName,
+		currentApiCatalogId
+	]);
+	/** Sidesheet handlers */
+	const handleSideSheet = useCallback((isOpen, transactionType) => {
 		setIsTransactionTypeSideSheetOpen(isOpen);
 		setSelectedTransactionType(transactionType);
 	}, []);
@@ -1185,11 +2108,318 @@ const UdpTransactionTypesPage = () => {
 		setIsCreateOrEditTransactionUiActionSidesheetOpen(isOpen);
 		setSelectedTransactionUiAction(transactionUiAction);
 	}, []);
+	const handleTransactionTypeConfigurationSidesheet = useCallback((isOpen, transactionType) => {
+		setIsTransactionTypeConfigurationSidesheetOpen(isOpen);
+		setSelectedTransactionType(transactionType);
+	}, []);
+	const handleCreateOrEditTransactionTypeConfigurationSidesheet = useCallback((isOpen, transactionTypeConfiguration) => {
+		setIsCreateOrEditTransactionTypeConfigurationSidesheetOpen(isOpen);
+		setSelectedTransactionTypeConfiguration(transactionTypeConfiguration);
+	}, []);
+	const handleTransactionTypeConfigurationTransactionActionSidesheet = useCallback((isOpen, transactionTypeConfiguration) => {
+		setIsTransactionTypeConfigurationTransactionActionSidesheetOpen(isOpen);
+		setSelectedTransactionTypeConfiguration(transactionTypeConfiguration);
+	}, []);
+	const handleCreateOrEditTransactionTypeConfigurationTransactionActionSidesheet = useCallback((isOpen, transactionTypeConfigurationTransactionAction) => {
+		setIsCreateOrEditTransactionTypeConfigurationTransactionActionSidesheetOpen(isOpen);
+		setSelectedTransactionTypeConfigurationTransactionAction(transactionTypeConfigurationTransactionAction);
+	}, []);
+	const handleTransactionAttachmentTypeSidesheet = useCallback((isOpen, transactionType) => {
+		setIsTransactionAttachmentTypeSidesheetOpen(isOpen);
+		setSelectedTransactionType(transactionType);
+	}, []);
+	const handleCreateOrEditTransactionAttachmentTypeSidesheet = useCallback((isOpen, transactionAttachmentType) => {
+		setIsCreateOrEditTransactionAttachmentTypeSidesheetOpen(isOpen);
+		setSelectedTransactionAttachmentType(transactionAttachmentType);
+	}, []);
 	/** TransactionType */
 	const handleCreateTransactionType = useCallback(async (formValues) => {
 		const newTransactionType = { ...formValues };
 		try {
-			if ((await postCreateTransactionType(newTransactionType))?.status === 201) enqueueSnackbar(t("TransactionType created successfully"), {
+			if ((await postCreateTransactionType(newTransactionType))?.status === 201) enqueueSnackbar(t("TransactionType created successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleSideSheet(false);
+			setSelectedDomainName("");
+			gridApiRef.current?.refreshServerSide();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		gridApiRef,
+		handleSideSheet,
+		successAction,
+		t
+	]);
+	const handleUpdateTransactionType = useCallback(async (formValues, initialValues) => {
+		const transactionTypeId = initialValues.transactionTypeId;
+		const updatedTransactionType = {
+			...initialValues,
+			...formValues
+		};
+		try {
+			if ((await putUpdateTransactionType(transactionTypeId, updatedTransactionType)).status === 204) enqueueSnackbar(t("TransactionType updated successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleSideSheet(false);
+			setSelectedDomainName("");
+			gridApiRef.current?.refreshServerSide();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		gridApiRef,
+		handleSideSheet,
+		successAction,
+		t
+	]);
+	const handleDeleteTransactionType = useCallback(async () => {
+		if (!selectedTransactionType) return;
+		setIsTransactionTypeSidesheetLoading(true);
+		const transactionTypeId = selectedTransactionType.transactionTypeId;
+		try {
+			if ((await deleteTransactionType(transactionTypeId)).status === 204) enqueueSnackbar(t("TransactionType deleted successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			setIsDeleteTransactionTypeDialogOpen(false);
+			gridApiRef.current?.refreshServerSide();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		} finally {
+			setIsTransactionTypeSidesheetLoading(false);
+		}
+	}, [
+		enqueueSnackbar,
+		selectedTransactionType,
+		successAction,
+		t,
+		setIsTransactionTypeSidesheetLoading,
+		setIsDeleteTransactionTypeDialogOpen
+	]);
+	/** end of TransactionType */
+	/** TransactionTypeStatus */
+	const handleCreateTransactionTypeStatus = useCallback(async (formValues) => {
+		const newTransactionTypeStatus = {
+			...formValues,
+			transactionTypeId: selectedTransactionType?.transactionTypeId
+		};
+		let hasDefaultOrClosedorCancelledStatus = false;
+		try {
+			const isCreatingDefaultStatus = formValues?.isDefault === true;
+			const isCreatingClosedStatus = formValues?.isClosedStatus === true;
+			const isCreatingCancelledStatus = formValues?.isCancelledStatus === true;
+			if (isCreatingDefaultStatus || isCreatingClosedStatus || isCreatingCancelledStatus) {
+				const searchTransactionTypeStatusResponse = await searchTransactionTypeStatusByTransactionTypeId(selectedTransactionType?.transactionTypeId);
+				if (searchTransactionTypeStatusResponse?.status !== 200) {
+					enqueueSnackbar(t("Unable to validate existing TransactionTypeStatus records. Please try again."), {
+						variant: "error",
+						anchorOrigin: {
+							vertical: "top",
+							horizontal: "center"
+						}
+					});
+					return;
+				}
+				hasDefaultOrClosedorCancelledStatus = hasDefaultAndClosedTransactionTypeStatus(searchTransactionTypeStatusResponse?.data?.pageList, isCreatingDefaultStatus, isCreatingClosedStatus, isCreatingCancelledStatus);
+			}
+			if ((isCreatingDefaultStatus || isCreatingClosedStatus || isCreatingCancelledStatus) && hasDefaultOrClosedorCancelledStatus) {
+				let statusConflictMessage = "";
+				if (isCreatingDefaultStatus) statusConflictMessage = "There is already a TransactionTypeStatus for this TransactionType that has IsDefault set to true.";
+				else if (isCreatingClosedStatus) statusConflictMessage = "There is already a TransactionTypeStatus for this TransactionType that has IsClosedStatus set to true.";
+				else if (isCreatingCancelledStatus) statusConflictMessage = "There is already a TransactionTypeStatus for this TransactionType that has IsCancelledStatus set to true.";
+				enqueueSnackbar(t(statusConflictMessage), {
+					variant: "error",
+					anchorOrigin: {
+						vertical: "top",
+						horizontal: "center"
+					}
+				});
+				return;
+			}
+			if ((await postCreateTransactionTypeStatus(newTransactionTypeStatus))?.status === 201) enqueueSnackbar(t("TransactionTypeStatus created successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionTypeStatusSideSheet(false);
+			ttsGridApiRef.current?.refreshServerSide();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response?.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		ttsGridApiRef,
+		handleCreateOrEditTransactionTypeStatusSideSheet,
+		successAction,
+		t,
+		selectedTransactionType,
+		searchTransactionTypeStatusByTransactionTypeId,
+		hasDefaultAndClosedTransactionTypeStatus
+	]);
+	const handleUpdateTransactionTypeStatus = useCallback(async (formValues, initialValues) => {
+		const transactionTypeStatusId = initialValues.transactionTypeStatusId;
+		const updatedTransactionTypeStatus = {
+			...initialValues,
+			...formValues
+		};
+		let hasExistingDefaultOrClosedStatus = false;
+		try {
+			const isEditingDefaultStatus = formValues?.isDefault === true;
+			const isEditingClosedStatus = formValues?.isClosedStatus === true;
+			if (isEditingDefaultStatus || isEditingClosedStatus) {
+				const searchTransactionTypeStatusResponse = await searchTransactionTypeStatusByTransactionTypeId(selectedTransactionType?.transactionTypeId);
+				if (searchTransactionTypeStatusResponse?.status !== 200) {
+					enqueueSnackbar(t("Unable to validate existing TransactionTypeStatus records. Please try again."), {
+						variant: "error",
+						anchorOrigin: {
+							vertical: "top",
+							horizontal: "center"
+						}
+					});
+					return;
+				}
+				hasExistingDefaultOrClosedStatus = hasDefaultAndClosedTransactionTypeStatus(searchTransactionTypeStatusResponse?.data?.pageList, isEditingDefaultStatus, isEditingClosedStatus);
+			}
+			if ((isEditingDefaultStatus || isEditingClosedStatus) && hasExistingDefaultOrClosedStatus) {
+				enqueueSnackbar(t(`There is already a TransactionTypeStatus for this TransactionType that has
+              ${isEditingDefaultStatus ? isEditingClosedStatus ? "IsDefault and/or IsClosedStatus" : "IsDefault" : "IsClosedStatus"} set to true.`), {
+					variant: "error",
+					anchorOrigin: {
+						vertical: "top",
+						horizontal: "center"
+					}
+				});
+				return;
+			}
+			if ((await putUpdateTransactionTypeStatus(transactionTypeStatusId, updatedTransactionTypeStatus)).status === 204) enqueueSnackbar(t("TransactionTypeStatus updated successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionTypeStatusSideSheet(false);
+			ttsGridApiRef.current?.refreshServerSide();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response?.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		ttsGridApiRef,
+		handleCreateOrEditTransactionTypeStatusSideSheet,
+		successAction,
+		t,
+		searchTransactionTypeStatusByTransactionTypeId,
+		hasDefaultAndClosedTransactionTypeStatus,
+		selectedTransactionType
+	]);
+	const handleDeleteTransactionTypeStatus = useCallback(async () => {
+		if (!selectedTransactionTypeStatus) return;
+		const transactionTypeStatusId = selectedTransactionTypeStatus.transactionTypeStatusId;
+		try {
+			if ((await deleteTransactionTypeStatus(transactionTypeStatusId)).status === 204) enqueueSnackbar(t("TransactionTypeStatus deleted successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			setIsDeleteTransactionTypeStatusDialogOpen(false);
+			ttsGridApiRef.current?.refreshServerSide();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		selectedTransactionTypeStatus,
+		successAction,
+		t,
+		ttsGridApiRef,
+		setIsDeleteTransactionTypeStatusDialogOpen
+	]);
+	/** end of TransactionTypeStatus */
+	/** TransactionTypeTransactionAction */
+	const handleCreateTransactionTypeTransactionAction = useCallback(async (formValues) => {
+		const { transactionAction, toStatus, actionApiId, pageId, mandatoryFields, hiddenFields, domainDataToUpdate, ...restValues } = formValues || {};
+		const domainDataDictionary = (Array.isArray(domainDataToUpdate) ? domainDataToUpdate : []).reduce((accumulator, entry) => {
+			if (!entry) return accumulator;
+			const [field, value] = entry;
+			if (field) accumulator[field] = value;
+			return accumulator;
+		}, {});
+		const newTransactionTypeTransactionAction = {
+			...restValues,
+			transactionTypeId: selectedTransactionType?.transactionTypeId,
+			transactionActionId: transactionAction?.transactionActionId,
+			parameters: {
+				ToStatus: toStatus?.transactionTypeStatusId,
+				DomainDataToUpdate: domainDataDictionary,
+				MandatoryFields: Array.isArray(mandatoryFields) ? mandatoryFields : [],
+				HiddenFields: Array.isArray(hiddenFields) ? hiddenFields : [],
+				ActionApiId: actionApiId?.actionApiId || "",
+				PageId: pageId?.pageId || ""
+			}
+		};
+		try {
+			if ((await postCreateTransactionTypeTransactionAction(newTransactionTypeTransactionAction))?.status === 201) enqueueSnackbar(t("TransactionTypeTransactionAction created successfully"), {
 				anchorOrigin: {
 					vertical: "top",
 					horizontal: "center"
@@ -1197,9 +2427,8 @@ const UdpTransactionTypesPage = () => {
 				action: successAction,
 				autoHideDuration: null
 			});
-			handleSideSheet(false);
-			setSelectedDomainName("");
-			gridApiRef.current?.refreshServerSide();
+			handleCreateOrEditTransactionTypeTransactionActionSidesheet(false);
+			tttaGridApiRef.current?.refreshServerSide();
 		} catch (err) {
 			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
 				variant: "error",
@@ -1211,19 +2440,40 @@ const UdpTransactionTypesPage = () => {
 		}
 	}, [
 		enqueueSnackbar,
-		gridApiRef,
-		handleSideSheet,
+		tttaGridApiRef,
+		handleCreateOrEditTransactionTypeTransactionActionSidesheet,
 		successAction,
-		t
+		t,
+		selectedTransactionType
 	]);
-	const handleUpdateTransactionType = useCallback(async (formValues, initialValues) => {
-		const transactionTypeId = initialValues.transactionTypeId;
-		const updatedTransactionType = {
+	const handleUpdateTransactionTypeTransactionAction = useCallback(async (formValues, initialValues) => {
+		const { transactionAction, toStatus, actionApiId, pageId, mandatoryFields, hiddenFields, domainDataToUpdate } = formValues || {};
+		const transactionTypeTransactionActionId = initialValues.transactionTypeTransactionActionId;
+		const domainDataDictionary = (Array.isArray(domainDataToUpdate) ? domainDataToUpdate : []).reduce((accumulator, entry) => {
+			if (!entry) return accumulator;
+			const [field, value] = entry;
+			if (field) accumulator[field] = value;
+			return accumulator;
+		}, {});
+		const updatedTransactionTypeTransactionAction = {
 			...initialValues,
-			...formValues
+			name: formValues?.name || "",
+			description: formValues?.description || "",
+			icon: formValues?.icon || "",
+			transactionTypeTransactionActionId,
+			transactionTypeId: selectedTransactionType?.transactionTypeId,
+			transactionActionId: transactionAction?.transactionActionId,
+			parameters: {
+				ToStatus: toStatus?.transactionTypeStatusId,
+				DomainDataToUpdate: domainDataDictionary,
+				MandatoryFields: Array.isArray(mandatoryFields) ? mandatoryFields : [],
+				HiddenFields: Array.isArray(hiddenFields) ? hiddenFields : [],
+				ActionApiId: actionApiId?.actionApiId || "",
+				PageId: pageId?.pageId || ""
+			}
 		};
 		try {
-			if ((await putUpdateTransactionType(transactionTypeId, updatedTransactionType)).status === 204) enqueueSnackbar(t("TransactionType updated successfully"), {
+			if ((await putUpdateTransactionTypeTransactionAction(transactionTypeTransactionActionId, updatedTransactionTypeTransactionAction)).status === 204) enqueueSnackbar(t("TransactionTypeTransactionAction updated successfully"), {
 				anchorOrigin: {
 					vertical: "top",
 					horizontal: "center"
@@ -1231,9 +2481,8 @@ const UdpTransactionTypesPage = () => {
 				action: successAction,
 				autoHideDuration: null
 			});
-			handleSideSheet(false);
-			setSelectedDomainName("");
-			gridApiRef.current?.refreshServerSide();
+			handleCreateOrEditTransactionTypeTransactionActionSidesheet(false);
+			tttaGridApiRef.current?.refreshServerSide();
 		} catch (err) {
 			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
 				variant: "error",
@@ -1245,17 +2494,17 @@ const UdpTransactionTypesPage = () => {
 		}
 	}, [
 		enqueueSnackbar,
-		gridApiRef,
-		handleSideSheet,
+		tttaGridApiRef,
+		handleCreateOrEditTransactionTypeTransactionActionSidesheet,
 		successAction,
-		t
+		t,
+		selectedTransactionType
 	]);
-	const handleDeleteTransactionType = useCallback(async () => {
-		if (!selectedTransactionType) return;
-		setIsTransactionTypeSidesheetLoading(true);
-		const transactionTypeId = selectedTransactionType.transactionTypeId;
+	const handleDeleteTransactionTypeTransactionAction = useCallback(async () => {
+		if (!selectedTransactionTypeTransactionAction) return;
+		const transactionTypeTransactionActionId = selectedTransactionTypeTransactionAction.transactionTypeTransactionActionId;
 		try {
-			if ((await deleteTransactionType(transactionTypeId)).status === 204) enqueueSnackbar(t("TransactionType deleted successfully"), {
+			if ((await deleteTransactionTypeTransactionAction(transactionTypeTransactionActionId)).status === 204) enqueueSnackbar(t("TransactionTypeTransactionAction deleted successfully"), {
 				anchorOrigin: {
 					vertical: "top",
 					horizontal: "center"
@@ -1263,8 +2512,8 @@ const UdpTransactionTypesPage = () => {
 				action: successAction,
 				autoHideDuration: null
 			});
-			setIsDeleteTransactionTypeDialogOpen(false);
-			gridApiRef.current?.refreshServerSide();
+			setIsDeleteTransactionTypeTransactionActionDialogOpen(false);
+			tttaGridApiRef.current?.refreshServerSide();
 		} catch (err) {
 			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
 				variant: "error",
@@ -1273,54 +2522,161 @@ const UdpTransactionTypesPage = () => {
 					horizontal: "center"
 				}
 			});
-		} finally {
-			setIsTransactionTypeSidesheetLoading(false);
 		}
 	}, [
 		enqueueSnackbar,
-		selectedTransactionType,
+		selectedTransactionTypeTransactionAction,
 		successAction,
 		t,
-		setIsTransactionTypeSidesheetLoading,
-		setIsDeleteTransactionTypeDialogOpen
+		setIsDeleteTransactionTypeTransactionActionDialogOpen
 	]);
-	/** end of TransactionType */
-	/** TransactionTypeStatus */
-	const handleCreateTransactionTypeStatus = useCallback(async (formValues) => {
-		const newTransactionTypeStatus = {
-			...formValues,
-			transactionTypeId: selectedTransactionType?.transactionTypeId
+	/** end of TransactionTypeTransactionAction */
+	/** TransactionUiAction */
+	const handleCreateTransactionUiAction = useCallback(async (formValues) => {
+		const { transactionUiActionType, actionApi, page, ...restValues } = formValues;
+		const newTransactionUiAction = {
+			...restValues,
+			transactionTypeId: selectedTransactionType?.transactionTypeId,
+			transactionUiActionTypeId: transactionUiActionType?.transactionUiActionTypeId,
+			parameters: {
+				ActionApiId: actionApi?.actionApiId || "",
+				PageId: page?.pageId || ""
+			}
 		};
-		let hasExistingDefaultOrClosedStatus = false;
 		try {
-			const isCreatingDefaultStatus = formValues?.isDefault === true;
-			const isCreatingClosedStatus = formValues?.isClosedStatus === true;
-			if (isCreatingDefaultStatus || isCreatingClosedStatus) {
-				const searchTransactionTypeStatusResponse = await searchTransactionTypeStatusByTransactionTypeId(selectedTransactionType?.transactionTypeId);
-				if (searchTransactionTypeStatusResponse?.status !== 200) {
-					enqueueSnackbar(t("Unable to validate existing TransactionTypeStatus records. Please try again."), {
-						variant: "error",
-						anchorOrigin: {
-							vertical: "top",
-							horizontal: "center"
-						}
-					});
-					return;
+			if ((await postCreateTransactionUiAction(newTransactionUiAction))?.status === 201) enqueueSnackbar(t("TransactionUiAction created successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionUiActionSidesheet(false);
+			tuaGridApiRef.current?.refreshServerSide();
+			fetchTUiActionsList();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
 				}
-				hasExistingDefaultOrClosedStatus = hasDefaultAndClosedTransactionTypeStatus(searchTransactionTypeStatusResponse?.data?.pageList, isCreatingDefaultStatus, isCreatingClosedStatus);
-			}
-			if ((isCreatingDefaultStatus || isCreatingClosedStatus) && hasExistingDefaultOrClosedStatus) {
-				enqueueSnackbar(t(`There is already a TransactionTypeStatus for this TransactionType that has
-                ${isCreatingDefaultStatus ? isCreatingClosedStatus ? "IsDefault and/or IsClosedStatus" : "IsDefault" : "IsClosedStatus"} set to true.`), {
-					variant: "error",
-					anchorOrigin: {
-						vertical: "top",
-						horizontal: "center"
-					}
-				});
-				return;
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		tuaGridApiRef,
+		handleCreateOrEditTransactionUiActionSidesheet,
+		successAction,
+		t,
+		selectedTransactionType,
+		fetchTUiActionsList
+	]);
+	const handleUpdateTransactionUiAction = useCallback(async (formValues, initialValues) => {
+		const { transactionUiActionType, actionApi, page, ...restValues } = formValues;
+		const transactionUiActionId = initialValues.transactionUiActionId;
+		const updatedTransactionUiAction = {
+			...restValues,
+			transactionUiActionId,
+			transactionTypeId: selectedTransactionType?.transactionTypeId,
+			transactionUiActionTypeId: transactionUiActionType?.transactionUiActionTypeId,
+			parameters: {
+				ActionApiId: actionApi?.actionApiId || "",
+				PageId: page?.pageId || ""
 			}
-			if ((await postCreateTransactionTypeStatus(newTransactionTypeStatus))?.status === 201) enqueueSnackbar(t("TransactionTypeStatus created successfully"), {
+		};
+		try {
+			if ((await putUpdateTransactionUiAction(transactionUiActionId, updatedTransactionUiAction)).status === 204) enqueueSnackbar(t("TransactionUiAction updated successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionUiActionSidesheet(false);
+			tuaGridApiRef.current?.refreshServerSide();
+			fetchTUiActionsList();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		tuaGridApiRef,
+		handleCreateOrEditTransactionUiActionSidesheet,
+		successAction,
+		t,
+		selectedTransactionType,
+		fetchTUiActionsList
+	]);
+	const handleDeleteTransactionUiAction = useCallback(async () => {
+		if (!selectedTransactionUiAction) return;
+		const transactionUiActionId = selectedTransactionUiAction.transactionUiActionId;
+		try {
+			if ((await deleteTransactionUiAction(transactionUiActionId)).status === 204) enqueueSnackbar(t("TransactionUiAction deleted successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			setIsDeleteTransactionUiActionDialogOpen(false);
+			tuaGridApiRef.current?.refreshServerSide();
+			fetchTUiActionsList();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		selectedTransactionUiAction,
+		successAction,
+		t,
+		setIsDeleteTransactionUiActionDialogOpen,
+		fetchTUiActionsList
+	]);
+	/** end of TransactionUiAction */
+	/** TransactionTypeConfiguration */
+	const handleCreateTransactionTypeConfiguration = useCallback(async (formValues) => {
+		const { transactionRuleType, currentStatus, tenantUserRoles, currentDomainValue, ...restValues } = formValues;
+		const domainDataDictionary = (Array.isArray(currentDomainValue) ? currentDomainValue : []).reduce((accumulator, entry) => {
+			if (!entry) return accumulator;
+			const [field, value] = entry;
+			if (field) accumulator[field] = value;
+			return accumulator;
+		}, {});
+		const tenantUserRoleIds = tenantUserRoles?.map((tur) => tur?.roleId);
+		const configurationObj = {
+			CurrentStatus: currentStatus,
+			CurrentDomainValue: domainDataDictionary,
+			TenantUserRoleIds: Array.isArray(tenantUserRoleIds) ? tenantUserRoleIds : []
+		};
+		const expressionLogic = formatTransactionTypeConfigurationIntoExpressionLogic(configurationObj);
+		const newTransactionTypeConfiguration = {
+			...restValues,
+			transactionTypeId: selectedTransactionType?.transactionTypeId,
+			transactionRuleTypeId: transactionRuleType?.transactionRuleTypeId,
+			configuration: {
+				...configurationObj,
+				CurrentStatusId: currentStatus?.transactionTypeStatusId
+			},
+			expressionLogic
+		};
+		try {
+			if ((await postCreateTransactionTypeConfiguration(newTransactionTypeConfiguration))?.status === 201) enqueueSnackbar(t("TransactionTypeConfiguration created successfully"), {
 				anchorOrigin: {
 					vertical: "top",
 					horizontal: "center"
@@ -1328,10 +2684,10 @@ const UdpTransactionTypesPage = () => {
 				action: successAction,
 				autoHideDuration: null
 			});
-			handleCreateOrEditTransactionTypeStatusSideSheet(false);
-			ttsGridApiRef.current?.refreshServerSide();
+			handleCreateOrEditTransactionTypeConfigurationSidesheet(false);
+			ttcGridApiRef.current?.refreshServerSide();
 		} catch (err) {
-			enqueueSnackbar(typeof err.response?.data === "object" ? err.response.data.title : err.response.data, {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
 				variant: "error",
 				anchorOrigin: {
 					vertical: "top",
@@ -1341,50 +2697,44 @@ const UdpTransactionTypesPage = () => {
 		}
 	}, [
 		enqueueSnackbar,
-		ttsGridApiRef,
-		handleCreateOrEditTransactionTypeStatusSideSheet,
+		ttcGridApiRef,
+		handleCreateOrEditTransactionTypeConfigurationSidesheet,
 		successAction,
 		t,
-		selectedTransactionType,
-		searchTransactionTypeStatusByTransactionTypeId,
-		hasDefaultAndClosedTransactionTypeStatus
+		selectedTransactionType
 	]);
-	const handleUpdateTransactionTypeStatus = useCallback(async (formValues, initialValues) => {
-		const transactionTypeStatusId = initialValues.transactionTypeStatusId;
-		const updatedTransactionTypeStatus = {
+	const handleUpdateTransactionTypeConfiguration = useCallback(async (formValues, initialValues) => {
+		const { transactionRuleType, currentStatus, tenantUserRoles, currentDomainValue, name, ...restValues } = formValues;
+		const transactionTypeConfigurationId = initialValues.transactionTypeConfigurationId;
+		const domainDataDictionary = (Array.isArray(currentDomainValue) ? currentDomainValue : []).reduce((accumulator, entry) => {
+			if (!entry) return accumulator;
+			const [field, value] = entry;
+			if (field) accumulator[field] = value;
+			return accumulator;
+		}, {});
+		const tenantUserRoleIds = tenantUserRoles?.map((tur) => tur?.roleId);
+		const configurationObj = {
+			CurrentStatus: currentStatus,
+			CurrentDomainValue: domainDataDictionary,
+			TenantUserRoleIds: Array.isArray(tenantUserRoleIds) ? tenantUserRoleIds : []
+		};
+		const expressionLogic = formatTransactionTypeConfigurationIntoExpressionLogic(configurationObj);
+		const updatedTransactionTypeConfiguration = {
 			...initialValues,
-			...formValues
+			name: name || "",
+			order: formValues?.order || 0,
+			enabled: formValues?.enabled,
+			transactionTypeConfigurationId,
+			transactionTypeId: selectedTransactionType?.transactionTypeId,
+			transactionRuleTypeId: transactionRuleType?.transactionRuleTypeId,
+			configuration: {
+				...configurationObj,
+				CurrentStatusId: currentStatus?.transactionTypeStatusId
+			},
+			expressionLogic
 		};
-		let hasExistingDefaultOrClosedStatus = false;
 		try {
-			const isEditingDefaultStatus = formValues?.isDefault === true;
-			const isEditingClosedStatus = formValues?.isClosedStatus === true;
-			if (isEditingDefaultStatus || isEditingClosedStatus) {
-				const searchTransactionTypeStatusResponse = await searchTransactionTypeStatusByTransactionTypeId(selectedTransactionType?.transactionTypeId);
-				if (searchTransactionTypeStatusResponse?.status !== 200) {
-					enqueueSnackbar(t("Unable to validate existing TransactionTypeStatus records. Please try again."), {
-						variant: "error",
-						anchorOrigin: {
-							vertical: "top",
-							horizontal: "center"
-						}
-					});
-					return;
-				}
-				hasExistingDefaultOrClosedStatus = hasDefaultAndClosedTransactionTypeStatus(searchTransactionTypeStatusResponse?.data?.pageList, isEditingDefaultStatus, isEditingClosedStatus);
-			}
-			if ((isEditingDefaultStatus || isEditingClosedStatus) && hasExistingDefaultOrClosedStatus) {
-				enqueueSnackbar(t(`There is already a TransactionTypeStatus for this TransactionType that has
-              ${isEditingDefaultStatus ? isEditingClosedStatus ? "IsDefault and/or IsClosedStatus" : "IsDefault" : "IsClosedStatus"} set to true.`), {
-					variant: "error",
-					anchorOrigin: {
-						vertical: "top",
-						horizontal: "center"
-					}
-				});
-				return;
-			}
-			if ((await putUpdateTransactionTypeStatus(transactionTypeStatusId, updatedTransactionTypeStatus)).status === 204) enqueueSnackbar(t("TransactionTypeStatus updated successfully"), {
+			if ((await putUpdateTransactionTypeConfiguration(transactionTypeConfigurationId, updatedTransactionTypeConfiguration)).status === 204) enqueueSnackbar(t("TransactionTypeConfiguration updated successfully"), {
 				anchorOrigin: {
 					vertical: "top",
 					horizontal: "center"
@@ -1392,10 +2742,10 @@ const UdpTransactionTypesPage = () => {
 				action: successAction,
 				autoHideDuration: null
 			});
-			handleCreateOrEditTransactionTypeStatusSideSheet(false);
-			ttsGridApiRef.current?.refreshServerSide();
+			handleCreateOrEditTransactionTypeConfigurationSidesheet(false);
+			ttcGridApiRef.current?.refreshServerSide();
 		} catch (err) {
-			enqueueSnackbar(typeof err.response?.data === "object" ? err.response.data.title : err.response.data, {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
 				variant: "error",
 				anchorOrigin: {
 					vertical: "top",
@@ -1405,19 +2755,17 @@ const UdpTransactionTypesPage = () => {
 		}
 	}, [
 		enqueueSnackbar,
-		ttsGridApiRef,
-		handleCreateOrEditTransactionTypeStatusSideSheet,
+		ttcGridApiRef,
+		handleCreateOrEditTransactionTypeConfigurationSidesheet,
 		successAction,
 		t,
-		searchTransactionTypeStatusByTransactionTypeId,
-		hasDefaultAndClosedTransactionTypeStatus,
 		selectedTransactionType
 	]);
-	const handleDeleteTransactionTypeStatus = useCallback(async () => {
-		if (!selectedTransactionTypeStatus) return;
-		const transactionTypeStatusId = selectedTransactionTypeStatus.transactionTypeStatusId;
+	const handleDeleteTransactionTypeConfiguration = useCallback(async () => {
+		if (!selectedTransactionTypeConfiguration) return;
+		const transactionTypeConfigurationId = selectedTransactionTypeConfiguration.transactionTypeConfigurationId;
 		try {
-			if ((await deleteTransactionTypeStatus(transactionTypeStatusId)).status === 204) enqueueSnackbar(t("TransactionTypeStatus deleted successfully"), {
+			if ((await deleteTransactionTypeConfiguration(transactionTypeConfigurationId)).status === 204) enqueueSnackbar(t("TransactionTypeConfiguration deleted successfully"), {
 				anchorOrigin: {
 					vertical: "top",
 					horizontal: "center"
@@ -1425,8 +2773,8 @@ const UdpTransactionTypesPage = () => {
 				action: successAction,
 				autoHideDuration: null
 			});
-			setIsDeleteTransactionTypeStatusDialogOpen(false);
-			ttsGridApiRef.current?.refreshServerSide();
+			setIsDeleteTransactionTypeConfigurationDialogOpen(false);
+			ttcGridApiRef.current?.refreshServerSide();
 		} catch (err) {
 			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
 				variant: "error",
@@ -1438,37 +2786,24 @@ const UdpTransactionTypesPage = () => {
 		}
 	}, [
 		enqueueSnackbar,
-		selectedTransactionTypeStatus,
+		selectedTransactionTypeConfiguration,
 		successAction,
 		t,
-		ttsGridApiRef,
-		setIsDeleteTransactionTypeStatusDialogOpen
+		setIsDeleteTransactionTypeConfigurationDialogOpen
 	]);
-	/** end of TransactionTypeStatus */
-	/** TransactionTypeTransactionAction */
-	const handleCreateTransactionTypeTransactionAction = useCallback(async (formValues) => {
-		const { transactionAction, toStatus, actionApiId, pageId, mandatoryFields, hiddenFields, domainDataToUpdate, ...restValues } = formValues || {};
-		const domainDataDictionary = (Array.isArray(domainDataToUpdate) ? domainDataToUpdate : []).reduce((accumulator, entry) => {
-			if (!entry) return accumulator;
-			const [field, value] = entry;
-			if (field) accumulator[field] = value;
-			return accumulator;
-		}, {});
-		const newTransactionTypeTransactionAction = {
-			...restValues,
-			transactionTypeId: selectedTransactionType?.transactionTypeId,
-			transactionActionId: transactionAction?.transactionActionId,
-			parameters: {
-				ToStatus: toStatus?.transactionTypeStatusId,
-				DomainDataToUpdate: domainDataDictionary,
-				MandatoryFields: Array.isArray(mandatoryFields) ? mandatoryFields : [],
-				HiddenFields: Array.isArray(hiddenFields) ? hiddenFields : [],
-				ActionApiId: actionApiId?.actionApiId || "",
-				PageId: pageId?.pageId || ""
-			}
-		};
+	/** end of TransactionTypeConfiguration */
+	/** TransactionTypeConfigurationTransactionAction */
+	const handleCreateTransactionTypeConfigurationTransactionAction = useCallback(async (formValues) => {
+		const { transactionTypeTransactionActions } = formValues;
+		const newTTCTActions = [];
+		transactionTypeTransactionActions?.forEach((action) => {
+			newTTCTActions.push({
+				transactionTypeConfigurationId: selectedTransactionTypeConfiguration?.transactionTypeConfigurationId,
+				transactionTypeTransactionActionId: action?.transactionTypeTransactionActionId
+			});
+		});
 		try {
-			if ((await postCreateTransactionTypeTransactionAction(newTransactionTypeTransactionAction))?.status === 201) enqueueSnackbar(t("TransactionTypeTransactionAction created successfully"), {
+			if ((await postCreateTransactionTypeConfigurationTransactionAction(newTTCTActions))?.status === 201) enqueueSnackbar(t("TransactionTypeConfigurationTransactionAction(s) created successfully"), {
 				anchorOrigin: {
 					vertical: "top",
 					horizontal: "center"
@@ -1476,8 +2811,9 @@ const UdpTransactionTypesPage = () => {
 				action: successAction,
 				autoHideDuration: null
 			});
-			handleCreateOrEditTransactionTypeTransactionActionSidesheet(false);
-			tttaGridApiRef.current?.refreshServerSide();
+			handleCreateOrEditTransactionTypeConfigurationTransactionActionSidesheet(false);
+			ttctaGridApiRef.current?.refreshServerSide();
+			fetchTtctaList();
 		} catch (err) {
 			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
 				variant: "error",
@@ -1489,40 +2825,23 @@ const UdpTransactionTypesPage = () => {
 		}
 	}, [
 		enqueueSnackbar,
-		tttaGridApiRef,
-		handleCreateOrEditTransactionTypeTransactionActionSidesheet,
+		ttctaGridApiRef,
+		handleCreateOrEditTransactionTypeConfigurationTransactionActionSidesheet,
 		successAction,
 		t,
-		selectedTransactionType
+		selectedTransactionTypeConfiguration,
+		fetchTtctaList
 	]);
-	const handleUpdateTransactionTypeTransactionAction = useCallback(async (formValues, initialValues) => {
-		const { transactionAction, toStatus, actionApiId, pageId, mandatoryFields, hiddenFields, domainDataToUpdate } = formValues || {};
-		const transactionTypeTransactionActionId = initialValues.transactionTypeTransactionActionId;
-		const domainDataDictionary = (Array.isArray(domainDataToUpdate) ? domainDataToUpdate : []).reduce((accumulator, entry) => {
-			if (!entry) return accumulator;
-			const [field, value] = entry;
-			if (field) accumulator[field] = value;
-			return accumulator;
-		}, {});
-		const updatedTransactionTypeTransactionAction = {
-			...initialValues,
-			name: formValues?.name || "",
-			description: formValues?.description || "",
-			icon: formValues?.icon || "",
-			transactionTypeTransactionActionId,
-			transactionTypeId: selectedTransactionType?.transactionTypeId,
-			transactionActionId: transactionAction?.transactionActionId,
-			parameters: {
-				ToStatus: toStatus?.transactionTypeStatusId,
-				DomainDataToUpdate: domainDataDictionary,
-				MandatoryFields: Array.isArray(mandatoryFields) ? mandatoryFields : [],
-				HiddenFields: Array.isArray(hiddenFields) ? hiddenFields : [],
-				ActionApiId: actionApiId?.actionApiId || "",
-				PageId: pageId?.pageId || ""
-			}
+	const handleUpdateTransactionTypeConfigurationTransactionAction = useCallback(async (formValues, initialValues) => {
+		const { transactionTypeTransactionActions } = formValues;
+		const transactionTypeConfigurationId = selectedTransactionTypeConfiguration?.transactionTypeConfigurationId;
+		const existingTransactionTypeTransactionActionId = initialValues?.transactionTypeTransactionActionId;
+		const updatedTransactionTypeConfigurationTransactionAction = {
+			transactionTypeConfigurationId,
+			transactionTypeTransactionActionId: transactionTypeTransactionActions?.[0]?.transactionTypeTransactionActionId
 		};
 		try {
-			if ((await putUpdateTransactionTypeTransactionAction(transactionTypeTransactionActionId, updatedTransactionTypeTransactionAction)).status === 204) enqueueSnackbar(t("TransactionTypeTransactionAction updated successfully"), {
+			if ((await putUpdateTransactionTypeConfigurationTransactionAction(transactionTypeConfigurationId, existingTransactionTypeTransactionActionId, updatedTransactionTypeConfigurationTransactionAction)).status === 204) enqueueSnackbar(t("TransactionTypeConfigurationTransactionAction updated successfully"), {
 				anchorOrigin: {
 					vertical: "top",
 					horizontal: "center"
@@ -1530,8 +2849,9 @@ const UdpTransactionTypesPage = () => {
 				action: successAction,
 				autoHideDuration: null
 			});
-			handleCreateOrEditTransactionTypeTransactionActionSidesheet(false);
-			tttaGridApiRef.current?.refreshServerSide();
+			handleCreateOrEditTransactionTypeConfigurationTransactionActionSidesheet(false);
+			ttctaGridApiRef.current?.refreshServerSide();
+			fetchTtctaList();
 		} catch (err) {
 			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
 				variant: "error",
@@ -1543,17 +2863,19 @@ const UdpTransactionTypesPage = () => {
 		}
 	}, [
 		enqueueSnackbar,
-		tttaGridApiRef,
-		handleCreateOrEditTransactionTypeTransactionActionSidesheet,
+		ttctaGridApiRef,
+		handleCreateOrEditTransactionTypeConfigurationTransactionActionSidesheet,
 		successAction,
 		t,
-		selectedTransactionType
+		selectedTransactionTypeConfiguration,
+		fetchTtctaList
 	]);
-	const handleDeleteTransactionTypeTransactionAction = useCallback(async () => {
-		if (!selectedTransactionTypeTransactionAction) return;
-		const transactionTypeTransactionActionId = selectedTransactionTypeTransactionAction.transactionTypeTransactionActionId;
+	const handleDeleteTransactionTypeConfigurationTransactionAction = useCallback(async () => {
+		if (!selectedTransactionTypeConfigurationTransactionAction) return;
+		const transactionTypeConfigurationId = selectedTransactionTypeConfigurationTransactionAction?.transactionTypeConfigurationId;
+		const transactionTypeTransactionActionId = selectedTransactionTypeConfigurationTransactionAction?.transactionTypeTransactionActionId;
 		try {
-			if ((await deleteTransactionTypeTransactionAction(transactionTypeTransactionActionId)).status === 204) enqueueSnackbar(t("TransactionTypeTransactionAction deleted successfully"), {
+			if ((await deleteTransactionTypeConfigurationTransactionAction(transactionTypeConfigurationId, transactionTypeTransactionActionId)).status === 204) enqueueSnackbar(t("TransactionTypeConfigurationTransactionAction deleted successfully"), {
 				anchorOrigin: {
 					vertical: "top",
 					horizontal: "center"
@@ -1561,8 +2883,9 @@ const UdpTransactionTypesPage = () => {
 				action: successAction,
 				autoHideDuration: null
 			});
-			setIsDeleteTransactionTypeTransactionActionDialogOpen(false);
-			tttaGridApiRef.current?.refreshServerSide();
+			setIsDeleteTransactionTypeConfigurationTransactionActionDialogOpen(false);
+			ttctaGridApiRef.current?.refreshServerSide();
+			fetchTtctaList();
 		} catch (err) {
 			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
 				variant: "error",
@@ -1573,27 +2896,23 @@ const UdpTransactionTypesPage = () => {
 			});
 		}
 	}, [
+		ttctaGridApiRef,
 		enqueueSnackbar,
-		selectedTransactionTypeTransactionAction,
+		selectedTransactionTypeConfigurationTransactionAction,
 		successAction,
 		t,
-		setIsDeleteTransactionTypeTransactionActionDialogOpen
+		setIsDeleteTransactionTypeConfigurationTransactionActionDialogOpen,
+		fetchTtctaList
 	]);
-	/** end of TransactionTypeTransactionAction */
-	/** TransactionUiAction */
-	const handleCreateTransactionUiAction = useCallback(async (formValues) => {
-		const { transactionUiActionType, actionApi, page, ...restValues } = formValues;
-		const newTransactionUiAction = {
-			...restValues,
-			transactionTypeId: selectedTransactionType?.transactionTypeId,
-			transactionUiActionTypeId: transactionUiActionType?.transactionUiActionTypeId,
-			parameters: {
-				ActionApiId: actionApi?.actionApiId || "",
-				PageId: page?.pageId || ""
-			}
+	/** end of TransactionTypeConfigurationTransactionAction */
+	/** TransactionAttachmentType */
+	const handleCreateTransactionAttachmentType = useCallback(async (formValues) => {
+		const newTransactionAttachmentType = {
+			...formValues,
+			transactionTypeId: selectedTransactionType?.transactionTypeId
 		};
 		try {
-			if ((await postCreateTransactionUiAction(newTransactionUiAction))?.status === 201) enqueueSnackbar(t("TransactionUiAction created successfully"), {
+			if ((await postCreateTransactionAttachmentType(newTransactionAttachmentType))?.status === 201) enqueueSnackbar(t("TransactionAttachmentType created successfully"), {
 				anchorOrigin: {
 					vertical: "top",
 					horizontal: "center"
@@ -1601,9 +2920,8 @@ const UdpTransactionTypesPage = () => {
 				action: successAction,
 				autoHideDuration: null
 			});
-			handleCreateOrEditTransactionUiActionSidesheet(false);
-			tuaGridApiRef.current?.refreshServerSide();
-			fetchTUiActionsList();
+			handleCreateOrEditTransactionAttachmentTypeSidesheet(false);
+			tatGridApiRef.current?.refreshServerSide();
 		} catch (err) {
 			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
 				variant: "error",
@@ -1615,28 +2933,23 @@ const UdpTransactionTypesPage = () => {
 		}
 	}, [
 		enqueueSnackbar,
-		tuaGridApiRef,
-		handleCreateOrEditTransactionUiActionSidesheet,
+		tatGridApiRef,
 		successAction,
 		t,
 		selectedTransactionType,
-		fetchTUiActionsList
+		handleCreateOrEditTransactionAttachmentTypeSidesheet
 	]);
-	const handleUpdateTransactionUiAction = useCallback(async (formValues, initialValues) => {
-		const { transactionUiActionType, actionApi, page, ...restValues } = formValues;
-		const transactionUiActionId = initialValues.transactionUiActionId;
-		const updatedTransactionUiAction = {
-			...restValues,
-			transactionUiActionId,
-			transactionTypeId: selectedTransactionType?.transactionTypeId,
-			transactionUiActionTypeId: transactionUiActionType?.transactionUiActionTypeId,
-			parameters: {
-				ActionApiId: actionApi?.actionApiId || "",
-				PageId: page?.pageId || ""
-			}
+	const handleUpdateTransactionAttachmentType = useCallback(async (formValues, initialValues) => {
+		const transactionTypeId = selectedTransactionType?.transactionTypeId;
+		const transactionAttachmentTypeId = selectedTransactionAttachmentType?.transactionAttachmentTypeId;
+		const updatedTransactionType = {
+			...initialValues,
+			...formValues,
+			transactionTypeId,
+			transactionAttachmentTypeId
 		};
 		try {
-			if ((await putUpdateTransactionUiAction(transactionUiActionId, updatedTransactionUiAction)).status === 204) enqueueSnackbar(t("TransactionUiAction updated successfully"), {
+			if ((await putUpdateTransactionAttachmentType(transactionAttachmentTypeId, updatedTransactionType)).status === 204) enqueueSnackbar(t("TransactionAttachmentType updated successfully"), {
 				anchorOrigin: {
 					vertical: "top",
 					horizontal: "center"
@@ -1644,9 +2957,8 @@ const UdpTransactionTypesPage = () => {
 				action: successAction,
 				autoHideDuration: null
 			});
-			handleCreateOrEditTransactionUiActionSidesheet(false);
-			tuaGridApiRef.current?.refreshServerSide();
-			fetchTUiActionsList();
+			handleCreateOrEditTransactionAttachmentTypeSidesheet(false);
+			tatGridApiRef.current?.refreshServerSide();
 		} catch (err) {
 			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
 				variant: "error",
@@ -1658,18 +2970,15 @@ const UdpTransactionTypesPage = () => {
 		}
 	}, [
 		enqueueSnackbar,
-		tuaGridApiRef,
-		handleCreateOrEditTransactionUiActionSidesheet,
-		successAction,
-		t,
 		selectedTransactionType,
-		fetchTUiActionsList
+		successAction,
+		t
 	]);
-	const handleDeleteTransactionUiAction = useCallback(async () => {
-		if (!selectedTransactionUiAction) return;
-		const transactionUiActionId = selectedTransactionUiAction.transactionUiActionId;
+	const handleDeleteTransactionAttachmentType = useCallback(async () => {
+		if (!selectedTransactionAttachmentType) return;
+		const transactionAttachmentTypeId = selectedTransactionAttachmentType?.transactionAttachmentTypeId;
 		try {
-			if ((await deleteTransactionUiAction(transactionUiActionId)).status === 204) enqueueSnackbar(t("TransactionUiAction deleted successfully"), {
+			if ((await deleteTransactionAttachmentType(transactionAttachmentTypeId)).status === 204) enqueueSnackbar(t("TransactionAttachmentType deleted successfully"), {
 				anchorOrigin: {
 					vertical: "top",
 					horizontal: "center"
@@ -1677,9 +2986,8 @@ const UdpTransactionTypesPage = () => {
 				action: successAction,
 				autoHideDuration: null
 			});
-			setIsDeleteTransactionUiActionDialogOpen(false);
-			tuaGridApiRef.current?.refreshServerSide();
-			fetchTUiActionsList();
+			setIsDeleteTransactionAttachmentTypeDialogOpen(false);
+			tatGridApiRef.current?.refreshServerSide();
 		} catch (err) {
 			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
 				variant: "error",
@@ -1691,13 +2999,13 @@ const UdpTransactionTypesPage = () => {
 		}
 	}, [
 		enqueueSnackbar,
-		selectedTransactionUiAction,
+		selectedTransactionAttachmentType,
+		tatGridApiRef,
 		successAction,
 		t,
-		setIsDeleteTransactionUiActionDialogOpen,
-		fetchTUiActionsList
+		setIsDeleteTransactionAttachmentTypeDialogOpen
 	]);
-	/** end of TransactionUiAction */
+	/** end of TransactionAttachmentType */
 	const handleOpenDeleteTransactionTypeDialog = useCallback((transactionType) => {
 		setSelectedTransactionType(transactionType);
 		setIsDeleteTransactionTypeDialogOpen(true);
@@ -1730,13 +3038,38 @@ const UdpTransactionTypesPage = () => {
 		setIsDeleteTransactionUiActionDialogOpen(false);
 		setSelectedTransactionUiAction(null);
 	}, []);
+	const handleOpenDeleteTransactionTypeConfigurationDialog = useCallback((transactionTypeConfiguration) => {
+		setSelectedTransactionTypeConfiguration(transactionTypeConfiguration);
+		setIsDeleteTransactionTypeConfigurationDialogOpen(true);
+	}, []);
+	const handleCloseDeleteTransactionTypeConfigurationDialog = useCallback(() => {
+		setIsDeleteTransactionTypeConfigurationDialogOpen(false);
+		setSelectedTransactionTypeConfiguration(null);
+	}, []);
+	const handleOpenDeleteTransactionTypeConfigurationTransactionActionDialog = useCallback((transactionTypeConfigurationTransactionAction) => {
+		setSelectedTransactionTypeConfigurationTransactionAction(transactionTypeConfigurationTransactionAction);
+		setIsDeleteTransactionTypeConfigurationTransactionActionDialogOpen(true);
+	}, []);
+	const handleCloseDeleteTransactionTypeConfigurationTransactionActionDialog = useCallback(() => {
+		setIsDeleteTransactionTypeConfigurationTransactionActionDialogOpen(false);
+		setSelectedTransactionTypeConfigurationTransactionAction(null);
+	}, []);
+	const handleOpenDeleteTransactionAttachmentTypeDialog = useCallback((transactionAttachmentType) => {
+		setSelectedTransactionAttachmentType(transactionAttachmentType);
+		setIsDeleteTransactionAttachmentTypeDialogOpen(true);
+	}, []);
+	const handleCloseDeleteTransactionAttachmentTypeDialog = useCallback(() => {
+		setIsDeleteTransactionAttachmentTypeDialogOpen(false);
+		setSelectedTransactionAttachmentType(null);
+	}, []);
 	const columnDefs = useMemo(() => {
 		return [
 			{
 				headerName: t("Transaction Type ID"),
 				field: "transactionTypeId",
 				resizable: true,
-				sortable: false
+				sortable: false,
+				hide: true
 			},
 			{
 				headerName: t("Name"),
@@ -1757,7 +3090,7 @@ const UdpTransactionTypesPage = () => {
 				sortable: false
 			},
 			{
-				headerName: t("Has Revision"),
+				headerName: t("Allow Revisions"),
 				field: "hasRevision",
 				resizable: true,
 				sortable: false,
@@ -1770,14 +3103,27 @@ const UdpTransactionTypesPage = () => {
 				sortable: false
 			},
 			{
-				headerName: t("Domain Type Field"),
-				field: "domainTypeField",
+				headerName: t("Enabled"),
+				field: "enabled",
+				resizable: true,
+				sortable: false,
+				cellDataType: "boolean"
+			},
+			{
+				headerName: t("Field Label"),
+				field: "domainFieldLabel",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Sub-Type"),
+				field: "domainFieldType",
 				resizable: true,
 				sortable: false
 			},
 			{
-				headerName: t("Domain Type Value"),
-				field: "domainTypeValue",
+				headerName: t("Sub-Type Value"),
+				field: "domainFieldValue",
 				resizable: true,
 				sortable: false
 			},
@@ -1820,11 +3166,27 @@ const UdpTransactionTypesPage = () => {
 					},
 					{
 						id: 4,
-						title: t("Manage UiActions"),
+						title: t("Manage Forms/Pages"),
 						iconName: "send",
 						handleOnClick: (e, transactionType) => {
 							handleTransactionUiActionSidesheet(true, transactionType?.data);
 						}
+					},
+					{
+						id: 5,
+						title: t("Manage Rules"),
+						iconName: "wizard",
+						handleOnClick: (e, transactionType) => {
+							handleTransactionTypeConfigurationSidesheet(true, transactionType?.data);
+						}
+					},
+					{
+						id: 6,
+						title: t("Manage Attachment Types"),
+						iconName: "attachment",
+						handleOnClick: (e, transactionType) => {
+							handleTransactionAttachmentTypeSidesheet(true, transactionType?.data);
+						}
 					}
 				] },
 				valueGetter: (params) => params.data,
@@ -1839,6 +3201,8 @@ const UdpTransactionTypesPage = () => {
 		handleTransactionTypeStatusSideSheet,
 		handleTransactionTypeTransactionActionSidesheet,
 		handleTransactionUiActionSidesheet,
+		handleTransactionTypeConfigurationSidesheet,
+		handleTransactionAttachmentTypeSidesheet,
 		t
 	]);
 	const headerConfig = {
@@ -1888,13 +3252,15 @@ const UdpTransactionTypesPage = () => {
 		handleUpdateTransactionType,
 		catalogObjects,
 		catalogObjectProperties
-	}), /* @__PURE__ */ React.createElement(FluentDialog, {
+	}), getTransactionsByTransactionIdLoading ? /* @__PURE__ */ React.createElement(LinearProgress$1, null) : /* @__PURE__ */ React.createElement(FluentDialog, {
 		open: isDeleteTransactionTypeDialogOpen,
 		onClose: handleCloseDeleteTransactionTypeDialog,
 		title: t("Confirm Delete"),
-		message: t(`Are you sure you want to delete transaction type '${selectedTransactionType?.name}'`),
+		message: !transactionsByTransactionTypeId?.pageList?.length ? t(`Are you sure you want to delete this type?`) : t(`Unable to delete this type as there are existing transactions associated with it.
+              As an alternative, you can disable the type to prevent further use.`),
 		labelOne: t("Delete"),
 		actionOne: handleDeleteTransactionType,
+		buttonOneHidden: !!transactionsByTransactionTypeId?.pageList?.length,
 		labelTwo: t("Cancel"),
 		actionTwo: handleCloseDeleteTransactionTypeDialog
 	}), /* @__PURE__ */ React.createElement(UdpTransactionTypeStatusSidesheet_default, {
@@ -1912,7 +3278,7 @@ const UdpTransactionTypesPage = () => {
 		open: isDeleteTransactionTypeStatusDialogOpen,
 		onClose: handleCloseDeleteTransactionTypeStatusDialog,
 		title: t("Confirm Delete"),
-		message: t(`Are you sure you want to delete transaction type status '${selectedTransactionTypeStatus?.name}'`),
+		message: t(`Are you sure you want to delete this status?`),
 		labelOne: t("Delete"),
 		actionOne: handleDeleteTransactionTypeStatus,
 		labelTwo: t("Cancel"),
@@ -1932,12 +3298,12 @@ const UdpTransactionTypesPage = () => {
 		catalogObjectProperties,
 		actionApis,
 		pages,
-		searchTransactionTypeStatusByTransactionTypeId
+		ttstatuses
 	}), /* @__PURE__ */ React.createElement(FluentDialog, {
 		open: isDeleteTransactionTypeTransactionActionDialogOpen,
 		onClose: handleCloseDeleteTransactionTypeTransactionActionDialog,
 		title: t("Confirm Delete"),
-		message: t(`Are you sure you want to delete transaction type transaction action '${selectedTransactionTypeTransactionAction?.name}'`),
+		message: t(`Are you sure you want to delete this action?`),
 		labelOne: t("Delete"),
 		actionOne: handleDeleteTransactionTypeTransactionAction,
 		labelTwo: t("Cancel"),
@@ -1961,11 +3327,75 @@ const UdpTransactionTypesPage = () => {
 		open: isDeleteTransactionUiActionDialogOpen,
 		onClose: handleCloseDeleteTransactionUiActionDialog,
 		title: t("Confirm Delete"),
-		message: t(`Are you sure you want to delete this transaction UI action?`),
+		message: t(`Are you sure you want to delete this UI action?`),
 		labelOne: t("Delete"),
 		actionOne: handleDeleteTransactionUiAction,
 		labelTwo: t("Cancel"),
 		actionTwo: handleCloseDeleteTransactionUiActionDialog
+	}), /* @__PURE__ */ React.createElement(UdpTransactionTypeConfigurationSidesheet_default, {
+		ref: ttcGridApiRef,
+		transactionType: selectedTransactionType,
+		transactionTypeConfiguration: selectedTransactionTypeConfiguration,
+		isSideSheetOpen: isTransactionTypeConfigurationSidesheetOpen,
+		handleTransactionTypeConfigurationSidesheet,
+		isCreateOrEditTransactionTypeConfigurationSidesheetOpen,
+		handleCreateOrEditTransactionTypeConfigurationSidesheet,
+		handleCreateTransactionTypeConfiguration,
+		handleUpdateTransactionTypeConfiguration,
+		handleDeleteTransactionTypeConfiguration: handleOpenDeleteTransactionTypeConfigurationDialog,
+		transactionRuleTypes,
+		catalogObjectProperties,
+		ttstatuses,
+		roles,
+		transactionTypeConfigurationTransactionAction: selectedTransactionTypeConfigurationTransactionAction,
+		isTransactionTypeConfigurationTransactionActionSidesheetOpen,
+		handleTransactionTypeConfigurationTransactionActionSidesheet,
+		handleCreateOrEditTransactionTypeConfigurationTransactionActionSidesheet,
+		isCreateOrEditTransactionTypeConfigurationTransactionActionSidesheetOpen,
+		tttactions,
+		handleCreateTransactionTypeConfigurationTransactionAction,
+		handleUpdateTransactionTypeConfigurationTransactionAction,
+		handleDeleteTransactionTypeConfigurationTransactionAction: handleOpenDeleteTransactionTypeConfigurationTransactionActionDialog,
+		ttctaList,
+		ttctaGridApiRef
+	}), /* @__PURE__ */ React.createElement(FluentDialog, {
+		open: isDeleteTransactionTypeConfigurationDialogOpen,
+		onClose: handleCloseDeleteTransactionTypeConfigurationDialog,
+		title: t("Confirm Delete"),
+		message: t(`Are you sure you want to delete this rule?`),
+		labelOne: t("Delete"),
+		actionOne: handleDeleteTransactionTypeConfiguration,
+		labelTwo: t("Cancel"),
+		actionTwo: handleCloseDeleteTransactionTypeConfigurationDialog
+	}), /* @__PURE__ */ React.createElement(FluentDialog, {
+		open: isDeleteTransactionTypeConfigurationTransactionActionDialogOpen,
+		onClose: handleCloseDeleteTransactionTypeConfigurationTransactionActionDialog,
+		title: t("Confirm Delete"),
+		message: t(`Are you sure you want to delete this linked action?`),
+		labelOne: t("Delete"),
+		actionOne: handleDeleteTransactionTypeConfigurationTransactionAction,
+		labelTwo: t("Cancel"),
+		actionTwo: handleCloseDeleteTransactionTypeConfigurationTransactionActionDialog
+	}), /* @__PURE__ */ React.createElement(UdpTransactionAttachmentTypeSidesheet_default, {
+		ref: tatGridApiRef,
+		transactionType: selectedTransactionType,
+		transactionAttachmentType: selectedTransactionAttachmentType,
+		isSideSheetOpen: isTransactionAttachmentTypeSidesheetOpen,
+		isTransactionAttachmentTypeCreateOrEditSidesheetOpen: isCreateOrEditTransactionAttachmentTypeSidesheetOpen,
+		handleTransactionAttachmentTypeSidesheet,
+		handleCreateOrEditTransactionAttachmentTypeSidesheet,
+		handleCreateTransactionAttachmentType,
+		handleUpdateTransactionAttachmentType,
+		handleDeleteTransactionAttachmentType: handleOpenDeleteTransactionAttachmentTypeDialog
+	}), /* @__PURE__ */ React.createElement(FluentDialog, {
+		open: isDeleteTransactionAttachmentTypeDialogOpen,
+		onClose: handleCloseDeleteTransactionAttachmentTypeDialog,
+		title: t("Confirm Delete"),
+		message: t(`Are you sure you want to delete this attachment type?`),
+		labelOne: t("Delete"),
+		actionOne: handleDeleteTransactionAttachmentType,
+		labelTwo: t("Cancel"),
+		actionTwo: handleCloseDeleteTransactionAttachmentTypeDialog
 	}));
 };
 var UdpTransactionTypesPage_default = UdpTransactionTypesPage;
@@ -1976,4 +3406,4 @@ var UdpTransactionTypesPage_exports = /* @__PURE__ */ __export({ default: () =>
 
 //#endregion
 export { UdpTransactionTypesPage_default as n, UdpTransactionTypesPage_exports as t };
-//# sourceMappingURL=UdpTransactionTypesPage-CmsWZHM4.js.map
+//# sourceMappingURL=UdpTransactionTypesPage-Do_tl8J2.js.map