udp-react-enterprise-component-library 25.16.0 → 25.16.2-beta.1

package/dist/udpPages-D8I3GU4V.js

@@ -0,0 +1,2824 @@
+import { __export } from "./chunk-CTAAG5j7.js";
+import { useAgGridApi } from "./AgTable-0F_xrxvX.js";
+import { Form, FormButtons, SubmitButton } from "./FormButtons-BL9d-T3e.js";
+import { Field } from "./Field-Idoc1A5M.js";
+import { FluentButton } from "./FluentButton-h_8VjXGT.js";
+import { getEntityAttributes, getPathObject, getPrimaryKeyValues } from "./CrudBrowserUtilities-Cm_FNdfE.js";
+import { useHandleAxiosSnackbar } from "./apiHelpers-Bju2gkBq.js";
+import { useUser } from "./useUser-Cn88hlN_.js";
+import { apiMutate as apiMutate$1 } from "./useAxiosMutate-BiRO7ZCN.js";
+import { FluentTextFieldAutoComplete } from "./FluentTextFieldAutoComplete-BQvVv8m_.js";
+import { toLowerFirstChar, toUpperFirstChar } from "./StringUtilities-DyjYA5pU.js";
+import { FluentIcon } from "./FluentIcon-CB-ANF6C.js";
+import { FluentIconButton } from "./FluentIconButton-le92OnEc.js";
+import { CardinalityTypeEnums, GridExcelStyleEnums, LogicalSearchOperatorEnums, SplitScreenTypeEnums, UdpEnums, UdpReminderFiledForType } from "./unitySystemEnums-DXk8yS3v.js";
+import { UnityFluentIcon } from "./UnityFluentIcon-fuqAQh0C.js";
+import { useCatalogStore } from "./catalogStore-DDyUXvDn.js";
+import { useActionState, useActions } from "./useActions-C4qJAr_e.js";
+import { PrimaryActionButton } from "./PrimaryActionButton-CQXyHAeG.js";
+import { getSearchIdentifiers, getSearchObject } from "./SearchUtilities-CxVn31Ak.js";
+import { getIconFromName, mapNodeObjValuesToSearchParameters } from "./TreeUtilities-BxV5PMJ8.js";
+import { getUnityIconFromName } from "./UnityIconLibrary-DnCuEr5M.js";
+import { SideSheet } from "./SideSheet-BhKZOd2G.js";
+import { useAxiosGet } from "./useAxiosGet-CAH3ZOZ8.js";
+import { executeQueryAdHoc, executeQueryWithParameters, getBaseMethod } from "./methodUtils-Bgi0VCWP.js";
+import { AmbientCard } from "./AmbientCard-Cp-eNzrW.js";
+import { NotesScreen } from "./NotesScreen-CvAvZ_R3.js";
+import { FILE_TO_TYPES } from "./reminderConstants-Btqf39dU.js";
+import { RemindersScreen } from "./RemindersScreen-9OpdtOBe.js";
+import { useTenant } from "./useTenant-BGWpH8AX.js";
+import { usePromotedMethodEntity } from "./usePromotedMethodEntity-YlKDqDnn.js";
+import { ChatContainer } from "./ChatContainer-il3bj22z.js";
+import { ActionsRenderer, AmbientGridTemplate } from "./AmbientGridTemplate-B58pNLnZ.js";
+import { FluentDialog } from "./FluentDialog-DU5BAKwU.js";
+import { useApiCatalog } from "./useApiCatalog-Bt9zKIld.js";
+import { useQueryExecutors } from "./useQueryExecutors-CU1LD7zt.js";
+import { useSearchFilterParamsMap } from "./useSearchFilterParamsMap-tHRVgYQ-.js";
+import { RecentlyLoadedNodesTable } from "./RecentlyLoadedNodesTable-BZ4YiuvL.js";
+import { LinearProgress as LinearProgress$1 } from "./LinearProgress-CVk0GRO-.js";
+import { GridRow, GridUnit } from "./GridRow-Bu4ZB7BW.js";
+import { FluentTextField } from "./FluentTextField-DCzp_6wE.js";
+import { PowerBIReport } from "./PowerBIReport-CYX6YxbE.js";
+import { useAuthedUser } from "./useAuthedUser-BbuZ-TTz.js";
+import { SearchMethodUdpGrid } from "./SearchMethodUdpGrid-Ua0Kj84J.js";
+import { CrudTableSidePanel } from "./CrudTableSidePanel-DdQ_D8g0.js";
+import { UdpMaintenanceEnginePage, UdpMaintenanceEnginePage_exports } from "./UdpMaintenanceEnginePage-CpqXzyEv.js";
+import { FluentCheckbox } from "./FluentCheckbox-DdPx94AF.js";
+import { IconLibrary_default } from "./IconLibrary-CPErCan6.js";
+import { WidgetCard_default } from "./widgets-CRzkTpIV.js";
+import { FluentDisplayNumbers_default } from "./AmbientVisualizer-BFFwonre.js";
+import { DataBrowserContainer } from "./DataBrowserContainer-CESNdu3e.js";
+import { RemindersCard } from "./RemindersCard-BJhfqNQk.js";
+import { UdpPublicForm_exports } from "./UdpPublicForm-CGo9h-lA.js";
+import { ImportDataFromFileMapping } from "./ImportDataFromFileMapping-CjANFPa8.js";
+import React, { Fragment, forwardRef, memo, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { Avatar, Box, Button, CircularProgress, Divider, FormControlLabel, Grid, IconButton, LinearProgress, Switch, TextField, Typography, colors, makeStyles } from "@material-ui/core";
+import { ConfigService, UdpFormsBuilder, UdpFormsList, UdpFormsRenderer } from "udp-react-stencil-component-library";
+import { useSnackbar } from "notistack";
+import { useHistory, useLocation } from "react-router-dom";
+import { DateTime, IANAZone } from "luxon";
+import { AddIcon, ChartIcon, DeleteIcon, EditIcon, MarketDownIcon, MarketIcon, NumberedListIcon, RefreshIcon, SortIcon, UploadIcon, ViewIcon } from "@fluentui/react-icons";
+import { debounce } from "lodash";
+import { useTranslation } from "react-i18next";
+import { v4 } from "uuid";
+import { Alert } from "@material-ui/lab";
+import { MuiVegaLite } from "@material-vega/material-ui";
+import ToggleButton from "@material-ui/lab/ToggleButton";
+import round from "@extra-number/round";
+import DownArrow from "@material-ui/icons/esm/ArrowDownward";
+import UpArrow from "@material-ui/icons/esm/ArrowUpward";
+import ToggleButtonGroup from "@material-ui/lab/ToggleButtonGroup";
+import { Sparklines, SparklinesLine } from "react-sparklines";
+import ReactJson from "react-json-view";
+
+//#region src/udp/pages/UdpNotesPage.jsx
+var UdpNotesPage_exports = /* @__PURE__ */ __export({ default: () => UdpNotesPage_default });
+const UdpNotesPage = (props) => {
+	const { params } = props;
+	const { nodeObj, manytoManyNodeObjKey } = params;
+	const [notes, setNotes] = useState([]);
+	const [typeOptions, setTypeOptions] = useState([]);
+	const [loading, setLoading] = useState(false);
+	const [sheetOpen, setSheetOpen] = useState(false);
+	const [noteId, setNoteId] = useState("");
+	const { openSplitScreen } = useActions();
+	const { catalogPromotedEntities } = useActionState();
+	const { handleErrorSnackbar } = useHandleAxiosSnackbar();
+	const { t } = useTranslation();
+	const formRef = useRef(null);
+	const user = useUser();
+	const noteFiledForSearchApiMethod = useMemo(() => {
+		return getBaseMethod(UdpEnums.Udp_Note_Filed_For, "unityBaseSearchMethod", catalogPromotedEntities);
+	}, [catalogPromotedEntities]);
+	const noteTypeGetAllApiMethod = useMemo(() => {
+		return getBaseMethod(UdpEnums.Udp_Note_Type, "unityBaseGetAllMethod", catalogPromotedEntities);
+	}, [catalogPromotedEntities]);
+	const getNotes = useCallback(async () => {
+		if (!nodeObj) return [];
+		let notesList = [];
+		setLoading(true);
+		const data = { data: getSearchObject([{
+			searchField: "entityBusinessKey",
+			searchValue: manytoManyNodeObjKey ? nodeObj[manytoManyNodeObjKey]?.businessObjectKey : nodeObj?.businessObjectKey,
+			searchOperator: "="
+		}], 1, 200, true) };
+		if (noteFiledForSearchApiMethod) {
+			const response = await executeQueryAdHoc(data, noteFiledForSearchApiMethod.apiMethodId);
+			if (response?.status === 200) {
+				const pageList = response.data.pageList;
+				if (pageList?.length) notesList = pageList.map((item) => item.note);
+			} else handleErrorSnackbar(null, t("Could not retrieve notes"));
+		} else handleErrorSnackbar(null, t("Search NoteFiledFor Method Not Promoted"));
+		setLoading(false);
+		setNotes(notesList);
+	}, [
+		noteFiledForSearchApiMethod,
+		handleErrorSnackbar,
+		nodeObj,
+		manytoManyNodeObjKey,
+		t,
+		user
+	]);
+	const openSheet = useCallback((value) => {
+		setNoteId(value?.id || "");
+		setSheetOpen(true);
+	}, []);
+	const closeSheet = useCallback(() => {
+		setNoteId("");
+		setSheetOpen(false);
+	}, []);
+	const handleEditPage = useCallback((value) => {
+		openSplitScreen({
+			open: true,
+			action: null,
+			type: SplitScreenTypeEnums.Notes,
+			params: {
+				id: value?.id || "",
+				reloadNotes: getNotes
+			}
+		});
+	}, [openSplitScreen, getNotes]);
+	const getType = useCallback((params$1) => {
+		return typeOptions.find((t$1) => t$1.code === params$1.data.typeCode)?.name || "";
+	}, [typeOptions]);
+	const actionList = useMemo(() => [{
+		id: 1,
+		title: t("Note"),
+		icon: ViewIcon,
+		onClick: openSheet,
+		disabled: false
+	}, {
+		id: 2,
+		title: t("Edit"),
+		icon: EditIcon,
+		onClick: handleEditPage,
+		disabled: false
+	}], [
+		t,
+		openSheet,
+		handleEditPage
+	]);
+	const columnDefs = [
+		{
+			headerName: "Date",
+			field: "createdOn",
+			resizable: true,
+			sortable: true
+		},
+		{
+			headerName: "Subject",
+			field: "subject",
+			resizable: true,
+			sortable: true
+		},
+		{
+			headerName: "Note",
+			field: "content",
+			resizable: true,
+			sortable: true,
+			valueGetter: (params$1) => params$1.data.content.replace(/(<([^>]+)>)/gi, "")
+		},
+		{
+			headerName: "Type",
+			field: "typeCode",
+			resizable: true,
+			sortable: true,
+			valueGetter: getType
+		},
+		{
+			headerName: "Created By",
+			field: "userDisplayName",
+			resizable: true,
+			sortable: true
+		},
+		{
+			headerName: "",
+			cellRenderer: "actionsRenderer",
+			cellRendererParams: { actionList },
+			pinned: "right",
+			suppressMenu: true,
+			sortable: false
+		}
+	];
+	useEffect(() => {
+		getNotes();
+	}, []);
+	useEffect(() => {
+		const getTypeOptions = async () => {
+			let options = [];
+			if (noteTypeGetAllApiMethod) {
+				const typesResponse = await executeQueryAdHoc({ data: {} }, noteTypeGetAllApiMethod.apiMethodId);
+				if (typesResponse?.status === 200) options = typesResponse.data;
+			}
+			setTypeOptions(options);
+		};
+		getTypeOptions();
+	}, [noteTypeGetAllApiMethod]);
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(SideSheet, {
+		open: sheetOpen,
+		onClose: closeSheet,
+		title: t("Note"),
+		width: 600
+	}, /* @__PURE__ */ React.createElement(NotesScreen, {
+		viewOnly: true,
+		id: noteId,
+		shortcutContentFinderEnabled: false,
+		formRef
+	})), /* @__PURE__ */ React.createElement(AmbientGridTemplate, {
+		title: "Notes",
+		data: notes,
+		columnDefs,
+		loading,
+		frameworkComponents: { actionsRenderer: ActionsRenderer },
+		groupingData: []
+	}));
+};
+var UdpNotesPage_default = UdpNotesPage;
+
+//#endregion
+//#region src/udp/pages/UdpVerticalManagementSidesheet.jsx
+const UdpVerticalManagementSidesheet = (props) => {
+	const { selectedVertical, environment, associatedProducts, isEdit, deleteVertical, open, selectedCatalog, closeSidesheet, onSubmit,...sheetProps } = props;
+	const { t } = useTranslation();
+	const [loading, setLoading] = useState(false);
+	useActionState();
+	const [displayedIcon, setDisplayedIcon] = useState({
+		name: "StatusCircleQuestionMarkIcon",
+		color: "",
+		type: ""
+	});
+	const [products, setProducts] = useState([]);
+	const [openIconLibrary, setOpenIconLibrary] = useState(false);
+	const [selectedProductIds, setSelectedProductIds] = useState([]);
+	const [checkboxValues, setCheckboxValues] = useState([]);
+	const [submitButtonDisabled, setSubmitButtonDisabled] = useState(true);
+	const selectedProductIdsRef = useRef();
+	selectedProductIdsRef.current = selectedProductIds;
+	const displayedIconRef = useRef();
+	displayedIconRef.current = displayedIcon;
+	const selectedVerticalRef = useRef();
+	selectedVerticalRef.current = selectedVertical;
+	const formRef = useRef();
+	const nameRef = useRef();
+	const { handleErrorSnackbar, handleSuccessSnackbar } = useHandleAxiosSnackbar();
+	const CheckBoxRenderer = ({ onChange, value, id, defaultChecked }) => {
+		const isAssociatedToVertical = useCallback((productId) => {
+			if (!isEdit) return false;
+			for (let product of associatedProducts) if (product.productId === productId && product.verticalId === selectedVerticalRef.current.verticalId) return true;
+			getIconFromName(selectedVerticalRef.current.icon);
+			return false;
+		}, [associatedProducts, selectedVerticalRef]);
+		const handleCheckboxChange = (e) => {
+			if (e.target.checked) setSelectedProductIds((prevState) => [...prevState, id]);
+			else setSelectedProductIds((prevState) => prevState.filter((item) => item !== id));
+		};
+		return /* @__PURE__ */ React.createElement(FluentCheckbox, {
+			defaultChecked: isAssociatedToVertical(id),
+			onChange: handleCheckboxChange,
+			aria: "column-active"
+		});
+	};
+	const gridOptions = useMemo(() => ({
+		frameworkComponents: {
+			actionsRenderer: ActionsRenderer,
+			checkboxRenderer: CheckBoxRenderer
+		},
+		columnDefs: [{
+			headerName: "",
+			field: "select",
+			cellRenderer: "checkboxRenderer",
+			cellRendererParams: (params) => ({ id: params.data.productId })
+		}, {
+			headerName: t("Product Name"),
+			field: "name",
+			minWidth: 200
+		}]
+	}), [
+		isEdit,
+		selectedVertical,
+		associatedProducts
+	]);
+	const executeMutation = useCallback(async (endpoint, method, data) => apiMutate$1(ConfigService.uemV1ApiUrl, endpoint, { method: method || "post" }, data), []);
+	const getProducts = useCallback(async (data) => {
+		setLoading(true);
+		const response = await executeMutation("uem", "post", data);
+		if (response?.status === 200) setProducts(response?.data);
+		setLoading(false);
+	}, [executeMutation, setProducts]);
+	const createVertical = useCallback(async (data) => {
+		setLoading(true);
+		if ((await executeMutation("vertical/uemCreate", "post", data))?.status === 201) {
+			closeSidesheet();
+			handleSuccessSnackbar("Vertical Created Successfully");
+		} else handleErrorSnackbar("Something went wrong");
+		setLoading(false);
+	}, [executeMutation]);
+	const updateVertical = useCallback(async (data) => {
+		setLoading(true);
+		if ((await executeMutation(`vertical/${selectedVertical.verticalId}/uemUpdate`, "put", data))?.status === 204) {
+			closeSidesheet();
+			handleSuccessSnackbar("Vertical Updated Successfully");
+		} else handleErrorSnackbar("Something went wrong");
+		setLoading(false);
+	}, [selectedVertical, executeMutation]);
+	const handleSubmit = useCallback((values) => {
+		setLoading(true);
+		const products$1 = selectedProductIdsRef.current.map((productId) => ({ productId }));
+		!isEdit ? createVertical({ data: {
+			name: values.name,
+			products: products$1,
+			icon: displayedIconRef?.current.name,
+			EnvironmentId: environment.environmentId,
+			apiPath: "api/v1/vertical/uemCreate"
+		} }) : updateVertical({ data: {
+			name: values.name,
+			products: products$1,
+			icon: displayedIconRef?.current.name,
+			EnvironmentId: environment.environmentId,
+			apiPath: `api/v1/vertical/${selectedVertical.verticalId}/uemUpdate`
+		} });
+	}, [
+		isEdit,
+		createVertical,
+		environment,
+		updateVertical,
+		selectedVertical,
+		selectedProductIdsRef
+	]);
+	useEffect(() => {
+		if (environment && getProducts) {
+			if (environment.environmentId) getProducts({ data: {
+				customerId: null,
+				environmentId: environment.environmentId,
+				apiPath: `tenantService/api/v2/product`
+			} });
+		}
+	}, [environment, getProducts]);
+	useEffect(() => {
+		if (selectedVertical) {
+			const associatedProductIds = selectedVertical.verticalProductVertical.map((product) => product.productId);
+			setSelectedProductIds((prevState) => [...prevState, ...associatedProductIds]);
+		}
+	}, [selectedVertical, setSelectedProductIds]);
+	const setDisplayedIconCallback = useCallback(() => {
+		setDisplayedIcon({ name: isEdit && selectedVertical?.icon ? selectedVertical?.icon : "StatusCircleQuestionMarkIcon" });
+	}, [selectedVertical, isEdit]);
+	useEffect(() => {
+		setDisplayedIconCallback();
+	}, [open]);
+	const closeIconLibrary = () => {
+		setOpenIconLibrary(false);
+	};
+	const onOpenLibrary = () => {
+		setOpenIconLibrary(true);
+	};
+	const handleIconSelect = (icon) => {
+		const updateddisplayedIcon = { ...props.displayedIcon };
+		updateddisplayedIcon.name = icon.id;
+		updateddisplayedIcon.type = icon.type || null;
+		setDisplayedIcon(updateddisplayedIcon);
+		closeIconLibrary();
+	};
+	const initialValues = useMemo(() => {
+		return { name: isEdit ? selectedVertical?.name : "" };
+	}, [
+		associatedProducts,
+		selectedVertical,
+		isEdit
+	]);
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(SideSheet, {
+		open,
+		onClose: () => closeSidesheet(),
+		width: 400,
+		title: props.title
+	}, /* @__PURE__ */ React.createElement(Form, {
+		ref: formRef,
+		onSubmit: handleSubmit,
+		initialValues
+	}, /* @__PURE__ */ React.createElement("div", { style: { display: "flex" } }, /* @__PURE__ */ React.createElement(Field, {
+		ref: nameRef,
+		component: TextField,
+		label: t("Name"),
+		id: "name",
+		name: "name",
+		variant: "outlined",
+		size: "small",
+		required: true,
+		style: { marginTop: 8 }
+	}), /* @__PURE__ */ React.createElement(IconButton, { onClick: onOpenLibrary }, displayedIcon && /* @__PURE__ */ React.createElement(UnityFluentIcon, {
+		type: displayedIcon?.type,
+		icon: displayedIcon?.type === "unity" ? getUnityIconFromName(displayedIcon?.name) : getIconFromName(displayedIcon?.name)
+	}))), /* @__PURE__ */ React.createElement(AmbientGridTemplate, {
+		data: products,
+		title: t("Products"),
+		loading,
+		height: "calc(100vh - 300px)",
+		hideGroupTab: true,
+		hideColumnTab: true,
+		disablePagination: true,
+		hideFitGrid: true,
+		hideExpandGrid: true,
+		hideExportGrid: true,
+		hideRemoveFilters: true,
+		hideFilterTab: true,
+		...gridOptions
+	}), /* @__PURE__ */ React.createElement(FormButtons, null, /* @__PURE__ */ React.createElement(SubmitButton, {
+		variant: "contained",
+		color: "secondary",
+		marginTop: "50px",
+		disabled: false,
+		disablePristine: false
+	}, t(isEdit ? "Update" : "Create"))), loading && /* @__PURE__ */ React.createElement(LinearProgress, null))), /* @__PURE__ */ React.createElement(SideSheet, {
+		open: openIconLibrary,
+		onClose: closeIconLibrary,
+		title: t("Icon Library"),
+		width: "100%",
+		anchor: "bottom"
+	}, /* @__PURE__ */ React.createElement(IconLibrary_default, {
+		addItem: handleIconSelect,
+		selectedIconName: displayedIcon?.name,
+		title: t("Select Icon")
+	})));
+};
+var UdpVerticalManagementSidesheet_default = UdpVerticalManagementSidesheet;
+
+//#endregion
+//#region src/udp/pages/UdpVerticalManagementPage.jsx
+var UdpVerticalManagementPage_exports = /* @__PURE__ */ __export({ default: () => UdpVerticalManagementPage_default });
+const UdpVerticalManagementPage = (props) => {
+	const { params } = props;
+	const { nodeObj: environment, inquiryNodeProperties } = params;
+	const { t } = useTranslation();
+	const [sideSheetOpen, setSideSheetOpen] = useState(false);
+	const [sideSheetEdit, setSideSheetEdit] = useState(false);
+	const [loading, setLoading] = useState(false);
+	const [selectedVertical, setSelectedVertical] = useState(null);
+	const [verticals, setVerticals] = useState([]);
+	const [productVertical, setProductVertical] = useState([]);
+	const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
+	const selectedVerticalRef = useRef();
+	selectedVerticalRef.current = selectedVertical ? selectedVertical : null;
+	const { handleErrorSnackbar, handleSuccessSnackbar } = useHandleAxiosSnackbar();
+	const openSheetAsEdit = useCallback((isEdit) => {
+		setSideSheetOpen(true);
+		setSideSheetEdit(isEdit);
+	}, []);
+	const closeDeleteDialog = useCallback(() => {
+		setDeleteDialogOpen(false);
+	}, [setDeleteDialogOpen]);
+	const executeMutation = useCallback(async (endpoint, method, data) => apiMutate$1(ConfigService.uemV1ApiUrl, endpoint, { method: method || "post" }, data), []);
+	const getVerticals = useCallback(async (data, isFirstLoad = false) => {
+		if (isFirstLoad) setLoading(true);
+		const response = await executeMutation("uem", "post", data);
+		if (response?.status === 200) setVerticals(response?.data);
+		if (isFirstLoad) setLoading(false);
+	}, [executeMutation]);
+	const deleteVertical = useCallback(async () => {
+		const data = { data: {
+			environmentId: environment.environmentId,
+			apiPath: `TenantService/api/v2/Vertical/${selectedVerticalRef.current.verticalId}/uemDelete`
+		} };
+		if ((await executeMutation(`vertical/${selectedVerticalRef.current.verticalId}/uemDelete`, "delete", data))?.status === 204) {
+			console.log("success");
+			handleSuccessSnackbar("Vertical Deleted Successfully");
+		}
+		getVerticals({ data: {
+			customerId: null,
+			environmentId: environment.environmentId,
+			apiPath: `TenantService/api/v2/Vertical`
+		} }, true);
+		closeDeleteDialog();
+	}, [
+		executeMutation,
+		selectedVertical,
+		closeDeleteDialog
+	]);
+	const getProductVerticals = useCallback(async (data) => {
+		const response = await executeMutation("productVertical", "get", data);
+		if (response?.status === 200) setProductVertical(response?.data);
+	}, [executeMutation]);
+	useEffect(() => {
+		if (environment && getVerticals) {
+			if (environment.environmentId) {
+				getProductVerticals({ data: { apiPath: `api/v2/ProductVertical` } });
+				getVerticals({ data: {
+					customerId: null,
+					environmentId: environment.environmentId,
+					apiPath: `TenantService/api/v2/Vertical`
+				} }, true);
+			}
+		}
+	}, [
+		environment,
+		getVerticals,
+		getProductVerticals,
+		deleteVertical
+	]);
+	const closeSheet = useCallback(() => {
+		setSideSheetOpen(false);
+		getVerticals({ data: {
+			customerId: null,
+			environmentId: environment.environmentId,
+			apiPath: `TenantService/api/v2/Vertical`
+		} });
+	}, [getVerticals, environment]);
+	const handleEditPage = useCallback((value) => {
+		setSelectedVertical(value);
+		console.log("Edit page, value: ", value);
+		openSheetAsEdit(true);
+	}, [t]);
+	const handleCreateVertical = useCallback((value) => {
+		openSheetAsEdit(false);
+	}, [t]);
+	const handleDelete = useCallback((value) => {
+		setSelectedVertical(value);
+		console.log("Delete page, value: ", value);
+		setDeleteDialogOpen(true);
+	}, [t]);
+	const actionList = useMemo(() => [{
+		id: 1,
+		title: t("Edit"),
+		icon: EditIcon,
+		onClick: handleEditPage,
+		disabled: false
+	}, {
+		id: 2,
+		title: t("Delete"),
+		icon: DeleteIcon,
+		onClick: handleDelete,
+		disabled: false
+	}], [
+		t,
+		handleEditPage,
+		handleDelete
+	]);
+	const gridOptions = useMemo(() => ({
+		frameworkComponents: { actionsRenderer: ActionsRenderer },
+		columnDefs: [
+			{
+				headerName: t("Name"),
+				field: "name",
+				minWidth: 300
+			},
+			{
+				headerName: t("Icon"),
+				field: "icon"
+			},
+			{
+				headerName: t("Actions"),
+				cellRenderer: "actionsRenderer",
+				cellRendererParams: { actionList },
+				pinned: "right",
+				suppressMenu: true,
+				sortable: false
+			}
+		]
+	}), [
+		t,
+		actionList,
+		productVertical
+	]);
+	const pab = /* @__PURE__ */ React.createElement(PrimaryActionButton, { onClick: handleCreateVertical }, /* @__PURE__ */ React.createElement(Typography, { style: { marginRight: 5 } }, "Add"), /* @__PURE__ */ React.createElement(AddIcon, null));
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(UdpVerticalManagementSidesheet_default, {
+		open: sideSheetOpen,
+		closeSidesheet: closeSheet,
+		selectedVertical,
+		environment,
+		title: t(sideSheetEdit ? "Edit Vertical" : "Create Vertical"),
+		associatedProducts: productVertical,
+		isEdit: sideSheetEdit
+	}), /* @__PURE__ */ React.createElement(AmbientGridTemplate, {
+		title: t("Vertical Manager"),
+		primaryActionButton: pab,
+		data: verticals,
+		loading,
+		gridOptions,
+		groupingData: []
+	}), /* @__PURE__ */ React.createElement(FluentDialog, {
+		open: deleteDialogOpen,
+		handleClose: closeDeleteDialog,
+		title: t("Delete Vertical"),
+		message: t("Are you sure you want to Delete") + ` "${selectedVertical?.name}"?`,
+		actionOne: deleteVertical,
+		labelOne: t("Delete"),
+		actionTwo: closeDeleteDialog,
+		labelTwo: t("Cancel")
+	}));
+};
+var UdpVerticalManagementPage_default = UdpVerticalManagementPage;
+
+//#endregion
+//#region src/udp/pages/UdpGridPanelManagementSidesheet.jsx
+/**
+* @param {object} props
+* @param {object} props.selectedGridPanel
+* @param {string} props.environment
+* @param {boolean} props.open
+* @param {Function} props.onClose
+* @param {Function} props.onSubmit
+* @param {string} props.title
+* @param {any[]} props.grids
+* @param {any[]} props.panels
+* @param {any} props.grid
+* @param {Function} props.setGrid
+* @param {any} props.panel
+* @param {Function} props.setPanel
+* @returns {JSX.Element}
+*/
+const UdpGridPanelManagementSidesheet = (props) => {
+	const { selectedGridPanel, environment, open, onClose, onSubmit, title, grids, panels, grid, setGrid, panel, setPanel,...sheetProps } = props;
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		open,
+		onClose: () => onClose(),
+		width: 400,
+		title,
+		buttonLabel: "Save",
+		onSubmit,
+		...sheetProps
+	}, /* @__PURE__ */ React.createElement(FluentTextFieldAutoComplete, {
+		id: "grid",
+		label: "Grid",
+		options: grids,
+		optionKey: "name",
+		onChange: setGrid,
+		value: grid
+	}), /* @__PURE__ */ React.createElement(FluentTextFieldAutoComplete, {
+		id: "panel",
+		label: "Panel",
+		options: panels,
+		optionKey: "name",
+		onChange: setPanel,
+		value: panel
+	}));
+};
+var UdpGridPanelManagementSidesheet_default = UdpGridPanelManagementSidesheet;
+
+//#endregion
+//#region src/udp/pages/UdpGridPanelManagementPage.jsx
+var UdpGridPanelManagementPage_exports = /* @__PURE__ */ __export({ default: () => UdpGridPanelManagementPage_default });
+const UdpGridPanelManagementPage = (props) => {
+	const { params } = props;
+	const { nodeObj: environment } = params;
+	const { t } = useTranslation();
+	const [loading, setLoading] = useState(false);
+	const [gridPanels, setGridPanels] = useState([]);
+	const [grids, setGrids] = useState([]);
+	const [panels, setPanels] = useState([]);
+	const [addSidesheetOpen, setAddSidesheetOpen] = useState(false);
+	const [selectedRow, setSelectedRow] = useState();
+	const [deleteDialogOpen, setDeleteDialogOpen] = useState();
+	const [dataToDelete, setDataToDelete] = useState();
+	const [grid, setGrid] = useState(null);
+	const [panel, setPanel] = useState(null);
+	const { handleErrorSnackbar, handleSuccessSnackbar } = useHandleAxiosSnackbar();
+	const executeMutation = useCallback(async (endpoint, method, data) => apiMutate$1(ConfigService.uemV1ApiUrl, endpoint, { method: method || "post" }, data), []);
+	const getGridPanels = useCallback(async () => {
+		setLoading(true);
+		const response = await executeMutation("uem", "post", { data: {
+			customerId: null,
+			environmentId: environment.environmentId,
+			apiPath: `TenantService/api/v2/gridPanel`
+		} });
+		if (response?.status === 200) setGridPanels(response?.data);
+		setLoading(false);
+	}, [environment?.environmentId, executeMutation]);
+	const getGrids = useCallback(async () => {
+		const response = await executeMutation("uem", "post", { data: {
+			customerId: null,
+			environmentId: environment.environmentId,
+			apiPath: `TenantService/api/v2/grid`
+		} });
+		if (response?.status === 200) setGrids(response?.data);
+	}, [environment?.environmentId, executeMutation]);
+	const getPanels = useCallback(async () => {
+		const response = await executeMutation("uem", "post", { data: {
+			customerId: null,
+			environmentId: environment.environmentId,
+			apiPath: `IntegrationService/api/v2/panel`
+		} });
+		if (response?.status === 200) setPanels(response?.data);
+	}, [environment?.environmentId, executeMutation]);
+	const createGridPanel = useCallback(async () => {
+		setLoading(true);
+		if ((await executeMutation("gridPanel/uemCreate", "post", { data: {
+			customerId: null,
+			gridId: grid.gridId,
+			panelId: panel.panelId,
+			environmentId: environment.environmentId,
+			apiPath: `api/v1/gridPanel/uemCreate`
+		} }))?.status === 201) {
+			handleSuccessSnackbar("GridPanel Created Successfully");
+			getGridPanels();
+			setAddSidesheetOpen(false);
+		} else handleErrorSnackbar("Something went wrong");
+		setLoading(false);
+	}, [
+		environment,
+		executeMutation,
+		getGridPanels,
+		grid,
+		handleErrorSnackbar,
+		handleSuccessSnackbar,
+		panel
+	]);
+	const updateGridPanel = useCallback(async () => {
+		setLoading(true);
+		if ((await executeMutation("gridPanel/uemUpdate", "put", { data: {
+			gridPanelId: selectedRow.gridPanelId,
+			customerId: null,
+			gridId: grid.gridId,
+			panelId: panel.panelId,
+			environmentId: environment.environmentId
+		} }))?.status === 204) {
+			handleSuccessSnackbar("GridPanel Updated Successfully");
+			getGridPanels();
+			setAddSidesheetOpen(false);
+		} else handleErrorSnackbar("Something went wrong");
+		setLoading(false);
+	}, [
+		environment,
+		executeMutation,
+		getGridPanels,
+		grid,
+		handleErrorSnackbar,
+		handleSuccessSnackbar,
+		panel,
+		selectedRow
+	]);
+	const deleteGridPanel = useCallback(async () => {
+		setLoading(true);
+		if ((await executeMutation("gridPanel/uemDelete", "delete", { data: {
+			gridPanelId: dataToDelete.gridPanelId,
+			customerId: null,
+			gridId: dataToDelete.gridId,
+			panelId: dataToDelete.panelId,
+			environmentId: environment.environmentId
+		} }))?.status === 204) {
+			handleSuccessSnackbar("GridPanel Deleted Successfully");
+			getGridPanels();
+		} else handleErrorSnackbar("Something went wrong");
+		setDataToDelete();
+		setLoading(false);
+	}, [
+		environment,
+		executeMutation,
+		getGridPanels,
+		handleErrorSnackbar,
+		handleSuccessSnackbar,
+		dataToDelete
+	]);
+	const openDeleteDialog = (data) => {
+		setDeleteDialogOpen(true);
+		setDataToDelete(data);
+		console.log(data);
+	};
+	useEffect(() => {
+		getGridPanels();
+		getGrids();
+		getPanels();
+	}, [
+		getGridPanels,
+		getGrids,
+		getPanels
+	]);
+	const handleEdit = useCallback((row) => {
+		setSelectedRow(row);
+	}, []);
+	useEffect(() => {
+		if (selectedRow) {
+			const selectedGrid = grids.find((grid$1) => grid$1.gridId === selectedRow.gridId);
+			const selectedPanel = panels.find((panel$1) => panel$1.panelId === selectedRow.panelId);
+			setGrid(selectedGrid);
+			setPanel(selectedPanel);
+			setAddSidesheetOpen(true);
+		}
+	}, [
+		grids,
+		panels,
+		selectedRow
+	]);
+	const actionList = useMemo(() => [{
+		id: 1,
+		title: t("Edit"),
+		icon: EditIcon,
+		onClick: handleEdit,
+		disabled: false
+	}, {
+		id: 2,
+		title: t("Delete"),
+		icon: DeleteIcon,
+		onClick: openDeleteDialog,
+		disabled: false
+	}], [t, handleEdit]);
+	const gridOptions = useMemo(() => ({
+		frameworkComponents: { actionsRenderer: ActionsRenderer },
+		columnDefs: [
+			{
+				headerName: t("gridPanelId"),
+				field: "gridPanelId"
+			},
+			{
+				headerName: t("gridId"),
+				field: "gridId"
+			},
+			{
+				headerName: t("panelId"),
+				field: "panelId"
+			},
+			{
+				headerName: t("Actions"),
+				cellRenderer: "actionsRenderer",
+				cellRendererParams: { actionList },
+				pinned: "right",
+				suppressMenu: true,
+				sortable: false
+			}
+		]
+	}), [actionList, t]);
+	const handleClose = useCallback(() => {
+		setGrid();
+		setPanel();
+		setSelectedRow();
+		setAddSidesheetOpen(false);
+	}, []);
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(UdpGridPanelManagementSidesheet_default, {
+		title: selectedRow ? "Update GridPanel" : "Create GridPanel",
+		open: addSidesheetOpen,
+		onClose: handleClose,
+		environment,
+		grids,
+		panels,
+		grid,
+		setGrid,
+		panel,
+		setPanel,
+		onSubmit: selectedRow ? updateGridPanel : createGridPanel
+	}), /* @__PURE__ */ React.createElement(FluentDialog, {
+		open: deleteDialogOpen,
+		handleClose: () => setDeleteDialogOpen(false),
+		title: t("Delete GridPanel"),
+		message: t("Are you sure?"),
+		actionOne: deleteGridPanel,
+		labelOne: t("Delete"),
+		actionTwo: () => setDeleteDialogOpen(false),
+		labelTwo: t("Cancel")
+	}), /* @__PURE__ */ React.createElement(AmbientGridTemplate, {
+		title: t("Grid Panel Manager"),
+		useNewHeader: true,
+		data: gridPanels,
+		gridOptions,
+		onPrimaryActionClick: () => setAddSidesheetOpen(true),
+		primaryActionLabel: "Add",
+		loading
+	}));
+};
+var UdpGridPanelManagementPage_default = UdpGridPanelManagementPage;
+
+//#endregion
+//#region src/udp/pages/UdpInquiryMaintenanceEnginePage.jsx
+var UdpInquiryMaintenanceEnginePage_exports = /* @__PURE__ */ __export({ default: () => UdpInquiryMaintenanceEnginePage_default });
+const UdpInquiryMaintenanceEnginePage = (props) => {
+	const { params } = props;
+	const { nodeObj } = params;
+	const [loading, setLoading] = useState(false);
+	const [{ data: catalogKey, loading: catalogKeyLoading }] = useAxiosGet(ConfigService.productV1ApiUrl, `UdpObjectInfo/getCatalogId/${nodeObj.businessObjectKey}?fromUdpObjectInfo=true`, {}, !!!nodeObj, false);
+	useEffect(() => {
+		setLoading(catalogKeyLoading);
+	}, [catalogKeyLoading]);
+	return /* @__PURE__ */ React.createElement(UdpMaintenanceEnginePage, { catalogKey: catalogKey || "" });
+};
+var UdpInquiryMaintenanceEnginePage_default = UdpInquiryMaintenanceEnginePage;
+
+//#endregion
+//#region src/udp/pages/UdpReportsPage.jsx
+var UdpReportsPage_exports = /* @__PURE__ */ __export({ default: () => UdpReportsPage_default });
+const UdpReportsPage = (props) => {
+	const { params } = props;
+	return /* @__PURE__ */ React.createElement(PowerBIReport, { id: params?.pbiReportCode || null });
+};
+var UdpReportsPage_default = UdpReportsPage;
+
+//#endregion
+//#region src/UI/widgets/FluentComponents/atoms/FluentTrendArrow.jsx
+const useStyles$9 = makeStyles((theme) => ({
+	root: {},
+	DownArrow: {
+		color: colors.red[500],
+		fontSize: 16
+	},
+	UpArrow: {
+		color: colors.green[500],
+		fontSize: 16
+	}
+}));
+const FluentTrendArrow = (props) => {
+	const { type } = props;
+	const classes = useStyles$9();
+	let trend = "";
+	switch (type) {
+		case "up":
+			trend = /* @__PURE__ */ React.createElement(UpArrow, { className: classes.UpArrow });
+			break;
+		case "down":
+			trend = /* @__PURE__ */ React.createElement(DownArrow, { className: classes.DownArrow });
+			break;
+		default:
+	}
+	return trend;
+};
+var FluentTrendArrow_default = FluentTrendArrow;
+
+//#endregion
+//#region src/UI/widgets/FluentComponents/atoms/FluentStatsSnippet.jsx
+const useStyles$8 = makeStyles((theme) => ({
+	root: {},
+	percent: {
+		display: "flex",
+		flexDirection: "row",
+		marginTop: theme.spacing(-.5)
+	},
+	arrow: {
+		display: "flex",
+		flexDirection: "column",
+		justifyContent: "center"
+	},
+	percentAmount: {}
+}));
+const FluentStatsSnippet = (props) => {
+	const classes = useStyles$8(props);
+	const { label, amount: rawAmount, prevAmount, percent: percentProp, trend: trendProp } = props;
+	let amount = rawAmount;
+	if (Math.abs(rawAmount) > 1e6) {
+		let newNumber = rawAmount / 1e6;
+		amount = [Math.round(newNumber * 10) / 10, "M"];
+	} else if (Math.abs(rawAmount) > 1e3) {
+		let newNumber = rawAmount / 1e3;
+		amount = [Math.round(newNumber * 10) / 10, "K"];
+	}
+	let percent = percentProp;
+	let trend = trendProp;
+	if (typeof prevAmount === "number") {
+		const ratio = (rawAmount - prevAmount) / prevAmount;
+		percent = Math.abs(round(ratio * 100, Math.abs(ratio) < .01 ? .01 : 1)) + "%";
+		trend = ratio < 0 ? "down" : "up";
+	}
+	return /* @__PURE__ */ React.createElement("div", { className: classes.root }, /* @__PURE__ */ React.createElement(Typography, {
+		variant: "overline",
+		component: "div"
+	}, label), /* @__PURE__ */ React.createElement(Typography, {
+		className: classes.stat,
+		variant: "h5",
+		component: "div"
+	}, amount), /* @__PURE__ */ React.createElement("div", { className: classes.percent }, /* @__PURE__ */ React.createElement("div", { className: classes.arrow }, /* @__PURE__ */ React.createElement(FluentTrendArrow_default, { type: trend })), /* @__PURE__ */ React.createElement("div", { className: classes.percentAmount }, /* @__PURE__ */ React.createElement(Typography, { variant: "caption" }, percent))));
+};
+var FluentStatsSnippet_default = FluentStatsSnippet;
+
+//#endregion
+//#region src/UI/widgets/FluentComponents/ChartSummaryToggle.jsx
+const ChartSummaryToggle = (props) => {
+	const { value, onChange } = props;
+	const change = useCallback((e, value$1) => onChange && onChange(value$1), [onChange]);
+	return /* @__PURE__ */ React.createElement(ToggleButtonGroup, {
+		value,
+		exclusive: true,
+		onChange: change,
+		"aria-label": "chart summary mode toggle"
+	}, /* @__PURE__ */ React.createElement(ToggleButton, {
+		name: "chart-summary-mode",
+		value: "summary",
+		"aria-label": "summary"
+	}, /* @__PURE__ */ React.createElement(FluentIcon, { component: NumberedListIcon })), /* @__PURE__ */ React.createElement(ToggleButton, {
+		name: "chart-summary-mode",
+		value: "chart",
+		"aria-label": "chart"
+	}, /* @__PURE__ */ React.createElement(FluentIcon, { component: ChartIcon })));
+};
+var ChartSummaryToggle_default = ChartSummaryToggle;
+
+//#endregion
+//#region src/UI/widgets/utils/ConvertISODate.js
+const convertISODate = (isoDate) => {
+	return new Date(isoDate).toLocaleDateString("en-US");
+};
+
+//#endregion
+//#region src/UI/widgets/library/DonutChartWidget.jsx
+var DonutChartWidget_exports = /* @__PURE__ */ __export({
+	default: () => DonutChartWidget_default,
+	layout: () => layout$2
+});
+const layout$2 = {
+	w: {
+		default: 2,
+		min: 0,
+		max: 4
+	},
+	h: {
+		default: 2,
+		min: 0,
+		max: 4
+	}
+};
+const DonutChartWidget = (props, ref) => {
+	const { children, params, setParam,...other } = props;
+	const { mockData, apiUrl, theme, dateRange } = params;
+	let body = /* @__PURE__ */ React.createElement(Fragment, null, dateRange && /* @__PURE__ */ React.createElement(Typography, {
+		gutterBottom: true,
+		variant: "caption",
+		component: "h3"
+	}, "From: ", convertISODate(dateRange.from), " to:", " ", convertISODate(dateRange.to)), /* @__PURE__ */ React.createElement(Grid, { container: true }, mockData?.stats?.map((stat) => /* @__PURE__ */ React.createElement(Grid, {
+		item: true,
+		xs: 3,
+		key: stat.label
+	}, /* @__PURE__ */ React.createElement(FluentStatsSnippet_default, {
+		label: stat.label,
+		amount: stat.currentValue,
+		prevAmount: stat.previousValue
+	})))), /* @__PURE__ */ React.createElement(Box, {
+		clone: true,
+		flex: 1,
+		mt: 1,
+		overflow: "hidden"
+	}, /* @__PURE__ */ React.createElement(MuiVegaLite, {
+		variant: "donutChart",
+		style: {
+			overflow: "auto",
+			display: "flex",
+			alignItems: "center",
+			justifyContent: "center",
+			padding: 0
+		},
+		spec: {
+			$schema: "https://vega.github.io/schema/vega/v5.json",
+			width: 200,
+			height: 200,
+			data: [{
+				name: "table",
+				values: mockData?.data,
+				transform: [{
+					type: "pie",
+					field: "value"
+				}]
+			}, {
+				name: "used",
+				source: "table",
+				transform: [
+					{
+						type: "formula",
+						expr: "datum.id === 'Other' ? 'Other' : 'Main'",
+						as: "id"
+					},
+					{
+						type: "aggregate",
+						fields: ["field"],
+						groupby: ["id"],
+						ops: ["sum"],
+						as: ["sum"]
+					},
+					{
+						type: "pivot",
+						field: "label",
+						value: "sum"
+					}
+				]
+			}],
+			scales: [{
+				name: "color",
+				type: "ordinal",
+				domain: {
+					data: "table",
+					field: "label"
+				},
+				range: { scheme: "greys" }
+			}],
+			marks: [{
+				type: "arc",
+				from: { data: "table" },
+				encode: {
+					enter: {
+						fill: {
+							scale: "color",
+							field: "label"
+						},
+						x: { signal: "width / 2" },
+						y: { signal: "height / 2" },
+						padAngle: { value: .01 }
+					},
+					update: {
+						startAngle: { field: "startAngle" },
+						endAngle: { field: "endAngle" },
+						innerRadius: { signal: "width / 2 - 10" },
+						outerRadius: { signal: "width / 2" }
+					}
+				}
+			}, {
+				type: "text",
+				from: { data: "used" },
+				style: ["percent"],
+				encode: { enter: {
+					x: { signal: "width / 2" },
+					y: { signal: "height / 2" },
+					align: { value: "center" },
+					baseline: { value: "middle" },
+					fontSize: { value: 24 }
+				} }
+			}],
+			legends: [{
+				fill: "color",
+				direction: "vertical",
+				encode: { labels: {
+					name: "legendLabel",
+					enter: { text: { field: "label" } }
+				} },
+				orient: "right",
+				labelColor: theme === "dark" ? "white" : "rgba(0, 0, 0, 0.87)"
+			}]
+		}
+	})), children);
+	return /* @__PURE__ */ React.createElement(WidgetCard_default, {
+		theme,
+		ref,
+		headerActions: /* @__PURE__ */ React.createElement(ChartSummaryToggle_default, {
+			value: params.mode,
+			onChange: (value) => setParam("mode", value)
+		}),
+		...other,
+		title: mockData?.title
+	}, mockData ? body : /* @__PURE__ */ React.createElement(Typography, { variant: "subtitle2" }, "Could not retrieve widget data. Please contact support."));
+};
+var DonutChartWidget_default = forwardRef(DonutChartWidget);
+
+//#endregion
+//#region src/UI/widgets/library/SparklineWidget.jsx
+var SparklineWidget_exports = /* @__PURE__ */ __export({
+	default: () => SparklineWidget_default,
+	layout: () => layout$1
+});
+const layout$1 = {
+	w: {
+		default: 2,
+		min: 0,
+		max: 4
+	},
+	h: {
+		default: 2,
+		min: 0,
+		max: 4
+	}
+};
+const useStyles$7 = makeStyles((theme) => ({ statList: {
+	display: "flex",
+	flexDirection: "row",
+	justifyContent: "space-between"
+} }));
+const SparklineWidget = (props, ref) => {
+	const classes = useStyles$7();
+	const { children, params, setParam,...other } = props;
+	const { mockData, apiUrl, theme, dateRange } = params;
+	return /* @__PURE__ */ React.createElement(WidgetCard_default, {
+		className: classes.root,
+		theme,
+		ref,
+		...other,
+		title: mockData?.title
+	}, mockData ? /* @__PURE__ */ React.createElement(Fragment, null, dateRange && /* @__PURE__ */ React.createElement(Typography, {
+		gutterBottom: true,
+		variant: "caption",
+		component: "h3"
+	}, "From: ", convertISODate(dateRange.from), " to:", " ", convertISODate(dateRange.to)), /* @__PURE__ */ React.createElement("div", { className: classes.statList }, mockData?.stats?.map((stat) => /* @__PURE__ */ React.createElement(Grid, {
+		item: true,
+		key: stat.label
+	}, /* @__PURE__ */ React.createElement(FluentStatsSnippet_default, {
+		label: stat.label,
+		amount: stat.amount,
+		percent: stat.percent && stat.percent,
+		trend: stat.trend
+	})))), /* @__PURE__ */ React.createElement(Sparklines, {
+		data: mockData?.data,
+		strokeWidth: .5
+	}, /* @__PURE__ */ React.createElement(SparklinesLine, { color: "#067e7e" })), children) : /* @__PURE__ */ React.createElement(Typography, { variant: "subtitle2" }, "Could not retrieve widget data. Please contact support."));
+};
+var SparklineWidget_default = forwardRef(SparklineWidget);
+
+//#endregion
+//#region src/UI/widgets/FluentComponents/molecules/FluentStatNumber.jsx
+const useStyles$6 = makeStyles((theme) => ({
+	root: {
+		display: "flex",
+		flexDirection: "row"
+	},
+	caption: { textAlign: "left" },
+	captionSmall: { textAlign: "center" },
+	trend: {
+		marginTop: theme.spacing(2),
+		marginLeft: theme.spacing(1)
+	},
+	upIcon: { color: "green" },
+	downIcon: { color: "#D50000" },
+	avatar: { backgroundColor: "white" }
+}), { next: "FluentStatNumber" });
+const FluentStatNumber = (props) => {
+	const classes = useStyles$6();
+	const { small, trend, label, number } = props;
+	return /* @__PURE__ */ React.createElement("div", { className: classes.root }, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(FluentDisplayNumbers_default, {
+		small,
+		number: Math.abs(number)
+	})), /* @__PURE__ */ React.createElement("div", { className: !small ? classes.caption : classes.captionSmall }, /* @__PURE__ */ React.createElement(Typography, { variant: "overline" }, label))), /* @__PURE__ */ React.createElement("div", { className: classes.trend }, small && /* @__PURE__ */ React.createElement(Avatar, { className: classes.avatar }, trend === "down" ? /* @__PURE__ */ React.createElement(FluentIcon, {
+		component: MarketDownIcon,
+		className: classes.downIcon
+	}) : /* @__PURE__ */ React.createElement(FluentIcon, {
+		component: MarketIcon,
+		className: classes.upIcon
+	}))));
+};
+var FluentStatNumber_default = FluentStatNumber;
+
+//#endregion
+//#region src/UI/widgets/FluentComponents/molecules/FluentPrimaryStatNumber.jsx
+const useStyles$5 = makeStyles((theme) => ({
+	displayRow: {
+		display: "flex",
+		flexDirection: "row"
+	},
+	smallDisplay: {
+		marginTop: theme.spacing(6),
+		marginLeft: theme.spacing(3)
+	},
+	divider: {
+		height: theme.spacing(6),
+		marginTop: theme.spacing(6.5),
+		marginLeft: theme.spacing(2)
+	}
+}), { next: "FluentPrimaryStatNumber" });
+const FluentPrimaryStatNumber = (props) => {
+	const classes = useStyles$5();
+	const { mainStat, mainLabel } = props;
+	return /* @__PURE__ */ React.createElement("div", { className: classes.displayRow }, /* @__PURE__ */ React.createElement(FluentStatNumber_default, {
+		label: mainLabel,
+		number: mainStat
+	}));
+};
+var FluentPrimaryStatNumber_default = FluentPrimaryStatNumber;
+
+//#endregion
+//#region src/UI/widgets/FluentComponents/molecules/FluentSecondaryStatNumber.jsx
+const useStyles$4 = makeStyles((theme) => ({
+	displayRow: {
+		display: "flex",
+		flexDirection: "row"
+	},
+	divider: {
+		height: theme.spacing(6),
+		marginTop: theme.spacing(6.5),
+		marginLeft: theme.spacing(1)
+	}
+}));
+const FluentSecondaryStatNumber = (props) => {
+	const classes = useStyles$4();
+	const { secondaryStat, secondaryLabel, trend } = props;
+	return /* @__PURE__ */ React.createElement("div", { className: classes.displayRow }, /* @__PURE__ */ React.createElement("div", { className: classes.smallDisplay }, /* @__PURE__ */ React.createElement(FluentStatNumber_default, {
+		small: true,
+		trend,
+		label: secondaryLabel,
+		number: secondaryStat
+	})));
+};
+var FluentSecondaryStatNumber_default = FluentSecondaryStatNumber;
+
+//#endregion
+//#region src/UI/widgets/library/ProgressBarWidget.jsx
+var ProgressBarWidget_exports = /* @__PURE__ */ __export({
+	default: () => ProgressBarWidget_default,
+	layout: () => layout
+});
+const layout = {
+	w: {
+		default: 2,
+		min: 0,
+		max: 4
+	},
+	h: {
+		default: 2,
+		min: 0,
+		max: 4
+	}
+};
+const useStyles$3 = makeStyles((theme) => ({
+	root: {},
+	displayItems: {
+		display: "flex",
+		flexDirection: "row",
+		justifyContent: "space-around",
+		color: "white"
+	},
+	divider: {
+		marginTop: theme.spacing(4),
+		marginBottom: theme.spacing(2)
+	}
+}));
+const ProgressBarWidget = (props, ref) => {
+	const { children, params, setParam,...other } = props;
+	const { mockData, apiUrl, theme, dateRange } = params;
+	const classes = useStyles$3();
+	return /* @__PURE__ */ React.createElement(WidgetCard_default, {
+		theme,
+		ref,
+		...other,
+		title: mockData?.title,
+		widgetType: "ProgressBarWidget"
+	}, mockData ? /* @__PURE__ */ React.createElement(Fragment, null, dateRange && /* @__PURE__ */ React.createElement(Typography, {
+		gutterBottom: true,
+		variant: "caption",
+		component: "h3"
+	}, "Starting: ", convertISODate(dateRange.from)), /* @__PURE__ */ React.createElement(FluentPrimaryStatNumber_default, {
+		mainStat: mockData?.value,
+		mainLabel: mockData?.label
+	}), /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(LinearProgress, {
+		variant: "determinate",
+		color: "secondary",
+		value: mockData?.progress
+	}), mockData?.progress, "%"), mockData?.data && /* @__PURE__ */ React.createElement(Fragment, null, /* @__PURE__ */ React.createElement("div", { className: classes.divider }, /* @__PURE__ */ React.createElement(Divider, { style: {
+		background: "white",
+		opacity: .5
+	} })), /* @__PURE__ */ React.createElement("div", { className: classes.displayItems }, mockData?.data.map((item, index) => {
+		return /* @__PURE__ */ React.createElement(FluentSecondaryStatNumber_default, {
+			secondaryStat: item.value,
+			secondaryLabel: item.label,
+			trend: item.trend
+		});
+	}))), children) : /* @__PURE__ */ React.createElement(Typography, { variant: "subtitle2" }, "Could not retrieve widget data. Please contact support."));
+};
+var ProgressBarWidget_default = forwardRef(ProgressBarWidget);
+
+//#endregion
+//#region src/UI/widgets/library/RecentlyLoadedNodesWidget.jsx
+var RecentlyLoadedNodesWidget_exports = /* @__PURE__ */ __export({
+	RecentlyLoadedNodesWidget: () => RecentlyLoadedNodesWidget,
+	default: () => RecentlyLoadedNodesWidget_default
+});
+const RecentlyLoadedNodesWidget = (props, ref) => {
+	const { children, params, setParam,...other } = props;
+	const { recentlyLoadedNodes, loading, onLoadedNodeClick, tree, hideWidgetName } = params;
+	return /* @__PURE__ */ React.createElement(WidgetCard_default, {
+		ref,
+		title: "Recently Loaded",
+		hideWidgetName,
+		...other
+	}, /* @__PURE__ */ React.createElement(RecentlyLoadedNodesTable, {
+		recentlyLoadedNodes,
+		loading,
+		onLoadedNodeClick,
+		tree,
+		hideTitle: true
+	}), children);
+};
+var RecentlyLoadedNodesWidget_default = forwardRef(RecentlyLoadedNodesWidget);
+
+//#endregion
+//#region src/udp/pages/ChatUDP.jsx
+var ChatUDP_exports = /* @__PURE__ */ __export({ default: () => ChatUDP_default });
+const ChatUDP = () => {
+	return /* @__PURE__ */ React.createElement(ChatContainer, null);
+};
+var ChatUDP_default = ChatUDP;
+
+//#endregion
+//#region src/udp/pages/UdpDataBrowserPage.jsx
+var UdpDataBrowserPage_exports = /* @__PURE__ */ __export({
+	UdpDataBrowserPage: () => UdpDataBrowserPage,
+	default: () => UdpDataBrowserPage_default
+});
+const UdpDataBrowserPage = (props) => {
+	const { queryId, params } = props;
+	const user = useAuthedUser();
+	const { t } = useTranslation();
+	const [entityData, setEntityData] = useState([]);
+	const [gridApi, setGridApi] = useState(null);
+	const [alertWarnings, setAlertWarnings] = useState([]);
+	const location = useLocation();
+	const state = location.state;
+	let searchParamStr = location.search;
+	let searchParams = new URLSearchParams(searchParamStr);
+	const searchParamsQueryId = state?.queryId ? state.queryId : searchParams.has("queryId") === true ? toUpperFirstChar(searchParams.get("queryId")) : "";
+	const { handleErrorSnackbar, handleSuccessSnackbar } = useHandleAxiosSnackbar();
+	const { getCleanData } = useQueryExecutors();
+	const udpQueryId = useMemo(() => params?.queryId || queryId || searchParamsQueryId || "", [
+		params,
+		queryId,
+		searchParamsQueryId
+	]);
+	const udpTagId = params?.udpTagId || "";
+	const [selectedEntity, setSelectedEntity] = useState(null);
+	const [foreignKeyData, setForeignKeyData] = useState(null);
+	const [udpFieldSearchApiId, setUdpFieldSearchApiId] = useState(null);
+	const [loading, setLoading] = useState(false);
+	const [apiCatalogId, setApiCatalogId] = useState(null);
+	const [entityName, setEntityName] = useState(null);
+	const [enteredFromConfig, setEnteredFromConfig] = useState(false);
+	const { data: catalog } = useApiCatalog(apiCatalogId);
+	const { data: udpOjectFieldInfo } = usePromotedMethodEntity("UdpObjectFieldInfo", true);
+	const { getQueryFilterElements } = useSearchFilterParamsMap();
+	const [{ data: tpacb, loading: tpacbLoading, error: tpacbError }] = useAxiosGet(ConfigService.integrationV1ApiUrl, `tenantProductApiCatalogBase/tenant/${user?.currentTenantId}/product/${ConfigService.config.UNITY_PRODUCT_ID}`, {}, !!!user, false);
+	const [{ data: apiMethodInstance, loading: apiMethodInstancebLoading, error: apiMethodInstanceError }] = useAxiosGet(ConfigService.integrationV1ApiUrl, `apiMethodInstance/${udpQueryId}`, {}, !!!udpQueryId, false);
+	const [{ data: apiMethod, loading: apiMethodLoading, error: apiMethodError }] = useAxiosGet(ConfigService.integrationV1ApiUrl, `apiMethod/${apiMethodInstance?.apiMethodId}`, {}, !!!apiMethodInstance?.apiMethodId, false);
+	const udpCatalogKey = useMemo(() => apiMethod?.entityName || "", [apiMethod]);
+	const { data: promotedMethodEntities, loading: promotedMethodsLoading } = usePromotedMethodEntity(entityName);
+	const executeCreate = useCallback(async (data) => apiMutate$1(ConfigService.integrationV1ApiUrl, `apimethod/executeQueryWithParameters/${selectedEntity?.unityBaseCreateMethod?.apiMethodId}`, { method: "post" }, data), [selectedEntity]);
+	const executeUpdate = useCallback(async (data) => apiMutate$1(ConfigService.integrationV1ApiUrl, `apimethod/executeQueryWithParameters/${selectedEntity?.unityBaseUpdateMethod?.apiMethodId}`, { method: "post" }, data), [selectedEntity]);
+	const executeDelete = useCallback(async (data) => apiMutate$1(ConfigService.integrationV1ApiUrl, `apimethod/executeQueryWithParameters/${selectedEntity?.unityBaseDeleteMethod?.apiMethodId}`, { method: "post" }, data), [selectedEntity]);
+	const onCreate = useCallback(async (data) => {
+		return await executeCreate(data);
+	}, [executeCreate]);
+	const onUpdate = useCallback(async (data) => {
+		return await executeUpdate(data);
+	}, [executeUpdate]);
+	const onDelete = useCallback(async (data) => {
+		return await executeDelete(data);
+	}, [executeDelete]);
+	const queryColumnsData = useMemo(() => {
+		if (!apiMethodInstance) return [];
+		let catalogMods = [];
+		try {
+			const catalogModificationStr = apiMethodInstance.catalogModification;
+			catalogMods = JSON.parse(catalogModificationStr);
+		} catch {
+			console.warn("Error parsing apiMethodInstance catalogModification");
+		}
+		return catalogMods;
+	}, [apiMethodInstance]);
+	const lookupsMap = useMemo(() => {
+		if (!queryColumnsData.length) return null;
+		const map = {};
+		queryColumnsData.filter((column) => !!column.extendedProperties?.lookup).forEach((lc) => {
+			map[lc.name] = {
+				lookupKeyName: lc.extendedProperties?.lookupKeyName || "",
+				lookupValueName: lc.extendedProperties?.lookupKeyName || "",
+				value: lc.extendedProperties?.lookup || "",
+				filterOn: !!lc.filterOn || false
+			};
+		});
+		return map;
+	}, [queryColumnsData]);
+	const nodeFilterParams = useMemo(() => {
+		let filterParams = [];
+		if (params?.nodeObj && params?.queryParamMapping) {
+			const mappedParameters = mapNodeObjValuesToSearchParameters(params.nodeObj, params.queryParamMapping);
+			if (Object.keys(mappedParameters).length) Object.keys(mappedParameters).forEach((key) => {
+				filterParams.push({
+					name: key,
+					value: mappedParameters[key],
+					type: "string"
+				});
+			});
+		}
+		return filterParams;
+	}, [params]);
+	const searchFilterElements = useMemo(() => {
+		const filterElements = [];
+		if (!enteredFromConfig && udpTagId) filterElements.push({
+			searchField: "UdpTags.UdpTagAssociationUdpTag.Id",
+			searchOperator: "=",
+			searchValue: udpTagId
+		});
+		const queryFilterElements = getQueryFilterElements(apiMethodInstance, nodeFilterParams);
+		return filterElements.concat(queryFilterElements);
+	}, [
+		udpTagId,
+		enteredFromConfig,
+		getQueryFilterElements,
+		apiMethodInstance,
+		nodeFilterParams
+	]);
+	const entityAttributes = useMemo(() => {
+		return getEntityAttributes(catalog, entityName);
+	}, [catalog, entityName]);
+	const getMetaDataForUdpField = useCallback(async (entityName$1) => {
+		let fieldInfos = [];
+		if (udpFieldSearchApiId) executeQueryAdHoc({ data: getSearchObject([{
+			searchField: "ObjectInfo.SanitizedName",
+			searchOperator: "=",
+			searchValue: entityName$1
+		}], 1, 50, true) }, udpFieldSearchApiId).then((resp) => {
+			fieldInfos = resp.data?.pageList;
+		});
+		return fieldInfos;
+	}, [udpFieldSearchApiId]);
+	const getFKMethodEntities = useCallback(async (attributes) => {
+		if (!attributes) return [];
+		let fkMethods = [];
+		for (const attr of attributes) if (attr?.extendedProperties?.childEntity) {
+			const ceFieldsArr = [];
+			Object.keys(attr.extendedProperties.childEntityAssoc || {}).length && (attr.extendedProperties.childEntityAssoc.Cardinality === CardinalityTypeEnums.Many_To_Many || attr.extendedProperties.childEntityAssoc.Cardinality === CardinalityTypeEnums.One_To_Many) && !attr.extendedProperties.childEntityAssoc.UdpType && attr.extendedProperties.childEntityAssoc.Keys.forEach((value, i) => {
+				const name = value.split(",")[0];
+				if (name) ceFieldsArr.push({
+					idx: i,
+					name: /^[A-Z]*$/.test(name) ? name.toLowerCase() : toLowerFirstChar(name)
+				});
+			});
+			const ceAttr = attributes.find((p) => ceFieldsArr.find((cef) => cef.name === p.name));
+			if (ceAttr) await apiMutate$1(ConfigService.integrationV1ApiUrl, `apicatalog/${apiCatalogId}/promotedMethodEntities/${attr.reference}/product/${ConfigService.config.UNITY_PRODUCT_ID}`, { method: "get" }, {}).then((resp) => {
+				if (resp && resp.data) fkMethods.push({
+					entityAttribute: ceAttr,
+					entity: resp.data
+				});
+			});
+		}
+		return fkMethods;
+	}, [apiCatalogId]);
+	const getFKAssociationLabel = useCallback(async (entityName$1) => {
+		let fieldsInfo = [];
+		fieldsInfo = await getMetaDataForUdpField(entityName$1);
+		if (fieldsInfo?.length <= 0) return "";
+		return (fieldsInfo?.find((fi) => fi.properties?.maintainenceConfig?.associationLabel === "true"))?.name;
+	}, [getMetaDataForUdpField]);
+	const getDataByKey = (obj, k) => {
+		if (!obj) return null;
+		let val = obj[k] ?? null;
+		if (!val) {
+			const key = Object.keys(obj).find((objKey) => objKey.toLowerCase().includes(k));
+			if (key) val = obj[key];
+		}
+		return val;
+	};
+	const getFKData = useCallback(async () => {
+		if (!entityAttributes?.length) return null;
+		const fkMethods = await getFKMethodEntities(entityAttributes);
+		if (!fkMethods?.length) {
+			setForeignKeyData([]);
+			return [];
+		}
+		let fkData = [];
+		let promises = [];
+		let promiseDetails = [];
+		const warnings = [];
+		for (const method of fkMethods) if (method && method?.entity?.unityBaseGetAllMethod) {
+			const associationLabel = await getFKAssociationLabel(method.entity.entityName);
+			promiseDetails.push({
+				url: ConfigService.integrationV1ApiUrl + `/apimethod/executeQueryWithParameters/${method?.entity?.unityBaseGetAllMethod?.apiMethodId}`,
+				fieldName: method.entityAttribute.name,
+				name: method.entity.entityName,
+				associationLabel
+			});
+			promises.push(apiMutate$1(ConfigService.integrationV1ApiUrl, `apimethod/executeQueryWithParameters/${method?.entity?.unityBaseGetAllMethod?.apiMethodId}`, { method: "post" }, { data: {} }));
+		} else warnings.push({
+			id: v4(),
+			message: `${method.entity.entityName}'s Get-All method needs to be promoted`
+		});
+		setAlertWarnings(warnings);
+		Promise.all(promises).then((resp) => {
+			resp.forEach((response, index) => {
+				if (response.status === 200) {
+					if (response?.data) {
+						let respData = [];
+						const promiseDetail = promiseDetails.find((p) => p.url === response?.config?.url && !fkData.find((fd) => fd.entityName === p.Name && fd.fieldName === p.fieldName));
+						response.data.forEach((d) => {
+							const id = getDataByKey(d, promiseDetail?.fieldName && d[promiseDetail.fieldName] ? promiseDetail.fieldName : "id");
+							const name = getDataByKey(d, toLowerFirstChar(promiseDetail.associationLabel) || "name");
+							respData.push({
+								id,
+								name: name ?? id
+							});
+						});
+						fkData.push({
+							fieldName: promiseDetail.fieldName,
+							entityName: promiseDetail.name,
+							name: promiseDetail.fieldName,
+							data: respData
+						});
+					}
+				}
+			});
+			setForeignKeyData(fkData);
+		});
+	}, [
+		entityAttributes,
+		getFKMethodEntities,
+		getFKAssociationLabel
+	]);
+	const handleOnCreate = useCallback(async (values) => {
+		if (selectedEntity) {
+			const entityName$1 = selectedEntity?.entityName;
+			if (selectedEntity?.unityBaseCreateMethod) {
+				const response = await onCreate({ data: { requestBody: values } }).catch((res) => {
+					handleErrorSnackbar(res);
+				});
+				if (response?.status === 200) {
+					handleSuccessSnackbar(entityName$1 ? t(`${entityName$1} has been created`) : t(`Entity has been created`));
+					gridApi?.refreshServerSideStore();
+					return response;
+				}
+			}
+		}
+	}, [
+		selectedEntity,
+		onCreate,
+		t,
+		handleErrorSnackbar,
+		handleSuccessSnackbar,
+		gridApi
+	]);
+	const handleOnUpdate = useCallback(async (values, primaryKeyValues) => {
+		if (selectedEntity) {
+			const entityName$1 = selectedEntity?.entityName;
+			if (selectedEntity?.unityBaseUpdateMethod) {
+				const pathObject = getPathObject(selectedEntity.unityBaseUpdateMethod.pathParameters, primaryKeyValues);
+				let data = { requestBody: values };
+				if (Array.isArray(pathObject)) pathObject.forEach((po) => {
+					data[Object.keys(po)[0]] = po[Object.keys(po)[0]];
+				});
+				else data = {
+					...pathObject,
+					requestBody: values
+				};
+				if ((await onUpdate({ data }).catch((res) => {
+					handleErrorSnackbar(res);
+				}))?.status === 200) {
+					handleSuccessSnackbar(entityName$1 ? t(`${entityName$1} has been updated`) : t(`Entity has been updated`));
+					gridApi?.refreshServerSideStore();
+				}
+			}
+		}
+	}, [
+		selectedEntity,
+		onUpdate,
+		t,
+		gridApi,
+		handleErrorSnackbar,
+		handleSuccessSnackbar
+	]);
+	const handleOnDelete = useCallback(async (value) => {
+		value = getCleanData(value, lookupsMap);
+		if (selectedEntity) {
+			const entityName$1 = selectedEntity?.entityName;
+			if (selectedEntity?.unityBaseDeleteMethod) {
+				const primaryKeyValues = getPrimaryKeyValues(entityAttributes, value);
+				const pathObject = getPathObject(selectedEntity?.unityBaseDeleteMethod.pathParameters, primaryKeyValues);
+				let data = {};
+				if (Array.isArray(pathObject)) pathObject.forEach((po) => {
+					data[Object.keys(po)[0]] = po[Object.keys(po)[0]];
+				});
+				else data = { ...pathObject };
+				if ((await onDelete({ data }).catch((res) => {
+					handleErrorSnackbar(res);
+				}))?.status === 200) {
+					handleSuccessSnackbar(entityName$1 ? t(`${entityName$1} has been deleted`) : t(`Entity has been deleted`));
+					gridApi?.refreshServerSideStore();
+				}
+			}
+		}
+	}, [
+		selectedEntity,
+		entityAttributes,
+		onDelete,
+		t,
+		gridApi,
+		handleErrorSnackbar,
+		handleSuccessSnackbar,
+		getCleanData,
+		lookupsMap
+	]);
+	const handleEntitySelect = useCallback((entityName$1) => {
+		setAlertWarnings([]);
+		setEntityName(entityName$1);
+		setEnteredFromConfig(true);
+	}, []);
+	const removeWarning = useCallback((id) => {
+		setAlertWarnings(alertWarnings.filter((warning) => warning.id !== id));
+	}, [alertWarnings]);
+	const actionList = useMemo(() => {
+		if (!selectedEntity) return;
+		const data = getCleanData(entityData, lookupsMap);
+		const actions = [{
+			id: 1,
+			title: selectedEntity?.unityBaseUpdateMethod ? t("Edit") : t("Edit Method Not Accessible"),
+			icon: EditIcon,
+			onClick: null,
+			opens: "sideSheet",
+			loading: !!!foreignKeyData,
+			view: {
+				component: CrudTableSidePanel,
+				properties: {
+					entityAttributes,
+					foreignKeyData,
+					crudTableEditionData: null,
+					onUpdate: handleOnUpdate,
+					valuePropName: "crudTableEditionData",
+					closeSideSheet: null,
+					closeSideSheetPropName: "closeSideSheet",
+					pageId: selectedEntity?.unityBaseUpdateMethod?.pageId,
+					isNewEntry: false,
+					entityName,
+					entityData: data
+				}
+			},
+			disabled: !!!selectedEntity?.unityBaseUpdateMethod
+		}, {
+			id: 2,
+			title: selectedEntity?.unityBaseDeleteMethod ? t("Delete") : t("Delete Method Not Accessible"),
+			icon: DeleteIcon,
+			onClick: null,
+			opens: "dialog",
+			loading: !!!foreignKeyData,
+			view: {
+				component: null,
+				properties: {
+					title: t("Delete"),
+					message: t("Are you sure you want to delete this row?"),
+					labelOne: t("Cancel"),
+					actionTwo: handleOnDelete,
+					labelTwo: t("Confirm")
+				}
+			},
+			disabled: !!!selectedEntity?.unityBaseDeleteMethod
+		}];
+		if (params?.loadInquiryNode && params?.displayLoadNodeButton) actions.push({
+			id: 5,
+			title: t("Load to Tree"),
+			icon: UploadIcon,
+			onClick: (value) => {
+				const obj = getCleanData(value, lookupsMap);
+				params.loadInquiryNode(obj);
+			},
+			loading: !!!foreignKeyData,
+			view: {}
+		});
+		return actions;
+	}, [
+		selectedEntity,
+		t,
+		entityAttributes,
+		foreignKeyData,
+		handleOnUpdate,
+		handleOnDelete,
+		entityName,
+		entityData,
+		getCleanData,
+		lookupsMap,
+		params
+	]);
+	useEffect(() => {
+		const setFrKeyData = async () => {
+			await getFKData();
+		};
+		if (entityAttributes && udpFieldSearchApiId !== null) setFrKeyData();
+	}, [
+		entityAttributes,
+		getFKData,
+		udpFieldSearchApiId
+	]);
+	useEffect(() => {
+		if (promotedMethodEntities) setSelectedEntity(promotedMethodEntities);
+	}, [promotedMethodEntities]);
+	useEffect(() => {
+		if (udpOjectFieldInfo) setUdpFieldSearchApiId(udpOjectFieldInfo?.unityBaseSearchMethod?.apiMethodId || "");
+	}, [udpOjectFieldInfo]);
+	useEffect(() => {
+		setAlertWarnings([]);
+		if (udpCatalogKey) setEntityName(udpCatalogKey);
+	}, [udpCatalogKey]);
+	useEffect(() => {
+		if (tpacb) setApiCatalogId(tpacb.apiCatalogId);
+	}, [tpacb]);
+	useEffect(() => {
+		setLoading(tpacbLoading || promotedMethodsLoading);
+	}, [tpacbLoading, promotedMethodsLoading]);
+	if (tpacbError) return /* @__PURE__ */ React.createElement(Alert, { severity: "error" }, t("There is no Api Catalog associated with your tenant and product"));
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, alertWarnings.map((warning) => /* @__PURE__ */ React.createElement(Alert, {
+		onClose: () => removeWarning(warning.id),
+		severity: "warning"
+	}, warning.message || "")), /* @__PURE__ */ React.createElement(DataBrowserContainer, {
+		entityData,
+		actionList,
+		onCreate: handleOnCreate,
+		entityAttributes,
+		foreignKeyData,
+		isLoading: loading,
+		promotedEntity: selectedEntity,
+		setEntityData,
+		isServerSide: true,
+		apiMethod: {
+			apiCatalogId,
+			entityName
+		},
+		setGridApi,
+		filterElements: searchFilterElements,
+		backToConfigPage: enteredFromConfig ? () => handleEntitySelect(null) : null,
+		queryColumnsData,
+		lookupsMap,
+		disableRowSelction: !params?.loadInquiryNode
+	}));
+};
+var UdpDataBrowserPage_default = memo(UdpDataBrowserPage);
+
+//#endregion
+//#region src/udp/pages/UdpRemindersPage.jsx
+var UdpRemindersPage_exports = /* @__PURE__ */ __export({ default: () => UdpRemindersPage_default });
+const UdpRemindersPage = (props) => {
+	const { params } = props;
+	const { nodeObj, manytoManyNodeObjKey } = params;
+	const [reminders, setReminders] = useState([]);
+	const [typeOptions, setTypeOptions] = useState([]);
+	const [loading, setLoading] = useState(false);
+	const [sheetOpen, setSheetOpen] = useState(false);
+	const [reminderId, setReminderId] = useState("");
+	const { openSplitScreen } = useActions();
+	const { catalogPromotedEntities } = useActionState();
+	const { handleErrorSnackbar } = useHandleAxiosSnackbar();
+	const { t } = useTranslation();
+	const formRef = useRef(null);
+	const user = useUser();
+	const reminderFiledForSearchApiMethod = useMemo(() => {
+		return getBaseMethod(UdpEnums.Udp_Reminder_Filed_For, "unityBaseSearchMethod", catalogPromotedEntities);
+	}, [catalogPromotedEntities]);
+	const reminderTypeGetAllApiMethod = useMemo(() => {
+		return getBaseMethod(UdpEnums.Udp_Reminder_Type, "unityBaseGetAllMethod", catalogPromotedEntities);
+	}, [catalogPromotedEntities]);
+	const getReminders = useCallback(async () => {
+		if (!nodeObj) return [];
+		let remindersList = [];
+		setLoading(true);
+		const data = { data: getSearchObject([{
+			searchField: "entityBusinessKey",
+			searchValue: manytoManyNodeObjKey ? nodeObj[manytoManyNodeObjKey]?.businessObjectKey : nodeObj?.businessObjectKey,
+			searchOperator: "="
+		}, {
+			searchField: "Reminder.TenantID",
+			searchValue: user.currentTenantId,
+			searchOperator: "="
+		}], 1, 200, true) };
+		if (reminderFiledForSearchApiMethod) {
+			const response = await executeQueryAdHoc(data, reminderFiledForSearchApiMethod.apiMethodId);
+			if (response?.status === 200) {
+				const pageList = response.data.pageList;
+				if (pageList?.length) remindersList = pageList.map((item) => ({
+					...item.reminder,
+					filedToType: item.type
+				}));
+			} else handleErrorSnackbar(null, t("Could not retrieve reminders"));
+		} else handleErrorSnackbar(null, t("Search ReminderFiledFor Method Not Promoted"));
+		setLoading(false);
+		setReminders(remindersList);
+	}, [
+		reminderFiledForSearchApiMethod,
+		handleErrorSnackbar,
+		nodeObj,
+		manytoManyNodeObjKey,
+		t,
+		user
+	]);
+	const openSheet = useCallback((value) => {
+		setReminderId(value?.id || "");
+		setSheetOpen(true);
+	}, []);
+	const closeSheet = useCallback(() => {
+		setReminderId("");
+		setSheetOpen(false);
+	}, []);
+	const handleEditPage = useCallback((value) => {
+		openSplitScreen({
+			open: true,
+			action: null,
+			type: SplitScreenTypeEnums.Reminders,
+			params: {
+				id: value?.id || "",
+				reloadReminders: getReminders
+			}
+		});
+	}, [openSplitScreen, getReminders]);
+	const actionList = useMemo(() => [{
+		id: 1,
+		title: t("Reminder"),
+		icon: ViewIcon,
+		onClick: openSheet,
+		disabled: false
+	}, {
+		id: 2,
+		title: t("Edit"),
+		icon: EditIcon,
+		onClick: handleEditPage,
+		disabled: false
+	}], [
+		t,
+		openSheet,
+		handleEditPage
+	]);
+	const getFiledToType = (params$1) => {
+		return FILE_TO_TYPES.find((type) => type.value === params$1.data.filedToType)?.label || "";
+	};
+	const columnDefs = [
+		{
+			headerName: "Date",
+			field: "createdOn",
+			resizable: true,
+			sortable: true
+		},
+		{
+			headerName: "Subject",
+			field: "subject",
+			resizable: true,
+			sortable: true
+		},
+		{
+			headerName: "Reminder",
+			field: "content",
+			resizable: true,
+			sortable: true,
+			valueGetter: (params$1) => params$1.data.content.replace(/(<([^>]+)>)/gi, "")
+		},
+		{
+			headerName: "Reminder Date",
+			field: "reminderDate",
+			resizable: true,
+			sortable: true
+		},
+		{
+			headerName: "Type",
+			field: "typeCode",
+			resizable: true,
+			sortable: true,
+			valueGetter: useCallback((params$1) => {
+				return typeOptions.find((t$1) => t$1.code === params$1.data.typeCode)?.name || "";
+			}, [typeOptions])
+		},
+		{
+			headerName: "Filed To Type",
+			field: "filedToType",
+			resizable: true,
+			sortable: true,
+			valueGetter: getFiledToType
+		},
+		{
+			headerName: "Created By",
+			field: "userDisplayName",
+			resizable: true,
+			sortable: true
+		},
+		{
+			headerName: "",
+			cellRenderer: "actionsRenderer",
+			cellRendererParams: { actionList },
+			pinned: "right",
+			suppressMenu: true,
+			sortable: false
+		}
+	];
+	useEffect(() => {
+		getReminders();
+	}, []);
+	useEffect(() => {
+		const getTypeOptions = async () => {
+			let options = [];
+			if (reminderTypeGetAllApiMethod) {
+				const typesResponse = await executeQueryAdHoc({ data: {} }, reminderTypeGetAllApiMethod.apiMethodId);
+				if (typesResponse?.status === 200) options = typesResponse.data;
+			}
+			setTypeOptions(options);
+		};
+		getTypeOptions();
+	}, [reminderTypeGetAllApiMethod]);
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(SideSheet, {
+		open: sheetOpen,
+		onClose: closeSheet,
+		title: t("Reminder"),
+		width: 600
+	}, /* @__PURE__ */ React.createElement(RemindersScreen, {
+		viewOnly: true,
+		id: reminderId,
+		shortcutContentFinderEnabled: false,
+		formRef
+	})), /* @__PURE__ */ React.createElement(AmbientGridTemplate, {
+		title: "Reminders",
+		data: reminders,
+		columnDefs,
+		loading,
+		frameworkComponents: { actionsRenderer: ActionsRenderer },
+		groupingData: []
+	}));
+};
+var UdpRemindersPage_default = UdpRemindersPage;
+
+//#endregion
+//#region src/UI/widgets/library/RemindersWidget.jsx
+var RemindersWidget_exports = /* @__PURE__ */ __export({
+	RemindersWidget: () => RemindersWidget,
+	default: () => RemindersWidget_default
+});
+const useStyles$2 = makeStyles((theme) => ({
+	root: {},
+	actions: {
+		display: "flex",
+		alignItems: "center",
+		width: "100%",
+		justifyContent: "flex-end"
+	},
+	actionButton: {
+		marginRight: theme.spacing(.25),
+		position: "relative"
+	},
+	fabProgress: {
+		position: "absolute",
+		top: 4,
+		left: "35%",
+		zIndex: 1
+	}
+}));
+const RemindersWidget = (props, ref) => {
+	const { children, params, setParam,...other } = props;
+	const { onLoadedNodeClick, hideWidgetName, tree, catalogObjects } = params;
+	const [sortDirection, setSortDirection] = useState(null);
+	const [reminders, setReminders] = useState(null);
+	const [loading, setLoading] = useState(false);
+	const [allRemindersRequested, setAllRemindersRequested] = useState(false);
+	const [buttonProgress, setButtonProgress] = useState(false);
+	const [alertWarnings, setAlertWarnings] = useState([]);
+	const classes = useStyles$2(props);
+	const { catalogPromotedEntities } = useActionState();
+	const { handleErrorSnackbar } = useHandleAxiosSnackbar();
+	const { t } = useTranslation();
+	const user = useUser();
+	const reminderFiledForSearchApiMethod = useMemo(() => {
+		return getBaseMethod(UdpEnums.Udp_Reminder_Filed_For, "unityBaseSearchMethod", catalogPromotedEntities);
+	}, [catalogPromotedEntities]);
+	const updateReminderApiMethod = useMemo(() => {
+		return getBaseMethod(UdpEnums.Udp_Reminder, "unityBaseUpdateMethod", catalogPromotedEntities);
+	}, [catalogPromotedEntities]);
+	const currentSortDirection = useMemo(() => {
+		if (sortDirection === "asc") return "desc";
+		else if (sortDirection === "desc") return "asc";
+		else return null;
+	}, [sortDirection]);
+	const getNodeToLoad = useCallback((reminder) => {
+		const nodeToLoad = {};
+		const domainObject = reminder?.domainObject;
+		const entityBusinessKey = reminder?.entityBusinessKey || "";
+		let treeStructureId = "";
+		let apiMethodId = "";
+		const matchingNode = tree?.treeStructure?.find((node) => node.properties?.catalogReturnObject === domainObject);
+		if (matchingNode) {
+			treeStructureId = matchingNode.id;
+			if (!matchingNode.parentId) apiMethodId = tree.apiMethodInstance.apiMethodId;
+			else {
+				const associatedInquiryTree = matchingNode.properties?.associatedInquiryTree;
+				if (associatedInquiryTree) apiMethodId = associatedInquiryTree.apiMethodInstance?.apiMethodId || "";
+			}
+		}
+		nodeToLoad.apiMethodId = apiMethodId;
+		const searchIdentifiers = getSearchIdentifiers(catalogObjects, domainObject);
+		const filterElements = [];
+		const values = (entityBusinessKey.split("|")?.[1]).split(",");
+		searchIdentifiers.forEach((searchIdentifier, index) => {
+			const searchField = searchIdentifier ? searchIdentifier.charAt(0).toUpperCase() + searchIdentifier.slice(1) : "";
+			filterElements.push({
+				searchField,
+				searchOperator: "=",
+				searchValue: values[index]
+			});
+		});
+		nodeToLoad.queryPayload = getSearchObject(filterElements, 1, 50, true, LogicalSearchOperatorEnums.And);
+		nodeToLoad.nodeDetails = {
+			catalogReturnObject: domainObject,
+			treeStructureId
+		};
+		return nodeToLoad;
+	}, [tree, catalogObjects]);
+	const getIcon = useCallback((reminder) => {
+		const domainObject = reminder?.domainObject;
+		return (tree?.treeStructure?.find((node) => node.properties?.catalogReturnObject === domainObject))?.properties?.defaultIcon || {};
+	}, [tree]);
+	const sortByDate = useCallback((reminderList, direction) => {
+		const sortedReminders = [...reminderList];
+		if (direction === "asc") sortedReminders.sort((a, b) => new Date(b.reminderDate) - new Date(a.reminderDate));
+		else if (direction === "desc") sortedReminders.sort((a, b) => new Date(a.reminderDate) - new Date(b.reminderDate));
+		setReminders(sortedReminders);
+	}, []);
+	const sort = useCallback(() => {
+		sortByDate(reminders, sortDirection || "desc");
+		if (sortDirection === "desc" || !sortDirection) setSortDirection("asc");
+		else if (sortDirection === "asc") setSortDirection("desc");
+	}, [
+		reminders,
+		sortByDate,
+		sortDirection
+	]);
+	const getReminders = useCallback(async (allRequested = false, rffSearchApiMethod) => {
+		let remindersList = [];
+		const warnings = [];
+		if (!reminders) setLoading(true);
+		let filterElements = [
+			{
+				searchField: "Reminder.Acknowledged",
+				searchValue: false,
+				searchOperator: "=",
+				groupId: 1
+			},
+			{
+				searchField: "Reminder.ReminderDate",
+				searchValue: /* @__PURE__ */ new Date(),
+				searchOperator: "<=",
+				groupId: 1
+			},
+			{
+				searchField: "Type",
+				searchValue: UdpReminderFiledForType.System,
+				searchOperator: "=",
+				groupId: 2
+			},
+			{
+				searchField: "Type",
+				searchValue: UdpReminderFiledForType.User,
+				searchOperator: "=",
+				groupId: 3
+			},
+			{
+				searchField: "Reminder.UnityUserID",
+				searchValue: user.id,
+				searchOperator: "=",
+				groupId: 3
+			}
+		];
+		let filterGroups = [
+			{
+				groupId: 1,
+				logicalSearchOperator: LogicalSearchOperatorEnums.And,
+				parentGroupId: null
+			},
+			{
+				groupId: 2,
+				logicalSearchOperator: LogicalSearchOperatorEnums.Or,
+				parentGroupId: null
+			},
+			{
+				groupId: 3,
+				logicalSearchOperator: LogicalSearchOperatorEnums.And,
+				parentGroupId: 2
+			}
+		];
+		if (allRequested) {
+			filterElements = [
+				{
+					searchField: "Type",
+					searchValue: UdpReminderFiledForType.System,
+					searchOperator: "=",
+					groupId: 2
+				},
+				{
+					searchField: "Type",
+					searchValue: UdpReminderFiledForType.User,
+					searchOperator: "=",
+					groupId: 3
+				},
+				{
+					searchField: "Reminder.UnityUserID",
+					searchValue: user.id,
+					searchOperator: "=",
+					groupId: 3
+				}
+			];
+			filterGroups = [{
+				groupId: 2,
+				logicalSearchOperator: LogicalSearchOperatorEnums.Or,
+				parentGroupId: null
+			}, {
+				groupId: 3,
+				logicalSearchOperator: LogicalSearchOperatorEnums.And,
+				parentGroupId: 2
+			}];
+		}
+		const data = { data: getSearchObject(filterElements, 1, 200, true, LogicalSearchOperatorEnums.And, filterGroups) };
+		if (rffSearchApiMethod) if (!rffSearchApiMethod.apiMethodId) warnings.push({
+			id: v4(),
+			severity: "warning",
+			message: t("Search ReminderFiledFor Method Not Promoted")
+		});
+		else {
+			const response = await executeQueryAdHoc(data, rffSearchApiMethod.apiMethodId).catch((e) => {
+				setLoading(false);
+			});
+			if (response?.status === 200) {
+				const pageList = response.data.pageList;
+				if (pageList?.length) remindersList = pageList.map((item) => ({
+					...item.reminder,
+					domainObject: item.domainObject,
+					filedToType: item.type,
+					entityBusinessKey: item.entityBusinessKey
+				}));
+			} else warnings.push({
+				id: v4(),
+				severity: "error",
+				message: t("Could not retrieve reminders")
+			});
+		}
+		const treeDomains = tree?.treeStructure.map((node) => node.properties?.catalogReturnObject);
+		if (treeDomains.length) remindersList = remindersList.filter((reminder) => treeDomains.includes(reminder.domainObject));
+		else remindersList = [];
+		setAlertWarnings(warnings);
+		setLoading(false);
+		sortByDate(remindersList, currentSortDirection);
+	}, [
+		t,
+		user,
+		reminders,
+		sortByDate,
+		currentSortDirection,
+		tree
+	]);
+	const updateRemindersAcknowledgement = useCallback(async (reminders$1) => {
+		if (updateReminderApiMethod) {
+			const updatedPromises = [];
+			reminders$1.forEach((reminder) => {
+				reminder.acknowledged = reminder.checked;
+				const data = { requestBody: { ...reminder } };
+				data["{iD}"] = reminder.id;
+				updatedPromises.push(executeQueryWithParameters({ data }, updateReminderApiMethod.apiMethodId));
+			});
+			await Promise.all(updatedPromises.map((p) => p.catch((e) => e))).then((responses) => {
+				responses.forEach((response) => {
+					if (response.status === 200) {
+						const entityBusinessKey = response.data.entityBusinessKey;
+						if (!reminders$1?.find((nftu) => nftu.value === entityBusinessKey)) console.warn(`Reminder not updated for all file to entities`);
+					}
+				});
+			});
+		} else handleErrorSnackbar(null, "Update Reminder Method Not Promoted");
+	}, [updateReminderApiMethod, handleErrorSnackbar]);
+	const handleAcknowledgeClick = useCallback(async () => {
+		const acknowledgedReminders = reminders?.filter((r) => r.checked);
+		if (acknowledgedReminders.length) {
+			setButtonProgress(true);
+			await updateRemindersAcknowledgement(acknowledgedReminders);
+			setButtonProgress(false);
+			getReminders(allRemindersRequested, reminderFiledForSearchApiMethod);
+		}
+	}, [
+		reminders,
+		getReminders,
+		updateRemindersAcknowledgement,
+		allRemindersRequested,
+		reminderFiledForSearchApiMethod
+	]);
+	const handleSwitchChange = useCallback(async (event) => {
+		setLoading(true);
+		if (event.target.checked) {
+			setAllRemindersRequested(event.target.checked);
+			await getReminders(true, reminderFiledForSearchApiMethod);
+		} else {
+			setAllRemindersRequested(false);
+			await getReminders(false, reminderFiledForSearchApiMethod);
+		}
+		setLoading(false);
+	}, [getReminders, reminderFiledForSearchApiMethod]);
+	useEffect(() => {
+		if (reminderFiledForSearchApiMethod) getReminders(false, reminderFiledForSearchApiMethod);
+	}, [reminderFiledForSearchApiMethod]);
+	return /* @__PURE__ */ React.createElement(WidgetCard_default, {
+		ref,
+		hideWidgetName,
+		headerActions: /* @__PURE__ */ React.createElement("div", { className: classes.actions }, /* @__PURE__ */ React.createElement(FormControlLabel, {
+			control: /* @__PURE__ */ React.createElement(Switch, {
+				id: "udpRecord-RemindersWidget-Switch",
+				udprecordid: "udpRecord-RemindersWidget-Switch",
+				size: "small",
+				onChange: handleSwitchChange
+			}),
+			label: "All",
+			style: { marginRight: 8 }
+		}), /* @__PURE__ */ React.createElement(FluentIconButton, {
+			id: "udpRecord-RemindersWidget-Sort",
+			udprecordid: "udpRecord-RemindersWidget-Sort",
+			icon: SortIcon,
+			onClick: sort,
+			style: { marginRight: 4 }
+		}), /* @__PURE__ */ React.createElement("div", { className: classes.actionButton }, /* @__PURE__ */ React.createElement(FluentButton, {
+			id: "udpRecord-RemindersWidget-Complete",
+			udprecordid: "udpRecord-RemindersWidget-Complete",
+			variant: "contained",
+			color: "secondary",
+			onClick: handleAcknowledgeClick
+		}, buttonProgress && /* @__PURE__ */ React.createElement(CircularProgress, {
+			size: 24,
+			color: "primary",
+			className: classes.fabProgress
+		}), t("Complete")))),
+		...other
+	}, alertWarnings.length ? alertWarnings.map((warning) => /* @__PURE__ */ React.createElement(Alert, { severity: warning.severity || "warning" }, warning.message || "")) : /* @__PURE__ */ React.createElement(RemindersCard, {
+		reminders,
+		setReminders,
+		loading,
+		onLoadedNodeClick,
+		getNodeToLoad,
+		getIcon,
+		updateRemindersAcknowledgement
+	}), children);
+};
+var RemindersWidget_default = forwardRef(RemindersWidget);
+
+//#endregion
+//#region src/udp/pages/UdpPrivateForm.jsx
+var UdpPrivateForm_exports = /* @__PURE__ */ __export({ default: () => UdpPrivateForm_default });
+const useSearchParams = () => {
+	const search = useLocation().search;
+	return new URLSearchParams(search || window.location.search);
+};
+const UdpPrivateForm = (props) => {
+	const user = useUser();
+	const { enqueueSnackbar, closeSnackbar } = useSnackbar();
+	const { triggerAction } = useActions();
+	const queryParams = useSearchParams();
+	const formId = useMemo(() => {
+		return queryParams.get("udpf_formId");
+	}, [queryParams]);
+	const versionId = useMemo(() => {
+		return queryParams.get("udpf_version");
+	}, [queryParams]);
+	const submissionId = useMemo(() => {
+		return queryParams.get("udpf_submissionId");
+	}, [queryParams]);
+	return /* @__PURE__ */ React.createElement(UdpFormsRenderer, {
+		formId,
+		triggerAction,
+		version: versionId,
+		submissionId,
+		getUserCallback: () => user,
+		enqueueSnackbar,
+		closeSnackbar
+	});
+};
+var UdpPrivateForm_default = UdpPrivateForm;
+
+//#endregion
+//#region src/udp/pages/UdpFormsListPage.jsx
+var UdpFormsListPage_exports = /* @__PURE__ */ __export({ default: () => UdpFormsListPage_default });
+const UdpFormsListPage = (props) => {
+	useUser();
+	const tenant = useTenant();
+	const history = useHistory();
+	tenant?.activeTenant?.tenantId;
+	return /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(UdpFormsList, { history }));
+};
+var UdpFormsListPage_default = UdpFormsListPage;
+
+//#endregion
+//#region src/udp/pages/UdpFormsBuilderPage.jsx
+var UdpFormsBuilderPage_exports = /* @__PURE__ */ __export({ default: () => UdpFormsBuilderPage_default });
+const UdpFormsBuilderPage = () => {
+	useUser();
+	useTenant();
+	const location = useLocation();
+	const history = useHistory();
+	const { enqueueSnackbar, closeSnackbar } = useSnackbar();
+	const [searchParams, setSearchParams] = useState(() => new URLSearchParams(location.search));
+	useEffect(() => {
+		setSearchParams(new URLSearchParams(location.search));
+	}, [location.search]);
+	const formId = searchParams.get("udpf_formId");
+	const version = searchParams.get("udpf_version");
+	searchParams.get("udpf_callback_url");
+	return /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(UdpFormsBuilder, {
+		formId,
+		version,
+		enqueueSnackbar,
+		closeSnackbar,
+		history
+	}));
+};
+var UdpFormsBuilderPage_default = UdpFormsBuilderPage;
+
+//#endregion
+//#region src/udp/pages/UdpImportFromFileMappingPage.jsx
+var UdpImportFromFileMappingPage_exports = /* @__PURE__ */ __export({ default: () => UdpImportFromFileMappingPage_default });
+const UdpImportFromFileMappingPage = (props) => {
+	return /* @__PURE__ */ React.createElement(ImportDataFromFileMapping, null);
+};
+var UdpImportFromFileMappingPage_default = UdpImportFromFileMappingPage;
+
+//#endregion
+//#region src/enums/auditEventEnums.ts
+let AuditEventTypeEnums = /* @__PURE__ */ function(AuditEventTypeEnums$1) {
+	AuditEventTypeEnums$1[AuditEventTypeEnums$1["Create_Domain"] = 1] = "Create_Domain";
+	AuditEventTypeEnums$1[AuditEventTypeEnums$1["Update_Domain"] = 2] = "Update_Domain";
+	AuditEventTypeEnums$1[AuditEventTypeEnums$1["Delete_Domain"] = 3] = "Delete_Domain";
+	return AuditEventTypeEnums$1;
+}({});
+
+//#endregion
+//#region src/UI/widgets/utils/dateUtils.js
+/**
+* Creates a Date object based on an ISO 8601 date string.
+* @param dateString A ISO 8601 date string. EX: yyyy-MM-ddThh:mm:ss[Z|offset]
+* @returns A date object, or null if the format was invalid.
+*/
+const getDateFromString = (dateString) => {
+	if (!dateString || dateString.length === 0) return null;
+	const date = DateTime.fromISO(dateString);
+	return date ? date.toJSDate() : null;
+};
+/**
+* Formats a date string by converting it to a date in the specified time zone,
+* stripping out the time element and returning a localized date string.
+* @param date A Date or ISO 8601 date string. EX: yyyy-MM-ddThh:mm:ss[Z|offset]
+* @param timeZone An IANA time zone id. If supplied, convert the date into the specified time zone,
+* otherwise convert to local browser time.
+* @returns A date string without time based on the supplied time zone and the
+* user's browser locale settings.
+*/
+const getLocalizedDateString = (date, timeZone = "local") => {
+	const convertedDate = date instanceof Date ? date : getDateFromString(date);
+	return convertedDate ? DateTime.fromJSDate(convertedDate, { zone: timeZone }).toLocaleString(DateTime.DATE_SHORT) : "";
+};
+/**
+* Formats a date string by converting it to a date in the specified timezone,
+* and returning a string with the localized date and time.
+* @param date A Date or ISO 8601 date string. EX: yyyy-MM-ddThh:mm:ss[Z|offset]
+* @param delimiter If supplied, split the date and time by this string when returned.
+* @param timeZone If supplied, convert the date into the specified IANA time zone,
+* otherwise convert to local browser time.
+* @returns A date and time string based on the user's browser locale settings.
+*/
+const getLocalizedDateTimeString = (date, delimiter = null, timeZone = "local", includeOffset = false) => {
+	const convertedDate = date instanceof Date ? date : getDateFromString(date);
+	if (convertedDate === null) return "";
+	const convertedDateTime = DateTime.fromJSDate(convertedDate, { zone: timeZone });
+	if (delimiter !== null) return convertedDateTime.toLocaleString(DateTime.DATE_SHORT) + delimiter + convertedDateTime.toLocaleString(DateTime.TIME_WITH_SECONDS) + (includeOffset ? " " + convertedDateTime.offsetNameShort : "");
+	else return convertedDateTime.toLocaleString(DateTime.DATETIME_SHORT_WITH_SECONDS) + (includeOffset ? " " + convertedDateTime.offsetNameShort : "");
+};
+
+//#endregion
+//#region src/udp/utilities/dateLocalizationHooks.jsx
+/**
+* Gets a function that can be used to convert a date or
+* ISO 8601 date string (EX: yyyy-MM-ddThh:mm:ss[Z|offset])
+* to a localized date string without time in the specified IANA time zone.
+* @param timeZone An IANA time zone to convert the date to before returning as a string.
+* @returns A function to convert a date to a localized string.
+*/
+const useGetLocalizedDateString = (timeZone) => {
+	const user = useAuthedUser();
+	return useCallback((date) => {
+		return getLocalizedDateString(date, timeZone !== "local" && (timeZone === user?.additionalProperties?.activeUtilityTimeZone || IANAZone.isValidZone(timeZone)) ? timeZone : "local");
+	}, [user, timeZone]);
+};
+/**
+* Gets a function that can be used to convert a date or
+* ISO 8601 date string (EX: yyyy-MM-ddThh:mm:ss[Z|offset])
+* to a localized date time string in the specified IANA time zone.
+* @param timeZone The IANA time zone to convert the date before converting to
+* a localized string.
+* @param includeTimeZoneOffset If true, include the time zone offset in the localized string.
+* @returns A function to convert a date to a localized string.
+*/
+const useGetLocalizedDateTimeString = (timeZone, includeTimeZoneOffset = false) => {
+	const user = useAuthedUser();
+	return useCallback((date, delimiter = null) => {
+		return getLocalizedDateTimeString(date, delimiter, timeZone !== "local" && (timeZone === user?.additionalProperties?.activeUtilityTimeZone || IANAZone.isValidZone(timeZone)) ? timeZone : "local", includeTimeZoneOffset);
+	}, [
+		user,
+		timeZone,
+		includeTimeZoneOffset
+	]);
+};
+/**
+* Gets a function that can be used to convert a date or
+* ISO 8601 date string (EX: yyyy-MM-ddThh:mm:ss[Z|offset])
+* to a localized date time string in the current user's time zone.
+* @param includeTimeZoneOffset If true, include the time zone offset in the localized string.
+* @returns A function to convert a date to a localized string.
+*/
+const useGetLocalizedUserDateTimeString = (includeTimeZoneOffset = false) => {
+	const user = useAuthedUser();
+	return useCallback((date, delimiter = null) => {
+		return getLocalizedDateTimeString(date, delimiter, user?.additionalProperties?.timeZone, includeTimeZoneOffset);
+	}, [user, includeTimeZoneOffset]);
+};
+
+//#endregion
+//#region src/udp/pages/UdpAuditEventSidesheet.jsx
+const useStyles$1 = makeStyles((theme) => ({
+	textField: { marginTop: theme.spacing(0) },
+	loadingBar: {
+		top: theme.spacing(-2),
+		marginLeft: theme.spacing(-2),
+		marginRight: theme.spacing(-2)
+	}
+}));
+const UdpAuditEventSidesheet = (props) => {
+	const { auditEvent, isSideSheetOpen, handleSideSheet, promotedEntities, sheetProps } = props;
+	const { t } = useTranslation();
+	const classes = useStyles$1();
+	const getLocalizedDateTimeString$1 = useGetLocalizedUserDateTimeString();
+	const [auditEventDetail, setAuditEventDetail] = React.useState({});
+	const [loading, setLoading] = useState(false);
+	const auditEventDetailGetApiMethod = useMemo(() => {
+		return getBaseMethod(UdpEnums.Udp_Audit_Event_Detail, "unityBaseGetMethod", promotedEntities);
+	}, [promotedEntities]);
+	const onCloseSideSheet = () => {
+		handleSideSheet(false);
+	};
+	useEffect(() => {
+		const getAuditEventDetail = async () => {
+			let auditEventDetail$1 = {};
+			const data = {};
+			try {
+				if (auditEventDetailGetApiMethod && auditEvent) {
+					setLoading(true);
+					data["{auditEventId}"] = auditEvent.id;
+					const response = await executeQueryWithParameters({ data }, auditEventDetailGetApiMethod.apiMethodId);
+					if (response?.status === 200) {
+						auditEventDetail$1 = response.data;
+						setAuditEventDetail(auditEventDetail$1);
+					}
+				}
+			} finally {
+				setLoading(false);
+			}
+		};
+		getAuditEventDetail();
+	}, [auditEvent, auditEventDetailGetApiMethod]);
+	return /* @__PURE__ */ React.createElement(SideSheet, {
+		...sheetProps,
+		open: isSideSheetOpen,
+		onClose: onCloseSideSheet,
+		title: t(`Audit Event Details`),
+		width: 800,
+		color: "primary"
+	}, loading && /* @__PURE__ */ React.createElement(LinearProgress$1, {
+		className: classes.loadingBar,
+		color: "secondary"
+	}), /* @__PURE__ */ React.createElement(GridRow, null, /* @__PURE__ */ React.createElement(GridUnit, {
+		ratio: "1:1",
+		width: "100%"
+	}, /* @__PURE__ */ React.createElement(AmbientCard, {
+		title: t("Event"),
+		fullWidth: true,
+		subCard: true
+	}, /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(FluentTextField, {
+		className: classes.textField,
+		id: "auditEventTypeName",
+		label: t("Event Type"),
+		value: auditEvent?.auditEventTypeName || "",
+		disabled: true
+	}), /* @__PURE__ */ React.createElement(FluentTextField, {
+		className: classes.textField,
+		id: "auditEventUserDisplayName",
+		label: t("User"),
+		value: auditEvent?.userDisplayName || "",
+		disabled: true
+	}), /* @__PURE__ */ React.createElement(FluentTextField, {
+		className: classes.textField,
+		id: "auditEventDomain",
+		label: t("Description"),
+		value: auditEvent?.domain || "",
+		disabled: true
+	}), /* @__PURE__ */ React.createElement(FluentTextField, {
+		className: classes.textField,
+		id: "auditEventCreatedOn",
+		label: t("Created On"),
+		value: getLocalizedDateTimeString$1(auditEvent?.createdOn ?? ""),
+		disabled: true
+	}), /* @__PURE__ */ React.createElement(Box, null, (auditEvent?.typeCode === AuditEventTypeEnums.Update_Domain || auditEvent?.typeCode === AuditEventTypeEnums.Delete_Domain) && /* @__PURE__ */ React.createElement(ReactJson, {
+		src: auditEventDetail?.oldObj ? JSON.parse(auditEventDetail?.oldObj) : {},
+		name: t("Old Details"),
+		displayDataTypes: false,
+		displayObjectSize: false
+	}), (auditEvent?.typeCode === AuditEventTypeEnums.Update_Domain || auditEvent?.typeCode === AuditEventTypeEnums.Create_Domain) && /* @__PURE__ */ React.createElement(ReactJson, {
+		src: auditEventDetail?.newObj ? JSON.parse(auditEventDetail?.newObj) : {},
+		name: t("New Details"),
+		displayDataTypes: false,
+		displayObjectSize: false
+	})))))));
+};
+var UdpAuditEventSidesheet_default = UdpAuditEventSidesheet;
+
+//#endregion
+//#region src/udp/utilities/useDateStringColumnDef.js
+const useDateStringColumnDef = (includeTime = false, timeZone = null, includeTimeZoneOffset = false) => {
+	const user = useAuthedUser();
+	const zone = useMemo(() => {
+		const tz = timeZone ?? user?.additionalProperties?.timeZone ?? "local";
+		return tz !== "local" && (tz === user?.additionalProperties?.timeZone || IANAZone.isValidZone(tz)) ? tz : "local";
+	}, [timeZone, user]);
+	const getLocalizedDateTimeString$1 = useGetLocalizedDateTimeString(zone, includeTimeZoneOffset);
+	const getLocalizedDateString$1 = useGetLocalizedDateString(zone);
+	return useMemo(() => {
+		return !user ? {} : {
+			valueFormatter: (params) => {
+				if (!params) return "";
+				if (includeTime) return getLocalizedDateTimeString$1(params.value);
+				else return getLocalizedDateString$1(params.value);
+			},
+			cellClass: includeTime ? GridExcelStyleEnums.DateTimeShortWithSeconds : GridExcelStyleEnums.DateShort,
+			filter: "agDateColumnFilter",
+			filterParams: {
+				comparator: function(filterLocalDateAtMidnight, cellValue) {
+					const cellDate = getDateFromString(cellValue);
+					if (!cellDate) return null;
+					const filterDateTimeMidnight = DateTime.fromJSDate(filterLocalDateAtMidnight).setZone(zone, { keepLocalTime: true });
+					const cellDateTimeMidnight = DateTime.fromJSDate(cellDate, { zone }).set({
+						hour: 0,
+						minute: 0,
+						second: 0,
+						millisecond: 0
+					});
+					if (cellDateTimeMidnight < filterDateTimeMidnight) return -1;
+					else if (cellDateTimeMidnight > filterDateTimeMidnight) return 1;
+					else return 0;
+				},
+				buttons: ["apply", "reset"],
+				closeOnApply: true,
+				suppressAndOrCondition: true,
+				filterOptions: [
+					"equals",
+					"lessThan",
+					"greaterThan",
+					"inRange"
+				]
+			}
+		};
+	}, [
+		includeTime,
+		getLocalizedDateString$1,
+		getLocalizedDateTimeString$1,
+		user,
+		zone
+	]);
+};
+
+//#endregion
+//#region src/udp/pages/UdpAuditEventsPage.jsx
+var UdpAuditEventsPage_exports = /* @__PURE__ */ __export({ default: () => UdpAuditEventsPage_default });
+const baseSearchPayload = {
+	pageNumber: 1,
+	pageSize: 15,
+	filterElements: [],
+	filterGroups: [],
+	orderElements: [],
+	groupingType: "",
+	groupProperty: [],
+	groupOperationList: [],
+	eagerLoad: false,
+	logicalSearchOperator: 1
+};
+const useStyles = makeStyles((theme) => ({ loadingBar: {
+	bottom: theme.spacing(-.5),
+	marginLeft: theme.spacing(.5),
+	marginRight: theme.spacing(.5)
+} }));
+const UdpAuditEventsPage = (props) => {
+	const { params } = props;
+	const { gridApi, gridColumnApi, onGridReady } = useAgGridApi();
+	const { t } = useTranslation();
+	const classes = useStyles();
+	const dateStringColumnDef = useDateStringColumnDef(true);
+	const { handleErrorSnackbar } = useHandleAxiosSnackbar();
+	const gridApiRef = useRef(null);
+	const [searchQuery, setSearchQuery] = useState("");
+	const [displayProgressBar, setDisplayProgressBar] = useState(false);
+	const [selectedAuditEvent, setSelectedAuditEvent] = useState(null);
+	const [viewSideSheetOpen, setViewSideSheetOpen] = useState(false);
+	const [auditEventTypes, setAuditEventTypes] = useState([]);
+	const [searchObject, setSearchObject] = useState(baseSearchPayload);
+	const currentApiCatalogId = useCatalogStore((state) => state.currentApiCatalogId);
+	const promotedMethodEntitiesMap = useCatalogStore((state) => state.promotedMethodEntitiesMap);
+	const promotedEntities = useMemo(() => {
+		if (!currentApiCatalogId || !promotedMethodEntitiesMap) return null;
+		return promotedMethodEntitiesMap[currentApiCatalogId] || [];
+	}, [promotedMethodEntitiesMap, currentApiCatalogId]);
+	const auditEventTypeGetAllApiMethod = useMemo(() => {
+		return getBaseMethod(UdpEnums.Udp_Audit_Event_Type, "unityBaseGetAllMethod", promotedEntities);
+	}, [promotedEntities]);
+	const auditEventSearchApiMethod = useMemo(() => {
+		return getBaseMethod(UdpEnums.Udp_Audit_Event, "unityBaseSearchMethod", promotedEntities);
+	}, [promotedEntities]);
+	const getAuditEventTypeName = useCallback((auditEventTypeCode) => {
+		if (!auditEventTypes) return "";
+		return auditEventTypes.find((auditEventType) => auditEventType.code === auditEventTypeCode)?.name || "";
+	}, [auditEventTypes]);
+	const handleSideSheet = useCallback((isOpen, auditEvent) => {
+		setViewSideSheetOpen(isOpen);
+		setSelectedAuditEvent(auditEvent);
+	}, []);
+	const columnDefs = useMemo(() => {
+		return [
+			{
+				headerName: t("Event Type"),
+				field: "UdpAuditEventUdpAuditEventType.Name",
+				valueGetter: (params$1) => getAuditEventTypeName(params$1.data.typeCode),
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("User"),
+				field: "userDisplayName",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Description"),
+				field: "domain",
+				resizable: true,
+				sortable: false
+			},
+			{
+				headerName: t("Created On"),
+				field: "createdOn",
+				resizable: true,
+				sortable: true,
+				...dateStringColumnDef
+			},
+			{
+				field: "actions",
+				headerName: t("Details"),
+				cellRenderer: "actionsRenderer",
+				cellRendererParams: { actionList: [{
+					id: 0,
+					title: t("View"),
+					iconName: "view",
+					handleOnClick: (e, auditEvent) => handleSideSheet(true, {
+						...auditEvent?.data,
+						auditEventTypeName: getAuditEventTypeName(auditEvent?.data?.typeCode)
+					}),
+					disabled: false
+				}] },
+				suppressMenu: true,
+				sortable: false,
+				filter: false
+			}
+		];
+	}, [getAuditEventTypeName]);
+	const gridFunctions = [
+		{ name: "chipFilter" },
+		{ name: "agGridExport" },
+		{ name: "agGridSizeColumnsToFit" },
+		{ name: "agGridAutoSizeColumns" },
+		{ name: "agGridResetColumns" },
+		{ name: "agGridHideShowColumns" }
+	];
+	const gridOptions = useMemo(() => {
+		return { pagination: true };
+	}, []);
+	useEffect(() => {
+		const getAuditEventTypes = async () => {
+			let types = [];
+			if (auditEventTypeGetAllApiMethod) {
+				const response = await executeQueryAdHoc({ data: {} }, auditEventTypeGetAllApiMethod.apiMethodId);
+				if (response?.status === 200) types = response.data;
+			}
+			setAuditEventTypes(types);
+		};
+		getAuditEventTypes();
+	}, [auditEventTypeGetAllApiMethod]);
+	const handleGridApiCallback = (api) => {
+		gridApiRef.current = api;
+	};
+	const searchMethodConfig = useMemo(() => {
+		return {
+			apiMethodId: auditEventSearchApiMethod?.apiMethodId,
+			customSearchObject: searchObject
+		};
+	}, [auditEventSearchApiMethod]);
+	return /* @__PURE__ */ React.createElement(React.Fragment, null, displayProgressBar && /* @__PURE__ */ React.createElement(LinearProgress$1, {
+		className: classes.loadingBar,
+		color: "secondary"
+	}), /* @__PURE__ */ React.createElement(SearchMethodUdpGrid, {
+		searchMethodConfig,
+		columnDefs,
+		gridHeaderConfig: { title: t("Audit Events") },
+		gridOptions,
+		gridApiCallback: handleGridApiCallback,
+		gridFunctions
+	}), /* @__PURE__ */ React.createElement(UdpAuditEventSidesheet_default, {
+		auditEvent: selectedAuditEvent,
+		isSideSheetOpen: viewSideSheetOpen,
+		handleSideSheet,
+		promotedEntities
+	}));
+};
+var UdpAuditEventsPage_default = UdpAuditEventsPage;
+
+//#endregion
+//#region src/udp/pages/udpPages.js
+const UdpPages = {
+	UdpNotesPage: UdpNotesPage_exports,
+	UdpVerticalManagementPage: UdpVerticalManagementPage_exports,
+	UdpGridPanelManagementPage: UdpGridPanelManagementPage_exports,
+	UdpMaintenanceEnginePage: UdpMaintenanceEnginePage_exports,
+	UdpInquiryMaintenanceEnginePage: UdpInquiryMaintenanceEnginePage_exports,
+	UdpReportsPage: UdpReportsPage_exports,
+	DonutChartWidget: DonutChartWidget_exports,
+	SparklineWidget: SparklineWidget_exports,
+	ProgressBarWidget: ProgressBarWidget_exports,
+	RecentlyLoadedNodesWidget: RecentlyLoadedNodesWidget_exports,
+	ChatUDP: ChatUDP_exports,
+	UdpDataBrowserPage: UdpDataBrowserPage_exports,
+	UdpRemindersPage: UdpRemindersPage_exports,
+	RemindersWidget: RemindersWidget_exports,
+	UdpPublicForm: UdpPublicForm_exports,
+	UdpPrivateForm: UdpPrivateForm_exports,
+	UdpFormsBuilderPage: UdpFormsBuilderPage_exports,
+	UdpFormsListPage: UdpFormsListPage_exports,
+	UdpImportFromFileMappingPage: UdpImportFromFileMappingPage_exports,
+	UdpAuditEventsPage: UdpAuditEventsPage_exports
+};
+
+//#endregion
+export { DonutChartWidget_exports, FluentPrimaryStatNumber_default, FluentSecondaryStatNumber_default, FluentStatNumber_default, FluentStatsSnippet_default, ProgressBarWidget_exports, RecentlyLoadedNodesWidget_exports, RemindersWidget_exports, SparklineWidget_exports, UdpDataBrowserPage, UdpPages, convertISODate };
+//# sourceMappingURL=udpPages-D8I3GU4V.js.map