udp-react-enterprise-component-library 25.18.1-beta.4 → 25.18.1-beta.40

package/dist/Inquiry-CeZgX9ls.js

@@ -0,0 +1,2638 @@
+import { t as Form$1 } from "./Form-DbOA5j38.js";
+import { t as Field$1 } from "./Field-Cda5rJe2.js";
+import { t as FluentButton } from "./FluentButton-BexKrnAp.js";
+import { t as ConfigService } from "./configService-C4uoG3wj.js";
+import { t as apiMutate } from "./useAxiosMutate-DeqKSi5z.js";
+import { t as FluentTextFieldAutoComplete } from "./FluentTextFieldAutoComplete-5Hp3qpk6.js";
+import { n as pluralize, o as toUpperFirstChar } from "./StringUtilities-u-cxAW6-.js";
+import { t as FluentIcon } from "./FluentIcon-DQ6nSDJg.js";
+import { t as FluentIconButton } from "./FluentIconButton-Dc95mE3v.js";
+import { r as getSanitizedName } from "./entityUtilities-_8w-Zjs3.js";
+import { I as TreeViewModeEnums, _ as NodeActionEnums, v as NodeActionTriggerEnums } from "./unitySystemEnums-e5F9Jr7m.js";
+import { t as UnityFluentIcon } from "./UnityFluentIcon-DrASIcTF.js";
+import { n as useSetInitialInquiryMenuVisibility, r as useActionStore, t as useInquiryStore } from "./inquiryStore-BMYKf5MP.js";
+import { t as useCatalogStore } from "./catalogStore-DP2GxpTJ.js";
+import { n as useShellStore } from "./shellStore-C8zfPsZ-.js";
+import { n as useActions } from "./useActions-BWBXokgQ.js";
+import { i as mapRule, t as evaluateRule } from "./RuleUtilities-D5ACzikQ.js";
+import { n as getSearchIdentifiers, r as getSearchObject } from "./SearchUtilities-CNz302LN.js";
+import { t as GroupNode } from "./GroupNode-Djp62Urb.js";
+import { A as makeTreeStructure, B as searchForMatchingNode, E as getSearchValueString, M as mapNodeObjValuesToSearchParameters, S as getIconFromName, V as searchTree, _ as formatTreeMenuItem, d as findAllParentIds, n as collapseAllNodes, o as constructPreloadedTree, p as findNodeById, u as expandAllNodes, w as getNodeIdForRightBorder } from "./TreeUtilities-kiPupulY.js";
+import { r as SvgIcon, t as getUnityIconFromName } from "./UnityIconLibrary-CjIwzfjv.js";
+import { t as LayoutUnit } from "./LayoutUnit-D4jJvonh.js";
+import { t as useAxiosGet } from "./useAxiosGet-CYnt6Hd0.js";
+import { t as PrimaryActionHeader } from "./PrimaryActionHeader-DBJpROPu.js";
+import { t as UdpTabs } from "./UdpTabs-DVZGEwOC.js";
+import { t as useSetLocationState } from "./useSetLocationState-Kvcc9BTb.js";
+import { t as PageContainer } from "./PageContainer-DTXNLt_2.js";
+import { n as OpenPage } from "./DraggableSidebarTemplate-BUWBvL6H.js";
+import { n as executeQueryInstance } from "./methodUtils-CDx9usdO.js";
+import { n as useBuildEnvironment, t as APP_RIBBON_SPACE } from "./useBuildEnvironment-2gdqpmBX.js";
+import { t as FluentDialog } from "./FluentDialog-B5ZxvX1E.js";
+import { i as InquiryAdvancedSearch, t as InquirySearchContainer } from "./InquirySearchContainer-BIpngula.js";
+import { t as InquiryDashboard } from "./InquiryDashboard-BeXOeKII.js";
+import { i as InquiryHeaderSecondaryTarget, n as InquiryHeaderSecondaryAlertTarget, r as InquiryHeaderSecondary } from "./InquiryHeaderSecondaryAlert-DH8I1ThI.js";
+import { t as InquiryNodeControls } from "./InquiryNodeControls-B677QFu4.js";
+import { t as NodeLoader } from "./NodeLoader-6vxxLuHg.js";
+import { t as AggregateChip } from "./AggregateChip-6GSEsL_A.js";
+import { t as RecentlyLoadedNodesTable } from "./RecentlyLoadedNodesTable-CIR8D1c4.js";
+import { t as UtilitySideBar } from "./UtilitySideBar-wvrocDGI.js";
+import { t as PageActionWrapper } from "./PageActionWrapper-DonuC2VZ.js";
+import { t as WorkflowTreeMenu } from "./WorkflowTreeMenu-CTxpL6vb.js";
+import { t as UnitStateType } from "./workflowEnums-BJmSE_P8.js";
+import { i as transformWorkflowPlayTree } from "./workflowUtilities-Brby0vts.js";
+import { t as WorkflowContent } from "./WorkflowContent-CU_-pOym.js";
+import { t as LoadingOverlay_default } from "./LoadingOverlay-CLUqp3yg.js";
+import { t as useAuthedUser } from "./useAuthedUser-Bhr7Yhlg.js";
+import { t as buildCatalogObjectList } from "./CatalogUtilities-CAPPpjBH.js";
+import React, { useCallback, useEffect, useMemo, useState } from "react";
+import { Card, CircularProgress, Collapse, Divider, LinearProgress, Slide, Tooltip, Typography, darken, lighten, makeStyles, useTheme } from "@material-ui/core";
+import { useForm } from "react-final-form";
+import { useSnackbar } from "notistack";
+import clsx from "clsx";
+import { CaretDownSolid8Icon, CaretUpSolid8Icon, ChevronDownIcon, ChevronUpIcon, ClearIcon } from "@fluentui/react-icons";
+import PropTypes from "prop-types";
+import { cloneDeep, difference, orderBy } from "lodash";
+import { useTranslation } from "react-i18next";
+import { v4 } from "uuid";
+import { DndProvider, useDrag, useDrop } from "react-dnd";
+import { HTML5Backend } from "react-dnd-html5-backend";
+import TreeView from "@material-ui/lab/TreeView";
+import TreeItem from "@material-ui/lab/TreeItem";
+import NoEntityOpenedUrl from "./assets/unityIcons/NoEntityOpened.svg";
+
+//#region src/inquiry/ExecuteApiDialog.jsx
+const ExecuteApiDialog = (props) => {
+	const { open, handleCloseDialog, actionLabel = "Execute", title = "Execute the below Api", message, apiMethods = [], ...other } = props;
+	const form = useForm();
+	const { t } = useTranslation();
+	const handleSubmit = () => {
+		form.submit();
+	};
+	return /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(FluentDialog, {
+		open,
+		title,
+		actionOne: handleCloseDialog,
+		actionTwo: handleSubmit,
+		labelOne: t("Cancel"),
+		labelTwo: actionLabel,
+		onClose: handleCloseDialog,
+		message,
+		maxWidth: "sm",
+		...other
+	}, /* @__PURE__ */ React.createElement(Field$1, {
+		component: FluentTextFieldAutoComplete,
+		label: t("Api(s)"),
+		id: "apis",
+		name: "apiMethod",
+		fullWidth: true,
+		variant: "outlined",
+		margin: "normal",
+		size: "small",
+		options: apiMethods || [],
+		initialValue: apiMethods[0] || null,
+		required: true,
+		optionKey: "name"
+	})));
+};
+
+//#endregion
+//#region src/inquiry/InquiryWrapper.jsx
+const useStyles$6 = makeStyles((theme) => ({
+	root: {
+		display: "flex",
+		flexDirection: "row",
+		width: "100%",
+		position: "relative"
+	},
+	sideBar: {
+		width: (props) => props.nodeMinimized ? props.collapsedWidth : 350,
+		background: theme.palette.common.white,
+		borderRight: `1px solid ${theme.palette.divider}`
+	},
+	children: { width: "100%" }
+}));
+const InquiryWrapper = (props) => {
+	const classes = useStyles$6(props);
+	const { children, sideBar, nodeLoaded, onMouseEnter, onMouseLeave, className, sidebarClassName, childrenClassName } = props;
+	return /* @__PURE__ */ React.createElement("div", { className: clsx(classes.root, className) }, /* @__PURE__ */ React.createElement(Slide, {
+		direction: "right",
+		in: nodeLoaded,
+		mountOnEnter: true,
+		unmountOnExit: true
+	}, /* @__PURE__ */ React.createElement("div", {
+		onMouseEnter,
+		onMouseLeave,
+		className: clsx(classes.sideBar, sidebarClassName)
+	}, sideBar)), /* @__PURE__ */ React.createElement("div", { className: clsx(classes.children, childrenClassName) }, children));
+};
+
+//#endregion
+//#region src/inquiry/NodeDetails.jsx
+const useStyles$5 = makeStyles((theme) => ({
+	root: { marginLeft: theme.spacing(2) },
+	wrapper: {},
+	columnOne: {
+		height: 164,
+		overflowX: "auto",
+		display: "flex",
+		flexDirection: "column",
+		flexWrap: "wrap"
+	},
+	listItem: { marginRight: theme.spacing(1) }
+}));
+const ListItem$1 = (props) => {
+	const { label, value } = props;
+	const classes = useStyles$5();
+	return /* @__PURE__ */ React.createElement("div", { className: classes.listItem }, /* @__PURE__ */ React.createElement(Typography, {
+		color: "secondary",
+		variant: "caption"
+	}, label), /* @__PURE__ */ React.createElement(Typography, null, value), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "xxs" }));
+};
+const NodeDetails = (props) => {
+	const { node } = props;
+	const classes = useStyles$5();
+	const details = useMemo(() => {
+		if (!node || !node?.nodeObj || !node?.properties?.pageHeaderConfiguration) return [];
+		const shownPageHeaderConfigurations = node.properties.pageHeaderConfiguration.filter((phc) => phc.isShown);
+		const list = [];
+		shownPageHeaderConfigurations.forEach((sphc) => {
+			const propertyName = sphc.propertyName;
+			const property = sphc.property;
+			let value = node.nodeObj[propertyName];
+			if (sphc.joiningEntityKey) if (sphc.joiningEntityKey === node.properties?.catalogObjectKey) value = node.nodeObj[property ? property : propertyName];
+			else {
+				const valueObj = node.nodeObj[sphc.joiningEntityKey];
+				if (valueObj) value = valueObj[property ? property : propertyName];
+				if (!value) value = node.nodeObj[property ? property : propertyName];
+			}
+			const item = {
+				label: sphc.name,
+				value: value ? value.toString() : "N/A"
+			};
+			list.push(item);
+		});
+		return list;
+	}, [node]);
+	return /* @__PURE__ */ React.createElement("div", { className: classes.root }, /* @__PURE__ */ React.createElement("div", { className: classes.wrapper }, /* @__PURE__ */ React.createElement("div", { className: classes.columnOne }, details.map((item) => {
+		return /* @__PURE__ */ React.createElement(ListItem$1, {
+			key: item.label,
+			label: item.label,
+			value: item.value
+		});
+	}))));
+};
+
+//#endregion
+//#region src/inquiry/InquiryTreeMenuItem.jsx
+const useStyles$4 = makeStyles((theme) => ({
+	root: {
+		"&.Mui-selected > .MuiTreeItem-content": { backgroundColor: theme?.getThemeData()?.mode === "dark" ? theme.palette.grey[700] : theme.palette.grey[300] },
+		"&.Mui-selected > .MuiTreeItem-content .MuiTreeItem-label": {
+			backgroundColor: "transparent",
+			paddingLeft: 0
+		},
+		"&.Mui-selected > .MuiTreeItem-content > .MuiCollapse-wrapperInner": { backgroundColor: theme?.getThemeData()?.mode !== "dark" && theme.palette.grey[50] },
+		"& .MuiTreeItem-content .MuiTreeItem-iconContainer": { display: (props) => props.sidebarExpanded ? "flex" : "none" }
+	},
+	content: { backgroundColor: (props) => theme?.getThemeData()?.mode !== "dark" && props.adornmentName && props.adornmentColor ? lighten(props.adornmentColor, .92) : "" },
+	labelRoot: {
+		display: "flex",
+		alignItems: "center",
+		marginLeft: (props) => props.sidebarExpanded ? 0 : theme.spacing(1.5),
+		width: "100%"
+	},
+	labelContainer: { width: (props) => props.treeViewMode === TreeViewModeEnums.Compact ? `calc(100% - ${theme.spacing(6.25)}px)` : `calc(100% - ${theme.spacing(7.75)}px)` },
+	conditionalAdornmentContainer: { display: "inline-flex" },
+	labelText: {
+		fontSize: "0.75rem",
+		fontWeight: 600,
+		lineHeight: "1rem",
+		letterSpacing: .1
+	},
+	captionText: {
+		marginLeft: (props) => props.treeViewMode === TreeViewModeEnums.Compact ? theme.spacing(1) : "",
+		fontSize: "0.65rem",
+		fontWeight: 400,
+		lineHeight: 1,
+		letterSpacing: .4
+	},
+	labelOverflow: {
+		whiteSpace: "nowrap",
+		overflow: "hidden",
+		textOverflow: "ellipsis"
+	},
+	group: {
+		width: "100%",
+		"& .MuiTreeItem-group": { marginLeft: 0 },
+		"& .MuiTreeItem-content": {
+			paddingLeft: (props) => props.sidebarExpanded ? (props.depth || 1) * theme.spacing(1) : 0,
+			borderRight: (props) => props.showRightBorderColor ? `4px solid ${theme.palette.primary.main}` : "",
+			borderBottom: (props) => props.treeViewMode === TreeViewModeEnums.Compact ? `1px solid ${theme.palette.grey[200]}` : ""
+		},
+		"& .MuiTreeItem-content .MuiTreeItem-label": {
+			paddingLeft: 0,
+			width: (props) => props.sidebarExpanded && `calc(100% - ${theme.spacing(2.5)}px)`
+		},
+		"& .MuiTreeItem-content .MuiTreeItem-iconContainer span": { display: (props) => props.hideExpansion ? "none" : "" },
+		"& .MuiCollapse-wrapperInner": { backgroundColor: (props) => theme?.getThemeData()?.mode !== "dark" && props.isSelectedNode ? theme.palette.grey[50] : "" }
+	},
+	iconContainer: {
+		display: "flex",
+		alignItems: "center",
+		justifyContent: "center",
+		borderRadius: 50,
+		marginTop: (props) => props.treeViewMode === TreeViewModeEnums.Compact ? theme.spacing(.25) : theme.spacing(.5),
+		marginBottom: (props) => props.treeViewMode === TreeViewModeEnums.Compact ? theme.spacing(.25) : theme.spacing(.5),
+		marginRight: theme.spacing(1),
+		width: (props) => props.treeViewMode === TreeViewModeEnums.Compact ? theme.spacing(3) : theme.spacing(4),
+		height: (props) => props.treeViewMode === TreeViewModeEnums.Compact ? theme.spacing(3) : theme.spacing(4),
+		border: (props) => props.iconColor ? `1px solid ${darken(props.iconColor, .1)}` : `1px solid ${theme.palette.secondary.main}`,
+		backgroundColor: "#ffffff"
+	},
+	dropTarget: {
+		backgroundColor: theme.palette.action.hover,
+		border: `2px dashed ${theme.palette.primary.main}`
+	}
+}));
+const InquiryTreeMenuItem = (props) => {
+	const { parentId, nodeId, iconName, iconType, iconColor, adornmentName, adornmentType, adornmentColor, label, onNodeSelect, isSelectedNode, subLabel, sidebarExpanded, isLastNode, loading, node, onDropNode, treeViewMode, menuIndex, aggregateThresholdId, aggregateThresholdNodeMapping, ...other } = props;
+	const classes = useStyles$4(props);
+	const theme = useTheme();
+	const [{ isDragging }, dragRef] = useDrag({
+		type: "InquiryTreeMenuItem",
+		item: {
+			...node,
+			sourceNodeMenuIndex: menuIndex
+		},
+		collect: (monitor) => ({ isDragging: monitor.isDragging() })
+	});
+	const handleOnDrop = useCallback((sourceNode, monitor) => {
+		if (!monitor.didDrop()) {
+			if (onDropNode) {
+				const { sourceNodeMenuIndex, ...other$1 } = sourceNode;
+				onDropNode({ ...other$1 }, node, sourceNodeMenuIndex, menuIndex);
+			}
+		}
+	}, [
+		onDropNode,
+		node,
+		menuIndex
+	]);
+	const [{ canDrop, isOver }, dropRef] = useDrop(() => ({
+		accept: ["InquiryTreeMenuItem"],
+		drop: (sourceNode, monitor) => {
+			handleOnDrop(sourceNode, monitor);
+		},
+		canDrop: (sourceNode) => checkCanDrop(sourceNode),
+		collect: (monitor) => ({
+			isOver: monitor.isOver(),
+			canDrop: !!monitor.canDrop()
+		})
+	}), [handleOnDrop]);
+	const checkCanDrop = useCallback((sourceNode) => {
+		if (sourceNode) {
+			const onDropActions = node?.properties?.nodeActions?.filter((na) => na?.triggerType === NodeActionTriggerEnums.On_Node_Drop);
+			if (!onDropActions) return false;
+			return (onDropActions?.map((action) => action?.dragEntityName)).includes(sourceNode?.properties?.catalogReturnObject);
+		}
+	}, [node]);
+	const handleOnLabelClick = useCallback((e) => {
+		e.preventDefault();
+		onNodeSelect(e, nodeId);
+	}, [onNodeSelect, nodeId]);
+	return /* @__PURE__ */ React.createElement(TreeItem, {
+		id: "udpRecord-InquiryTreeMenuItem-TreeItem-" + label,
+		udprecordid: "udpRecord-InquiryTreeMenuItem-TreeItem-" + label,
+		className: classes.group,
+		key: nodeId,
+		nodeId,
+		collapseIcon: /* @__PURE__ */ React.createElement(FluentIcon, {
+			id: "udpRecord-InquiryTreeMenuItem-Icon-" + label,
+			size: "small",
+			component: CaretUpSolid8Icon,
+			style: {
+				color: lighten(theme.palette.primary.main, .5),
+				width: theme.spacing(1.5),
+				height: theme.spacing(1.5)
+			}
+		}),
+		expandIcon: /* @__PURE__ */ React.createElement(FluentIcon, {
+			id: "udpRecord-InquiryTreeMenuItem-Icon-" + label,
+			size: "small",
+			component: CaretDownSolid8Icon,
+			style: {
+				color: lighten(theme.palette.primary.main, .5),
+				width: theme.spacing(1.5),
+				height: theme.spacing(1.5)
+			}
+		}),
+		label: /* @__PURE__ */ React.createElement("div", {
+			ref: dropRef,
+			id: "udpRecord-InquiryTreeMenuItem-" + label,
+			udprecordid: "udpRecord-InquiryTreeMenuItem-" + label,
+			className: clsx({ [classes.dropTarget]: canDrop && isOver })
+		}, /* @__PURE__ */ React.createElement(Tooltip, { title: sidebarExpanded ? "" : label }, /* @__PURE__ */ React.createElement("div", {
+			ref: node?.properties?.isDraggable && dragRef || null,
+			style: { opacity: isDragging ? .5 : 1 }
+		}, loading ? /* @__PURE__ */ React.createElement(CircularProgress, { size: 12 }) : /* @__PURE__ */ React.createElement("div", {
+			className: classes.labelRoot,
+			style: { fontWeight: isSelectedNode ? "bold" : "" }
+		}, iconName && /* @__PURE__ */ React.createElement("div", { className: classes.iconContainer }, /* @__PURE__ */ React.createElement(UnityFluentIcon, {
+			size: treeViewMode === TreeViewModeEnums.Compact ? "small" : "medium",
+			color: iconColor,
+			type: iconType,
+			icon: iconType === "unity" ? getUnityIconFromName(iconName) : getIconFromName(iconName),
+			style: { color: iconColor ? darken(iconColor, .1) : theme.palette.secondary.main }
+		})), sidebarExpanded && /* @__PURE__ */ React.createElement("div", { className: classes.labelContainer }, /* @__PURE__ */ React.createElement(Typography, {
+			variant: "subtitle2",
+			className: clsx(classes.labelText, classes.labelOverflow)
+		}, label, subLabel && treeViewMode === TreeViewModeEnums.Compact && /* @__PURE__ */ React.createElement(Typography, {
+			variant: "caption",
+			className: clsx(classes.captionText, classes.labelOverflow)
+		}, subLabel)), subLabel && treeViewMode === TreeViewModeEnums.Classic && /* @__PURE__ */ React.createElement("div", { className: classes.labelOverflow }, /* @__PURE__ */ React.createElement(Typography, {
+			variant: "caption",
+			className: clsx(classes.captionText)
+		}, subLabel))), /* @__PURE__ */ React.createElement(AggregateChip, {
+			aggregateThresholdId,
+			aggregateThresholdParamMappings: aggregateThresholdNodeMapping
+		}), adornmentName && sidebarExpanded && /* @__PURE__ */ React.createElement("div", { className: classes.conditionalAdornmentContainer }, /* @__PURE__ */ React.createElement(UnityFluentIcon, {
+			size: treeViewMode === TreeViewModeEnums.Compact ? "small" : "medium",
+			color: adornmentColor,
+			type: adornmentType,
+			icon: adornmentType === "unity" ? getUnityIconFromName(adornmentName) : getIconFromName(adornmentName),
+			style: { color: adornmentColor }
+		}))), isLastNode && /* @__PURE__ */ React.createElement(FluentButton, {
+			onClick: () => console.log("Last Node"),
+			className: classes.button
+		}, /* @__PURE__ */ React.createElement(Typography, { variant: "caption" }, "Last Node"))))),
+		onLabelClick: handleOnLabelClick,
+		classes: {
+			root: classes.root,
+			content: classes.content
+		},
+		...other
+	});
+};
+
+//#endregion
+//#region src/inquiry/InquiryTreeMenu.jsx
+const useStyles$3 = makeStyles((theme) => ({
+	root: {
+		marginBottom: theme.spacing(1.75),
+		borderTop: (props) => props.treeViewMode === TreeViewModeEnums.Compact ? `1px solid ${theme.palette.grey[200]}` : ""
+	},
+	noChildrenContainer: { borderBottom: (props) => props.treeViewMode === TreeViewModeEnums.Compact ? `1px solid ${theme.palette.grey[200]}` : "" }
+}));
+const InquiryTreeMenu = (props) => {
+	const { menuItems, onSelectNode, onDropNode, menuIndex, selectedNodeId, selectedNodeParentId, expandAllClicked, sidebarExpanded, executeQueryAdHoc, catalogObjects, promotedEntities, treeStructureArr, setMenuList, treeViewMode } = props;
+	const [defaultExpanded, setDefaultExpanded] = useState(null);
+	const [isCurrentActiveTree, setIsCurrentActiveTree] = useState(false);
+	const [selectedNodeIsHidden, setSelectedNodeIsHidden] = useState(false);
+	const [loadingChildren, setLoadingChildren] = useState(false);
+	const [tree, setTree] = useState(menuItems);
+	const theme = useTheme();
+	const classes = useStyles$3(props);
+	const { enqueueSnackbar } = useSnackbar();
+	const handleSelectedNode = useCallback((e, value) => {
+		const selectedNode = searchTree(tree, value);
+		selectedNode.parentNode = findNodeById(menuItems, selectedNode.entityNodeParentId ? selectedNode.entityNodeParentId : selectedNode.parentId);
+		if (onSelectNode) {
+			onSelectNode(selectedNode, menuIndex, tree);
+			setSelectedNodeIsHidden(false);
+		}
+	}, [
+		tree,
+		menuIndex,
+		onSelectNode,
+		menuItems
+	]);
+	const renderTree = useCallback((node, depth = 1) => {
+		let nodeId = node.id;
+		let iconName = node.properties?.defaultIcon?.name;
+		let iconType = node.properties?.defaultIcon?.type;
+		let iconColor = node.properties?.defaultIcon?.color?.hex;
+		if (node.properties?.conditionalNodeIconName) {
+			iconName = node.properties?.conditionalNodeIconName;
+			iconType = node.properties?.conditionalNodeIconType;
+			iconColor = node.properties?.conditionalNodeIconName ? node.properties?.conditionalNodeIconColor ?? node.properties?.defaultIcon?.color?.hex : node.properties?.defaultIcon?.color?.hex;
+		}
+		let adornmentName = node.properties?.conditionalNodeAdornmentName || "";
+		let adornmentType = node.properties?.conditionalNodeAdornmentName ? node.properties.conditionalNodeAdornmentType : "";
+		let adornmentColor = node.properties?.conditionalNodeAdornmentName ? node.properties?.conditionalNodeAdornmentColor ?? node.properties?.defaultIcon?.color?.hex : "";
+		let aggregateThresholdId = node.properties?.aggregateThresholdId || "";
+		let aggregateThresholdNodeMapping = mapNodeObjValuesToSearchParameters(node?.nodeObj, node.properties?.aggregateThresholdParamMappings);
+		let label = node.properties?.nodeLabel || node.properties?.name;
+		let subLabel = node.properties?.nodeSubLabel;
+		if (node.isGroupNode) {
+			label = node.properties?.label;
+			subLabel = node.properties?.subLabel;
+			iconName = node.properties?.icon?.name;
+			iconType = node.properties?.icon?.type;
+			iconColor = node.properties?.icon?.color?.hex;
+		}
+		return /* @__PURE__ */ React.createElement(InquiryTreeMenuItem, {
+			key: nodeId,
+			nodeId,
+			label,
+			subLabel,
+			iconName,
+			iconType,
+			iconColor,
+			adornmentName,
+			adornmentType,
+			adornmentColor,
+			parentId: node.parentId,
+			onNodeSelect: handleSelectedNode,
+			selectedNodeId,
+			isSelectedNode: selectedNodeId === node.id,
+			showRightBorderColor: selectedNodeIsHidden && isCurrentActiveTree && getNodeIdForRightBorder(defaultExpanded, tree, selectedNodeParentId) === node.id,
+			isCurrentActiveTree,
+			sidebarExpanded,
+			depth,
+			hideExpansion: !node.properties?.lazyLoad && !!!node.children?.length,
+			node,
+			onDropNode,
+			treeViewMode,
+			menuIndex,
+			aggregateThresholdId,
+			aggregateThresholdNodeMapping
+		}, node.properties?.lazyLoad && !!!node.children?.length && !node.completedLoadingChildren && !node.errorRetrievingChildren && /* @__PURE__ */ React.createElement(CircularProgress, {
+			size: 12,
+			style: { marginLeft: (depth || 1) * theme.spacing(1) }
+		}), node.properties?.lazyLoad && !!!node.children?.length && node.completedLoadingChildren && sidebarExpanded && !node.errorRetrievingChildren && /* @__PURE__ */ React.createElement("div", { className: classes.noChildrenContainer }, /* @__PURE__ */ React.createElement(Typography, {
+			variant: "caption",
+			style: {
+				marginLeft: (depth || 1) * theme.spacing(3),
+				fontWeight: 400
+			}
+		}, "No Children")), node.properties?.lazyLoad && sidebarExpanded && node.errorRetrievingChildren && /* @__PURE__ */ React.createElement("div", { className: classes.noChildrenContainer }, /* @__PURE__ */ React.createElement(Typography, {
+			variant: "caption",
+			style: {
+				marginLeft: (depth || 1) * theme.spacing(3),
+				fontWeight: 400
+			}
+		}, node.completedLoadingChildren ? `Error Retrieving ${!!node.children?.length ? `Additional ` : ""}Children` : node.errorRetrievingChildren)), Array.isArray(node.children) ? node.children.map((n, i) => renderTree(n, depth + 1)) : null);
+	}, [
+		handleSelectedNode,
+		selectedNodeId,
+		selectedNodeIsHidden,
+		isCurrentActiveTree,
+		sidebarExpanded,
+		defaultExpanded,
+		tree,
+		selectedNodeParentId,
+		theme,
+		classes,
+		onDropNode,
+		treeViewMode,
+		menuIndex
+	]);
+	const handleNodeExpansion = useCallback(async (evt, nodeIds) => {
+		const expandingNodes = nodeIds.filter((x) => !defaultExpanded.includes(x));
+		let currentExpandedNodeId = null;
+		let currentExpandedNode = null;
+		if (nodeIds.length > defaultExpanded.length) currentExpandedNodeId = expandingNodes[0];
+		const treeCopy = cloneDeep(tree);
+		if (!currentExpandedNodeId) {
+			const collapsingNodeList = difference(defaultExpanded, nodeIds);
+			if (collapsingNodeList.length) {
+				const collapsingNodeId = collapsingNodeList[0];
+				const nodeMatch = findNodeById(treeCopy, collapsingNodeId);
+				if (nodeMatch) {
+					nodeMatch.isExpanded = false;
+					setMenuList((prevState) => {
+						const menuItemsListCopy = cloneDeep(prevState);
+						menuItemsListCopy[menuIndex] = treeCopy;
+						return menuItemsListCopy;
+					});
+				}
+			}
+		}
+		setDefaultExpanded(nodeIds);
+		if (currentExpandedNodeId) {
+			currentExpandedNode = searchTree(treeCopy, currentExpandedNodeId);
+			if (currentExpandedNode?.properties?.lazyLoad) {
+				setLoadingChildren(true);
+				const promises = [];
+				const parentNodeRefKeys = [];
+				const treeStructuresList = [];
+				const searchObjList = [];
+				const manyToManyPromises = [];
+				const manyToManyValueMap = {};
+				const manyToManyObjectList = [];
+				const matchingNode = findNodeById(treeCopy, currentExpandedNodeId);
+				if (matchingNode) matchingNode.children = [];
+				currentExpandedNode.lazyLoadChildrenArr.forEach((searchMethod) => {
+					parentNodeRefKeys.push(searchMethod.parentNodeRefKey);
+					const childTree = treeStructureArr.find((ts) => ts.properties.catalogReturnObject === searchMethod.catalogReturnObject);
+					childTree && treeStructuresList.push(childTree);
+					promises.push(executeQueryAdHoc({ data: searchMethod.data }, searchMethod.apiMethodId));
+					searchObjList.push({ wasLazyLoaded: currentExpandedNode?.properties?.lazyLoad });
+					if (searchMethod.manyToManyJointEntityApiMethodId) manyToManyObjectList.push({
+						manyToManyKeys: searchMethod["manyToManyKeys"],
+						apiMethodId: searchMethod.manyToManyJointEntityApiMethodId
+					});
+					else manyToManyObjectList.push(null);
+				});
+				const updatedNodeObj = cloneDeep(currentExpandedNode.nodeObj);
+				let errorExists = false;
+				await Promise.all(promises.map((p) => p.catch((e) => {
+					errorExists = true;
+					setLoadingChildren(false);
+				}))).then((responses) => {
+					responses.forEach((response, index) => {
+						if (response?.status === 200) {
+							if (response?.data?.pageList?.length) {
+								const manyToManyJoiningObject = manyToManyObjectList[index];
+								if (manyToManyJoiningObject) {
+									const childFilterElements = [];
+									const items = response.data.pageList;
+									manyToManyJoiningObject.manyToManyKeys.forEach((mtmKey) => {
+										const searchNameKey = mtmKey.searchNameKey;
+										const searchValueKey = mtmKey.searchValueKey;
+										const searchValue = [];
+										let formattedPropertyName = toUpperFirstChar(searchNameKey);
+										items.forEach((item) => {
+											if (item[searchValueKey]) searchValue.push(item[searchValueKey]);
+										});
+										childFilterElements.push({
+											searchField: formattedPropertyName,
+											searchValue: searchValue.toString(),
+											searchOperator: "IN"
+										});
+									});
+									const data = getSearchObject(childFilterElements, 1, 50);
+									const newIndex = Object.keys(manyToManyValueMap).length;
+									manyToManyValueMap[newIndex] = {
+										treeStructure: treeStructuresList[index],
+										searchObj: searchObjList[index],
+										joiningTableEntities: items,
+										joiningObject: manyToManyJoiningObject
+									};
+									manyToManyPromises.push(executeQueryAdHoc({ data }, manyToManyJoiningObject.apiMethodId));
+								} else if (treeStructuresList[index]) {
+									const items = response.data.pageList;
+									items?.length && items.forEach((item) => {
+										const displayTree = formatTreeMenuItem(item, treeStructuresList[index], catalogObjects, promotedEntities, null, searchObjList[index].wasLazyLoaded);
+										displayTree.parentId = currentExpandedNode.id;
+										if (displayTree.wasLazyLoaded && displayTree.properties?.isUsingJointEntityAdditionalProperties) enqueueSnackbar(`Promote ${displayTree.properties?.joiningEntityName} search method to view additional joining properties`, {
+											variant: "warning",
+											anchorOrigin: {
+												vertical: "top",
+												horizontal: "center"
+											},
+											preventDuplicate: true,
+											autoHideDuration: 5e3
+										});
+										if (matchingNode) {
+											if (displayTree.wasLazyLoaded && !displayTree.properties?.isUsingJointEntityAdditionalProperties && matchingNode.children.some((child) => child?.nodeObj?.businessObjectKey && child?.nodeObj?.businessObjectKey === displayTree?.nodeObj?.businessObjectKey)) return;
+											matchingNode.children.push(displayTree);
+										}
+									});
+								}
+								const parentNodeCatalogObjKey = parentNodeRefKeys[index];
+								if (parentNodeCatalogObjKey) updatedNodeObj[parentNodeCatalogObjKey] = response.data.pageList;
+							}
+						}
+					});
+				});
+				await Promise.all(manyToManyPromises.map((p) => p.catch((e) => {
+					errorExists = true;
+					setLoadingChildren(false);
+				}))).then((responses) => {
+					responses.forEach((response, index) => {
+						if (response?.status === 200) {
+							if (response?.data?.pageList?.length) {
+								const manytoManyValue = manyToManyValueMap[index];
+								if (manytoManyValue) {
+									const joiningEntityCatalogObjectKey = manytoManyValue.treeStructure?.properties?.joiningEntityCatalogObjectKey;
+									const items = response.data.pageList;
+									manytoManyValue.joiningTableEntities.forEach((entityRow) => {
+										const manyToManyJoiningObject = manytoManyValue.joiningObject;
+										if (manyToManyJoiningObject && entityRow.hasOwnProperty(joiningEntityCatalogObjectKey)) manyToManyJoiningObject.manyToManyKeys.forEach((mtmKey) => {
+											const searchValueKey = mtmKey.searchValueKey;
+											const searchItemIdentifier = mtmKey.searchItemIdentifier;
+											if (entityRow[searchValueKey]) entityRow[joiningEntityCatalogObjectKey] = items.find((item) => item[searchItemIdentifier] === entityRow[searchValueKey]);
+										});
+									});
+									manytoManyValue.joiningTableEntities.length && manytoManyValue.joiningTableEntities.forEach((item) => {
+										const displayTree = formatTreeMenuItem(item, manytoManyValue.treeStructure, catalogObjects, promotedEntities, null, manytoManyValue.searchObj.wasLazyLoaded);
+										displayTree.parentId = currentExpandedNode.id;
+										if (matchingNode) {
+											if (displayTree.wasLazyLoaded && !displayTree.properties?.isUsingJointEntityAdditionalProperties && matchingNode.children.some((child) => {
+												const joiningEntityCatalogObjectKey$1 = child.properties?.joiningEntityCatalogObjectKey;
+												if (displayTree?.nodeObj) return false;
+												return child?.nodeObj?.[joiningEntityCatalogObjectKey$1]?.businessObjectKey === displayTree?.nodeObj?.[joiningEntityCatalogObjectKey$1]?.businessObjectKey;
+											})) return;
+											matchingNode.children.push(displayTree);
+										}
+									});
+								}
+							}
+						}
+					});
+				});
+				if (matchingNode) matchingNode.completedLoadingChildren = true;
+				if (currentExpandedNode.lazyLoadChildrenArr.length) {
+					if (matchingNode) {
+						matchingNode.nodeObj = updatedNodeObj;
+						matchingNode.isExpanded = true;
+						if (errorExists) matchingNode.errorRetrievingChildren = true;
+					}
+					setMenuList((prevState) => {
+						const menuItemsListCopy = cloneDeep(prevState);
+						menuItemsListCopy[menuIndex] = treeCopy;
+						return menuItemsListCopy;
+					});
+					setLoadingChildren(false);
+				}
+			} else {
+				const foundNode = findNodeById(treeCopy, currentExpandedNodeId);
+				if (foundNode) foundNode.isExpanded = true;
+				else foundNode.isExpanded = false;
+				setMenuList((prevState) => {
+					const menuItemsListCopy = cloneDeep(prevState);
+					menuItemsListCopy[menuIndex] = treeCopy;
+					return menuItemsListCopy;
+				});
+			}
+		}
+		const allParentNodeIds = findAllParentIds(treeCopy, searchTree(treeCopy, selectedNodeParentId), selectedNodeParentId ? [selectedNodeParentId] : []);
+		const selectedNodeShown = allParentNodeIds.every((id) => nodeIds.includes(id));
+		if (isCurrentActiveTree && allParentNodeIds.length && !selectedNodeShown) setSelectedNodeIsHidden(true);
+		else setSelectedNodeIsHidden(false);
+	}, [
+		defaultExpanded,
+		tree,
+		selectedNodeParentId,
+		isCurrentActiveTree,
+		menuIndex,
+		setMenuList,
+		treeStructureArr,
+		executeQueryAdHoc,
+		catalogObjects,
+		promotedEntities,
+		enqueueSnackbar
+	]);
+	const getDefaultExpandedRecursively = useCallback((tree$1) => {
+		if (!tree$1) return [];
+		return tree$1.reduce((defaultExpandedIds, item) => {
+			if (item?.isExpanded) defaultExpandedIds.push(item.id);
+			if (item?.children?.length) defaultExpandedIds = defaultExpandedIds.concat(getDefaultExpandedRecursively(item.children));
+			return defaultExpandedIds;
+		}, []);
+	}, []);
+	useEffect(() => {
+		setTree(menuItems);
+	}, [menuItems]);
+	useEffect(() => {
+		if (!tree) return;
+		let expanded = [];
+		if (tree?.isExpanded) expanded.push(tree.id);
+		expanded = expanded.concat(getDefaultExpandedRecursively(tree.children));
+		setDefaultExpanded(expanded);
+	}, [getDefaultExpandedRecursively, tree]);
+	useEffect(() => {
+		if (!!searchTree(tree, selectedNodeId)) setIsCurrentActiveTree(true);
+		else setIsCurrentActiveTree(false);
+	}, [tree, selectedNodeId]);
+	useEffect(() => {
+		setSelectedNodeIsHidden(false);
+	}, [expandAllClicked]);
+	if (!defaultExpanded) return null;
+	return /* @__PURE__ */ React.createElement(TreeView, {
+		key: tree,
+		className: classes.root,
+		defaultCollapseIcon: /* @__PURE__ */ React.createElement(FluentIcon, {
+			size: "small",
+			component: CaretUpSolid8Icon,
+			style: {
+				color: lighten(theme.palette.primary.main, .5),
+				width: theme.spacing(1.5),
+				height: theme.spacing(1.5)
+			}
+		}),
+		expanded: defaultExpanded || [],
+		onNodeToggle: handleNodeExpansion,
+		defaultExpandIcon: /* @__PURE__ */ React.createElement(FluentIcon, {
+			size: "small",
+			component: CaretDownSolid8Icon,
+			style: {
+				color: lighten(theme.palette.primary.main, .5),
+				width: theme.spacing(1.5),
+				height: theme.spacing(1.5)
+			}
+		}),
+		selected: selectedNodeId
+	}, tree && renderTree(tree));
+};
+
+//#endregion
+//#region src/inquiry/NodeList.jsx
+const useStyles$2 = makeStyles((theme) => ({
+	root: { overflowX: "auto" },
+	nodeContainer: { width: "100%" },
+	loader: {
+		marginRight: theme.spacing(1),
+		marginLeft: theme.spacing(1)
+	},
+	empty: {
+		display: "flex",
+		justifyContent: "center",
+		alignItems: "center"
+	},
+	emptyIcon: { textAlign: "center" },
+	emptyIconText: { color: theme.palette.secondary }
+}));
+const NodeList = (props) => {
+	const { menuItemsList, onSelectNode, onDropNode, selectedNodeId, selectedNodeParentId, expandAllClicked, classes: classProps, menuLoading, nodesRequested, sidebarExpanded, executeQueryAdHoc, catalogObjects, promotedEntities, treeStructureArr, setMenuList, treeViewMode } = props;
+	const { root } = classProps || {};
+	const classes = useStyles$2();
+	const handleSelectNode = useCallback((selectedNode, menuIndex, selectedTree) => {
+		onSelectNode(selectedNode, menuIndex, selectedTree);
+	}, [onSelectNode]);
+	return /* @__PURE__ */ React.createElement("div", { className: clsx(classes.root, root, !!!menuItemsList?.length && !menuLoading && classes.empty) }, !!!menuItemsList?.length && !menuLoading && /* @__PURE__ */ React.createElement("div", { className: classes.emptyIcon }, /* @__PURE__ */ React.createElement(SvgIcon, {
+		src: NoEntityOpenedUrl,
+		size: 42
+	}), /* @__PURE__ */ React.createElement(Typography, {
+		variant: "subtitle1",
+		className: classes.emptyIconText
+	}, "No Entity Opened")), menuItemsList?.length > 0 && menuItemsList.map((menuItems, index) => /* @__PURE__ */ React.createElement("div", {
+		key: menuItems.id,
+		className: classes.nodeContainer
+	}, /* @__PURE__ */ React.createElement(InquiryTreeMenu, {
+		menuItems,
+		onSelectNode: handleSelectNode,
+		onDropNode,
+		menuIndex: index,
+		selectedNodeId,
+		selectedNodeParentId,
+		expandAllClicked,
+		sidebarExpanded,
+		executeQueryAdHoc,
+		catalogObjects,
+		promotedEntities,
+		treeStructureArr: treeStructureArr || [],
+		setMenuList,
+		treeViewMode
+	}))), menuLoading && /* @__PURE__ */ React.createElement("div", { className: classes.loader }, /* @__PURE__ */ React.createElement(NodeLoader, {
+		loading: menuLoading,
+		nodesRequested
+	})));
+};
+
+//#endregion
+//#region src/inquiry/InquiryContainer.jsx
+const useStyles$1 = makeStyles((theme) => ({
+	root: {
+		display: "flex",
+		height: ({ appRibbonSpace }) => `calc(100vh - ${appRibbonSpace + 56}px)`
+	},
+	mainWrapper: { padding: theme.spacing(2) },
+	children: { height: "calc(100vh - 150px)" },
+	searchContainerRoot: { height: "calc(100vh - 140px)" },
+	nodeListRoot: {
+		height: (props) => `calc(100vh - ${props.shellHidden ? "120px" : "176px"})`,
+		overflowX: "hidden"
+	},
+	nodeListRootLoaded: {
+		height: (props) => props.tree?.isPreloaded ? "calc(100vh - 140px)" : `calc(100vh - ${props.shellHidden ? "130px" : "184px"})`,
+		overflowX: "hidden"
+	},
+	tabRoot: {
+		width: "100%",
+		minWidth: 0
+	},
+	nodeListRootLoading: { height: "calc(100vh - 108px)" },
+	chevronButtons: {
+		display: "flex",
+		justifyContent: "center",
+		zIndex: theme.zIndex.appBar
+	},
+	chevronButtonClosed: {
+		position: "absolute",
+		left: "50%",
+		top: 14,
+		marginLeft: -13,
+		zIndex: theme.zIndex.appBar
+	},
+	entityHeader: {
+		position: "relative",
+		zIndex: theme.zIndex.appBar,
+		boxShadow: "0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 3px 3px 0px rgba(0, 0, 0, 0.12)"
+	},
+	nodeHeader: { boxShadow: "0px 2px 1px -1px rgba(0, 0, 0, 0.2), 0px 1px 1px 0px rgba(0, 0, 0, 0.14), 0px 3px 3px 0px rgba(0, 0, 0, 0.12)" },
+	content: {
+		overflowY: "auto",
+		height: "calc(100vh - 50px)"
+	},
+	workflowMenuContent: {
+		marginTop: theme.spacing(1),
+		height: ({ appRibbonSpace }) => `calc(100vh - ${appRibbonSpace + 120}px)`,
+		overflowX: "hidden",
+		paddingTop: theme.spacing(1)
+	},
+	workflowTreeLoader: {
+		marginRight: theme.spacing(1),
+		marginLeft: theme.spacing(1)
+	}
+}));
+const WORKFLOW_MAX_NETWORK_CALLS = 50;
+const InquiryContainer = (props) => {
+	const { catalogObjects, executeQueryAdHoc, executeQueryWithParameters, executeGetDetailedTree, executeAddRecentlyLoadedNodes, initialSearchValue, litnHistory, litnHistoryLoading, pageId, pageData, pageLoading, pageError, productId, promotedEntities, promotedMethods, shellContext, setPageId, tree, treeId, treeLoading, treeError, user, autoCollapseNav = true, containerId = "" } = props;
+	const shellHidden = useShellStore((state) => state.shellHidden);
+	const buildEnv = useBuildEnvironment();
+	const classes = useStyles$1({
+		shellHidden,
+		...props,
+		appRibbonSpace: buildEnv ? APP_RIBBON_SPACE : 0
+	});
+	const { t } = useTranslation();
+	const { enqueueSnackbar } = useSnackbar();
+	const [nodeLoaded, setNodeLoaded] = useState(false);
+	const [searchValue, setSearchValue] = useState(initialSearchValue || "");
+	const [clearSearchStr, setClearSearchStr] = useState(false);
+	const [inSearch, setInSearch] = useState(false);
+	const [selectedSearchRows, setSelectedSearchRows] = useState(null);
+	const [menuList, setMenuList] = useState([]);
+	const [menuLoading, setMenuLoading] = useState(false);
+	const [selectedNode, setSelectedNode] = useState(null);
+	const [selectedTree, setSelectedTree] = useState(null);
+	const [selectedMenuIndex, setSelectedMenuIndex] = useState(null);
+	const [disableMoveToTop, setDisableMoveToTop] = useState(true);
+	const [nodeHistory, setNodeHistory] = useState([]);
+	const [expandAllClicked, setExpandAllClicked] = useState(false);
+	const [tabValue, setTabValue] = useState(0);
+	const [selectedPageId, setSelectedPageId] = useState(null);
+	const [nodesRequested, setNodesRequested] = useState([]);
+	const [sidebarTabValue, setSidebarTabValue] = useState(0);
+	const [advancedSearchItems, setAdvancedSearchItems] = useState([]);
+	const [isAdvancedSearch, setIsAdvancedSearch] = useState(false);
+	const [entityValue, setEntityValue] = useState("");
+	const [treeViewMode, setTreeViewMode] = useState(TreeViewModeEnums.Classic);
+	const [advancedSearchEntityValue, setAdvancedSearchEntityValue] = useState("");
+	const [moveToTopLoading, setMoveToTopLoading] = useState(false);
+	const [promotedMethodsToExecute, setPromotedMethodsToExecute] = useState([]);
+	const [executeApiDialogOpen, setExecuteApiDialogOpen] = useState(false);
+	const [executeApiData, setExecuteApiData] = useState(null);
+	const [executeApiProgress, setExecuteApiProgress] = useState(false);
+	const [isPreloaded, setIsPreloaded] = useState(false);
+	const [headerTitle, setHeaderTitle] = useState("");
+	const [sidebarExpanded, setSidebarExpanded] = useState(true);
+	const [primaryExpanded, setPrimaryExpanded] = useState(false);
+	const [secondaryExpanded, setSecondaryExpanded] = useState(false);
+	const [showToggle1, setShowToggle1] = useState(false);
+	const [showToggle2, setShowToggle2] = useState(false);
+	const [utilitySideBarWidth, setUtilitySideBarWidth] = useState(288);
+	const [refreshNodeHeaderPageData, setRefreshNodeHeaderPageData] = useState(null);
+	const [refreshPageHeaderPageData, setRefreshPageHeaderPageData] = useState(null);
+	const [inquiryWorkflowTabValue, setInquiryWorkflowTabValue] = useState(1);
+	const [workflowMenuItemsList, setWorkflowMenuItemsList] = useState([]);
+	const [selectedWorkflowNode, setSelectedWorkflowNode] = useState(null);
+	const [reloadWorkflowFromPage, setReloadWorkflowFromPage] = useState(false);
+	const [getWorkflowPlayErrorCount, setGetWorkflowPlayErrorCount] = useState(0);
+	const [getWorkflowInitializedCount, setGetWorkflowInitializedCount] = useState(0);
+	const [workflowInitialized, setWorkflowInitialized] = useState(false);
+	const [workflow, setWorkflow] = useState(null);
+	useSetInitialInquiryMenuVisibility();
+	const inquiryMenuHidden = useInquiryStore((state) => state.inquiryMenuHidden);
+	const { setActionPanels, setShowInquiryHeaderActions, setMenuListState, setInquiryParams, closeAllSplitScreens } = useActions();
+	const setSelectedNodeForStore = useActionStore((state) => state.setSelectedNode);
+	const setHideActions = useActionStore((state) => state.setHideActions);
+	const setInquiryTitleHeader = useInquiryStore((state) => state.setInquiryToolbarTitle);
+	const setNavigationExpanded = useShellStore((state) => state.setNavigationExpanded);
+	const setSubHeaderActionHasChildren = useShellStore((state) => state.setSubHeaderActionHasChildren);
+	const inquiryTitle = useInquiryStore((state) => state.title);
+	const workflowMap = useInquiryStore((state) => state.workflowMap);
+	const setWorkflowMap = useInquiryStore((state) => state.setWorkflowMap);
+	const workflowStarting = useInquiryStore((state) => state.workflowStarting);
+	const setLocationState = useSetLocationState();
+	const [{ data: explorePageData, loading: explorePageLoading }] = useAxiosGet(ConfigService.tenantV1ApiUrl, `page/${tree?.explorePageId}`, {}, !!!tree?.explorePageId, false);
+	const orderBySequence = (list) => {
+		return orderBy(list, ["sequenceNo"], ["asc"]);
+	};
+	const inquiryWorkflow = useMemo(() => {
+		if (workflowMap) return workflowMap[containerId || 0];
+	}, [workflowMap, containerId]);
+	const nodeHeaderPageIdToLoad = useMemo(() => {
+		const nodeHeaderPages = selectedNode?.properties?.nodeHeaderPages;
+		if (!nodeHeaderPages) return null;
+		const orderedNodeHeaderPages = orderBySequence(nodeHeaderPages);
+		let nodeHeaderPageId = null;
+		for (let i = 0; i < orderedNodeHeaderPages.length; i++) {
+			const nodeHeaderPage = orderedNodeHeaderPages[i];
+			if (nodeHeaderPage?.propertyMapping && nodeHeaderPage?.jsonLogic) if (evaluateRule(mapRule(nodeHeaderPage?.propertyMapping, nodeHeaderPage?.jsonLogic), selectedNode.nodeObj, null, false)) {
+				nodeHeaderPageId = nodeHeaderPage.page?.pageId;
+				break;
+			} else continue;
+			else {
+				nodeHeaderPageId = nodeHeaderPage.page?.pageId;
+				break;
+			}
+		}
+		return nodeHeaderPageId;
+	}, [selectedNode]);
+	const pageHeaderPageIdToLoad = useMemo(() => {
+		if (!selectedPageId) return null;
+		const matchingTab = selectedNode?.properties?.tabs?.find((tab) => tab.page?.pageId === selectedPageId);
+		if (!matchingTab) return null;
+		const pageHeaderPages = matchingTab?.pageHeaderPages;
+		if (!pageHeaderPages) return null;
+		const orderedPageHeaderPages = orderBySequence(pageHeaderPages);
+		let pageHeaderPageId = null;
+		for (let i = 0; i < orderedPageHeaderPages.length; i++) {
+			const pageHeaderPage = orderedPageHeaderPages[i];
+			if (pageHeaderPage?.propertyMapping && pageHeaderPage?.jsonLogic) if (evaluateRule(mapRule(pageHeaderPage?.propertyMapping, pageHeaderPage?.jsonLogic), selectedNode.nodeObj, null, false)) {
+				pageHeaderPageId = pageHeaderPage.page?.pageId;
+				break;
+			} else continue;
+			else {
+				pageHeaderPageId = pageHeaderPage.page?.pageId;
+				break;
+			}
+		}
+		return pageHeaderPageId;
+	}, [selectedNode, selectedPageId]);
+	const [{ data: nodeHeaderPageData, loading: nodeHeaderPageLoading }] = useAxiosGet(ConfigService.tenantV1ApiUrl, `page/${nodeHeaderPageIdToLoad}`, {}, !!!nodeHeaderPageIdToLoad, false);
+	const [{ data: pageHeaderPageData, loading: pageHeaderPageLoading }] = useAxiosGet(ConfigService.tenantV1ApiUrl, `page/${pageHeaderPageIdToLoad}`, {}, !!!pageHeaderPageIdToLoad, false);
+	const [{ data: workflowPlay, loading: workflowPlayLoading, error: workflowPlayError }, reloadWorkflow] = useAxiosGet(ConfigService.builderV1ApiUrl, `workflow/play/${inquiryWorkflow?.currentWorkflowPlayId}`, {}, !!!inquiryWorkflow?.currentWorkflowPlayId, false);
+	const [{ data: users }] = useAxiosGet(ConfigService.securityV1ApiUrl, `users?tenantId=${user?.currentTenantId || ""}`, {}, !!!inquiryWorkflow?.inWorkflowMode && !!!user?.currentTenantId);
+	const [{ data: groups }] = useAxiosGet(ConfigService.tenantV1ApiUrl, `groups?tenantId=${user?.currentTenantId || ""}&productId=${ConfigService.config.UNITY_PRODUCT_ID}`, {}, !!!inquiryWorkflow?.inWorkflowMode && !!!user?.currentTenantId);
+	const handleReloadWorkflow = useCallback(async () => {
+		setReloadWorkflowFromPage(true);
+		if (inquiryWorkflow?.currentWorkflowPlayId) await reloadWorkflow();
+		setReloadWorkflowFromPage(false);
+	}, [reloadWorkflow, inquiryWorkflow]);
+	const handleSelectedWorkflowNode = useCallback(async (node, menuIndex) => {
+		if (node.isSelectable) {
+			setSelectedWorkflowNode(node);
+			await handleReloadWorkflow();
+		}
+	}, [handleReloadWorkflow]);
+	const searchItems = useMemo(() => {
+		if (!tree) return [];
+		return tree.treeStructure.reduce((items, node) => {
+			let item = null;
+			const entityAttributes = (catalogObjects?.find((co) => co.catalogObjectName === node.properties.catalogReturnObject))?.properties || null;
+			const searchFilterElements = node.properties?.searchFilterElements;
+			if (searchFilterElements) searchFilterElements.forEach((element) => element.searchValue = searchValue);
+			if (!node.parentId) item = {
+				apiMethodInstance: tree.apiMethodInstance,
+				apiMethodId: tree.apiMethodInstance.apiMethodId,
+				columns: entityAttributes || node.properties.searchTableColumns,
+				searchFilterElements,
+				id: `${v4()}-${searchValue}`,
+				catalogReturnObject: node.properties.catalogReturnObject,
+				treeStructure: tree.treeStructure,
+				associatedInquiryTree: null
+			};
+			else {
+				const associatedInquiryTree = node.properties?.associatedInquiryTree;
+				if (associatedInquiryTree && node.properties?.isPrimarySearch) item = {
+					apiMethodInstance: associatedInquiryTree.apiMethodInstance,
+					apiMethodId: associatedInquiryTree.apiMethodInstance?.apiMethodId,
+					columns: entityAttributes || node.properties.searchTableColumns,
+					searchFilterElements,
+					id: `${v4()}-${searchValue}`,
+					catalogReturnObject: node.properties.catalogReturnObject,
+					treeStructure: associatedInquiryTree.treeStructure,
+					associatedInquiryTree
+				};
+			}
+			if (item) items.push(item);
+			return items;
+		}, []);
+	}, [
+		tree,
+		searchValue,
+		catalogObjects
+	]);
+	const entitySearchItems = useMemo(() => {
+		if (!searchItems) return [];
+		if (!entityValue?.value) return searchItems;
+		else return searchItems.filter((item) => item.catalogReturnObject === entityValue.value);
+	}, [searchItems, entityValue]);
+	const getLoadedNodeObject = useCallback((apiMethodId, queryPayload, nodeLabel, catalogReturnObject, treeStructureId) => {
+		const loadedNode = {
+			productId,
+			inquiryTreeId: treeId,
+			userId: user.id,
+			apiMethodId,
+			nodeDetails: {},
+			queryPayload: {}
+		};
+		loadedNode.nodeDetails = {
+			nodeLabel,
+			catalogReturnObject,
+			treeStructureId
+		};
+		loadedNode.queryPayload = queryPayload;
+		return loadedNode;
+	}, [
+		treeId,
+		user,
+		productId
+	]);
+	const setAppNavigationExpanded = useCallback((value) => {
+		if (autoCollapseNav) setNavigationExpanded(value);
+	}, [autoCollapseNav, setNavigationExpanded]);
+	const loadNodes = useCallback((searchRows) => {
+		if (searchRows && Object.keys(searchRows).length) {
+			setSidebarTabValue(0);
+			setNodeLoaded(true);
+			setInSearch(false);
+			setMenuLoading(true);
+			const catalogObjectKeys = Object.keys(searchRows);
+			const promises = [];
+			const searchObjList = [];
+			const loadedNodesList = [];
+			const nodesRequestedArr = [];
+			catalogObjectKeys.forEach((key) => {
+				const searchObj = searchRows[key];
+				const currentSearchTree = searchObj?.treeStructure.find((tree$1) => tree$1?.properties?.catalogReturnObject === key);
+				const lazyLoad = !!currentSearchTree?.properties?.lazyLoad;
+				const rows = searchObj.rows;
+				const searchIdentifier = searchObj.searchIdentifier;
+				const apiMethodId = searchObj.apiMethodId;
+				const associatedInquiryTree = searchObj?.associatedInquiryTree;
+				rows.forEach((row) => {
+					const filterElements = [];
+					searchIdentifier.split(",").forEach((si) => {
+						const formattedPropertyName = si.charAt(0).toUpperCase() + si.slice(1);
+						filterElements.push({
+							searchField: formattedPropertyName,
+							searchValue: row[si] ?? "",
+							searchOperator: "="
+						});
+					});
+					const searchObject = getSearchObject(filterElements, 1, 50, !lazyLoad);
+					const data = { data: searchObject };
+					promises.push(executeQueryAdHoc(data, apiMethodId));
+					nodesRequestedArr.push(nodesRequestedArr.length + 1);
+					searchObjList.push({
+						searchObject,
+						apiMethodId,
+						treeStructure: searchObj.treeStructure,
+						catalogReturnObject: key,
+						associatedInquiryTree,
+						wasLazyLoaded: lazyLoad,
+						menuTree: currentSearchTree
+					});
+				});
+			});
+			setNodesRequested(nodesRequestedArr);
+			Promise.all(promises).then((responses) => {
+				const updatedMenuList = menuList.slice();
+				responses.forEach((response, index) => {
+					if (response.status === 200) {
+						if (response?.data?.pageList?.length) {
+							const treeStructure = makeTreeStructure(searchObjList[index].treeStructure, "id", "parentId");
+							const displayTree = formatTreeMenuItem(response.data.pageList[0], treeStructure, catalogObjects, promotedEntities, searchObjList[index].associatedInquiryTree, searchObjList[index].wasLazyLoaded);
+							if (displayTree && !Array.isArray(displayTree) && Object.keys(displayTree).length) {
+								updatedMenuList.push(displayTree);
+								loadedNodesList.push(getLoadedNodeObject(searchObjList[index].apiMethodId, searchObjList[index].searchObject, displayTree?.properties?.nodeLabel, searchObjList[index].catalogReturnObject, treeStructure.id));
+								if (index === 0) {
+									displayTree.properties.searchValue = getSearchValueString(response.data.pageList[0], displayTree?.properties?.searchIdentifier);
+									if (selectedNode) {
+										const updatedNodeHistory = nodeHistory.map((node) => node);
+										updatedNodeHistory.push(selectedNode);
+										setNodeHistory(updatedNodeHistory);
+									}
+									setActionPanels(displayTree?.properties.panels, containerId);
+									setSelectedNode(displayTree);
+								}
+							}
+						}
+					}
+				});
+				if (menuList.length) setSelectedMenuIndex(menuList.length);
+				else setSelectedMenuIndex(0);
+				executeAddRecentlyLoadedNodes({ data: loadedNodesList });
+				setAppNavigationExpanded(false);
+				setMenuList(updatedMenuList);
+				setSelectedSearchRows(null);
+				setMenuLoading(false);
+				setNodesRequested([]);
+				setSearchValue("");
+				setClearSearchStr(true);
+			});
+		}
+	}, [
+		menuList,
+		executeQueryAdHoc,
+		catalogObjects,
+		selectedNode,
+		nodeHistory,
+		getLoadedNodeObject,
+		executeAddRecentlyLoadedNodes,
+		promotedEntities,
+		setActionPanels,
+		setAppNavigationExpanded,
+		containerId
+	]);
+	const handleCloseWorkflow = useCallback(() => {
+		setWorkflowMap({ [containerId || 0]: {
+			inWorkflowMode: false,
+			currentWorkflowPlayId: ""
+		} });
+		setHideActions(false);
+		setSelectedWorkflowNode(null);
+		setWorkflowMenuItemsList([]);
+		setInquiryWorkflowTabValue(1);
+		setGetWorkflowPlayErrorCount(0);
+		setGetWorkflowInitializedCount(0);
+		setWorkflowInitialized(false);
+		setWorkflow(null);
+	}, [
+		setWorkflowMap,
+		containerId,
+		setHideActions
+	]);
+	const handleRemoveMenuItem = useCallback((menus) => {
+		const updatedMenuList = menus ?? menuList.slice();
+		updatedMenuList.splice(selectedMenuIndex, 1);
+		setMenuList(updatedMenuList);
+		setDisableMoveToTop(true);
+		if (updatedMenuList?.length) {
+			const newSelectedNode = updatedMenuList[0];
+			setActionPanels(newSelectedNode?.properties.panels, containerId);
+			setSelectedNode(newSelectedNode);
+			setSelectedMenuIndex(0);
+		} else {
+			setActionPanels([], containerId);
+			setSelectedNode(null);
+			setSelectedMenuIndex(null);
+			setNodeLoaded(false);
+			closeAllSplitScreens();
+			handleCloseWorkflow();
+		}
+	}, [
+		menuList,
+		selectedMenuIndex,
+		setActionPanels,
+		closeAllSplitScreens,
+		containerId,
+		handleCloseWorkflow
+	]);
+	const handleRecentlyLoadedNodeClick = useCallback(async (loadedNode, additionalAction = () => {}) => {
+		setNodeLoaded(true);
+		setMenuLoading(true);
+		setSidebarTabValue(0);
+		setNodesRequested([1]);
+		const data = { data: loadedNode?.queryPayload };
+		const currentTreeStructureArr = tree.treeStructure.filter((node) => loadedNode?.nodeDetails?.catalogReturnObject === node.properties.catalogReturnObject);
+		const currentTree = currentTreeStructureArr.find((t$1) => {
+			if (t$1?.properties?.associatedInquiryTree?.treeStructure) return t$1?.properties?.associatedInquiryTree?.treeStructure.find((n) => n.id === loadedNode?.nodeDetails?.treeStructureId);
+			else return false;
+		}) || currentTreeStructureArr[0];
+		if (currentTree) if (currentTree.properties?.associatedInquiryTree) {
+			const associatedTree = (currentTree.properties.associatedInquiryTree?.treeStructure).find((node) => node.id === loadedNode?.nodeDetails?.treeStructureId);
+			data.data.eagerLoad = !associatedTree?.properties?.lazyLoad;
+		} else data.data.eagerLoad = !currentTree?.properties?.lazyLoad;
+		const apiMethodId = loadedNode?.apiMethodId;
+		const response = await executeQueryAdHoc(data, apiMethodId).catch((e) => {
+			console.error(e);
+		});
+		if (response?.status === 200 && loadedNode?.nodeDetails?.catalogReturnObject) {
+			if (response?.data?.pageList?.length) {
+				const matchingNode = tree?.treeStructure?.find((node) => node.properties.catalogReturnObject === loadedNode?.nodeDetails?.catalogReturnObject);
+				let nodeTreeStructure = tree?.treeStructure;
+				if (matchingNode?.properties?.associatedInquiryTree) nodeTreeStructure = matchingNode?.properties?.associatedInquiryTree.treeStructure;
+				const treeStructure = makeTreeStructure(nodeTreeStructure, "id", "parentId");
+				const displayTree = formatTreeMenuItem(response.data.pageList[0], treeStructure, catalogObjects, promotedEntities, matchingNode?.properties?.associatedInquiryTree, !data.data.eagerLoad);
+				if (displayTree && !Array.isArray(displayTree) && Object.keys(displayTree).length) {
+					displayTree.properties.searchValue = getSearchValueString(response.data.pageList[0], displayTree?.properties?.searchIdentifier);
+					if (selectedNode) {
+						const updatedNodeHistory = nodeHistory.map((node) => node);
+						updatedNodeHistory.push(selectedNode);
+						setNodeHistory(updatedNodeHistory);
+					}
+					setActionPanels(displayTree?.properties.panels, containerId);
+					setSelectedNode(displayTree);
+					setAppNavigationExpanded(false);
+					setMenuList([displayTree]);
+				}
+				setSelectedMenuIndex(0);
+				setMenuLoading(false);
+				setNodesRequested([]);
+			}
+		} else {
+			setMenuLoading(false);
+			enqueueSnackbar(t(`Unable to load entity`), {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		}
+		additionalAction();
+	}, [
+		tree,
+		executeQueryAdHoc,
+		catalogObjects,
+		promotedEntities,
+		selectedNode,
+		setActionPanels,
+		nodeHistory,
+		enqueueSnackbar,
+		t,
+		setAppNavigationExpanded,
+		containerId
+	]);
+	const handleLoadNodes = useCallback(() => {
+		loadNodes(selectedSearchRows);
+	}, [selectedSearchRows, loadNodes]);
+	const handleSingleNodeLoad = useCallback((searchRow) => {
+		loadNodes(searchRow);
+	}, [loadNodes]);
+	const handleRowDoubleClick = useCallback((rowData, catalogReturnObject) => {
+		const node = {};
+		const searchItem = searchItems.find((item) => item.catalogReturnObject === catalogReturnObject);
+		const identifiers = getSearchIdentifiers(catalogObjects, searchItem.catalogReturnObject) || [];
+		node[searchItem.catalogReturnObject] = {
+			rows: [rowData],
+			apiMethodId: searchItem.apiMethodId,
+			searchIdentifier: identifiers.toString(),
+			treeStructure: searchItem.treeStructure
+		};
+		loadNodes(node);
+	}, [
+		loadNodes,
+		searchItems,
+		catalogObjects
+	]);
+	const clearNodes = useCallback(() => {
+		setNodeLoaded(false);
+		setMenuList([]);
+		setActionPanels([], containerId);
+		setSelectedNode(null);
+		setSelectedMenuIndex(null);
+		setNodeHistory([]);
+		setTabValue(0);
+		setSelectedPageId(null);
+		setPageId(null);
+		setHeaderTitle("");
+		setNodesRequested([]);
+		closeAllSplitScreens();
+		handleCloseWorkflow();
+	}, [
+		setActionPanels,
+		setPageId,
+		closeAllSplitScreens,
+		containerId,
+		handleCloseWorkflow
+	]);
+	const handlePrimaryAction = useCallback(() => {
+		handleLoadNodes();
+	}, [handleLoadNodes]);
+	const handleSearch = useCallback((event) => {
+		if (event.key === "Enter") {
+			setSearchValue(event.target.value);
+			setIsAdvancedSearch(false);
+			setInSearch(true);
+		}
+	}, []);
+	const clearSearch = useCallback(() => {
+		setInSearch(false);
+		if (menuList.length > 0) setShowToggle2(true);
+		setSearchValue("");
+		setClearSearchStr(true);
+		setSelectedSearchRows(null);
+	}, [menuList]);
+	const handleSelectedSearchRows = useCallback((objectName, rows, searchIdentifier, apiMethodId, treeStructure, associatedInquiryTree) => {
+		let searchRows = cloneDeep(selectedSearchRows);
+		if (!searchRows) searchRows = {};
+		searchRows[objectName] = {
+			rows,
+			searchIdentifier,
+			apiMethodId,
+			treeStructure,
+			associatedInquiryTree
+		};
+		setSelectedSearchRows(searchRows);
+	}, [selectedSearchRows]);
+	const handleSelectedNode = useCallback((newSelectedNode, menuIndex, selectedTree$1) => {
+		setSelectedMenuIndex(menuIndex);
+		setSelectedTree(selectedTree$1);
+		setInSearch(false);
+		if (newSelectedNode.properties.associatedTreeId) setDisableMoveToTop(false);
+		else setDisableMoveToTop(true);
+		if (selectedNode) {
+			const updatedNodeHistory = nodeHistory?.map((node) => node) || [];
+			updatedNodeHistory.push(selectedNode);
+			setNodeHistory(updatedNodeHistory);
+		}
+		setActionPanels(newSelectedNode?.properties.panels, containerId);
+		setSelectedNode(newSelectedNode);
+	}, [
+		selectedNode,
+		setActionPanels,
+		nodeHistory,
+		containerId
+	]);
+	const constructMenuItemForDroppedNode = useCallback((loadPageNodeActions, targetNodeObj, sourceNodeObj, targetNodeEntityName, sourceNodeEntityName) => {
+		const menuItem = {
+			children: [],
+			id: v4(),
+			isExpanded: true,
+			parentId: null,
+			properties: {
+				nodeLabel: "",
+				tabs: [],
+				searchValue: "",
+				nodeSubLabel: null,
+				defaultPageHeaderExpanded: "hidden",
+				defaultNodeHeaderExpanded: "hidden",
+				defaultIcon: {
+					color: null,
+					name: "BranchCompareIcon",
+					type: null
+				},
+				nodeActions: loadPageNodeActions,
+				isDroppedLoadedPageNode: true,
+				existingPageLoadEntities: [sourceNodeEntityName]
+			},
+			inquiryParams: [targetNodeObj, sourceNodeObj],
+			nodeObj: targetNodeObj
+		};
+		if (loadPageNodeActions?.length) loadPageNodeActions.forEach((nodeAction) => {
+			if (nodeAction?.dragEntityName === sourceNodeEntityName) {
+				const tabObj = {
+					id: v4(),
+					page: nodeAction.page,
+					inquiryTreeRuleId: nodeAction.inquiryTreeRuleId || "",
+					jsonLogic: nodeAction.jsonLogic || null,
+					propertyIsCustomMapping: nodeAction.propertyIsCustomMapping || "",
+					propertyMapping: nodeAction.propertyMapping || "",
+					sequence: nodeAction.sequence || "1",
+					requiredFieldMapping: nodeAction.parameters?.requiredFieldMapping || null
+				};
+				menuItem.properties.tabs.push(tabObj);
+			}
+		});
+		let nodeLabel = "DnD Nodes";
+		if (targetNodeEntityName === sourceNodeEntityName) nodeLabel = pluralize(getSanitizedName(targetNodeEntityName));
+		else nodeLabel = `${getSanitizedName(targetNodeEntityName)}/${getSanitizedName(sourceNodeEntityName)}`;
+		menuItem.properties.nodeLabel = nodeLabel;
+		return menuItem;
+	}, []);
+	const loadPageForDroppedNode = useCallback((sourceNode, targetNode, loadPageNodeActions, targetNodeCatalogReturnObject, sourceNodeCatalogReturnObject) => {
+		if (!targetNode?.properties?.isDroppedLoadedPageNode) {
+			if (loadPageNodeActions.length) {
+				setMoveToTopLoading(true);
+				const pageMenuItem = constructMenuItemForDroppedNode(orderBySequence(loadPageNodeActions), targetNode?.nodeObj, sourceNode?.nodeObj, targetNodeCatalogReturnObject, sourceNodeCatalogReturnObject);
+				const updatedMenuList = cloneDeep(menuList);
+				updatedMenuList.unshift(pageMenuItem);
+				setActionPanels(updatedMenuList[0]?.properties.panels, containerId);
+				setSelectedNode(updatedMenuList[0]);
+				setMenuList(updatedMenuList);
+				setMoveToTopLoading(false);
+			}
+		} else if (targetNode?.properties?.isDroppedLoadedPageNode) {
+			setMoveToTopLoading(true);
+			const updatedMenuList = cloneDeep(menuList);
+			const targetMenuItem = updatedMenuList.find((item) => item.id === targetNode.id);
+			if (targetMenuItem) {
+				const nodeLabel = targetMenuItem.properties?.nodeLabel;
+				if (!nodeLabel.includes(sourceNodeCatalogReturnObject)) targetMenuItem.properties.nodeLabel = `${nodeLabel}/${getSanitizedName(sourceNodeCatalogReturnObject)}`;
+				targetMenuItem.inquiryParams.push(sourceNode?.nodeObj);
+				if (!targetNode?.properties?.existingPageLoadEntities?.includes(sourceNodeCatalogReturnObject) && loadPageNodeActions?.length) {
+					targetMenuItem.properties.existingPageLoadEntities.push(sourceNodeCatalogReturnObject);
+					loadPageNodeActions.forEach((nodeAction) => {
+						if (nodeAction?.dragEntityName === sourceNodeCatalogReturnObject) {
+							const tabObj = {
+								id: v4(),
+								page: nodeAction.page,
+								inquiryTreeRuleId: nodeAction.inquiryTreeRuleId || "",
+								jsonLogic: nodeAction.jsonLogic || null,
+								propertyIsCustomMapping: nodeAction.propertyIsCustomMapping || "",
+								propertyMapping: nodeAction.propertyMapping || "",
+								sequence: nodeAction.sequence || "1",
+								requiredFieldMapping: nodeAction.parameters?.requiredFieldMapping || null
+							};
+							targetMenuItem.properties.tabs.push(tabObj);
+						}
+					});
+				}
+				setActionPanels(targetMenuItem?.properties.panels, containerId);
+				setSelectedNode(targetMenuItem);
+			}
+			setMenuList(updatedMenuList);
+			setMoveToTopLoading(false);
+		}
+	}, [
+		constructMenuItemForDroppedNode,
+		menuList,
+		setActionPanels,
+		containerId
+	]);
+	const handleDroppedNodeForExecuteApi = useCallback((sourceNode, targetNode, executeApiNodeActions, sourceNodeType, targetNodeType, sourceNodeMenuIndex, targetNodeMenuIndex) => {
+		if (!promotedMethods?.length) return;
+		const apiMethodIds = executeApiNodeActions.map((eana) => eana.actionValue);
+		const pmte = promotedMethods.filter((method) => apiMethodIds.includes(method?.apiMethodId));
+		setExecuteApiData({
+			source: sourceNode?.nodeObj,
+			target: targetNode?.nodeObj,
+			sourceNodeType,
+			targetNodeType,
+			sourceNodeMenuIndex,
+			targetNodeMenuIndex
+		});
+		setPromotedMethodsToExecute(pmte);
+		setExecuteApiDialogOpen(true);
+	}, [promotedMethods]);
+	const handleCloseExecuteApiDialog = useCallback(() => {
+		setExecuteApiData(null);
+		setPromotedMethodsToExecute([]);
+		setExecuteApiDialogOpen(false);
+	}, []);
+	const handleMenuTreesRefresh = useCallback(async (menuIndexes) => {
+		if (!menuList.length) return;
+		const updatedMenuList = menuList.slice();
+		const promises = [];
+		let apiMethodId = tree.apiMethodInstance.apiMethodId;
+		let workingTree = tree;
+		let assocInquiryTreeMap = {};
+		let searchObjList = [];
+		if (!menuIndexes?.length) menuIndexes = [selectedMenuIndex];
+		menuIndexes.forEach((index) => {
+			const menuTree = menuList[index];
+			if (menuTree) {
+				const { properties, associatedInquiryTree } = menuTree;
+				const { filterElements } = properties;
+				if (associatedInquiryTree) {
+					apiMethodId = associatedInquiryTree.apiMethodInstance.apiMethodId;
+					workingTree = associatedInquiryTree;
+					assocInquiryTreeMap[index] = associatedInquiryTree;
+				}
+				const lazyLoad = !!workingTree?.properties?.lazyLoad;
+				const data = { data: getSearchObject(filterElements, 1, 50, !lazyLoad) };
+				promises.push(executeQueryAdHoc(data, apiMethodId));
+				searchObjList.push({ wasLazyLoaded: lazyLoad });
+			}
+		});
+		await Promise.all(promises.map((p) => p.catch((e) => e))).then((responses) => {
+			responses.forEach((response, index) => {
+				if (response.status === 200) {
+					if (response?.data?.pageList?.length) {
+						const treeStructure = makeTreeStructure(workingTree.treeStructure, "id", "parentId");
+						const displayTree = formatTreeMenuItem(response.data.pageList[0], treeStructure, catalogObjects, promotedEntities, assocInquiryTreeMap[index], searchObjList[index].wasLazyLoaded);
+						updatedMenuList[menuIndexes[index]] = displayTree;
+					}
+				}
+			});
+		});
+		const currentSelectedTree = updatedMenuList[selectedMenuIndex];
+		const selectedNodeSearchIdentifier = selectedNode.properties.searchIdentifier || [];
+		setMenuList(updatedMenuList);
+		if (selectedNodeSearchIdentifier) {
+			const matchingNode = searchForMatchingNode(currentSelectedTree, selectedNode.nodeObj, selectedNodeSearchIdentifier.split(","));
+			setActionPanels(matchingNode?.properties.panels, containerId);
+			setSelectedNode(matchingNode);
+		} else setSelectedNode(selectedNode);
+	}, [
+		menuList,
+		tree,
+		selectedMenuIndex,
+		catalogObjects,
+		executeQueryAdHoc,
+		selectedNode,
+		promotedEntities,
+		setActionPanels,
+		containerId
+	]);
+	const handleMenuTreesRefreshFromPage = useCallback(async (updateAllPreloadedTrees = false) => {
+		if (!selectedNode) return;
+		let selectedNodeIndex = -1;
+		let apiMethodId = tree.apiMethodInstance.apiMethodId;
+		let workingTree = tree;
+		if (selectedTree) {
+			if (selectedTree.children.length > 0) selectedNodeIndex = selectedTree.children.indexOf(selectedNode);
+			const { properties, associatedInquiryTree } = selectedTree;
+			const { filterElements } = properties;
+			if (associatedInquiryTree) {
+				apiMethodId = associatedInquiryTree.apiMethodInstance.apiMethodId;
+				workingTree = associatedInquiryTree;
+			}
+			const lazyLoad = !!workingTree?.properties?.lazyLoad;
+			const data = { data: getSearchObject(filterElements, 1, 50, !lazyLoad) };
+			let displayTree = null;
+			let response = null;
+			if (tree?.isPreloaded && tree?.apiMethodInstance?.apiMethodInstanceId && selectedTree.isGroupNode) response = await executeQueryInstance({ data: {} }, tree.apiMethodInstance.apiMethodInstanceId);
+			else response = await executeQueryAdHoc(data, apiMethodId);
+			if (response?.status === 200) {
+				if (response?.data?.pageList?.length) {
+					const treeStructure = makeTreeStructure(workingTree.treeStructure, "id", "parentId");
+					let responseObj = response.data.pageList[0];
+					if (selectedTree.isGroupNode) responseObj = response.data.pageList;
+					displayTree = formatTreeMenuItem(responseObj, treeStructure, catalogObjects, promotedEntities, associatedInquiryTree, lazyLoad);
+				}
+			}
+			if (selectedTree.isGroupNode && selectedTree.children.length > 0) displayTree.map((childNode) => {
+				childNode.parentGroupId = selectedTree.id;
+				childNode.parentId = selectedTree.id;
+				childNode.parentGroupName = selectedTree.properties.label;
+			});
+			const currentSelectedTree = displayTree;
+			const selectedNodeSearchIdentifier = selectedNode.properties.searchIdentifier || "";
+			setMenuList((prevState) => {
+				const updatedMenuList = prevState.slice();
+				if (updateAllPreloadedTrees && workingTree?.isPreloaded) updatedMenuList.forEach((menuItem) => {
+					const newGroupId = v4();
+					menuItem.id = newGroupId;
+					menuItem.children?.forEach((childNode) => {
+						childNode.parentGroupId = newGroupId;
+						childNode.parentId = newGroupId;
+					});
+				});
+				if (selectedTree.isGroupNode) {
+					if (selectedTree.children.length > 0 && Array.isArray(displayTree)) updatedMenuList[selectedMenuIndex].children = displayTree;
+					if (!updateAllPreloadedTrees) {
+						const newGroupId = v4();
+						updatedMenuList[selectedMenuIndex].id = newGroupId;
+						updatedMenuList[selectedMenuIndex]?.children?.forEach((childNode) => {
+							childNode.parentGroupId = newGroupId;
+							childNode.parentId = newGroupId;
+						});
+					}
+				} else if (!selectedTree.isGroupNode) updatedMenuList[selectedMenuIndex] = displayTree;
+				return updatedMenuList;
+			});
+			if (selectedNodeSearchIdentifier) {
+				let tree$1 = currentSelectedTree;
+				if (selectedTree.isGroupNode && selectedNodeIndex >= 0) tree$1 = currentSelectedTree[selectedNodeIndex];
+				const matchingNode = searchForMatchingNode(tree$1, selectedNode.nodeObj, selectedNodeSearchIdentifier.split(","));
+				setActionPanels(matchingNode?.properties.panels, containerId);
+				setSelectedNode(matchingNode);
+			} else if (selectedTree.isGroupNode && selectedNodeIndex >= 0) setSelectedNode(displayTree[selectedNodeIndex]);
+			else setSelectedNode(selectedNode);
+		}
+	}, [
+		tree,
+		selectedMenuIndex,
+		catalogObjects,
+		executeQueryAdHoc,
+		selectedNode,
+		promotedEntities,
+		setActionPanels,
+		containerId,
+		selectedTree
+	]);
+	const executeApiForDroppedNode = useCallback(async (value) => {
+		setExecuteApiProgress(true);
+		const { sourceNodeMenuIndex, targetNodeMenuIndex, ...apiData } = executeApiData;
+		if ((await executeQueryWithParameters({ data: { requestBody: { ...apiData } } }, value?.apiMethod?.apiMethodId).catch((res) => {
+			console.error(res);
+		}))?.status === 200) {
+			const menuIndexes = [sourceNodeMenuIndex];
+			if (sourceNodeMenuIndex !== targetNodeMenuIndex) menuIndexes.push(targetNodeMenuIndex);
+			handleMenuTreesRefresh(menuIndexes);
+		}
+		setExecuteApiProgress(false);
+		handleCloseExecuteApiDialog();
+	}, [
+		executeQueryWithParameters,
+		handleCloseExecuteApiDialog,
+		executeApiData,
+		handleMenuTreesRefresh
+	]);
+	const handleDroppedNode = useCallback((sourceNode, targetNode, sourceNodeMenuIndex, targetNodeMenuIndex) => {
+		const sourceNodeCatalogReturnObject = sourceNode?.properties?.catalogReturnObject;
+		const targetNodeCatalogReturnObject = targetNode?.properties?.catalogReturnObject;
+		const targetNodeActions = targetNode?.properties?.nodeActions || [];
+		const loadPageNodeActions = targetNodeActions.filter((nodeAction) => nodeAction.triggerType === NodeActionTriggerEnums.On_Node_Drop && nodeAction.actionTypeId === NodeActionEnums.Load_Inquiry_Page);
+		const executeApiNodeActions = targetNodeActions.filter((nodeAction) => nodeAction.triggerType === NodeActionTriggerEnums.On_Node_Drop && nodeAction.actionTypeId === NodeActionEnums.Execute_Api && sourceNodeCatalogReturnObject === nodeAction?.dragEntityName);
+		targetNodeActions.filter((nodeAction) => nodeAction.triggerType === NodeActionTriggerEnums.On_Node_Drop && nodeAction.actionTypeId === NodeActionEnums.Start_Workflow && sourceNodeCatalogReturnObject === nodeAction?.dragEntityName);
+		if (targetNodeActions.some((tna) => tna.dragEntityName === sourceNodeCatalogReturnObject && tna.actionTypeId === NodeActionEnums.Execute_Api)) handleDroppedNodeForExecuteApi(sourceNode, targetNode, executeApiNodeActions, sourceNodeCatalogReturnObject, targetNodeCatalogReturnObject, sourceNodeMenuIndex, targetNodeMenuIndex);
+		if (targetNodeActions.some((tna) => tna.dragEntityName === sourceNodeCatalogReturnObject && tna.actionTypeId === NodeActionEnums.Load_Inquiry_Page)) loadPageForDroppedNode(sourceNode, targetNode, loadPageNodeActions, targetNodeCatalogReturnObject, sourceNodeCatalogReturnObject);
+	}, [loadPageForDroppedNode, handleDroppedNodeForExecuteApi]);
+	const handleMoveToTop = useCallback(async () => {
+		if (!selectedNode) return;
+		const associatedTreeId = selectedNode.properties.associatedTreeId;
+		if (!associatedTreeId) return;
+		setMenuLoading(true);
+		setMoveToTopLoading(true);
+		let associatedInquiryTree = selectedNode.properties.associatedInquiryTree;
+		if (!associatedInquiryTree) {
+			const detailedTreeResponse = await executeGetDetailedTree(associatedTreeId);
+			if (detailedTreeResponse.status === 200) associatedInquiryTree = detailedTreeResponse.data;
+		}
+		const lazyLoad = !!associatedInquiryTree?.properties?.lazyLoad;
+		const filterElements = selectedNode.properties.filterElements;
+		const apiMethodId = associatedInquiryTree.apiMethodInstance.apiMethodId;
+		const searchObject = getSearchObject(filterElements, 1, 50, !lazyLoad);
+		const data = { data: searchObject };
+		const loadedNodesList = [];
+		const response = await executeQueryAdHoc(data, apiMethodId).catch((res) => {
+			enqueueSnackbar(t(`Unable to move to top: ${res?.response?.data}`), {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+		});
+		if (response?.status === 200) {
+			if (response?.data?.pageList?.length) {
+				const updatedMenuList = menuList.slice();
+				const treeStructure = makeTreeStructure(associatedInquiryTree.treeStructure, "id", "parentId");
+				const displayTree = formatTreeMenuItem(response.data.pageList[0], treeStructure, catalogObjects, promotedEntities, associatedInquiryTree, lazyLoad);
+				loadedNodesList.push(getLoadedNodeObject(apiMethodId, searchObject, displayTree?.properties?.nodeLabel, displayTree?.properties?.catalogReturnObject, treeStructure.id));
+				if (displayTree && !Array.isArray(displayTree) && Object.keys(displayTree).length) {
+					displayTree.properties.searchValue = getSearchValueString(response.data.pageList[0], displayTree?.properties?.searchIdentifier);
+					if (selectedNode) {
+						const updatedNodeHistory = nodeHistory.map((node) => node);
+						updatedNodeHistory.push(selectedNode);
+						setNodeHistory(updatedNodeHistory);
+					}
+					setActionPanels(displayTree?.properties.panels, containerId);
+					setSelectedNode(displayTree);
+					executeAddRecentlyLoadedNodes({ data: loadedNodesList });
+					updatedMenuList[selectedMenuIndex] = displayTree;
+					setMenuList(updatedMenuList);
+				}
+				setDisableMoveToTop(true);
+			}
+		}
+		setMenuLoading(false);
+		setMoveToTopLoading(false);
+	}, [
+		selectedNode,
+		executeQueryAdHoc,
+		executeGetDetailedTree,
+		menuList,
+		catalogObjects,
+		promotedEntities,
+		getLoadedNodeObject,
+		setActionPanels,
+		executeAddRecentlyLoadedNodes,
+		selectedMenuIndex,
+		nodeHistory,
+		containerId,
+		enqueueSnackbar,
+		t
+	]);
+	const handleExpandAll = useCallback(() => {
+		setMenuList((prevState) => {
+			const updatedMenuList = cloneDeep(prevState);
+			updatedMenuList.forEach((tree$1) => {
+				expandAllNodes(tree$1);
+			});
+			return updatedMenuList;
+		});
+		setExpandAllClicked(!expandAllClicked);
+	}, [expandAllClicked]);
+	const handleCollapseAll = useCallback(() => {
+		setMenuList((prevState) => {
+			const updatedMenuList = cloneDeep(prevState);
+			updatedMenuList.forEach((tree$1) => {
+				collapseAllNodes(tree$1);
+			});
+			return updatedMenuList;
+		});
+	}, []);
+	const inquiryTabList = useMemo(() => {
+		if (!selectedNode || !selectedNode?.properties?.tabs) return [];
+		const tabList = [];
+		orderBySequence(selectedNode.properties.tabs).forEach((tab) => {
+			if (tab?.propertyMapping && tab?.jsonLogic) {
+				if (!evaluateRule(mapRule(tab?.propertyMapping, tab?.jsonLogic), selectedNode.nodeObj, null, false)) return;
+			}
+			let label = "";
+			if (tab?.displayName && tab?.displayName.trim()) label = tab?.displayName.trim();
+			else if (tab?.page?.name && tab?.page?.name.trim()) label = tab?.page?.name.trim();
+			const page = {
+				label,
+				icon: null,
+				pageId: tab?.page?.pageId || null,
+				trees: tab?.trees || [],
+				requiredFieldMapping: tab?.requiredFieldMapping || {},
+				queryId: tab?.queryId || "",
+				queryParamMapping: tab?.queryParamMapping || null
+			};
+			tabList.push(page);
+		});
+		setSelectedPageId(tabList[0]?.pageId);
+		return tabList;
+	}, [selectedNode]);
+	const handlePageChange = useCallback((event, value) => {
+		setTabValue(value);
+		if (selectedPageId !== inquiryTabList[value]?.pageId) setSelectedPageId(inquiryTabList[value]?.pageId);
+	}, [inquiryTabList, selectedPageId]);
+	const handleLoadingSpecificNode = useCallback(async (obj) => {
+		setMenuLoading(true);
+		setNodesRequested([1]);
+		const currentTabValue = inquiryTabList?.length ? inquiryTabList[tabValue] : null;
+		let error = false;
+		let errorMessage = t(`Unable to load entity`);
+		if (!obj?.businessObjectKey) {
+			error = true;
+			errorMessage = t(`Unable to load entity: No Business Object Key`);
+		} else if (!currentTabValue?.trees?.length) {
+			error = true;
+			errorMessage = t(`Unable to load entity: No Trees Configured for Tab`);
+		}
+		if (error) {
+			setMenuLoading(false);
+			setNodesRequested([]);
+			enqueueSnackbar(errorMessage, {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+			return;
+		}
+		const fullyQualifiedName = obj.businessObjectKey.split("|")[0];
+		const sanitizedName = getSanitizedName(fullyQualifiedName);
+		const catObjName = catalogObjects.find((domain) => domain.catalogObjectName === fullyQualifiedName) ? fullyQualifiedName : sanitizedName;
+		const matchingTabValueTree = currentTabValue.trees.find((tabTree) => tabTree.catalogReturnObject === catObjName);
+		if (!matchingTabValueTree) {
+			setMenuLoading(false);
+			setNodesRequested([]);
+			enqueueSnackbar(t(`Unable to load entity: Incorrect tree(s) configured for Node trying to load`), {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+			return;
+		}
+		let nodeTree = null;
+		const detailedTreeResponse = await executeGetDetailedTree(matchingTabValueTree.treeId);
+		if (detailedTreeResponse.status === 200) nodeTree = detailedTreeResponse.data;
+		else {
+			setMenuLoading(false);
+			setNodesRequested([]);
+			enqueueSnackbar(t(`Unable to load entity: Tree for item failed to load`), {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+			return;
+		}
+		if (!nodeTree) {
+			setMenuLoading(false);
+			setNodesRequested([]);
+			enqueueSnackbar(t(`Unable to load entity: Tree for item failed to load`), {
+				variant: "error",
+				anchorOrigin: {
+					vertical: "top",
+					horizontal: "center"
+				}
+			});
+			return;
+		}
+		const searchIdentifiers = getSearchIdentifiers(catalogObjects, catObjName);
+		const filterElements = [];
+		const searchValues = [];
+		searchIdentifiers.forEach((searchIdentifier) => {
+			const searchField = searchIdentifier ? searchIdentifier.charAt(0).toUpperCase() + searchIdentifier.slice(1) : "";
+			filterElements.push({
+				searchField,
+				searchOperator: "=",
+				searchValue: obj[searchIdentifier] ?? ""
+			});
+			searchValues.push(obj[searchIdentifier]);
+		});
+		const apiMethodId = nodeTree.apiMethodInstance.apiMethodId;
+		const lazyLoad = !!nodeTree?.properties?.lazyLoad;
+		const searchResponse = await executeQueryAdHoc({ data: getSearchObject(filterElements, 1, 50, !lazyLoad) }, apiMethodId);
+		if (searchResponse.status === 200) {
+			if (searchResponse?.data?.pageList?.length) {
+				const treeStructure = makeTreeStructure(nodeTree.treeStructure, "id", "parentId");
+				const displayTree = formatTreeMenuItem(searchResponse.data.pageList[0], treeStructure, catalogObjects, promotedEntities, nodeTree, lazyLoad);
+				setMenuList((prevState) => [...prevState, displayTree]);
+				setNodesRequested([]);
+				setMenuLoading(false);
+			}
+		}
+	}, [
+		inquiryTabList,
+		tabValue,
+		catalogObjects,
+		enqueueSnackbar,
+		t,
+		executeGetDetailedTree,
+		executeQueryAdHoc,
+		promotedEntities
+	]);
+	const handleSideBarValueChange = useCallback((value) => {
+		setSidebarTabValue(value);
+	}, []);
+	const handleAdvancedSearchClick = useCallback((values, selectedSearchOperators, entity, lookupPropertyNames) => {
+		setIsAdvancedSearch(true);
+		setInSearch(true);
+		const foundSearchItem = searchItems.find((item) => item.catalogReturnObject === entity);
+		const searchFilterElements = [];
+		Object.keys(values).filter((field) => field.startsWith(`${getSanitizedName(entity)}:`)).forEach((searchField) => {
+			const filterElement = {
+				searchField: "",
+				searchOperator: "",
+				searchValue: ""
+			};
+			const configuredSearchField = searchField.replace(`${getSanitizedName(entity)}:`, "");
+			filterElement.searchField = configuredSearchField.charAt(0).toUpperCase() + configuredSearchField.slice(1);
+			filterElement.searchOperator = selectedSearchOperators && selectedSearchOperators[configuredSearchField]?.value || "=";
+			if (configuredSearchField.includes(":between") || !values[searchField]) return;
+			if (filterElement.searchOperator === "BETWEEN") {
+				let fromValue = values[searchField] instanceof Date ? values[searchField].toISOString() : values[searchField];
+				let toValue = values[`${searchField}:between`] instanceof Date ? values[`${searchField}:between`].toISOString() : values[`${searchField}:between`];
+				filterElement.searchValue = `${fromValue}${toValue ? `,${toValue}` : ""}`;
+			} else filterElement.searchValue = values[searchField] instanceof Date ? values[searchField].toISOString() : values[searchField];
+			if (lookupPropertyNames.includes(configuredSearchField)) filterElement.searchValue = values[searchField]["value"];
+			searchFilterElements.push(filterElement);
+		});
+		foundSearchItem.searchFilterElements = searchFilterElements;
+		setAdvancedSearchItems([foundSearchItem]);
+	}, [searchItems]);
+	const entityList = useMemo(() => {
+		if (!searchItems?.length) return [];
+		return searchItems.reduce((entities, item) => {
+			if (item.catalogReturnObject) entities.push({
+				label: getSanitizedName(item.catalogReturnObject),
+				value: item.catalogReturnObject
+			});
+			return entities;
+		}, []);
+	}, [searchItems]);
+	const secondaryButtons = useMemo(() => {
+		if (inSearch) return [{
+			component: ClearIcon,
+			label: "Clear Search",
+			click: clearSearch,
+			id: 1
+		}];
+		return [];
+	}, [clearSearch, inSearch]);
+	const pageHeightOffSet = useMemo(() => {
+		let offset = 0;
+		if (primaryExpanded) offset = offset + 180;
+		if (secondaryExpanded) offset = offset + 270;
+		if (selectedNode?.properties?.tabs?.length > 1) offset = offset + 44;
+		return offset;
+	}, [
+		primaryExpanded,
+		secondaryExpanded,
+		selectedNode
+	]);
+	const onTreeViewModeChange = useCallback(() => {
+		if (treeViewMode === TreeViewModeEnums.Classic) setTreeViewMode(TreeViewModeEnums.Compact);
+		else if (treeViewMode === TreeViewModeEnums.Compact) setTreeViewMode(TreeViewModeEnums.Classic);
+	}, [treeViewMode]);
+	const selectedNodeChildren = useMemo(() => {
+		if (!!!selectedNode?.children?.length) return [];
+		return selectedNode?.children?.filter((child) => !(child instanceof GroupNode));
+	}, [selectedNode]);
+	const udpPageWidgetParams = useMemo(() => {
+		const currentTabValue = inquiryTabList?.length ? inquiryTabList[tabValue] : null;
+		return {
+			pageId: currentTabValue?.pageId || "",
+			entityName: selectedNode?.properties?.catalogReturnObject,
+			contentId: selectedNode?.properties?.searchValue,
+			nodeObj: selectedNode?.nodeObj,
+			nodeId: selectedNode?.id,
+			manytoManyNodeObjKey: selectedNode?.properties?.joiningEntityCatalogObjectKey,
+			parentNodeObj: selectedNode?.parentNode?.nodeObj,
+			parentGroupName: selectedNode?.parentGroupName,
+			inquiryParams: selectedNode?.inquiryParams,
+			inquiryNodeProperties: selectedNode?.properties,
+			refreshTree: handleMenuTreesRefreshFromPage,
+			loadInquiryNode: handleLoadingSpecificNode,
+			requiredFieldsMap: currentTabValue?.requiredFieldMapping || {},
+			displayLoadNodeButton: !!currentTabValue?.trees?.length,
+			nodeChildren: selectedNodeChildren,
+			catalogObjects,
+			queryId: currentTabValue?.queryId,
+			queryParamMapping: currentTabValue?.queryParamMapping,
+			refreshNodeHeaderData: refreshNodeHeaderPageData,
+			refreshPageHeaderData: refreshPageHeaderPageData,
+			inquiryContainerId: containerId
+		};
+	}, [
+		inquiryTabList,
+		selectedNode,
+		catalogObjects,
+		handleMenuTreesRefreshFromPage,
+		handleLoadingSpecificNode,
+		tabValue,
+		selectedNodeChildren,
+		refreshNodeHeaderPageData,
+		refreshPageHeaderPageData,
+		containerId
+	]);
+	const pageWidgetParams = useMemo(() => {
+		const currentTabValue = inquiryTabList?.length ? inquiryTabList[tabValue] : null;
+		return {
+			pageId: currentTabValue?.pageId || "",
+			entityName: selectedNode?.properties?.catalogReturnObject,
+			contentId: selectedNode?.properties?.searchValue,
+			nodeObj: selectedNode?.nodeObj,
+			nodeId: selectedNode?.id,
+			manytoManyNodeObjKey: selectedNode?.properties?.joiningEntityCatalogObjectKey,
+			parentNodeObj: selectedNode?.parentNode?.nodeObj,
+			parentGroupName: selectedNode?.parentGroupName,
+			inquiryParams: selectedNode?.inquiryParams,
+			inquiryNodeProperties: selectedNode?.properties,
+			heightOffset: pageHeightOffSet,
+			refreshTree: handleMenuTreesRefreshFromPage,
+			loadInquiryNode: handleLoadingSpecificNode,
+			requiredFieldsMap: currentTabValue?.requiredFieldMapping || {},
+			displayLoadNodeButton: !!currentTabValue?.trees?.length,
+			nodeChildren: selectedNodeChildren,
+			catalogObjects,
+			queryId: currentTabValue?.queryId,
+			queryParamMapping: currentTabValue?.queryParamMapping,
+			refreshNodeHeaderData: refreshNodeHeaderPageData,
+			refreshPageHeaderData: refreshPageHeaderPageData,
+			inquiryContainerId: containerId
+		};
+	}, [
+		inquiryTabList,
+		selectedNode,
+		catalogObjects,
+		handleMenuTreesRefreshFromPage,
+		handleLoadingSpecificNode,
+		pageHeightOffSet,
+		tabValue,
+		selectedNodeChildren,
+		refreshNodeHeaderPageData,
+		refreshPageHeaderPageData,
+		containerId
+	]);
+	const pageContainer = useMemo(() => {
+		return /* @__PURE__ */ React.createElement(PageContainer, {
+			user,
+			key: selectedNode?.properties?.searchValue,
+			pageData,
+			pageLoading,
+			widgetParams: pageData?.isUdpPage ? udpPageWidgetParams : pageWidgetParams,
+			disableMargins: true
+		});
+	}, [
+		user,
+		pageData,
+		pageLoading,
+		udpPageWidgetParams,
+		selectedNode,
+		pageWidgetParams
+	]);
+	const handleSidebarExpandClick = useCallback(() => {
+		setSidebarExpanded((expanded) => !expanded);
+	}, []);
+	const handleInquiryWorkflowTabChange = useCallback((value, tabValue$1) => {
+		setInquiryWorkflowTabValue(tabValue$1);
+	}, []);
+	useEffect(() => {
+		setSubHeaderActionHasChildren(false);
+	}, [setSubHeaderActionHasChildren]);
+	useEffect(() => {
+		clearNodes();
+		clearSearch();
+	}, [treeId]);
+	useEffect(() => {
+		if (shellContext) {
+			shellContext.setSecondExtendedWindow(true);
+			shellContext.setHeaderExpander(false);
+		}
+	}, [shellContext]);
+	useEffect(() => {
+		if (inSearch) {
+			setHeaderTitle("");
+			setPrimaryExpanded(false);
+			setSecondaryExpanded(false);
+			setShowToggle1(false);
+			setShowToggle2(false);
+		} else if (!inSearch && selectedNode) {
+			setHeaderTitle(selectedNode?.isGroupNode ? selectedNode.properties?.label : selectedNode.properties?.headerTitle);
+			if (!selectedNode.properties?.defaultNodeHeaderExpanded || selectedNode.properties?.defaultNodeHeaderExpanded === "hidden") {
+				setShowToggle1(false);
+				setPrimaryExpanded(false);
+			} else {
+				setShowToggle1(true);
+				setPrimaryExpanded(selectedNode.properties?.defaultNodeHeaderExpanded ? selectedNode.properties?.defaultNodeHeaderExpanded === "expanded" : false);
+			}
+			if (!selectedNode.properties?.defaultPageHeaderExpanded || selectedNode.properties?.defaultPageHeaderExpanded === "hidden") {
+				setShowToggle2(false);
+				setSecondaryExpanded(false);
+			} else {
+				setShowToggle2(true);
+				setSecondaryExpanded(selectedNode.properties?.defaultPageHeaderExpanded ? selectedNode.properties?.defaultPageHeaderExpanded === "expanded" : true);
+			}
+		}
+	}, [inSearch, selectedNode]);
+	useEffect(() => {
+		if (!nodeLoaded) {
+			setHeaderTitle("");
+			setShowToggle1(false);
+			setShowToggle2(false);
+			setPrimaryExpanded(false);
+			setSecondaryExpanded(false);
+		}
+	}, [nodeLoaded]);
+	useEffect(() => {
+		if (!sidebarExpanded) setSidebarTabValue(0);
+	}, [sidebarExpanded]);
+	useEffect(() => {
+		if (setPageId) if (selectedNode) if (selectedNode?.properties?.tabs?.length > 1) setPageId(selectedPageId || null);
+		else {
+			const pageTabs = selectedNode?.properties?.tabs;
+			if (pageTabs?.[0]) setPageId(pageTabs[0].page?.pageId || null);
+			else setPageId(null);
+		}
+		else setPageId(null);
+	}, [
+		setPageId,
+		selectedNode,
+		selectedPageId
+	]);
+	useEffect(() => {
+		if (initialSearchValue) {
+			setIsAdvancedSearch(false);
+			setInSearch(true);
+			setSearchValue(initialSearchValue);
+		}
+	}, [initialSearchValue]);
+	useEffect(() => {
+		setTabValue(0);
+	}, [selectedNode]);
+	useEffect(() => {
+		if (inSearch) setShowInquiryHeaderActions(false);
+		else setShowInquiryHeaderActions(true);
+	}, [inSearch, setShowInquiryHeaderActions]);
+	useEffect(() => {
+		setInquiryParams({
+			selectedNode,
+			selectedNodeParent: selectedNode?.parentNode,
+			refreshTree: handleMenuTreesRefresh
+		}, containerId);
+	}, [
+		selectedNode,
+		handleMenuTreesRefresh,
+		setInquiryParams,
+		containerId
+	]);
+	useEffect(() => {
+		setMenuListState({
+			menuList,
+			handleRemoveMenuItem,
+			selectedMenuIndex
+		});
+	}, [
+		setMenuListState,
+		menuList,
+		handleRemoveMenuItem,
+		selectedMenuIndex
+	]);
+	useEffect(() => {
+		if (tree) {
+			const getPreloadedTree = async () => {
+				setMenuLoading(true);
+				setNodesRequested([1]);
+				const response = await executeQueryInstance({ data: {} }, tree.apiMethodInstance?.apiMethodInstanceId);
+				if (response.status === 200) {
+					if (response?.data?.pageList?.length) {
+						const preloadedList = constructPreloadedTree(makeTreeStructure(cloneDeep(tree.treeStructure), "id", "parentId"), response.data.pageList, catalogObjects);
+						setMenuList(preloadedList || []);
+						if (preloadedList?.length) {
+							setSelectedNode(preloadedList[0]);
+							setSelectedTree(preloadedList[0]);
+							setSelectedMenuIndex(0);
+						}
+						setAppNavigationExpanded(false);
+					}
+				}
+				setMenuLoading(false);
+				setNodesRequested([]);
+			};
+			if (tree) {
+				const topNode = tree?.treeStructure?.find((node) => !node.parentId);
+				setInquiryTitleHeader(topNode?.properties?.inquiryTitle || "");
+			}
+			setIsPreloaded(tree.isPreloaded);
+			if (tree.isPreloaded) {
+				setNodeLoaded(true);
+				getPreloadedTree();
+			}
+		}
+	}, [
+		tree,
+		setAppNavigationExpanded,
+		catalogObjects
+	]);
+	useEffect(() => {
+		setSelectedNodeForStore(selectedNode || null);
+	}, [selectedNode, setSelectedNodeForStore]);
+	useEffect(() => {
+		if (workflowPlay) setWorkflow(workflowPlay);
+	}, [workflowPlay]);
+	useEffect(() => {
+		if (workflow) setSelectedWorkflowNode((prevNode) => {
+			if (!!prevNode) {
+				const foundNode = workflow.workflowPlayNode?.children?.find((child) => child.id === prevNode.id);
+				if (!!foundNode) {
+					const updatedNode = { ...prevNode };
+					updatedNode.properties.state = foundNode.state;
+					return updatedNode;
+				} else return prevNode;
+			}
+		});
+	}, [workflow]);
+	useEffect(() => {
+		if (workflow) {
+			if (!workflowInitialized) {
+				let initialized = false;
+				if (workflow.workflowPlayNode?.children?.length) {
+					if (workflow.workflowPlayNode.children[0].state !== UnitStateType.Initial) {
+						initialized = true;
+						setWorkflowInitialized(true);
+					}
+				}
+				if (!initialized && getWorkflowInitializedCount < WORKFLOW_MAX_NETWORK_CALLS && inquiryWorkflow?.currentWorkflowPlayId) {
+					const timer = setTimeout(async () => {
+						await reloadWorkflow();
+						setGetWorkflowInitializedCount((prevCount) => prevCount + 1);
+					}, 1e3);
+					return () => clearTimeout(timer);
+				}
+				if (getWorkflowInitializedCount === WORKFLOW_MAX_NETWORK_CALLS) enqueueSnackbar(t(`Unable to initialize workflow`), {
+					variant: "error",
+					anchorOrigin: {
+						vertical: "top",
+						horizontal: "center"
+					}
+				});
+			}
+			if (workflowInitialized) {
+				const list = [];
+				const updatedMenu = transformWorkflowPlayTree(workflow.workflowPlayNode);
+				if (updatedMenu) list.push(updatedMenu);
+				setWorkflowMenuItemsList(list);
+			}
+		}
+	}, [
+		workflow,
+		workflowInitialized,
+		reloadWorkflow,
+		getWorkflowInitializedCount,
+		inquiryWorkflow,
+		enqueueSnackbar,
+		t
+	]);
+	useEffect(() => {
+		if (inquiryWorkflow?.inWorkflowMode && inquiryWorkflowTabValue === 1) setHideActions(true);
+		else if (inquiryWorkflow?.inWorkflowMode && inquiryWorkflowTabValue === 0) setHideActions(false);
+	}, [
+		setHideActions,
+		inquiryWorkflowTabValue,
+		inquiryWorkflow
+	]);
+	useEffect(() => {
+		if (!selectedWorkflowNode) {
+			const menu = workflowMenuItemsList[0];
+			if (menu) {
+				const firstSelectableMenuItem = menu?.children?.find((item) => item.isSelectable);
+				setSelectedWorkflowNode(firstSelectableMenuItem || null);
+				if (autoCollapseNav) setNavigationExpanded(false);
+			}
+		}
+	}, [
+		workflowMenuItemsList,
+		selectedWorkflowNode,
+		setNavigationExpanded,
+		autoCollapseNav
+	]);
+	useEffect(() => {
+		if (!!workflowPlayError && getWorkflowPlayErrorCount < WORKFLOW_MAX_NETWORK_CALLS && inquiryWorkflow?.currentWorkflowPlayId) {
+			const timer = setTimeout(() => {
+				reloadWorkflow();
+				setGetWorkflowPlayErrorCount((prevCount) => prevCount + 1);
+			}, 1e3);
+			return () => clearTimeout(timer);
+		}
+		if (getWorkflowPlayErrorCount === WORKFLOW_MAX_NETWORK_CALLS) enqueueSnackbar(t(`Unable to load workflow`), {
+			variant: "error",
+			anchorOrigin: {
+				vertical: "top",
+				horizontal: "center"
+			}
+		});
+	}, [
+		workflowPlayError,
+		reloadWorkflow,
+		getWorkflowPlayErrorCount,
+		enqueueSnackbar,
+		t,
+		inquiryWorkflow
+	]);
+	useEffect(() => {
+		setLocationState({ label: t(inquiryTitle) || t("Inquiry") });
+	}, [
+		setLocationState,
+		t,
+		inquiryTitle
+	]);
+	return /* @__PURE__ */ React.createElement(DndProvider, { backend: HTML5Backend }, /* @__PURE__ */ React.createElement(LoadingOverlay_default, { open: workflowStarting }), /* @__PURE__ */ React.createElement("div", {
+		key: treeId,
+		className: classes.root
+	}, !inquiryMenuHidden && /* @__PURE__ */ React.createElement(UtilitySideBar, {
+		title: t(inquiryTitle) || t("Inquiry"),
+		isUsingChildren: true,
+		resizable: true,
+		removePadding: true,
+		removeTopLayoutUnit: true,
+		onUtilitySidebarToggleExpandClick: handleSidebarExpandClick,
+		collapsedWidth: 78,
+		handleResize: (width) => setUtilitySideBarWidth(width),
+		hideTitleBar: inquiryWorkflow?.inWorkflowMode
+	}, moveToTopLoading && /* @__PURE__ */ React.createElement(LinearProgress, null), sidebarTabValue === 0 && /* @__PURE__ */ React.createElement(React.Fragment, null, inquiryWorkflow?.inWorkflowMode && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(UdpTabs, {
+		value: inquiryWorkflowTabValue,
+		onChange: handleInquiryWorkflowTabChange,
+		tabList: [{ label: t("Inquiry") }, { label: t("Workflow") }],
+		buttonWidth: "100%"
+	}), /* @__PURE__ */ React.createElement(Divider, null)), (!inquiryWorkflow?.inWorkflowMode || inquiryWorkflow?.inWorkflowMode && inquiryWorkflowTabValue === 0) && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(InquiryNodeControls, {
+		remove: () => handleRemoveMenuItem(null),
+		moveToTop: handleMoveToTop,
+		expandAll: handleExpandAll,
+		collapseAll: handleCollapseAll,
+		clearAll: clearNodes,
+		switchTreeViewMode: onTreeViewModeChange,
+		treeViewMode,
+		changeSideBarView: handleSideBarValueChange,
+		handleKeyDown: handleSearch,
+		disableMoveToTop,
+		entityList,
+		entityValue,
+		setEntityValue,
+		hiddenControls: sidebarExpanded ? isPreloaded ? ["remove", "clearAll"] : [] : isPreloaded ? [
+			"remove",
+			"expandAll",
+			"clearAll",
+			"collapseAll"
+		] : [
+			"remove",
+			"expandAll",
+			"clearAll",
+			"collapseAll"
+		],
+		showControls: !treeLoading && !treeError && nodeLoaded,
+		showSearch: !treeLoading && !treeError,
+		defaultValue: initialSearchValue,
+		clearSearchStr,
+		setClearSearchStr,
+		isPreloadedTree: isPreloaded,
+		treeLoading
+	}, !treeLoading && treeError && /* @__PURE__ */ React.createElement("div", { style: {
+		marginLeft: 4,
+		marginBottom: 12
+	} }, /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "nudge" }), /* @__PURE__ */ React.createElement(Typography, null, "Error getting tree data from tree id"))), /* @__PURE__ */ React.createElement(NodeList, {
+		menuItemsList: menuList,
+		onSelectNode: handleSelectedNode,
+		onDropNode: handleDroppedNode,
+		selectedNodeId: selectedNode?.id ?? "",
+		selectedNodeParentId: selectedNode?.parentId ?? "",
+		expandAllClicked,
+		classes: { root: !treeLoading ? nodeLoaded ? classes.nodeListRootLoaded : classes.nodeListRoot : classes.nodeListRootLoading },
+		menuLoading,
+		nodesRequested,
+		sidebarExpanded,
+		executeQueryAdHoc,
+		catalogObjects,
+		promotedEntities,
+		treeStructureArr: tree?.treeStructure || [],
+		setMenuList,
+		treeViewMode: treeViewMode || TreeViewModeEnums.Classic
+	}))), sidebarTabValue === 1 && /* @__PURE__ */ React.createElement(InquiryAdvancedSearch, {
+		entityList,
+		entityValue: advancedSearchEntityValue,
+		setEntityValue: setAdvancedSearchEntityValue,
+		onSubmit: handleAdvancedSearchClick,
+		currentNodeCatalogReturnObject: selectedNode?.properties?.catalogReturnObject,
+		changeSideBarView: handleSideBarValueChange,
+		catalogObjects,
+		tree,
+		executeQueryWithParameters
+	}), inquiryWorkflow?.inWorkflowMode && inquiryWorkflowTabValue === 1 && /* @__PURE__ */ React.createElement("div", {
+		className: classes.workflowMenuContent,
+		key: inquiryWorkflow?.currentWorkflowPlayId
+	}, workflowMenuItemsList?.length > 0 && (!workflowPlayLoading || reloadWorkflowFromPage) && workflowMenuItemsList.map((workflowMenuItems, index) => /* @__PURE__ */ React.createElement("div", {
+		key: workflowMenuItems.id,
+		className: classes.nodeContainer
+	}, /* @__PURE__ */ React.createElement(WorkflowTreeMenu, {
+		menuItems: workflowMenuItems,
+		onSelectNode: handleSelectedWorkflowNode,
+		menuIndex: index,
+		selectedNodeId: selectedWorkflowNode?.id,
+		selectedNodeParentId: selectedWorkflowNode?.parentId,
+		sidebarExpanded,
+		treeViewMode: TreeViewModeEnums.Classic
+	}))), (workflowPlayLoading || workflowPlayError || !workflowInitialized) && !reloadWorkflowFromPage && /* @__PURE__ */ React.createElement("div", { className: classes.workflowTreeLoader }, /* @__PURE__ */ React.createElement(NodeLoader, { loading: workflowPlayLoading || workflowPlayError || !workflowInitialized })))), /* @__PURE__ */ React.createElement(OpenPage, {
+		disableGutters: true,
+		style: {
+			position: "relative",
+			top: 0,
+			width: `calc(100% - ${utilitySideBarWidth}px)`
+		}
+	}, /* @__PURE__ */ React.createElement(Form$1, {
+		onSubmit: executeApiForDroppedNode,
+		key: promotedMethodsToExecute
+	}, /* @__PURE__ */ React.createElement(ExecuteApiDialog, {
+		open: executeApiDialogOpen,
+		handleCloseDialog: handleCloseExecuteApiDialog,
+		apiMethods: promotedMethodsToExecute,
+		progress: executeApiProgress
+	})), /* @__PURE__ */ React.createElement("div", { className: classes.content }, (!inquiryWorkflow?.inWorkflowMode || inquiryWorkflow?.inWorkflowMode && inquiryWorkflowTabValue === 0) && /* @__PURE__ */ React.createElement(InquiryWrapper, {
+		nodeLoaded: false,
+		collapsedWidth: 32
+	}, (inSearch || nodeLoaded) && /* @__PURE__ */ React.createElement(Card, { square: true }, /* @__PURE__ */ React.createElement(PrimaryActionHeader, {
+		key: `${selectedNode?.id}-${inSearch}`,
+		title: headerTitle,
+		buttonLabel: "Load",
+		single: true,
+		secondaryButtons,
+		handleClick: handlePrimaryAction,
+		hidePAB: nodeLoaded && !inSearch,
+		allowAdditionalTitleComponent: true,
+		additionalComponentId: containerId
+	})), !!selectedNode && /* @__PURE__ */ React.createElement(Card, {
+		square: true,
+		className: classes.nodeHeader
+	}, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(Collapse, {
+		in: primaryExpanded,
+		timeout: "auto"
+	}, nodeHeaderPageIdToLoad && showToggle1 ? /* @__PURE__ */ React.createElement(PageContainer, {
+		user,
+		key: nodeHeaderPageIdToLoad,
+		pageData: nodeHeaderPageData,
+		pageLoading: nodeHeaderPageLoading,
+		widgetParams: {
+			nodeObj: selectedNode?.nodeObj,
+			nodeId: selectedNode?.id,
+			selectedNode,
+			setRefreshNodeHeaderPageData,
+			inquiryContainerId: containerId
+		},
+		disableMargins: true,
+		loadingHeight: 32
+	}) : /* @__PURE__ */ React.createElement(NodeDetails, { node: selectedNode })), showToggle1 && /* @__PURE__ */ React.createElement("div", { className: clsx(primaryExpanded ? classes.chevronButtons : classes.chevronButtonClosed) }, /* @__PURE__ */ React.createElement(FluentIconButton, {
+		onClick: () => setPrimaryExpanded(!primaryExpanded),
+		icon: primaryExpanded ? ChevronUpIcon : ChevronDownIcon
+	}))), /* @__PURE__ */ React.createElement(Divider, null), /* @__PURE__ */ React.createElement(Collapse, {
+		in: secondaryExpanded,
+		timeout: "auto"
+	}, /* @__PURE__ */ React.createElement("div", { className: classes.inquiryHeader }, pageHeaderPageIdToLoad && showToggle2 ? /* @__PURE__ */ React.createElement(PageContainer, {
+		user,
+		key: pageHeaderPageIdToLoad,
+		pageData: pageHeaderPageData,
+		pageLoading: pageHeaderPageLoading,
+		widgetParams: {
+			nodeObj: selectedNode?.nodeObj,
+			nodeId: selectedNode?.id,
+			selectedNode,
+			setRefreshPageHeaderPageData,
+			inquiryContainerId: containerId
+		},
+		disableMargins: true,
+		loadingHeight: 32
+	}) : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(InquiryHeaderSecondaryTarget, { className: classes.actions }), /* @__PURE__ */ React.createElement(InquiryHeaderSecondaryAlertTarget, { className: classes.actions })))), selectedNode?.properties?.tabs?.length > 1 && !inSearch ? /* @__PURE__ */ React.createElement(UdpTabs, {
+		value: tabValue,
+		onChange: handlePageChange,
+		tabList: inquiryTabList
+	}) : null), !!selectedNode && showToggle2 && /* @__PURE__ */ React.createElement(Card, {
+		square: true,
+		className: classes.entityHeader
+	}, /* @__PURE__ */ React.createElement("div", { className: classes.chevronButtons }, /* @__PURE__ */ React.createElement(FluentIconButton, {
+		onClick: () => setSecondaryExpanded(!secondaryExpanded),
+		icon: secondaryExpanded ? ChevronUpIcon : ChevronDownIcon,
+		className: classes.icon
+	}))), !treeError && /* @__PURE__ */ React.createElement(PageActionWrapper, {
+		forPageContainer: true,
+		splitScreenStateKey: "pageContainerSplitScreen"
+	}, /* @__PURE__ */ React.createElement("div", {
+		className: classes.mainWrapper,
+		style: { width: "100%" }
+	}, inSearch ? /* @__PURE__ */ React.createElement(InquirySearchContainer, {
+		searchItems: entitySearchItems,
+		isAdvancedSearch,
+		advancedSearchItems,
+		setSelectedSearchRows: handleSelectedSearchRows,
+		catalogObjects,
+		loadSingleNode: handleSingleNodeLoad,
+		onRowDoubleClick: handleRowDoubleClick,
+		classes: { root: classes.searchContainerRoot },
+		executeQueryAdHoc,
+		apiMethodInstanceId: tree?.apiMethodInstance?.apiMethodInstanceId
+	}) : !tree || !catalogObjects ? /* @__PURE__ */ React.createElement(LinearProgress, null) : !nodeLoaded && !tree?.isPreloaded ? tree?.explorePageId ? /* @__PURE__ */ React.createElement(PageContainer, {
+		user,
+		key: selectedNode?.properties?.searchValue,
+		pageData: explorePageData,
+		pageLoading: explorePageLoading,
+		widgetParams: {
+			tree,
+			recentlyLoadedNodes: litnHistory,
+			loading: litnHistoryLoading,
+			onLoadedNodeClick: handleRecentlyLoadedNodeClick,
+			tableHeight: "calc(100vh - 172px)",
+			catalogObjects
+		},
+		disableMargins: true
+	}) : /* @__PURE__ */ React.createElement(InquiryDashboard, {
+		treeId,
+		recentlyLoadedNodeOnClick: handleRecentlyLoadedNodeClick
+	}, /* @__PURE__ */ React.createElement(RecentlyLoadedNodesTable, {
+		recentlyLoadedNodes: litnHistory,
+		loading: litnHistoryLoading,
+		onLoadedNodeClick: handleRecentlyLoadedNodeClick,
+		tableHeight: "calc(100vh - 172px)",
+		tree
+	})) : selectedNode?.properties?.tabs?.length > 0 && (selectedNode?.properties?.tabs?.length > 1 ? pageId && pageContainer : pageId ? pageContainer : null))), shellContext?.secondExtendedWindow && /* @__PURE__ */ React.createElement(InquiryHeaderSecondary, { secondExtended: true }, /* @__PURE__ */ React.createElement("div", { className: classes.information }, /* @__PURE__ */ React.createElement("div", { className: classes.summaryCard })))), inquiryWorkflow?.inWorkflowMode && inquiryWorkflowTabValue === 1 && /* @__PURE__ */ React.createElement(WorkflowContent, {
+		selectedNode: selectedWorkflowNode,
+		workflow,
+		reloadWorkflow: handleReloadWorkflow,
+		users,
+		groups,
+		handleClose: handleCloseWorkflow,
+		inquiryPageParams: pageData?.isUdpPage ? udpPageWidgetParams : pageWidgetParams
+	})))));
+};
+InquiryContainer.propTypes = {
+	user: PropTypes.object,
+	shellContext: PropTypes.object,
+	litnHistory: PropTypes.array,
+	litnHistoryLoading: PropTypes.bool,
+	tree: PropTypes.object,
+	treeId: PropTypes.string,
+	catalogObjects: PropTypes.array,
+	executeQueryAdHoc: PropTypes.func,
+	executeQueryWithParameters: PropTypes.func,
+	executeGetDetailedTree: PropTypes.func,
+	executeAddRecentlyLoadedNodes: PropTypes.func,
+	treeLoading: PropTypes.bool,
+	treeError: PropTypes.object,
+	pageData: PropTypes.object,
+	pageLoading: PropTypes.bool,
+	pageError: PropTypes.object,
+	setPageId: PropTypes.func,
+	pageId: PropTypes.string,
+	isValidWidget: PropTypes.func,
+	productId: PropTypes.string,
+	initialSearchValue: PropTypes.string,
+	promotedEntities: PropTypes.array,
+	promotedMethods: PropTypes.array
+};
+
+//#endregion
+//#region src/inquiry/Inquiry.jsx
+const useStyles = makeStyles((theme) => ({ loadingContent: {
+	flex: 1,
+	display: "flex",
+	flexDirection: "column",
+	alignItems: "center",
+	justifyContent: "center",
+	height: (props) => props.loadingHeight ? props.loadingHeight : "calc(100vh - 160px)"
+} }));
+/**
+* Required Props:
+* user - current unity user
+* productId - current product id of application
+* shellContext - context of the shell in the application. Will be used for some global actions (ie. collapse menu bar from within inquiry container)
+* litnHistory (loaded inquiry tree node history) - array of tree node objects to be used in the recently loaded nodes
+* litnHistoryLoading - request status of the litnHistory request
+* tree - tree object which contains the tree structure and its properties
+* treeLoading - request status of tree request
+* treeError - error status of tree request
+* treeId - id of the tree that's being loaded (retreived from URL)
+* catalogObjects - array of catalog items and it's relationship and properties
+* executeQueryAdHoc - search callback
+* executeQueryWithParameters - search callback with extra parameters
+* executeGetDetailedTree - callback to get detailed tree information for the associated tree
+* executeAddRecentlyLoadedNodes - callback to add loaded nodes to history
+* pageData - data for the page to be displayed in inquiry
+* pageLoading - boolean value for if a page is loading
+* pageError - error status of page request
+* setPageId - setter for setting pageId when it changes
+* pageId - id of page
+* initialSearchValue - query parameter representing a value to search upon loading of this inquiry page
+* promotedEntities - promoted entities for the catalog used in the inquiry tree
+* promotedMethods - promoted methods for the catalog used in the inquiry tree
+*
+* @param {*} props
+* @returns Inquiry
+*/
+const Inquiry = (props) => {
+	const { shellContext, treeId, searchValue, autoCollapseNav = true, useNewUdpTab = true, containerId = "" } = props;
+	const classes = useStyles(props);
+	const user = useAuthedUser();
+	const { location } = props;
+	const udpTreeId = treeId || location?.pathname?.replace("/inquiry/", "");
+	let searchParamStr = location?.search;
+	let searchParams = new URLSearchParams(searchParamStr);
+	const initialSearchValue = searchValue || (searchParams.has("searchValue") === true ? searchParams.get("searchValue") : "");
+	const [pageId, setPageId] = useState(null);
+	const { setCatalogEntities, setCatalogPromotedEntities, setActionPanels, setInquiryParams } = useActions();
+	const currentApiCatalogId = useCatalogStore((state) => state.currentApiCatalogId);
+	const catalogsMap = useCatalogStore((state) => state.catalogsMap);
+	const promotedMethodEntitiesMap = useCatalogStore((state) => state.promotedMethodEntitiesMap);
+	const setCurrentContainerId = useShellStore((state) => state.setCurrentContainerId);
+	const [{ data: litnHistory, loading: litnHistoryLoading }, refetchLitnHistory] = useAxiosGet(ConfigService.integrationV1ApiUrl, `inquirytree/loadedInquiryTreeNodes?inquiryTreeId=${udpTreeId}&userId=${user.id}&productId=${ConfigService.config.UNITY_PRODUCT_ID}`, {}, !!!udpTreeId, false);
+	const [{ data: tree, loading: treeLoading, error: treeError }] = useAxiosGet(ConfigService.integrationV1ApiUrl, `inquirytree/${udpTreeId}/detailed`, {}, !!!udpTreeId, false);
+	const executeQueryAdHoc = useCallback(async (data, apiMethodId) => apiMutate(ConfigService.integrationV1ApiUrl, `apimethod/executeQueryAdHoc/${apiMethodId}`, { method: "post" }, data), []);
+	const executeQueryWithParameters = useCallback(async (data, apiMethodId) => apiMutate(ConfigService.integrationV1ApiUrl, `apimethod/executeQueryWithParameters/${apiMethodId}`, { method: "post" }, data), []);
+	const executeGetDetailedTree = useCallback(async (treeId$1) => apiMutate(ConfigService.integrationV1ApiUrl, `inquirytree/${treeId$1}/detailed`, { method: "get" }), []);
+	const executeAddRecentlyLoadedNodes = useCallback(async (data) => {
+		await apiMutate(ConfigService.integrationV1ApiUrl, `inquirytree/${udpTreeId}/loadedInquiryTreeNodes/user/${user.id}/product/${ConfigService.config.UNITY_PRODUCT_ID}`, { method: "post" }, data);
+		refetchLitnHistory();
+	}, [
+		user,
+		udpTreeId,
+		refetchLitnHistory
+	]);
+	const [{ data: page, loading: pageLoading, error: pageError }] = useAxiosGet(ConfigService.tenantV1ApiUrl, `page/${pageId}`, {}, !!!pageId, false);
+	const catalogObjects = useMemo(() => {
+		if (!currentApiCatalogId || !catalogsMap || !tree) return null;
+		const catalogObjectList = catalogsMap[currentApiCatalogId]?.ctlg?.catalogObjectList;
+		if (!catalogObjectList) return null;
+		let matchingObject = null;
+		let filteredCatalogObjects = [];
+		if (catalogObjectList) {
+			matchingObject = catalogObjectList.find((obj) => obj.catalogObjectName === tree.apiMethodInstance?.returnObject);
+			if (!!matchingObject) {
+				const children = matchingObject.properties.filter((property) => !!property.extendedProperties.childEntity);
+				filteredCatalogObjects.push(matchingObject);
+				buildCatalogObjectList(filteredCatalogObjects, children, catalogObjectList);
+			}
+		}
+		return filteredCatalogObjects;
+	}, [
+		catalogsMap,
+		currentApiCatalogId,
+		tree
+	]);
+	const promotedMethods = useMemo(() => {
+		if (!currentApiCatalogId || !catalogsMap) return null;
+		return catalogsMap[currentApiCatalogId]?.promotedMethods;
+	}, [catalogsMap, currentApiCatalogId]);
+	const promotedEntities = useMemo(() => {
+		if (!currentApiCatalogId || !promotedMethodEntitiesMap) return null;
+		return promotedMethodEntitiesMap[currentApiCatalogId] || [];
+	}, [promotedMethodEntitiesMap, currentApiCatalogId]);
+	useEffect(() => {
+		if (catalogObjects) setCatalogEntities(catalogObjects);
+	}, [setCatalogEntities, catalogObjects]);
+	useEffect(() => {
+		if (promotedEntities) setCatalogPromotedEntities(promotedEntities);
+	}, [setCatalogPromotedEntities, promotedEntities]);
+	useEffect(() => {
+		if (containerId) setCurrentContainerId(containerId);
+		return () => {
+			if (containerId) {
+				setCurrentContainerId(null);
+				setActionPanels(null, containerId);
+				setInquiryParams(null, containerId);
+			}
+		};
+	}, [
+		setActionPanels,
+		setCurrentContainerId,
+		containerId,
+		setInquiryParams
+	]);
+	if (treeLoading && !treeError) return /* @__PURE__ */ React.createElement("div", { className: classes.loadingContent }, /* @__PURE__ */ React.createElement(CircularProgress, { size: 64 }));
+	return /* @__PURE__ */ React.createElement(InquiryContainer, {
+		user,
+		productId: ConfigService.config.UNITY_PRODUCT_ID,
+		shellContext,
+		litnHistory,
+		litnHistoryLoading,
+		tree,
+		treeLoading,
+		treeError,
+		treeId: udpTreeId,
+		catalogObjects,
+		executeQueryAdHoc,
+		executeQueryWithParameters,
+		executeGetDetailedTree,
+		executeAddRecentlyLoadedNodes,
+		pageData: page,
+		pageLoading,
+		pageError,
+		setPageId,
+		pageId,
+		initialSearchValue,
+		promotedEntities,
+		promotedMethods,
+		autoCollapseNav,
+		useNewUdpTab,
+		containerId
+	});
+};
+
+//#endregion
+export { InquiryTreeMenuItem as a, ExecuteApiDialog as c, InquiryTreeMenu as i, InquiryContainer as n, NodeDetails as o, NodeList as r, InquiryWrapper as s, Inquiry as t };
+//# sourceMappingURL=Inquiry-CeZgX9ls.js.map