udp-react-enterprise-component-library 25.18.1-beta.8 → 25.18.1-beta.81

package/dist/UdpTransactionsPage-B6OV3w81.js

@@ -0,0 +1,2470 @@
+import { t as __exportAll } from "./chunk-BN_g-Awi.js";
+import { t as Form } from "./Form-DbOA5j38.js";
+import { t as Field } from "./Field-Cda5rJe2.js";
+import { a as FormSpy } from "./form-Dj1zVw6K.js";
+import { t as FluentButton } from "./FluentButton-BexKrnAp.js";
+import { t as ConfigService$1 } from "./configService-C4uoG3wj.js";
+import { i as useHandleAxiosSnackbar } from "./apiHelpers-WIR8pqy0.js";
+import { t as useUser } from "./useUser-wpHGo6jU.js";
+import { n as useAxiosMutate, t as apiMutate } from "./useAxiosMutate-DeqKSi5z.js";
+import { t as FluentTextFieldAutoComplete } from "./FluentTextFieldAutoComplete-5Hp3qpk6.js";
+import { t as FluentIcon } from "./FluentIcon-DQ6nSDJg.js";
+import { r as getSanitizedName } from "./entityUtilities-_8w-Zjs3.js";
+import { B as UdpSearchEnums, F as TransactionUiActionTypeEnums, N as TransactionActionTypeEnums, P as TransactionEventTypeEnums, n as CardinalityTypeEnums } from "./unitySystemEnums-CZDCsD5t.js";
+import { t as useCatalogStore } from "./catalogStore-DP2GxpTJ.js";
+import { t as Typography$1 } from "./Typography-FuShOop3.js";
+import { S as getIconFromName } from "./TreeUtilities-jEhtZNg5.js";
+import { n as SideSheet } from "./SideSheet-CDXVa_Kr.js";
+import { t as useAxiosGet } from "./useAxiosGet-CYnt6Hd0.js";
+import { t as StatusChip } from "./StatusChip-DZAN88VU.js";
+import { t as UdpTabs } from "./UdpTabs-DVZGEwOC.js";
+import { t as PageContainer } from "./PageContainer-ButX_XVS.js";
+import { t as Adornment } from "./Adornment-Ciq1X7he.js";
+import { t as AmbientCard } from "./AmbientCard-DhAiVDYD.js";
+import { t as AmbientTextField } from "./AmbientTextField-CdnqPJUw.js";
+import { t as FluentDialog } from "./FluentDialog-B5ZxvX1E.js";
+import { t as LinearProgress$1 } from "./LinearProgress-CpJeIaEP.js";
+import { t as FluentTextField } from "./FluentTextField-WfFk-koa.js";
+import { t as useAuthedUser } from "./useAuthedUser-Bhr7Yhlg.js";
+import { t as Divider$1 } from "./Divider-B63XWSBY.js";
+import { n as AmbientList } from "./dataDisplay-CTkvIsCs.js";
+import { t as AmbientAutoComplete } from "./AmbientAutoComplete-NohpvB31.js";
+import { t as AmbientAlert } from "./AmbientAlert-DcYkGCUm.js";
+import { t as EmptyStateDisplay } from "./EmptyStateDisplay-YOwCw38_.js";
+import { t as FileViewer } from "./fileViewer-C_Q-hFda.js";
+import { n as UdpTabPanel } from "./tabs-CAaJhUt5.js";
+import { n as UdpTimeline } from "./timeline-CdeAJqvB.js";
+import { t as SearchMethodUdpGrid } from "./SearchMethodUdpGrid-CWYZUOx-.js";
+import { i as getLocalizedDateTimeString, t as formatDate } from "./dateUtils-COj9Xpy9.js";
+import { t as UdpActionCard } from "./UdpActionCard-VtAacuCM.js";
+import { t as Attachments } from "./uploader-BdeUKdYW.js";
+import React, { forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
+import { Badge, CircularProgress, FormControlLabel, LinearProgress, Switch, makeStyles } from "@material-ui/core";
+import { useSnackbar } from "notistack";
+import { useLocation } from "react-router-dom";
+import { AddIcon, ContactIcon, DocumentIcon, FileImageIcon, PDFIcon, ViewIcon, WordDocumentIcon } from "@fluentui/react-icons";
+import { useTranslation } from "react-i18next";
+import { create } from "zustand";
+import { devtools } from "zustand/middleware";
+import jsonLogic from "json-logic-js";
+import { ConfigService, UdpAttachmentItem, UdpTimelineConnector, UdpTimelineDot, UdpTimelineItem, UdpTimelineSeparator } from "udp-react-stencil-component-library";
+import "date-fns";
+import "./udp/pages/UdpTransactionsPage/sidesheets/WorkflowActions.css";
+import "./udp/pages/UdpTransactionsPage/sidesheets/EditTransaction.css";
+import "./udp/pages/UdpTransactionsPage/components/EditTransactionDetailsFooterItem.css";
+import "./udp/pages/UdpTransactionsPage/UdpTransactionsPage.css";
+
+//#region src/stores/transactionStore.ts
+const useTransactionStore = create()(devtools((set) => ({
+	transactionTypesMap: {},
+	setTransactionTypesMap: (transactionTypesMap) => set((state) => ({ transactionTypesMap: {
+		...state.transactionTypesMap,
+		...transactionTypesMap
+	} }))
+})));
+
+//#endregion
+//#region src/utilities/transactions/useTransactionEngine.js
+const useTransactionEngine = (transactionTypeId) => {
+	const user = useUser();
+	const [transactionTypeFields, setTransactionTypeFields] = useState([]);
+	const currentApiCatalogId = useCatalogStore((state) => state.currentApiCatalogId);
+	const catalogsMap = useCatalogStore((state) => state.catalogsMap);
+	const transactionTypesMap = useTransactionStore((state) => state.transactionTypesMap);
+	const transactionType = transactionTypesMap ? transactionTypesMap[transactionTypeId] : null;
+	const evaluateRule = useCallback((rule, udpTransaction) => {
+		let udpTransactionEvaluationData = {
+			currentStatusId: udpTransaction?.currentStatusId,
+			currentDomainValue: udpTransaction?.entityBusinessObject,
+			tenantUserRoleIds: user?.roleIds || []
+		};
+		return jsonLogic.apply(rule, udpTransactionEvaluationData);
+	}, [user?.roleIds]);
+	const getTransactionTypeTransactionActions = useCallback((udpTransaction, ruleTypeId = null) => {
+		return transactionType?.udpTransactionTypeUdpTransactionTypeConfiguration?.reduce((actions, config) => {
+			const ruleLogic = config?.expressionLogic;
+			if (!ruleTypeId) return actions;
+			if (config.transactionRuleTypeId === ruleTypeId && config.enabled && ruleLogic) {
+				if (evaluateRule(ruleLogic, udpTransaction)) {
+					const nestedActions = (config?.udpTransactionTypeConfigurationUdpTransactionTypeConfigurationTransactionAction || []).map((action) => action.udpTransactionTypeConfigurationTransactionActionUdpTransactionTypeTransactionAction).filter((action) => action);
+					if (nestedActions.length > 0) actions = actions.concat(nestedActions);
+				}
+				return actions;
+			}
+			return actions;
+		}, []);
+	}, [transactionType, evaluateRule]);
+	const hasRevisions = useMemo(() => {
+		return transactionType?.hasRevision;
+	}, [transactionType]);
+	const hasClosedStatus = useMemo(() => {
+		return transactionType?.udpTransactionTypeUdpTransactionTypeStatus?.some((status) => status.isClosedStatus);
+	}, [transactionType]);
+	const canCancel = useMemo(() => {
+		return transactionType?.archiveOnCancel || transactionType?.udpTransactionTypeUdpTransactionTypeStatus?.some((status) => status.isCancelledStatus);
+	}, [transactionType]);
+	const transactionTypeStatuses = useMemo(() => transactionType?.udpTransactionTypeUdpTransactionTypeStatus, [transactionType]);
+	const transactionTypeGridColumns = useMemo(() => {
+		if (Array.isArray(transactionType?.domainFields)) return transactionType?.domainFields || [];
+		else if (transactionType?.domainFields && Object.keys(transactionType.domainFields).length) return Object.entries(transactionType.domainFields).map(([propertyName, value]) => ({
+			propertyName,
+			...value
+		})).sort((a, b) => a.order - b.order) || [];
+		return [];
+	}, [transactionType]);
+	const transactionTypeStatusColorsMap = useMemo(() => {
+		const statusColorsMap = {};
+		transactionType?.udpTransactionTypeUdpTransactionTypeStatus?.forEach((status) => {
+			statusColorsMap[status.name] = status.color || "default";
+		});
+		return statusColorsMap;
+	}, [transactionType]);
+	const getHiddenFields = useCallback((udpTransaction) => {
+		const transactionActions = getTransactionTypeTransactionActions(udpTransaction, TransactionEventTypeEnums.Form);
+		if (!transactionActions) return [];
+		let hiddenFields = [];
+		transactionActions.filter((action) => action.transactionActionId === TransactionActionTypeEnums.Set_Fields_Hidden).forEach((action) => {
+			if (action.parameters?.hiddenFields) hiddenFields = hiddenFields.concat(action.parameters.hiddenFields);
+		});
+		return hiddenFields;
+	}, [getTransactionTypeTransactionActions]);
+	const getRequiredFields = useCallback((udpTransaction) => {
+		const transactionActions = getTransactionTypeTransactionActions(udpTransaction, TransactionEventTypeEnums.Form);
+		if (!transactionActions) return [];
+		let requiredFields = [];
+		transactionActions.filter((action) => action.transactionActionId === TransactionActionTypeEnums.Set_Mandatory_Fields).forEach((action) => {
+			if (action.parameters?.mandatoryFields) requiredFields = requiredFields.concat(action.parameters.mandatoryFields);
+		});
+		return requiredFields;
+	}, [getTransactionTypeTransactionActions]);
+	const getUiActionRenderPageId = useCallback((uiActionType) => {
+		return (transactionType?.udpTransactionTypeUdpTransactionUiAction?.find((action) => action.transactionUiActionTypeId === uiActionType))?.parameters?.pageId || null;
+	}, [transactionType]);
+	const getTransactionTypeLabel = useCallback((udpTransaction) => {
+		if (!transactionType?.domainFieldLabel) return null;
+		return udpTransaction?.entityBusinessObject ? udpTransaction.entityBusinessObject[transactionType.domainFieldLabel] : null;
+	}, [transactionType]);
+	const checkIfTransactionIsClosed = useCallback((udpTransaction) => {
+		if (!hasClosedStatus) return false;
+		const closedStatus = transactionType?.udpTransactionTypeUdpTransactionTypeStatus?.find((status) => status.isClosedStatus);
+		if (!closedStatus) return false;
+		return closedStatus.transactionTypeStatusId === udpTransaction?.currentStatusId;
+	}, [hasClosedStatus, transactionType]);
+	useEffect(() => {
+		if (catalogsMap && currentApiCatalogId && transactionType) {
+			const apiCatalog = catalogsMap[currentApiCatalogId];
+			if (apiCatalog) {
+				const transactionTypeObject = apiCatalog.ctlg.catalogObjectList.find((obj) => obj.catalogObjectName.toLowerCase() === transactionType?.domainName?.toLowerCase());
+				if (transactionTypeObject) setTransactionTypeFields(transactionTypeObject.properties || []);
+			}
+		}
+	}, [
+		catalogsMap,
+		currentApiCatalogId,
+		transactionType
+	]);
+	return {
+		currentTransactionType: transactionType,
+		evaluateRule,
+		getTransactionTypeTransactionActions,
+		hasRevisions,
+		getHiddenFields,
+		getRequiredFields,
+		hasClosedStatus,
+		transactionTypeGridColumns,
+		getUiActionRenderPageId,
+		checkIfTransactionIsClosed,
+		getTransactionTypeLabel,
+		transactionTypeStatusColorsMap,
+		transactionTypeStatuses,
+		canCancel
+	};
+};
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/UdpTransactionGrid.jsx
+const UDP_TRANSACTION_GRID_ID = "32c0fd0b-bb94-497a-b47a-6c7e8f746134";
+const UdpTransactionGrid = (props) => {
+	const { transactionTypeId, domainName, transactionTypeLoading, handleGridApiCallback, openAddTransaction, openViewTransaction, openEditTransaction, openAttachmentTransaction, openWorkflowActionTransaction, openCreateRevision, searchMethodObject, domainColumnFormatters = {}, refreshGridData, gridApi, initialFilterModel, initialGridOptions = {} } = props;
+	const [dialogOpen, setDialogOpen] = useState(false);
+	const [selectedTransaction, setSelectedTransaction] = useState(null);
+	const { t } = useTranslation();
+	const { hasRevisions, transactionTypeGridColumns, getUiActionRenderPageId, transactionTypeStatusColorsMap, getTransactionTypeLabel, transactionTypeStatuses, canCancel } = useTransactionEngine(transactionTypeId);
+	const { handleErrorSnackbar, handleSuccessSnackbar } = useHandleAxiosSnackbar();
+	const [{ data, loading: cancelLoading, error: cancelError }, cancelTransaction] = useAxiosMutate(`${ConfigService$1.productV1ApiUrl}`, `udptransaction/${selectedTransaction?.transactionId}/cancelTransaction`, { method: "post" }, {});
+	const { currentApiCatalogId, catalogsMap } = useCatalogStore();
+	const handleDialogClose = () => {
+		setSelectedTransaction(null);
+		setDialogOpen(false);
+	};
+	const handleConfirmActionDialog = useCallback(async () => {
+		try {
+			if ((await cancelTransaction())?.status === 200) {
+				refreshGridData();
+				handleSuccessSnackbar(t(`Transaction has been cancelled successfully`));
+			} else handleErrorSnackbar(new Error(t(`Error cancelling Transaction. Please try again later.`)));
+		} catch (error) {
+			handleErrorSnackbar(error);
+		} finally {
+			handleDialogClose();
+		}
+	}, [
+		cancelTransaction,
+		refreshGridData,
+		handleErrorSnackbar,
+		handleSuccessSnackbar,
+		t
+	]);
+	const removeTimeFromDate = (date) => {
+		const parsedDate = new Date(date);
+		if (parsedDate.getTime()) {
+			const year = parsedDate.getFullYear();
+			const month = parsedDate.getMonth() + 1;
+			const day = parsedDate.getDate().toString();
+			return `${year}-${month.toString()}-${day}`;
+		}
+		return parsedDate;
+	};
+	const transactionLabel = useMemo(() => {
+		return getTransactionTypeLabel(selectedTransaction) ?? selectedTransaction?.entityBusinessKey;
+	}, [getTransactionTypeLabel, selectedTransaction]);
+	const pdfViewPageId = useMemo(() => {
+		return getUiActionRenderPageId(TransactionUiActionTypeEnums.Render_View_Pdf_Page);
+	}, [getUiActionRenderPageId]);
+	const catalogObjectList = useMemo(() => {
+		if (catalogsMap && currentApiCatalogId && catalogsMap[currentApiCatalogId]) return catalogsMap[currentApiCatalogId]?.ctlg?.catalogObjectList;
+		return null;
+	}, [catalogsMap, currentApiCatalogId]);
+	const columnDefs = useMemo(() => {
+		const initialColumnDefs = [
+			{
+				headerName: t("Transaction Id"),
+				field: "transactionId",
+				hide: true
+			},
+			{
+				headerName: t("Created On"),
+				field: "createdOn",
+				cellDataType: "dateString",
+				valueFormatter: (params) => {
+					return removeTimeFromDate(params?.data.createdOn);
+				}
+			},
+			{
+				headerName: t("Current Status"),
+				field: "currentStatusId",
+				cellRenderer: "statusRenderer",
+				cellRendererParams: {
+					statusMappingConfig: transactionTypeStatusColorsMap,
+					getStatusValue: (params) => params?.data.udpTransactionUdpTransactionTypeStatus.name
+				},
+				filter: "agSetColumnFilter",
+				filterParams: {
+					values: (params) => {
+						if (transactionTypeStatuses) params.success(transactionTypeStatuses);
+					},
+					keyCreator: (params) => params.value.transactionTypeStatusId,
+					valueFormatter: (params) => params.value.name
+				},
+				valueFormatter: (params) => params?.data.udpTransactionUdpTransactionTypeStatus.name
+			},
+			{
+				headerName: t("Last Event Type"),
+				field: "lastEventTypeId",
+				valueFormatter: (params) => params?.data.udpTransactionUdpTransactionEventType.name
+			},
+			{
+				headerName: t("Attachments"),
+				field: "attachments",
+				pinned: "right",
+				maxWidth: 100,
+				onCellClicked: (event) => {
+					openAttachmentTransaction(event.data);
+				},
+				valueFormatter: (params) => {
+					return params?.data.udpTransactionUdpTransactionAttachment.length;
+				}
+			},
+			{
+				field: "actions",
+				cellRenderer: "actionsRenderer",
+				cellRendererParams: { actionList: [
+					{
+						id: 0,
+						title: t("Next Steps"),
+						iconName: "migrateAlt",
+						handleOnClick: (e, params) => {
+							openWorkflowActionTransaction(params?.data);
+						}
+					},
+					...pdfViewPageId ? [{
+						id: 1,
+						title: t("View"),
+						iconName: "view",
+						handleOnClick: (e, params) => {
+							openViewTransaction(params?.data);
+						},
+						disabled: !pdfViewPageId
+					}] : [],
+					{
+						id: 2,
+						title: t("Edit"),
+						iconName: "edit",
+						handleOnClick: (e, params) => {
+							openEditTransaction(params?.data);
+						}
+					},
+					{
+						id: 3,
+						title: t("Create Revision"),
+						iconName: "add",
+						handleOnClick: (e, params) => {
+							openCreateRevision(params?.data);
+						},
+						disabled: !hasRevisions
+					},
+					...canCancel ? [{
+						id: 4,
+						title: t("Cancel"),
+						iconName: "close16",
+						handleOnClick: (e, params) => {
+							setSelectedTransaction(params?.data);
+							setDialogOpen(true);
+						}
+					}] : []
+				] }
+			}
+		];
+		transactionTypeGridColumns?.forEach((gridColumn) => {
+			const propertyName = gridColumn?.propertyName || "";
+			let catalogObject = catalogObjectList?.find((catalogObject$1) => getSanitizedName(catalogObject$1.catalogObjectName) == domainName);
+			let valueFormatter = (params) => {
+				if (catalogObjectList) {
+					if ((catalogObject?.properties?.find((objectProperty) => {
+						return objectProperty.name === propertyName;
+					}))?.type.toLowerCase() == "datetime" && params?.data?.entityBusinessObject[propertyName]) return removeTimeFromDate(params?.data?.entityBusinessObject[propertyName]);
+				}
+				return params?.data ? params?.data?.entityBusinessObject[propertyName] : "";
+			};
+			if (domainColumnFormatters[propertyName]) valueFormatter = domainColumnFormatters[propertyName].formatter;
+			let agColumnFilter = "agTextColumnFilter";
+			if ((catalogObject?.properties?.find((objectProperty) => {
+				return objectProperty.name === propertyName;
+			}))?.type.toLowerCase() == "datetime") agColumnFilter = "agDateColumnFilter";
+			initialColumnDefs.push({
+				headerName: gridColumn?.displayName,
+				field: `${UdpSearchEnums.UdpBusinessDomainPrefix}.${domainName}.${propertyName}`,
+				valueFormatter,
+				filter: agColumnFilter
+			});
+		});
+		Object.keys(domainColumnFormatters).forEach((columnKey) => {
+			if (!(transactionTypeGridColumns?.map((col) => col.propertyName))?.includes(columnKey)) {
+				let formatedHeaderName = columnKey.slice(0, 1).toUpperCase() + columnKey.slice(1);
+				initialColumnDefs.push({
+					headerName: formatedHeaderName,
+					field: `${UdpSearchEnums.UdpBusinessDomainPrefix}.${domainName}.${columnKey}`,
+					valueFormatter: domainColumnFormatters[columnKey].formatter
+				});
+			}
+		});
+		if (hasRevisions) initialColumnDefs.splice(3, 0, {
+			headerName: t("Revision No"),
+			field: "currentRevisionNo"
+		});
+		return initialColumnDefs;
+	}, [
+		domainName,
+		t,
+		openViewTransaction,
+		openEditTransaction,
+		openAttachmentTransaction,
+		openWorkflowActionTransaction,
+		domainColumnFormatters,
+		transactionTypeGridColumns,
+		openCreateRevision,
+		hasRevisions,
+		pdfViewPageId,
+		transactionTypeStatusColorsMap,
+		catalogObjectList,
+		transactionTypeStatuses,
+		canCancel
+	]);
+	const headerConfig = {
+		title: domainName,
+		primaryActionButton: {
+			label: domainName + " Entry",
+			iconName: "add",
+			onClick: () => {
+				openAddTransaction();
+			}
+		}
+	};
+	const gridFunctions = [
+		{ name: "openSavedViews" },
+		{ name: "agGridExport" },
+		{ name: "agGridHideShowColumns" },
+		{ name: "agGridSizeColumnsToFit" }
+	];
+	const gridOptions = useMemo(() => {
+		return {
+			pagination: true,
+			rowSelection: "none",
+			...initialGridOptions
+		};
+	}, [initialGridOptions]);
+	const searchMethodConfig = useMemo(() => {
+		let combinedSearchObject = {
+			eagerLoad: true,
+			filterElements: [{
+				searchField: "transactionTypeId",
+				searchOperator: "=",
+				searchValue: transactionTypeId
+			}, {
+				searchField: "isDeleted",
+				searchOperator: "=",
+				searchValue: false
+			}]
+		};
+		if (searchMethodObject) {
+			let combinedFilterElems = combinedSearchObject.filterElements.concat(searchMethodObject?.filterElements || []);
+			combinedSearchObject = {
+				...combinedSearchObject,
+				...searchMethodObject
+			};
+			combinedSearchObject = {
+				...combinedSearchObject,
+				filterElements: combinedFilterElems
+			};
+		}
+		return {
+			requestUrl: `${ConfigService$1.productV1ApiUrl}/UdpTransaction/search`,
+			customSearchObject: combinedSearchObject
+		};
+	}, [transactionTypeId, searchMethodObject]);
+	useEffect(() => {
+		if (gridApi && initialFilterModel && Object.keys(initialFilterModel).length) {
+			gridApi.setFilterModel(initialFilterModel);
+			gridApi.onFilterChanged();
+		}
+	}, [gridApi, initialFilterModel]);
+	console.log(gridApi?.getFilterModel());
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, transactionTypeLoading && /* @__PURE__ */ React.createElement(LinearProgress$1, null), /* @__PURE__ */ React.createElement(SearchMethodUdpGrid, {
+		gridHeaderConfig: headerConfig,
+		gridFunctions,
+		gridOptions,
+		columnDefs,
+		searchMethodConfig,
+		gridApiCallback: handleGridApiCallback,
+		gridId: UDP_TRANSACTION_GRID_ID,
+		entityName: domainName
+	}), /* @__PURE__ */ React.createElement(FluentDialog, {
+		title: t(`Cancel Transaction`),
+		message: `Are you sure you want to cancel the transaction for ${domainName} - ${transactionLabel || ""}?`,
+		labelOne: t("Confirm"),
+		actionOne: handleConfirmActionDialog,
+		labelTwo: t("Cancel"),
+		actionTwo: handleDialogClose,
+		open: dialogOpen,
+		handleClose: handleDialogClose,
+		loading: cancelLoading
+	}));
+};
+var UdpTransactionGrid_default = UdpTransactionGrid;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/sidesheets/ViewTransaction.jsx
+const ViewTransaction = (props) => {
+	const { transaction } = props;
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(FileViewer, {
+		data: {
+			filePath: "",
+			fileExtension: "pdf"
+		},
+		acceptedFileExtensions: "pdf"
+	}));
+};
+var ViewTransaction_default = ViewTransaction;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/components/AttachmentTransactionAttachmentList.jsx
+const AttachmentTransactionAttachmentList = (props) => {
+	const { attachments, setSelectedAttachment } = props;
+	const formattedAttachments = useMemo(() => {
+		return attachments.map((attachment) => ({
+			attachmentName: attachment.fileName,
+			extension: attachment.extension,
+			transactionAttachmentId: attachment.transactionAttachmentId
+		}));
+	}, [attachments]);
+	const getFileIcon = (item) => {
+		if (item.attachmentName.includes(".pdf")) return PDFIcon;
+		else if (item.attachmentName.includes(".docx")) return WordDocumentIcon;
+		else if (item.attachmentName.includes(".")) return FileImageIcon;
+	};
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(AmbientList, {
+		data: formattedAttachments,
+		useAvatar: false,
+		fieldConfig: {
+			primaryText: "attachmentName",
+			secondaryText: "description"
+		},
+		onItemClick: (item) => {
+			setSelectedAttachment(item);
+		},
+		getItemIcon: (item) => {
+			return getFileIcon(item);
+		},
+		listHeight: "calc(100vh - 105px)",
+		maxHeight: "calc(100vh - 105px)"
+	}));
+};
+var AttachmentTransactionAttachmentList_default = AttachmentTransactionAttachmentList;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/sidesheets/AttachmentTransaction.jsx
+const AttachmentTransaction = (props) => {
+	const { transaction, attachmentRef } = props;
+	const [selectedAttachment, setSelectedAttachment] = useState("");
+	const attachments = transaction?.udpTransactionUdpTransactionAttachment;
+	const { t } = useTranslation();
+	const [{ data: attachmentFileInfo }, refetchattachmentFileInfo] = useAxiosGet(`${process.env.REACT_APP_PRODUCT_API_BASE}`, `UdpTransactionAttachment/${selectedAttachment?.transactionAttachmentId}/udpDriveFile/download`, {}, true);
+	const [{ data: attachmentFile, loading: loadingFile, error: downloadError }, refetchAttachmentFile] = useAxiosGet(`${process.env.REACT_APP_PRODUCT_API_BASE}`, `UdpTransactionAttachment/${selectedAttachment?.transactionAttachmentId}/download`, { responseType: "blob" }, true);
+	const blobUrl = useMemo(() => {
+		if (!attachmentFile) return null;
+		const pdfBlob = new Blob([attachmentFile], { type: "application/pdf" });
+		return URL.createObjectURL(pdfBlob);
+	}, [attachmentFile]);
+	useEffect(() => {
+		if (selectedAttachment) {
+			refetchattachmentFileInfo();
+			refetchAttachmentFile();
+		}
+	}, [
+		selectedAttachment,
+		refetchattachmentFileInfo,
+		refetchAttachmentFile
+	]);
+	const getErrorMessage = () => {
+		if (!downloadError) return null;
+		const status = downloadError.response?.status;
+		if (status === 404) return t("The requested attachment could not be found.");
+		if (status >= 500) return t("A server error occured. Please try again later.");
+		return downloadError.message || t("An unexpected error occured.");
+	};
+	let fileDataObj = {
+		filePath: blobUrl,
+		fileExtension: attachmentFileInfo?.extension
+	};
+	const fixedHeight = "calc(100vh - 140px)";
+	const classStyles = makeStyles((theme) => ({
+		sidesheet: {
+			display: "flex",
+			flexDirection: "row",
+			flex: 1,
+			height: fixedHeight
+		},
+		attachmentListContainer: {
+			textAlign: "left",
+			width: "35%",
+			height: fixedHeight
+		},
+		attachmentListHeader: {
+			backgroundColor: "white",
+			justifyItems: "left",
+			paddingLeft: "5%"
+		},
+		attachmentListHeaderPrimaryText: {
+			fontSize: "var(--h6-font-size)",
+			fontWeight: "var(--body1-font-weight)",
+			color: "var(--text-main)"
+		},
+		attachmentListHeaderSecondaryText: {
+			fontSize: "var(--body2-font-size)",
+			color: "var(--text-secondary)",
+			paddingBottom: "2%"
+		},
+		attachemntFileInfoCol: {
+			width: "50%",
+			display: "flex",
+			flexDirection: "column",
+			flex: 1,
+			overflowY: "auto",
+			height: "calc(100vh - 50px)"
+		},
+		attachmentFileNameHeader: { backgroundColor: "white" },
+		attachmentFileName: {
+			color: "var(--text-main)",
+			fontSize: "var(--h6-font-size)",
+			fontWeight: "var(--body1-font-weight)",
+			marginTop: "1%",
+			marginBottom: "1%",
+			justifySelf: "center"
+		},
+		fileViewer: {
+			marginLeft: "var(--spacing-02)",
+			marginRight: "var(--spacing-02)"
+		},
+		divider: { "& MuiDivider-root": { backgroundColor: "var(--gray-02)" } }
+	}))();
+	useImperativeHandle(attachmentRef, () => ({ downloadSelectedFile: async () => {
+		if (!selectedAttachment) return;
+		try {
+			const url = (await apiMutate(ConfigService$1.productV1ApiUrl, `UdpTransactionAttachment/${selectedAttachment.transactionAttachmentId}/udpDriveFile/download`, {})).data.link;
+			const link = document.createElement("a");
+			link.href = url;
+			link.download = selectedAttachment.fileName ?? selectedAttachment.name;
+			document.body.appendChild(link);
+			link.click();
+			document.body.removeChild(link);
+		} catch (e) {
+			console.error("Download failed", e);
+		}
+	} }));
+	const handleOpenInNewTab = useCallback((e) => {
+		e?.preventDefault();
+		if (blobUrl) window.open(blobUrl, "_blank");
+	}, [blobUrl]);
+	const refetchAttachment = () => {
+		refetchattachmentFileInfo();
+		refetchAttachmentFile();
+	};
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("div", { className: classStyles.sidesheet }, /* @__PURE__ */ React.createElement("div", { className: classStyles.attachmentListContainer }, /* @__PURE__ */ React.createElement("div", { className: classStyles.attachmentListHeader }, /* @__PURE__ */ React.createElement("div", { className: classStyles.attachmentListHeaderPrimaryText }, "Attachments"), /* @__PURE__ */ React.createElement("div", { className: classStyles.attachmentListHeaderSecondaryText }, attachments.length + " file(s) attached")), /* @__PURE__ */ React.createElement("div", { className: classStyles.divider }, /* @__PURE__ */ React.createElement(Divider$1, null)), /* @__PURE__ */ React.createElement(AttachmentTransactionAttachmentList_default, {
+		transaction,
+		attachments,
+		setSelectedAttachment
+	})), /* @__PURE__ */ React.createElement("div", { className: classStyles.attachemntFileInfoCol }, /* @__PURE__ */ React.createElement("div", { className: classStyles.attachmentFileNameHeader }, selectedAttachment && /* @__PURE__ */ React.createElement("p", { className: classStyles.attachmentFileName }, selectedAttachment.attachmentName), /* @__PURE__ */ React.createElement("div", { className: classStyles.divider }, /* @__PURE__ */ React.createElement(Divider$1, null))), downloadError && /* @__PURE__ */ React.createElement(AmbientAlert, {
+		showAlert: !!downloadError,
+		alertSeverity: "error",
+		alertTitle: t("Failed to load preview"),
+		alertMessage: getErrorMessage(),
+		alertAction: true,
+		alertActionButton: t("Retry"),
+		alertHandleAction: () => refetchAttachment()
+	}), loadingFile && !downloadError ? /* @__PURE__ */ React.createElement(LinearProgress$1, null) : selectedAttachment && attachmentFileInfo && blobUrl ? /* @__PURE__ */ React.createElement("div", { className: classStyles.fileViewer }, /* @__PURE__ */ React.createElement(FileViewer, {
+		data: attachmentFileInfo?.extension == "pdf" ? fileDataObj : [fileDataObj],
+		onClickDownload: handleOpenInNewTab
+	})) : !selectedAttachment && /* @__PURE__ */ React.createElement(EmptyStateDisplay, {
+		icon: ViewIcon,
+		primaryText: "Select an attachment to preview",
+		secondaryText: "Choose a file from the attachments list to view its contents"
+	}))));
+};
+var AttachmentTransaction_default = AttachmentTransaction;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/components/UdpTransactionCustomPage.jsx
+const UdpTransactionCustomPage = (props) => {
+	const { pageId, transactionTypeId, transactionUiActionType, formRef, refetchTransaction, transaction, transactionTypeTransactionActionId, setHasUnsavedChanges, onSubmitSuccess } = props;
+	const { getUiActionRenderPageId, getHiddenFields, getRequiredFields } = useTransactionEngine(transactionTypeId);
+	const { handleErrorSnackbar, handleSuccessSnackbar } = useHandleAxiosSnackbar();
+	const { t } = useTranslation();
+	const executeCreateTransactionAction = useCallback(async (data) => apiMutate(ConfigService.productV1ApiUrl, `udpTransaction/transactionType/${transactionTypeId}/create`, { method: "post" }, data), [transactionTypeId]);
+	const executeSaveChanges = useCallback(async (data) => apiMutate(ConfigService.productV1ApiUrl, `udpTransaction/${transaction?.transactionId}/saveChanges`, { method: "put" }, data), [transaction?.transactionId]);
+	const executeCreateRevision = useCallback(async (data) => apiMutate(ConfigService.productV1ApiUrl, `udpTransaction/${transaction?.transactionId}/createRevision`, { method: "post" }, data), [transaction?.transactionId]);
+	const executeSubmitCustomAction = useCallback(async (data) => apiMutate(ConfigService.productV1ApiUrl, `udptransactiontypeTransactionAction/${transactionTypeTransactionActionId}/transaction/${transaction.transactionId}/submit`, { method: "post" }, data), [transactionTypeTransactionActionId, transaction?.transactionId]);
+	const onSubmit = useCallback(async (values) => {
+		try {
+			const request = { data: values };
+			let response = null;
+			let message = "";
+			let errorMessagePart = "";
+			if (transactionUiActionType === TransactionUiActionTypeEnums.Render_Create_Transaction_Page) {
+				response = await executeCreateTransactionAction(request);
+				message = "Transaction has been created successfully";
+				errorMessagePart = "creating";
+			} else if (transactionUiActionType === TransactionUiActionTypeEnums.Render_Transaction_Details_Page) {
+				response = await executeSaveChanges(request);
+				message = "Transaction has been saved successfully";
+				errorMessagePart = "saving";
+			} else if (transactionUiActionType === TransactionUiActionTypeEnums.Render_Create_Revision_Page) {
+				response = await executeCreateRevision(request);
+				message = "Revision has been created successfully";
+				errorMessagePart = "creating revision for";
+			} else if (!!transactionTypeTransactionActionId) {
+				response = await executeSubmitCustomAction(request);
+				message = "Action has been submitted successfully";
+				errorMessagePart = "submitting action for";
+			}
+			if (response?.status === 200) {
+				handleSuccessSnackbar(t(`${message} `));
+				onSubmitSuccess?.(response);
+			} else handleErrorSnackbar(new Error(t(`Error ${errorMessagePart} Transaction. Please try again later.`)));
+		} catch (error) {
+			handleErrorSnackbar(error);
+		} finally {
+			if (setHasUnsavedChanges) {
+				formRef.current?.form?.restart(values);
+				setHasUnsavedChanges(false);
+			}
+			if (refetchTransaction) refetchTransaction();
+		}
+	}, [
+		executeCreateTransactionAction,
+		executeSaveChanges,
+		executeCreateRevision,
+		handleErrorSnackbar,
+		handleSuccessSnackbar,
+		transactionUiActionType,
+		executeSubmitCustomAction,
+		t,
+		transactionTypeTransactionActionId,
+		setHasUnsavedChanges,
+		formRef,
+		onSubmitSuccess,
+		refetchTransaction
+	]);
+	const isFieldRequired = useCallback((fieldName) => {
+		return getRequiredFields(transaction)?.includes(fieldName);
+	}, [getRequiredFields, transaction]);
+	const isFieldHidden = useCallback((fieldName) => {
+		return getHiddenFields(transaction)?.includes(fieldName);
+	}, [getHiddenFields, transaction]);
+	const transactionPageId = useMemo(() => {
+		if (pageId) return pageId;
+		return getUiActionRenderPageId(transactionUiActionType);
+	}, [
+		getUiActionRenderPageId,
+		transactionUiActionType,
+		pageId
+	]);
+	if (!transactionPageId) return null;
+	return /* @__PURE__ */ React.createElement(Form, {
+		onSubmit,
+		ref: formRef
+	}, /* @__PURE__ */ React.createElement(FormSpy, { subscription: { dirty: true } }, ({ dirty }) => {
+		if (setHasUnsavedChanges) setHasUnsavedChanges(dirty);
+	}), /* @__PURE__ */ React.createElement(PageContainer, {
+		pageId: transactionPageId,
+		updateLocationState: false,
+		widgetParams: {
+			transaction,
+			isFieldRequired,
+			isFieldHidden
+		}
+	}));
+};
+var UdpTransactionCustomPage_default = UdpTransactionCustomPage;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/sidesheets/WorkflowActions.jsx
+const TransactionActionButton = ({ icon, primaryText, secondaryText, onClick, action }) => {
+	const actionCardIcon = useMemo(() => getIconFromName(icon), [icon]);
+	return /* @__PURE__ */ React.createElement(UdpActionCard, {
+		icon: actionCardIcon ? actionCardIcon : DocumentIcon,
+		primaryText,
+		secondaryText,
+		onClick: () => {
+			onClick(action);
+		}
+	});
+};
+const WorkflowActions = ({ transaction, closeSideSheet, refreshGridData }) => {
+	const [dialogOpen, setDialogOpen] = useState(true);
+	const [dialogUserStrings, setDialogUserStrings] = useState(null);
+	const [selectedAction, setSelectedAction] = useState(null);
+	const [sideSheetOpen, setSideSheetOpen] = useState(false);
+	const [loading, setLoading] = useState(false);
+	const formRef = useRef(null);
+	const { getTransactionTypeTransactionActions } = useTransactionEngine(transaction.transactionTypeId);
+	const handleOnCloseSideSheet = useCallback(() => {
+		setSideSheetOpen(false);
+	}, []);
+	const handleSubmitWorkflowAction = useCallback(async () => {
+		setLoading(true);
+		await formRef.current?.form?.submit();
+		setLoading(false);
+		handleOnCloseSideSheet();
+		closeSideSheet();
+		refreshGridData();
+	}, [
+		handleOnCloseSideSheet,
+		refreshGridData,
+		closeSideSheet,
+		formRef
+	]);
+	const transactionTypeTransactionActions = useMemo(() => {
+		return getTransactionTypeTransactionActions(transaction, TransactionEventTypeEnums.Sidesheet) || [];
+	}, [getTransactionTypeTransactionActions, transaction]);
+	const [{ data: transactionData }, postTransactionData] = useAxiosMutate(`${ConfigService$1.productV1ApiUrl}`, "udptransactiontypeTransactionAction", { method: "post" }, {});
+	const i18n = useTranslation().t;
+	const { enqueueSnackbar } = useSnackbar();
+	const handleDialogOpen = useCallback((title, message) => {
+		setDialogUserStrings({
+			title,
+			message
+		});
+		setDialogOpen(true);
+	}, []);
+	const handleDialogClose = useCallback(() => {
+		setDialogOpen(false);
+	}, []);
+	const handleConfirmActionDialog = useCallback(async () => {
+		setDialogOpen(true);
+		handleDialogClose();
+		setLoading(true);
+		try {
+			await postTransactionData({
+				url: `${ConfigService$1.productV1ApiUrl}/udptransactiontypeTransactionAction/${selectedAction.transactionTypeTransactionActionId}/transaction/${transaction.transactionId}/submit`,
+				data: {}
+			});
+			enqueueSnackbar(i18n("Successfully submitted!"), {
+				variant: "success",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+			closeSideSheet();
+			refreshGridData();
+		} catch (event) {
+			enqueueSnackbar(i18n(event.message), {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+		setLoading(false);
+	}, [
+		postTransactionData,
+		handleDialogClose,
+		transaction,
+		selectedAction,
+		enqueueSnackbar,
+		i18n,
+		closeSideSheet,
+		refreshGridData
+	]);
+	const handleOnActionClick = useCallback((action) => {
+		const pageId = action.parameters.pageId;
+		setSelectedAction(action);
+		if (pageId) setSideSheetOpen(true);
+		else handleDialogOpen(action.name, action.description);
+	}, [handleDialogOpen]);
+	const TransactionActionButtons = useMemo(() => {
+		if (!transactionTypeTransactionActions.length) return null;
+		return transactionTypeTransactionActions?.map((action) => /* @__PURE__ */ React.createElement(TransactionActionButton, {
+			key: action.transactionTypeTransactionActionId,
+			primaryText: action.name,
+			secondaryText: action.description,
+			icon: action.icon,
+			onClick: handleOnActionClick,
+			action
+		}));
+	}, [transactionTypeTransactionActions, handleOnActionClick]);
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("div", { className: "transaction-action-buttons-container" }, TransactionActionButtons), dialogUserStrings && /* @__PURE__ */ React.createElement(FluentDialog, {
+		title: i18n(`Are you sure you want to proceed with \"${dialogUserStrings.title}\"?`),
+		message: dialogUserStrings.message,
+		labelOne: i18n("Confirm"),
+		actionOne: handleConfirmActionDialog,
+		labelTwo: i18n("Cancel"),
+		actionTwo: handleDialogClose,
+		open: dialogOpen,
+		handleClose: handleDialogClose
+	}), /* @__PURE__ */ React.createElement(SideSheet, {
+		open: sideSheetOpen,
+		title: selectedAction?.name,
+		onClose: handleOnCloseSideSheet,
+		width: 600,
+		buttonLabel: i18n("Submit"),
+		onSubmit: handleSubmitWorkflowAction,
+		progress: loading,
+		variant: "indeterminate"
+	}, selectedAction && selectedAction.parameters?.pageId && /* @__PURE__ */ React.createElement(UdpTransactionCustomPage_default, {
+		pageId: selectedAction.parameters.pageId,
+		transaction,
+		formRef,
+		transactionTypeTransactionActionId: selectedAction.transactionTypeTransactionActionId
+	})));
+};
+var WorkflowActions_default = WorkflowActions;
+
+//#endregion
+//#region src/uploader/utils/allowedFileProperties.js
+const MAX_FILE_SIZE_MB = 30;
+const allowedExtensions = [
+	"pdf",
+	"xlsx",
+	"xls",
+	"xlsm",
+	"csv",
+	"jpg",
+	"jpeg",
+	"png",
+	"tif",
+	"tiff",
+	"doc",
+	"docx",
+	"docm",
+	"ppt",
+	"pptm",
+	"rtf"
+];
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/sidesheets/EditTransactionHeaderItem.jsx
+const EditTransactionHeaderItem = (props) => {
+	const { label, value, statusChip } = props;
+	return /* @__PURE__ */ React.createElement("div", { className: "transaction-sidesheet-header-item" }, /* @__PURE__ */ React.createElement(Typography$1, { variant: "caption" }, label), statusChip ? /* @__PURE__ */ React.createElement("div", { className: "transaction-sidesheet-header-item-status" }, /* @__PURE__ */ React.createElement(StatusChip, statusChip)) : /* @__PURE__ */ React.createElement(Typography$1, { variant: "body1" }, value));
+};
+var EditTransactionHeaderItem_default = EditTransactionHeaderItem;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/components/transactionHistory/TransactionTimelineItem.jsx
+const TransactionTimelineItem = (props) => {
+	const { title, description, date, status, onClick } = props;
+	return /* @__PURE__ */ React.createElement(UdpTimelineItem, {
+		dotShape: "default",
+		onItemClick: onClick,
+		clickable: true,
+		statusLabel: status
+	}, /* @__PURE__ */ React.createElement(UdpTimelineSeparator, { slot: "separator" }, /* @__PURE__ */ React.createElement(UdpTimelineConnector, null), /* @__PURE__ */ React.createElement(UdpTimelineDot, {
+		color: "primary",
+		shape: "default",
+		size: "medium"
+	})), /* @__PURE__ */ React.createElement("span", { slot: "title" }, title), /* @__PURE__ */ React.createElement("span", { slot: "content" }, date), /* @__PURE__ */ React.createElement("span", { slot: "caption" }, description));
+};
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/components/transactionHistory/TransactionTimeline.jsx
+const TransactionTimeline = forwardRef((props, ref) => {
+	const { transactionId } = props;
+	const { t } = useTranslation();
+	const searchObj = useMemo(() => {
+		return {
+			eagerLoad: true,
+			pageNumber: 0,
+			pageSize: 100,
+			filterElements: [{
+				searchField: "transactionId",
+				searchValue: transactionId,
+				searchOperator: "="
+			}],
+			orderElements: [{
+				sortColumn: "createdOn",
+				sortDirection: "desc"
+			}],
+			getAll: true
+		};
+	}, [transactionId]);
+	const [{ data: transactionHistory, loading: isLoading }, fetchTransactionHistory] = useAxiosMutate(ConfigService$1.productV1ApiUrl, `UdpTransactionHistory/search`, {
+		method: "post",
+		data: searchObj
+	});
+	useImperativeHandle(ref, () => ({ refresh: () => {
+		fetchTransactionHistory();
+	} }));
+	useEffect(() => {
+		fetchTransactionHistory();
+	}, [fetchTransactionHistory]);
+	return /* @__PURE__ */ React.createElement("div", null, isLoading ? /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(LinearProgress, null)) : transactionHistory?.pageList?.length > 0 ? /* @__PURE__ */ React.createElement(AmbientCard, null, /* @__PURE__ */ React.createElement(UdpTimeline, null, transactionHistory?.pageList?.map((item, index) => /* @__PURE__ */ React.createElement(TransactionTimelineItem, {
+		key: index,
+		title: item?.udpTransactionHistoryUdpTransactionTypeTransactionAction?.name ?? item?.udpTransactionHistoryUdpTransactionEventType?.name,
+		description: item?.changedByName ? `By ${item?.changedByName}` : null,
+		date: item?.createdOn ? formatDate(item?.createdOn, "dd/mm/yyyy") : null,
+		status: item?.udpTransactionHistoryUdpTransactionTypeStatus?.name
+	})))) : /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(EmptyStateDisplay, { primaryText: t("No History") })));
+});
+TransactionTimeline.displayName = "TransactionTimeline";
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/components/transactionAttachment/TransactionAttachment.jsx
+const TransactionAttachment = (props) => {
+	const { attachment, isLastItem } = props;
+	const [{ data: attachmentWithDownloadLink, loading: isLoading }] = useAxiosGet(ConfigService.productV1ApiUrl, `UdpTransactionAttachment/${attachment?.transactionAttachmentId}/udpDriveFile/download`, {}, !!!attachment?.transactionAttachmentId);
+	return /* @__PURE__ */ React.createElement(UdpAttachmentItem, {
+		loading: isLoading,
+		fileName: attachment?.fileName,
+		fileSize: attachment?.fileSize,
+		fileExtension: attachment?.extension,
+		uploadedBy: attachment?.updatedByName,
+		uploadedDate: attachment?.lastUpdated,
+		isLastItem,
+		downloadUrl: attachmentWithDownloadLink?.link
+	});
+};
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/components/transactionAttachment/TransactionAttachments.jsx
+const TransactionAttachments = (props) => {
+	const { transactionAttachments, isLoading } = props;
+	const { t } = useTranslation();
+	return /* @__PURE__ */ React.createElement("div", null, isLoading ? /* @__PURE__ */ React.createElement(LinearProgress, null) : transactionAttachments?.pageList?.length > 0 ? /* @__PURE__ */ React.createElement(AmbientCard, { fullWidth: true }, transactionAttachments.pageList.map((attachment, index) => /* @__PURE__ */ React.createElement(TransactionAttachment, {
+		key: index,
+		attachment,
+		isLastItem: index === transactionAttachments.pageList.length - 1
+	}))) : /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(EmptyStateDisplay, { primaryText: t("No Attachments") })));
+};
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/components/transactionNote/TransactionNote.jsx
+const useStyles$2 = makeStyles((theme) => ({
+	titleContainer: {
+		display: "flex",
+		gap: "8px",
+		justifyContent: "space-between",
+		alignItems: "center"
+	},
+	chipContainer: {
+		display: "flex",
+		gap: theme.spacing(1),
+		alignItems: "center",
+		marginTop: theme.spacing(1)
+	},
+	card: {
+		width: "100%",
+		cursor: "pointer",
+		"&:hover": { backgroundColor: "rgba(0, 0, 0, 0.04)" },
+		padding: "8px 12px",
+		border: "1px solid rgba(0, 0, 0, 0.08)"
+	},
+	captionText: { color: theme.palette.text.hint }
+}));
+const TransactionNote = (props) => {
+	const { onClick, note } = props;
+	const classes = useStyles$2();
+	return /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(AmbientCard, {
+		fullWidth: true,
+		adornment: "info",
+		noAdornment: false,
+		customAdornment: /* @__PURE__ */ React.createElement(Adornment, { color: "info" }),
+		removeTopLayoutUnit: true,
+		removePadding: true,
+		lastChildBottomPadding: "0px",
+		cardContentHeight: "100%"
+	}, /* @__PURE__ */ React.createElement("div", {
+		className: classes.card,
+		onClick
+	}, /* @__PURE__ */ React.createElement("div", { className: classes.titleContainer }, /* @__PURE__ */ React.createElement(Typography$1, { variant: "h6" }, note?.subject ?? "Transaction Note"), /* @__PURE__ */ React.createElement(Typography$1, {
+		variant: "caption",
+		className: classes.captionText
+	}, getLocalizedDateTimeString(note?.createdOn))), /* @__PURE__ */ React.createElement(Typography$1, { variant: "body1" }, note?.content ?? "This is a placeholder for the transaction note component."), /* @__PURE__ */ React.createElement("div", { className: classes.chipContainer }, /* @__PURE__ */ React.createElement(StatusChip, {
+		label: note?.userDisplayName,
+		color: "default",
+		variant: "outline",
+		icon: /* @__PURE__ */ React.createElement(ContactIcon, null)
+	})))));
+};
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/components/transactionNote/TransactionNoteForm.jsx
+const useStyles$1 = makeStyles((theme) => ({ loading: { marginBottom: theme.spacing(1) } }));
+const TransactionNoteFormComponent = (props, ref) => {
+	const { initialValues, viewOnly, businessObjectKey, closeSideSheet, noteTypes, fetchNoteTypesLoading } = props;
+	const [isLoading, setIsLoading] = useState(false);
+	const user = useAuthedUser();
+	const { handleSuccessSnackbar, handleErrorSnackbar } = useHandleAxiosSnackbar();
+	const { t } = useTranslation();
+	const classes = useStyles$1();
+	const addTransactionNote = useCallback(async (data) => apiMutate(ConfigService$1.productV1ApiUrl, `UdpNote`, { method: "post" }, data), []);
+	const addNoteFiledFor = useCallback(async (data) => apiMutate(ConfigService$1.productV1ApiUrl, `UdpNoteFiledFor`, { method: "post" }, data), []);
+	const handleSubmitForm = useCallback(async (values) => {
+		setIsLoading(true);
+		await addTransactionNote({ data: {
+			typeCode: values?.noteType?.code,
+			subject: values?.subject,
+			content: values?.content,
+			unityUserID: user?.id,
+			userDisplayName: user?.name ?? ""
+		} }).then(async (res) => {
+			console.log("Transaction Note response: ", { res });
+			if (res?.data?.id) await addNoteFiledFor({ data: {
+				entityBusinessKey: businessObjectKey,
+				noteId: res?.data?.id
+			} }).then(() => {
+				handleSuccessSnackbar(t("Transaction note has been added successfully."));
+				if (closeSideSheet) closeSideSheet();
+			});
+		}).catch((res) => {
+			handleErrorSnackbar(res, t("Unable to add transaction note."));
+		});
+		setIsLoading(false);
+	}, [
+		addNoteFiledFor,
+		addTransactionNote,
+		businessObjectKey,
+		handleErrorSnackbar,
+		handleSuccessSnackbar,
+		t,
+		user,
+		closeSideSheet
+	]);
+	return /* @__PURE__ */ React.createElement("div", null, fetchNoteTypesLoading ? /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(LinearProgress$1, null)) : /* @__PURE__ */ React.createElement("div", null, isLoading && /* @__PURE__ */ React.createElement("div", { className: classes.loading }, /* @__PURE__ */ React.createElement(LinearProgress$1, null)), /* @__PURE__ */ React.createElement(Form, {
+		ref,
+		onSubmit: handleSubmitForm,
+		initialValues,
+		id: `transactionNoteForm-${businessObjectKey}`,
+		render: ({ submitting }) => /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Field, {
+			component: FluentTextFieldAutoComplete,
+			id: "noteType",
+			name: "noteType",
+			optionKey: "name",
+			disableClearable: true,
+			label: t("Type"),
+			options: noteTypes ?? [],
+			disabled: viewOnly || submitting,
+			onChange: () => {},
+			required: true
+		}), /* @__PURE__ */ React.createElement(Field, {
+			component: FluentTextField,
+			id: "subject",
+			name: "subject",
+			label: t("Subject"),
+			disabled: viewOnly || submitting,
+			onChange: () => {},
+			required: true
+		}), /* @__PURE__ */ React.createElement(Field, {
+			component: FluentTextField,
+			id: "content",
+			name: "content",
+			label: t("Details"),
+			onChange: () => {},
+			multiline: true,
+			rows: 5,
+			maxRows: 10,
+			disabled: viewOnly || submitting,
+			required: true
+		}), viewOnly && /* @__PURE__ */ React.createElement(Typography$1, { variant: "caption" }, t("Viewing note details. Use the Add Note action to create a new entry.")))
+	})));
+};
+const TransactionNoteForm = forwardRef(TransactionNoteFormComponent);
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/components/transactionNote/TransactionNotes.jsx
+const useStyles = makeStyles((theme) => ({ notes: {
+	display: "flex",
+	flexDirection: "column",
+	gap: theme.spacing(1)
+} }));
+const TransactionNotes = (props) => {
+	const { businessObjectKey, refreshNotes, setRefreshNotes, noteTypes, fetchNoteTypesLoading } = props;
+	const [openSideSheet, setOpenSideSheet] = useState(false);
+	const [selectedNote, setSelectedNote] = useState(null);
+	const [noteList, setNoteList] = useState([]);
+	const classes = useStyles();
+	const { t } = useTranslation();
+	const [isLoading, setIsLoading] = useState(false);
+	const noteFileForSearchObj = useMemo(() => {
+		return {
+			eagerLoad: true,
+			pageNumber: 0,
+			pageSize: 100,
+			filterElements: [{
+				searchField: "entityBusinessKey",
+				searchValue: businessObjectKey,
+				searchOperator: "="
+			}],
+			getAll: true
+		};
+	}, [businessObjectKey]);
+	const [{ data: noteFiledFor, loading: fetchNoteFiledForLoading }, fetchNoteFiledFor] = useAxiosMutate(ConfigService$1.productV1ApiUrl, `UdpNoteFiledFor/search`, {
+		method: "post",
+		data: noteFileForSearchObj
+	});
+	const handleViewNote = useCallback((note) => {
+		setSelectedNote(note);
+		setOpenSideSheet(true);
+	}, []);
+	const handleCloseSideSheet = useCallback(() => {
+		setOpenSideSheet(false);
+		setSelectedNote(null);
+	}, []);
+	useEffect(() => {
+		fetchNoteFiledFor();
+	}, [fetchNoteFiledFor]);
+	useEffect(() => {
+		if (refreshNotes) {
+			fetchNoteFiledFor();
+			setRefreshNotes(false);
+		}
+	}, [
+		fetchNoteFiledFor,
+		refreshNotes,
+		setRefreshNotes
+	]);
+	useEffect(() => {
+		if (!fetchNoteFiledForLoading && noteFiledFor?.pageList?.length > 0) {
+			const searchObj = {
+				eagerLoad: true,
+				pageNumber: 0,
+				pageSize: 100,
+				filterElements: [{
+					searchField: "iD",
+					searchValue: noteFiledFor?.pageList?.map((obj) => obj?.noteID).join(","),
+					searchOperator: "IN"
+				}],
+				getAll: true
+			};
+			setIsLoading(true);
+			apiMutate(ConfigService$1.productV1ApiUrl, `UdpNote/search`, {
+				method: "post",
+				data: searchObj
+			}, {}).then((resp) => {
+				if (resp && resp.data) setNoteList(resp.data?.pageList);
+				else setNoteList([]);
+			}).finally(() => {
+				setIsLoading(false);
+			});
+		} else setNoteList([]);
+	}, [
+		fetchNoteFiledForLoading,
+		noteFiledFor,
+		setIsLoading
+	]);
+	return /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("div", { className: classes.notes }, isLoading || fetchNoteFiledForLoading ? /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(LinearProgress$1, null)) : noteList?.length > 0 ? noteList.map((note, index) => /* @__PURE__ */ React.createElement(TransactionNote, {
+		key: index,
+		note,
+		onClick: () => handleViewNote(note)
+	})) : /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(EmptyStateDisplay, { primaryText: "No Notes" }))), /* @__PURE__ */ React.createElement(SideSheet, {
+		title: t("View Note"),
+		width: 600,
+		open: openSideSheet,
+		onClose: handleCloseSideSheet
+	}, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(TransactionNoteForm, {
+		initialValues: selectedNote,
+		businessObjectKey,
+		viewOnly: true,
+		noteTypes,
+		fetchNoteTypeLoading: fetchNoteTypesLoading
+	}))));
+};
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/sidesheets/enum.ts
+let TRANSACTION_TAB = /* @__PURE__ */ function(TRANSACTION_TAB$1) {
+	TRANSACTION_TAB$1[TRANSACTION_TAB$1["DETAILS"] = 0] = "DETAILS";
+	TRANSACTION_TAB$1[TRANSACTION_TAB$1["HISTORY"] = 1] = "HISTORY";
+	TRANSACTION_TAB$1[TRANSACTION_TAB$1["ATTACHMENTS"] = 2] = "ATTACHMENTS";
+	TRANSACTION_TAB$1[TRANSACTION_TAB$1["NOTES"] = 3] = "NOTES";
+	return TRANSACTION_TAB$1;
+}({});
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/components/EditTransactionDetailsFooterItem.jsx
+const EditTransactionDetailsFooterItem = (props) => {
+	const { transactionTypeId, transactionIsClosed, handleOnCancel, handleOnSaveChanges } = props;
+	const { hasRevisions } = useTransactionEngine(transactionTypeId);
+	const { t } = useTranslation();
+	return /* @__PURE__ */ React.createElement("div", { className: "transaction-details-footer-item" }, /* @__PURE__ */ React.createElement(FluentButton, {
+		color: "primary",
+		onClick: handleOnCancel
+	}, t("Cancel")), !transactionIsClosed && /* @__PURE__ */ React.createElement(FluentButton, {
+		variant: "contained",
+		color: "primary",
+		onClick: handleOnSaveChanges
+	}, t("Save Changes")));
+};
+var EditTransactionDetailsFooterItem_default = EditTransactionDetailsFooterItem;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/components/EditTransactionDetailsFormFields.jsx
+const EditTransactionDetailsFormFields = (props) => {
+	const { transaction, fieldAttributes } = props;
+	const { t } = useTranslation();
+	const { getHiddenFields, getRequiredFields } = useTransactionEngine(transaction.transactionTypeId);
+	const fieldComponentMap = {
+		string: AmbientTextField,
+		datetime: AmbientTextField,
+		number: AmbientTextField,
+		bool: Switch,
+		array: AmbientAutoComplete
+	};
+	const getEntityName = (optionValuesArr, entityId) => {
+		return (optionValuesArr?.find((entity) => entity.id == entityId))?.name;
+	};
+	const numberDataTypes = [
+		"int",
+		"short",
+		"long"
+	];
+	const removeTimeFormatDate = (date) => {
+		const parsedDate = new Date(date);
+		if (parsedDate.getTime()) {
+			const year = parsedDate.getFullYear();
+			const month = parsedDate.getMonth() + 1;
+			const day = parsedDate.getDate().toString().padStart(2, "0");
+			return `${year}-${month.toString().padStart(2, "0")}-${day}`;
+		}
+		return parsedDate;
+	};
+	const dataTypeComponentMap = (transaction$1, attribute) => {
+		const fieldName = attribute.name;
+		let fieldDataType = attribute.type.toLowerCase();
+		fieldDataType = numberDataTypes.includes(fieldDataType) ? "number" : fieldDataType;
+		const isAsscoiationLabel = attribute.associationLabel;
+		let fieldComponentProps = null;
+		switch (fieldDataType) {
+			case "number":
+				fieldComponentProps = {
+					initialValue: transaction$1.entityBusinessObject[fieldName],
+					type: "number",
+					InputProps: { inputProps: { min: 0 } }
+				};
+				break;
+			case "datetime":
+				fieldComponentProps = {
+					initialValue: removeTimeFormatDate(transaction$1.entityBusinessObject[fieldName]),
+					type: "date"
+				};
+				break;
+			case "array":
+				fieldComponentProps = {
+					options: attribute?.options?.map((option) => option.id),
+					getOptionLabelFunction: (option) => getEntityName(attribute?.options, option) || option,
+					initialValue: transaction$1.entityBusinessObject[fieldName]
+				};
+				break;
+			case "bool":
+				fieldComponentProps = {
+					type: "checkbox",
+					initialValue: false
+				};
+				break;
+			default: fieldComponentProps = { initialValue: transaction$1.entityBusinessObject[fieldName] };
+		}
+		const formLabel = isAsscoiationLabel ? fieldName + " Name" : fieldName;
+		const isRequired = getRequiredFields(transaction$1).includes(fieldName) || attribute.required;
+		const isHidden = getHiddenFields(transaction$1).includes(fieldName) || attribute.isPrimaryKey || !attribute.extendedProperties.defaultVisible;
+		let fieldComponent = /* @__PURE__ */ React.createElement(Field, {
+			component: fieldComponentMap[fieldDataType] ?? AmbientTextField,
+			label: t(formLabel),
+			name: fieldName,
+			fullWidth: true,
+			variant: "outlined",
+			margin: "normal",
+			disabled: attribute.isReadOnly,
+			required: isRequired && fieldDataType != "bool",
+			...fieldComponentProps
+		});
+		return /* @__PURE__ */ React.createElement(React.Fragment, null, !isHidden && (fieldDataType == "bool" ? /* @__PURE__ */ React.createElement(FormControlLabel, {
+			control: fieldComponent,
+			label: formLabel
+		}) : fieldComponent));
+	};
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, fieldAttributes.map((attribute) => {
+		return /* @__PURE__ */ React.createElement(React.Fragment, null, dataTypeComponentMap(transaction, attribute));
+	}));
+};
+var EditTransactionDetailsFormFields_default = EditTransactionDetailsFormFields;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/components/EditTransactionDetailsForm.jsx
+const EditTransactionDetailsForm = (props) => {
+	const { transaction, formRef } = props;
+	const [entityAttributes, setEntityAttributes] = useState(null);
+	const fullyQualifiedName = transaction.entityBusinessKey?.split("|")[0];
+	const { handleErrorSnackbar, handleSuccessSnackbar } = useHandleAxiosSnackbar();
+	const { t } = useTranslation();
+	const { currentApiCatalogId, catalogsMap } = useCatalogStore();
+	const catalogObjectList = useMemo(() => {
+		if (catalogsMap && currentApiCatalogId && catalogsMap[currentApiCatalogId]) return catalogsMap[currentApiCatalogId]?.ctlg?.catalogObjectList;
+	}, [catalogsMap, currentApiCatalogId]);
+	const [{ data: udpObjectInfo }, fetchUdpObjectInfo] = useAxiosMutate(ConfigService$1.productV1ApiUrl, `UdpObjectInfo/search`, {
+		method: "post",
+		data: {
+			eagerLoad: true,
+			pageNumber: 1,
+			pageSize: 50,
+			filterElements: [{
+				searchField: "sanitizedName",
+				searchOperator: "=",
+				searchValue: getSanitizedName(fullyQualifiedName)
+			}]
+		}
+	});
+	const updateFieldInfo = (tableEntries, catalogObjectFieldInfo, fkFieldInfo, fkDomainName) => {
+		let updatedFields = {
+			type: "array",
+			options: tableEntries,
+			domainName: fkDomainName
+		};
+		const updatedFieldInfo = {
+			...fkFieldInfo,
+			...updatedFields
+		};
+		const index = catalogObjectFieldInfo.findIndex((f) => f.name.toLowerCase() === fkFieldInfo.name.toLowerCase());
+		if (index != -1) catalogObjectFieldInfo[index] = updatedFieldInfo;
+	};
+	const mergeCatalogObjectInfoFieldInfo = useCallback((entityCatalogObjectInfo, filteredEntityFieldInfo) => {
+		return entityCatalogObjectInfo.map((entityCatalogObject) => {
+			let matchingEntityFieldInfo = filteredEntityFieldInfo.find((fieldInfo) => {
+				let formattedFieldName = fieldInfo.name.slice(0, 1).toLowerCase() + fieldInfo.name.slice(1);
+				if (fieldInfo.name == "ID") formattedFieldName = formattedFieldName.toLowerCase();
+				return formattedFieldName == entityCatalogObject.name;
+			});
+			if (matchingEntityFieldInfo) {
+				let additional_fields = {
+					hidden: matchingEntityFieldInfo.properties.maintainenceConfig.hidden,
+					associationLabel: matchingEntityFieldInfo.properties.maintainenceConfig.associationLabel,
+					isPrimaryKey: matchingEntityFieldInfo.isPrimaryKey
+				};
+				return {
+					...entityCatalogObject,
+					...additional_fields
+				};
+			} else return entityCatalogObject;
+		});
+	}, []);
+	const filterOutManyToManyRelationships = (CatalogObjectInfo) => {
+		return CatalogObjectInfo.filter((catalogObject) => {
+			const cardinality = catalogObject.extendedProperties?.childEntityAssoc?.Cardinality;
+			if (cardinality != void 0) return cardinality != CardinalityTypeEnums.Many_To_Many && cardinality != CardinalityTypeEnums.One_To_One && catalogObject.name.toLowerCase() != "businessobjectkey";
+			else return catalogObject.name.toLowerCase() != "businessobjectkey";
+		});
+	};
+	const updateFkFields = useCallback(async (entityCatalogObjectInfo, catalogObjectInfo) => {
+		const childEntityAssociation = catalogObjectInfo.extendedProperties.childEntityAssoc;
+		if (childEntityAssociation.Cardinality != void 0) {
+			const foreignKeyAssociationFields = childEntityAssociation.Keys[0].split(",");
+			let fieldsInAssociationToIgnore = [
+				"id",
+				"businessobjectkey",
+				"entitybusinesskey"
+			];
+			return Promise.all(foreignKeyAssociationFields.map(async (fkFieldName) => {
+				if (fkFieldName.toLowerCase() != "id" && !fieldsInAssociationToIgnore.includes(fkFieldName.toLowerCase())) {
+					let fkFieldInfo = entityCatalogObjectInfo.find((field) => field.name.toLowerCase() == fkFieldName.toLowerCase());
+					const fkDomainName = getSanitizedName(childEntityAssociation.TargetType);
+					try {
+						const getTableEntriesResp = await apiMutate(ConfigService$1.productV1ApiUrl, `${fkDomainName}`, { method: "get" });
+						if (getTableEntriesResp.data.length > 0 && fkFieldInfo) updateFieldInfo(getTableEntriesResp.data, entityCatalogObjectInfo, fkFieldInfo, fkDomainName);
+					} catch (error) {
+						handleErrorSnackbar(new Error(t(`Error finiding field information! Please try again.`)));
+					}
+				}
+			}));
+		}
+	}, [handleErrorSnackbar, t]);
+	const filterAdjustEntityAttributes = useCallback(async (catalogObjectInfo) => {
+		let entityCatalogObjectInfo = catalogObjectInfo;
+		entityCatalogObjectInfo = filterOutManyToManyRelationships(entityCatalogObjectInfo);
+		let filteredEntityFieldInfo = (await fetchUdpObjectInfo()).data.pageList[0].objectFieldInfo.filter((fieldInfo) => fieldInfo.properties.isDefaultVisible);
+		await Promise.all(entityCatalogObjectInfo.map((catalogObjectInfo$1) => {
+			return updateFkFields(entityCatalogObjectInfo, catalogObjectInfo$1);
+		}));
+		entityCatalogObjectInfo = entityCatalogObjectInfo.filter((catalogObject) => !catalogObject.extendedProperties.childEntity);
+		return mergeCatalogObjectInfoFieldInfo(entityCatalogObjectInfo, filteredEntityFieldInfo);
+	}, [
+		fetchUdpObjectInfo,
+		mergeCatalogObjectInfoFieldInfo,
+		updateFkFields
+	]);
+	useEffect(() => {
+		if (catalogObjectList) {
+			let domainName = transaction.entityBusinessKey.split("|")[0].split(".").pop();
+			let domainCatalogObject = catalogObjectList?.find((catalogObject) => getSanitizedName(catalogObject.catalogObjectName) == domainName);
+			if (domainCatalogObject) filterAdjustEntityAttributes(domainCatalogObject.properties).then((filteredResp) => {
+				setEntityAttributes(filteredResp);
+			});
+		}
+	}, [
+		filterAdjustEntityAttributes,
+		catalogObjectList,
+		transaction
+	]);
+	const executeSaveChanges = useCallback(async (data) => apiMutate(ConfigService$1.productV1ApiUrl, `udpTransaction/${transaction?.transactionId}/saveChanges`, { method: "put" }, data), [transaction.transactionId]);
+	const onSubmit = useCallback(async (values) => {
+		if ((await executeSaveChanges({ data: values }))?.status === 200) handleSuccessSnackbar(t("Transaction has been saved successfully"));
+		else handleErrorSnackbar(new Error(t(`Error saving Transaction. Please try again later.`)));
+	}, [
+		executeSaveChanges,
+		handleSuccessSnackbar,
+		handleErrorSnackbar,
+		t
+	]);
+	const fieldAttributes = useMemo(() => {
+		if (!entityAttributes) return [];
+		return entityAttributes;
+	}, [entityAttributes]);
+	return fieldAttributes.length == 0 ? /* @__PURE__ */ React.createElement(LinearProgress, null) : /* @__PURE__ */ React.createElement(AmbientCard, null, /* @__PURE__ */ React.createElement(Form, {
+		onSubmit,
+		ref: formRef
+	}, /* @__PURE__ */ React.createElement(EditTransactionDetailsFormFields_default, {
+		transaction,
+		fieldAttributes
+	})));
+};
+var EditTransactionDetailsForm_default = EditTransactionDetailsForm;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/sidesheets/EditTransaction.jsx
+const EditTransaction = (props) => {
+	const { transaction: initialTransaction, transactionTypeId, transactionIsClosed, openInnerSidesheetState, setOpenInnerSidesheetState, refreshGridData, closeSideSheet, setSidesheetLoading, setHasUnsavedChanges, attachmentType, setAttachmentType, currentAttachments, setCurrentAttachments, attachmentProgress, setAttachmentProgress, transactionAttachmentTypes, transactionAttachments, setTransactionAttachments, filePreview, setFilePreview } = props;
+	const { t } = useTranslation();
+	const [selectedTab, setSelectedTab] = useState(0);
+	const [transaction, setTransaction] = useState(initialTransaction);
+	const [refreshNotes, setRefreshNotes] = useState(false);
+	const [{ data: noteTypes, loading: fetchNoteTypesLoading }] = useAxiosGet(ConfigService$1.productV1ApiUrl, `UdpNoteType`, {});
+	const { getUiActionRenderPageId, transactionTypeStatusColorsMap } = useTransactionEngine(transactionTypeId);
+	const refetchTransaction = useCallback(async () => {
+		setSidesheetLoading(true);
+		const response = await apiMutate(ConfigService$1.productV1ApiUrl, `udpTransaction/${initialTransaction.transactionId}/full`, { method: "get" });
+		if (response?.status === 200) {
+			setTransaction(response.data);
+			transactionTimelineRef.current?.refresh();
+		}
+		setSidesheetLoading(false);
+	}, [initialTransaction.transactionId, setSidesheetLoading]);
+	const formRef = useRef(null);
+	const transactionNoteFormRef = useRef(null);
+	const transactionTimelineRef = useRef();
+	const handleNoteFormSubmit = useCallback(() => {
+		transactionNoteFormRef.current?.handleSubmit?.();
+	}, []);
+	const handleNoteFormReset = useCallback(() => {
+		transactionNoteFormRef.current?.form?.reset?.();
+	}, []);
+	const handleSaveChanges = useCallback(async () => {
+		setSidesheetLoading(true);
+		await formRef.current?.form?.submit();
+		setSidesheetLoading(false);
+		refreshGridData();
+	}, [
+		refreshGridData,
+		setSidesheetLoading,
+		formRef
+	]);
+	const [{ data: transactionAttachmentsData, loading: fetchTransactionAttachmentsLoading }, fetchTransactionAttachments] = useAxiosMutate(ConfigService$1.productV1ApiUrl, `UdpTransactionAttachment/search`, {
+		method: "post",
+		data: {
+			pageSize: 50,
+			filterElements: [{
+				searchField: "TransactionId",
+				searchValue: transaction.transactionId,
+				searchOperator: "="
+			}, {
+				searchField: "IsDeleted",
+				searchValue: 0,
+				searchOperator: "="
+			}]
+		}
+	});
+	const { enqueueSnackbar } = useSnackbar();
+	const getAttachments = useCallback(async () => {
+		try {
+			setTransactionAttachments((await fetchTransactionAttachments()).data.pageList);
+			refetchTransaction();
+		} catch (error) {
+			console.error("Failed to fetch attachments:", error);
+			if (error?.message !== "canceled") enqueueSnackbar("Attachment fetch failed: We encountered a system error. Please try again or contact support if the issue persists.", {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+	}, [
+		fetchTransactionAttachments,
+		enqueueSnackbar,
+		refetchTransaction,
+		setTransactionAttachments
+	]);
+	const tabNames = [
+		t("Details"),
+		t("History"),
+		t("Attachments"),
+		t("Notes")
+	];
+	const headerItemInfo = useMemo(() => {
+		const items = [{
+			label: "Status",
+			statusChip: {
+				label: transaction.udpTransactionUdpTransactionTypeStatus?.name,
+				status: transactionTypeStatusColorsMap[transaction.udpTransactionUdpTransactionTypeStatus?.name] || "default"
+			}
+		}];
+		if (transaction?.currentRevisionNo) items.push({
+			label: "Revision",
+			value: `${transaction.currentRevisionNo}`
+		});
+		return items;
+	}, [transaction, transactionTypeStatusColorsMap]);
+	const handleUploadFiles = useCallback(async () => {
+		if (!currentAttachments.length) throw new Error("No files added for upload");
+		const formData = new FormData();
+		currentAttachments.forEach((file) => formData.append("files", file));
+		formData.append("attachmentTypeId", attachmentType.transactionAttachmentTypeId);
+		try {
+			setAttachmentProgress(true);
+			await apiMutate(ConfigService$1.productV1ApiUrl, `UdpTransactionAttachment/transaction/${transaction.transactionId}/upload`, {
+				method: "post",
+				headers: {
+					transactionId: transaction.transactionId,
+					attachmentTypeId: attachmentType.transactionAttachmentTypeId
+				},
+				data: formData
+			});
+			await getAttachments();
+			setCurrentAttachments([]);
+			setOpenInnerSidesheetState({ attachments: false });
+			enqueueSnackbar("Files uploaded successfully", {
+				variant: "success",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		} catch (error) {
+			enqueueSnackbar(`File upload failed: We encountered a system error. Please try again or contact support if the issue persists.`, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+			throw error;
+		} finally {
+			setAttachmentProgress(false);
+		}
+	}, [
+		attachmentType,
+		currentAttachments,
+		enqueueSnackbar,
+		getAttachments,
+		setOpenInnerSidesheetState,
+		transaction.transactionId,
+		setCurrentAttachments,
+		setAttachmentProgress
+	]);
+	const innerSidesheetList = useMemo(() => [
+		{
+			open: openInnerSidesheetState.workflowAction,
+			closeSheet: () => setOpenInnerSidesheetState({ workflowActions: false }),
+			title: "Available Workflow Actions",
+			children: /* @__PURE__ */ React.createElement(WorkflowActions_default, {
+				transaction,
+				closeSideSheet: () => {
+					setOpenInnerSidesheetState({ workflowActions: false });
+					refetchTransaction();
+				},
+				refreshGridData
+			})
+		},
+		{
+			open: openInnerSidesheetState.attachments,
+			closeSheet: () => setOpenInnerSidesheetState({ attachments: false }),
+			title: "Add Attachment",
+			buttonLabel: "Save",
+			buttonOneDisabled: !attachmentType || currentAttachments.length <= 0,
+			onSubmit: () => {
+				handleUploadFiles().then(() => refreshGridData()).catch((error) => console.error(error));
+			},
+			children: /* @__PURE__ */ React.createElement(Attachments, {
+				attachmentTypes: transactionAttachmentTypes,
+				attachmentType,
+				setAttachmentType,
+				attachmentProgress,
+				setAttachmentProgress,
+				currentAttachments,
+				setCurrentAttachments,
+				transaction,
+				previousAttachments: transactionAttachments,
+				setPreviousAttachments: setTransactionAttachments,
+				MAX_FILE_SIZE_MB,
+				allowedExtensions,
+				filePreview,
+				setFilePreview
+			})
+		},
+		{
+			open: openInnerSidesheetState.notes,
+			closeSheet: () => setOpenInnerSidesheetState({ notes: false }),
+			title: "Add Note",
+			buttonLabel: "Save note",
+			buttonTwoLabel: "Clear",
+			buttonTwoAction: handleNoteFormReset,
+			onSubmit: handleNoteFormSubmit,
+			children: /* @__PURE__ */ React.createElement(TransactionNoteForm, {
+				ref: transactionNoteFormRef,
+				businessObjectKey: transaction?.businessObjectKey,
+				closeSideSheet: () => {
+					setOpenInnerSidesheetState({ notes: false });
+					setRefreshNotes(true);
+				},
+				noteTypes,
+				fetchNoteTypesLoading
+			})
+		}
+	], [
+		openInnerSidesheetState.workflowAction,
+		openInnerSidesheetState.attachments,
+		openInnerSidesheetState.notes,
+		transaction,
+		refreshGridData,
+		attachmentType,
+		currentAttachments,
+		transactionAttachmentTypes,
+		attachmentProgress,
+		transactionAttachments,
+		filePreview,
+		handleNoteFormReset,
+		handleNoteFormSubmit,
+		noteTypes,
+		fetchNoteTypesLoading,
+		setOpenInnerSidesheetState,
+		refetchTransaction,
+		handleUploadFiles,
+		setAttachmentType,
+		setCurrentAttachments,
+		setAttachmentProgress,
+		setTransactionAttachments,
+		setFilePreview
+	]);
+	const transactionDetailPageId = useMemo(() => {
+		return getUiActionRenderPageId(TransactionUiActionTypeEnums.Render_Transaction_Details_Page);
+	}, [getUiActionRenderPageId]);
+	useEffect(() => {
+		(async () => {
+			if (!transactionAttachmentsData) getAttachments();
+		})();
+	}, [transactionAttachmentsData, getAttachments]);
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("div", { className: "edit-transaction-sidesheet" }, /* @__PURE__ */ React.createElement("div", { className: `edit-transaction-sidesheet-header 'is-sticky'` }, /* @__PURE__ */ React.createElement("div", { className: "edit-transaction-sidesheet-header-title" }), /* @__PURE__ */ React.createElement("div", { className: "edit-transaction-sidesheet-header-content" }, /* @__PURE__ */ React.createElement("div", { className: "edit-transaction-sidesheet-header-items" }, headerItemInfo.map((headerItem) => {
+		return /* @__PURE__ */ React.createElement(EditTransactionHeaderItem_default, {
+			key: headerItem.label,
+			label: headerItem.label,
+			statusChip: headerItem.statusChip,
+			value: headerItem.value
+		});
+	})), /* @__PURE__ */ React.createElement("div", { className: "edit-transaction-sidesheet-header-buttons" }, /* @__PURE__ */ React.createElement(FluentButton, {
+		color: "primary",
+		onClick: () => {
+			setOpenInnerSidesheetState({ attachments: true });
+		}
+	}, /* @__PURE__ */ React.createElement(FluentIcon, {
+		component: AddIcon,
+		className: "edit-transaction-header-button-icon",
+		size: "small"
+	}), "Attachment"), /* @__PURE__ */ React.createElement(FluentButton, {
+		color: "primary",
+		onClick: () => {
+			setOpenInnerSidesheetState({ notes: true });
+		}
+	}, /* @__PURE__ */ React.createElement(FluentIcon, {
+		component: AddIcon,
+		className: "edit-transaction-header-button-icon",
+		size: "small"
+	}), "Note")), /* @__PURE__ */ React.createElement("div", { className: "divider" }, /* @__PURE__ */ React.createElement(Divider$1, null)), /* @__PURE__ */ React.createElement("div", { className: "edit-transaction-sidesheet-tabs" }, /* @__PURE__ */ React.createElement(UdpTabs, {
+		value: selectedTab,
+		onChange: (value, tabIndex) => {
+			setSelectedTab(tabIndex);
+		},
+		tabList: tabNames.map((tabName) => ({ label: tabName })),
+		buttonWidth: "100%"
+	}))), /* @__PURE__ */ React.createElement("div", { className: "divider" }, /* @__PURE__ */ React.createElement(Divider$1, null))), /* @__PURE__ */ React.createElement("div", { className: "edit-transaction-sidesheet-body" }, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(UdpTabPanel, {
+		value: selectedTab,
+		index: TRANSACTION_TAB.DETAILS
+	}, transactionDetailPageId ? /* @__PURE__ */ React.createElement(UdpTransactionCustomPage_default, {
+		transactionTypeId,
+		transactionUiActionType: TransactionUiActionTypeEnums.Render_Transaction_Details_Page,
+		formRef,
+		transaction,
+		refetchTransaction,
+		setHasUnsavedChanges
+	}) : /* @__PURE__ */ React.createElement(EditTransactionDetailsForm_default, {
+		transaction,
+		formRef
+	})), /* @__PURE__ */ React.createElement(UdpTabPanel, {
+		value: selectedTab,
+		index: TRANSACTION_TAB.HISTORY
+	}, /* @__PURE__ */ React.createElement(TransactionTimeline, {
+		ref: transactionTimelineRef,
+		transactionId: transaction?.transactionId
+	})), /* @__PURE__ */ React.createElement(UdpTabPanel, {
+		value: selectedTab,
+		index: TRANSACTION_TAB.ATTACHMENTS
+	}, /* @__PURE__ */ React.createElement(TransactionAttachments, {
+		transactionAttachments: transactionAttachmentsData,
+		isLoading: fetchTransactionAttachmentsLoading
+	})), /* @__PURE__ */ React.createElement(UdpTabPanel, {
+		value: selectedTab,
+		index: TRANSACTION_TAB.NOTES
+	}, /* @__PURE__ */ React.createElement(TransactionNotes, {
+		businessObjectKey: transaction?.businessObjectKey,
+		refreshNotes,
+		setRefreshNotes,
+		noteTypes,
+		fetchNoteTypeLoading: fetchNoteTypesLoading
+	})))), selectedTab == TRANSACTION_TAB.DETAILS && /* @__PURE__ */ React.createElement("div", { className: "edit-transaction-sidesheet-footer" }, /* @__PURE__ */ React.createElement(EditTransactionDetailsFooterItem_default, {
+		transactionTypeId,
+		transactionIsClosed,
+		handleOnCancel: closeSideSheet,
+		handleOnSaveChanges: handleSaveChanges
+	}))), openInnerSidesheetState && innerSidesheetList.map((item) => {
+		return /* @__PURE__ */ React.createElement(SideSheet, {
+			key: item.title,
+			open: item.open,
+			width: 600,
+			title: item.title,
+			onClose: item.closeSheet,
+			buttonLabel: item?.buttonLabel,
+			buttonOneDisabled: item?.buttonOneDisabled,
+			buttonTwoLabel: item?.buttonTwoLabel,
+			buttonTwoAction: item?.buttonTwoAction,
+			onSubmit: item?.onSubmit,
+			color: "primary"
+		}, item.children);
+	}));
+};
+var EditTransaction_default = EditTransaction;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/UdpTransactionSidesheet.jsx
+const UdpTransactionSidesheet = (props) => {
+	const { openStates, handleSidesheet, handleAttachmentTransaction, transaction, transactionTypeId, domainName, refreshGridData } = props;
+	const [sidesheetLoading, setSidesheetLoading] = useState(false);
+	const [closingTransactionLoading, setClosingTransactionLoading] = useState(false);
+	const [editTransactionopenInnerSidesheetState, setEditTransactionOpenInnerSidesheetState] = useState({
+		attachments: false,
+		workflowActions: false,
+		notes: false
+	});
+	const [dialogOpen, setDialogOpen] = useState(false);
+	const [unsavedChangesDialogOpen, setUnsavedChangesDialogOpen] = useState(false);
+	const [hasUnsavedChanges, setHasUnsavedChanges] = useState(false);
+	const [createTransactionOpenInnerSidesheetState, setCreateTransactionOpenInnerSidesheetState] = useState({ attachments: false });
+	const [attachmentType, setAttachmentType] = useState(null);
+	const [currentAttachments, setCurrentAttachments] = useState([]);
+	const [attachmentProgress, setAttachmentProgress] = useState(false);
+	const [transactionAttachments, setTransactionAttachments] = useState([]);
+	const [filePreview, setFilePreview] = useState(false);
+	const { handleSuccessSnackbar, handleErrorSnackbar } = useHandleAxiosSnackbar();
+	const { hasClosedStatus, checkIfTransactionIsClosed, getTransactionTypeLabel, getUiActionRenderPageId } = useTransactionEngine(transactionTypeId);
+	const { t } = useTranslation();
+	const formRef = useRef(null);
+	const createdTransactionIdRef = useRef(null);
+	const attachmentRef = useRef();
+	const sidesheetWidth = openStates?.width ?? 800;
+	const transactionTypeEntry = transaction?.entityBusinessObject;
+	const { enqueueSnackbar } = useSnackbar();
+	const [{ data: transactionAttachmentTypes }, fetchTransactionAttachmentType] = useAxiosMutate(process.env.REACT_APP_PRODUCT_API_BASE, `UdpTransactionAttachmentType/search`, {
+		method: "post",
+		data: {
+			pageSize: 50,
+			filterElements: [{
+				searchField: "TransactionTypeId",
+				searchValue: transactionTypeId,
+				searchOperator: "="
+			}]
+		}
+	});
+	const handleDialogClose = () => {
+		setDialogOpen(false);
+	};
+	const handleUnsavedChangesDialogClose = () => {
+		setUnsavedChangesDialogOpen(false);
+	};
+	const handleResetAttachmentState = useCallback((resetSavedAttachmentsState) => {
+		if (resetSavedAttachmentsState) {
+			setAttachmentType(null);
+			setCurrentAttachments([]);
+		}
+		setAttachmentProgress(false);
+		setTransactionAttachments([]);
+		setFilePreview(false);
+	}, []);
+	const executeCloseTransaction = useCallback(async () => {
+		if ((await apiMutate(ConfigService$1.productV1ApiUrl, `udpTransaction/${transaction?.transactionId}/closeTransaction`, { method: "post" }))?.status === 200) {
+			handleSidesheet("edit", false);
+			refreshGridData();
+			handleSuccessSnackbar(t(`Transaction has been closed successfully`));
+		} else handleErrorSnackbar(new Error(t(`Error closing Transaction. Please try again later.`)));
+	}, [
+		transaction,
+		refreshGridData,
+		handleSidesheet,
+		handleSuccessSnackbar,
+		handleErrorSnackbar,
+		t
+	]);
+	const handleConfirmCloseTransactionDialog = useCallback(async () => {
+		try {
+			setClosingTransactionLoading(true);
+			await executeCloseTransaction();
+		} catch (error) {
+			handleErrorSnackbar(error);
+		} finally {
+			setClosingTransactionLoading(false);
+			handleDialogClose();
+		}
+	}, [executeCloseTransaction, handleErrorSnackbar]);
+	const formattedBusinesskey = transactionTypeEntry?.businessObjectKey?.split("|")?.pop();
+	const handleTransactionCreationSuccess = useCallback((response) => {
+		createdTransactionIdRef.current = response?.data?.transactionId ?? null;
+	}, []);
+	const handleFilesSelectedForUpload = useCallback(() => {
+		setCreateTransactionOpenInnerSidesheetState({ attachments: false });
+		enqueueSnackbar(`${currentAttachments.length} file(s) added for upload`, {
+			variant: "success",
+			anchorOrigin: {
+				vertical: "top",
+				horizontal: "center"
+			}
+		});
+	}, [enqueueSnackbar, currentAttachments.length]);
+	const handleUploadFilesForCreateTransaction = useCallback(async (transactionId) => {
+		if (!currentAttachments.length) throw new Error("No files added for upload");
+		const formData = new FormData();
+		currentAttachments.forEach((file) => formData.append("files", file));
+		formData.append("attachmentTypeId", attachmentType.transactionAttachmentTypeId);
+		try {
+			setAttachmentProgress(true);
+			await apiMutate(ConfigService$1.productV1ApiUrl, `UdpTransactionAttachment/transaction/${transactionId}/upload`, {
+				method: "post",
+				headers: {
+					transactionId,
+					attachmentTypeId: attachmentType.transactionAttachmentTypeId
+				},
+				data: formData
+			});
+			setCurrentAttachments([]);
+			setCreateTransactionOpenInnerSidesheetState({ attachments: false });
+			enqueueSnackbar("Files uploaded successfully", {
+				variant: "success",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		} catch (error) {
+			enqueueSnackbar(`File upload failed: We encountered a system error. Please try again or contact support if the issue persists.`, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+			throw error;
+		} finally {
+			setAttachmentProgress(false);
+		}
+	}, [
+		attachmentType,
+		currentAttachments,
+		enqueueSnackbar,
+		setCurrentAttachments,
+		setAttachmentProgress
+	]);
+	const handleTransactionCreation = useCallback(async () => {
+		setSidesheetLoading(true);
+		createdTransactionIdRef.current = null;
+		await formRef.current?.form?.submit();
+		const newTransactionId = createdTransactionIdRef.current;
+		if (newTransactionId && currentAttachments.length > 0) await handleUploadFilesForCreateTransaction(newTransactionId);
+		setSidesheetLoading(false);
+		handleSidesheet("add", false);
+		handleResetAttachmentState(true);
+		refreshGridData();
+	}, [
+		handleSidesheet,
+		refreshGridData,
+		formRef,
+		handleResetAttachmentState,
+		currentAttachments.length,
+		handleUploadFilesForCreateTransaction
+	]);
+	const handleCreateRevision = useCallback(async () => {
+		setSidesheetLoading(true);
+		await formRef.current?.form?.submit();
+		setSidesheetLoading(false);
+		handleSidesheet("createRevision", false);
+		refreshGridData();
+	}, [
+		handleSidesheet,
+		refreshGridData,
+		formRef
+	]);
+	const handleNextStepsAction = useCallback(() => {
+		if (!hasUnsavedChanges) setEditTransactionOpenInnerSidesheetState({ workflowAction: true });
+		else setUnsavedChangesDialogOpen(true);
+	}, [hasUnsavedChanges]);
+	const handleConfirmUnsavedChangesDialog = useCallback(() => {
+		setUnsavedChangesDialogOpen(false);
+		setEditTransactionOpenInnerSidesheetState({ workflowAction: true });
+	}, []);
+	const pdfViewPageId = useMemo(() => {
+		return getUiActionRenderPageId(TransactionUiActionTypeEnums.Render_View_Pdf_Page);
+	}, [getUiActionRenderPageId]);
+	const viewTransactionPage = useMemo(() => {
+		if (pdfViewPageId) return /* @__PURE__ */ React.createElement(PageContainer, {
+			pageId: pdfViewPageId,
+			widgetParams: { transaction }
+		});
+		else return /* @__PURE__ */ React.createElement(ViewTransaction_default, { transaction });
+	}, [transaction, pdfViewPageId]);
+	const transactionIsClosed = useMemo(() => {
+		return checkIfTransactionIsClosed(transaction);
+	}, [checkIfTransactionIsClosed, transaction]);
+	const transactionLabel = useMemo(() => {
+		return getTransactionTypeLabel(transaction) ?? formattedBusinesskey;
+	}, [
+		getTransactionTypeLabel,
+		transaction,
+		formattedBusinesskey
+	]);
+	const sidesheetList = useMemo(() => {
+		return [
+			{
+				open: openStates.addTransaction,
+				closeSheet: () => {
+					handleSidesheet("add", false);
+					handleResetAttachmentState(true);
+				},
+				title: domainName,
+				width: sidesheetWidth,
+				onSubmit: handleTransactionCreation,
+				children: /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(UdpTransactionCustomPage_default, {
+					transactionTypeId,
+					transactionUiActionType: TransactionUiActionTypeEnums.Render_Create_Transaction_Page,
+					formRef,
+					onSubmitSuccess: handleTransactionCreationSuccess
+				}), /* @__PURE__ */ React.createElement(SideSheet, {
+					key: "Create Transaction: Add Attachment",
+					open: createTransactionOpenInnerSidesheetState?.attachments,
+					width: 600,
+					title: t("Add Attachment"),
+					onClose: () => {
+						setCreateTransactionOpenInnerSidesheetState({ attachments: false });
+						handleResetAttachmentState(true);
+					},
+					buttonLabel: t("Save"),
+					buttonOneDisabled: !attachmentType || currentAttachments.length <= 0,
+					onSubmit: handleFilesSelectedForUpload,
+					color: "primary"
+				}, /* @__PURE__ */ React.createElement(Attachments, {
+					attachmentTypes: transactionAttachmentTypes,
+					attachmentType,
+					setAttachmentType,
+					attachmentProgress,
+					setAttachmentProgress,
+					currentAttachments,
+					setCurrentAttachments,
+					transaction,
+					previousAttachments: transactionAttachments,
+					setPreviousAttachments: setTransactionAttachments,
+					MAX_FILE_SIZE_MB,
+					allowedExtensions,
+					filePreview,
+					setFilePreview
+				}))),
+				buttonLabel: "Add",
+				buttonTwoLabel: /* @__PURE__ */ React.createElement(Badge, {
+					badgeContent: currentAttachments?.length,
+					color: "primary"
+				}, "Add Attachment"),
+				buttonTwoAction: () => setCreateTransactionOpenInnerSidesheetState({ attachments: true })
+			},
+			{
+				open: openStates.viewTransaction,
+				closeSheet: () => handleSidesheet("view", false),
+				title: domainName + " " + transactionLabel + " - Preview",
+				width: sidesheetWidth,
+				children: viewTransactionPage,
+				buttonLabel: !pdfViewPageId ? "Download" : null
+			},
+			{
+				open: openStates.attachmentTransaction,
+				closeSheet: () => handleSidesheet("view", false),
+				title: "Attachment for " + domainName + " " + transactionLabel,
+				width: sidesheetWidth,
+				buttonLabel: "Download",
+				onSubmit: () => {
+					if (attachmentRef.current) attachmentRef.current.downloadSelectedFile();
+				},
+				children: /* @__PURE__ */ React.createElement(AttachmentTransaction_default, {
+					handleAttachmentTransaction,
+					attachmentRef,
+					transaction,
+					domainName,
+					setSidesheetLoading
+				})
+			},
+			{
+				open: openStates.workflowAction,
+				closeSheet: () => handleSidesheet("action", false),
+				title: `Workflow Actions - ${domainName} ${transactionLabel}`,
+				width: sidesheetWidth,
+				children: /* @__PURE__ */ React.createElement(WorkflowActions_default, {
+					transaction,
+					closeSideSheet: () => {
+						handleSidesheet("action", false);
+					},
+					refreshGridData
+				})
+			},
+			{
+				open: openStates.editTransaction,
+				closeSheet: () => {
+					handleSidesheet("edit", false);
+					handleResetAttachmentState(true);
+				},
+				title: `Edit ${domainName} ${transactionLabel}`,
+				width: sidesheetWidth,
+				buttonLabel: "Next Steps",
+				buttonOneDisabled: transactionIsClosed,
+				onSubmit: handleNextStepsAction,
+				buttonTwoLabel: "Close " + domainName,
+				buttonTwoDisabled: transactionIsClosed || !hasClosedStatus,
+				buttonTwoAction: () => setDialogOpen(true),
+				children: /* @__PURE__ */ React.createElement(EditTransaction_default, {
+					transaction,
+					transactionTypeId,
+					transactionIsClosed,
+					openInnerSidesheetState: editTransactionopenInnerSidesheetState,
+					setOpenInnerSidesheetState: setEditTransactionOpenInnerSidesheetState,
+					refreshGridData,
+					closeSideSheet: () => {
+						handleSidesheet("edit", false);
+						handleResetAttachmentState(true);
+					},
+					setSidesheetLoading,
+					setHasUnsavedChanges,
+					attachmentType,
+					setAttachmentType,
+					currentAttachments,
+					setCurrentAttachments,
+					attachmentProgress,
+					setAttachmentProgress,
+					transactionAttachmentTypes,
+					transactionAttachments,
+					setTransactionAttachments,
+					filePreview,
+					setFilePreview
+				})
+			},
+			{
+				open: openStates.createRevision,
+				closeSheet: () => handleSidesheet("createRevision", false),
+				title: `Create Revision for ${domainName}`,
+				width: sidesheetWidth,
+				onSubmit: handleCreateRevision,
+				children: /* @__PURE__ */ React.createElement(UdpTransactionCustomPage_default, {
+					transactionTypeId,
+					transactionUiActionType: TransactionUiActionTypeEnums.Render_Create_Revision_Page,
+					formRef,
+					transaction
+				}),
+				buttonLabel: "Create Revision"
+			}
+		];
+	}, [
+		openStates,
+		handleSidesheet,
+		handleAttachmentTransaction,
+		transaction,
+		domainName,
+		editTransactionopenInnerSidesheetState,
+		setEditTransactionOpenInnerSidesheetState,
+		transactionLabel,
+		refreshGridData,
+		transactionTypeId,
+		handleTransactionCreation,
+		handleTransactionCreationSuccess,
+		hasClosedStatus,
+		handleCreateRevision,
+		transactionIsClosed,
+		viewTransactionPage,
+		pdfViewPageId,
+		sidesheetWidth,
+		handleNextStepsAction,
+		createTransactionOpenInnerSidesheetState,
+		t,
+		attachmentType,
+		setAttachmentType,
+		currentAttachments,
+		setCurrentAttachments,
+		attachmentProgress,
+		setAttachmentProgress,
+		transactionAttachmentTypes,
+		transactionAttachments,
+		setTransactionAttachments,
+		filePreview,
+		setFilePreview,
+		handleResetAttachmentState,
+		handleFilesSelectedForUpload
+	]);
+	useEffect(() => {
+		if ((openStates?.addTransaction || openStates?.editTransaction) && !transactionAttachmentTypes) {
+			setAttachmentProgress(true);
+			fetchTransactionAttachmentType().then(() => {
+				setAttachmentProgress(false);
+			});
+		}
+	}, [
+		fetchTransactionAttachmentType,
+		transactionAttachmentTypes,
+		openStates.addTransaction,
+		openStates.editTransaction
+	]);
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, openStates && sidesheetList.map((item) => {
+		return /* @__PURE__ */ React.createElement(SideSheet, {
+			key: item.title,
+			open: item.open,
+			width: sidesheetWidth,
+			title: item.title,
+			onClose: item.closeSheet,
+			noPadding: openStates.attachmentTransaction || openStates.editTransaction,
+			buttonLabel: item?.buttonLabel,
+			onSubmit: item?.onSubmit,
+			color: "primary",
+			buttonTwoLabel: item?.buttonTwoLabel,
+			buttonTwoAction: item?.buttonTwoAction,
+			buttonOneDisabled: item?.buttonOneDisabled,
+			buttonTwoDisabled: item?.buttonTwoDisabled,
+			progress: sidesheetLoading,
+			variant: "indeterminate"
+		}, /* @__PURE__ */ React.createElement("div", null, item.children));
+	}), /* @__PURE__ */ React.createElement(FluentDialog, {
+		title: t(`Close Transaction`),
+		message: `Are you sure you want to close transaction for ${transaction?.entityBusinessKey || ""}?`,
+		labelOne: t("Confirm"),
+		actionOne: handleConfirmCloseTransactionDialog,
+		labelTwo: t("Cancel"),
+		actionTwo: handleDialogClose,
+		open: dialogOpen,
+		handleClose: handleDialogClose,
+		loading: closingTransactionLoading
+	}), /* @__PURE__ */ React.createElement(FluentDialog, {
+		title: t(`Unsaved Changes`),
+		message: `You have unsaved changes. Are you sure you want to go to next steps?`,
+		labelOne: t("Confirm"),
+		actionOne: handleConfirmUnsavedChangesDialog,
+		labelTwo: t("Cancel"),
+		actionTwo: handleUnsavedChangesDialogClose,
+		open: unsavedChangesDialogOpen,
+		handleClose: handleUnsavedChangesDialogClose,
+		loading: closingTransactionLoading
+	}));
+};
+var UdpTransactionSidesheet_default = UdpTransactionSidesheet;
+
+//#endregion
+//#region src/hooks/useTransactionType.js
+const useTransactionType = (options = {}) => {
+	const { transactionTypeId, domainName, domainFieldType, domainFieldValue } = options;
+	const [resolvedId, setResolvedId] = useState(transactionTypeId || null);
+	const [data, setData] = useState(void 0);
+	const [loading, setLoading] = useState(true);
+	const [error, setError] = useState(void 0);
+	const [promise, setPromise] = useState(void 0);
+	const { transactionTypesMap, setTransactionTypesMap } = useTransactionStore();
+	const setSuccessState = useCallback((response) => {
+		setError(void 0);
+		setLoading(false);
+		setData(response);
+	}, []);
+	useEffect(() => {
+		if (transactionTypeId) {
+			setResolvedId(transactionTypeId);
+			return;
+		}
+		if (!domainName) return;
+		setLoading(true);
+		const domainPromise = apiMutate(ConfigService$1.productV1ApiUrl, `udpTransactionType/domain/${domainName}${domainFieldType && domainFieldValue ? `?domainFieldType=${domainFieldType}&domainFieldValue=${domainFieldValue}` : ""}`, {});
+		domainPromise.then((res) => {
+			const newId = res.data?.transactionTypeId;
+			if (newId) {
+				setResolvedId(newId);
+				setTransactionTypesMap({ [newId]: res.data });
+				setSuccessState(res.data);
+			} else setError("Transaction type not found for domain.");
+		}).catch(setError).finally(() => setPromise(domainPromise));
+	}, [
+		transactionTypeId,
+		domainName,
+		domainFieldType,
+		domainFieldValue
+	]);
+	useEffect(() => {
+		if (!resolvedId) return;
+		if (transactionTypesMap[resolvedId]) {
+			setSuccessState(transactionTypesMap[resolvedId]);
+			return;
+		}
+		setLoading(true);
+		const fetchPromise = apiMutate(ConfigService$1.productV1ApiUrl, `udpTransactionType/${resolvedId}?withAssociationData=true`, {});
+		fetchPromise.then((res) => {
+			const transactionType = res.data;
+			setTransactionTypesMap({ [resolvedId]: transactionType });
+			setSuccessState(transactionType);
+		}).catch(setError).finally(() => setPromise(fetchPromise));
+	}, [
+		resolvedId,
+		transactionTypesMap,
+		setTransactionTypesMap,
+		setSuccessState
+	]);
+	return {
+		data,
+		loading,
+		error,
+		promise
+	};
+};
+
+//#endregion
+//#region src/hooks/useUdpGridFilterModel.js
+const useUdpGridFilterModel = () => {
+	const { search } = useLocation();
+	const searchParams = useMemo(() => new URLSearchParams(search), [search]);
+	return useMemo(() => {
+		const constructedFilterModel = {};
+		searchParams.forEach((value, key) => {
+			if (key.startsWith("udp_search-")) {
+				const paramBody = key.replace("udp_search-", "");
+				const lastHyphenIndex = paramBody.lastIndexOf("-");
+				if (lastHyphenIndex !== -1) {
+					const field = paramBody.substring(0, lastHyphenIndex);
+					const operator = paramBody.substring(lastHyphenIndex + 1).replace(/_([a-z])/g, (_, char) => char.toUpperCase());
+					const { filterType, filterKey, parsedValue } = parseFilterValue(value);
+					if (constructedFilterModel[field]) constructedFilterModel[field].conditions.push({
+						filterType,
+						type: operator,
+						[filterKey]: parsedValue
+					});
+					else constructedFilterModel[field] = {
+						filterType,
+						operator: "OR",
+						conditions: [{
+							filterType,
+							type: operator,
+							[filterKey]: parsedValue
+						}]
+					};
+				}
+			}
+		});
+		return constructedFilterModel;
+	}, [searchParams]);
+};
+const parseFilterValue = (value) => {
+	if (!isNaN(Date.parse(value)) && (value.includes("-") || value.includes("/"))) return {
+		filterType: "date",
+		filterKey: "dateFrom",
+		parsedValue: value
+	};
+	if (!isNaN(value) && !isNaN(parseFloat(value))) return {
+		filterType: "number",
+		filterKey: "filter",
+		parsedValue: Number(value)
+	};
+	return {
+		filterType: "text",
+		filterKey: "filter",
+		parsedValue: value
+	};
+};
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/UdpTransactionsPage.jsx
+const UdpTransactionsPage = (props) => {
+	const { transactionTypeId = "", domainName: initialDomainName = "", domainFieldType, domainFieldValue, searchMethodObject, domainColumnFormatters, gridOptions } = props;
+	const [sidesheetState, setSidesheetState] = useState({
+		workflowAction: false,
+		addTransaction: false,
+		editTransaction: false,
+		viewTransaction: false,
+		attachmentTransaction: false,
+		createRevision: false
+	});
+	const [selectedTransaction, setSelectedTransaction] = useState(null);
+	const [gridApi, setGridApi] = useState(null);
+	const { data: transactionType, loading: transactionTypeLoading, error: transactionTypeError } = useTransactionType({
+		transactionTypeId,
+		domainName: initialDomainName,
+		domainFieldType,
+		domainFieldValue
+	});
+	useTransactionEngine(transactionType?.transactionTypeId);
+	const filterModel = useUdpGridFilterModel();
+	const handleSidesheet = (actionType, openStatus, transaction, width = 800) => {
+		if (actionType == "add") setSidesheetState({
+			addTransaction: openStatus,
+			width
+		});
+		else if (actionType == "edit") setSidesheetState({
+			editTransaction: openStatus,
+			width
+		});
+		else if (actionType == "view") setSidesheetState({
+			viewTransaction: openStatus,
+			width
+		});
+		else if (actionType == "attachment") setSidesheetState({
+			attachmentTransaction: openStatus,
+			width
+		});
+		else if (actionType == "action") setSidesheetState({
+			workflowAction: openStatus,
+			width
+		});
+		else if (actionType == "createRevision") setSidesheetState({
+			createRevision: openStatus,
+			width
+		});
+		setSelectedTransaction(transaction);
+	};
+	const handleAttachmentTransaction = () => {};
+	const handleGridApiCallback = useCallback((api) => {
+		setGridApi(api);
+	}, []);
+	const domainName = useMemo(() => {
+		if (transactionType) return transactionType.domainName.split(".").pop();
+		return initialDomainName;
+	}, [transactionType, initialDomainName]);
+	if (!transactionType) return /* @__PURE__ */ React.createElement("div", { className: "udp-transaction-page-loading" }, /* @__PURE__ */ React.createElement(CircularProgress, { size: 64 }));
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(UdpTransactionGrid_default, {
+		transactionTypeId: transactionType?.transactionTypeId,
+		transactionType,
+		domainName,
+		transactionTypeLoading,
+		searchMethodObject,
+		domainColumnFormatters,
+		openAddTransaction: () => {
+			handleSidesheet("add", true);
+		},
+		openViewTransaction: (transaction) => {
+			handleSidesheet("view", true, transaction);
+		},
+		openEditTransaction: (transaction) => {
+			handleSidesheet("edit", true, transaction);
+		},
+		openAttachmentTransaction: (transaction) => {
+			handleSidesheet("attachment", true, transaction, 1e3);
+		},
+		openWorkflowActionTransaction: (transaction) => {
+			handleSidesheet("action", true, transaction);
+		},
+		openCreateRevision: (transaction) => {
+			handleSidesheet("createRevision", true, transaction);
+		},
+		handleGridApiCallback,
+		refreshGridData: () => {
+			gridApi?.refreshServerSide();
+		},
+		gridApi,
+		initialFilterModel: filterModel,
+		initialGridOptions: gridOptions
+	}), /* @__PURE__ */ React.createElement(UdpTransactionSidesheet_default, {
+		openStates: sidesheetState,
+		handleSidesheet,
+		handleAttachmentTransaction,
+		transaction: selectedTransaction,
+		transactionTypeId: transactionType?.transactionTypeId,
+		domainName,
+		refreshGridData: () => {
+			gridApi?.refreshServerSide();
+		}
+	}));
+};
+var UdpTransactionsPage_default = UdpTransactionsPage;
+
+//#endregion
+//#region src/udp/pages/UdpTransactionsPage/index.ts
+var UdpTransactionsPage_exports = /* @__PURE__ */ __exportAll({ default: () => UdpTransactionsPage_default });
+
+//#endregion
+export { UdpTransactionsPage_default as n, UdpTransactionsPage_exports as t };
+//# sourceMappingURL=UdpTransactionsPage-B6OV3w81.js.map