@equinor/echo-framework 4.0.1 → 4.1.1

package/src/lib/feature/globalSelection/pdmsTag/pdmsTag.types.d.ts

@@ -2,11 +2,20 @@ import type { TagSummaryDto } from '@equinor/echo-search';
 export declare const PDMS_INTERNAL_TAG_TYPES: readonly ["PdmsTag", "PdmsPart"];
 export type PdmsInternalTagType = (typeof PDMS_INTERNAL_TAG_TYPES)[number];
 export declare const isPdmsInternalTagType: (value: string) => value is PdmsInternalTagType;
-export interface PdmsTagId {
-    readonly tagNo: string;
-    readonly instCode: string;
+/**
+ * StidTagId contains only tagNo and instCode.
+ */
+export type StidTagId = Pick<TagSummaryDto, 'tagNo' | 'instCode'>;
+/**
+ * Identifies a PDMS tag. Extends the standard STID tag ID (tagNo + instCode) with additional PDMS-specific properties.
+ * @remarks STID tags only have `tagNo` and `instCode`. PDMS tags add `internalTagType`, `plantNo`, and `plantCode`.
+ */
+export interface PdmsTagId extends StidTagId {
+    /** @remarks Discriminator between PDMS tag types: 'PdmsTag' for tags not in STID, 'PdmsPart' for parts without a tag. */
     readonly internalTagType: PdmsInternalTagType;
+    /** @remarks Also known as sapId. */
     readonly plantNo: string;
+    /** @remarks Usually same as instCode, but for some plants it replaces last instCode character with A, B, C, etc. */
     readonly plantCode: string;
 }
 export interface PdmsTagSummaryDto extends TagSummaryDto, PdmsTagId {

package/src/lib/feature/globalSelection/pdmsTag/pdmsTag.utils.d.ts

@@ -1,6 +1,4 @@
 import { type TagSummaryDto } from '@equinor/echo-search';
-import type { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionStore.types';
 import type { PdmsTagId, PdmsTagSummaryDto } from './pdmsTag.types';
-export declare function isPdmsTagId(itemId: GlobalSelectionTypes.ItemId): itemId is PdmsTagId;
 export declare function isPdmsTagSummaryDto(dto: TagSummaryDto): dto is PdmsTagSummaryDto;
 export declare function createPdmsTagSummaryDto(pdmsTagId: PdmsTagId): PdmsTagSummaryDto;

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

@@ -89,15 +89,14 @@ export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit
                     id: {
                         workOrderId: string;
                     } | {
-                        tagNo: string;
                         instCode: string;
+                        tagNo: string;
+                    } | {
                         internalTagType: import("../..").PdmsInternalTagType;
                         plantNo: string;
                         plantCode: string;
-                    } | {
                         instCode: string;
                         tagNo: string;
-                        internalTagType?: never | undefined;
                     } | {
                         equipmentId: string;
                     } | {

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

@@ -104,7 +104,7 @@ export declare function isSelectionEmpty(groups: SelectionTreeTypes.Group[]): bo
  * @returns {void}
  */
 export declare function removeStaleItemsFromGlobalSelection(groups: SelectionTreeTypes.Group[], itemIds: GlobalSelectionTypes.ItemId[]): void;
-export declare function getItemsByIdsFromGlobalSelectionStore(itemIds: GlobalSelectionTypes.ItemId[]): GlobalSelectionTypes.GenericItem<GlobalSelectionItemType>[];
+export declare function getItemsByIdsFromGlobalSelectionStore(itemIds: GlobalSelectionTypes.ItemId[]): GlobalSelectionTypes.SelectionItem[];
 /**
  * Returns an array of selection colors sorted by their frequency for the specified item IDs within a group.
  *

package/src/lib/feature/legend/components/LegendFeedbackMessage.d.ts

@@ -1,4 +1,4 @@
-export type LegendFeedbackVariant = 'error' | 'info' | 'warning';
+import type { LegendFeedbackVariant } from '../stores/legendUIStore/legendUIStore.types';
 interface LegendFeedbackMessageProps {
     className?: string;
     variant?: LegendFeedbackVariant;

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

@@ -0,0 +1,15 @@
+import { Marker } from '../../../../../types/legendMarkerBadge.type';
+import { MarkerId } from '../../../utils/markerId.utils';
+import { ColorGroupedMarker } from '../../../utils/splitMarkerByColor.types';
+/**
+ * Builds the list of color-grouped markers to render for a single legend item.
+ *
+ * When the item has no selection grouping, wraps the raw marker as a single transparent-key variant.
+ * Always returns markers sorted by color key for stable render order.
+ */
+export declare function buildMarkersToRender(marker: Marker, groupedMarkers: ReadonlyArray<ColorGroupedMarker> | null | undefined): ColorGroupedMarker[];
+/**
+ * Finds the best new markerId to migrate the active popover to after the old marker disappears.
+ * Prefers a marker with the same color key, falls back to the first available.
+ */
+export declare function findNewMarkerId(markerIds: MarkerId[], previousMarkerId: MarkerId): MarkerId | undefined;

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

@@ -0,0 +1,19 @@
+import { MarkerId } from '../../../utils/markerId.utils';
+import { ColorGroupedMarker } from '../../../utils/splitMarkerByColor.types';
+interface UseStalePopoverMarkersProps {
+    readonly markersToRender: ReadonlyArray<ColorGroupedMarker> | null;
+    readonly markerIds: ReadonlyArray<MarkerId>;
+    readonly selectionMarkerIds: ReadonlyArray<MarkerId>;
+}
+/**
+ * Holds stale markers visible while selection feedback is displayed after a delayed close or migration.
+ *
+ * When `shouldDelayPopoverUpdate` is true and the active popover's marker disappears (e.g. last item
+ * removed from a color group), this hook keeps the old `MarkerWithPopover` rendered for
+ * `POPOVER_UPDATE_DELAY_MS`. That gives the loading indicator and feedback message ("Removed",
+ * "Color changed") time to be visible before the popover closes or migrates to a new marker.
+ *
+ * @returns The markers that should be rendered — either the stale snapshot or the live `markersToRender`.
+ */
+export declare function useStalePopoverMarkers({ markersToRender, markerIds, selectionMarkerIds }: UseStalePopoverMarkersProps): ReadonlyArray<ColorGroupedMarker> | null;
+export {};

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

@@ -1,6 +1,7 @@
 import { LegendDataId, LegendId } from '../../../../types/legendType';
 import { MarkerId } from '../../utils/markerId.utils';
 import { ColorGroupedMarker } from '../../utils/splitMarkerByColor.types';
+export declare const POPOVER_UPDATE_DELAY_MS = 2000;
 /**
  * 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.

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

@@ -1,6 +1,10 @@
 import { Brand } from '@equinor/echo-utils';
 import { LegendId } from '../../../types/legendType';
 export type MarkerId = Brand<string, 'MarkerId'>;
+/**
+ * Color key used when a marker is not in any selection group (fallback/transparent state).
+ */
+export declare const TRANSPARENT_COLOR_KEY = "color_transparent";
 /**
  * Creates a unique marker ID from its component parts.
  * Format: positionId::legendId::groupKey
@@ -16,3 +20,8 @@ export declare function getPositionIdFromMarkerId(markerId: MarkerId): string |
  * Checks if a marker ID belongs to a specific position.
  */
 export declare function isMarkerAtPosition(markerId: MarkerId | undefined, positionId: string): boolean;
+/**
+ * Extracts the color/group key from a marker ID.
+ * Returns undefined if the marker ID is invalid.
+ */
+export declare function getColorKeyFromMarkerId(markerId: MarkerId): string | undefined;

package/src/lib/feature/legend/hooks/useFetchNotificationsByWorkOrderId.d.ts

@@ -0,0 +1,13 @@
+import { WorkOrderNotificationStatus } from '../../workOrder/api/api-workOrder-notification';
+/**
+ * React Query hook that fetches maintenance record/attachment notification data for a given work order.
+ *
+ * This hook returns only the resolved `data` value from React Query.
+ * Callers that need loading/error state should use `useQuery` directly.
+ *
+ * @param workOrderId - Unique identifier of the work order for which to fetch notification data.
+ * @returns Notification data for the work order, or `undefined` when not yet loaded or when the API returns no data.
+ */
+export declare function useFetchNotificationsByWorkOrderId({ workOrderId }: {
+    workOrderId: string;
+}): WorkOrderNotificationStatus | undefined;

package/src/lib/feature/legend/hooks/useItemToSelectionGroupsMapSubscription.d.ts

@@ -1,4 +1,4 @@
-import { GlobalSelectionTypes } from '../../globalSelection';
+import type { GlobalSelectionTypes } from '../../globalSelection/globalSelectionStore/globalSelectionStore.types';
 import { ItemToSelectionGroupsMap } from '../stores/itemToSelectionGroupsMapStore/itemToSelectionGroupsMapStore.types';
 interface ItemToSelectionGroupsMapSubscriptionResult {
     /** The complete itemToSelectionGroupsMap for looking up item -> selection groups */
@@ -11,7 +11,7 @@ interface ItemToSelectionGroupsMapSubscriptionResult {
  * and only triggers a re-render when any of the watched items change group membership.
  * Returns the full itemToSelectionGroupsMap so the caller can look up selection groups for each badge.
  *
- * @param watchItemIds - Array of item ID strings to watch (e.g., all badge item IDs from a marker)
+ * @param watchItemIds - Array of global selection item ID strings to watch
  * @returns Object containing the complete itemToSelectionGroupsMap for lookups
  *
  * @example
@@ -25,5 +25,5 @@ interface ItemToSelectionGroupsMapSubscriptionResult {
  * const { itemToSelectionGroupsMap } = useItemToSelectionGroupsMapSubscription(badgeItemIds);
  * ```
  */
-export declare const useItemToSelectionGroupsMapSubscription: (watchItemIds: GlobalSelectionTypes.ItemIdString[]) => ItemToSelectionGroupsMapSubscriptionResult;
+export declare const useItemToSelectionGroupsMapSubscription: (watchItemIds: ReadonlyArray<GlobalSelectionTypes.ItemIdString>) => ItemToSelectionGroupsMapSubscriptionResult;
 export {};

package/src/lib/feature/legend/hooks/useSelectionItemColorSubscription.d.ts

@@ -1,4 +1,4 @@
-import { GlobalSelectionTypes } from '../../globalSelection';
+import { type GlobalSelectionTypes } from '../../globalSelection/globalSelectionStore/globalSelectionStore.types';
 /**
  * Creates a per-marker subscription to selection item color changes.
  *
@@ -10,7 +10,7 @@ import { GlobalSelectionTypes } from '../../globalSelection';
  * the selection color of THIS marker's specific items changes, not when any
  * item's color changes in the global selection.
  *
- * @param itemIdStrings - Sorted array of item ID strings to watch
+ * @param itemIdStrings - Sorted array of global selection item ID strings to watch
  * @returns A combined key string representing current selection item colors for these items
  */
-export declare const useSelectionItemColorSubscription: (itemIdStrings: GlobalSelectionTypes.ItemIdString[]) => string;
+export declare const useSelectionItemColorSubscription: (itemIdStrings: ReadonlyArray<GlobalSelectionTypes.ItemIdString>) => string;

package/src/lib/feature/legend/hooks/useUniqueSelectionOnlyBadgeIdStrings.d.ts

@@ -0,0 +1,8 @@
+import type { GlobalSelectionTypes } from '../../globalSelection/globalSelectionStore/globalSelectionStore.types';
+import { Marker } from '../types/legendMarkerBadge.type';
+/**
+ * Returns unique global-selection item ID strings from all badges on the marker.
+ * Non-selection items are filtered out since they
+ * don't exist in global selection and need no selection lookups.
+ */
+export declare const useUniqueSelectionOnlyBadgeIdStrings: (marker?: Marker) => GlobalSelectionTypes.ItemIdString[];

package/src/lib/feature/legend/index.d.ts

@@ -1,3 +1,4 @@
+import './legendStrategies/notificationStrategy/notificationStrategy';
 import './legendStrategies/workOrderStrategy/WorkOrderLegend';
 export { getBadgeChips, getMarkerChips } from './components/basicLegendRenderer.logic';
 export { LegendList } from './components/LegendList';

package/src/lib/feature/legend/legendFacade.d.ts

@@ -1,8 +1,8 @@
-import type { LegendFeedbackVariant } from './components/LegendFeedbackMessage';
 import { getLegendStrategy, injectLegendStrategy } from './legendStrategies/legendCollections';
 import { isLegendDataIdEqualWithTag } from './logic/isLegendDataIdEqualWithTag';
 import { legendExistsInLegendStore, legendSnapShot, legendStoreSubscribe, useAllLegends, useLegendById } from './stores/legendDataStore/legendStore';
 import { legendExistsInLegendUIStore, useLegendUIById } from './stores/legendUIStore/legendUIStore';
+import type { LegendFeedbackVariant } from './stores/legendUIStore/legendUIStore.types';
 import { visibleDataAsTagsSnapshot } from './stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore';
 import { LegendId } from './types/legendType';
 /**
@@ -143,10 +143,19 @@ export declare const legendFacade: Readonly<{
     };
     utils: {
         isLegendDataIdEqualWithTag: typeof isLegendDataIdEqualWithTag;
+        dataIdToString: (id: import("./types/legendType").LegendDataId) => import("./types/legendType").LegendDataIdString;
+        dataIdToSelectionItemIdString: (id: import("./types/legendType").LegendDataId) => import("../globalSelection").GlobalSelectionTypes.ItemIdString | undefined;
+        isGlobalSelectionItemId: (id: import("./types/legendType").LegendDataId) => id is import("./types/legendType").GlobalSelectionLegendDataId;
+        selectionGuards: {
+            readonly WorkOrder: (legendDataId: import("./types/legendType").LegendDataId) => legendDataId is import("../globalSelection").GlobalSelectionTypes.WorkOrderId;
+            readonly Tag: (legendDataId: import("./types/legendType").LegendDataId) => legendDataId is import("../globalSelection").GlobalSelectionTypes.TagId;
+            readonly Equipment: (legendDataId: import("./types/legendType").LegendDataId) => legendDataId is import("../globalSelection").GlobalSelectionTypes.EquipmentId;
+        };
     };
     knownLegendIds: {
         equipmentLegendId: LegendId;
         tagLegendId: LegendId;
         workOrderLegendId: LegendId;
+        notificationLegendId: LegendId;
     };
 }>;

package/src/lib/feature/legend/legendStrategies/notificationStrategy/notificationStrategy.d.ts

@@ -0,0 +1 @@
+export {};

package/src/lib/feature/legend/legendStrategies/workOrderStrategy/CreateWorkOrderPopoverContent.d.ts

@@ -1,4 +1,3 @@
-import { GlobalSelectionTypes } from '../../../globalSelection';
 import { LegendDataId } from '../../types/legendType';
 /**
  * Creates popover content for a work order legend item.
@@ -11,4 +10,4 @@ import { LegendDataId } from '../../types/legendType';
  * @param itemIds - Selected item ids used to filter which work orders should be shown in the popover.
  * @returns A JSX element array when work orders are found, otherwise a single fallback JSX element.
  */
-export declare function createPopoverContent(legendDataId: LegendDataId, itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>): Promise<JSX.Element | JSX.Element[]>;
+export declare function createPopoverContent(legendDataId: LegendDataId, itemIds: ReadonlyArray<LegendDataId>): Promise<JSX.Element | JSX.Element[]>;

package/src/lib/feature/legend/legendStrategies/workOrderStrategy/components/WorkOrderPopoverPrimaryRow.d.ts

@@ -5,11 +5,11 @@
  * a list of unique notification type identifiers resolved for the work order.
  *
  * @param props \- Component props.
- * @param props.workOrderNumber \- Work order identifier used for display and for fetching related objects.
+ * @param props.workOrderId \- Work order identifier used for display and for fetching related objects.
  * @param props.isActive \- Whether the work order is active \(`true`\) or completed \(`false`\).
  * @returns A React element containing the primary row content.
  */
-export declare const WorkOrderPopoverPrimaryRow: ({ workOrderNumber, isActive }: {
-    workOrderNumber: string;
+export declare const WorkOrderPopoverPrimaryRow: ({ workOrderId, isActive }: {
+    workOrderId: string;
     isActive: boolean;
 }) => import("react/jsx-runtime").JSX.Element;

package/src/lib/feature/legend/legendStrategies/workOrderStrategy/useCreateWorkOrderMarkers.d.ts

@@ -1,5 +1,5 @@
-import { LegendDataId } from '../../types/legendType';
 import { Marker } from '../../types/legendMarkerBadge.type';
+import { LegendDataId } from '../../types/legendType';
 /**
  * Creates legend markers for work orders grouped by `tagId`.
  *

package/src/lib/feature/legend/legendStrategies/workOrderStrategy/workOrderPopover.types.d.ts

@@ -1,16 +1,15 @@
 import { LegendDataId } from '../../types/legendType';
-import { GlobalSelectionTypes } from '../../../globalSelection';
 export type PopoverProps = {
     legendDataId: LegendDataId;
-    itemIds?: ReadonlyArray<GlobalSelectionTypes.ItemId>;
+    itemIds?: ReadonlyArray<LegendDataId>;
 };
 export interface WorkOrderPopover {
-    workOrderId: string;
-    isActive: boolean;
-    orderTypeId: string;
-    description: string;
-    plantNo: string;
-    workCenter: string;
-    basicFinishDateTime: Date | undefined;
-    basicFinishDateStatus: string | undefined;
+    readonly workOrderId: string;
+    readonly isActive: boolean;
+    readonly orderTypeId: string;
+    readonly description: string;
+    readonly plantNo: string;
+    readonly workCenter: string;
+    readonly basicFinishDateTime: Date | undefined;
+    readonly basicFinishDateStatus: string | undefined;
 }

package/src/lib/feature/legend/logic/legendDataId.utils.d.ts

@@ -0,0 +1,50 @@
+import { GlobalSelectionItemType, type GlobalSelectionTypes } from '../../globalSelection';
+import type { SelectionItemTypeToItemIdMap } from '../../globalSelection/globalSelectionStore/globalSelectionStore.types';
+import { LegendDataId, LegendDataIdString, type GlobalSelectionLegendDataId } from '../types/legendType';
+/**
+ * Mapped type that produces proper TypeScript type predicates for each selection type.
+ * - Derives the GlobalSelectionItemType keys whose ID types are part of GlobalSelectionLegendDataId
+ * - Creates type guard functions that narrow `LegendDataId` to the specific ID type
+ */
+type SelectionGuardMap = {
+    readonly [K in GlobalSelectionItemType as SelectionItemTypeToItemIdMap[K] extends GlobalSelectionLegendDataId ? K : never]: (legendDataId: LegendDataId) => legendDataId is Extract<SelectionItemTypeToItemIdMap[K], LegendDataId>;
+};
+/**
+ * Type guards that narrow LegendDataId to specific selection ID types.
+ * Record-based exhaustiveness: if a new type is added to GlobalSelectionLegendDataId,
+ * SelectionGuardMap expands and demands a new entry — compile error.
+ *
+ * **Adding a new selection-based legend?**
+ * 1. Add its type to legendType.ts
+ * 2. Add its guard here (compile error until you do)
+ *
+ * isGlobalSelectionItemId automatically picks up new guards.
+ */
+export declare const selectionGuards: SelectionGuardMap;
+/**
+ * This is the bridge between the legend system and global selection.
+ * The generic legend infrastructure (color subscription, grouping, marker splitting)
+ * uses this to determine which items participate in selection-based features.
+ *
+ * Automatically includes all guards from selectionGuards.
+ */
+export declare const isGlobalSelectionItemId: (id: LegendDataId) => id is GlobalSelectionLegendDataId;
+/**
+ * Converts any LegendDataId to a stable, unique string.
+ * For global selection types this delegates to globalSelectionUtils.itemIdToString.
+ * For non-selection types (e.g. notifications) it produces a prefixed string
+ * that will never collide with global selection ID strings.
+ */
+export declare const dataIdToString: (id: LegendDataId) => LegendDataIdString;
+/**
+ * Converts a LegendDataId to a GlobalSelection ItemIdString if the ID
+ * belongs to global selection (tag, equipment, work order).
+ * Returns undefined for non-selection IDs (e.g. notifications) since they have no corresponding item ID string.
+ */
+export declare const dataIdToSelectionItemIdString: (id: LegendDataId) => GlobalSelectionTypes.ItemIdString | undefined;
+/**
+ * Maps a LegendDataId to its GlobalSelectionItemType, or undefined
+ * if the ID does not belong to global selection (e.g. notifications).
+ */
+export declare const dataIdToSelectionItemType: (id: LegendDataId) => GlobalSelectionItemType | undefined;
+export {};

package/src/lib/feature/legend/stores/legendUIStore/legendUIStore.types.d.ts

@@ -1,6 +1,8 @@
-import type { LegendFeedbackVariant } from '../../components/LegendFeedbackMessage';
+import type { SelectionFeedbackType } from '../../../globalSelection/components/SelectionActionBar/selectionFeedback.types';
 import { MarkerId } from '../../components/pdfMarkers/utils/markerId.utils';
 import { LegendId } from '../../types/legendType';
+export type { SelectionFeedbackType };
+export type LegendFeedbackVariant = 'error' | 'info' | 'warning';
 export interface LegendUIState {
     readonly accordionFeedback?: {
         message: string;
@@ -17,11 +19,16 @@ export type LegendUIStoreValues = {
     readonly activePopover: {
         readonly id?: MarkerId;
         readonly elements: ReadonlyArray<React.ReactElement>;
+        readonly selectionFeedback?: {
+            readonly isLoading: boolean;
+            readonly feedbackType: SelectionFeedbackType | null;
+        };
     };
     readonly selectionLegend: {
         readonly isHighlightVisible: boolean;
         readonly markersOutsideSelectionVisibility: MarkersOutsideSelectionVisibility;
     };
+    readonly shouldDelayPopoverUpdate: boolean;
 };
 export interface LegendUIStoreActions {
     toggleAccordion: (legendId: LegendId, newValue: boolean) => void;
@@ -45,6 +52,11 @@ export interface LegendUIStoreActions {
     setSelectionLegendIsHighlightVisible: (visible: boolean) => void;
     setActivePopoverId: (popoverId: MarkerId | undefined) => void;
     setActivePopoverElements: (elements: ReadonlyArray<React.ReactElement>) => void;
+    setPopoverSelectionFeedback: (feedback: {
+        isLoading: boolean;
+        feedbackType: SelectionFeedbackType | null;
+    } | undefined) => void;
+    setShouldDelayPopoverUpdate: (delay: boolean) => void;
     setAccordionFeedback: (legendId: LegendId, feedback: {
         message: string;
         variant?: LegendFeedbackVariant;

package/src/lib/feature/legend/stores/legendVisibleDataStore/legendVisibleDataStore.d.ts

@@ -59,15 +59,14 @@ export declare const useLegendVisibleDataStore: import("zustand").UseBoundStore<
         data: {
             Tag: {
                 [x: string]: ({
-                    tagNo: string;
                     instCode: string;
+                    tagNo: string;
+                } | {
                     internalTagType: import("../../../globalSelection").PdmsInternalTagType;
                     plantNo: string;
                     plantCode: string;
-                } | {
                     instCode: string;
                     tagNo: string;
-                    internalTagType?: never | undefined;
                 })[];
             };
             Equipment: {

package/src/lib/feature/legend/types/legendMarkerBadge.type.d.ts

@@ -6,13 +6,18 @@ export interface Marker {
     getDisplayKey: () => string;
     getHighlightColor: () => string;
     badges: ReadonlyArray<Badge>;
+    /**
+     * When true, renders as plain text instead of a colored chip in the legend panel.
+     * Typically used to display informational messages to the user, such as enable syncing.
+     */
     showAsPlainLabel?: boolean;
 }
 export interface Badge {
     getTitle: () => string;
     getColor: () => string;
     /**
-     * Returns a key that can be used for clustering or grouping badges together if they share the same key.
+     * Returns a unique identity key used to track which badges are hidden/toggled off in the legend panel.
+     * Typically implemented as a combination of title and color to ensure uniqueness.
      */
     getDisplayKey: () => string;
     getItemId: () => LegendDataId;

package/src/lib/feature/legend/types/legendStrategy.type.d.ts

@@ -1,4 +1,3 @@
-import { GlobalSelectionTypes } from '../../globalSelection';
 import { Marker } from './legendMarkerBadge.type';
 import { LegendDataId, LegendId, LegendOptionConfig } from './legendType';
 /**
@@ -36,10 +35,10 @@ export interface LegendStrategy {
      * This function is asynchronous because the popover content may depend on data that needs to be fetched before rendering,
      * such as related equipment, work orders, or other resources.
      * @param {LegendDataId} legendDataId - The identifier for the legend item for which to render popover content.
-     * @param {ReadonlyArray<GlobalSelectionTypes.ItemId>} itemIds - The item ids to be included in the popover content.
+     * @param {ReadonlyArray<LegendDataId>} itemIds - The item ids to be included in the popover content.
      * @returns A Promise resolving to one or more React elements to display in the popover.
      */
-    popoverContent: (legendDataId: LegendDataId, itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>) => Promise<React.ReactElement | ReadonlyArray<React.ReactElement>>;
+    popoverContent: (legendDataId: LegendDataId, itemIds: ReadonlyArray<LegendDataId>) => Promise<React.ReactElement | ReadonlyArray<React.ReactElement>>;
     /**
      * Returns the custom legend component for the legend, if this is omitted the default basicLegendRenderer will be used
      */

package/src/lib/feature/legend/types/legendType.d.ts

@@ -1,11 +1,13 @@
 import { Brand } from '@equinor/echo-utils';
 import { GlobalSelectionTypes } from '../../globalSelection';
-export type KnownLegendIds = 'Equipment Legend' | 'Tag Legend' | 'Work Order Legend';
+export type KnownLegendIds = 'Equipment Legend' | 'Tag Legend' | 'Work Order Legend' | 'Notification Legend';
 export type LegendId = KnownLegendIds | Brand<string, 'LegendId'>;
+export type LegendDataIdString = Brand<string, 'LegendDataIdString'>;
 export declare const knownLegendIds: {
     equipmentLegendId: LegendId;
     tagLegendId: LegendId;
     workOrderLegendId: LegendId;
+    notificationLegendId: LegendId;
 };
 export interface LegendState {
     readonly legendId: LegendId;
@@ -18,7 +20,20 @@ export interface LegendState {
 export type LegendTagId = GlobalSelectionTypes.TagId;
 export type LegendEquipmentId = GlobalSelectionTypes.EquipmentId;
 export type LegendWorkOrderId = GlobalSelectionTypes.WorkOrderId;
-export type LegendDataId = LegendTagId | LegendEquipmentId | LegendWorkOrderId;
+export type LegendNotificationId = {
+    testId: string;
+};
+/**
+ * Union of LegendDataId types that correspond to global selection item IDs.
+ * These can be safely used with globalSelectionUtils.
+ *
+ * **Adding a new selection-based legend?**
+ * 1. Add its type to here
+ * 2. Go to legendDataId.utils.ts and update selectionGuards (this will cause a compile error until you add a guard for the new type)
+ */
+export type GlobalSelectionLegendDataId = LegendTagId | LegendEquipmentId | LegendWorkOrderId;
+type NonGlobalSelectionLegendDataId = LegendNotificationId;
+export type LegendDataId = GlobalSelectionLegendDataId | NonGlobalSelectionLegendDataId;
 export interface LegendOptionConfig<T = string> {
     propertyName: T;
     /**
@@ -31,3 +46,4 @@ export interface LegendOptionConfig<T = string> {
     displayName: string;
     showChipsInViewportOnly?: boolean;
 }
+export {};

package/src/lib/feature/measuringPoint/components/lastRecordedMeasurement/lastRecordedMeasurement.logic.d.ts

@@ -1,8 +1,8 @@
 import { MeasurementDto } from '../../types/measuringPoint';
 export type LastRecordedMeasurementData = {
-    conditionAsText?: string;
-    measurementDateTime: string | null;
-    codeAsText?: string;
+    conditionAsText: string | undefined;
+    measurementDateTime: string | undefined;
+    codeAsText: string | undefined;
     lastRecordedMeasurement: MeasurementDto | undefined;
 };
 export declare const getLastRecordedMeasurement: (measurements: MeasurementDto[]) => LastRecordedMeasurementData;

package/src/lib/feature/workOrder/api/api-workOrder-notification.d.ts

@@ -0,0 +1,12 @@
+export interface WorkOrderNotificationStatus {
+    readonly workOrderId: string;
+    readonly maintenanceRecordTypes: string[];
+    readonly hasB30Document: boolean;
+}
+/**
+ * Fetches maintenance record types and attachment type information for a work order.
+ *
+ * @param workOrderId - Unique work order identifier.
+ * @returns The notification data for the given work order, or `undefined` if the request returns no data.
+ */
+export declare function fetchNotificationStatusByWorkOrderId(workOrderId: string): Promise<WorkOrderNotificationStatus | undefined>;

package/src/lib/services/dataLayerPanel/dataLayerPanel.store.d.ts

@@ -1,16 +1,17 @@
 import { WritableDraft } from 'immer';
 export interface PanelUserSettings {
-    isTagsVisible: boolean;
-    isTagsFromDocumentVisible: boolean;
-    isTagsFromSelectionVisible: boolean;
-    isWorkOrdersVisible: boolean;
-    isWorkOrdersFromDocumentVisible: boolean;
-    isWorkOrdersFromSelectionVisible: boolean;
-    isEquipmentsVisible: boolean;
-    isEquipmentsFromDocumentVisible: boolean;
-    isEquipmentsFromSelectionVisible: boolean;
-    isIocAnnotationsVisible: boolean;
-    isDataFromStidAnnoDetails: boolean;
+    readonly isTagsVisible: boolean;
+    readonly isTagsFromDocumentVisible: boolean;
+    readonly isTagsFromSelectionVisible: boolean;
+    readonly isWorkOrdersVisible: boolean;
+    readonly isWorkOrdersFromDocumentVisible: boolean;
+    readonly isWorkOrdersFromSelectionVisible: boolean;
+    readonly isEquipmentsVisible: boolean;
+    readonly isEquipmentsFromDocumentVisible: boolean;
+    readonly isEquipmentsFromSelectionVisible: boolean;
+    readonly isIocAnnotationsVisible: boolean;
+    readonly isDataFromStidAnnoDetails: boolean;
+    readonly isNotificationsVisible: boolean;
 }
 export interface DataLayerPanelState {
     isOpen: boolean;
@@ -59,6 +60,7 @@ export declare const useDataLayerPanelStore: import("zustand").UseBoundStore<Omi
             isEquipmentsFromSelectionVisible: boolean;
             isIocAnnotationsVisible: boolean;
             isDataFromStidAnnoDetails: boolean;
+            isNotificationsVisible: boolean;
         };
         togglePanel: () => void;
         toggleTags: () => void;

package/src/lib/feature/globalSelection/components/AddToSelectionMenuTrigger/AddToSelectionMenuItem.d.ts

@@ -1,8 +0,0 @@
-import { Guid } from '@equinor/echo-utils';
-import { SelectionGroup } from '../../selectionMenu/selectionTreeStore/selectionTree.store.types';
-interface AddToSelectionMenuItemProps {
-    group: SelectionGroup;
-    onAddToSelection: (groupId: Guid) => void;
-}
-export declare const AddToSelectionMenuItem: (props: AddToSelectionMenuItemProps) => import("react/jsx-runtime").JSX.Element;
-export {};

package/src/lib/feature/globalSelection/components/AddToSelectionMenuTrigger/AddToSelectionMenuTrigger.d.ts

@@ -1,6 +0,0 @@
-import { Guid } from '@equinor/echo-utils';
-interface AddToSelectionMenuTriggerProps {
-    onAddToSelection: (groupId: Guid) => void;
-}
-export declare const AddToSelectionMenuTrigger: (props: AddToSelectionMenuTriggerProps) => import("react/jsx-runtime").JSX.Element;
-export {};

package/src/lib/feature/legend/hooks/useUniqueBadgeItemIdStrings.d.ts

@@ -1,6 +0,0 @@
-import { GlobalSelectionTypes } from '../../globalSelection';
-import { Marker } from '../types/legendMarkerBadge.type';
-/**
- * Returns unique item ID strings from all badges on the marker.
- */
-export declare const useUniqueBadgeItemIdStrings: (marker?: Marker) => GlobalSelectionTypes.ItemIdString[];

package/src/lib/feature/measuringPoint/components/lastRecordedMeasurement/lastRecordedMeasurement.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-import { LastRecordedMeasurementData } from './lastRecordedMeasurement.logic';
-type LastRecordedMeasurementProps = {
-    lastRecordedMeasurement: LastRecordedMeasurementData;
-    failureMechanismDescription: string;
-};
-export declare const LastRecordedMeasurement: React.FC<LastRecordedMeasurementProps>;
-export {};