udp-react-enterprise-component-library 25.18.1-beta.9 → 25.18.1

package/dist/UdpTransactionTypesPage-Uk2cRhpd.js

@@ -0,0 +1,3737 @@
+import { t as __exportAll } from "./chunk-BN_g-Awi.js";
+import { t as Form$1 } from "./Form-DbOA5j38.js";
+import { t as Field$1 } from "./Field-Cda5rJe2.js";
+import { t as arrayMutators } from "./form-Dj1zVw6K.js";
+import { t as FluentButton } from "./FluentButton-BexKrnAp.js";
+import { t as ConfigService } from "./configService-C4uoG3wj.js";
+import { t as useUser } from "./useUser-wpHGo6jU.js";
+import { t as apiMutate } from "./useAxiosMutate-DeqKSi5z.js";
+import { V as UdpTransactionActionEnums, a as EMPTY_GUID } from "./unitySystemEnums-CZDCsD5t.js";
+import { n as getSuccessAction } from "./actionUtils-CPmiSAig.js";
+import { t as useCatalogStore } from "./catalogStore-DP2GxpTJ.js";
+import { t as LayoutUnit } from "./LayoutUnit-D4jJvonh.js";
+import { n as SideSheet } from "./SideSheet-CDXVa_Kr.js";
+import { t as useAxiosGet } from "./useAxiosGet-CYnt6Hd0.js";
+import { t as FluentDialog } from "./FluentDialog-B5ZxvX1E.js";
+import { t as useApiCatalog } from "./useApiCatalog-cpchDfC1.js";
+import { t as LinearProgress$1 } from "./LinearProgress-CpJeIaEP.js";
+import { t as FluentTextField } from "./FluentTextField-WfFk-koa.js";
+import { t as AmbientAutoComplete } from "./AmbientAutoComplete-NohpvB31.js";
+import { t as SearchMethodUdpGrid } from "./SearchMethodUdpGrid-BMHWSjf5.js";
+import React, { forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
+import { FormControlLabel, Switch, makeStyles } from "@material-ui/core";
+import { useForm, useFormState } from "react-final-form";
+import { useSnackbar } from "notistack";
+import { StatusCircleErrorXIcon } from "@fluentui/react-icons";
+import { useTranslation } from "react-i18next";
+import { FieldArray } from "react-final-form-arrays";
+
+//#region src/udp/pages/UdpTransactionTypesPage/forms/UdpTransactionTypeForm.jsx
+const useStyles$3 = makeStyles((theme) => ({
+	domainFields: {
+		display: "flex",
+		flexDirection: "row",
+		alignItems: "flex-end",
+		justifyContent: "flex-start",
+		"& > *": { marginRight: theme.spacing(2) }
+	},
+	domainValueField: { minWidth: "200px" },
+	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)
+	}
+}));
+const UdpTransactionTypeForm = (props, ref) => {
+	const { onSubmit, initialData, disableSubTypeFields, domainNameOptions, onSelectDomainName, domainFieldOptions, selectedDomainName } = props;
+	const handleSubmitRef = useRef();
+	const { t } = useTranslation();
+	const classes = useStyles$3();
+	const formInitialValues = useMemo(() => {
+		let formattedData;
+		if (!initialData) return;
+		formattedData = {
+			...initialData,
+			domainName: domainNameOptions?.find((domainName) => domainName === selectedDomainName || ""),
+			domainFieldType: domainFieldOptions?.find((domainField) => domainField === initialData?.domainFieldType),
+			domainFieldLabel: domainFieldOptions?.find((domainField) => domainField === initialData?.domainFieldLabel),
+			revisionField: domainFieldOptions?.find((domainField) => domainField === initialData?.revisionField),
+			domainFields: selectedDomainName === initialData?.domainName && initialData?.domainFields ? Object.entries(initialData?.domainFields).map(([fieldKey, fieldConfig]) => {
+				return [fieldKey, { ...fieldConfig && typeof fieldConfig === "object" ? fieldConfig : { value: fieldConfig } }];
+			}) : [[]]
+		};
+		return formattedData;
+	}, [
+		initialData,
+		domainNameOptions,
+		domainFieldOptions,
+		selectedDomainName
+	]);
+	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 ?? (() => {});
+			const handleDomainNameChange = (value) => {
+				const nextDomainName = value || "";
+				if ((form.getState().values?.domainName || "") !== nextDomainName) {
+					onSelectDomainName?.(nextDomainName);
+					form.change("domainFields", []);
+				}
+			};
+			const handleDomainFieldTypeChange = (value) => {
+				if (!value) form.change("domainFieldValue", "");
+			};
+			const hasRevision = !!form.getState().values?.hasRevision;
+			const hasDomainFieldType = !!form.getState().values?.domainFieldType;
+			const parseHasRevision = (value) => {
+				const nextValue = value?.target ? !!value.target.checked : !!value;
+				if (!nextValue) form.change("revisionField", null);
+				return nextValue;
+			};
+			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
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("Domain"),
+				id: "domainName",
+				name: "domainName",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: domainNameOptions || [],
+				getOptionLabelFunction: (option) => option,
+				additionalOnChangeAction: handleDomainNameChange
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: "Sub-Type",
+				id: "domainFieldType",
+				name: "domainFieldType",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: domainFieldOptions || [],
+				getOptionLabelFunction: (option) => option,
+				additionalOnChangeAction: handleDomainFieldTypeChange,
+				disabled: disableSubTypeFields
+			}), 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",
+				disabled: disableSubTypeFields
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("Field Label"),
+				id: "domainFieldLabel",
+				name: "domainFieldLabel",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: domainFieldOptions || [],
+				getOptionLabelFunction: (option) => option,
+				helperText: t("Field property to be used in transaction page labels")
+			}), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "nudge" }), /* @__PURE__ */ React.createElement(FormControlLabel, {
+				control: /* @__PURE__ */ React.createElement(Field$1, {
+					component: Switch,
+					id: "archiveOnCancel",
+					name: "archiveOnCancel",
+					type: "checkbox"
+				}),
+				label: t("Archive on Cancel")
+			}), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "nudge" }), /* @__PURE__ */ React.createElement(FormControlLabel, {
+				control: /* @__PURE__ */ React.createElement(Field$1, {
+					component: Switch,
+					id: "enabled",
+					name: "enabled",
+					type: "checkbox"
+				}),
+				label: t("Enabled")
+			}), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "nudge" }), /* @__PURE__ */ React.createElement(FormControlLabel, {
+				control: /* @__PURE__ */ React.createElement(Field$1, {
+					component: Switch,
+					id: "hasRevision",
+					name: "hasRevision",
+					type: "checkbox",
+					parse: parseHasRevision
+				}),
+				label: t("Allow Revisions")
+			}), hasRevision && /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: "Revision Field",
+				id: "revisionField",
+				name: "revisionField",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: domainFieldOptions || [],
+				getOptionLabelFunction: (option) => option
+			}), /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("div", { className: classes.addRemoveButtons }, /* @__PURE__ */ React.createElement(FluentButton, {
+				variant: "contained",
+				color: "primary",
+				onClick: () => push("domainFields", void 0)
+			}, t("Add a Domain Field"))), /* @__PURE__ */ React.createElement(FieldArray, { name: "domainFields" }, ({ 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: domainFieldOptions || [],
+				getOptionLabelFunction: (option) => option,
+				onChange: () => {}
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: FluentTextField,
+				label: index === 0 && t("Display Name"),
+				name: `${name}[1].displayName`,
+				fullWidth: true,
+				variant: "outlined",
+				margin: "normal",
+				size: "small",
+				onChange: () => {},
+				className: classes.domainValueField
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: FluentTextField,
+				label: index === 0 && t("Order"),
+				name: `${name}[1].order`,
+				fullWidth: true,
+				variant: "outlined",
+				margin: "normal",
+				size: "small",
+				type: "number",
+				onChange: () => {},
+				className: classes.domainValueField
+			}), /* @__PURE__ */ React.createElement("span", {
+				onClick: () => fields.remove(index),
+				style: { cursor: "pointer" },
+				className: classes.removeIcon
+			}, /* @__PURE__ */ React.createElement(StatusCircleErrorXIcon, null)))))));
+		}
+	});
+};
+var UdpTransactionTypeForm_default = forwardRef(UdpTransactionTypeForm);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/sidesheets/UdpTransactionTypeSidesheet.jsx
+const UdpTransactionTypeSidesheet = (props) => {
+	const { initialTransactionType, isSideSheetOpen, handleSideSheet, setSelectedDomainName, selectedDomainName, handleCreateTransactionType, handleUpdateTransactionType, catalogObjects, catalogObjectProperties } = props;
+	const isEditing = !!initialTransactionType;
+	const formRef = useRef();
+	const { t } = useTranslation();
+	const [transactions, setTransactions] = useState(null);
+	const catalogObjectNames = useMemo(() => {
+		const catalogObjectList = catalogObjects?.ctlg?.catalogObjectList;
+		if (!catalogObjectList) return [];
+		return catalogObjectList.map((obj) => obj.catalogObjectName);
+	}, [catalogObjects]);
+	const onSubmitForm = useCallback(async (values, initialData) => {
+		if (initialData) await handleUpdateTransactionType(values, initialData);
+		else await handleCreateTransactionType(values);
+	}, [handleCreateTransactionType, handleUpdateTransactionType]);
+	const handleCloseSidesheet = useCallback((isOpen, domainName) => {
+		handleSideSheet(isOpen);
+		setSelectedDomainName(domainName);
+	}, [handleSideSheet, setSelectedDomainName]);
+	if (!isSideSheetOpen && transactions) setTransactions(null);
+	const shouldDisableSubTypes = useMemo(() => {
+		if (!transactions || transactions.length === 0 || !initialTransactionType) return false;
+		const targetValue = initialTransactionType.domainFieldValue;
+		if (targetValue === void 0 || targetValue === null) return false;
+		return transactions.some((t$1) => {
+			return t$1.entityBusinessObject?.[initialTransactionType.domainFieldType] === targetValue;
+		});
+	}, [transactions, initialTransactionType]);
+	useEffect(() => {
+		if (initialTransactionType) setSelectedDomainName(initialTransactionType?.domainName);
+	}, [initialTransactionType, setSelectedDomainName]);
+	useEffect(() => {
+		let isMounted = true;
+		const fetchTransactions = async () => {
+			if (isEditing && isSideSheetOpen && initialTransactionType?.transactionTypeId) try {
+				const response = await apiMutate(ConfigService.productV1ApiUrl, "UdpTransaction/search", { method: "post" }, { data: {
+					filterElements: [{
+						searchField: "transactionTypeId",
+						searchOperator: "=",
+						searchValue: initialTransactionType.transactionTypeId
+					}, {
+						searchField: "isDeleted",
+						searchOperator: "=",
+						searchValue: 0
+					}],
+					getAll: true
+				} });
+				if (isMounted && response?.data?.pageList) setTransactions(response.data.pageList);
+			} catch (error) {
+				console.error("Failed to check transaction existence", error);
+				if (isMounted) setTransactions([]);
+			}
+		};
+		fetchTransactions();
+		return () => {
+			isMounted = false;
+		};
+	}, [
+		initialTransactionType,
+		isEditing,
+		isSideSheetOpen
+	]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 800,
+		title: isEditing ? t("Edit Transaction Type") : t("Create Transaction Type"),
+		onClose: () => handleCloseSidesheet(false),
+		buttonLabel: isEditing ? t("Save") : t("Create"),
+		onSubmit: () => {
+			formRef?.current?.submit();
+		}
+	}, isEditing && !transactions ? /* @__PURE__ */ React.createElement(LinearProgress$1, null) : /* @__PURE__ */ React.createElement(UdpTransactionTypeForm_default, {
+		ref: formRef,
+		onSubmit: onSubmitForm,
+		initialData: initialTransactionType,
+		disableSubTypeFields: shouldDisableSubTypes,
+		domainNameOptions: catalogObjectNames,
+		onSelectDomainName: setSelectedDomainName,
+		domainFieldOptions: catalogObjectProperties,
+		selectedDomainName
+	}));
+};
+var UdpTransactionTypeSidesheet_default = UdpTransactionTypeSidesheet;
+
+//#endregion
+//#region src/udp/utilities/transactionConstants.js
+const TRANSACTION_TYPE_STATUS_COLORS = [
+	{
+		name: "Default",
+		value: "gray"
+	},
+	{
+		name: "Warning",
+		value: "warning"
+	},
+	{
+		name: "Info",
+		value: "info"
+	},
+	{
+		name: "Success",
+		value: "success"
+	},
+	{
+		name: "Error",
+		value: "error"
+	}
+];
+const DOMAIN_VALUE_OPERATORS = [
+	{
+		value: "==",
+		name: "Equals"
+	},
+	{
+		value: "!=",
+		name: "Does not Equal"
+	},
+	{
+		value: ">",
+		name: "Greater Than"
+	},
+	{
+		value: "<",
+		name: "Less Than"
+	},
+	{
+		value: ">=",
+		name: "Greater Than or Equal To"
+	},
+	{
+		value: "<=",
+		name: "Less Than or Equal To"
+	},
+	{
+		value: "or",
+		name: "Or"
+	},
+	{
+		value: "and",
+		name: "And"
+	},
+	{
+		value: "!",
+		name: "Is Empty"
+	},
+	{
+		value: "!!",
+		name: "Is Not Empty"
+	}
+];
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/forms/UdpTransactionTypeStatusForm.jsx
+const UdpTransactionTypeStatusForm = (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 || ""
+			}), /* @__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(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("Color"),
+				id: "color",
+				name: "color",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: TRANSACTION_TYPE_STATUS_COLORS || [],
+				getOptionLabelFunction: (option) => option.name,
+				initialValue: TRANSACTION_TYPE_STATUS_COLORS?.find((color) => color?.value === initialData?.color) || null
+			}), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "nudge" }), /* @__PURE__ */ React.createElement(FormControlLabel, {
+				control: /* @__PURE__ */ React.createElement(Field$1, {
+					component: Switch,
+					id: "isDefault",
+					name: "isDefault",
+					type: "checkbox",
+					initialValue: !!initialData?.isDefault
+				}),
+				label: t("Default")
+			}), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "nudge" }), /* @__PURE__ */ React.createElement(FormControlLabel, {
+				control: /* @__PURE__ */ React.createElement(Field$1, {
+					component: Switch,
+					id: "isClosedStatus",
+					name: "isClosedStatus",
+					type: "checkbox",
+					initialValue: !!initialData?.isClosedStatus
+				}),
+				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")
+			}));
+		}
+	});
+};
+var UdpTransactionTypeStatusForm_default = forwardRef(UdpTransactionTypeStatusForm);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/sidesheets/UdpTransactionTypeStatusCreateAndEditSidesheet.jsx
+const UdpTransactionTypeStatusCreateAndEditSidesheet = (props) => {
+	const { initialTransactionTypeStatus, isSideSheetOpen, handleSideSheet, handleCreateTransactionTypeStatus, handleUpdateTransactionTypeStatus } = props;
+	const isEditing = !!initialTransactionTypeStatus;
+	const formRef = useRef();
+	const { t } = useTranslation();
+	const onSubmitForm = useCallback(async (values, initialData) => {
+		if (initialData) await handleUpdateTransactionTypeStatus(values, initialData);
+		else await handleCreateTransactionTypeStatus(values);
+	}, [handleCreateTransactionTypeStatus, handleUpdateTransactionTypeStatus]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 500,
+		title: isEditing ? t("Edit Status") : t("Create Status"),
+		onClose: () => handleSideSheet(false),
+		buttonLabel: isEditing ? t("Save") : t("Create"),
+		onSubmit: () => {
+			formRef?.current?.submit();
+		}
+	}, /* @__PURE__ */ React.createElement(UdpTransactionTypeStatusForm_default, {
+		ref: formRef,
+		onSubmit: onSubmitForm,
+		initialData: initialTransactionTypeStatus
+	}));
+};
+var UdpTransactionTypeStatusCreateAndEditSidesheet_default = UdpTransactionTypeStatusCreateAndEditSidesheet;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/sidesheets/UdpTransactionTypeStatusSidesheet.jsx
+const UdpTransactionTypeStatusSidesheet = (props, ref) => {
+	const { transactionType, transactionTypeStatus, isSideSheetOpen, isTransactionTypeStatusCreateOrEditSidesheetOpen, handleTransactionTypeStatusSideSheet, handleCreateOrEditTransactionTypeStatusSideSheet, handleCreateTransactionTypeStatus, handleUpdateTransactionTypeStatus, handleDeleteTransactionTypeStatus } = props;
+	const transactionTypeStatusGridApiRef = useRef(null);
+	const { t } = useTranslation();
+	useImperativeHandle(ref, () => ({ refreshServerSide: () => {
+		transactionTypeStatusGridApiRef?.current?.refreshServerSide();
+	} }));
+	const getStatusLabel = (node) => {
+		let label = "";
+		label = TRANSACTION_TYPE_STATUS_COLORS.find((color) => color.value === node.data.color)?.name;
+		return label || "";
+	};
+	const getStatusColor = useMemo(() => {
+		return {
+			Default: "gray",
+			Warning: "warning",
+			Info: "info",
+			Success: "success",
+			Error: "error"
+		};
+	}, []);
+	const columnDefs = useMemo(() => {
+		return [
+			{
+				headerName: t("Name"),
+				field: "name",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Code"),
+				field: "code",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Color"),
+				field: "color",
+				resizable: true,
+				sortable: false,
+				cellRenderer: "statusRenderer",
+				cellRendererParams: {
+					statusMappingConfig: getStatusColor,
+					getStatusValue: getStatusLabel
+				}
+			},
+			{
+				headerName: t("Default"),
+				field: "isDefault",
+				resizable: true,
+				sortable: false,
+				cellDataType: "boolean"
+			},
+			{
+				headerName: t("Closed Status"),
+				field: "isClosedStatus",
+				resizable: true,
+				sortable: false,
+				cellDataType: "boolean"
+			},
+			{
+				headerName: t("Cancelled Status"),
+				field: "isCancelledStatus",
+				resizable: true,
+				sortable: false,
+				cellDataType: "boolean"
+			},
+			{
+				headerName: t("Actions"),
+				field: "actions",
+				cellRenderer: "actionsRenderer",
+				cellRendererParams: { actionList: [{
+					id: 0,
+					title: t("Edit"),
+					iconName: "edit",
+					handleOnClick: (e, transactionTypeStatus$1) => {
+						handleCreateOrEditTransactionTypeStatusSideSheet(true, transactionTypeStatus$1?.data);
+					}
+				}, {
+					id: 1,
+					title: t("Delete"),
+					iconName: "trashCan",
+					handleOnClick: (e, transactionTypeStatus$1) => {
+						handleDeleteTransactionTypeStatus(transactionTypeStatus$1?.data);
+					}
+				}] },
+				suppressMenu: true,
+				sortable: false,
+				filter: false,
+				valueGetter: (params) => params.data
+			}
+		];
+	}, [
+		t,
+		handleCreateOrEditTransactionTypeStatusSideSheet,
+		handleDeleteTransactionTypeStatus
+	]);
+	const headerConfig = {
+		title: t("Statuses"),
+		primaryActionButton: {
+			label: t("Add"),
+			iconName: "add",
+			onClick: () => handleCreateOrEditTransactionTypeStatusSideSheet(true)
+		}
+	};
+	const gridFunctions = [
+		{ name: "agGridExport" },
+		{ name: "agGridSizeColumnsToFit" },
+		{ name: "agGridAutoSizeColumns" },
+		{ name: "agGridResetColumns" },
+		{ name: "agGridHideShowColumns" }
+	];
+	const gridOptions = useMemo(() => {
+		return { pagination: true };
+	}, []);
+	const handleGridApiCallback = (api) => {
+		transactionTypeStatusGridApiRef.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}/UdpTransactionTypeStatus/search`,
+				customSearchObject: { filterElements }
+			};
+		}
+		return {};
+	}, [transactionType]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 900,
+		title: t("Manage Statuses"),
+		onClose: () => handleTransactionTypeStatusSideSheet(false)
+	}, /* @__PURE__ */ React.createElement(SearchMethodUdpGrid, {
+		searchMethodConfig,
+		columnDefs,
+		gridHeaderConfig: headerConfig,
+		gridOptions,
+		gridApiCallback: handleGridApiCallback,
+		gridFunctions
+	}), /* @__PURE__ */ React.createElement(UdpTransactionTypeStatusCreateAndEditSidesheet_default, {
+		initialTransactionTypeStatus: transactionTypeStatus,
+		isSideSheetOpen: isTransactionTypeStatusCreateOrEditSidesheetOpen,
+		handleCreateTransactionTypeStatus,
+		handleUpdateTransactionTypeStatus,
+		handleSideSheet: handleCreateOrEditTransactionTypeStatusSideSheet
+	}));
+};
+var UdpTransactionTypeStatusSidesheet_default = forwardRef(UdpTransactionTypeStatusSidesheet);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/forms/UdpTransactionTypeTransactionActionFormFields.jsx
+const useStyles$2 = 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 UdpTransactionTypeTransactionActionFormFields = (props) => {
+	const { transactionActionOptions, catalogObjectProperties, actionApiOptions, pageOptions, transactionTypeStatusOptions, showMandatoryFields, showHiddenFields, showToStatusField, showActionApiField, showPageField, showDomainDataToUpdateFields, pushToFieldArray } = props;
+	const { t } = useTranslation();
+	const classes = useStyles$2();
+	const form = useForm();
+	const { values } = useFormState();
+	useEffect(() => {
+		if (!showMandatoryFields) form.change("mandatoryFields", []);
+		if (!showHiddenFields) form.change("hiddenFields", []);
+		if (!showToStatusField) form.change("toStatus", null);
+		if (!showActionApiField) form.change("actionApiId", null);
+		if (!showPageField) form.change("pageId", []);
+		if (!showDomainDataToUpdateFields) form.change("domainDataToUpdate", [[]]);
+	}, [
+		form,
+		showMandatoryFields,
+		showHiddenFields,
+		showToStatusField,
+		showActionApiField,
+		showPageField,
+		showDomainDataToUpdateFields,
+		values.transactionAction
+	]);
+	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
+	}), /* @__PURE__ */ React.createElement(Field$1, {
+		component: FluentTextField,
+		label: t("Description"),
+		id: "description",
+		name: "description",
+		fullWidth: true,
+		variant: "outlined",
+		margin: "normal",
+		size: "small"
+	}), /* @__PURE__ */ React.createElement(Field$1, {
+		component: FluentTextField,
+		label: t("Icon"),
+		id: "icon",
+		name: "icon",
+		fullWidth: true,
+		variant: "outlined",
+		margin: "normal",
+		size: "small"
+	}), /* @__PURE__ */ React.createElement(Field$1, {
+		component: AmbientAutoComplete,
+		label: t("Transaction Action"),
+		id: "transactionAction",
+		name: "transactionAction",
+		variant: "outlined",
+		isMultiple: false,
+		disableCloseOnSelect: false,
+		options: transactionActionOptions || [],
+		getOptionLabelFunction: (option) => option.name,
+		valueForChange: (value) => {
+			return value;
+		},
+		required: true
+	}), showToStatusField && /* @__PURE__ */ React.createElement(Field$1, {
+		component: AmbientAutoComplete,
+		label: t("To Status"),
+		id: "toStatus",
+		name: "toStatus",
+		variant: "outlined",
+		isMultiple: false,
+		disableCloseOnSelect: false,
+		options: transactionTypeStatusOptions || [],
+		getOptionLabelFunction: (option) => option.name
+	}), showMandatoryFields && /* @__PURE__ */ React.createElement(Field$1, {
+		component: AmbientAutoComplete,
+		label: t("Mandatory Fields"),
+		id: "mandatoryFields",
+		name: "mandatoryFields",
+		variant: "outlined",
+		isMultiple: true,
+		disableCloseOnSelect: true,
+		options: catalogObjectProperties || [],
+		getOptionLabelFunction: (option) => option
+	}), showHiddenFields && /* @__PURE__ */ React.createElement(Field$1, {
+		component: AmbientAutoComplete,
+		label: t("Hidden Fields"),
+		id: "hiddenFields",
+		name: "hiddenFields",
+		variant: "outlined",
+		isMultiple: true,
+		disableCloseOnSelect: true,
+		options: catalogObjectProperties || [],
+		getOptionLabelFunction: (option) => option
+	}), showActionApiField && /* @__PURE__ */ React.createElement(Field$1, {
+		component: AmbientAutoComplete,
+		label: t("Action Api"),
+		id: "actionApiId",
+		name: "actionApiId",
+		variant: "outlined",
+		isMultiple: false,
+		disableCloseOnSelect: false,
+		options: actionApiOptions || [],
+		getOptionLabelFunction: (option) => option.name
+	}), showPageField && /* @__PURE__ */ React.createElement(Field$1, {
+		component: AmbientAutoComplete,
+		label: t("Page"),
+		id: "pageId",
+		name: "pageId",
+		variant: "outlined",
+		isMultiple: false,
+		disableCloseOnSelect: false,
+		options: pageOptions || [],
+		getOptionLabelFunction: (option) => option.name
+	}), showDomainDataToUpdateFields && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("div", { className: classes.addRemoveButtons }, /* @__PURE__ */ React.createElement(FluentButton, {
+		variant: "contained",
+		color: "primary",
+		onClick: () => pushToFieldArray("domainDataToUpdate", void 0)
+	}, t("Add a Domain Field"))), /* @__PURE__ */ React.createElement(FieldArray, { name: "domainDataToUpdate" }, ({ 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 UdpTransactionTypeTransactionActionFormFields_default = UdpTransactionTypeTransactionActionFormFields;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/forms/UdpTransactionTypeTransactionActionForm.jsx
+const baseActionsList = [
+	UdpTransactionActionEnums.Send_Email,
+	UdpTransactionActionEnums.Create_Reminder,
+	UdpTransactionActionEnums.Custom_Client_Action
+];
+const UdpTransactionTypeTransactionActionForm = (props, ref) => {
+	const { onSubmit, initialData, transactionActionOptions, catalogObjectProperties, actionApiOptions, pageOptions, transactionTypeStatusOptions } = props;
+	const handleSubmitRef = useRef();
+	const formInitialValues = useMemo(() => {
+		let formattedData;
+		if (!initialData) return;
+		formattedData = {
+			...initialData,
+			transactionAction: transactionActionOptions?.find((transactionAction) => transactionAction?.transactionActionId === initialData?.transactionActionId),
+			toStatus: transactionTypeStatusOptions?.find((tts) => tts?.transactionTypeStatusId === initialData?.parameters?.toStatus),
+			mandatoryFields: initialData?.parameters?.mandatoryFields,
+			hiddenFields: initialData?.parameters?.hiddenFields,
+			actionApiId: actionApiOptions?.find((actionApi) => actionApi?.actionApiId === initialData?.parameters?.actionApiId),
+			pageId: pageOptions?.find((page) => page?.pageId === initialData?.parameters?.pageId),
+			domainDataToUpdate: initialData?.parameters?.domainDataToUpdate ? Object.entries(initialData?.parameters?.domainDataToUpdate) : [[]]
+		};
+		return formattedData;
+	}, [
+		initialData,
+		transactionActionOptions,
+		transactionTypeStatusOptions,
+		actionApiOptions,
+		pageOptions
+	]);
+	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 ?? (() => {});
+			const transactionActionName = form?.getState()?.values?.transactionAction?.name;
+			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.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,
+				catalogObjectProperties,
+				actionApiOptions,
+				pageOptions,
+				transactionTypeStatusOptions,
+				showMandatoryFields,
+				showHiddenFields,
+				showToStatusField,
+				showActionApiField,
+				showPageField,
+				showDomainDataToUpdateFields,
+				pushToFieldArray: push
+			});
+		}
+	});
+};
+var UdpTransactionTypeTransactionActionForm_default = forwardRef(UdpTransactionTypeTransactionActionForm);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/sidesheets/UdpTransactionTypeTransactionActionCreateAndEditSidesheet.jsx
+const UdpTransactionTypeTransactionActionCreateAndEditSidesheet = (props) => {
+	const { initialTransactionTypeTransactionAction, isSideSheetOpen, handleSideSheet, handleCreateTransactionTypeTransactionAction, handleUpdateTransactionTypeTransactionAction, transactionActions, catalogObjectProperties, actionApis, pages, transactionTypeStatusOptions } = props;
+	const isEditing = !!initialTransactionTypeTransactionAction;
+	const formRef = useRef();
+	const { t } = useTranslation();
+	const onSubmitForm = useCallback(async (values, initialData) => {
+		if (initialData) await handleUpdateTransactionTypeTransactionAction(values, initialData);
+		else await handleCreateTransactionTypeTransactionAction(values);
+	}, [handleCreateTransactionTypeTransactionAction, handleUpdateTransactionTypeTransactionAction]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 600,
+		title: isEditing ? t("Edit Action") : t("Create Action"),
+		onClose: () => handleSideSheet(false),
+		buttonLabel: isEditing ? t("Save") : t("Create"),
+		onSubmit: () => {
+			formRef?.current?.submit();
+		}
+	}, /* @__PURE__ */ React.createElement(UdpTransactionTypeTransactionActionForm_default, {
+		ref: formRef,
+		onSubmit: onSubmitForm,
+		initialData: initialTransactionTypeTransactionAction,
+		transactionActionOptions: transactionActions,
+		catalogObjectProperties,
+		actionApiOptions: actionApis,
+		pageOptions: pages,
+		transactionTypeStatusOptions
+	}));
+};
+var UdpTransactionTypeTransactionActionCreateAndEditSidesheet_default = UdpTransactionTypeTransactionActionCreateAndEditSidesheet;
+
+//#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, ttstatuses } = props;
+	const transactionTypeTransactionActionGridApiRef = useRef(null);
+	const { t } = useTranslation();
+	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();
+	} }));
+	const getTransactionActionName = useCallback((transactionActionId) => {
+		if (!transactionActions) return "";
+		return transactionActions.find((transactionAction) => transactionAction.transactionActionId === transactionActionId)?.name || "";
+	}, [transactionActions]);
+	const columnDefs = useMemo(() => {
+		return [
+			{
+				headerName: t("Name"),
+				field: "name",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Description"),
+				field: "description",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Icon"),
+				field: "icon",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Transaction Action"),
+				resizable: true,
+				sortable: false,
+				valueGetter: (params) => getTransactionActionName(params.data.transactionActionId)
+			},
+			{
+				headerName: t("Actions"),
+				field: "actions",
+				cellRenderer: "actionsRenderer",
+				cellRendererParams: { actionList: [{
+					id: 0,
+					title: t("Edit"),
+					iconName: "edit",
+					handleOnClick: (e, transactionTypeTransactionAction$1) => {
+						handleCreateOrEditTransactionTypeTransactionActionSidesheet(true, transactionTypeTransactionAction$1?.data);
+					}
+				}, {
+					id: 1,
+					title: t("Delete"),
+					iconName: "trashCan",
+					handleOnClick: (e, transactionTypeTransactionAction$1) => {
+						handleDeleteTransactionTypeTransactionAction(transactionTypeTransactionAction$1?.data);
+					}
+				}] },
+				suppressMenu: true,
+				sortable: false,
+				filter: false,
+				valueGetter: (params) => params.data
+			}
+		];
+	}, [
+		t,
+		handleCreateOrEditTransactionTypeTransactionActionSidesheet,
+		handleDeleteTransactionTypeTransactionAction,
+		getTransactionActionName
+	]);
+	const headerConfig = {
+		title: t("Actions"),
+		primaryActionButton: {
+			label: t("Add"),
+			iconName: "add",
+			onClick: () => handleCreateOrEditTransactionTypeTransactionActionSidesheet(true)
+		}
+	};
+	const gridFunctions = [
+		{ name: "agGridExport" },
+		{ name: "agGridSizeColumnsToFit" },
+		{ name: "agGridAutoSizeColumns" },
+		{ name: "agGridResetColumns" },
+		{ name: "agGridHideShowColumns" }
+	];
+	const gridOptions = useMemo(() => {
+		return { pagination: true };
+	}, []);
+	const handleGridApiCallback = (api) => {
+		transactionTypeTransactionActionGridApiRef.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}/UdpTransactionTypeTransactionAction/search`,
+				customSearchObject: { filterElements }
+			};
+		}
+		return {};
+	}, [transactionType]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 800,
+		title: t("Manage Actions"),
+		onClose: () => handleTransactionTypeTransactionActionSidesheet(false)
+	}, /* @__PURE__ */ React.createElement(SearchMethodUdpGrid, {
+		searchMethodConfig,
+		columnDefs,
+		gridHeaderConfig: headerConfig,
+		gridOptions,
+		gridApiCallback: handleGridApiCallback,
+		gridFunctions
+	}), /* @__PURE__ */ React.createElement(UdpTransactionTypeTransactionActionCreateAndEditSidesheet_default, {
+		initialTransactionTypeTransactionAction: transactionTypeTransactionAction,
+		isSideSheetOpen: isTransactionTypeTransactionActionCreateOrEditSidesheetOpen,
+		handleCreateTransactionTypeTransactionAction,
+		handleUpdateTransactionTypeTransactionAction,
+		handleSideSheet: handleCreateOrEditTransactionTypeTransactionActionSidesheet,
+		transactionActions: filteredTransactionActions,
+		catalogObjectProperties,
+		actionApis,
+		pages,
+		transactionTypeStatusOptions: ttstatuses
+	}));
+};
+var UdpTransactionTypeTransactionActionSidesheet_default = forwardRef(UdpTransactionTypeTransactionActionSidesheet);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/forms/UdpTransactionUiActionForm.jsx
+const UdpTransactionUiActionForm = (props, ref) => {
+	const { onSubmit, initialData, transactionUiActionTypeOptions, actionApiOptions, pageOptions } = 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, /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("Transaction UI Action Type"),
+				id: "transactionUiActionType",
+				name: "transactionUiActionType",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: transactionUiActionTypeOptions || [],
+				getOptionLabelFunction: (option) => option.name,
+				initialValue: transactionUiActionTypeOptions?.find((transactionUiActionType) => transactionUiActionType?.transactionUiActionTypeId === initialData?.transactionUiActionTypeId) || null,
+				required: true
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("Action Api"),
+				id: "actionApi",
+				name: "actionApi",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: actionApiOptions || [],
+				getOptionLabelFunction: (option) => option.name,
+				initialValue: actionApiOptions?.find((actionApi) => actionApi?.actionApiId === initialData?.parameters?.actionApiId) || null
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("Page"),
+				id: "page",
+				name: "page",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: pageOptions || [],
+				getOptionLabelFunction: (option) => option.name,
+				initialValue: pageOptions?.find((page) => page?.pageId === initialData?.parameters?.pageId) || null
+			}));
+		}
+	});
+};
+var UdpTransactionUiActionForm_default = forwardRef(UdpTransactionUiActionForm);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/sidesheets/UdpTransactionUiActionCreateAndEditSidesheet.jsx
+const UdpTransactionUiActionCreateAndEditSidesheet = (props) => {
+	const { initialTransactionUiAction, isSideSheetOpen, handleSideSheet, handleCreateTransactionUiAction, handleUpdateTransactionUiAction, transactionUiActionTypes, actionApis, pages, tUiActionsList } = props;
+	const isEditing = !!initialTransactionUiAction;
+	const formRef = useRef();
+	const { t } = useTranslation();
+	const normalizeToArray = (source) => {
+		if (Array.isArray(source)) return source;
+		return [];
+	};
+	const filterAvailableTUATypes = useCallback((allTUATypes, transactionUiActions, currentTransactionUiActionTypeId = null) => {
+		const allTUATypesArray = normalizeToArray(allTUATypes);
+		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) return [];
+		return filterAvailableTUATypes(transactionUiActionTypes, tUiActionsList, initialTransactionUiAction ? initialTransactionUiAction.transactionUiActionTypeId : null);
+	}, [
+		transactionUiActionTypes,
+		tUiActionsList,
+		initialTransactionUiAction,
+		filterAvailableTUATypes
+	]);
+	const onSubmitForm = useCallback(async (values, initialData) => {
+		if (initialData) await handleUpdateTransactionUiAction(values, initialData);
+		else await handleCreateTransactionUiAction(values);
+	}, [handleCreateTransactionUiAction, handleUpdateTransactionUiAction]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 600,
+		title: isEditing ? t("Edit UI Action") : t("Create UI Action"),
+		onClose: () => handleSideSheet(false),
+		buttonLabel: isEditing ? t("Save") : t("Create"),
+		onSubmit: () => {
+			formRef?.current?.submit();
+		}
+	}, /* @__PURE__ */ React.createElement(UdpTransactionUiActionForm_default, {
+		ref: formRef,
+		onSubmit: onSubmitForm,
+		initialData: initialTransactionUiAction,
+		transactionUiActionTypeOptions: availableTUATypeOptions,
+		actionApiOptions: actionApis,
+		pageOptions: pages
+	}));
+};
+var UdpTransactionUiActionCreateAndEditSidesheet_default = UdpTransactionUiActionCreateAndEditSidesheet;
+
+//#endregion
+//#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 transactionUiActionGridApiRef = useRef(null);
+	const { t } = useTranslation();
+	useImperativeHandle(ref, () => ({ refreshServerSide: () => {
+		transactionUiActionGridApiRef?.current?.refreshServerSide();
+	} }));
+	const getTransactionUiActionTypeName = useCallback((transactionUiActionTypeId) => {
+		if (!transactionUiActionTypes) return "";
+		return transactionUiActionTypes.find((transactionUiActionType) => transactionUiActionType.transactionUiActionTypeId === transactionUiActionTypeId)?.name || "";
+	}, [transactionUiActionTypes]);
+	const columnDefs = useMemo(() => {
+		return [
+			{
+				headerName: t("TransactionUiActionId"),
+				field: "transactionUiActionId",
+				resizable: true,
+				sortable: false,
+				hide: true
+			},
+			{
+				headerName: t("Type"),
+				field: "transactionUiActionTypeId",
+				resizable: false,
+				sortable: false,
+				valueGetter: (params) => getTransactionUiActionTypeName(params.data.transactionUiActionTypeId)
+			},
+			{
+				headerName: t("Actions"),
+				field: "actions",
+				cellRenderer: "actionsRenderer",
+				cellRendererParams: { actionList: [{
+					id: 0,
+					title: t("Edit"),
+					iconName: "edit",
+					handleOnClick: (e, transactionUiAction$1) => {
+						handleCreateOrEditTransactionUiActionSidesheet(true, transactionUiAction$1?.data);
+					}
+				}, {
+					id: 1,
+					title: t("Delete"),
+					iconName: "trashCan",
+					handleOnClick: (e, transactionUiAction$1) => {
+						handleDeleteTransactionUiAction(transactionUiAction$1?.data);
+					}
+				}] },
+				suppressMenu: true,
+				sortable: false,
+				filter: false,
+				valueGetter: (params) => params.data
+			}
+		];
+	}, [
+		t,
+		handleCreateOrEditTransactionUiActionSidesheet,
+		handleDeleteTransactionUiAction,
+		getTransactionUiActionTypeName
+	]);
+	const headerConfig = {
+		title: t("Form / Page Overrides"),
+		primaryActionButton: {
+			label: t("Add"),
+			iconName: "add",
+			onClick: () => handleCreateOrEditTransactionUiActionSidesheet(true)
+		}
+	};
+	const gridFunctions = [
+		{ name: "agGridExport" },
+		{ name: "agGridSizeColumnsToFit" },
+		{ name: "agGridAutoSizeColumns" },
+		{ name: "agGridResetColumns" },
+		{ name: "agGridHideShowColumns" }
+	];
+	const gridOptions = useMemo(() => {
+		return { pagination: true };
+	}, []);
+	const handleGridApiCallback = (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 }
+			};
+		}
+		return {};
+	}, [transactionType]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 800,
+		title: t("Manage Form / Page Overrides"),
+		onClose: () => handleTransactionUiActionSidesheet(false)
+	}, /* @__PURE__ */ React.createElement(SearchMethodUdpGrid, {
+		searchMethodConfig,
+		columnDefs,
+		gridHeaderConfig: headerConfig,
+		gridOptions,
+		gridApiCallback: handleGridApiCallback,
+		gridFunctions
+	}), /* @__PURE__ */ React.createElement(UdpTransactionUiActionCreateAndEditSidesheet_default, {
+		initialTransactionUiAction: transactionUiAction,
+		isSideSheetOpen: isCreateOrEditTransactionUiActionSidesheetOpen,
+		handleCreateTransactionUiAction,
+		handleUpdateTransactionUiAction,
+		handleSideSheet: handleCreateOrEditTransactionUiActionSidesheet,
+		transactionUiActionTypes,
+		actionApis,
+		pages,
+		tUiActionsList
+	}));
+};
+var UdpTransactionUiActionSidesheet_default = forwardRef(UdpTransactionUiActionSidesheet);
+
+//#endregion
+//#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) }
+	},
+	domainValueField: { minWidth: "200px" },
+	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 UdpTransactionTypeConfigurationForm = (props, ref) => {
+	const { onSubmit, initialData, transactionRuleTypes, catalogObjectProperties, transactionTypeStatusOptions, roles } = props;
+	const handleSubmitRef = useRef();
+	const { t } = useTranslation();
+	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).map(([fieldKey, fieldConfig]) => {
+				const normalizedFieldConfig = fieldConfig && typeof fieldConfig === "object" ? fieldConfig : { value: fieldConfig };
+				const operatorOption = DOMAIN_VALUE_OPERATORS.find((option) => option.value === normalizedFieldConfig?.operator) || null;
+				return [fieldKey, {
+					...normalizedFieldConfig,
+					operator: operatorOption
+				}];
+			}) : [[]]
+		};
+		return formattedData;
+	}, [
+		initialData,
+		transactionRuleTypes,
+		roles,
+		ttstatusesWithNostatusOption
+	]);
+	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,
+				groupBy: (option) => option.productName,
+				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: AmbientAutoComplete,
+				label: index === 0 && t("Operator"),
+				name: `${name}[1].operator`,
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: DOMAIN_VALUE_OPERATORS || [],
+				getOptionLabelFunction: (option) => option.name,
+				onChange: () => {}
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: FluentTextField,
+				label: index === 0 && t("Value"),
+				name: `${name}[1].value`,
+				fullWidth: true,
+				variant: "outlined",
+				margin: "normal",
+				size: "small",
+				onChange: () => {},
+				className: classes.domainValueField
+			}), /* @__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: 800,
+		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 }
+			};
+		}
+		return {};
+	}, [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 }
+			};
+		}
+		return {};
+	}, [transactionType]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 900,
+		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 }
+			};
+		}
+		return {};
+	}, [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, config]) => {
+		if (!field || !config) return;
+		const isConfigObject = config && typeof config === "object" && !Array.isArray(config);
+		const operator = isConfigObject ? config?.operator : null;
+		const comparisonValue = isConfigObject ? config?.value : config;
+		const effectiveOperator = operator || "==";
+		const operands = effectiveOperator === "!" || effectiveOperator === "!!" ? [{ var: `currentDomainValue.${field}` }] : [{ var: `currentDomainValue.${field}` }, comparisonValue];
+		andConditions.push({ [effectiveOperator]: operands });
+	});
+	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);
+		};
+		if (isTransactionTypeStatusSidesheetOpen || isTransactionTypeConfigurationSidesheetOpen || isTransactionTypeTransactionActionSidesheetOpen) loadTTStatuses();
+	}, [
+		searchTransactionTypeStatusByTransactionTypeId,
+		isTransactionTypeStatusSidesheetOpen,
+		isTransactionTypeConfigurationSidesheetOpen,
+		isTransactionTypeTransactionActionSidesheetOpen
+	]);
+	/** 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);
+		};
+		if (isTransactionTypeConfigurationTransactionActionSidesheetOpen) loadTTTActions();
+	}, [searchTransactionTypeTransactionActionByTransactionTypeId, isTransactionTypeConfigurationTransactionActionSidesheetOpen]);
+	/** 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) => {
+			if (obj.apiCatalogId !== currentApiCatalogId) return false;
+			if (selectedDomainName || selectedTransactionType && !selectedDomainName) return obj.catalogObjectName === selectedDomainName;
+			return obj.catalogObjectName === selectedTransactionType?.domainName;
+		});
+		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);
+	}, []);
+	const handleTransactionTypeStatusSideSheet = useCallback((isOpen, transactionType) => {
+		setIsTransactionTypeStatusSidesheetOpen(isOpen);
+		setSelectedTransactionType(transactionType);
+	}, []);
+	const handleCreateOrEditTransactionTypeStatusSideSheet = useCallback((isOpen, transactionTypeStatus) => {
+		setIsCreateOrEditTransactionTypeStatusSidesheetOpen(isOpen);
+		setSelectedTransactionTypeStatus(transactionTypeStatus);
+	}, []);
+	const handleTransactionTypeTransactionActionSidesheet = useCallback((isOpen, transactionType) => {
+		setIsTransactionTypeTransactionActionSidesheetOpen(isOpen);
+		setSelectedTransactionType(transactionType);
+	}, []);
+	const handleCreateOrEditTransactionTypeTransactionActionSidesheet = useCallback((isOpen, transactionTypeTransactionAction) => {
+		setIsCreateOrEditTransactionTypeTransactionActionSidesheetOpen(isOpen);
+		setSelectedTransactionTypeTransactionAction(transactionTypeTransactionAction);
+	}, []);
+	const handleTransactionUiActionSidesheet = useCallback((isOpen, transactionType) => {
+		setIsTransactionUiActionSidesheetOpen(isOpen);
+		setSelectedTransactionType(transactionType);
+	}, []);
+	const handleCreateOrEditTransactionUiActionSidesheet = useCallback((isOpen, transactionUiAction) => {
+		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 { domainFields, ...restValues } = formValues;
+		const domainFieldsDictionary = (Array.isArray(domainFields) ? domainFields : []).reduce((accumulator, entry) => {
+			if (!entry) return accumulator;
+			const field = entry[0];
+			const displayName = entry[1]?.displayName || field;
+			const order = entry[1]?.order || 0;
+			if (field) accumulator[field] = {
+				displayName,
+				order
+			};
+			return accumulator;
+		}, {});
+		const newTransactionType = {
+			...restValues,
+			domainFields: domainFieldsDictionary
+		};
+		try {
+			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 { domainFields, ...restValues } = formValues;
+		const transactionTypeId = initialValues.transactionTypeId;
+		const domainFieldsDictionary = (Array.isArray(domainFields) ? domainFields : []).reduce((accumulator, entry) => {
+			if (!entry) return accumulator;
+			const field = entry[0];
+			const displayName = entry[1]?.displayName || field;
+			const order = entry[1]?.order || 0;
+			if (field) accumulator[field] = {
+				displayName,
+				order
+			};
+			return accumulator;
+		}, {});
+		const updatedTransactionType = {
+			...initialValues,
+			...formValues,
+			domainFields: domainFieldsDictionary
+		};
+		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,
+			color: formValues?.color?.value || null
+		};
+		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,
+			color: formValues?.color?.value || null
+		};
+		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"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionTypeTransactionActionSidesheet(false);
+			tttaGridApiRef.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,
+		tttaGridApiRef,
+		handleCreateOrEditTransactionTypeTransactionActionSidesheet,
+		successAction,
+		t,
+		selectedTransactionType
+	]);
+	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 || ""
+			}
+		};
+		try {
+			if ((await putUpdateTransactionTypeTransactionAction(transactionTypeTransactionActionId, updatedTransactionTypeTransactionAction)).status === 204) enqueueSnackbar(t("TransactionTypeTransactionAction updated successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionTypeTransactionActionSidesheet(false);
+			tttaGridApiRef.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,
+		tttaGridApiRef,
+		handleCreateOrEditTransactionTypeTransactionActionSidesheet,
+		successAction,
+		t,
+		selectedTransactionType
+	]);
+	const handleDeleteTransactionTypeTransactionAction = useCallback(async () => {
+		if (!selectedTransactionTypeTransactionAction) return;
+		const transactionTypeTransactionActionId = selectedTransactionTypeTransactionAction.transactionTypeTransactionActionId;
+		try {
+			if ((await deleteTransactionTypeTransactionAction(transactionTypeTransactionActionId)).status === 204) enqueueSnackbar(t("TransactionTypeTransactionAction deleted successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			setIsDeleteTransactionTypeTransactionActionDialogOpen(false);
+			tttaGridApiRef.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,
+		selectedTransactionTypeTransactionAction,
+		successAction,
+		t,
+		setIsDeleteTransactionTypeTransactionActionDialogOpen
+	]);
+	/** 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 || ""
+			}
+		};
+		try {
+			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"
+				}
+			});
+		}
+	}, [
+		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 || ""
+			}
+		};
+		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 = entry[0];
+			const value = entry[1].value;
+			const operator = entry[1]?.operator?.value;
+			if (field) accumulator[field] = {
+				value,
+				operator
+			};
+			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"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionTypeConfigurationSidesheet(false);
+			ttcGridApiRef.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,
+		ttcGridApiRef,
+		handleCreateOrEditTransactionTypeConfigurationSidesheet,
+		successAction,
+		t,
+		selectedTransactionType
+	]);
+	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 = entry[0];
+			const value = entry[1].value;
+			const operator = entry[1]?.operator?.value;
+			if (field) accumulator[field] = {
+				value,
+				operator
+			};
+			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,
+			name: name || "",
+			order: formValues?.order || 0,
+			enabled: formValues?.enabled,
+			transactionTypeConfigurationId,
+			transactionTypeId: selectedTransactionType?.transactionTypeId,
+			transactionRuleTypeId: transactionRuleType?.transactionRuleTypeId,
+			configuration: {
+				...configurationObj,
+				CurrentStatusId: currentStatus?.transactionTypeStatusId
+			},
+			expressionLogic
+		};
+		try {
+			if ((await putUpdateTransactionTypeConfiguration(transactionTypeConfigurationId, updatedTransactionTypeConfiguration)).status === 204) enqueueSnackbar(t("TransactionTypeConfiguration updated successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionTypeConfigurationSidesheet(false);
+			ttcGridApiRef.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,
+		ttcGridApiRef,
+		handleCreateOrEditTransactionTypeConfigurationSidesheet,
+		successAction,
+		t,
+		selectedTransactionType
+	]);
+	const handleDeleteTransactionTypeConfiguration = useCallback(async () => {
+		if (!selectedTransactionTypeConfiguration) return;
+		const transactionTypeConfigurationId = selectedTransactionTypeConfiguration.transactionTypeConfigurationId;
+		try {
+			if ((await deleteTransactionTypeConfiguration(transactionTypeConfigurationId)).status === 204) enqueueSnackbar(t("TransactionTypeConfiguration deleted successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			setIsDeleteTransactionTypeConfigurationDialogOpen(false);
+			ttcGridApiRef.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,
+		selectedTransactionTypeConfiguration,
+		successAction,
+		t,
+		setIsDeleteTransactionTypeConfigurationDialogOpen
+	]);
+	/** 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 postCreateTransactionTypeConfigurationTransactionAction(newTTCTActions))?.status === 201) enqueueSnackbar(t("TransactionTypeConfigurationTransactionAction(s) created successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionTypeConfigurationTransactionActionSidesheet(false);
+			ttctaGridApiRef.current?.refreshServerSide();
+			fetchTtctaList();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		ttctaGridApiRef,
+		handleCreateOrEditTransactionTypeConfigurationTransactionActionSidesheet,
+		successAction,
+		t,
+		selectedTransactionTypeConfiguration,
+		fetchTtctaList
+	]);
+	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 putUpdateTransactionTypeConfigurationTransactionAction(transactionTypeConfigurationId, existingTransactionTypeTransactionActionId, updatedTransactionTypeConfigurationTransactionAction)).status === 204) enqueueSnackbar(t("TransactionTypeConfigurationTransactionAction updated successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionTypeConfigurationTransactionActionSidesheet(false);
+			ttctaGridApiRef.current?.refreshServerSide();
+			fetchTtctaList();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		ttctaGridApiRef,
+		handleCreateOrEditTransactionTypeConfigurationTransactionActionSidesheet,
+		successAction,
+		t,
+		selectedTransactionTypeConfiguration,
+		fetchTtctaList
+	]);
+	const handleDeleteTransactionTypeConfigurationTransactionAction = useCallback(async () => {
+		if (!selectedTransactionTypeConfigurationTransactionAction) return;
+		const transactionTypeConfigurationId = selectedTransactionTypeConfigurationTransactionAction?.transactionTypeConfigurationId;
+		const transactionTypeTransactionActionId = selectedTransactionTypeConfigurationTransactionAction?.transactionTypeTransactionActionId;
+		try {
+			if ((await deleteTransactionTypeConfigurationTransactionAction(transactionTypeConfigurationId, transactionTypeTransactionActionId)).status === 204) enqueueSnackbar(t("TransactionTypeConfigurationTransactionAction deleted successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			setIsDeleteTransactionTypeConfigurationTransactionActionDialogOpen(false);
+			ttctaGridApiRef.current?.refreshServerSide();
+			fetchTtctaList();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		ttctaGridApiRef,
+		enqueueSnackbar,
+		selectedTransactionTypeConfigurationTransactionAction,
+		successAction,
+		t,
+		setIsDeleteTransactionTypeConfigurationTransactionActionDialogOpen,
+		fetchTtctaList
+	]);
+	/** end of TransactionTypeConfigurationTransactionAction */
+	/** TransactionAttachmentType */
+	const handleCreateTransactionAttachmentType = useCallback(async (formValues) => {
+		const newTransactionAttachmentType = {
+			...formValues,
+			transactionTypeId: selectedTransactionType?.transactionTypeId
+		};
+		try {
+			if ((await postCreateTransactionAttachmentType(newTransactionAttachmentType))?.status === 201) enqueueSnackbar(t("TransactionAttachmentType created successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionAttachmentTypeSidesheet(false);
+			tatGridApiRef.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,
+		tatGridApiRef,
+		successAction,
+		t,
+		selectedTransactionType,
+		handleCreateOrEditTransactionAttachmentTypeSidesheet
+	]);
+	const handleUpdateTransactionAttachmentType = useCallback(async (formValues, initialValues) => {
+		const transactionTypeId = selectedTransactionType?.transactionTypeId;
+		const transactionAttachmentTypeId = selectedTransactionAttachmentType?.transactionAttachmentTypeId;
+		const updatedTransactionType = {
+			...initialValues,
+			...formValues,
+			transactionTypeId,
+			transactionAttachmentTypeId
+		};
+		try {
+			if ((await putUpdateTransactionAttachmentType(transactionAttachmentTypeId, updatedTransactionType)).status === 204) enqueueSnackbar(t("TransactionAttachmentType updated successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionAttachmentTypeSidesheet(false);
+			tatGridApiRef.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,
+		selectedTransactionType,
+		successAction,
+		t
+	]);
+	const handleDeleteTransactionAttachmentType = useCallback(async () => {
+		if (!selectedTransactionAttachmentType) return;
+		const transactionAttachmentTypeId = selectedTransactionAttachmentType?.transactionAttachmentTypeId;
+		try {
+			if ((await deleteTransactionAttachmentType(transactionAttachmentTypeId)).status === 204) enqueueSnackbar(t("TransactionAttachmentType deleted successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			setIsDeleteTransactionAttachmentTypeDialogOpen(false);
+			tatGridApiRef.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,
+		selectedTransactionAttachmentType,
+		tatGridApiRef,
+		successAction,
+		t,
+		setIsDeleteTransactionAttachmentTypeDialogOpen
+	]);
+	/** end of TransactionAttachmentType */
+	const handleOpenDeleteTransactionTypeDialog = useCallback((transactionType) => {
+		setSelectedTransactionType(transactionType);
+		setIsDeleteTransactionTypeDialogOpen(true);
+	}, []);
+	const handleCloseDeleteTransactionTypeDialog = useCallback(() => {
+		setIsDeleteTransactionTypeDialogOpen(false);
+		setSelectedTransactionType(null);
+	}, []);
+	const handleOpenDeleteTransactionTypeStatusDialog = useCallback((transactionTypeStatus) => {
+		setSelectedTransactionTypeStatus(transactionTypeStatus);
+		setIsDeleteTransactionTypeStatusDialogOpen(true);
+	}, []);
+	const handleCloseDeleteTransactionTypeStatusDialog = useCallback(() => {
+		setIsDeleteTransactionTypeStatusDialogOpen(false);
+		setSelectedTransactionTypeStatus(null);
+	}, []);
+	const handleOpenDeleteTransactionTypeTransactionActionDialog = useCallback((transactionTypeTransactionAction) => {
+		setSelectedTransactionTypeTransactionAction(transactionTypeTransactionAction);
+		setIsDeleteTransactionTypeTransactionActionDialogOpen(true);
+	}, []);
+	const handleCloseDeleteTransactionTypeTransactionActionDialog = useCallback(() => {
+		setIsDeleteTransactionTypeTransactionActionDialogOpen(false);
+		setSelectedTransactionTypeTransactionAction(null);
+	}, []);
+	const handleOpenDeleteTransactionUiActionDialog = useCallback((transactionUiAction) => {
+		setSelectedTransactionUiAction(transactionUiAction);
+		setIsDeleteTransactionUiActionDialogOpen(true);
+	}, []);
+	const handleCloseDeleteTransactionUiActionDialog = useCallback(() => {
+		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,
+				hide: true
+			},
+			{
+				headerName: t("Name"),
+				field: "name",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Domain Name"),
+				field: "domainName",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Domain Fields"),
+				field: "domainFields",
+				resizable: true,
+				sortable: false,
+				hide: true
+			},
+			{
+				headerName: t("Allow Revisions"),
+				field: "hasRevision",
+				resizable: true,
+				sortable: false,
+				cellDataType: "boolean"
+			},
+			{
+				headerName: t("Revision Field"),
+				field: "revisionField",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Enabled"),
+				field: "enabled",
+				resizable: true,
+				sortable: false,
+				cellDataType: "boolean"
+			},
+			{
+				headerName: t("Archived on Cancel"),
+				field: "archiveOnCancel",
+				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("Sub-Type Value"),
+				field: "domainFieldValue",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Actions"),
+				field: "actions",
+				cellRenderer: "actionsRenderer",
+				cellRendererParams: { actionList: [
+					{
+						id: 0,
+						title: t("Edit"),
+						iconName: "edit",
+						handleOnClick: (e, transactionType) => {
+							handleSideSheet(true, transactionType?.data);
+						}
+					},
+					{
+						id: 1,
+						title: t("Delete"),
+						iconName: "trashCan",
+						handleOnClick: (e, transactionType) => {
+							handleOpenDeleteTransactionTypeDialog(transactionType?.data);
+						}
+					},
+					{
+						id: 2,
+						title: t("Manage Statuses"),
+						iconName: "settings",
+						handleOnClick: (e, transactionType) => {
+							handleTransactionTypeStatusSideSheet(true, transactionType?.data);
+						}
+					},
+					{
+						id: 3,
+						title: t("Manage Actions"),
+						iconName: "workorder",
+						handleOnClick: (e, transactionType) => {
+							handleTransactionTypeTransactionActionSidesheet(true, transactionType?.data);
+						}
+					},
+					{
+						id: 4,
+						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,
+				suppressMenu: true,
+				sortable: false,
+				filter: false
+			}
+		];
+	}, [
+		handleSideSheet,
+		handleOpenDeleteTransactionTypeDialog,
+		handleTransactionTypeStatusSideSheet,
+		handleTransactionTypeTransactionActionSidesheet,
+		handleTransactionUiActionSidesheet,
+		handleTransactionTypeConfigurationSidesheet,
+		handleTransactionAttachmentTypeSidesheet,
+		t
+	]);
+	const headerConfig = {
+		title: t("Transaction Types"),
+		primaryActionButton: {
+			label: t("Add"),
+			iconName: "add",
+			onClick: () => handleSideSheet(true)
+		}
+	};
+	const gridFunctions = [
+		{ name: "agGridExport" },
+		{ name: "agGridSizeColumnsToFit" },
+		{ name: "agGridAutoSizeColumns" },
+		{ name: "agGridResetColumns" },
+		{ name: "agGridHideShowColumns" }
+	];
+	const gridOptions = useMemo(() => {
+		return { pagination: true };
+	}, []);
+	const handleGridApiCallback = (api) => {
+		gridApiRef.current = api;
+	};
+	const searchMethodConfig = useMemo(() => {
+		return {
+			requestUrl: `${process.env.REACT_APP_PRODUCT_API_BASE}/UdpTransactionType/search`,
+			customSearchObject: searchObject
+		};
+	}, [searchObject]);
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, isTransactionTypeSidesheetLoading && /* @__PURE__ */ React.createElement(LinearProgress$1, {
+		className: classes.loadingBar,
+		color: "secondary"
+	}), /* @__PURE__ */ React.createElement(SearchMethodUdpGrid, {
+		searchMethodConfig,
+		columnDefs,
+		gridHeaderConfig: headerConfig,
+		gridOptions,
+		gridApiCallback: handleGridApiCallback,
+		gridFunctions
+	}), /* @__PURE__ */ React.createElement(UdpTransactionTypeSidesheet_default, {
+		key: selectedTransactionType?.transactionTypeId,
+		initialTransactionType: selectedTransactionType,
+		selectedDomainName,
+		isSideSheetOpen: isTransactionTypeSideSheetOpen,
+		handleSideSheet,
+		setSelectedDomainName,
+		handleCreateTransactionType,
+		handleUpdateTransactionType,
+		catalogObjects,
+		catalogObjectProperties
+	}), getTransactionsByTransactionIdLoading ? /* @__PURE__ */ React.createElement(LinearProgress$1, null) : /* @__PURE__ */ React.createElement(FluentDialog, {
+		open: isDeleteTransactionTypeDialogOpen,
+		onClose: handleCloseDeleteTransactionTypeDialog,
+		title: t("Confirm Delete"),
+		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, {
+		ref: ttsGridApiRef,
+		transactionType: selectedTransactionType,
+		transactionTypeStatus: selectedTransactionTypeStatus,
+		isSideSheetOpen: isTransactionTypeStatusSidesheetOpen,
+		isTransactionTypeStatusCreateOrEditSidesheetOpen: isCreateOrEditTransactionTypeStatusSidesheetOpen,
+		handleTransactionTypeStatusSideSheet,
+		handleCreateOrEditTransactionTypeStatusSideSheet,
+		handleCreateTransactionTypeStatus,
+		handleUpdateTransactionTypeStatus,
+		handleDeleteTransactionTypeStatus: handleOpenDeleteTransactionTypeStatusDialog
+	}), /* @__PURE__ */ React.createElement(FluentDialog, {
+		open: isDeleteTransactionTypeStatusDialogOpen,
+		onClose: handleCloseDeleteTransactionTypeStatusDialog,
+		title: t("Confirm Delete"),
+		message: t(`Are you sure you want to delete this status?`),
+		labelOne: t("Delete"),
+		actionOne: handleDeleteTransactionTypeStatus,
+		labelTwo: t("Cancel"),
+		actionTwo: handleCloseDeleteTransactionTypeStatusDialog
+	}), /* @__PURE__ */ React.createElement(UdpTransactionTypeTransactionActionSidesheet_default, {
+		ref: tttaGridApiRef,
+		transactionType: selectedTransactionType,
+		transactionTypeTransactionAction: selectedTransactionTypeTransactionAction,
+		isSideSheetOpen: isTransactionTypeTransactionActionSidesheetOpen,
+		isTransactionTypeTransactionActionCreateOrEditSidesheetOpen: isCreateOrEditTransactionTypeTransactionActionSidesheetOpen,
+		handleTransactionTypeTransactionActionSidesheet,
+		handleCreateOrEditTransactionTypeTransactionActionSidesheet,
+		handleCreateTransactionTypeTransactionAction,
+		handleUpdateTransactionTypeTransactionAction,
+		handleDeleteTransactionTypeTransactionAction: handleOpenDeleteTransactionTypeTransactionActionDialog,
+		transactionActions,
+		catalogObjectProperties,
+		actionApis,
+		pages,
+		ttstatuses
+	}), /* @__PURE__ */ React.createElement(FluentDialog, {
+		open: isDeleteTransactionTypeTransactionActionDialogOpen,
+		onClose: handleCloseDeleteTransactionTypeTransactionActionDialog,
+		title: t("Confirm Delete"),
+		message: t(`Are you sure you want to delete this action?`),
+		labelOne: t("Delete"),
+		actionOne: handleDeleteTransactionTypeTransactionAction,
+		labelTwo: t("Cancel"),
+		actionTwo: handleCloseDeleteTransactionTypeTransactionActionDialog
+	}), /* @__PURE__ */ React.createElement(UdpTransactionUiActionSidesheet_default, {
+		ref: tuaGridApiRef,
+		transactionType: selectedTransactionType,
+		transactionUiAction: selectedTransactionUiAction,
+		isSideSheetOpen: isTransactionUiActionSidesheetOpen,
+		handleTransactionUiActionSidesheet,
+		isCreateOrEditTransactionUiActionSidesheetOpen,
+		handleCreateOrEditTransactionUiActionSidesheet,
+		handleCreateTransactionUiAction,
+		handleUpdateTransactionUiAction,
+		handleDeleteTransactionUiAction: handleOpenDeleteTransactionUiActionDialog,
+		transactionUiActionTypes,
+		actionApis,
+		pages,
+		tUiActionsList
+	}), /* @__PURE__ */ React.createElement(FluentDialog, {
+		open: isDeleteTransactionUiActionDialogOpen,
+		onClose: handleCloseDeleteTransactionUiActionDialog,
+		title: t("Confirm Delete"),
+		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;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/index.ts
+var UdpTransactionTypesPage_exports = /* @__PURE__ */ __exportAll({ default: () => UdpTransactionTypesPage_default });
+
+//#endregion
+export { UdpTransactionTypesPage_default as n, UdpTransactionTypesPage_exports as t };
+//# sourceMappingURL=UdpTransactionTypesPage-Uk2cRhpd.js.map