udp-react-enterprise-component-library 25.18.1-beta.3 → 25.18.1-beta.30

package/dist/UdpTransactionTypesPage-fo1YR5Cw.js

@@ -0,0 +1,1979 @@
+import { t as __export } from "./chunk-B4enJp2Q.js";
+import { t as Form$1 } from "./Form-DbOA5j38.js";
+import { t as Field$1 } from "./Field-Cda5rJe2.js";
+import { t as arrayMutators } from "./form-Dj1zVw6K.js";
+import { t as FluentButton } from "./FluentButton-BexKrnAp.js";
+import { t as useUser } from "./useUser-wpHGo6jU.js";
+import { t as apiMutate } from "./useAxiosMutate-DcLxzykX.js";
+import { R as UdpTransactionActionEnums } from "./unitySystemEnums-DtVX3A-I.js";
+import { n as getSuccessAction } from "./actionUtils-BEMs2nQ4.js";
+import { t as useCatalogStore } from "./catalogStore-DP2GxpTJ.js";
+import { n as SideSheet } from "./SideSheet-C-rILQqR.js";
+import { t as useAxiosGet } from "./useAxiosGet-vvPjwB4W.js";
+import { t as FluentDialog } from "./FluentDialog-B5ZxvX1E.js";
+import { t as useApiCatalog } from "./useApiCatalog-Yi_KDPot.js";
+import { t as LinearProgress$1 } from "./LinearProgress-DM2DNWCe.js";
+import { t as FluentTextField } from "./FluentTextField-CXvZawOG.js";
+import { t as SearchMethodUdpGrid } from "./SearchMethodUdpGrid-QU4FZ0Gk.js";
+import { t as AmbientAutoComplete } from "./AmbientAutoComplete-PIhfakyF.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 UdpTransactionTypeForm = (props, ref) => {
+	const { onSubmit, initialData, domainNameOptions, onSelectDomainName, domainFieldOptions } = props;
+	const handleSubmitRef = useRef();
+	const { t } = useTranslation();
+	useImperativeHandle(ref, () => ({ submit: () => {
+		handleSubmitRef?.current();
+	} }));
+	const handleSubmit = useCallback((formData) => {
+		onSubmit(formData, initialData);
+	}, [initialData, onSubmit]);
+	return /* @__PURE__ */ React.createElement(Form$1, {
+		onSubmit: handleSubmit,
+		render: ({ handleSubmit: handleSubmit$1, form }) => {
+			handleSubmitRef.current = handleSubmit$1;
+			const handleDomainNameChange = (value) => {
+				const nextDomainName = value || "";
+				if ((form.getState().values?.domainName || "") !== nextDomainName) {
+					onSelectDomainName?.(nextDomainName);
+					form.change("domainFields", []);
+				}
+			};
+			const hasRevision = !!form.getState().values?.hasRevision;
+			const hasDomainTypeField = !!form.getState().values?.domainTypeField;
+			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,
+				initialValue: initialData?.name || ""
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("Domain Name"),
+				id: "domainName",
+				name: "domainName",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				initialValue: initialData?.domainName,
+				options: domainNameOptions || [],
+				getOptionLabelFunction: (option) => option,
+				additionalOnChangeAction: handleDomainNameChange
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: "Domain Fields",
+				id: "domainFields",
+				name: "domainFields",
+				variant: "outlined",
+				isMultiple: true,
+				disableCloseOnSelect: true,
+				initialValue: initialData?.domainFields,
+				options: domainFieldOptions || [],
+				getOptionLabelFunction: (option) => option
+			}), /* @__PURE__ */ React.createElement(FormControlLabel, {
+				control: /* @__PURE__ */ React.createElement(Field$1, {
+					component: Switch,
+					id: "hasRevision",
+					name: "hasRevision",
+					type: "checkbox",
+					initialValue: !!initialData?.hasRevision,
+					parse: parseHasRevision
+				}),
+				label: t("Has Revision?")
+			}), hasRevision && /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: "Revision Field",
+				id: "revisionField",
+				name: "revisionField",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				initialValue: initialData?.revisionField,
+				options: domainFieldOptions || [],
+				getOptionLabelFunction: (option) => option
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: "Domain Type Field",
+				id: "domainTypeField",
+				name: "domainTypeField",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				initialValue: initialData?.domainTypeField,
+				options: domainFieldOptions || [],
+				getOptionLabelFunction: (option) => option
+			}), hasDomainTypeField && /* @__PURE__ */ React.createElement(Field$1, {
+				component: FluentTextField,
+				label: t("Domain Type Value"),
+				id: "domainTypeValue",
+				name: "domainTypeValue",
+				fullWidth: true,
+				variant: "outlined",
+				margin: "normal",
+				size: "small",
+				initialValue: initialData?.domainTypeValue || ""
+			}));
+		}
+	});
+};
+var UdpTransactionTypeForm_default = forwardRef(UdpTransactionTypeForm);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/sidesheets/UdpTransactionTypeSidesheet.jsx
+const UdpTransactionTypeSidesheet = (props) => {
+	const { initialTransactionType, isSideSheetOpen, handleSideSheet, setSelectedDomainName, handleCreateTransactionType, handleUpdateTransactionType, catalogObjects, catalogObjectProperties } = props;
+	const isEditing = !!initialTransactionType;
+	const formRef = useRef();
+	const { t } = useTranslation();
+	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]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 500,
+		title: isEditing ? t("Edit Transaction Type") : t("Create Transaction Type"),
+		onClose: () => handleCloseSidesheet(false),
+		buttonLabel: isEditing ? t("Save") : t("Create"),
+		onSubmit: () => {
+			formRef?.current?.submit();
+		}
+	}, /* @__PURE__ */ React.createElement(UdpTransactionTypeForm_default, {
+		ref: formRef,
+		onSubmit: onSubmitForm,
+		initialData: initialTransactionType,
+		domainNameOptions: catalogObjectNames,
+		onSelectDomainName: setSelectedDomainName,
+		domainFieldOptions: catalogObjectProperties
+	}));
+};
+var UdpTransactionTypeSidesheet_default = UdpTransactionTypeSidesheet;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/forms/UdpTransactionTypeStatusForm.jsx
+const UdpTransactionTypeStatusForm = (props, ref) => {
+	const { onSubmit, initialData } = props;
+	const handleSubmitRef = useRef();
+	const { t } = useTranslation();
+	useImperativeHandle(ref, () => ({ submit: () => {
+		handleSubmitRef?.current();
+	} }));
+	const handleSubmit = useCallback((formData) => {
+		onSubmit(formData, initialData);
+	}, [initialData, onSubmit]);
+	return /* @__PURE__ */ React.createElement(Form$1, {
+		onSubmit: handleSubmit,
+		render: ({ handleSubmit: handleSubmit$1 }) => {
+			handleSubmitRef.current = handleSubmit$1;
+			return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Field$1, {
+				component: FluentTextField,
+				label: t("Name"),
+				id: "name",
+				name: "name",
+				fullWidth: true,
+				variant: "outlined",
+				margin: "normal",
+				size: "small",
+				required: true,
+				initialValue: initialData?.name || ""
+			}), /* @__PURE__ */ React.createElement(FormControlLabel, {
+				control: /* @__PURE__ */ React.createElement(Field$1, {
+					component: Switch,
+					id: "isDefault",
+					name: "isDefault",
+					type: "checkbox",
+					initialValue: !!initialData?.isDefault
+				}),
+				label: t("Default?")
+			}), /* @__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?")
+			}));
+		}
+	});
+};
+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 Transaction Type Status") : t("Create Transaction Type 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 columnDefs = useMemo(() => {
+		return [
+			{
+				headerName: t("Name"),
+				field: "name",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Default"),
+				field: "isDefault",
+				resizable: false,
+				sortable: false,
+				cellDataType: "boolean"
+			},
+			{
+				headerName: t("Is Closed Status"),
+				field: "isClosedStatus",
+				resizable: false,
+				sortable: false,
+				cellDataType: "boolean"
+			},
+			{
+				headerName: t("Actions"),
+				field: "actions",
+				cellRenderer: "actionsRenderer",
+				cellRendererParams: { actionList: [{
+					id: 0,
+					title: t("Edit"),
+					iconName: "edit",
+					handleOnClick: (e, transactionTypeStatus$1) => {
+						handleCreateOrEditTransactionTypeStatusSideSheet(true, transactionTypeStatus$1?.data);
+					}
+				}, {
+					id: 1,
+					title: t("Delete"),
+					iconName: "trashCan",
+					handleOnClick: (e, transactionTypeStatus$1) => {
+						handleDeleteTransactionTypeStatus(transactionTypeStatus$1?.data);
+					}
+				}] },
+				suppressMenu: true,
+				sortable: false,
+				filter: false,
+				valueGetter: (params) => params.data
+			}
+		];
+	}, [
+		t,
+		handleCreateOrEditTransactionTypeStatusSideSheet,
+		handleDeleteTransactionTypeStatus
+	]);
+	const headerConfig = {
+		title: t("Statuses"),
+		primaryActionButton: {
+			label: t("Add"),
+			iconName: "add",
+			onClick: () => handleCreateOrEditTransactionTypeStatusSideSheet(true)
+		}
+	};
+	const gridFunctions = [
+		{ name: "agGridExport" },
+		{ name: "agGridSizeColumnsToFit" },
+		{ name: "agGridAutoSizeColumns" },
+		{ name: "agGridResetColumns" },
+		{ name: "agGridHideShowColumns" }
+	];
+	const gridOptions = useMemo(() => {
+		return { pagination: true };
+	}, []);
+	const handleGridApiCallback = (api) => {
+		transactionTypeStatusGridApiRef.current = api;
+	};
+	const searchMethodConfig = useMemo(() => {
+		let filterElements = [];
+		if (transactionType?.transactionTypeId) filterElements = [{
+			searchField: "TransactionTypeId",
+			searchOperator: "=",
+			searchValue: transactionType?.transactionTypeId,
+			groupId: 1
+		}];
+		return {
+			requestUrl: `${process.env.REACT_APP_PRODUCT_API_BASE}/UdpTransactionTypeStatus/search`,
+			customSearchObject: { filterElements }
+		};
+	}, [transactionType]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 800,
+		title: t("Transaction Type 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$1 = makeStyles((theme) => ({
+	domainFields: {
+		display: "flex",
+		flexDirection: "row",
+		alignItems: "flex-end",
+		justifyContent: "flex-start",
+		"& > *": { marginRight: theme.spacing(2) }
+	},
+	addRemoveButtons: {
+		display: "flex",
+		flexDirection: "row",
+		alignItems: "center",
+		justifyContent: "flex-start",
+		margin: `${theme.spacing(2)}px  0  0 ${-theme.spacing(2)}px`,
+		"& > *": { margin: `0 ${theme.spacing(2)}px` }
+	},
+	removeIcon: {
+		fontSize: theme.spacing(3.5),
+		marginTop: theme.spacing(1)
+	},
+	noRemoveIcon: { marginLeft: theme.spacing(3.5) }
+}));
+const UdpTransactionTypeTransactionActionFormFields = (props) => {
+	const { transactionActionOptions, catalogObjectProperties, actionApiOptions, pageOptions, transactionTypeStatusOptions, showMandatoryFields, showHiddenFields, showToStatusField, showActionApiField, showPageField, showDomainDataToUpdateFields, pushToFieldArray } = props;
+	const { t } = useTranslation();
+	const classes = useStyles$1();
+	const form = useForm();
+	const { values } = useFormState();
+	useEffect(() => {
+		if (!showMandatoryFields) form.change("mandatoryFields", []);
+		if (!showHiddenFields) form.change("hiddenFields", []);
+		if (!showToStatusField) form.change("toStatus", null);
+		if (!showActionApiField) form.change("actionApiId", null);
+		if (!showPageField) form.change("pageId", []);
+		if (!showDomainDataToUpdateFields) form.change("domainDataToUpdate", [[]]);
+	}, [
+		form,
+		showMandatoryFields,
+		showHiddenFields,
+		showToStatusField,
+		showActionApiField,
+		showPageField,
+		showDomainDataToUpdateFields,
+		values.transactionAction
+	]);
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Field$1, {
+		component: FluentTextField,
+		label: t("Name"),
+		id: "name",
+		name: "name",
+		fullWidth: true,
+		variant: "outlined",
+		margin: "normal",
+		size: "small",
+		required: true
+	}), /* @__PURE__ */ React.createElement(Field$1, {
+		component: FluentTextField,
+		label: t("Description"),
+		id: "description",
+		name: "description",
+		fullWidth: true,
+		variant: "outlined",
+		margin: "normal",
+		size: "small"
+	}), /* @__PURE__ */ React.createElement(Field$1, {
+		component: FluentTextField,
+		label: t("Icon"),
+		id: "icon",
+		name: "icon",
+		fullWidth: true,
+		variant: "outlined",
+		margin: "normal",
+		size: "small"
+	}), /* @__PURE__ */ React.createElement(Field$1, {
+		component: AmbientAutoComplete,
+		label: t("Transaction Action"),
+		id: "transactionAction",
+		name: "transactionAction",
+		variant: "outlined",
+		isMultiple: false,
+		disableCloseOnSelect: false,
+		options: transactionActionOptions || [],
+		getOptionLabelFunction: (option) => option.name,
+		valueForChange: (value) => {
+			return value;
+		},
+		required: true
+	}), showToStatusField && /* @__PURE__ */ React.createElement(Field$1, {
+		component: AmbientAutoComplete,
+		label: t("To Status"),
+		id: "toStatus",
+		name: "toStatus",
+		variant: "outlined",
+		isMultiple: false,
+		disableCloseOnSelect: false,
+		options: transactionTypeStatusOptions || [],
+		getOptionLabelFunction: (option) => option.name
+	}), showMandatoryFields && /* @__PURE__ */ React.createElement(Field$1, {
+		component: AmbientAutoComplete,
+		label: t("Mandatory Fields"),
+		id: "mandatoryFields",
+		name: "mandatoryFields",
+		variant: "outlined",
+		isMultiple: true,
+		disableCloseOnSelect: true,
+		options: catalogObjectProperties || [],
+		getOptionLabelFunction: (option) => option
+	}), showHiddenFields && /* @__PURE__ */ React.createElement(Field$1, {
+		component: AmbientAutoComplete,
+		label: t("Hidden Fields"),
+		id: "hiddenFields",
+		name: "hiddenFields",
+		variant: "outlined",
+		isMultiple: true,
+		disableCloseOnSelect: true,
+		options: catalogObjectProperties || [],
+		getOptionLabelFunction: (option) => option
+	}), showActionApiField && /* @__PURE__ */ React.createElement(Field$1, {
+		component: AmbientAutoComplete,
+		label: t("Action Api"),
+		id: "actionApiId",
+		name: "actionApiId",
+		variant: "outlined",
+		isMultiple: false,
+		disableCloseOnSelect: false,
+		options: actionApiOptions || [],
+		getOptionLabelFunction: (option) => option.name
+	}), showPageField && /* @__PURE__ */ React.createElement(Field$1, {
+		component: AmbientAutoComplete,
+		label: t("Page"),
+		id: "pageId",
+		name: "pageId",
+		variant: "outlined",
+		isMultiple: false,
+		disableCloseOnSelect: false,
+		options: pageOptions || [],
+		getOptionLabelFunction: (option) => option.name
+	}), showDomainDataToUpdateFields && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("div", { className: classes.addRemoveButtons }, /* @__PURE__ */ React.createElement(FluentButton, {
+		variant: "contained",
+		color: "primary",
+		onClick: () => pushToFieldArray("domainDataToUpdate", void 0)
+	}, t("Add a Domain Field"))), /* @__PURE__ */ React.createElement(FieldArray, { name: "domainDataToUpdate" }, ({ fields }) => fields.map((name, index) => /* @__PURE__ */ React.createElement("div", {
+		key: `${name}${index}`,
+		className: classes.domainFields
+	}, /* @__PURE__ */ React.createElement(Field$1, {
+		component: AmbientAutoComplete,
+		label: index === 0 && t("Field"),
+		name: `${name}[0]`,
+		variant: "outlined",
+		isMultiple: false,
+		disableCloseOnSelect: false,
+		options: catalogObjectProperties || [],
+		getOptionLabelFunction: (option) => option,
+		onChange: () => {}
+	}), /* @__PURE__ */ React.createElement(Field$1, {
+		component: FluentTextField,
+		label: index === 0 && t("Value"),
+		name: `${name}[1]`,
+		fullWidth: true,
+		variant: "outlined",
+		margin: "normal",
+		size: "small",
+		onChange: () => {}
+	}), /* @__PURE__ */ React.createElement("span", {
+		onClick: () => fields.remove(index),
+		style: { cursor: "pointer" },
+		className: classes.removeIcon
+	}, /* @__PURE__ */ React.createElement(StatusCircleErrorXIcon, null)))))));
+};
+var UdpTransactionTypeTransactionActionFormFields_default = UdpTransactionTypeTransactionActionFormFields;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/forms/UdpTransactionTypeTransactionActionForm.jsx
+const baseActionsList = [
+	UdpTransactionActionEnums.Send_Email,
+	UdpTransactionActionEnums.Create_Reminder,
+	UdpTransactionActionEnums.Custom_Client_Action
+];
+const UdpTransactionTypeTransactionActionForm = (props, ref) => {
+	const { onSubmit, initialData, transactionActionOptions, catalogObjectProperties, actionApiOptions, pageOptions, transactionTypeStatusOptions } = props;
+	const handleSubmitRef = useRef();
+	const formInitialValues = useMemo(() => {
+		let formattedData;
+		if (!initialData) return;
+		formattedData = {
+			...initialData,
+			transactionAction: transactionActionOptions?.find((transactionAction) => transactionAction?.transactionActionId === initialData?.transactionActionId),
+			toStatus: transactionTypeStatusOptions?.find((tts) => tts?.transactionTypeStatusId === initialData?.parameters?.toStatus),
+			mandatoryFields: initialData?.parameters?.mandatoryFields,
+			hiddenFields: initialData?.parameters?.hiddenFields,
+			actionApiId: actionApiOptions?.find((actionApi) => actionApi?.actionApiId === initialData?.parameters?.actionApiId),
+			pageId: pageOptions?.find((page) => page?.pageId === initialData?.parameters?.pageId),
+			domainDataToUpdate: initialData?.parameters?.domainDataToUpdate ? Object.entries(initialData?.parameters?.domainDataToUpdate) : [[]]
+		};
+		return formattedData;
+	}, [
+		initialData,
+		transactionActionOptions,
+		transactionTypeStatusOptions,
+		actionApiOptions,
+		pageOptions
+	]);
+	useImperativeHandle(ref, () => ({ submit: () => {
+		handleSubmitRef?.current();
+	} }));
+	const handleSubmit = useCallback((formData) => {
+		onSubmit(formData, initialData);
+	}, [initialData, onSubmit]);
+	return /* @__PURE__ */ React.createElement(Form$1, {
+		onSubmit: handleSubmit,
+		mutators: { ...arrayMutators },
+		initialValues: { ...formInitialValues },
+		render: ({ handleSubmit: handleSubmit$1, form }) => {
+			handleSubmitRef.current = handleSubmit$1;
+			const push = form?.mutators?.push ?? (() => {});
+			const transactionActionName = form?.getState()?.values?.transactionAction?.name;
+			const showMandatoryFields = transactionActionName === UdpTransactionActionEnums.Set_Mandatory_Fields;
+			const showHiddenFields = transactionActionName === UdpTransactionActionEnums.Set_Fields_Hidden;
+			const showToStatusField = [...baseActionsList, UdpTransactionActionEnums.Update_Status].includes(transactionActionName);
+			const showActionApiField = [...baseActionsList, UdpTransactionActionEnums.Execute_Api].includes(transactionActionName);
+			const showPageField = [...baseActionsList, UdpTransactionActionEnums.Execute_Api].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 Transaction Type Transaction Action") : t("Create Transaction Type Transaction 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, searchTransactionTypeStatusByTransactionTypeId } = props;
+	const transactionTypeTransactionActionGridApiRef = useRef(null);
+	const { t } = useTranslation();
+	const [ttstatuses, setTTStatuses] = useState([]);
+	useEffect(() => {
+		if (!transactionType?.transactionTypeId) return;
+		const loadTTStatuses = async () => {
+			const ttsResponse = await searchTransactionTypeStatusByTransactionTypeId(transactionType?.transactionTypeId);
+			if (ttsResponse?.status === 200) setTTStatuses(ttsResponse.data?.pageList);
+		};
+		loadTTStatuses();
+	}, [searchTransactionTypeStatusByTransactionTypeId, transactionType?.transactionTypeId]);
+	useImperativeHandle(ref, () => ({ refreshServerSide: () => {
+		transactionTypeTransactionActionGridApiRef?.current?.refreshServerSide();
+	} }));
+	const getTransactionActionName = useCallback((transactionActionId) => {
+		if (!transactionActions) return "";
+		return transactionActions.find((transactionAction) => transactionAction.transactionActionId === transactionActionId)?.name || "";
+	}, [transactionActions]);
+	const columnDefs = useMemo(() => {
+		return [
+			{
+				headerName: t("Name"),
+				field: "name",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Description"),
+				field: "description",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Icon"),
+				field: "icon",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Transaction Action"),
+				resizable: true,
+				sortable: false,
+				valueGetter: (params) => getTransactionActionName(params.data.transactionActionId)
+			},
+			{
+				headerName: t("Actions"),
+				field: "actions",
+				cellRenderer: "actionsRenderer",
+				cellRendererParams: { actionList: [{
+					id: 0,
+					title: t("Edit"),
+					iconName: "edit",
+					handleOnClick: (e, transactionTypeTransactionAction$1) => {
+						handleCreateOrEditTransactionTypeTransactionActionSidesheet(true, transactionTypeTransactionAction$1?.data);
+					}
+				}, {
+					id: 1,
+					title: t("Delete"),
+					iconName: "trashCan",
+					handleOnClick: (e, transactionTypeTransactionAction$1) => {
+						handleDeleteTransactionTypeTransactionAction(transactionTypeTransactionAction$1?.data);
+					}
+				}] },
+				suppressMenu: true,
+				sortable: false,
+				filter: false,
+				valueGetter: (params) => params.data
+			}
+		];
+	}, [
+		t,
+		handleCreateOrEditTransactionTypeTransactionActionSidesheet,
+		handleDeleteTransactionTypeTransactionAction,
+		getTransactionActionName
+	]);
+	const headerConfig = {
+		title: t("Actions"),
+		primaryActionButton: {
+			label: t("Add"),
+			iconName: "add",
+			onClick: () => handleCreateOrEditTransactionTypeTransactionActionSidesheet(true)
+		}
+	};
+	const gridFunctions = [
+		{ name: "agGridExport" },
+		{ name: "agGridSizeColumnsToFit" },
+		{ name: "agGridAutoSizeColumns" },
+		{ name: "agGridResetColumns" },
+		{ name: "agGridHideShowColumns" }
+	];
+	const gridOptions = useMemo(() => {
+		return { pagination: true };
+	}, []);
+	const handleGridApiCallback = (api) => {
+		transactionTypeTransactionActionGridApiRef.current = api;
+	};
+	const searchMethodConfig = useMemo(() => {
+		let filterElements = [];
+		if (transactionType?.transactionTypeId) filterElements = [{
+			searchField: "TransactionTypeId",
+			searchOperator: "=",
+			searchValue: transactionType?.transactionTypeId,
+			groupId: 1
+		}];
+		return {
+			requestUrl: `${process.env.REACT_APP_PRODUCT_API_BASE}/UdpTransactionTypeTransactionAction/search`,
+			customSearchObject: { filterElements }
+		};
+	}, [transactionType]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 800,
+		title: t("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,
+		catalogObjectProperties,
+		actionApis,
+		pages,
+		transactionTypeStatusOptions: ttstatuses
+	}));
+};
+var UdpTransactionTypeTransactionActionSidesheet_default = forwardRef(UdpTransactionTypeTransactionActionSidesheet);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/forms/UdpTransactionUiActionForm.jsx
+const UdpTransactionUiActionForm = (props, ref) => {
+	const { onSubmit, initialData, transactionUiActionTypeOptions, actionApiOptions, pageOptions } = props;
+	const { t } = useTranslation();
+	const handleSubmitRef = useRef();
+	useImperativeHandle(ref, () => ({ submit: () => {
+		handleSubmitRef?.current();
+	} }));
+	const handleSubmit = useCallback((formData) => {
+		onSubmit(formData, initialData);
+	}, [initialData, onSubmit]);
+	return /* @__PURE__ */ React.createElement(Form$1, {
+		onSubmit: handleSubmit,
+		render: ({ handleSubmit: handleSubmit$1 }) => {
+			handleSubmitRef.current = handleSubmit$1;
+			return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("Transaction UI Action Type"),
+				id: "transactionUiActionType",
+				name: "transactionUiActionType",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: transactionUiActionTypeOptions || [],
+				getOptionLabelFunction: (option) => option.name,
+				initialValue: transactionUiActionTypeOptions?.find((transactionUiActionType) => transactionUiActionType?.transactionUiActionTypeId === initialData?.transactionUiActionTypeId) || null,
+				required: true
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("Action Api"),
+				id: "actionApi",
+				name: "actionApi",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: actionApiOptions || [],
+				getOptionLabelFunction: (option) => option.name,
+				initialValue: actionApiOptions?.find((actionApi) => actionApi?.actionApiId === initialData?.parameters?.actionApiId) || null
+			}), /* @__PURE__ */ React.createElement(Field$1, {
+				component: AmbientAutoComplete,
+				label: t("Page"),
+				id: "page",
+				name: "page",
+				variant: "outlined",
+				isMultiple: false,
+				disableCloseOnSelect: false,
+				options: pageOptions || [],
+				getOptionLabelFunction: (option) => option.name,
+				initialValue: pageOptions?.find((page) => page?.pageId === initialData?.parameters?.pageId) || null
+			}));
+		}
+	});
+};
+var UdpTransactionUiActionForm_default = forwardRef(UdpTransactionUiActionForm);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/sidesheets/UdpTransactionUiActionCreateAndEditSidesheet.jsx
+const UdpTransactionUiActionCreateAndEditSidesheet = (props) => {
+	const { initialTransactionUiAction, isSideSheetOpen, handleSideSheet, handleCreateTransactionUiAction, handleUpdateTransactionUiAction, transactionUiActionTypes, actionApis, pages, tUiActionsList } = props;
+	const isEditing = !!initialTransactionUiAction;
+	const formRef = useRef();
+	const { t } = useTranslation();
+	const normalizeToArray = (source) => {
+		if (Array.isArray(source)) return source;
+		return [];
+	};
+	const filterAvailableTUATypes = useCallback((allTUATypes, transactionUiActions, currentTransactionUiActionTypeId = null) => {
+		const allTUATypesArray = normalizeToArray(allTUATypes);
+		const usedTUATypeIds = normalizeToArray(transactionUiActions?.pageList).map((action) => action.transactionUiActionTypeId).filter((id) => id !== void 0 && id !== currentTransactionUiActionTypeId);
+		return allTUATypesArray.filter((type) => !usedTUATypeIds.includes(type.transactionUiActionTypeId));
+	}, []);
+	const availableTUATypeOptions = useMemo(() => {
+		if (!transactionUiActionTypes || !tUiActionsList) return [];
+		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 Transaction UI Action") : t("Create Transaction 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 transactonUiActionGridApiRef = useRef(null);
+	const { t } = useTranslation();
+	useImperativeHandle(ref, () => ({ refreshServerSide: () => {
+		transactonUiActionGridApiRef?.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
+			},
+			{
+				headerName: t("Type"),
+				field: "transactionUiActionTypeId",
+				resizable: false,
+				sortable: false,
+				valueGetter: (params) => getTransactionUiActionTypeName(params.data.transactionUiActionTypeId)
+			},
+			{
+				headerName: t("Actions"),
+				field: "actions",
+				cellRenderer: "actionsRenderer",
+				cellRendererParams: { actionList: [{
+					id: 0,
+					title: t("Edit"),
+					iconName: "edit",
+					handleOnClick: (e, transactionUiAction$1) => {
+						handleCreateOrEditTransactionUiActionSidesheet(true, transactionUiAction$1?.data);
+					}
+				}, {
+					id: 1,
+					title: t("Delete"),
+					iconName: "trashCan",
+					handleOnClick: (e, transactionUiAction$1) => {
+						handleDeleteTransactionUiAction(transactionUiAction$1?.data);
+					}
+				}] },
+				suppressMenu: true,
+				sortable: false,
+				filter: false,
+				valueGetter: (params) => params.data
+			}
+		];
+	}, [
+		t,
+		handleCreateOrEditTransactionUiActionSidesheet,
+		handleDeleteTransactionUiAction,
+		getTransactionUiActionTypeName
+	]);
+	const headerConfig = {
+		title: t("Transaction UI Actions"),
+		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) => {
+		transactonUiActionGridApiRef.current = api;
+	};
+	const searchMethodConfig = useMemo(() => {
+		let filterElements = [];
+		if (transactionType?.transactionTypeId) filterElements = [{
+			searchField: "TransactionTypeId",
+			searchOperator: "=",
+			searchValue: transactionType?.transactionTypeId,
+			groupId: 1
+		}];
+		return {
+			requestUrl: `${process.env.REACT_APP_PRODUCT_API_BASE}/UdpTransactionUiAction/search`,
+			customSearchObject: { filterElements }
+		};
+	}, [transactionType]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open: isSideSheetOpen,
+		width: 800,
+		title: t("Transaction UI Actions"),
+		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/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)
+} }));
+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 [searchObject, setSearchObject] = useState(baseSearchPayload);
+	const [selectedTransactionType, setSelectedTransactionType] = useState(null);
+	const [isTransactionTypeSideSheetOpen, setIsTransactionTypeSideSheetOpen] = useState(false);
+	const [isTransactionTypeSidesheetLoading, setIsTransactionTypeSidesheetLoading] = useState(false);
+	const [isDeleteTransactionTypeDialogOpen, setIsDeleteTransactionTypeDialogOpen] = useState(false);
+	const [selectedDomainName, setSelectedDomainName] = useState("");
+	const [isTransactionTypeStatusSidesheetOpen, setIsTransactionTypeStatusSidesheetOpen] = useState(false);
+	const [isDeleteTransactionTypeStatusDialogOpen, setIsDeleteTransactionTypeStatusDialogOpen] = useState(false);
+	const [selectedTransactionTypeStatus, setSelectedTransactionTypeStatus] = useState(null);
+	const [isCreateOrEditTransactionTypeStatusSidesheetOpen, setIsCreateOrEditTransactionTypeStatusSidesheetOpen] = useState(false);
+	const [isTransactionTypeTransactionActionSidesheetOpen, setIsTransactionTypeTransactionActionSidesheetOpen] = useState(false);
+	const [selectedTransactionTypeTransactionAction, setSelectedTransactionTypeTransactionAction] = useState(null);
+	const [isCreateOrEditTransactionTypeTransactionActionSidesheetOpen, setIsCreateOrEditTransactionTypeTransactionActionSidesheetOpen] = useState(false);
+	const [isDeleteTransactionTypeTransactionActionDialogOpen, setIsDeleteTransactionTypeTransactionActionDialogOpen] = useState(false);
+	const [isTransactionUiActionSidesheetOpen, setIsTransactionUiActionSidesheetOpen] = useState(false);
+	const [selectedTransactionUiAction, setSelectedTransactionUiAction] = useState(false);
+	const [isCreateOrEditTransactionUiActionSidesheetOpen, setIsCreateOrEditTransactionUiActionSidesheetOpen] = useState(false);
+	const [isDeleteTransactionUiActionDialogOpen, setIsDeleteTransactionUiActionDialogOpen] = useState(false);
+	const hasDefaultAndClosedTransactionTypeStatus = useCallback((transactionTypeStatuses, checkHasDefault = false, checkHasClosedStatus = false) => {
+		if (!transactionTypeStatuses) return false;
+		return transactionTypeStatuses?.some((record) => {
+			if (record.transactionTypeStatusId !== selectedTransactionTypeStatus?.transactionTypeStatusId) {
+				const isDefault = record?.isDefault;
+				const isClosedStatus = record?.isClosedStatus;
+				if (checkHasDefault && isDefault) return true;
+				if (checkHasClosedStatus && isClosedStatus) return true;
+			}
+			return false;
+		});
+	}, [selectedTransactionTypeStatus]);
+	/** TransactionType */
+	const postCreateTransactionType = async (transactionType) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionType`, { method: "POST" }, { data: transactionType });
+	};
+	const putUpdateTransactionType = async (transactionTypeId, transactionType) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionType/${transactionTypeId}`, { method: "PUT" }, { data: transactionType });
+	};
+	const deleteTransactionType = async (transactionTypeId) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionType/${transactionTypeId}`, { method: "DELETE" });
+	};
+	/** TransactionTypeStatus */
+	const postCreateTransactionTypeStatus = async (transactionTypeStatus) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeStatus`, { method: "POST" }, { data: transactionTypeStatus });
+	};
+	const putUpdateTransactionTypeStatus = async (transactionTypeStatusId, transactionTypeStatus) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeStatus/${transactionTypeStatusId}`, { method: "PUT" }, { data: transactionTypeStatus });
+	};
+	const deleteTransactionTypeStatus = async (transactionTypeStatusId) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeStatus/${transactionTypeStatusId}`, { method: "DELETE" });
+	};
+	const searchTransactionTypeStatusByTransactionTypeId = useCallback(async (transactionTypeId) => {
+		const searchPayload = {
+			filterElements: [{
+				searchField: "TransactionTypeId",
+				searchOperator: "=",
+				searchValue: transactionTypeId,
+				groupId: 1
+			}],
+			getAll: true
+		};
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeStatus/search`, { method: "POST" }, { data: searchPayload });
+	}, []);
+	/** TransactionAction */
+	const [{ data: transactionActions }] = useAxiosGet(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionAction`, { method: "GET" }, false, false);
+	/** ActionApis */
+	const [{ data: actionApis }] = useAxiosGet(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionWorkflowActionApi`, { method: "GET" }, false, false);
+	/** PageIds */
+	const [{ data: pages }] = useAxiosGet(process.env.REACT_APP_TENANTS_API_BASE, `Page?tenantId=${user?.currentTenantId}`, { method: "GET" }, !!!user?.currentTenantId, false);
+	/** TransactionTypeTransactionAction */
+	const postCreateTransactionTypeTransactionAction = async (transactionTypeTransactionAction) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeTransactionAction`, { method: "POST" }, { data: transactionTypeTransactionAction });
+	};
+	const putUpdateTransactionTypeTransactionAction = async (transactionTypeTransactionActionId, transactionTypeTransactionAction) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeTransactionAction/${transactionTypeTransactionActionId}`, { method: "PUT" }, { data: transactionTypeTransactionAction });
+	};
+	const deleteTransactionTypeTransactionAction = async (transactionTypeTransactionActionId) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionTypeTransactionAction/${transactionTypeTransactionActionId}`, { method: "DELETE" });
+	};
+	/** TransactionUiAction */
+	const postCreateTransactionUiAction = async (transactionUiAction) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionUiAction`, { method: "POST" }, { data: transactionUiAction });
+	};
+	const putUpdateTransactionUiAction = async (transactionUiActionId, transactionUiAction) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionUiAction/${transactionUiActionId}`, { method: "PUT" }, { data: transactionUiAction });
+	};
+	const deleteTransactionUiAction = async (transactionUiActionId) => {
+		return await apiMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionUiAction/${transactionUiActionId}`, { method: "DELETE" });
+	};
+	const [{ data: tUiActionsList }, fetchTUiActionsList] = useAxiosGet(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionUiAction/search`, {
+		method: "post",
+		data: {
+			filterElements: [{
+				searchField: "TransactionTypeId",
+				searchOperator: "=",
+				searchValue: selectedTransactionType?.transactionTypeId,
+				groupId: 1
+			}],
+			getAll: true
+		}
+	}, !!!selectedTransactionType?.transactionTypeId, false);
+	/** TransactionUiActionType */
+	const [{ data: transactionUiActionTypes }] = useAxiosGet(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionUiActionType`, { method: "GET" }, false, false);
+	const currentApiCatalogId = useCatalogStore((state) => state.currentApiCatalogId);
+	const { data: catalogObjects } = useApiCatalog(currentApiCatalogId);
+	const catalogObjectProperties = useMemo(() => {
+		const catalogObjectList = catalogObjects?.ctlg?.catalogObjectList;
+		if (!catalogObjectList) return [];
+		const catalogObject = catalogObjectList?.find((obj) => (obj.catalogObjectName === selectedTransactionType?.domainName || obj.catalogObjectName === selectedDomainName) && obj.apiCatalogId === currentApiCatalogId);
+		if (!catalogObject) return [];
+		return catalogObject?.properties.filter((property) => property.name !== "businessObjectKey" && property.name !== null).map((property) => property.name);
+	}, [
+		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);
+	}, []);
+	/** TransactionType */
+	const handleCreateTransactionType = useCallback(async (formValues) => {
+		const newTransactionType = { ...formValues };
+		try {
+			if ((await postCreateTransactionType(newTransactionType))?.status === 201) enqueueSnackbar(t("TransactionType created successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleSideSheet(false);
+			setSelectedDomainName("");
+			gridApiRef.current?.refreshServerSide();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		gridApiRef,
+		handleSideSheet,
+		successAction,
+		t
+	]);
+	const handleUpdateTransactionType = useCallback(async (formValues, initialValues) => {
+		const transactionTypeId = initialValues.transactionTypeId;
+		const updatedTransactionType = {
+			...initialValues,
+			...formValues
+		};
+		try {
+			if ((await putUpdateTransactionType(transactionTypeId, updatedTransactionType)).status === 204) enqueueSnackbar(t("TransactionType updated successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleSideSheet(false);
+			setSelectedDomainName("");
+			gridApiRef.current?.refreshServerSide();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		gridApiRef,
+		handleSideSheet,
+		successAction,
+		t
+	]);
+	const handleDeleteTransactionType = useCallback(async () => {
+		if (!selectedTransactionType) return;
+		setIsTransactionTypeSidesheetLoading(true);
+		const transactionTypeId = selectedTransactionType.transactionTypeId;
+		try {
+			if ((await deleteTransactionType(transactionTypeId)).status === 204) enqueueSnackbar(t("TransactionType deleted successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			setIsDeleteTransactionTypeDialogOpen(false);
+			gridApiRef.current?.refreshServerSide();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		} finally {
+			setIsTransactionTypeSidesheetLoading(false);
+		}
+	}, [
+		enqueueSnackbar,
+		selectedTransactionType,
+		successAction,
+		t,
+		setIsTransactionTypeSidesheetLoading,
+		setIsDeleteTransactionTypeDialogOpen
+	]);
+	/** end of TransactionType */
+	/** TransactionTypeStatus */
+	const handleCreateTransactionTypeStatus = useCallback(async (formValues) => {
+		const newTransactionTypeStatus = {
+			...formValues,
+			transactionTypeId: selectedTransactionType?.transactionTypeId
+		};
+		let hasExistingDefaultOrClosedStatus = false;
+		try {
+			const isCreatingDefaultStatus = formValues?.isDefault === true;
+			const isCreatingClosedStatus = formValues?.isClosedStatus === true;
+			if (isCreatingDefaultStatus || isCreatingClosedStatus) {
+				const searchTransactionTypeStatusResponse = await searchTransactionTypeStatusByTransactionTypeId(selectedTransactionType?.transactionTypeId);
+				if (searchTransactionTypeStatusResponse?.status !== 200) {
+					enqueueSnackbar(t("Unable to validate existing TransactionTypeStatus records. Please try again."), {
+						variant: "error",
+						anchorOrigin: {
+							vertical: "top",
+							horizontal: "center"
+						}
+					});
+					return;
+				}
+				hasExistingDefaultOrClosedStatus = hasDefaultAndClosedTransactionTypeStatus(searchTransactionTypeStatusResponse?.data?.pageList, isCreatingDefaultStatus, isCreatingClosedStatus);
+			}
+			if ((isCreatingDefaultStatus || isCreatingClosedStatus) && hasExistingDefaultOrClosedStatus) {
+				enqueueSnackbar(t(`There is already a TransactionTypeStatus for this TransactionType that has
+                ${isCreatingDefaultStatus ? isCreatingClosedStatus ? "IsDefault and/or IsClosedStatus" : "IsDefault" : "IsClosedStatus"} set to true.`), {
+					variant: "error",
+					anchorOrigin: {
+						vertical: "top",
+						horizontal: "center"
+					}
+				});
+				return;
+			}
+			if ((await postCreateTransactionTypeStatus(newTransactionTypeStatus))?.status === 201) enqueueSnackbar(t("TransactionTypeStatus created successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionTypeStatusSideSheet(false);
+			ttsGridApiRef.current?.refreshServerSide();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response?.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		ttsGridApiRef,
+		handleCreateOrEditTransactionTypeStatusSideSheet,
+		successAction,
+		t,
+		selectedTransactionType,
+		searchTransactionTypeStatusByTransactionTypeId,
+		hasDefaultAndClosedTransactionTypeStatus
+	]);
+	const handleUpdateTransactionTypeStatus = useCallback(async (formValues, initialValues) => {
+		const transactionTypeStatusId = initialValues.transactionTypeStatusId;
+		const updatedTransactionTypeStatus = {
+			...initialValues,
+			...formValues
+		};
+		let hasExistingDefaultOrClosedStatus = false;
+		try {
+			const isEditingDefaultStatus = formValues?.isDefault === true;
+			const isEditingClosedStatus = formValues?.isClosedStatus === true;
+			if (isEditingDefaultStatus || isEditingClosedStatus) {
+				const searchTransactionTypeStatusResponse = await searchTransactionTypeStatusByTransactionTypeId(selectedTransactionType?.transactionTypeId);
+				if (searchTransactionTypeStatusResponse?.status !== 200) {
+					enqueueSnackbar(t("Unable to validate existing TransactionTypeStatus records. Please try again."), {
+						variant: "error",
+						anchorOrigin: {
+							vertical: "top",
+							horizontal: "center"
+						}
+					});
+					return;
+				}
+				hasExistingDefaultOrClosedStatus = hasDefaultAndClosedTransactionTypeStatus(searchTransactionTypeStatusResponse?.data?.pageList, isEditingDefaultStatus, isEditingClosedStatus);
+			}
+			if ((isEditingDefaultStatus || isEditingClosedStatus) && hasExistingDefaultOrClosedStatus) {
+				enqueueSnackbar(t(`There is already a TransactionTypeStatus for this TransactionType that has
+              ${isEditingDefaultStatus ? isEditingClosedStatus ? "IsDefault and/or IsClosedStatus" : "IsDefault" : "IsClosedStatus"} set to true.`), {
+					variant: "error",
+					anchorOrigin: {
+						vertical: "top",
+						horizontal: "center"
+					}
+				});
+				return;
+			}
+			if ((await putUpdateTransactionTypeStatus(transactionTypeStatusId, updatedTransactionTypeStatus)).status === 204) enqueueSnackbar(t("TransactionTypeStatus updated successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionTypeStatusSideSheet(false);
+			ttsGridApiRef.current?.refreshServerSide();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response?.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		ttsGridApiRef,
+		handleCreateOrEditTransactionTypeStatusSideSheet,
+		successAction,
+		t,
+		searchTransactionTypeStatusByTransactionTypeId,
+		hasDefaultAndClosedTransactionTypeStatus,
+		selectedTransactionType
+	]);
+	const handleDeleteTransactionTypeStatus = useCallback(async () => {
+		if (!selectedTransactionTypeStatus) return;
+		const transactionTypeStatusId = selectedTransactionTypeStatus.transactionTypeStatusId;
+		try {
+			if ((await deleteTransactionTypeStatus(transactionTypeStatusId)).status === 204) enqueueSnackbar(t("TransactionTypeStatus deleted successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			setIsDeleteTransactionTypeStatusDialogOpen(false);
+			ttsGridApiRef.current?.refreshServerSide();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		selectedTransactionTypeStatus,
+		successAction,
+		t,
+		ttsGridApiRef,
+		setIsDeleteTransactionTypeStatusDialogOpen
+	]);
+	/** end of TransactionTypeStatus */
+	/** TransactionTypeTransactionAction */
+	const handleCreateTransactionTypeTransactionAction = useCallback(async (formValues) => {
+		const { transactionAction, toStatus, actionApiId, pageId, mandatoryFields, hiddenFields, domainDataToUpdate, ...restValues } = formValues || {};
+		const domainDataDictionary = (Array.isArray(domainDataToUpdate) ? domainDataToUpdate : []).reduce((accumulator, entry) => {
+			if (!entry) return accumulator;
+			const [field, value] = entry;
+			if (field) accumulator[field] = value;
+			return accumulator;
+		}, {});
+		const newTransactionTypeTransactionAction = {
+			...restValues,
+			transactionTypeId: selectedTransactionType?.transactionTypeId,
+			transactionActionId: transactionAction?.transactionActionId,
+			parameters: {
+				ToStatus: toStatus?.transactionTypeStatusId,
+				DomainDataToUpdate: domainDataDictionary,
+				MandatoryFields: Array.isArray(mandatoryFields) ? mandatoryFields : [],
+				HiddenFields: Array.isArray(hiddenFields) ? hiddenFields : [],
+				ActionApiId: actionApiId?.actionApiId || "",
+				PageId: pageId?.pageId || ""
+			}
+		};
+		try {
+			if ((await postCreateTransactionTypeTransactionAction(newTransactionTypeTransactionAction))?.status === 201) enqueueSnackbar(t("TransactionTypeTransactionAction created successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionTypeTransactionActionSidesheet(false);
+			tttaGridApiRef.current?.refreshServerSide();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		tttaGridApiRef,
+		handleCreateOrEditTransactionTypeTransactionActionSidesheet,
+		successAction,
+		t,
+		selectedTransactionType
+	]);
+	const handleUpdateTransactionTypeTransactionAction = useCallback(async (formValues, initialValues) => {
+		const { transactionAction, toStatus, actionApiId, pageId, mandatoryFields, hiddenFields, domainDataToUpdate } = formValues || {};
+		const transactionTypeTransactionActionId = initialValues.transactionTypeTransactionActionId;
+		const domainDataDictionary = (Array.isArray(domainDataToUpdate) ? domainDataToUpdate : []).reduce((accumulator, entry) => {
+			if (!entry) return accumulator;
+			const [field, value] = entry;
+			if (field) accumulator[field] = value;
+			return accumulator;
+		}, {});
+		const updatedTransactionTypeTransactionAction = {
+			...initialValues,
+			name: formValues?.name || "",
+			description: formValues?.description || "",
+			icon: formValues?.icon || "",
+			transactionTypeTransactionActionId,
+			transactionTypeId: selectedTransactionType?.transactionTypeId,
+			transactionActionId: transactionAction?.transactionActionId,
+			parameters: {
+				ToStatus: toStatus?.transactionTypeStatusId,
+				DomainDataToUpdate: domainDataDictionary,
+				MandatoryFields: Array.isArray(mandatoryFields) ? mandatoryFields : [],
+				HiddenFields: Array.isArray(hiddenFields) ? hiddenFields : [],
+				ActionApiId: actionApiId?.actionApiId || "",
+				PageId: pageId?.pageId || ""
+			}
+		};
+		try {
+			if ((await putUpdateTransactionTypeTransactionAction(transactionTypeTransactionActionId, updatedTransactionTypeTransactionAction)).status === 204) enqueueSnackbar(t("TransactionTypeTransactionAction updated successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionTypeTransactionActionSidesheet(false);
+			tttaGridApiRef.current?.refreshServerSide();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		tttaGridApiRef,
+		handleCreateOrEditTransactionTypeTransactionActionSidesheet,
+		successAction,
+		t,
+		selectedTransactionType
+	]);
+	const handleDeleteTransactionTypeTransactionAction = useCallback(async () => {
+		if (!selectedTransactionTypeTransactionAction) return;
+		const transactionTypeTransactionActionId = selectedTransactionTypeTransactionAction.transactionTypeTransactionActionId;
+		try {
+			if ((await deleteTransactionTypeTransactionAction(transactionTypeTransactionActionId)).status === 204) enqueueSnackbar(t("TransactionTypeTransactionAction deleted successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			setIsDeleteTransactionTypeTransactionActionDialogOpen(false);
+			tttaGridApiRef.current?.refreshServerSide();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		selectedTransactionTypeTransactionAction,
+		successAction,
+		t,
+		setIsDeleteTransactionTypeTransactionActionDialogOpen
+	]);
+	/** end of TransactionTypeTransactionAction */
+	/** TransactionUiAction */
+	const handleCreateTransactionUiAction = useCallback(async (formValues) => {
+		const { transactionUiActionType, actionApi, page, ...restValues } = formValues;
+		const newTransactionUiAction = {
+			...restValues,
+			transactionTypeId: selectedTransactionType?.transactionTypeId,
+			transactionUiActionTypeId: transactionUiActionType?.transactionUiActionTypeId,
+			parameters: {
+				ActionApiId: actionApi?.actionApiId || "",
+				PageId: page?.pageId || ""
+			}
+		};
+		try {
+			if ((await postCreateTransactionUiAction(newTransactionUiAction))?.status === 201) enqueueSnackbar(t("TransactionUiAction created successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionUiActionSidesheet(false);
+			tuaGridApiRef.current?.refreshServerSide();
+			fetchTUiActionsList();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		tuaGridApiRef,
+		handleCreateOrEditTransactionUiActionSidesheet,
+		successAction,
+		t,
+		selectedTransactionType,
+		fetchTUiActionsList
+	]);
+	const handleUpdateTransactionUiAction = useCallback(async (formValues, initialValues) => {
+		const { transactionUiActionType, actionApi, page, ...restValues } = formValues;
+		const transactionUiActionId = initialValues.transactionUiActionId;
+		const updatedTransactionUiAction = {
+			...restValues,
+			transactionUiActionId,
+			transactionTypeId: selectedTransactionType?.transactionTypeId,
+			transactionUiActionTypeId: transactionUiActionType?.transactionUiActionTypeId,
+			parameters: {
+				ActionApiId: actionApi?.actionApiId || "",
+				PageId: page?.pageId || ""
+			}
+		};
+		try {
+			if ((await putUpdateTransactionUiAction(transactionUiActionId, updatedTransactionUiAction)).status === 204) enqueueSnackbar(t("TransactionUiAction updated successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			handleCreateOrEditTransactionUiActionSidesheet(false);
+			tuaGridApiRef.current?.refreshServerSide();
+			fetchTUiActionsList();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		tuaGridApiRef,
+		handleCreateOrEditTransactionUiActionSidesheet,
+		successAction,
+		t,
+		selectedTransactionType,
+		fetchTUiActionsList
+	]);
+	const handleDeleteTransactionUiAction = useCallback(async () => {
+		if (!selectedTransactionUiAction) return;
+		const transactionUiActionId = selectedTransactionUiAction.transactionUiActionId;
+		try {
+			if ((await deleteTransactionUiAction(transactionUiActionId)).status === 204) enqueueSnackbar(t("TransactionUiAction deleted successfully"), {
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				},
+				action: successAction,
+				autoHideDuration: null
+			});
+			setIsDeleteTransactionUiActionDialogOpen(false);
+			tuaGridApiRef.current?.refreshServerSide();
+			fetchTUiActionsList();
+		} catch (err) {
+			enqueueSnackbar(typeof err.response.data === "object" ? err.response.data.title : err.response.data, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		enqueueSnackbar,
+		selectedTransactionUiAction,
+		successAction,
+		t,
+		setIsDeleteTransactionUiActionDialogOpen,
+		fetchTUiActionsList
+	]);
+	/** end of TransactionUiAction */
+	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 columnDefs = useMemo(() => {
+		return [
+			{
+				headerName: t("Transaction Type ID"),
+				field: "transactionTypeId",
+				resizable: true,
+				sortable: false
+			},
+			{
+				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
+			},
+			{
+				headerName: t("Has Revision"),
+				field: "hasRevision",
+				resizable: true,
+				sortable: false,
+				cellDataType: "boolean"
+			},
+			{
+				headerName: t("Revision Field"),
+				field: "revisionField",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Domain Type Field"),
+				field: "domainTypeField",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Domain Type Value"),
+				field: "domainTypeValue",
+				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 UiActions"),
+						iconName: "send",
+						handleOnClick: (e, transactionType) => {
+							handleTransactionUiActionSidesheet(true, transactionType?.data);
+						}
+					}
+				] },
+				valueGetter: (params) => params.data,
+				suppressMenu: true,
+				sortable: false,
+				filter: false
+			}
+		];
+	}, [
+		handleSideSheet,
+		handleOpenDeleteTransactionTypeDialog,
+		handleTransactionTypeStatusSideSheet,
+		handleTransactionTypeTransactionActionSidesheet,
+		handleTransactionUiActionSidesheet,
+		t
+	]);
+	const headerConfig = {
+		title: t("Transaction Types"),
+		primaryActionButton: {
+			label: t("Add"),
+			iconName: "add",
+			onClick: () => handleSideSheet(true)
+		}
+	};
+	const gridFunctions = [
+		{ name: "agGridExport" },
+		{ name: "agGridSizeColumnsToFit" },
+		{ name: "agGridAutoSizeColumns" },
+		{ name: "agGridResetColumns" },
+		{ name: "agGridHideShowColumns" }
+	];
+	const gridOptions = useMemo(() => {
+		return { pagination: true };
+	}, []);
+	const handleGridApiCallback = (api) => {
+		gridApiRef.current = api;
+	};
+	const searchMethodConfig = useMemo(() => {
+		return {
+			requestUrl: `${process.env.REACT_APP_PRODUCT_API_BASE}/UdpTransactionType/search`,
+			customSearchObject: searchObject
+		};
+	}, [searchObject]);
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, isTransactionTypeSidesheetLoading && /* @__PURE__ */ React.createElement(LinearProgress$1, {
+		className: classes.loadingBar,
+		color: "secondary"
+	}), /* @__PURE__ */ React.createElement(SearchMethodUdpGrid, {
+		searchMethodConfig,
+		columnDefs,
+		gridHeaderConfig: headerConfig,
+		gridOptions,
+		gridApiCallback: handleGridApiCallback,
+		gridFunctions
+	}), /* @__PURE__ */ React.createElement(UdpTransactionTypeSidesheet_default, {
+		key: selectedTransactionType?.transactionTypeId,
+		initialTransactionType: selectedTransactionType,
+		isSideSheetOpen: isTransactionTypeSideSheetOpen,
+		handleSideSheet,
+		setSelectedDomainName,
+		handleCreateTransactionType,
+		handleUpdateTransactionType,
+		catalogObjects,
+		catalogObjectProperties
+	}), /* @__PURE__ */ React.createElement(FluentDialog, {
+		open: isDeleteTransactionTypeDialogOpen,
+		onClose: handleCloseDeleteTransactionTypeDialog,
+		title: t("Confirm Delete"),
+		message: t(`Are you sure you want to delete transaction type '${selectedTransactionType?.name}'`),
+		labelOne: t("Delete"),
+		actionOne: handleDeleteTransactionType,
+		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 transaction type status '${selectedTransactionTypeStatus?.name}'`),
+		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,
+		searchTransactionTypeStatusByTransactionTypeId
+	}), /* @__PURE__ */ React.createElement(FluentDialog, {
+		open: isDeleteTransactionTypeTransactionActionDialogOpen,
+		onClose: handleCloseDeleteTransactionTypeTransactionActionDialog,
+		title: t("Confirm Delete"),
+		message: t(`Are you sure you want to delete transaction type transaction action '${selectedTransactionTypeTransactionAction?.name}'`),
+		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 transaction UI action?`),
+		labelOne: t("Delete"),
+		actionOne: handleDeleteTransactionUiAction,
+		labelTwo: t("Cancel"),
+		actionTwo: handleCloseDeleteTransactionUiActionDialog
+	}));
+};
+var UdpTransactionTypesPage_default = UdpTransactionTypesPage;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionTypesPage/index.ts
+var UdpTransactionTypesPage_exports = /* @__PURE__ */ __export({ default: () => UdpTransactionTypesPage_default });
+
+//#endregion
+export { UdpTransactionTypesPage_default as n, UdpTransactionTypesPage_exports as t };
+//# sourceMappingURL=UdpTransactionTypesPage-fo1YR5Cw.js.map