@equinor/echo-framework 2.3.0 → 2.4.1

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@equinor/echo-framework",
-  "version": "2.3.0",
+  "version": "2.4.1",
   "peerDependencies": {
-    "@equinor/echo-base": ">= 2.3.0 < 3.0.0",
-    "@equinor/echo-components": ">= 2.3.0 < 3.0.0",
-    "@equinor/echo-core": ">= 2.3.0 < 3.0.0",
-    "@equinor/echo-search": ">= 2.3.0 < 3.0.0",
-    "@equinor/echo-utils": ">= 2.3.0 < 3.0.0",
+    "@equinor/echo-base": ">= 2.4.1 < 3.0.0",
+    "@equinor/echo-components": ">= 2.4.1 < 3.0.0",
+    "@equinor/echo-core": ">= 2.4.1 < 3.0.0",
+    "@equinor/echo-search": ">= 2.4.1 < 3.0.0",
+    "@equinor/echo-utils": ">= 2.4.1 < 3.0.0",
     "@equinor/eds-core-react": "0.49.0",
     "@equinor/eds-icons": "0.22.0",
     "react": ">= 17.0.2",
@@ -18,8 +18,8 @@
     "lodash": "4.17.21",
     "react-router-dom": "5.3.4",
     "zustand": ">= 4.4.7 < 5",
-    "immer": "10.1.3",
-    "msw": "2.11.6"
+    "immer": "11.1.3",
+    "msw": "2.12.7"
   },
   "dependencies": {
     "dexie": "4.2.1",
@@ -28,6 +28,10 @@
     "ag-charts-react": "12.3.1",
     "ag-charts-enterprise": "12.3.1"
   },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./index.cjs.js"
+  },
   "main": "./index.cjs.js",
   "type": "commonjs",
   "types": "./index.d.ts"

package/src/index.d.ts

@@ -7,8 +7,9 @@ export { NotificationListItem } from './lib/components/notificationListItem';
 export type { NotificationListItemType } from './lib/components/notificationListItem';
 export { PrepviewButton } from './lib/components/prepviewButton/prepviewButton';
 export { useFetchPlantInfo } from './lib/components/requestAccess/hooks/fetchPlantInfo';
+export { MissingAccessInfoButton } from './lib/components/requestAccess/MissingAccessInfoButton';
+export { RequestAccessButton } from './lib/components/requestAccess/RequestAccessButton';
 export { RequestProCoSysAccess } from './lib/components/requestAccess/RequestProCoSysAccess';
-export { RequestSapAccess } from './lib/components/requestAccess/RequestSapAccess';
 export { WorkOrderListItem } from './lib/components/workOrderListItem';
 export type { WorkOrderListItemData } from './lib/components/workOrderListItem/types/types';
 export * from './lib/coreApplication';
@@ -28,7 +29,8 @@ export { PopoverLoading } from './lib/feature/legend/components/pdfMarkers/subCo
 export * from './lib/feature/legend/index';
 export { legendVisibleTagsSubscribeToStore } from './lib/feature/legend/stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore';
 export { knownLegendIds } from './lib/feature/legend/types/legendType';
-export type { LegendDataId, LegendEquipmentId, LegendState, LegendTagId } from './lib/feature/legend/types/legendType';
+export type { LegendDataId, LegendEquipmentId, LegendId, LegendState, LegendTagId } from './lib/feature/legend/types/legendType';
+export type { Brand } from '@equinor/echo-utils';
 export { getLatestMeasurementDate, sortMeasuringPointsByMeasurementDate } from './lib/feature/measuringPoint/components/measuringPoints.utils';
 export * from './lib/feature/measuringPoint/index';
 export * from './lib/feature/measuringPoint/types/measuringPoint';
@@ -59,7 +61,6 @@ export { createSimpleStore } from './lib/services/stores/createSimpleStore';
 export * from './lib/services/userSetting';
 export * from './lib/types/activeTag.types';
 export * from './lib/types/api-echohub';
-export { dataAccessLinks } from './lib/types/dataAccess/dataAccessLinks';
 export { DocType } from './lib/types/docType';
 export type { EchoHubPlant } from './lib/types/echoHubPlant';
 export * from './lib/types/eventTypes';
@@ -73,6 +74,9 @@ export { PingableSources } from './lib/types/pingableSources';
 export { SearchItemDetailsType as searchItemDetailsType } from './lib/types/searchItemDetailsType';
 export { allWorkOrderTypes, WorkOrderTypes } from './lib/types/workOrderTypes';
 export * from './lib/utils';
+export { IocAccessGuidanceSection, ProCoSysAccessGuidanceSection, SapAccessGuidanceSection } from './lib/utils/dataAccess/accessGuidanceSections';
+export type { AccessGuidanceSection } from './lib/utils/dataAccess/accessGuidanceSections';
+export { dataAccessLinks } from './lib/utils/dataAccess/dataAccessLinks';
 export { getPdmsPlantCodeForTag } from './lib/utils/getPdmsPlantCodeForTag';
 export { isImage, isVideo } from './lib/utils/mediaTypeUtils';
 export { convertPathNameToReadableString } from './lib/utils/moduleNameUtils';

package/src/lib/components/index.d.ts

@@ -20,6 +20,8 @@ export * from './prepview';
 export * from './prepviewButton/prepviewButton';
 export * from './projectSelector';
 export * from './realTimeData';
+export { MissingAccessInfoButton } from './requestAccess/MissingAccessInfoButton';
+export { RequestAccessButton } from './requestAccess/RequestAccessButton';
 export * from './router';
 export { SearchListItem } from './searchListItem/searchListItem';
 export * from './searchMenu';

package/src/lib/components/prepview/Prepview.d.ts

@@ -9,13 +9,23 @@ interface PrepviewProps {
     tagClicked: (tagId: string, instCode: string) => void;
     historicItemClicked?: (item: HistoricNotificationItem | HistoricWorkOrderItem | HistoricPunchItem, itemType: WorkItemType) => void;
     showLongTextClicked?: (id: string, type: WorkItemType, longText: string) => void;
+    openPrepviewCallback?: (args: {
+        prepviewInput: {
+            notificationId?: string;
+            workOrderId?: string;
+            punchId?: string;
+            instCode?: string;
+        };
+        panelKey?: string;
+        keepLastNavigationItem?: boolean;
+        allowToggle?: boolean;
+    }) => void;
     notificationId?: string;
     currentNotificationLegendOption?: SNBadgeType;
     workOrderId?: string;
     currentWorkOrderLegendOption?: WoBadgeType;
     workOrderOperationId?: string;
     workOrderDateType?: WorkOrderDateType;
-    objectNotificationClicked?: (notification: HistoricNotificationItem) => void;
     punchId?: string;
     instCode?: string;
     packageClicked?: (type: ItemTypes, itemNumber: string, projectNumber: string) => void;

package/src/lib/components/prepview/context/PrepviewContext.d.ts

@@ -9,9 +9,9 @@ interface PrepviewContext {
     historicItemClicked?: (item: HistoricNotificationItem | HistoricWorkOrderItem | HistoricPunchItem, itemType: WorkItemType) => void;
     showLongTextClicked?: (id: string, type: WorkItemType, longText: string) => void;
     currentNotificationLegendOption?: SNBadgeType;
+    openNotificationById?: (notificationId: string) => void;
     isWorkOrder: boolean;
     workOrderOperationId?: string;
-    objectNotificationClicked?: (notification: HistoricNotificationItem) => void;
     currentWorkOrderLegendOption?: WoBadgeType;
     instCode?: string;
     packageClicked?: (type: ItemTypes, itemNumber: string, projectNumber: string) => void;

package/src/lib/components/prepview/panels/objects/EquipmentListItem.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface EquipmentListItemProps {
+    readonly equipmentId: string;
+    readonly equipmentDescription: string | undefined;
+    readonly tagId: string | undefined;
+    readonly tagPlantId: string | undefined;
+}
+export declare const EquipmentListItem: React.FC<EquipmentListItemProps>;
+export {};

package/src/lib/components/prepview/panels/objects/NotificationListItem.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface NotificationListItemProps {
+    readonly notificationId: string;
+    readonly notificationTypeId: string;
+    readonly isActive: boolean;
+    readonly onNotificationClick: () => void;
+}
+export declare const NotificationListItem: React.FC<NotificationListItemProps>;
+export {};

package/src/lib/components/requestAccess/MissingAccessInfoButton.d.ts

@@ -0,0 +1,6 @@
+import { AccessGuidanceSection } from '../../utils/dataAccess/accessGuidanceSections';
+type MissingAccessInfoProps = {
+    accessGuidanceSection: AccessGuidanceSection;
+};
+export declare const MissingAccessInfoButton: React.FC<MissingAccessInfoProps>;
+export {};

package/src/lib/components/requestAccess/RequestAccessButton.d.ts

@@ -1,8 +1,9 @@
 import React from 'react';
+type RequestAccessButtonVariant = 'linkButton' | 'standaloneButton';
 interface Props {
     applyForAccessUrl: string;
     buttonLabel?: string;
-    className?: string;
+    variant?: RequestAccessButtonVariant;
     onClicked?: () => void;
 }
 export declare const RequestAccessButton: React.FC<React.PropsWithChildren<Props>>;

package/src/lib/components/requestAccess/RequestProCoSysAccess.d.ts

@@ -1,6 +1,5 @@
 import React from 'react';
 type RequestProCoSysAccessProps = {
-    className?: string;
     onClicked?: () => void;
     plantName?: string;
 };

package/src/lib/components/verticalTabsSplitView/VerticalTabsSplitView.d.ts

@@ -18,5 +18,5 @@ interface VerticalTabsSplitViewProps {
     infoLabelText?: string;
     actionRow?: React.ReactNode;
 }
-declare function VerticalTabsSplitView({ groups, listItemStyle, infoLabelText, actionRow, }: VerticalTabsSplitViewProps): import("react/jsx-runtime").JSX.Element;
+declare function VerticalTabsSplitView({ groups, listItemStyle, infoLabelText, actionRow }: VerticalTabsSplitViewProps): import("react/jsx-runtime").JSX.Element;
 export { VerticalTabsSplitView };

package/src/lib/coreApplication/EchoUserInterfaceStore.d.ts

@@ -1,15 +1,20 @@
 import { FunctionComponent } from 'react';
 import * as zustand from 'zustand';
+export type ProfileSettingsScrollTarget = 'dataAccess' | undefined;
 export interface EchoUiState {
     activeAppMenuItem: string;
     isLegendActive: boolean | undefined;
     activeTopMenuItem: string;
     activeTopMenuComponents: FunctionComponent[];
     moduleName: string;
+    isDataAccessSettingsExpanded: boolean;
+    profileSettingsScrollTarget: ProfileSettingsScrollTarget;
     updateActiveAppMenuItem: (newActiveAppMenuItem: string) => void;
     updateIsLegendActive: (isLegendActive: boolean) => void;
     updateActiveTopMenuItem: (newActiveTopMenuItem: string) => void;
     updateActiveTopMenuComponents: (newActiveTopMenuComponents: FunctionComponent[]) => void;
     updateModuleName: (newModuleName: string) => void;
+    updateIsDataAccessSettingsExpanded: (isDataAccessSettingsExpanded: boolean) => void;
+    updateProfileSettingsScrollTarget: (scrollTarget: ProfileSettingsScrollTarget) => void;
 }
 export declare const useEchoUserInterfaceStore: zustand.UseBoundStore<zustand.StoreApi<EchoUiState>>;

package/src/lib/feature/equipment/hooks/useEquipmentWithMeasuringPoints.d.ts

@@ -3,7 +3,7 @@ export declare function useEquipmentWithoutMeasuringPoints(equipmentId: string):
     status: 'error' | 'success' | 'pending';
     equipmentWithMeasuringPoints: EquipmentWithMeasuringPoints[];
 };
-export declare function useEquipmentWithMeasuringPoints(equipmentId: string, isEnabledMeasuringPoints: boolean): {
+export declare function useEquipmentWithMeasuringPoints(equipmentId: string): {
     status: 'error' | 'success' | 'pending';
     equipmentWithMeasuringPoints: EquipmentWithMeasuringPoints[];
 };

package/src/lib/feature/globalSelection/globalSelectionStore/globalSelectionStore.d.ts

@@ -1,4 +1,4 @@
-import { GlobalSelectionStore, GlobalSelectionTypes } from './globalSelectionStore.types';
+import { GlobalSelectionItemType, GlobalSelectionStore, GlobalSelectionTypes } from './globalSelectionStore.types';
 export declare const initialWorkOrderList: GlobalSelectionTypes.WorkOrderList;
 export declare const initialTagList: GlobalSelectionTypes.TagList;
 export declare const initialEquipmentList: GlobalSelectionTypes.EquipmentList;
@@ -34,7 +34,210 @@ export declare const useGlobalSelectionStore: import("zustand").UseBoundStore<Om
         } | undefined): () => void;
     };
 }, "setState"> & {
-    setState(nextStateOrUpdater: GlobalSelectionStore | Partial<GlobalSelectionStore> | ((state: import("immer").WritableDraft<GlobalSelectionStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+    setState(nextStateOrUpdater: GlobalSelectionStore | Partial<GlobalSelectionStore> | ((state: {
+        addWorkOrdersToSelection: (args: {
+            workOrderIds: GlobalSelectionTypes.WorkOrderId[];
+            color?: string;
+        }) => Promise<import("./globalSelectionStore.types").GlobalSelectionAddItemResult<import("@equinor/echo-search").ResultArray<import("@equinor/echo-search").WorkOrderData>[]>>;
+        addTagsToSelection: (args: {
+            tagIds: GlobalSelectionTypes.TagId[];
+            color?: string;
+        }) => Promise<import("./globalSelectionStore.types").GlobalSelectionAddItemResult<import("@equinor/echo-search").ResultArray<import("@equinor/echo-search").TagSummaryDto>[]>>;
+        addEquipmentsToSelection: (args: {
+            equipmentIds: GlobalSelectionTypes.EquipmentId[];
+            color?: string;
+        }) => Promise<import("./globalSelectionStore.types").GlobalSelectionAddItemResult<import("@equinor/echo-search").ResultArray<import("@equinor/echo-search").EquipmentData>[]>>;
+        addMeasuringPointsToSelection: (args: {
+            measuringPointIds: GlobalSelectionTypes.MeasuringPointId[];
+            color?: string;
+        }) => Promise<import("./globalSelectionStore.types").GlobalSelectionAddItemResult<import("@equinor/echo-search").ResultArray<import("@equinor/echo-search").MeasuringPointData>[]>>;
+        removeItemsFromSelection: (args: {
+            itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>;
+        }) => void;
+        setColorByItemIds: (args: {
+            itemIds: ReadonlyArray<Readonly<GlobalSelectionTypes.ItemId>>;
+            color: string;
+        }) => void;
+        setVisibilityByItemIds: (args: {
+            itemIds: ReadonlyArray<Readonly<GlobalSelectionTypes.ItemId>>;
+            isVisible: boolean;
+        }) => void;
+        setAllItemsVisibility: (args: {
+            isVisible: boolean;
+        }) => void;
+        setItemMetaData: (args: ReadonlyArray<import("./globalSelectionStore.types").GlobalSelectionItemIdMetadata>) => void;
+        resetItemErrorStatuses: () => void;
+        getStoredItemIds: () => ReadonlyArray<GlobalSelectionTypes.ItemId>;
+        resetState: () => void;
+        setErrorStatusForItems: (args: {
+            itemErrorStatuses: GlobalSelectionTypes.ItemErrorStatusUpdate[];
+        }) => void;
+        removeErrorStatusForItems: (args: {
+            itemIds: Readonly<GlobalSelectionTypes.ItemId[]>;
+        }) => void;
+        lists: {
+            WorkOrder: {
+                items: Map<GlobalSelectionTypes.ItemIdString, {
+                    id: {
+                        workOrderId: string;
+                    } | {
+                        instCode: string;
+                        tagNo: string;
+                    } | {
+                        equipmentId: string;
+                    } | {
+                        measuringPointId: string;
+                    };
+                    type: GlobalSelectionItemType.WorkOrder;
+                    data: {
+                        workOrderType: import("@equinor/echo-search").WorkOrderType;
+                        workOrderTypeDescription: import("@equinor/echo-search").WorkOrderTypeDescription;
+                        workOrderId: string;
+                        tagId: string | undefined;
+                        tagPlantId: string | undefined;
+                        workCenterId: string;
+                        workCenterPlantId: string;
+                        title: string;
+                        plantId: string;
+                        activeStatusIds: string[];
+                        sortField: string;
+                        revisionId: string;
+                        basicStartDateTime: Date | undefined;
+                        basicEndDateTime: Date | undefined;
+                        createdDateTime: Date | undefined;
+                        changedDateTime: Date | undefined;
+                        isTimeOnlyWorkOrder: boolean | undefined;
+                    };
+                    metaData: {
+                        color: string;
+                        isHiddenByUser: boolean;
+                        errorStatus?: string | undefined;
+                        systemStatus: import("./globalSelectionStore.types").SelectionItemSystemStatus;
+                    };
+                }>;
+            };
+            Tag: {
+                items: Map<GlobalSelectionTypes.ItemIdString, {
+                    id: {
+                        workOrderId: string;
+                    } | {
+                        instCode: string;
+                        tagNo: string;
+                    } | {
+                        equipmentId: string;
+                    } | {
+                        measuringPointId: string;
+                    };
+                    type: GlobalSelectionItemType.Tag;
+                    data: {
+                        instCode: string;
+                        pdmsPlantCode: string | undefined;
+                        tagCategoryDescription: string;
+                        tagCategory: number;
+                        tagStatus: import("@equinor/echo-search").TagStatus;
+                        tagType: string;
+                        updatedDate: Date;
+                        locationCode: string;
+                        contrCode: string;
+                        plantNo: string;
+                        poNo: string;
+                        xCoordinate?: number | undefined;
+                        yCoordinate?: number | undefined;
+                        zCoordinate?: number | undefined;
+                        additionalFields: {
+                            type: string;
+                            value: string;
+                        }[];
+                        tagNo: string;
+                        description: string;
+                        projectCode: string;
+                        system: string;
+                    };
+                    metaData: {
+                        color: string;
+                        isHiddenByUser: boolean;
+                        errorStatus?: string | undefined;
+                        systemStatus: import("./globalSelectionStore.types").SelectionItemSystemStatus;
+                    };
+                }>;
+            };
+            Equipment: {
+                items: Map<GlobalSelectionTypes.ItemIdString, {
+                    id: {
+                        workOrderId: string;
+                    } | {
+                        instCode: string;
+                        tagNo: string;
+                    } | {
+                        equipmentId: string;
+                    } | {
+                        measuringPointId: string;
+                    };
+                    type: GlobalSelectionItemType.Equipment;
+                    data: {
+                        equipmentId: string;
+                        activeStatusIds: string[];
+                        area: string;
+                        categoryId: import("dist/libs/echo-search/src/dataService/maintenance/equipment/equipment.type").EquipmentCategoryId | string;
+                        changedDate?: Date | undefined;
+                        createdDate?: Date | undefined;
+                        e3DRef: string;
+                        equipmentDescription: string;
+                        equipmentsStatus: string[];
+                        locationId: string;
+                        maintenancePlantId: string;
+                        tagId: string | undefined;
+                        tagPlantId: string | undefined;
+                        partType: string;
+                        partTypeText: string;
+                    };
+                    metaData: {
+                        color: string;
+                        isHiddenByUser: boolean;
+                        errorStatus?: string | undefined;
+                        systemStatus: import("./globalSelectionStore.types").SelectionItemSystemStatus;
+                    };
+                }>;
+            };
+            MeasuringPoint: {
+                items: Map<GlobalSelectionTypes.ItemIdString, {
+                    id: {
+                        workOrderId: string;
+                    } | {
+                        instCode: string;
+                        tagNo: string;
+                    } | {
+                        equipmentId: string;
+                    } | {
+                        measuringPointId: string;
+                    };
+                    type: GlobalSelectionItemType.MeasuringPoint;
+                    data: {
+                        measuringPointId: string;
+                        measuringPosition: string;
+                        measuringPoint: string;
+                        functionalLocationId: string | undefined;
+                        tagPlantId: string | undefined;
+                        tagId: string | undefined;
+                        equipmentId: string | undefined;
+                        quantitativeCharacteristicId: string | undefined;
+                        quantitativeCharacteristicUnit: string | undefined;
+                        positionDetails_CoordinateSystemName?: string | undefined;
+                        positionDetails_E3DReferenceNumber?: string | undefined;
+                        positionDetails_CoordinateEast?: string | undefined;
+                        positionDetails_CoordinateNorth?: string | undefined;
+                        positionDetails_CoordinateUp?: string | undefined;
+                    };
+                    metaData: {
+                        color: string;
+                        isHiddenByUser: boolean;
+                        errorStatus?: string | undefined;
+                        systemStatus: import("./globalSelectionStore.types").SelectionItemSystemStatus;
+                    };
+                }>;
+            };
+        };
+    }) => void), shouldReplace?: boolean | undefined, action?: string | {
         type: string;
     } | undefined): void;
 }>;

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/persist/selectionTree.load.utils.d.ts

@@ -52,3 +52,10 @@ export declare function applyColorsOnSelectionApiData(groups: ApiSelectionGroup[
  * @returns An array of `SelectionGroup` objects constructed from the API data, with the local selection group positioned as specified.
  */
 export declare function buildSelectionTreeFromApi(root: ApiSelectionTreeRootBase): SelectionGroup[];
+/**
+ * Displays a user-friendly error message using the error handling system and a toast notification.
+ *
+ * @param userFriendlyMessage - The message to be displayed to the user.
+ * @param errorName - An optional name for the error (default is "Error").
+ */
+export declare function displayUserFriendlyErrorMessage(userFriendlyMessage: string, errorName?: string | undefined): void;

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/selectionTree.store.d.ts

@@ -1,4 +1,6 @@
-import { SelectionTreeStore } from './selectionTree.store.types';
+import { Guid } from '@equinor/echo-utils';
+import { GlobalSelectionTypes } from '../../globalSelectionStore/globalSelectionStore.types';
+import { SelectionGroup, SelectionTreeStore } from './selectionTree.store.types';
 /**
  * Zustand store hook for managing the selection tree state in the global selection feature.
  *
@@ -27,7 +29,81 @@ export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit
         } | undefined): () => void;
     };
 }, "setState"> & {
-    setState(nextStateOrUpdater: SelectionTreeStore | Partial<SelectionTreeStore> | ((state: import("immer").WritableDraft<SelectionTreeStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+    setState(nextStateOrUpdater: SelectionTreeStore | Partial<SelectionTreeStore> | ((state: {
+        setCurrentSelectionId: (args: {
+            guid: Guid | undefined;
+        }) => void;
+        addItems: (args: {
+            itemIds: GlobalSelectionTypes.ItemId[];
+            groupId?: Guid;
+        }) => Promise<void>;
+        addTags: (args: import("./actions/selectionTree.action.types").AddItemArgs<GlobalSelectionTypes.TagId>) => import("./selectionTree.store.types").AddTagsReturnType;
+        addWorkOrders: (args: import("./actions/selectionTree.action.types").AddItemArgs<GlobalSelectionTypes.WorkOrderId>) => import("./selectionTree.store.types").AddWorkOrdersReturnType;
+        addEquipments: (args: import("./actions/selectionTree.action.types").AddItemArgs<GlobalSelectionTypes.EquipmentId>) => import("./selectionTree.store.types").AddEquipmentsReturnType;
+        addMeasuringPoints: (args: import("./actions/selectionTree.action.types").AddItemArgs<GlobalSelectionTypes.MeasuringPointId>) => import("./selectionTree.store.types").AddMeasuringPointsReturnType;
+        createGroup: (args: {
+            groupId?: string;
+            label: string;
+            subLabel: string;
+        }) => Guid;
+        removeGroupById: (args: {
+            groupId: Guid;
+            categoryId?: import("./selectionTree.store.types").GlobalSelectionCategoryId;
+        }) => void;
+        findGroupIdByLabel: (args: {
+            label: string;
+        }) => Guid | undefined;
+        findGroupById: (args: {
+            id: Guid;
+        }) => SelectionGroup | undefined;
+        removeItemsById: (args: {
+            groupId?: Guid;
+            categoryId: import("./selectionTree.store.types").GlobalSelectionCategoryId;
+            itemIds: GlobalSelectionTypes.ItemId[];
+        }) => void;
+        removeAllItemsById: (args: {
+            itemIds: GlobalSelectionTypes.ItemId[];
+        }) => void;
+        moveItems: (args: {
+            sourceGroupId: Guid;
+            sourceCategoryId?: import("./selectionTree.store.types").GlobalSelectionCategoryId;
+            sourceItemId?: GlobalSelectionTypes.ItemId;
+            targetGroupId: Guid;
+        }) => void;
+        setVisibilityById: (args: {
+            groupId: Guid;
+            categoryId?: import("./selectionTree.store.types").GlobalSelectionCategoryId;
+            isVisible: boolean;
+        }) => void;
+        resetState: () => void;
+        setWholeState: (args: {
+            selectionId: Guid | undefined;
+            groups: SelectionGroup[];
+        }) => void;
+        currentSelectionId?: Guid | undefined;
+        groups: {
+            categories: {
+                id: import("./selectionTree.store.types").GlobalSelectionCategoryId;
+                label: string;
+                items: Map<GlobalSelectionTypes.ItemIdString, {
+                    id: {
+                        workOrderId: string;
+                    } | {
+                        instCode: string;
+                        tagNo: string;
+                    } | {
+                        equipmentId: string;
+                    } | {
+                        measuringPointId: string;
+                    };
+                    type: import("../../globalSelectionStore/globalSelectionStore.types").GlobalSelectionItemType;
+                }>;
+            }[];
+            groupId: Guid;
+            label: string;
+            subLabel: string;
+        }[];
+    }) => void), shouldReplace?: boolean | undefined, action?: string | {
         type: string;
     } | undefined): void;
 }>;

package/src/lib/feature/legend/components/pdfMarkers/PositionalItem.d.ts

@@ -4,7 +4,7 @@ interface PositionalItemProps {
      * This is the CSS position string, that will be used in --transform: var(--position);
      */
     position: string;
-    isOpen: boolean;
+    isActive: boolean;
     children: React.ReactNode;
 }
 /**

package/src/lib/feature/legend/components/pdfMarkers/subComponents/LegendMarkersRenderer.d.ts

@@ -5,7 +5,7 @@ interface LegendPositionItem {
     positionString: string;
     hasPointer: boolean;
     /** Unique identifier that doesn't change on viewport changes */
-    uniqueIdentifier: string;
+    positionId: string;
 }
 interface LegendMarkersRendererProps {
     positionItems: ReadonlyArray<LegendPositionItem>;

package/src/lib/feature/legend/components/pdfMarkers/subComponents/MarkerWithPopover.d.ts

@@ -0,0 +1,13 @@
+import { LegendDataId, LegendId } from '../../../types/legendType';
+import { MarkerId } from '../utils/markerId.utils';
+import { GroupedMarker } from '../utils/splitMarkerByBadgeSelectionGroup.types';
+interface MarkerWithPopoverProps {
+    legendId: LegendId;
+    hasPointer: boolean;
+    hiddenBadges: string[];
+    marker: GroupedMarker;
+    itemId: LegendDataId;
+    markerId: MarkerId;
+}
+export declare const MarkerWithPopover: (props: MarkerWithPopoverProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/lib/feature/legend/components/pdfMarkers/subComponents/MultipleMarkersByLegends.d.ts

@@ -1,12 +1,8 @@
 import { LegendDataId } from '../../../types/legendType';
-import { PopoverContent, RequestPopoverHandler } from './hooks/usePopoverHandler.types';
 interface MultipleMarkersByLegendsProps {
     itemId: LegendDataId;
     hasPointer: boolean;
-    onOpenPopover: RequestPopoverHandler;
-    onClosePopover: () => void;
-    currentPopover?: PopoverContent;
-    uniqueIdentifier: string;
+    positionId: string;
 }
 export declare const MultipleMarkersByLegends: import("react").MemoExoticComponent<(props: MultipleMarkersByLegendsProps) => import("react/jsx-runtime").JSX.Element>;
 export {};

package/src/lib/feature/legend/components/pdfMarkers/subComponents/MultipleMarkersBySingleLegend.d.ts

@@ -3,8 +3,7 @@ interface MultipleMarkersBySingleLegendComponentProps {
     legendId: LegendId;
     itemId: LegendDataId;
     hasPointer: boolean;
-    isActive: boolean;
-    onClick: () => void;
+    positionId: string;
 }
 export declare const MultipleMarkersBySingleLegend: import("react").MemoExoticComponent<(props: MultipleMarkersBySingleLegendComponentProps) => import("react/jsx-runtime").JSX.Element[] | null>;
 export {};

package/src/lib/feature/legend/components/pdfMarkers/subComponents/hooks/useMarkerPopover.d.ts

@@ -0,0 +1,19 @@
+import { LegendDataId, LegendId } from '../../../../types/legendType';
+import { MarkerId } from '../../utils/markerId.utils';
+import { GroupedMarker } from '../../utils/splitMarkerByBadgeSelectionGroup.types';
+/**
+ * Hook to manage popover state and async content loading for legend markers.
+ * When fetching, it will show a loading spinner if content takes too long to load.
+ *
+ * @param markerId - Unique identifier for this marker
+ * @param legendId - The legend this marker belongs to
+ * @param itemId - The data ID for this legend item
+ * @param marker - The grouped marker data containing badges
+ * @returns Object with isActive state, elements array, and handlers for open/close
+ */
+export declare function useMarkerPopover(markerId: MarkerId, legendId: LegendId, itemId: LegendDataId, marker: GroupedMarker): {
+    isPopoverActive: boolean;
+    elements: readonly import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>[];
+    handleOpen: () => Promise<void>;
+    handleClose: () => void;
+};

package/src/lib/feature/legend/components/pdfMarkers/utils/markerId.utils.d.ts

@@ -0,0 +1,18 @@
+import { Brand } from '@equinor/echo-utils';
+import { LegendId } from '../../../types/legendType';
+export type MarkerId = Brand<string, 'MarkerId'>;
+/**
+ * Creates a unique marker ID from its component parts.
+ * Format: positionId::legendId::groupKey
+ */
+export declare function createMarkerId(positionId: string, legendId: LegendId, groupKey: string): MarkerId;
+/**
+ * Extracts the position ID from a marker ID.
+ * Returns undefined if the marker ID is invalid.
+ * @internal - Only exported for testing purposes
+ */
+export declare function getPositionIdFromMarkerId(markerId: MarkerId): string | undefined;
+/**
+ * Checks if a marker ID belongs to a specific position.
+ */
+export declare function isMarkerAtPosition(markerId: MarkerId | undefined, positionId: string): boolean;