udp-react-enterprise-component-library 25.18.3 → 25.18.4-beta.2

package/dist/UdpTransactionTypesPage-ntOhrBlV.js

@@ -1,3716 +0,0 @@
-import { t as __exportAll } from "./chunk-BYypO7fO.js";
-import { t as Form$1 } from "./Form-DbOA5j38.js";
-import { t as Field$1 } from "./Field-BSE8Fwr1.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-BcHMn9qn.js";
-import { V as UdpTransactionActionEnums, a as EMPTY_GUID } from "./unitySystemEnums-BhRg17du.js";
-import { n as getSuccessAction } from "./actionUtils-CrHVnhsb.js";
-import { t as useCatalogStore } from "./catalogStore-DP2GxpTJ.js";
-import { t as LayoutUnit } from "./LayoutUnit-D4jJvonh.js";
-import { n as SideSheet } from "./SideSheet-eEV_BlS7.js";
-import { t as useAxiosGet } from "./useAxiosGet-BSc3KA_u.js";
-import { t as FluentDialog } from "./FluentDialog-jQs3r2dc.js";
-import { t as useApiCatalog } from "./useApiCatalog-Bmu_e2h6.js";
-import { t as LinearProgress$1 } from "./LinearProgress-C6iEYnWR.js";
-import { t as FluentTextField } from "./FluentTextField-UqPEyyNn.js";
-import { t as AmbientAutoComplete } from "./AmbientAutoComplete-Do6EdcKH.js";
-import { t as SearchMethodUdpGrid } from "./SearchMethodUdpGrid-CglYOe5V.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, form }) => {
-			handleSubmitRef.current = handleSubmit;
-			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) => {
-			return t.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 }) => {
-			handleSubmitRef.current = handleSubmit;
-			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) => {
-						handleCreateOrEditTransactionTypeStatusSideSheet(true, transactionTypeStatus?.data);
-					}
-				}, {
-					id: 1,
-					title: t("Delete"),
-					iconName: "trashCan",
-					handleOnClick: (e, transactionTypeStatus) => {
-						handleDeleteTransactionTypeStatus(transactionTypeStatus?.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: `${ConfigService.productV1ApiUrl}/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, form }) => {
-			handleSubmitRef.current = handleSubmit;
-			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) => {
-						handleCreateOrEditTransactionTypeTransactionActionSidesheet(true, transactionTypeTransactionAction?.data);
-					}
-				}, {
-					id: 1,
-					title: t("Delete"),
-					iconName: "trashCan",
-					handleOnClick: (e, transactionTypeTransactionAction) => {
-						handleDeleteTransactionTypeTransactionAction(transactionTypeTransactionAction?.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: `${ConfigService.productV1ApiUrl}/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 }) => {
-			handleSubmitRef.current = handleSubmit;
-			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) => {
-						handleCreateOrEditTransactionUiActionSidesheet(true, transactionUiAction?.data);
-					}
-				}, {
-					id: 1,
-					title: t("Delete"),
-					iconName: "trashCan",
-					handleOnClick: (e, transactionUiAction) => {
-						handleDeleteTransactionUiAction(transactionUiAction?.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: `${ConfigService.productV1ApiUrl}/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, form }) => {
-			handleSubmitRef.current = handleSubmit;
-			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 }) => {
-			handleSubmitRef.current = handleSubmit;
-			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) => {
-						handleDeleteTransactionTypeConfigurationTransactionAction(transactionTypeConfigurationTransactionAction?.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: `${ConfigService.productV1ApiUrl}/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) => {
-							handleCreateOrEditTransactionTypeConfigurationSidesheet(true, transactionTypeConfiguration?.data);
-						}
-					},
-					{
-						id: 1,
-						title: t("Delete"),
-						iconName: "trashCan",
-						handleOnClick: (e, transactionTypeConfiguration) => {
-							handleDeleteTransactionTypeConfiguration(transactionTypeConfiguration?.data);
-						}
-					},
-					{
-						id: 2,
-						title: t("Link"),
-						iconName: "link",
-						handleOnClick: (e, transactionTypeConfiguration) => {
-							handleTransactionTypeConfigurationTransactionActionSidesheet(true, transactionTypeConfiguration?.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: `${ConfigService.productV1ApiUrl}/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 }) => {
-			handleSubmitRef.current = handleSubmit;
-			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) => {
-						handleCreateOrEditTransactionAttachmentTypeSidesheet(true, transactionAttachmentType?.data);
-					}
-				}, {
-					id: 1,
-					title: t("Delete"),
-					iconName: "trashCan",
-					handleOnClick: (e, transactionAttachmentType) => {
-						handleDeleteTransactionAttachmentType(transactionAttachmentType?.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: `${ConfigService.productV1ApiUrl}/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(ConfigService.productV1ApiUrl, `UdpTransactionType`, { method: "POST" }, { data: transactionType });
-	};
-	const putUpdateTransactionType = async (transactionTypeId, transactionType) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionType/${transactionTypeId}`, { method: "PUT" }, { data: transactionType });
-	};
-	const deleteTransactionType = async (transactionTypeId) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionType/${transactionTypeId}`, { method: "DELETE" });
-	};
-	const [{ data: transactionsByTransactionTypeId, loading: getTransactionsByTransactionIdLoading }, fetchTransactionsByTransactionTypeId] = useAxiosGet(ConfigService.productV1ApiUrl, `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(ConfigService.productV1ApiUrl, `UdpTransactionTypeStatus`, { method: "POST" }, { data: transactionTypeStatus });
-	};
-	const putUpdateTransactionTypeStatus = async (transactionTypeStatusId, transactionTypeStatus) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionTypeStatus/${transactionTypeStatusId}`, { method: "PUT" }, { data: transactionTypeStatus });
-	};
-	const deleteTransactionTypeStatus = async (transactionTypeStatusId) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionTypeStatus/${transactionTypeStatusId}`, { method: "DELETE" });
-	};
-	const searchTransactionTypeStatusByTransactionTypeId = useCallback(async (transactionTypeId) => {
-		const searchPayload = {
-			filterElements: [{
-				searchField: "TransactionTypeId",
-				searchOperator: "=",
-				searchValue: transactionTypeId,
-				groupId: 1
-			}],
-			getAll: true
-		};
-		return await apiMutate(ConfigService.productV1ApiUrl, `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(ConfigService.productV1ApiUrl, `UdpTransactionAction`, { method: "GET" }, false, false);
-	/** ActionApis */
-	const [{ data: actionApis }] = useAxiosGet(ConfigService.productV1ApiUrl, `UdpTransactionWorkflowActionApi`, { method: "GET" }, false, false);
-	/** PageIds */
-	const [{ data: pages }] = useAxiosGet(ConfigService.tenantV1ApiUrl, `Page?tenantId=${user?.currentTenantId}`, { method: "GET" }, !!!user?.currentTenantId, false);
-	/** TransactionTypeTransactionAction */
-	const postCreateTransactionTypeTransactionAction = async (transactionTypeTransactionAction) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionTypeTransactionAction`, { method: "POST" }, { data: transactionTypeTransactionAction });
-	};
-	const putUpdateTransactionTypeTransactionAction = async (transactionTypeTransactionActionId, transactionTypeTransactionAction) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionTypeTransactionAction/${transactionTypeTransactionActionId}`, { method: "PUT" }, { data: transactionTypeTransactionAction });
-	};
-	const deleteTransactionTypeTransactionAction = async (transactionTypeTransactionActionId) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionTypeTransactionAction/${transactionTypeTransactionActionId}`, { method: "DELETE" });
-	};
-	const searchTransactionTypeTransactionActionByTransactionTypeId = useCallback(async (transactionTypeId) => {
-		const searchPayload = {
-			filterElements: [{
-				searchField: "TransactionTypeId",
-				searchOperator: "=",
-				searchValue: transactionTypeId,
-				groupId: 1
-			}],
-			getAll: true
-		};
-		return await apiMutate(ConfigService.productV1ApiUrl, `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(ConfigService.productV1ApiUrl, `UdpTransactionUiAction`, { method: "POST" }, { data: transactionUiAction });
-	};
-	const putUpdateTransactionUiAction = async (transactionUiActionId, transactionUiAction) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionUiAction/${transactionUiActionId}`, { method: "PUT" }, { data: transactionUiAction });
-	};
-	const deleteTransactionUiAction = async (transactionUiActionId) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionUiAction/${transactionUiActionId}`, { method: "DELETE" });
-	};
-	const [{ data: tUiActionsList }, fetchTUiActionsList] = useAxiosGet(ConfigService.productV1ApiUrl, `UdpTransactionUiAction/search`, {
-		method: "post",
-		data: {
-			filterElements: [{
-				searchField: "TransactionTypeId",
-				searchOperator: "=",
-				searchValue: selectedTransactionType?.transactionTypeId,
-				groupId: 1
-			}],
-			getAll: true
-		}
-	}, !!!isTransactionUiActionSidesheetOpen, false);
-	/** TransactionUiActionType */
-	const [{ data: transactionUiActionTypes }] = useAxiosGet(ConfigService.productV1ApiUrl, `UdpTransactionUiActionType`, { method: "GET" }, false, false);
-	/** TransactionTypeConfiguration */
-	const postCreateTransactionTypeConfiguration = async (transactionTypeConfiguration) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionTypeConfiguration`, { method: "POST" }, { data: transactionTypeConfiguration });
-	};
-	const putUpdateTransactionTypeConfiguration = async (transactionTypeConfigurationId, transactionTypeConfiguration) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionTypeConfiguration/${transactionTypeConfigurationId}`, { method: "PUT" }, { data: transactionTypeConfiguration });
-	};
-	const deleteTransactionTypeConfiguration = async (transactionTypeConfigurationId) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionTypeConfiguration/${transactionTypeConfigurationId}`, { method: "DELETE" });
-	};
-	/** TransactionRuleType */
-	const [{ data: transactionRuleTypes }] = useAxiosGet(ConfigService.productV1ApiUrl, `UdpTransactionRuleType`, { method: "GET" }, false, false);
-	/** Roles */
-	const [{ data: roles }] = useAxiosGet(ConfigService.tenantV1ApiUrl, `Roles?tenantId=${user?.currentTenantId}`, { method: "GET" }, !!!user?.currentTenantId, false);
-	/** TransactionTypeConfigurationTransactionAction */
-	const postCreateTransactionTypeConfigurationTransactionAction = async (ttcta) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionTypeConfigurationTransactionAction/createBulk`, { method: "POST" }, { data: ttcta });
-	};
-	const putUpdateTransactionTypeConfigurationTransactionAction = async (transactionTypeConfigurationId, transactionTypeTransactionActionId, transactionTypeConfigurationTransactionAction) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionTypeConfigurationTransactionAction/${transactionTypeConfigurationId}/${transactionTypeTransactionActionId}`, { method: "PUT" }, { data: transactionTypeConfigurationTransactionAction });
-	};
-	const deleteTransactionTypeConfigurationTransactionAction = async (transactionTypeConfigurationId, transactionTypeTransactionActionId) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionTypeConfigurationTransactionAction/${transactionTypeConfigurationId}/${transactionTypeTransactionActionId}`, { method: "DELETE" });
-	};
-	const [{ data: ttctaList }, fetchTtctaList] = useAxiosGet(ConfigService.productV1ApiUrl, `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(ConfigService.productV1ApiUrl, `UdpTransactionAttachmentType`, { method: "POST" }, { data: transactionAttachmentType });
-	};
-	const putUpdateTransactionAttachmentType = async (transactionAttachmentTypeId, transactionAttachmentType) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `UdpTransactionAttachmentType/${transactionAttachmentTypeId}`, { method: "PUT" }, { data: transactionAttachmentType });
-	};
-	const deleteTransactionAttachmentType = async (transactionAttachmentTypeId) => {
-		return await apiMutate(ConfigService.productV1ApiUrl, `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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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
-			});
-			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: `${ConfigService.productV1ApiUrl}/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-ntOhrBlV.js.map