udp-react-enterprise-component-library 1.0.5 → 25.1.0-beta.2

package/dist/UtilitySideBar-B4r2IAv5.js

@@ -0,0 +1,2020 @@
+import { APP_RIBBON_SPACE, CardinalityTypeEnums, FluentButton, FluentIconButton, LayoutUnit, NodeGroupOutlierEnums, NodeGroupTypeEnums, SeverityTypeEnums, StatusChip, executeQueryInstance, getEllipseColor, toLowerFirstChar, toUpperFirstChar, useAxiosGet, useBuildEnvironment } from "./EnvironmentRibbon-BMvQEZPZ.js";
+import { getSearchIdentifiers, getSearchObject } from "./SearchUtilities-dbXvMYoa.js";
+import React, { memo, useCallback, useEffect, useMemo, useState } from "react";
+import { Button, ButtonBase, CardContent, CardMedia, CircularProgress, Collapse, Paper, Typography, lighten, makeStyles, useTheme } from "@material-ui/core";
+import { ConfigService } from "udp-react-stencil-component-library";
+import clsx from "clsx";
+import * as Icons from "@fluentui/react-icons";
+import { ArrowUpRightIcon, ChevronDownIcon, ChevronRightIcon, ChevronUpIcon, DeleteIcon, EditIcon } from "@fluentui/react-icons";
+import PropTypes from "prop-types";
+import { cloneDeep, orderBy } from "lodash";
+import { useTranslation } from "react-i18next";
+import jsonLogic from "json-logic-js";
+import { v4 } from "uuid";
+import Sewer from "./assets/unityIcons/Sewer.svg";
+import WaterDrop from "./assets/unityIcons/WaterDrop.svg";
+import { createTeleporter } from "react-teleporter";
+import { Alert } from "@material-ui/lab";
+import Skeleton$1 from "@material-ui/lab/Skeleton";
+import { ResizableBox } from "react-resizable";
+
+//#region src/utilities/rules/RuleUtilities.js
+/**
+* Constructs an array of object from the object map.
+*
+* @param {Object} obj ex: {"a": "customerID", "b": "firstName"}
+* @returns an array of object ex. [{"variable": "a", "value": "serviceLocationID"}, {"variable": "b", "value" "firstName"}]
+*/
+const getPropertyMappingList = (obj) => {
+	const mappings = [];
+	if (obj) {
+		const keys = Object.keys(obj);
+		keys.forEach((key) => {
+			const mappingObj = {
+				variable: key,
+				value: obj[key]
+			};
+			mappings.push(mappingObj);
+		});
+	}
+	return mappings;
+};
+/**
+* Constructs a map object where variables are keys and values are the values.
+*
+* @param {Array<Object>} properties ex. [{"variable": "a", "value": "serviceLocationID"}, {"variable": "b", "value" "firstName"}]
+* @returns mapped object ex: {"a": "customerID", "b": "firstName"}
+*/
+const getPropertyMappingObj = (properties) => {
+	const mapping = {};
+	if (properties?.length) properties.forEach((property) => {
+		mapping[property.variable] = property.value;
+	});
+	return mapping;
+};
+/**
+* Maps the keys of mapping to the values of data.
+*
+* @param {Object} mapping ex: {"a": "customerID", "b": "firstName"}
+* @param {Object} data ex: {"customerID": 1001, "firstName": "John"}
+* @returns flat object ex: {"a": 1001, "b": "John"}
+*/
+const mapRuleData = (mapping, data) => {
+	const mappedData = {};
+	if (mapping && mapping.length) {
+		const keys = Object.keys(mapping);
+		keys.forEach((key) => {
+			const dataKey = mapping[key];
+			if (dataKey) {
+				const dataValue = data[dataKey];
+				mappedData[key] = dataValue;
+			}
+		});
+	}
+	return mappedData;
+};
+/**
+* Maps the mapping values in the mapping object to the variables in the rule.
+*
+* @param {Object} mapping ex: {"a": "customerID", "b": "firstName"}
+* @param {Object} rule ex: {"or": [{"==": [{"var": "a"}, 400]}, {"==": [{"var": "b"}, John]}]}
+* @returns jsonLogic object with the correct variable names ex: [{"==": [{"var": "customerID"}, 400]}, {"==": [{"var": "firstName"}, John]}]
+*/
+const mapRule = (mapping = {}, rule = "") => {
+	const keys = Object.keys(mapping);
+	let updatedJsonLogic = JSON.stringify(rule);
+	keys.forEach((key) => {
+		const substr = JSON.stringify({ var: key });
+		const newSubstr = JSON.stringify({ var: mapping[key] });
+		updatedJsonLogic = updatedJsonLogic.replaceAll(substr, newSubstr);
+	});
+	try {
+		return JSON.parse(updatedJsonLogic);
+	} catch (err) {
+		console.err("Error with parsing JSON Logic String");
+		return {};
+	}
+};
+/**
+* Evaluates the rule with provided data.
+*
+* @param {Object} rule ex: {"or": [{"==": [{"var": "customerID"}, 400]}, {"==": [{"var": "firstName"}, John]}]}
+* @param {Object} data ex: {"customerID": 1001, "firstName": "John"}
+* @param {string} objectKey ex: "users"
+* @param {boolean} dataLazyLoaded ex: "true"
+* @returns the evaluated rule ex: true
+*/
+const evaluateRule = (rule, data, objectKey, dataLazyLoaded) => {
+	let formattedData = {};
+	if (objectKey && dataLazyLoaded) formattedData[objectKey] = data[objectKey] ? data[objectKey] : data;
+	else formattedData = data;
+	return jsonLogic.apply(rule, formattedData);
+};
+
+//#endregion
+//#region src/models/GroupNode.ts
+var GroupNode = class {
+	constructor(node) {
+		this.id = node.id || v4();
+		this.isGroupNode = true;
+		this.hideEmptyGroups = node.hideEmptyGroups || false;
+		this.groupType = node.groupType || NodeGroupTypeEnums.Static;
+		this.children = node.children || [];
+		this.isExpanded = node.isExpanded || false;
+		this.parentId = node.parentId || null;
+		this.parentGroupId = node.parentGroupId || null;
+		this.properties = node.properties ? {
+			propertyMapping: null,
+			jsonLogic: null,
+			icon: {
+				name: "GroupedListIcon",
+				type: "",
+				color: ""
+			},
+			...node.properties
+		} : {
+			propertyMapping: null,
+			jsonLogic: null,
+			icon: {
+				name: "GroupedListIcon",
+				type: "",
+				color: ""
+			}
+		};
+		this.isOutlierGroup = node.isOutlierGroup || false;
+	}
+};
+
+//#endregion
+//#region src/utilities/tree/TreeUtilities.js
+const makeTreeStructure = (treeData, key, parentKey, parentGroupKey = "parentGroupId") => {
+	if (!treeData) return [];
+	const keys = [];
+	treeData.forEach((node) => {
+		node.children = [];
+		if (node["isExpanded"] === void 0 && !node.isGroupNode) if (node.properties.defaultDisplay === "collapsed" || node.properties.lazyLoad) node.isExpanded = false;
+		else node.isExpanded = true;
+		keys.push(node[key]);
+	});
+	const roots = treeData.filter((node) => {
+		return !(node?.isGroupNode ? node[parentGroupKey] : node[parentKey]);
+	});
+	const nodes = [];
+	const existingGroups = [];
+	roots.forEach((root) => {
+		nodes.push(root);
+	});
+	while (nodes.length > 0) {
+		const node = nodes.pop();
+		let children = treeData.filter((data) => data[parentKey] === node[key] || data[parentGroupKey] === node[key]);
+		children.forEach((child) => {
+			if (child?.isGroupNode) {
+				const existingGroup = existingGroups.find((eg) => eg.id === child.id && eg.parentGroupId === child.parentGroupId);
+				if (!existingGroup) {
+					existingGroups.push(child);
+					node.children.push(child);
+					nodes.push(child);
+				}
+			} else if (node.isGroupNode && child.parentGroupId || !node.isGroupNode && !child.parentGroupId) {
+				node.children.push(child);
+				nodes.push(child);
+			}
+		});
+	}
+	const removeEmptyGroupNodes = (node) => {
+		if (node?.isGroupNode && node?.hideEmptyGroups && !node?.children?.length) return null;
+		node.children = node.children.map(removeEmptyGroupNodes).filter((child) => child !== null);
+		return node;
+	};
+	const filteredRoots = roots.map(removeEmptyGroupNodes).filter((root) => root !== null);
+	if (filteredRoots.length === 1) return filteredRoots[0];
+	return filteredRoots;
+};
+const makeTreeStaticGroupStructure = (treeData, key, parentKey, groupType = NodeGroupTypeEnums.Static, hideEmptyGroups) => {
+	if (!treeData) return [];
+	const keys = [];
+	treeData.forEach((node, index) => {
+		const { id, hideEmptyGroups: hideEmptyGroups$1, children, apiMethodInstanceId, parentGroupId, order, isExpanded,...groupProperties } = node;
+		treeData[index] = new GroupNode({
+			id,
+			groupType,
+			children,
+			parentId: parentGroupId,
+			parentGroupId,
+			isExpanded,
+			properties: { ...groupProperties }
+		});
+		keys.push(node[key]);
+	});
+	const roots = treeData.filter((node) => keys.indexOf(node[parentKey]) === -1);
+	const nodes = [];
+	roots.forEach((root) => {
+		nodes.push(root);
+	});
+	while (nodes.length > 0) {
+		const node = nodes.pop();
+		let children = treeData.filter((data) => data[parentKey] === node[key]);
+		children.forEach((child) => {
+			node.children.push(child);
+			nodes.push(child);
+		});
+	}
+	if (roots.length === 1) return roots[0];
+	return roots;
+};
+const makeDynamicGroupStructures = (treeStructure, results) => {
+	if (!treeStructure) return [];
+	const groupStructures = [];
+	results.forEach((item) => {
+		processDynamicGroupForCurrentNodeLevel(item, treeStructure, groupStructures, groupStructures);
+	});
+	return groupStructures;
+};
+const processDynamicGroupForCurrentNodeLevel = (item, node, groupStructures, previousFilteredGroups = []) => {
+	const { property, id } = node;
+	const label = property ? getLabelFromProperty(item, property) : null;
+	let filteredGroups = [];
+	previousFilteredGroups.forEach((group) => {
+		if (group) {
+			const foundGroups = findNodesByIdAndLabel(group, id, label);
+			if (foundGroups.length) filteredGroups = filteredGroups.concat(foundGroups);
+		}
+	});
+	if (filteredGroups.length) {
+		if (node?.children?.length) node.children.forEach((child) => processDynamicGroupForCurrentNodeLevel(item, child, groupStructures, filteredGroups));
+	} else if (label) {
+		const dynamicGroupTree = makeDynamicGroupTree(node, item);
+		if (node.parentGroupId) previousFilteredGroups.forEach((filteredGroup) => {
+			const matchingGroupNode = findNodeById(filteredGroup, node.parentGroupId);
+			if (matchingGroupNode) {
+				dynamicGroupTree.parentGroupId = matchingGroupNode.id;
+				matchingGroupNode.children.push(dynamicGroupTree);
+			}
+		});
+		else groupStructures.push(dynamicGroupTree);
+	}
+};
+const makeDynamicGroupTree = (node, item, parentGroupNode) => {
+	const { id, children, apiMethodInstanceId, parentGroupId, order, property, label, isExpanded,...groupProperties } = node;
+	const updatedLabel = property ? getLabelFromProperty(item, property) : null;
+	if (updatedLabel) {
+		const groupNode = new GroupNode({
+			id: `${id}`,
+			groupType: NodeGroupTypeEnums.Dynamic,
+			children: [],
+			parentGroupId: parentGroupNode?.id || null,
+			isExpanded,
+			properties: {
+				label: updatedLabel,
+				...groupProperties,
+				propertyKey: property
+			}
+		});
+		if (parentGroupNode) parentGroupNode.children.push(groupNode);
+		if (children?.length) children.forEach((child) => makeDynamicGroupTree(child, item, groupNode));
+		return groupNode;
+	}
+};
+const makeDynamicTreeStructure = (treeData, key, parentKey) => {
+	if (!treeData) return [];
+	const keys = [];
+	treeData.forEach((node, index) => {
+		keys.push(node[key]);
+	});
+	const roots = treeData.filter((node) => keys.indexOf(node[parentKey]) === -1);
+	const nodes = [];
+	roots.forEach((root) => {
+		nodes.push(root);
+	});
+	while (nodes.length > 0) {
+		const node = nodes.pop();
+		let children = treeData.filter((data) => data[parentKey] === node[key]);
+		children.forEach((child) => {
+			node.children.push(child);
+			nodes.push(child);
+		});
+	}
+	if (roots.length === 1) return roots[0];
+	return roots;
+};
+const getIconFromName = (name) => {
+	if (!name) return null;
+	const substr = name.slice(-4);
+	if (substr.toLowerCase() !== "icon") {
+		const updatedName = `${name}Icon`;
+		return Icons[updatedName] || null;
+	} else return Icons[name] || null;
+};
+const findLastNode = (tree) => {
+	let result = null;
+	if (!tree?.children?.length) return tree;
+	else {
+		if (tree?.children) tree.children.forEach((node) => result = findLastNode(node));
+		return result;
+	}
+};
+const searchTree = (tree, id) => {
+	let result = null;
+	if (tree.id === id) return tree;
+	else {
+		if (tree.children) tree.children.some((node) => result = searchTree(node, id));
+		return result;
+	}
+};
+const deleteNode = (treeData, nodeId) => {
+	const updatedTreeData = [...treeData];
+	const foundNode = updatedTreeData.find((node) => node.id === nodeId);
+	const nodeIndex = updatedTreeData.findIndex((node) => node.id === nodeId);
+	if (!foundNode.parentId || !updatedTreeData.some((node) => node.parentId === nodeId)) {
+		if (nodeIndex > -1) updatedTreeData.splice(nodeIndex, 1);
+		const immediateChild = updatedTreeData.find((node) => node.parentId === nodeId);
+		if (immediateChild) immediateChild.parentId = null;
+	} else {
+		foundNode.isDeleted = true;
+		foundNode.properties = {};
+	}
+	return updatedTreeData;
+};
+const deleteNodeAndChildren = (treeData, nodeId) => {
+	const updatedTreeData = [...treeData];
+	const nodeIdsToDelete = [];
+	nodeIdsToDelete.push(nodeId);
+	getAllChildrenNodesToDelete(updatedTreeData, nodeId, nodeIdsToDelete);
+	return updatedTreeData.filter((node) => !nodeIdsToDelete.includes(node.id));
+};
+const getAllChildrenNodesToDelete = (treeData, nodeId, nodeIdsToDelete) => {
+	const nodesToDelete = treeData.filter((node) => node.parentId === nodeId);
+	nodesToDelete.forEach((node) => {
+		nodeIdsToDelete.push(node.id);
+		getAllChildrenNodesToDelete(treeData, node.id, nodeIdsToDelete);
+	});
+};
+const processCatalogObjectKeysInOrder = (tree, keys) => {
+	if (!tree?.children?.length) keys.push(tree?.properties?.catalogObjectKey);
+	else if (tree?.children) {
+		if (tree?.properties?.catalogObjectKey) keys.push(tree?.properties?.catalogObjectKey);
+		tree.children.forEach((node) => processCatalogObjectKeysInOrder(node, keys));
+	}
+};
+const processOrderedTreeData = (tree, treeData) => {
+	if (!tree?.children?.length) treeData.push(tree);
+	else if (tree?.children) {
+		treeData.push(tree);
+		tree.children.forEach((node) => processOrderedTreeData(node, treeData));
+	}
+};
+const processObjectToTree = (result, treeData, objectReferenceKeys, treeList, catalogObjects, promotedEntities, wasLazyLoaded) => {
+	const treeArr = { ...treeData };
+	processReferences(result, objectReferenceKeys, treeArr, 0, treeList, null, catalogObjects, promotedEntities, wasLazyLoaded);
+};
+const processReferences = (reference, objectReferenceKeys, treeData, index, treeList, parentId, catalogObjects, promotedEntities, wasLazyLoaded) => {
+	const newIndex = index + 1;
+	if (reference) {
+		let node = parentId ? treeData[newIndex] : treeData[0];
+		let nodeGroups = [];
+		if (parentId) {
+			if (node?.properties?.groupConfiguration?.groupType === NodeGroupTypeEnums.Static) nodeGroups = constructStaticNodeGroups(node, true);
+			else if (node?.properties?.groupConfiguration?.groupType === NodeGroupTypeEnums.Dynamic) nodeGroups = constructDynamicNodeGroups(reference, node, true);
+		}
+		if (Array.isArray(reference) && reference.length) reference.forEach((ref, i) => {
+			if (node) {
+				const nodeCopy = cloneDeep(node);
+				processObjIndex(nodeCopy, ref, i, parentId, catalogObjects, promotedEntities, wasLazyLoaded);
+				if (nodeGroups.length) {
+					if (node?.properties?.groupConfiguration?.groupType === NodeGroupTypeEnums.Static) {
+						const groupedItemIndexes = /* @__PURE__ */ new Set();
+						let processedItem = {
+							itemAdded: false,
+							nodeChildren: []
+						};
+						nodeGroups.forEach((nodeGroup) => {
+							let nodeGroupChildren = [];
+							processedItem = processItemForStaticNodeGroup(nodeGroup, ref, groupedItemIndexes, nodeCopy, i, /* @__PURE__ */ new Set(), treeList);
+							nodeGroupChildren = nodeGroupChildren.concat(processedItem.nodeChildren);
+							mapNodeGroupChildren(nodeGroup, nodeGroupChildren);
+							nodeGroup.parentGroupId = nodeCopy.parentId;
+						});
+						if (!processedItem.itemAdded && node?.properties?.groupConfiguration?.outlier === NodeGroupOutlierEnums.Individual) {
+							const nodeIsHidden = checkNodeIsHidden(nodeCopy, ref, wasLazyLoaded);
+							!nodeIsHidden && treeList.push(nodeCopy);
+						}
+					} else if (node?.properties?.groupConfiguration?.groupType === NodeGroupTypeEnums.Dynamic) nodeGroups.forEach((nodeGroup) => {
+						nodeGroup.parentGroupId = nodeCopy.parentId;
+						nodeGroup.parentId = nodeCopy.parentId;
+						processGroupNodesAndAddToTreeList(nodeGroup, treeList, nodeCopy.parentId, ref, wasLazyLoaded);
+					});
+				} else {
+					const nodeIsHidden = checkNodeIsHidden(nodeCopy, ref, wasLazyLoaded);
+					!nodeIsHidden && treeList.push(nodeCopy);
+				}
+				if (nodeCopy?.children?.length) {
+					const objectReferenceKeysCopy = [...objectReferenceKeys];
+					nodeCopy.children.forEach((childNode, i$1) => {
+						const catalogObjectKey = childNode?.properties?.catalogObjectKey;
+						const nextIndex = objectReferenceKeysCopy.indexOf(catalogObjectKey);
+						if (!parentId) objectReferenceKeysCopy[nextIndex] = null;
+						processReferences(ref[catalogObjectKey], objectReferenceKeys, treeData, nextIndex, treeList, nodeCopy.id, catalogObjects, promotedEntities, nodeCopy.properties.lazyLoad);
+					});
+				}
+			}
+		});
+		else if (typeof reference === "object" && !Array.isArray(reference)) {
+			processObjIndex(node, reference, 0, parentId, catalogObjects, promotedEntities, wasLazyLoaded);
+			if (node) {
+				const nodeCopy = cloneDeep(node);
+				const nodeIsHidden = checkNodeIsHidden(nodeCopy, reference, wasLazyLoaded);
+				!nodeIsHidden && treeList.push(nodeCopy);
+				if (nodeCopy?.children?.length) {
+					const objectReferenceKeysCopy = [...objectReferenceKeys];
+					nodeCopy.children.forEach((childNode, i) => {
+						const catalogObjectKey = childNode?.properties?.catalogObjectKey;
+						const nextIndex = parentId ? newIndex : objectReferenceKeysCopy.indexOf(catalogObjectKey);
+						if (!parentId) objectReferenceKeysCopy[nextIndex] = null;
+						processReferences(reference[catalogObjectKey], objectReferenceKeys, treeData, nextIndex, treeList, nodeCopy.id, catalogObjects, promotedEntities, nodeCopy.properties.lazyLoad);
+					});
+				}
+			}
+		}
+	}
+};
+const processObjIndex = (node, obj, index, parentId, catalogObjects, promotedEntities, wasLazyLoaded) => {
+	if (node.properties.conditionalNodeIconExpression) {
+		const conditionalNodeIcon = evaluateRule(node.properties.conditionalNodeIconExpression, obj, node.properties?.joiningEntityCatalogObjectKey, wasLazyLoaded);
+		if (conditionalNodeIcon) {
+			node.properties["conditionalNodeIconName"] = conditionalNodeIcon?.name || "";
+			node.properties["conditionalNodeIconColor"] = conditionalNodeIcon?.iconColor?.hex;
+			node.properties["conditionalNodeIconType"] = conditionalNodeIcon?.type || "";
+		} else {
+			node.properties["conditionalNodeIconName"] = "";
+			node.properties["conditionalNodeIconColor"] = "";
+			node.properties["conditionalNodeIconType"] = "";
+		}
+	}
+	if (node.properties.conditionalNodeAdornmentExpression || node.properties.conditionalIconExpression) {
+		const conditionalNodeAdornment = node.properties.conditionalNodeAdornmentExpression ? evaluateRule(node.properties.conditionalNodeAdornmentExpression, obj, node.properties?.joiningEntityCatalogObjectKey, wasLazyLoaded) : evaluateRule(node.properties.conditionalIconExpression, obj, node.properties?.joiningEntityCatalogObjectKey, wasLazyLoaded);
+		if (conditionalNodeAdornment) {
+			node.properties["conditionalNodeAdornmentName"] = conditionalNodeAdornment?.name || "";
+			node.properties["conditionalNodeAdornmentColor"] = conditionalNodeAdornment?.iconColor?.hex;
+			node.properties["conditionalNodeAdornmentType"] = conditionalNodeAdornment?.type || "";
+		} else {
+			node.properties["conditionalNodeAdornmentName"] = "";
+			node.properties["conditionalNodeAdornmentColor"] = "";
+			node.properties["conditionalNodeAdornmentType"] = "";
+		}
+	}
+	if (node.properties.catalogReturnObject) {
+		let searchIdentifiers = getSearchIdentifiers(catalogObjects, node.properties.catalogReturnObject);
+		node.properties["searchIdentifier"] = searchIdentifiers?.join(",");
+		const associatedTreePrimaryKeyMap = node.properties.associatedTreePrimaryKeyMap;
+		if (!!associatedTreePrimaryKeyMap) {
+			searchIdentifiers = Object.keys(associatedTreePrimaryKeyMap);
+			node.properties["searchIdentifier"] = searchIdentifiers;
+		}
+		node.properties["filterElements"] = [];
+		const searchValues = [];
+		const joiningEntityCatalogObjectKey = node?.properties?.joiningEntityCatalogObjectKey;
+		searchIdentifiers.forEach((searchIdentifier) => {
+			const searchField = searchIdentifier ? searchIdentifier.charAt(0).toUpperCase() + searchIdentifier.slice(1) : "";
+			let searchValue = "";
+			let si = associatedTreePrimaryKeyMap?.[searchIdentifier] ? associatedTreePrimaryKeyMap?.[searchIdentifier] : searchIdentifier;
+			if (obj[si]) searchValue = obj[si];
+			else if (joiningEntityCatalogObjectKey) searchValue = obj[joiningEntityCatalogObjectKey] ? obj[joiningEntityCatalogObjectKey][si] : "";
+			node.properties["filterElements"].push({
+				searchField,
+				searchOperator: "=",
+				searchValue: searchValue ?? ""
+			});
+			searchValues.push(searchValue);
+		});
+		node.properties["searchValue"] = searchValues.toString();
+	}
+	node.properties["nodeLabel"] = getDisplayName(node, obj);
+	node.properties["nodeSubLabel"] = getDisplayDetails(node, obj);
+	node.properties["headerTitle"] = getHeaderTitle(node, obj);
+	node.parentId = parentId;
+	node["entityNodeParentId"] = parentId;
+	node.id = v4();
+	node.nodeObj = obj;
+	if (node?.properties?.lazyLoad) node.lazyLoadChildrenArr = getLazyLoadChildrenArr(node, catalogObjects, promotedEntities);
+};
+const getEntityAssoc = (nodeEntity, node) => {
+	let entityAssoc = null;
+	if (nodeEntity) {
+		const referenceProperty = nodeEntity.properties.find((property) => {
+			if (node.properties?.joiningEntityName) return property.reference === node.properties?.joiningEntityName;
+			else return property.reference === node.properties?.catalogReturnObject;
+		});
+		entityAssoc = referenceProperty ? referenceProperty.extendedProperties?.childEntityAssoc : null;
+	}
+	return entityAssoc;
+};
+const getLazyLoadChildrenArr = (node, catalogObjects, promotedEntities) => {
+	const lazyLoadChildrenArr = [];
+	let defaultSearchIdentifiers = [];
+	if (node?.properties?.catalogReturnObject) defaultSearchIdentifiers = getSearchIdentifiers(catalogObjects, node.properties.catalogReturnObject);
+	node && node.children && node.children.forEach((childNode) => {
+		const lazyNodeSearchObj = {
+			apiMethodId: null,
+			data: null,
+			parentNodeRefKey: childNode.properties?.catalogObjectKey,
+			catalogReturnObject: childNode.properties?.catalogReturnObject
+		};
+		const entityName = childNode.properties?.catalogReturnObject;
+		const promotedEntity = promotedEntities?.find((pe) => pe.entityName === entityName);
+		let searchIdentifiers = [];
+		const filterElements = [];
+		if (promotedEntity) {
+			let baseSearch = promotedEntity.unityBaseSearchMethod;
+			let childBaseSearch = promotedEntity.unityBaseSearchMethod;
+			const nodeEntity = catalogObjects?.find((co) => co.catalogObjectName === node.properties?.catalogReturnObject);
+			let isManyToManySearch = false;
+			let usingJoiningTableForSearch = false;
+			if (nodeEntity) {
+				const childEntityAssoc = getEntityAssoc(nodeEntity, childNode);
+				let joiningEntityName = null;
+				let promotedEntityForJoiningTable = null;
+				if (childEntityAssoc.Cardinality === CardinalityTypeEnums.Many_To_Many) {
+					isManyToManySearch = true;
+					lazyNodeSearchObj["manyToManyKeys"] = [];
+					joiningEntityName = childNode.properties?.joiningEntityName;
+					promotedEntityForJoiningTable = promotedEntities?.find((pe) => pe.entityName === joiningEntityName);
+					if (promotedEntityForJoiningTable?.unityBaseSearchMethod) {
+						baseSearch = promotedEntityForJoiningTable.unityBaseSearchMethod;
+						lazyNodeSearchObj.manyToManyJointEntityApiMethodId = childBaseSearch?.apiMethodId;
+						usingJoiningTableForSearch = true;
+					}
+					const childNodeEntity = catalogObjects.find((co) => co.catalogObjectName === childNode.properties?.catalogReturnObject);
+					const entityAssoc = getEntityAssoc(childNodeEntity, childNode);
+					if (entityAssoc && Object.keys(entityAssoc).length) entityAssoc.Keys.forEach((keyVal) => {
+						const keyValArr = keyVal.split(",");
+						const foreignKeyName = keyValArr[0] ? keyValArr[0].trim() : "";
+						const parentIdentifierName = keyValArr[1] ? keyValArr[1].trim() : "";
+						const searchValueKey = /^[A-Z]*$/.test(parentIdentifierName) ? parentIdentifierName.toLowerCase() : toLowerFirstChar(parentIdentifierName);
+						lazyNodeSearchObj["manyToManyKeys"].push({
+							searchItemIdentifier: usingJoiningTableForSearch ? /^[A-Z]*$/.test(foreignKeyName) ? foreignKeyName.toLowerCase() : toLowerFirstChar(foreignKeyName) : searchValueKey,
+							searchNameKey: foreignKeyName,
+							searchValueKey
+						});
+					});
+				}
+				if (childEntityAssoc && Object.keys(childEntityAssoc).length) childEntityAssoc.Keys.forEach((keyVal) => {
+					const keyValArr = keyVal.split(",");
+					let searchJoiningEntity = "";
+					if (!isManyToManySearch && node.nodeObj.hasOwnProperty(node.properties.joiningEntityCatalogObjectKey)) searchJoiningEntity = node.properties.joiningEntityCatalogObjectKey;
+					const foreignKeyName = keyValArr[0] ? keyValArr[0].trim() : "";
+					const parentIdentifierName = keyValArr[1] ? keyValArr[1].trim() : "";
+					let siObj = {
+						searchNameKey: parentIdentifierName,
+						searchValueKey: /^[A-Z]*$/.test(foreignKeyName) ? foreignKeyName.toLowerCase() : toLowerFirstChar(foreignKeyName),
+						searchJoiningEntity
+					};
+					if (isManyToManySearch && !usingJoiningTableForSearch) siObj = {
+						searchNameKey: foreignKeyName,
+						searchValueKey: /^[A-Z]*$/.test(foreignKeyName) ? foreignKeyName.toLowerCase() : toLowerFirstChar(foreignKeyName)
+					};
+					if (isManyToManySearch) {
+						if (childNode.properties?.catalogObjectKey && childNode.properties?.joiningEntityCatalogObjectLeftKey) {
+							siObj["joiningEntityKeyName"] = toUpperFirstChar(!usingJoiningTableForSearch ? childNode.properties?.joiningEntityChildKey : childNode.properties?.catalogObjectKey);
+							siObj["joiningEntityCatalogObjectLeftKeyName"] = toUpperFirstChar(childNode.properties?.joiningEntityCatalogObjectLeftKey);
+						}
+						if (promotedEntityForJoiningTable?.unityBaseSearchMethod) {
+							siObj["joiningEntityKeyName"] = null;
+							siObj["joiningEntityCatalogObjectLeftKeyName"] = null;
+						}
+					}
+					searchIdentifiers.push(siObj);
+				});
+			}
+			if (!searchIdentifiers.length) defaultSearchIdentifiers.forEach((searchIdentifier) => {
+				const siObj = {
+					searchNameKey: searchIdentifier,
+					searchValueKey: searchIdentifier
+				};
+				if (childNode.properties?.catalogObjectKey && childNode.properties?.joiningEntityCatalogObjectLeftKey) {
+					siObj["joiningEntityKeyName"] = toUpperFirstChar(childNode.properties?.catalogObjectKey);
+					siObj["joiningEntityCatalogObjectLeftKeyName"] = toUpperFirstChar(childNode.properties?.joiningEntityCatalogObjectLeftKey);
+				}
+				searchIdentifiers.push(siObj);
+			});
+			searchIdentifiers.forEach((si) => {
+				let searchValue = "";
+				if (si?.searchJoiningEntity) searchValue = node.nodeObj[si.searchJoiningEntity][si.searchValueKey];
+				else if (usingJoiningTableForSearch) {
+					const joiningEntityCatalogObjectKey = node?.properties?.joiningEntityCatalogObjectKey;
+					const value = node?.nodeObj?.[joiningEntityCatalogObjectKey];
+					searchValue = value ? value[si.searchValueKey] : node.nodeObj[si.searchValueKey];
+				} else searchValue = node.nodeObj[si.searchValueKey];
+				let formattedPropertyName = toUpperFirstChar(si.searchNameKey);
+				if (si["joiningEntityKeyName"] && si["joiningEntityCatalogObjectLeftKeyName"]) formattedPropertyName = `${si["joiningEntityKeyName"]}.${si["joiningEntityCatalogObjectLeftKeyName"]}.${formattedPropertyName}`;
+				filterElements.push({
+					searchField: formattedPropertyName,
+					searchValue,
+					searchOperator: "="
+				});
+			});
+			lazyNodeSearchObj.data = getSearchObject(filterElements, 1, 50);
+			lazyNodeSearchObj.apiMethodId = baseSearch?.apiMethodId || null;
+			lazyLoadChildrenArr.push(lazyNodeSearchObj);
+		} else {
+			console.log("Error: Promote " + entityName + " entity");
+			node.errorRetrievingChildren = "Error: Promote " + entityName + " child entity";
+		}
+	});
+	return lazyLoadChildrenArr;
+};
+const formatTreeMenuItem = (responseObject, treeStructure, catalogObjects, promotedEntities, associatedInquiryTree, wasLazyLoaded) => {
+	if (!responseObject) return null;
+	const tree = cloneDeep(treeStructure);
+	const orderedKeys = [];
+	const orderedTreeData = [];
+	const treeArr = [];
+	processCatalogObjectKeysInOrder(tree, orderedKeys);
+	processOrderedTreeData(tree, orderedTreeData);
+	processObjectToTree(responseObject, orderedTreeData, orderedKeys, treeArr, catalogObjects, promotedEntities, wasLazyLoaded);
+	const displayTree = makeTreeStructure(treeArr, "id", "parentId");
+	displayTree["associatedInquiryTree"] = associatedInquiryTree;
+	displayTree["wasLazyLoaded"] = wasLazyLoaded;
+	return displayTree;
+};
+const expandAllNodes = (tree) => {
+	tree.isExpanded = true;
+	if (tree?.children) tree.children.forEach((node) => expandAllNodes(node));
+};
+const collapseAllNodes = (tree) => {
+	tree.isExpanded = false;
+	if (tree?.children) tree.children.forEach((node) => collapseAllNodes(node));
+};
+const findAllParentIds = (menuItems, currentParentNode, allParentIds = []) => {
+	if (currentParentNode?.parentId) {
+		allParentIds.push(currentParentNode?.parentId);
+		const newParentNode = searchTree(menuItems, currentParentNode?.parentId);
+		findAllParentIds(menuItems, newParentNode, allParentIds);
+	}
+	return allParentIds;
+};
+const formatTreeLabel = (label, obj) => {
+	const fields = label?.split("+");
+	const keys = fields?.map((field) => field.trim());
+	if (keys) {
+		const skippableKeys = [];
+		const updatedKeys = keys.map((key, index) => {
+			const matchedKey = key.charAt(0) === "\"";
+			if (matchedKey) {
+				skippableKeys.push(index);
+				key = key.replace(/"/g, "");
+			}
+			return key;
+		});
+		const values = [];
+		for (let j = 0; j < keys.length; j++) {
+			let property = keys[j];
+			if (property) {
+				const splitProperties = property.split(".");
+				if (splitProperties.length > 1) {
+					let constructedValue = null;
+					splitProperties.forEach((property$1) => {
+						const matches = property$1.match(/\[(.*?)\]/);
+						let objIndex = null;
+						let arrIndex = null;
+						if (matches) {
+							arrIndex = parseInt(matches[1]);
+							objIndex = matches.index;
+						}
+						if (typeof arrIndex === "number" && objIndex) {
+							const formattedProperty = property$1.substring(0, objIndex);
+							if (!constructedValue) {
+								if (obj[formattedProperty]) constructedValue = obj[formattedProperty][arrIndex];
+							} else if (constructedValue[formattedProperty]) constructedValue = constructedValue[formattedProperty][arrIndex];
+						} else if (!constructedValue) constructedValue = obj[property$1];
+						else constructedValue = constructedValue[property$1];
+					});
+					if (typeof constructedValue === "boolean" || typeof constructedValue === "number") constructedValue = constructedValue.toString();
+					values.push(constructedValue);
+					continue;
+				}
+			}
+			let value = obj[property];
+			if (typeof value === "boolean" || typeof value === "number") value = value.toString();
+			values.push(value);
+		}
+		let displayName = updatedKeys.join("+");
+		for (let k = 0; k < updatedKeys.length; k++) if (!skippableKeys.includes(k)) if (values[k]) displayName = displayName.replace(`${updatedKeys[k]}`, values[k]);
+		else displayName = displayName.replace(`${updatedKeys[k]}`, "");
+		return displayName.replaceAll("+", " ");
+	} else return label;
+};
+const getDisplayName = (node, obj) => {
+	return formatTreeLabel(node.properties["displayName"], obj);
+};
+const getDisplayDetails = (node, obj) => {
+	return formatTreeLabel(node.properties["displayDetails"], obj);
+};
+const getHeaderTitle = (node, obj) => {
+	return formatTreeLabel(node.properties["headerName"], obj);
+};
+const searchForMatchingNode = (tree, nodeObj = {}, searchIdentifiers = []) => {
+	let result = null;
+	let match = true;
+	searchIdentifiers.forEach((searchIdentifier) => {
+		if (tree?.nodeObj[searchIdentifier] !== nodeObj[searchIdentifier]) match = false;
+	});
+	if (match && searchIdentifiers.length) return tree;
+	else {
+		if (tree.children) tree.children.some((node) => result = searchForMatchingNode(node, nodeObj, searchIdentifiers));
+		return result;
+	}
+};
+const getNodeIdForRightBorder = (expandedNodeIds, node, parentId) => {
+	if (!expandedNodeIds.includes(node?.id)) return node.id;
+	if (!expandedNodeIds.includes(parentId)) {
+		const foundParentNode = node.children.find((item) => item.id === parentId);
+		if (foundParentNode) if (expandedNodeIds.includes(foundParentNode?.parentId)) return parentId;
+		else return getNodeIdForRightBorder(expandedNodeIds, foundParentNode, foundParentNode?.parentId);
+	} else return parentId;
+};
+const findNodeById = (tree, id) => {
+	let result = null;
+	if (tree?.id === id) return tree;
+	else {
+		if (tree.children) tree.children.some((node) => result = findNodeById(node, id));
+		return result;
+	}
+};
+const findNodeByIdAndLabel = (tree, id, label) => {
+	let result = null;
+	if (tree?.id === id && tree?.properties?.label === label) return tree;
+	else {
+		if (tree.children) tree.children.some((node) => result = findNodeById(node, id, label));
+		return result;
+	}
+};
+const findNodesByIdAndLabel = (tree, id, label) => {
+	let results = [];
+	if (tree?.id === id && tree?.properties?.label === label) results.push(tree);
+	if (tree.children) tree.children.forEach((node) => {
+		results = results.concat(findNodesByIdAndLabel(node, id, label));
+	});
+	return results;
+};
+const updateNodeForStaticGrouping = (displayTree, nodeGroup, nodeChildren, treeList, scopedGroupItemIndexes, groupedItemIndexes, index, item) => {
+	const updatedDisplayTree = { ...displayTree };
+	const nodeIsHidden = checkNodeIsHidden(updatedDisplayTree, item, false);
+	if (!nodeIsHidden) {
+		updatedDisplayTree.children = displayTree.children ? cloneDeep(displayTree.children) : displayTree.children;
+		updatedDisplayTree["parentId"] = nodeGroup.id;
+		updatedDisplayTree["parentGroupId"] = nodeGroup.id;
+		if (updatedDisplayTree.isGroupNode) nodeGroup.children.push(updatedDisplayTree);
+		else nodeChildren.push(updatedDisplayTree);
+		if (treeList) treeList.push(updatedDisplayTree);
+		scopedGroupItemIndexes.add(index);
+		groupedItemIndexes.add(index);
+	}
+};
+const processItemForStaticNodeGroup = (nodeGroup, item, groupedItemIndexes, displayTree, index, scopedGroupItemIndexes = /* @__PURE__ */ new Set(), treeList, nodeChildren = []) => {
+	if (nodeGroup?.properties?.propertyMapping && nodeGroup?.properties?.jsonLogic) {
+		const rule = mapRule(nodeGroup?.properties?.propertyMapping, nodeGroup?.properties?.jsonLogic);
+		if (rule && evaluateRule(rule, item, item.properties?.joiningEntityCatalogObjectKey, false)) {
+			let itemAdded = false;
+			nodeGroup.children.forEach((childGroup) => {
+				if (childGroup.isGroupNode) {
+					const processedItem = processItemForStaticNodeGroup(childGroup, item, groupedItemIndexes, displayTree, index, childGroup.children.length ? /* @__PURE__ */ new Set() : scopedGroupItemIndexes, treeList, nodeChildren) || { itemAdded };
+					itemAdded = processedItem?.itemAdded;
+				}
+			});
+			if (!itemAdded) {
+				updateNodeForStaticGrouping(displayTree, nodeGroup, nodeChildren, treeList, scopedGroupItemIndexes, groupedItemIndexes, index, item);
+				itemAdded = true;
+			}
+		}
+	} else if (nodeGroup.isOutlierGroup && !groupedItemIndexes.has(index)) updateNodeForStaticGrouping(displayTree, nodeGroup, nodeChildren, treeList, scopedGroupItemIndexes, groupedItemIndexes, index, item);
+	if (treeList && nodeGroup.isGroupNode) {
+		const existingGroup = treeList.filter((node) => node.isGroupNode).find((eg) => eg.id === nodeGroup.id);
+		if (!existingGroup) {
+			const nodeIsHidden = checkNodeIsHidden(nodeGroup, item, false);
+			!nodeIsHidden && treeList.push(nodeGroup);
+		}
+	}
+	return {
+		itemAdded: groupedItemIndexes.has(index),
+		nodeChildren
+	};
+};
+const constructStaticNodeGroups = (tree, shouldUseNewId = false) => {
+	const nodeGroups = [];
+	const groupConfiguration = tree?.properties?.groupConfiguration;
+	const groupType = groupConfiguration?.groupType || NodeGroupTypeEnums.Static;
+	const hideEmptyGroups = groupConfiguration?.hideEmptyGroups;
+	if (groupConfiguration?.enabled && groupConfiguration?.groupings[groupType]?.length) {
+		groupConfiguration.groupings[groupType].forEach((grouping) => {
+			const orderedGroups = orderByGroupOrder(grouping?.groups);
+			const newIdMap = {};
+			orderedGroups.forEach((group) => {
+				if (shouldUseNewId) newIdMap[group.id] = v4();
+				group["children"] = [];
+			});
+			if (Object.keys(newIdMap).length) orderedGroups.forEach((group) => {
+				if (newIdMap[group.id]) group.id = newIdMap[group.id];
+				if (newIdMap[group.parentGroupId]) group.parentGroupId = newIdMap[group.parentGroupId];
+			});
+			if (orderedGroups?.length) {
+				const firstGroup = orderedGroups.find((group) => !group.parentGroupId) || orderedGroups[0];
+				orderedGroups.shift();
+				const displayTree = makeTreeStaticGroupStructure(orderedGroups, "id", "parentGroupId", groupType, hideEmptyGroups);
+				const { id, isExpanded,...firstGroupProperties } = firstGroup;
+				const groupNode = new GroupNode({
+					id,
+					hideEmptyGroups,
+					groupType,
+					children: Array.isArray(displayTree) ? displayTree : [displayTree],
+					isExpanded,
+					properties: { ...firstGroupProperties }
+				});
+				nodeGroups.push(groupNode);
+			}
+		});
+		if (groupConfiguration?.outlier === "group") {
+			const outlierGroup = new GroupNode({
+				groupType,
+				isOutlierGroup: true,
+				properties: {
+					label: groupConfiguration?.outlierGroupLabel || "Unlabeled Outlier Group",
+					icon: groupConfiguration?.outlierIcon
+				}
+			});
+			nodeGroups.push(outlierGroup);
+		}
+	}
+	return nodeGroups;
+};
+const getOrderedDynamicGroups = (tree, shouldUseNewId = false) => {
+	const groupConfiguration = tree?.properties?.groupConfiguration;
+	const groupType = groupConfiguration?.groupType || NodeGroupTypeEnums.Dynamic;
+	let orderedGroups = [];
+	if (groupConfiguration?.enabled && groupConfiguration?.groupings[groupType]?.length) groupConfiguration.groupings[groupType].forEach((grouping) => {
+		orderedGroups = orderByGroupOrder(grouping?.groups);
+		const newIdMap = {};
+		orderedGroups.forEach((group) => {
+			if (shouldUseNewId) newIdMap[group.id] = v4();
+			group["children"] = [];
+		});
+		if (Object.keys(newIdMap).length) orderedGroups.forEach((group) => {
+			if (newIdMap[group.id]) group.id = newIdMap[group.id];
+			if (newIdMap[group.parentGroupId]) group.parentGroupId = newIdMap[group.parentGroupId];
+		});
+	});
+	return orderedGroups;
+};
+const constructDynamicNodeGroups = (results, tree, shouldUseNewId = false) => {
+	let nodeGroups = [];
+	const groupConfiguration = tree?.properties?.groupConfiguration;
+	const groupType = groupConfiguration?.groupType || NodeGroupTypeEnums.Dynamic;
+	if (groupConfiguration?.enabled && groupConfiguration?.groupings[groupType]?.length) groupConfiguration.groupings[groupType].forEach((grouping) => {
+		const orderedGroups = orderByGroupOrder(grouping?.groups);
+		const newIdMap = {};
+		orderedGroups.forEach((group) => {
+			if (shouldUseNewId) newIdMap[group.id] = v4();
+			group["children"] = [];
+		});
+		if (Object.keys(newIdMap).length) orderedGroups.forEach((group) => {
+			if (newIdMap[group.id]) group.id = newIdMap[group.id];
+			if (newIdMap[group.parentGroupId]) group.parentGroupId = newIdMap[group.parentGroupId];
+		});
+		if (orderedGroups?.length) {
+			const isSingleGroup = orderedGroups.length === 1;
+			const dynamicTreeStructure = makeDynamicTreeStructure(orderedGroups, "id", "parentGroupId");
+			const groupSet = makeDynamicGroupStructures(dynamicTreeStructure, results);
+			results.forEach((item, index) => {
+				const orderedKeys = [];
+				const orderedTreeData = [];
+				const treeArr = [];
+				const innerGroupList = [];
+				processCatalogObjectKeysInOrder(tree, orderedKeys);
+				processOrderedTreeData(tree, orderedTreeData);
+				processObjectToTree(item, orderedTreeData, orderedKeys, treeArr, null, null, false, innerGroupList);
+				const displayTree = makeTreeStructure(treeArr, "id", "parentId");
+				const updatedDisplayTree = cloneDeep(displayTree);
+				const nodeIsHidden = checkNodeIsHidden(updatedDisplayTree, item, false);
+				!nodeIsHidden && processItemForDynamicNodeGroups(updatedDisplayTree, dynamicTreeStructure, groupSet, groupSet, isSingleGroup);
+			});
+			groupSet.forEach((group) => updateTreeIds(group, null, v4(), v4()));
+			nodeGroups = nodeGroups.concat(groupSet);
+		}
+	});
+	return nodeGroups;
+};
+const getLabelFromProperty = (item, property) => {
+	const splitProperties = property.split(".");
+	if (splitProperties.length) {
+		let constructedValue = null;
+		splitProperties.forEach((property$1) => {
+			const matches = property$1.match(/\[(.*?)\]/);
+			let objIndex = null;
+			let arrIndex = null;
+			if (matches) {
+				arrIndex = parseInt(matches[1]);
+				objIndex = matches.index;
+			}
+			if (typeof arrIndex === "number" && objIndex) {
+				const formattedProperty = property$1.substring(0, objIndex);
+				if (!constructedValue) {
+					if (item[formattedProperty]) constructedValue = item[formattedProperty][arrIndex];
+				} else if (constructedValue[formattedProperty]) constructedValue = constructedValue[formattedProperty][arrIndex];
+			} else if (!constructedValue) constructedValue = item ? item[property$1] : "";
+			else constructedValue = constructedValue[property$1];
+		});
+		return constructedValue;
+	}
+	return null;
+};
+const constructBusinessObjectArrFromTree = (node, businessObjects = []) => {
+	if (node?.nodeObj) {
+		const businessObject = {
+			label: "",
+			value: "",
+			domainObject: ""
+		};
+		const joiningEntityCatalogObjectKey = node.properties?.joiningEntityCatalogObjectKey;
+		const displayName = node.properties?.displayName;
+		if (joiningEntityCatalogObjectKey) {
+			const jointEntity = node.nodeObj[joiningEntityCatalogObjectKey];
+			businessObject.label = formatTreeLabel(displayName, node.nodeObj) || jointEntity?.businessObjectKey;
+			businessObject.value = jointEntity?.businessObjectKey;
+			businessObject.domainObject = node.properties?.catalogReturnObject;
+		} else {
+			const entity = node.nodeObj;
+			businessObject.label = formatTreeLabel(displayName, node.nodeObj) || entity?.businessObjectKey;
+			businessObject.value = entity?.businessObjectKey;
+			businessObject.domainObject = node.properties?.catalogReturnObject;
+		}
+		businessObjects.push(businessObject);
+	}
+	if (node?.children?.length) node.children.forEach((childNode) => constructBusinessObjectArrFromTree(childNode, businessObjects));
+	return businessObjects;
+};
+const processItemForDynamicNodeGroups = (displayTree, node, groupNodes, previousFilteredGroups = [], isSingleGroup = false) => {
+	const { property, id } = node;
+	const item = displayTree?.nodeObj;
+	const label = property ? getLabelFromProperty(item, property) : null;
+	let filteredGroups = [];
+	previousFilteredGroups.forEach((group) => {
+		if (group) {
+			const foundGroups = findNodesByIdAndLabel(group, id, label);
+			if (foundGroups.length) filteredGroups = filteredGroups.concat(foundGroups);
+		}
+	});
+	if (filteredGroups.length) if (node?.children?.length) node.children.forEach((child) => processItemForDynamicNodeGroups(displayTree, child, groupNodes, filteredGroups, isSingleGroup));
+	else filteredGroups.forEach((filteredGroup) => {
+		const matchingGroupNode = findNodeByIdAndLabel(filteredGroup, node.id, label);
+		if (matchingGroupNode) {
+			displayTree["parentGroupId"] = matchingGroupNode.id;
+			matchingGroupNode.children.push(displayTree);
+		}
+	});
+	else if (isSingleGroup) groupNodes.push(displayTree);
+	else previousFilteredGroups.forEach((filteredGroup) => {
+		if (filteredGroup) {
+			displayTree["parentGroupId"] = filteredGroup.id;
+			filteredGroup.children.push(displayTree);
+		}
+	});
+};
+const orderByGroupOrder = (groups = []) => {
+	return orderBy(groups, ["order"], ["asc"]);
+};
+const updateTreeIds = (node, lastEntityNodeId, newId = v4(), newParentId = v4()) => {
+	let entityNodeParentId = lastEntityNodeId;
+	if (node) {
+		node.id = newId;
+		if (node.parentId || node.parentGroupId) {
+			node.parentId = newParentId;
+			node.parentGroupId = newParentId;
+		}
+		if (!node.isGroupNode && entityNodeParentId) node["entityNodeParentId"] = entityNodeParentId;
+		if (!node.isGroupNode) entityNodeParentId = node.id;
+	}
+	if (node?.children?.length) node.children.forEach((child) => updateTreeIds(child, entityNodeParentId, v4(), newId));
+};
+const processGroupNodesAndAddToTreeList = (node, treeList, lastEntityNodeId, item, wasLazyLoaded) => {
+	let entityNodeParentId = lastEntityNodeId;
+	if (treeList) {
+		if (!treeList.find((tree) => tree.id === node.id)) {
+			if (!node.isGroupNode && entityNodeParentId) node["entityNodeParentId"] = entityNodeParentId;
+			if (!node.isGroupNode) entityNodeParentId = node.id;
+			const nodeIsHidden = checkNodeIsHidden(node, item, wasLazyLoaded);
+			!nodeIsHidden && treeList.push(node);
+		}
+	}
+	if (node?.children?.length) node.children.forEach((child) => processGroupNodesAndAddToTreeList(child, treeList, entityNodeParentId, item, wasLazyLoaded));
+};
+const mapNodeGroupChildren = (nodeGroup, nodeGroupChildren = []) => {
+	nodeGroupChildren.forEach((node) => {
+		if (nodeGroup.id === node.parentGroupId) nodeGroup.children.push(node);
+	});
+	if (nodeGroup?.children?.length) nodeGroup.children.forEach((childGroup) => {
+		if (childGroup.isGroupNode) mapNodeGroupChildren(childGroup, nodeGroupChildren);
+	});
+	return nodeGroup;
+};
+const checkNodeIsHidden = (node, item, wasLazyLoaded = false) => {
+	if (!node || node && !Object.keys(node).length) return true;
+	let rule = null;
+	if (node.isGroupNode) {
+		if (node.properties?.hiddenNode?.enabled) {}
+	} else if (node.properties?.hiddenNode?.enabled) {
+		rule = mapRule(node.properties.hiddenNode.propertyMapping, node.properties.hiddenNode.jsonLogic);
+		if (rule && evaluateRule(rule, item, node.properties?.joiningEntityCatalogObjectKey, wasLazyLoaded)) return true;
+	}
+	return false;
+};
+const constructPreloadedTree = (treeStructure, pageList) => {
+	if (!pageList) return null;
+	let preloadedList = [];
+	const tree = cloneDeep(treeStructure);
+	if (tree.properties?.groupConfiguration?.enabled && tree.properties?.groupConfiguration.groupType === NodeGroupTypeEnums.Static && tree.properties?.groupConfiguration?.groupings?.static?.length) {
+		const topNodeGroups = constructStaticNodeGroups(tree);
+		const groupedItemIndexes = /* @__PURE__ */ new Set();
+		topNodeGroups.forEach((nodeGroup) => {
+			let nodeGroupChildren = [];
+			pageList.forEach((item, index) => {
+				const orderedKeys = [];
+				const orderedTreeData = [];
+				const treeArr = [];
+				const innerGroupList = [];
+				processCatalogObjectKeysInOrder(tree, orderedKeys);
+				processOrderedTreeData(tree, orderedTreeData);
+				processObjectToTree(item, orderedTreeData, orderedKeys, treeArr, null, null, false, innerGroupList);
+				const displayTree = makeTreeStructure(treeArr, "id", "parentId");
+				const processedItem = processItemForStaticNodeGroup(nodeGroup, item, groupedItemIndexes, displayTree, index, /* @__PURE__ */ new Set());
+				nodeGroupChildren = nodeGroupChildren.concat(processedItem?.nodeChildren || []);
+			});
+			const updatedNodeGroup = mapNodeGroupChildren(nodeGroup, nodeGroupChildren);
+			updatedNodeGroup.children.forEach((child) => {
+				updateTreeIds(child, null, v4(), v4());
+			});
+			preloadedList.push(updatedNodeGroup);
+		});
+		if (tree.properties?.groupConfiguration?.outlier === NodeGroupOutlierEnums.Individual) pageList.forEach((item, index) => {
+			if (!groupedItemIndexes.has(index)) {
+				const orderedKeys = [];
+				const orderedTreeData = [];
+				const treeArr = [];
+				processCatalogObjectKeysInOrder(tree, orderedKeys);
+				processOrderedTreeData(tree, orderedTreeData);
+				processObjectToTree(item, orderedTreeData, orderedKeys, treeArr, null, null, false);
+				const displayTree = makeTreeStructure(treeArr, "id", "parentId");
+				const nodeIsHidden = checkNodeIsHidden(displayTree, item, false);
+				if (!nodeIsHidden) {
+					updateTreeIds(displayTree, null, v4(), v4());
+					preloadedList.push(displayTree);
+				}
+			}
+		});
+	} else if (tree.properties?.groupConfiguration?.enabled && tree.properties?.groupConfiguration.groupType === NodeGroupTypeEnums.Dynamic && tree.properties?.groupConfiguration?.groupings?.dynamic?.length) {
+		const nodeGroups = constructDynamicNodeGroups2(pageList, tree);
+		preloadedList = preloadedList.concat(nodeGroups);
+	} else pageList.forEach((item) => {
+		const orderedKeys = [];
+		const orderedTreeData = [];
+		const treeArr = [];
+		processCatalogObjectKeysInOrder(tree, orderedKeys);
+		processOrderedTreeData(tree, orderedTreeData);
+		processObjectToTree(item, orderedTreeData, orderedKeys, treeArr);
+		const displayTree = makeTreeStructure(treeArr, "id", "parentId");
+		const nodeIsHidden = checkNodeIsHidden(displayTree, item, false);
+		!nodeIsHidden && preloadedList.push(displayTree);
+	});
+	return preloadedList;
+};
+const CompareGroupByOrder = (a, b) => {
+	if (a.order > b.order) return 1;
+	if (a.order < b.order) return -1;
+	return 0;
+};
+const CompareSiblingNodes = (a, b) => {
+	if (a.hasOwnProperty("isGroupNode") && !b.hasOwnProperty("isGroupNode")) return -1;
+	if (!a.hasOwnProperty("isGroupNode") && b.hasOwnProperty("isGroupNode")) return 1;
+	if (a.hasOwnProperty("isGroupNode") && b.hasOwnProperty("isGroupNode")) {
+		if (a.properties?.order > b.properties?.order) return 1;
+		if (a.properties?.order < b.properties?.order) return -1;
+	}
+	return 0;
+};
+const GetGroupChildMap = (_map, groupKey) => {
+	if (_map[groupKey] === void 0) _map[groupKey] = [];
+	return _map[groupKey];
+};
+const AddGroupToChildMap = (_map, groupKey, groupNode) => {
+	let childMap = GetGroupChildMap(_map, groupKey);
+	childMap.push(groupNode);
+	childMap.sort(CompareGroupByOrder);
+};
+const createDynamicGroups2 = (_treeConfig, _groupConfig, _item, _curItem, _pList, _siblings, _parentId) => {
+	let _groupCreated = false;
+	if (_pList.length > 0) {
+		let tmpProp = _pList[0];
+		if (_curItem.hasOwnProperty(tmpProp)) {
+			let newItem = _curItem[tmpProp];
+			if (_pList.length > 1) {
+				if (Array.isArray(newItem)) for (let i = 0, numOfItems = newItem.length; i < numOfItems; i++) {
+					let aGroupWasCreated = createDynamicGroups2(_treeConfig, _groupConfig, _item, newItem[i], _pList.slice(1), _siblings, _parentId);
+					_groupCreated = aGroupWasCreated ? aGroupWasCreated : _groupCreated;
+				}
+				else if (typeof newItem === "object" && newItem !== null) {
+					let aGroupWasCreated = createDynamicGroups2(_treeConfig, _groupConfig, _item, newItem, _pList.slice(1), _siblings, _parentId);
+					_groupCreated = aGroupWasCreated ? aGroupWasCreated : _groupCreated;
+				}
+			} else if (typeof newItem !== "object" && newItem !== null && newItem !== "") {
+				let groupName = newItem.toString();
+				let groupNode = null;
+				for (let siblingIdx = 0, numOfSiblings = _siblings.length; siblingIdx < numOfSiblings; siblingIdx++) {
+					let sibling = _siblings[siblingIdx];
+					if (sibling.hasOwnProperty("isGroupNode") && sibling.isGroupNode === true) {
+						if (sibling.properties.label === groupName) {
+							groupNode = sibling;
+							break;
+						}
+					}
+				}
+				if (groupNode == null) {
+					let newGroupNodeId = v4();
+					groupNode = new GroupNode({
+						id: `${newGroupNodeId}`,
+						groupType: NodeGroupTypeEnums.Dynamic,
+						children: [],
+						parentGroupId: _parentId,
+						parentId: _parentId,
+						isExpanded: _groupConfig.isExpanded,
+						properties: {
+							label: groupName,
+							propertyIsCustom: _groupConfig.propertyIsCustom,
+							propertyKey: _groupConfig.property,
+							order: _groupConfig.order
+						}
+					});
+					_siblings.push(groupNode);
+				}
+				_groupCreated = true;
+				let subGroupWasCreated = false;
+				for (let subGroupIdx = 0, numOfSubGroups = _groupConfig.children.length; subGroupIdx < numOfSubGroups; subGroupIdx++) {
+					let subGroupConfig = _groupConfig.children[subGroupIdx];
+					let subGroupPropList = subGroupConfig.property ? subGroupConfig.property.split(".") : [];
+					let subGroupCreated = createDynamicGroups2(_treeConfig, subGroupConfig, _item, _item, subGroupPropList, groupNode.children, groupNode.id);
+					subGroupWasCreated = subGroupCreated ? subGroupCreated : subGroupWasCreated;
+				}
+				if (!subGroupWasCreated) {
+					let tmpNode = cloneDeep(_treeConfig);
+					processObjIndex(tmpNode, _item, null, groupNode.id, null, null, false);
+					groupNode.children.push(tmpNode);
+					let newChildNodes = [];
+					for (let childNodeIdx = 0, numOfChildNodes = tmpNode.children.length; childNodeIdx < numOfChildNodes; childNodeIdx++) {
+						let childConfigNode = tmpNode.children[childNodeIdx];
+						let propToGetRecords = childConfigNode.properties.catalogObjectKey;
+						if (propToGetRecords && propToGetRecords != null && _item.hasOwnProperty(propToGetRecords)) {
+							let newResultSet = _item[propToGetRecords];
+							if (newResultSet && newResultSet != null) if (Array.isArray(newResultSet)) newChildNodes.push(...constructDynamicNodeGroups2(newResultSet, childConfigNode, tmpNode.id));
+							else {
+								let tmpNewResultSet = [];
+								tmpNewResultSet.push(newResultSet);
+								newChildNodes.push(...constructDynamicNodeGroups2(newResultSet, childConfigNode, tmpNode.id));
+							}
+						}
+					}
+					tmpNode.children = newChildNodes;
+				}
+				groupNode.children.sort(CompareSiblingNodes);
+			}
+		}
+	}
+	return _groupCreated;
+};
+const constructDynamicGroupConfigTrees2 = (configNode) => {
+	let topLevelConfigGroupNodes = [];
+	const groupConfiguration = configNode?.properties?.groupConfiguration;
+	const groupType = groupConfiguration?.groupType || NodeGroupTypeEnums.Dynamic;
+	if (groupConfiguration?.enabled && groupConfiguration?.groupings[groupType]?.length) {
+		let dynamicGroupings = groupConfiguration.groupings[groupType];
+		for (let groupingIdx = 0, numOfGroupings = dynamicGroupings.length; groupingIdx < numOfGroupings; groupingIdx++) {
+			let grouping = dynamicGroupings[groupingIdx];
+			if (grouping.groups === void 0 || grouping.groups === null) continue;
+			let groupChildMap = {};
+			for (let groupIdx = 0, numOfGroups = grouping.groups.length; groupIdx < numOfGroups; groupIdx++) {
+				let group = grouping.groups[groupIdx];
+				group["children"] = GetGroupChildMap(groupChildMap, group.id);
+				if (group.parentGroupId === void 0 || group.parentGroupId === null) topLevelConfigGroupNodes.push(group);
+				else AddGroupToChildMap(groupChildMap, group.parentGroupId, group);
+			}
+		}
+	}
+	for (let configIdx = 0, numOfChildConfigNodes = configNode.children.length; configIdx < numOfChildConfigNodes; configIdx++) {
+		let childConfigNode = configNode.children[configIdx];
+		constructDynamicGroupConfigTrees2(childConfigNode);
+	}
+	configNode.groupConfigTrees = topLevelConfigGroupNodes;
+};
+const constructDynamicNodeGroups2 = (results, configNode, parentId = null) => {
+	let levelNodes = [];
+	if (!configNode.groupConfigTrees) constructDynamicGroupConfigTrees2(configNode);
+	for (let rIdx = 0, numOfResults = results.length; rIdx < numOfResults; rIdx++) {
+		let item = results[rIdx];
+		let groupCreated = false;
+		for (let ctlIdx = 0, numOfGroupConfigTrees = configNode.groupConfigTrees.length; ctlIdx < numOfGroupConfigTrees; ctlIdx++) {
+			let groupConfigNode = configNode.groupConfigTrees[ctlIdx];
+			let gPropList = groupConfigNode.property ? groupConfigNode.property.split(".") : [];
+			let aGroupWasCreated = createDynamicGroups2(configNode, groupConfigNode, item, item, gPropList, levelNodes, parentId);
+			groupCreated = aGroupWasCreated ? aGroupWasCreated : groupCreated;
+		}
+		if (!groupCreated) {
+			let tmpNode = cloneDeep(configNode);
+			processObjIndex(tmpNode, item, null, parentId, null, null, false);
+			levelNodes.push(tmpNode);
+			let newChildNodes = [];
+			for (let childNodeIdx = 0, numOfChildNodes = tmpNode.children.length; childNodeIdx < numOfChildNodes; childNodeIdx++) {
+				let childConfigNode = tmpNode.children[childNodeIdx];
+				let propToGetRecords = childConfigNode.properties.catalogObjectKey;
+				if (propToGetRecords && propToGetRecords != null && item.hasOwnProperty(propToGetRecords)) {
+					let newResultSet = item[propToGetRecords];
+					if (newResultSet && newResultSet != null) if (Array.isArray(newResultSet)) newChildNodes.push(...constructDynamicNodeGroups2(newResultSet, childConfigNode, tmpNode.id));
+					else {
+						let tmpNewResultSet = [];
+						tmpNewResultSet.push(newResultSet);
+						newChildNodes.push(...constructDynamicNodeGroups2(newResultSet, childConfigNode, tmpNode.id));
+					}
+				}
+			}
+			tmpNode.children = newChildNodes;
+		}
+	}
+	levelNodes.sort(CompareSiblingNodes);
+	return levelNodes;
+};
+const transformMenuPageTree = (node) => {
+	if (!node?.menuItemInstance?.isActive) return null;
+	const parameters = node.menuItemInstance?.parameters && JSON.parse(node.menuItemInstance.parameters);
+	const label = node.title || "";
+	const expanded = parameters?.defaultDisplay === "expanded";
+	const updatedNode = {
+		id: node.menuStructureId,
+		parentId: node.parentId,
+		isExpanded: expanded,
+		properties: {
+			defaultIcon: {
+				type: "",
+				name: parameters.FluentIcon,
+				color: ""
+			},
+			nodeLabel: label,
+			nodeSubLabel: "",
+			page: {
+				id: parameters.PageId,
+				entity: { entityName: parameters.entityName },
+				pbiReportCode: parameters.pbiReportCode,
+				udpTagId: parameters.udpTagId,
+				queryId: parameters.queryId,
+				inquiryTreeId: parameters?.InquiryTreeId,
+				requiredFieldMapping: parameters?.requiredFieldMapping
+			},
+			aggregateThresholdId: parameters.aggregateThresholdId || ""
+		},
+		children: []
+	};
+	for (const child of node.menuItemInstanceStructures) {
+		const updatedChild = transformMenuPageTree(child);
+		if (updatedChild) updatedNode.children.push(updatedChild);
+	}
+	return updatedNode;
+};
+const mapNodeObjValuesToSearchParameters = (nodeObj, aggregateThresholdParamMappings) => {
+	if (!aggregateThresholdParamMappings || !nodeObj) return {};
+	const mappings = { ...aggregateThresholdParamMappings };
+	Object.keys(mappings).forEach((key) => {
+		const nodeObjKey = mappings[key];
+		if (nodeObjKey) {
+			const nodeObjValue = nodeObj[nodeObjKey];
+			mappings[key] = nodeObjValue || "";
+		}
+	});
+	return mappings;
+};
+const getSearchValueString = (nodeObj, searchIdentifier) => {
+	const searchIdentifiers = searchIdentifier.split(",");
+	const searchValues = [];
+	searchIdentifiers.forEach((searchIdentifier$1) => {
+		searchValues.push(nodeObj[searchIdentifier$1]);
+	});
+	return searchValues.toString();
+};
+
+//#endregion
+//#region src/utilities/iconLibrary/UnityIconLibrary.jsx
+const unityIcons = [{
+	id: "WaterDropIcon",
+	label: "Water Drop",
+	icon: /* @__PURE__ */ React.createElement(WaterDrop, null),
+	type: "unity"
+}, {
+	id: "SewerIcon",
+	label: "Sewer",
+	icon: /* @__PURE__ */ React.createElement(Sewer, null),
+	type: "unity"
+}];
+const getUnityIconFromName = (name) => {
+	const foundIcon = unityIcons.find((icon) => icon.id === name);
+	return foundIcon?.icon || null;
+};
+
+//#endregion
+//#region src/shell/ui/SidebarCollapseButton.jsx
+const useStyles$6 = makeStyles((theme) => ({
+	root: {
+		display: "flex",
+		justifyContent: "flex-start",
+		height: 48,
+		width: "100%",
+		paddingLeft: 0
+	},
+	iconButton: {
+		width: 48,
+		height: 48,
+		marginLeft: 16 - 24 / 2
+	},
+	expanded: {},
+	icon: {
+		width: 14,
+		height: 14,
+		margin: 8 / 2,
+		transition: theme?.transitions?.create("transform", {
+			easing: theme?.transitions?.easing?.sharp,
+			duration: theme?.transitions?.duration?.shortest
+		}),
+		"$expanded &": { transform: "scaleX(-1)" }
+	},
+	switch: {
+		margin: 8 / 2,
+		transition: theme?.transitions?.create("transform", {
+			easing: theme?.transitions?.easing?.sharp,
+			duration: theme?.transitions?.duration?.shortest
+		}),
+		"$expanded &": { transform: "scaleX(-1)" }
+	}
+}), { name: "SidebarCollapseButton" });
+/**
+* Custom styled button used for expanding/collapsing sidebars
+*/
+const SidebarCollapseButton = (props) => {
+	const classes = useStyles$6(props);
+	const { expanded, className, id, udprecordid,...other } = props;
+	const { t } = useTranslation();
+	return /* @__PURE__ */ React.createElement("div", {
+		...other,
+		className: clsx(className, classes.root, { [classes.expanded]: expanded })
+	}, /* @__PURE__ */ React.createElement(FluentIconButton, {
+		id,
+		udprecordid,
+		color: "inherit",
+		className: clsx(classes.iconButton, classes.switch),
+		"aria-label": expanded ? t("mainMenuAria.collapseNavigation") : t("mainMenuAria.expandNavigation"),
+		icon: ChevronRightIcon
+	}));
+};
+
+//#endregion
+//#region src/UI/inputs/buttons/AmbientCardButton.jsx
+const useStyles$5 = makeStyles((theme) => ({ root: {
+	borderRadius: 0,
+	padding: 8
+} }));
+const AmbientCardButton = (props) => {
+	const classes = useStyles$5(props);
+	const { editOption, launchOption, deleteOption, children,...otherProps } = props;
+	return /* @__PURE__ */ React.createElement(Button, {
+		classes: { root: classes.root },
+		variant: "outlined",
+		disableElevation: true,
+		color: "primary",
+		...otherProps
+	}, editOption && /* @__PURE__ */ React.createElement(EditIcon, null), launchOption && /* @__PURE__ */ React.createElement(ArrowUpRightIcon, null), deleteOption && /* @__PURE__ */ React.createElement(DeleteIcon, null), children);
+};
+AmbientCardButton.propTypes = {
+	editOption: PropTypes.bool,
+	launchOption: PropTypes.bool,
+	deleteOption: PropTypes.bool,
+	children: PropTypes.string
+};
+
+//#endregion
+//#region src/UI/components/feedback/Adornment.jsx
+const useStyles$4 = makeStyles((theme) => ({ root: (props) => ({
+	width: theme.spacing(.5),
+	height: "100%",
+	background: theme.palette[props.color].main
+}) }));
+const Adornment = (props) => {
+	const classes = useStyles$4(props);
+	return /* @__PURE__ */ React.createElement("div", { className: classes.root });
+};
+Adornment.propTypes = { color: PropTypes.string };
+
+//#endregion
+//#region src/UI/surfaces/cards/AmbientCard.jsx
+const useStyles$3 = makeStyles((theme) => ({
+	root: {},
+	paper: {
+		width: "100%",
+		position: "relative",
+		display: "flex",
+		flexDirection: "column",
+		height: (props) => props?.cardHeight ?? ""
+	},
+	adornment: {
+		top: 0,
+		left: 0,
+		height: "100%",
+		position: "absolute"
+	},
+	launchButtons: {
+		padding: theme.spacing(0, 2, 2, 2),
+		display: "flex",
+		justifyContent: "flex-end",
+		bottom: (props) => props.adjustBaseline ? props.adjustBaseline : 16,
+		right: theme.spacing(2),
+		gridGap: theme.spacing(1)
+	},
+	moreButton: {
+		marginTop: theme.spacing(1),
+		display: "flex",
+		justifyContent: "center",
+		backgroundColor: lighten(theme.palette.secondary.main, .9),
+		padding: theme.spacing(1)
+	},
+	styleWidth: {
+		width: (props) => !props?.fullWidth ? "75%" : "100%",
+		height: "100%"
+	},
+	media: { height: (props) => props.mediaHeight || 120 },
+	cardContent: {
+		flexGrow: 1,
+		padding: (props) => props.removePadding && 0,
+		"&:last-child": { paddingBottom: (props) => props.lastChildBottomPadding ? props.lastChildBottomPadding : theme.spacing(2) },
+		paddingTop: 0,
+		height: (props) => props.cardContentHeight ? props.cardContentHeight : ""
+	},
+	titleWrapper: {
+		display: "flex",
+		backgroundColor: (props) => props.headerColor && getEllipseColor(theme, props.headerColor, "light")
+	},
+	title: { color: (props) => props.headerColor && theme.palette.getContrastText(getEllipseColor(theme, props.headerColor, "light")) },
+	loading: {
+		position: "absolute",
+		top: 0,
+		left: 0
+	},
+	expandMessage: { display: "flex" },
+	cardRoot: { "&:last-child": { paddingBottom: theme.spacing(2) } },
+	visualization: {
+		display: "flex",
+		alignItems: "flex-end",
+		width: "100%",
+		height: 300
+	},
+	titlesWrapper: {
+		display: "flex",
+		flexDirection: "column",
+		flex: 1,
+		lineHeight: (props) => props.globalExpanded && "125%"
+	},
+	collapseChildren: {
+		flexGrow: 1,
+		"& .MuiCollapse-wrapper": { height: "100%" },
+		"& .MuiCollapse-wrapperInner": { height: "100%" },
+		height: (props) => props.cardContentHeight ? props.cardContentHeight : ""
+	}
+}));
+const AmbientCard = (props) => {
+	const classes = useStyles$3(props);
+	const [expanded, setExpanded] = useState(false);
+	const { adornment = "secondary", ariaLabel, baseLoading, cardHeight, children, collapseChildrenWhenExpanded, customAdornment = " ", deleteEvent, deleteOption, editEvent, editOption, extendedContent, extendedList, fullWidth, globalToggle, header, image, imageTitle, label, large, launchEvent, launchOption, loading, mediaHeight, more, moreMessage, moreButton, moreButtonExpanded, noAdornment = false, overrideStatusSuccess, overrideStatusError, overrideStatusWarning, overrideStatusInfo, removeTopLayoutUnit, status, subCard, title, toggleGlobalExpanded = true, visualization, subtitle,...otherProps } = props;
+	const [globalExpanded, setGlobalExpanded] = useState(toggleGlobalExpanded);
+	return !baseLoading && /* @__PURE__ */ React.createElement(Paper, {
+		elevation: 0,
+		className: classes.paper
+	}, !noAdornment && /* @__PURE__ */ React.createElement("div", { className: classes.adornment }, customAdornment ? customAdornment : /* @__PURE__ */ React.createElement(Adornment, { color: adornment })), title && /* @__PURE__ */ React.createElement(CardContent, {
+		className: classes.titleWrapper,
+		classes: { root: classes.cardRoot }
+	}, /* @__PURE__ */ React.createElement("div", { className: classes.titlesWrapper }, /* @__PURE__ */ React.createElement(Typography, {
+		className: classes.title,
+		component: "h2",
+		variant: subCard ? "subtitle2" : "h6"
+	}, title), subtitle && /* @__PURE__ */ React.createElement(Typography, {
+		variant: "body1",
+		className: classes.title
+	}, subtitle)), status && /* @__PURE__ */ React.createElement(StatusChip, {
+		status,
+		label,
+		success: overrideStatusSuccess,
+		error: overrideStatusError,
+		warning: overrideStatusWarning,
+		info: overrideStatusInfo
+	}), globalToggle && /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(FluentIconButton, {
+		onClick: () => setGlobalExpanded(!globalExpanded),
+		icon: globalExpanded ? ChevronUpIcon : ChevronDownIcon,
+		className: classes.icon,
+		id: "udpRecord-AmbientCard-Toggle-" + (globalExpanded ? "Up" : "Down"),
+		udprecordid: "udpRecord-AmbientCard-Toggle-" + (globalExpanded ? "Up" : "Down")
+	}))), image && /* @__PURE__ */ React.createElement(CardMedia, {
+		className: classes.media,
+		image,
+		title: imageTitle
+	}), globalExpanded && /* @__PURE__ */ React.createElement(CardContent, { classes: { root: classes.cardContent } }, !image && !header && !removeTopLayoutUnit && /* @__PURE__ */ React.createElement(LayoutUnit, { unit: large ? "md" : "xxs" }), image && /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "xs" }), /* @__PURE__ */ React.createElement(Collapse, {
+		in: !collapseChildrenWhenExpanded || !expanded,
+		timeout: "auto",
+		className: classes.collapseChildren
+	}, /* @__PURE__ */ React.createElement("div", { className: classes.styleWidth }, children)), extendedList && /* @__PURE__ */ React.createElement(Collapse, {
+		in: expanded,
+		timeout: "auto"
+	}, /* @__PURE__ */ React.createElement("div", null, extendedList)), more && /* @__PURE__ */ React.createElement("div", { className: classes.moreButton }, /* @__PURE__ */ React.createElement("div", { className: classes.expandMessage }, /* @__PURE__ */ React.createElement(Typography, {
+		style: {
+			marginTop: 4,
+			marginRight: 16
+		},
+		variant: "subtitle2"
+	}, !expanded && moreMessage), /* @__PURE__ */ React.createElement(FluentButton, {
+		onClick: () => setExpanded(!expanded),
+		color: "secondary",
+		variant: "outlined"
+	}, expanded ? moreButtonExpanded : moreButton)))), visualization && /* @__PURE__ */ React.createElement("div", { className: classes.visualization }, visualization), !globalToggle && (editOption || launchOption || deleteOption) && /* @__PURE__ */ React.createElement("div", { className: classes.launchButtons }, editOption && /* @__PURE__ */ React.createElement(AmbientCardButton, {
+		"aria-label": ariaLabel,
+		editOption: true,
+		...otherProps,
+		onClick: editEvent,
+		id: "udpRecord-AmbientCard-edit",
+		udprecordid: "udpRecord-AmbientCard-edit"
+	}), launchOption && /* @__PURE__ */ React.createElement(AmbientCardButton, {
+		"aria-label": ariaLabel,
+		launchOption: true,
+		...otherProps,
+		onClick: launchEvent,
+		id: "udpRecord-AmbientCard-launch",
+		udprecordid: "udpRecord-AmbientCard-launch"
+	}), deleteOption && /* @__PURE__ */ React.createElement(AmbientCardButton, {
+		"aria-label": ariaLabel,
+		deleteOption: true,
+		...otherProps,
+		onClick: deleteEvent,
+		id: "udpRecord-AmbientCard-delete",
+		udprecordid: "udpRecord-AmbientCard-delete"
+	})));
+};
+
+//#endregion
+//#region src/UI/feedback/NodeLoader.jsx
+const useStyles$2 = makeStyles((theme) => ({
+	root: {},
+	nodeWrapper: { display: "flex" }
+}));
+const NodeLoader = ({ loading, nodesRequested = [1] }) => {
+	const classes = useStyles$2();
+	const singleNode = [
+		1,
+		2,
+		3,
+		4
+	];
+	const NodeElement = () => {
+		return /* @__PURE__ */ React.createElement("div", { className: classes.nodeWrapper }, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement(Skeleton$1, {
+			variant: "circle",
+			width: 20,
+			height: 20
+		})), /* @__PURE__ */ React.createElement("div", { style: {
+			marginLeft: 8,
+			width: "100%"
+		} }, /* @__PURE__ */ React.createElement(Skeleton$1, {
+			height: 20,
+			variant: "rect",
+			width: "100%"
+		})));
+	};
+	const NodeGroup = ({ indent }) => {
+		return /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("div", { style: { marginLeft: indent } }, /* @__PURE__ */ React.createElement(NodeElement, null)), /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "xxs" }));
+	};
+	const singleNodeGroup = loading && /* @__PURE__ */ React.createElement("div", null, singleNode.map((item, index) => {
+		return /* @__PURE__ */ React.createElement(NodeGroup, { indent: index * 8 });
+	}));
+	return /* @__PURE__ */ React.createElement("div", null, nodesRequested && nodesRequested.map((item) => {
+		return /* @__PURE__ */ React.createElement("div", { className: classes.root }, singleNodeGroup, " ", /* @__PURE__ */ React.createElement(LayoutUnit, { unit: "xxs" }));
+	}));
+};
+
+//#endregion
+//#region src/models/NumberOperator.ts
+let NumberOperatorEnums = /* @__PURE__ */ function(NumberOperatorEnums$1) {
+	NumberOperatorEnums$1["Equals"] = "=";
+	NumberOperatorEnums$1["Does_Not_Equal"] = "!=";
+	NumberOperatorEnums$1["Greater_Than"] = ">";
+	NumberOperatorEnums$1["Less_Than"] = "<";
+	NumberOperatorEnums$1["Greater_Than_Or_Equal_To"] = ">=";
+	NumberOperatorEnums$1["Less_Than_Or_Equal_To"] = "<=";
+	NumberOperatorEnums$1["Between"] = "BETWEEN";
+	return NumberOperatorEnums$1;
+}({});
+
+//#endregion
+//#region src/UI/utilityDisplay/utilities/aggregateUtils.js
+const getThresholdStatus = (aggThreshold, aggregateValue) => {
+	if (!aggThreshold || !aggregateValue) return null;
+	const thresholdTypes = [
+		{
+			type: SeverityTypeEnums.Success,
+			threshold: aggThreshold.successThreshold
+		},
+		{
+			type: SeverityTypeEnums.Error,
+			threshold: aggThreshold.errorThreshold
+		},
+		{
+			type: SeverityTypeEnums.Warning,
+			threshold: aggThreshold.warningThreshold
+		},
+		{
+			type: SeverityTypeEnums.Info,
+			threshold: aggThreshold.infoThreshold
+		}
+	];
+	let thresholdStatus = "";
+	for (const { type, threshold } of thresholdTypes) if (threshold && evaluateThreshold(threshold, aggregateValue)) {
+		thresholdStatus = type;
+		break;
+	}
+	return thresholdStatus;
+};
+const evaluateThreshold = (threshold = {}, aggregateValue) => {
+	if (typeof threshold === "string") try {
+		threshold = JSON.parse(threshold);
+	} catch {
+		console.error(`Could not parse: ${threshold}`);
+		return false;
+	}
+	const { operator, value1, value2 } = threshold;
+	let thresholdMet = false;
+	switch (operator) {
+		case NumberOperatorEnums.Equals:
+			thresholdMet = aggregateValue === parseFloat(value1);
+			break;
+		case NumberOperatorEnums.Does_Not_Equal:
+			thresholdMet = aggregateValue !== parseFloat(value1);
+			break;
+		case NumberOperatorEnums.Greater_Than:
+			thresholdMet = aggregateValue > parseFloat(value1);
+			break;
+		case NumberOperatorEnums.Less_Than:
+			thresholdMet = aggregateValue < parseFloat(value1);
+			break;
+		case NumberOperatorEnums.Greater_Than_Or_Equal_To:
+			thresholdMet = aggregateValue >= parseFloat(value1);
+			break;
+		case NumberOperatorEnums.Less_Than_Or_Equal_To:
+			thresholdMet = aggregateValue <= parseFloat(value1);
+			break;
+		case NumberOperatorEnums.Between:
+			thresholdMet = aggregateValue >= parseFloat(value1) && aggregateValue <= parseFloat(value2);
+			break;
+		default: break;
+	}
+	return thresholdMet;
+};
+
+//#endregion
+//#region src/UI/dataDisplay/entityHeader/ui/AlertPill.jsx
+/**
+* Styles for the AlertPill component
+*/
+const useStyles$1 = makeStyles((theme) => {
+	const endRadius = theme.spacing(3);
+	return {
+		root: {
+			display: "flex",
+			flexDirection: "row",
+			overflow: "hidden",
+			flexGrow: 0,
+			alignSelf: "start"
+		},
+		alertRoot: {
+			padding: theme.spacing(0, 1.5, 0, 1),
+			borderRadius: 0,
+			"&:first-of-type": {
+				borderTopLeftRadius: endRadius,
+				borderBottomLeftRadius: endRadius
+			},
+			"&:last-of-type": {
+				borderTopRightRadius: endRadius,
+				borderBottomRightRadius: endRadius
+			}
+		},
+		alertIcon: { marginRight: theme.spacing(.5) },
+		buttonBase: {
+			borderRadius: endRadius,
+			overflow: "hidden"
+		},
+		defaultSeverityAlert: { backgroundColor: theme.palette.grey[400] }
+	};
+});
+/**
+* Memoized version of the Alert component
+*
+* @param {object} props - Component props
+* @param {number} props.count - The count to display in the Alert
+* @param {boolean} props.hide - Whether the Alert should be hidden
+* @param {string} props.severity - The severity of the Alert
+* @param {object} props.alertProps - Additional props to pass to the Alert component
+* @param {number} props.maxCount - Max count to show before displaying as "{maxCount}+"
+* @returns {JSX.Element | null} - The Alert component, or null if the count is falsy or hide is true
+*/
+const MemoizedAlert = memo((props) => {
+	const { count, hide, severity, alertProps, maxCount, label } = props;
+	const classes = useStyles$1(props);
+	if (count && !hide) {
+		let displayCount = count;
+		if (maxCount && count > maxCount) displayCount = `${maxCount}+`;
+		if (severity === SeverityTypeEnums.Default) return /* @__PURE__ */ React.createElement(Alert, {
+			severity: SeverityTypeEnums.Info,
+			...alertProps,
+			className: classes.defaultSeverityAlert
+		}, displayCount);
+		return /* @__PURE__ */ React.createElement(Alert, {
+			severity,
+			...alertProps
+		}, label ? label : displayCount);
+	}
+	return null;
+});
+MemoizedAlert.displayName = "MemoizedAlert";
+/**
+* The AlertPill component displays a row of Alerts, each with a count and a severity level.
+* Alerts can be hidden by setting the corresponding hide prop to true.
+*
+* @param {object} props - Component props
+* @param {function} [props.handleClick] - The click event handler.
+* @param {number} props.maxCount - Max count to show before displaying as "{maxCount}+"
+* @param {number} props.errorCount - The count for the error Alert
+* @param {number} props.warningCount - The count for the warning Alert
+* @param {number} props.successCount - The count for the success Alert
+* @param {number} props.infoCount - The count for the info Alert
+* @param {number} props.defaultCount - The count for the default Alert
+* @param {string} props.errorLabel - The label for the error Alert
+* @param {string} props.warningLabel - The label for the warning Alert
+* @param {string} props.successLabel - The label for the success Alert
+* @param {string} props.infoLabel - The label for the info Alert
+* @param {string} props.defaultLabel - The label for the default Alert
+* @param {boolean} props.hideError - Whether the error Alert should be hidden
+* @param {boolean} props.hideWarning - Whether the warning Alert should be hidden
+* @param {boolean} props.hideSuccess - Whether the success Alert should be hidden
+* @param {boolean} props.hideInfo - Whether the info Alert should be hidden
+* @param {boolean} props.hideDefault - Whether the default Alert should be hidden
+* @param {string} props.variant - The variant of the Alert
+* @param {function} [props.handleClick] - The click event handler.
+* @param {number} props.maxCount - Max count to show before displaying as "{maxCount}+"
+* @returns {JSX.Element} - The AlertPill component
+*/
+const AlertPill = (props) => {
+	const { variant = "filled", handleClick, maxCount, errorCount, warningCount, successCount, infoCount, defaultCount, errorLabel, warningLabel, successLabel, infoLabel, defaultLabel, hideError = false, hideWarning = false, hideSuccess = false, hideInfo = false, hideDefault = false } = props;
+	const classes = useStyles$1(props);
+	const variantMapping = {
+		filled: "filled",
+		standard: "hint",
+		outlined: "outlined",
+		text: ""
+	};
+	const alertProps = {
+		variant: variantMapping[variant],
+		classes: {
+			root: classes.alertRoot,
+			icon: classes.alertIcon
+		}
+	};
+	return /* @__PURE__ */ React.createElement("div", { className: classes.root }, /* @__PURE__ */ React.createElement(ButtonBase, {
+		onClick: handleClick,
+		className: classes.buttonBase
+	}, /* @__PURE__ */ React.createElement(MemoizedAlert, {
+		count: errorCount,
+		hide: hideError,
+		severity: SeverityTypeEnums.Error,
+		alertProps,
+		maxCount,
+		label: errorLabel
+	}), /* @__PURE__ */ React.createElement(MemoizedAlert, {
+		count: warningCount,
+		hide: hideWarning,
+		severity: SeverityTypeEnums.Warning,
+		alertProps,
+		maxCount,
+		label: warningLabel
+	}), /* @__PURE__ */ React.createElement(MemoizedAlert, {
+		count: successCount,
+		hide: hideSuccess,
+		severity: SeverityTypeEnums.Success,
+		alertProps,
+		maxCount,
+		label: successLabel
+	}), /* @__PURE__ */ React.createElement(MemoizedAlert, {
+		count: infoCount,
+		hide: hideInfo,
+		severity: SeverityTypeEnums.Info,
+		alertProps,
+		maxCount,
+		label: infoLabel
+	}), /* @__PURE__ */ React.createElement(MemoizedAlert, {
+		count: defaultCount,
+		hide: hideDefault,
+		severity: SeverityTypeEnums.Default,
+		alertProps,
+		maxCount,
+		label: defaultLabel
+	})));
+};
+
+//#endregion
+//#region src/UI/utilityDisplay/AggregateChip.jsx
+const AggregateChip = (props) => {
+	const { aggregateThresholdId, aggregateThresholdParamMappings, label, chipColor, setStatus, isActionable = false, isAlert = false, hideAlert = false, onAlertClick } = props;
+	const [color, setColor] = useState(chipColor);
+	const [aggregateValue, setAggregateValue] = useState(null);
+	const [loading, setLoading] = useState(false);
+	const [{ data: aggregateThreshold, loading: loadingAggregateThreshold }] = useAxiosGet(ConfigService.integrationV2ApiUrl, `aggregateThreshold/${aggregateThresholdId}`, {}, !!!aggregateThresholdId);
+	const alertDisplayLabel = useMemo(() => {
+		if (!label) return aggregateValue;
+		return `${label.replace("{value}", aggregateValue)}`;
+	}, [aggregateValue, label]);
+	useEffect(() => {
+		const setAggregateData = async (apiMethodInstanceId, valueKey) => {
+			setLoading(true);
+			const data = aggregateThresholdParamMappings ? { data: aggregateThresholdParamMappings } : { data: {} };
+			const response = await executeQueryInstance(data, apiMethodInstanceId).catch((res) => setLoading(false));
+			if (response?.status === 200 && valueKey) {
+				const aggregateResult = response.data?.aggregateResults && response.data?.aggregateResults[0];
+				if (aggregateResult) setAggregateValue(aggregateResult[valueKey] ? Math.round(aggregateResult[valueKey]) : "");
+			}
+			setLoading(false);
+		};
+		if (aggregateThreshold) setAggregateData(aggregateThreshold.apiMethodInstanceId, aggregateThreshold.aggregateKey);
+	}, [aggregateThreshold]);
+	useEffect(() => {
+		if (aggregateThreshold && aggregateValue) {
+			const status = getThresholdStatus(aggregateThreshold, aggregateValue);
+			setColor(status);
+			if (setStatus) setStatus(status || "default");
+		}
+	}, [
+		aggregateThreshold,
+		aggregateValue,
+		setStatus
+	]);
+	if (loading || loadingAggregateThreshold) return /* @__PURE__ */ React.createElement(CircularProgress, { size: 18 });
+	if (!color && !isAlert) return /* @__PURE__ */ React.createElement(Typography, {
+		variant: "caption2",
+		style: { fontSize: "0.7rem" }
+	}, label || aggregateValue);
+	if (isAlert) return /* @__PURE__ */ React.createElement(AlertPill, {
+		handleClick: onAlertClick,
+		successCount: color === SeverityTypeEnums.Success ? aggregateValue : "",
+		errorCount: color === SeverityTypeEnums.Error ? aggregateValue : "",
+		warningCount: color === SeverityTypeEnums.Warning ? aggregateValue : "",
+		infoCount: color === SeverityTypeEnums.Info ? aggregateValue : "",
+		defaultCount: !color && (aggregateValue || ""),
+		successLabel: color === SeverityTypeEnums.Success ? alertDisplayLabel : "",
+		errorLabel: color === SeverityTypeEnums.Error ? alertDisplayLabel : "",
+		warningLabel: color === SeverityTypeEnums.Warning ? alertDisplayLabel : "",
+		infoLabel: color === SeverityTypeEnums.Info ? alertDisplayLabel : "",
+		defaultLabel: !color && (alertDisplayLabel || ""),
+		hideSuccess: color === SeverityTypeEnums.Success ? hideAlert : false,
+		hideError: color === SeverityTypeEnums.Error ? hideAlert : false,
+		hideWarning: color === SeverityTypeEnums.Warning ? hideAlert : false,
+		hideInfo: color === SeverityTypeEnums.Info ? hideAlert : false,
+		hideDefault: !color ? hideAlert : false
+	});
+	return label || aggregateValue ? /* @__PURE__ */ React.createElement(StatusChip, {
+		label: label || aggregateValue,
+		status: color,
+		useSmallChip: true,
+		isActionable
+	}) : null;
+};
+AggregateChip.prototype = {
+	chipColor: PropTypes.oneOf([
+		"success",
+		"error",
+		"warning",
+		"info",
+		void 0,
+		null
+	]),
+	aggregateThresholdId: PropTypes.oneOf([
+		PropTypes.string,
+		void 0,
+		null
+	])
+};
+
+//#endregion
+//#region src/utilities/utilityBar/UtilityBarInport.jsx
+const UtilityBarInports = createTeleporter({ multiSources: true });
+/**
+* @param {any} props
+*/
+function UtilityBarInportTarget(props) {
+	return /* @__PURE__ */ React.createElement(UtilityBarInports.Target, props);
+}
+/**
+* Places a Control in the App SubHeader
+*/
+const UtilityBarInport = (props) => {
+	const { children, className,...buttonProps } = props;
+	return /* @__PURE__ */ React.createElement(UtilityBarInports.Source, null, children);
+};
+
+//#endregion
+//#region src/UI/utilityDisplay/UtilitySideBar.jsx
+const EXPANDED_WIDTH = 288;
+const COLLAPSED_WIDTH = 78;
+const MAX_WIDTH = 700;
+const useStyles = makeStyles((theme) => ({
+	root: {
+		paddingTop: (props) => props.removePadding || props.sidebarHidden ? 0 : 40,
+		overflow: "hidden",
+		height: "100%"
+	},
+	titleWrapper: {
+		display: (props) => props.hideTitleBar ? "none" : "flex",
+		width: "100%",
+		paddingLeft: theme.spacing(1)
+	},
+	button: { marginTop: -8 },
+	title: {
+		flex: 1,
+		width: "100%",
+		marginTop: 8
+	},
+	expandedWidth: { width: 288 },
+	handle: {
+		top: 0,
+		right: theme.spacing(-.75),
+		width: theme.spacing(.75),
+		zIndex: 1e4,
+		height: "calc(100vh - 56px)",
+		display: "inline-block",
+		position: "absolute",
+		"&:hover": { cursor: "col-resize" }
+	}
+}));
+const UtilitySideBar = (props) => {
+	const { onUtilitySidebarToggleExpandClick, resizable, title, utilitySidebarToggleOverride, isUsingChildren = false, removeTopLayoutUnit = false, collapsedWidth, children, sidebarHidden, handleResize = null, hideTitleBar } = props;
+	const buildEnv = useBuildEnvironment();
+	const classes = useStyles({
+		...props,
+		appRibbbonSpace: buildEnv ? APP_RIBBON_SPACE : 0
+	});
+	const [expanded, setExpanded] = useState(true);
+	const [width, setWidth] = useState(EXPANDED_WIDTH);
+	const _collapsedWidth = collapsedWidth ?? COLLAPSED_WIDTH;
+	const theme = useTheme();
+	const onResize = (event, { element, size, handle }) => {
+		setWidth(size.width);
+		if (handleResize) handleResize(size.width);
+	};
+	const handleToggleClick = useCallback(() => {
+		if (onUtilitySidebarToggleExpandClick) onUtilitySidebarToggleExpandClick();
+		setExpanded((expanded$1) => !expanded$1);
+	}, [onUtilitySidebarToggleExpandClick]);
+	useEffect(() => {
+		if (typeof utilitySidebarToggleOverride === "boolean") setExpanded(utilitySidebarToggleOverride);
+	}, [utilitySidebarToggleOverride]);
+	return /* @__PURE__ */ React.createElement(ResizableBox, {
+		width: expanded ? width : _collapsedWidth,
+		resizeHandles: resizable && expanded ? ["e"] : [],
+		axis: "x",
+		minConstraints: expanded ? [EXPANDED_WIDTH] : [_collapsedWidth],
+		maxConstraints: [MAX_WIDTH],
+		onResize,
+		handle: expanded && /* @__PURE__ */ React.createElement("div", { className: classes.handle }),
+		style: { position: "relative" }
+	}, /* @__PURE__ */ React.createElement("div", {
+		className: classes.root,
+		style: { width: expanded ? width : _collapsedWidth }
+	}, /* @__PURE__ */ React.createElement(AmbientCard, {
+		fullWidth: true,
+		removePadding: true,
+		lastChildBottomPadding: 12,
+		removeTopLayoutUnit: removeTopLayoutUnit || sidebarHidden
+	}, /* @__PURE__ */ React.createElement("div", { style: {
+		display: hideTitleBar ? "none" : "flex",
+		width: "100%",
+		paddingLeft: theme.spacing(1)
+	} }, /* @__PURE__ */ React.createElement("div", { className: classes.title }, expanded && /* @__PURE__ */ React.createElement(Typography, { variant: "h6" }, " ", title, " ")), /* @__PURE__ */ React.createElement("div", { className: classes.button }, /* @__PURE__ */ React.createElement(SidebarCollapseButton, {
+		id: "udpRecord-UtilitySideBar",
+		udprecordid: "udpRecord-UtilitySideBar",
+		expanded,
+		onClick: handleToggleClick
+	}))), !isUsingChildren && /* @__PURE__ */ React.createElement(UtilityBarInportTarget, null), isUsingChildren && children)));
+};
+
+//#endregion
+export { Adornment, AggregateChip, AlertPill, AmbientCard, AmbientCardButton, GroupNode, NodeLoader, SidebarCollapseButton, UtilityBarInport, UtilityBarInportTarget, UtilitySideBar, checkNodeIsHidden, collapseAllNodes, constructBusinessObjectArrFromTree, constructDynamicNodeGroups, constructDynamicNodeGroups2, constructPreloadedTree, constructStaticNodeGroups, deleteNode, deleteNodeAndChildren, evaluateRule, expandAllNodes, findAllParentIds, findLastNode, findNodeById, findNodeByIdAndLabel, findNodesByIdAndLabel, formatTreeLabel, formatTreeMenuItem, getAllChildrenNodesToDelete, getDisplayDetails, getDisplayName, getHeaderTitle, getIconFromName, getLazyLoadChildrenArr, getNodeIdForRightBorder, getOrderedDynamicGroups, getPropertyMappingList, getPropertyMappingObj, getSearchValueString, getUnityIconFromName, makeDynamicGroupStructures, makeDynamicTreeStructure, makeTreeStaticGroupStructure, makeTreeStructure, mapNodeGroupChildren, mapNodeObjValuesToSearchParameters, mapRule, mapRuleData, processCatalogObjectKeysInOrder, processItemForDynamicNodeGroups, processItemForStaticNodeGroup, processObjIndex, processObjectToTree, processOrderedTreeData, processReferences, searchForMatchingNode, searchTree, transformMenuPageTree, unityIcons, updateTreeIds };
+//# sourceMappingURL=UtilitySideBar-B4r2IAv5.js.map