@equinor/echo-framework 6.2.2 → 6.2.4

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

@@ -10,5 +10,5 @@ interface PositionalItemProps {
 /**
  * An item that can be positioned anywhere in the absolute container.
  */
-export declare const PositionalItem: React.MemoExoticComponent<(props: PositionalItemProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const PositionalItem: React.MemoExoticComponent<(props: PositionalItemProps) => React.JSX.Element>;
 export {};

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

@@ -5,5 +5,5 @@ interface ItemMarkerPopoverContainerProps {
     isPopoverActive: boolean;
     handleClose: () => void;
 }
-export declare const ItemMarkerPopoverContainer: ({ legendId, elements, isPopoverActive, handleClose }: ItemMarkerPopoverContainerProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const ItemMarkerPopoverContainer: ({ legendId, elements, isPopoverActive, handleClose }: ItemMarkerPopoverContainerProps) => import("react").JSX.Element | null;
 export {};

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

@@ -8,5 +8,5 @@ interface MarkerWithPopoverProps {
     readonly itemId: LegendDataId;
     readonly markerId: MarkerId;
 }
-export declare const MarkerWithPopover: (props: MarkerWithPopoverProps) => import("react/jsx-runtime").JSX.Element;
+export declare const MarkerWithPopover: (props: MarkerWithPopoverProps) => import("react").JSX.Element;
 export {};

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

@@ -4,5 +4,5 @@ interface MultipleMarkersByLegendsProps {
     hasPointer: boolean;
     positionId: string;
 }
-export declare const MultipleMarkersByLegends: import("react").MemoExoticComponent<(props: MultipleMarkersByLegendsProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const MultipleMarkersByLegends: import("react").MemoExoticComponent<(props: MultipleMarkersByLegendsProps) => import("react").JSX.Element>;
 export {};

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

@@ -5,4 +5,4 @@ export interface MultipleMarkersBySingleLegendComponentProps {
     hasPointer: boolean;
     positionId: string;
 }
-export declare const MultipleMarkersBySingleLegend: import("react").MemoExoticComponent<(props: MultipleMarkersBySingleLegendComponentProps) => import("react/jsx-runtime").JSX.Element[] | null>;
+export declare const MultipleMarkersBySingleLegend: import("react").MemoExoticComponent<(props: MultipleMarkersBySingleLegendComponentProps) => import("react").JSX.Element[] | null>;

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

@@ -1,4 +1,4 @@
 import { MultipleMarkersBySingleLegendComponentProps } from './MultipleMarkersBySingleLegend';
 type MultipleMarkersBySingleLegendContainerProps = MultipleMarkersBySingleLegendComponentProps;
-export declare const MultipleMarkersBySingleLegendContainer: import("react").MemoExoticComponent<(props: MultipleMarkersBySingleLegendContainerProps) => import("react/jsx-runtime").JSX.Element | null>;
+export declare const MultipleMarkersBySingleLegendContainer: import("react").MemoExoticComponent<(props: MultipleMarkersBySingleLegendContainerProps) => import("react").JSX.Element | null>;
 export {};

package/src/lib/feature/legend/components/popover/LegendPopoverContent.d.ts

@@ -21,4 +21,4 @@ export interface LegendPopoverContentProps {
  * @param {ReadonlyArray<string>} [props.excludedChipLegendTitles] - Optional array of titles to exclude from the legend chips.
  * @param {boolean} [props.showAddToSelectionButton] - Optional flag to show or hide the "Add to Selection" button.
  */
-export declare const LegendPopoverContent: (props: LegendPopoverContentProps) => import("react/jsx-runtime").JSX.Element;
+export declare const LegendPopoverContent: (props: LegendPopoverContentProps) => import("react").JSX.Element;

package/src/lib/feature/legend/components/selectionLegend/SelectionLegend.d.ts

@@ -1 +1 @@
-export declare const SelectionLegendRenderer: import("react").MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element | null>;
+export declare const SelectionLegendRenderer: import("react").MemoExoticComponent<() => import("react").JSX.Element | null>;

package/src/lib/feature/legend/components/selectionLegend/SelectionLegendChip.d.ts

@@ -1,7 +1,8 @@
 interface LegendItemProps {
-    label: string;
-    onClick: (isDisabled: boolean) => void;
-    colors: string[];
+    readonly label: string;
+    readonly onClick: (isActive: boolean) => void;
+    readonly colors: ReadonlyArray<string>;
+    readonly isActive: boolean;
 }
-export declare const SelectionLegendChip: import("react").MemoExoticComponent<(props: LegendItemProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const SelectionLegendChip: import("react").MemoExoticComponent<(props: LegendItemProps) => import("react").JSX.Element>;
 export {};

package/src/lib/feature/legend/components/selectionLegend/components/SelectionLegendActions.d.ts

@@ -2,4 +2,4 @@
  * SelectionLegendActions renders the action buttons for the Selection Legend.
  * It provides options to toggle the visibility of highlights around selection group markers.
  */
-export declare const SelectionLegendActions: () => import("react/jsx-runtime").JSX.Element;
+export declare const SelectionLegendActions: () => import("react").JSX.Element;

package/src/lib/feature/legend/components/selectionLegend/components/SelectionLegendOtherMarkers.d.ts

@@ -1,4 +1,4 @@
 /**
  * Allows the user to select how to display markers that are not in any selection group.
  */
-export declare const SelectionLegendOtherMarkers: () => import("react/jsx-runtime").JSX.Element;
+export declare const SelectionLegendOtherMarkers: () => import("react").JSX.Element;

package/src/lib/feature/legend/components/selectionLegend/selectionLegend.utils.d.ts

@@ -1,6 +1,6 @@
 import { Guid } from '@equinor/echo-utils';
 import { GlobalSelectionItemType } from '../../../globalSelection';
-import type { LegendSelectionGroupKey } from '../../stores/legendUIStore/legendUIStore.types';
+import type { LegendSelectionGroupKey, ToggleableLegend } from '../../stores/legendUIStore/legendUIStore.types';
 import { CombinedMarker } from '../../types/legendMarkerBadge.type';
 /**
  * Key used for markers that don't belong to any selection group
@@ -27,6 +27,12 @@ export declare const shouldSplitGroupsByItemType: (groupId: Guid) => boolean;
  * @returns The standardized group key
  */
 export declare const createSelectionGroupKey: (groupId: Guid, color: string, itemType?: GlobalSelectionItemType) => LegendSelectionGroupKey;
+export declare const isSelectionGroupDisabled: (hiddenSelectionGroupKeys: ReadonlySet<string>, groupId: Guid, colors: ReadonlyArray<string>, itemType?: GlobalSelectionItemType) => boolean;
+/**
+ * Type guard for selection-group-related hidden keys.
+ * This centralizes key format knowledge in one place.
+ */
+export declare const isSelectionGroupKey: (toggleableLegend: ToggleableLegend) => toggleableLegend is LegendSelectionGroupKey;
 /**
  * Checks if a marker is outside any selection group.
  * A marker is outside selection if its highlight color is 'transparent'.

package/src/lib/feature/legend/hooks/useLegendMarkers/useLegendMarkers.logic.d.ts

@@ -36,6 +36,7 @@ export declare const processRawBadges: (rawMarker: RawMarkerData, markerColor: s
 export declare const collectGroupKeys: (markers: ReadonlyArray<ProcessedMarker>) => ReadonlyArray<LegendSelectionGroupKey>;
 /**
  * Filters out markers whose selection group is hidden.
+ * A marker is only hidden when ALL of its selection groups are toggled off.
  */
 export declare const filterHiddenGroups: (markers: ReadonlyArray<ProcessedMarker>, hiddenGroups: ReadonlyArray<ToggleableLegend>) => ReadonlyArray<ProcessedMarker>;
 /**
@@ -55,7 +56,7 @@ export declare const collectSelectionItemIdStrings: (rawMarkers: ReadonlyArray<R
 export declare const processRawMarkers: (rawMarkers: ReadonlyArray<RawMarkerData>, selectedBadgeOption?: LegendBadgeOptionConfig) => ReadonlyArray<ProcessedMarker>;
 interface SelectionInfo {
     readonly highlightColor: string;
-    readonly groupKey: LegendSelectionGroupKey;
+    readonly groupKeys: ReadonlyArray<LegendSelectionGroupKey>;
 }
 /**
  * Gets the selection info (highlight color and group key) for an item from global selection.

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

@@ -0,0 +1,13 @@
+import type { TagNoWithOpenWorkOrders } from '../legendStrategies/workOrderStrategy/workOrder.types';
+import { TagNo } from '@equinor/echo-search';
+/**
+ * Fetches open work orders for the given tags and filters them by data-layer visibility settings.
+ *
+ * @param items - Tag items to fetch open work orders for.
+ * @returns Object containing `tagNosWithOpenWorkOrders` grouped by tag number.
+ */
+export declare function useOpenWorkOrdersByTagNos(items: ReadonlyArray<{
+    tagNo: TagNo;
+}>): {
+    tagNosWithOpenWorkOrders: readonly TagNoWithOpenWorkOrders[];
+};

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

@@ -0,0 +1,2 @@
+import { TagNo, WorkOrderDto } from '@equinor/echo-search';
+export declare function useOpenWorkOrdersByTagsQuery(tagNos: ReadonlyArray<TagNo>): import("@tanstack/react-query").UseQueryResult<NoInfer<readonly WorkOrderDto[]>, Error>;

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

@@ -0,0 +1,15 @@
+import { TagNoWithWorkOrdersWithPermits } from '../types/legendWorkPermits.type';
+import { TagNo } from '@equinor/echo-search';
+/**
+ * Wraps {@link useOpenWorkOrdersByTagNos} and augments every work order with the
+ * matching `workPermitStatuses` from the plant-wide work-permit map.
+ *
+ * This keeps the work-order strategy/legend pipeline fully synchronous: the
+ * async work-permit fetch is contained in a single hook here, and downstream
+ * consumers only see synchronous data.
+ */
+export declare function useOpenWorkOrdersWithWorkPermits(items: ReadonlyArray<{
+    tagNo: TagNo;
+}>): {
+    tagNosWithWorkOrders: readonly TagNoWithWorkOrdersWithPermits[];
+};

package/src/lib/feature/legend/hooks/workOrdersByTagNos.logic.d.ts

@@ -0,0 +1,21 @@
+import { TagNo, WorkOrderDto } from '@equinor/echo-search';
+import { GlobalSelectionTypes } from '../../globalSelection';
+import type { TagNoWithOpenWorkOrders } from '../legendStrategies/workOrderStrategy/workOrder.types';
+interface GetVisibleTagNosWithWorkOrdersParams {
+    readonly items: ReadonlyArray<{
+        readonly tagNo: TagNo;
+    }>;
+    readonly workOrders: ReadonlyArray<WorkOrderDto>;
+    readonly isWorkOrdersFromDocumentVisible: boolean;
+    readonly isWorkOrdersFromSelectionVisible: boolean;
+    readonly selectedWorkOrders: ReadonlyMap<GlobalSelectionTypes.ItemIdString, unknown>;
+}
+/**
+ * Groups work orders by tag and filters them according to the data-layer visibility settings.
+ *
+ * - When work orders from documents are visible, all matched work orders are kept.
+ * - Otherwise, when work orders from selection are visible, only globally selected work orders are kept.
+ * - When neither is visible, nothing is returned.
+ */
+export declare function getVisibleTagNosWithWorkOrders({ items, workOrders, isWorkOrdersFromDocumentVisible, isWorkOrdersFromSelectionVisible, selectedWorkOrders }: GetVisibleTagNosWithWorkOrdersParams): ReadonlyArray<TagNoWithOpenWorkOrders>;
+export {};

package/src/lib/feature/legend/hooks/workOrdersWithWorkPermits.logic.d.ts

@@ -0,0 +1,12 @@
+import { WorkOrderDto } from '@equinor/echo-search';
+import { WorkOrderWithWorkPermits } from '../types/legendWorkPermits.type';
+/**
+ * Derives the tag number from a SAP functional location ID by stripping the 5-char plant prefix.
+ * Returns empty string when the input is undefined or empty.
+ */
+export declare function functionalLocationIdToTagNo(functionalLocationId: string | undefined): string;
+/**
+ * Augments a work order with the matching work-permit statuses looked up by tag number.
+ * Returns a new object — does not mutate the input.
+ */
+export declare function augmentWorkOrder(workOrder: WorkOrderDto, workPermitsByTagNo: Readonly<Record<string, ReadonlyArray<string>>> | undefined): WorkOrderWithWorkPermits;

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

@@ -10,15 +10,14 @@ export type { LegendPopoverContentProps } from './components/popover/LegendPopov
 export { trackEventNewLegendAccordionToggled, trackEventNewLegendSelectedBadgeOptionChanged, trackEventNewLegendSelectedMarkerOptionChanged } from './legendAnalytics';
 export { legendFacade } from './legendFacade';
 export { convertIocAnnotationStateToLegendStatus, getPrioritizedIocAnnotationLegendStatus } from './legendStrategies/iocAnnotationStrategy/hooks/useIocAnnotationMarkers.utils';
-export type { IocAnnotationState } from './legendStrategies/iocAnnotationStrategy/iocAnnotationStrategy.types';
+export { IocAnnotationLegendStatus } from './legendStrategies/iocAnnotationStrategy/iocAnnotationStrategy.types';
 export { getLegendStrategy } from './legendStrategies/legendCollections';
 export { legendSnapShot } from './stores/legendDataStore/legendStore';
 export type { Badge, CombinedMarker, LegendChipData, RawItemAppearance, RawMarkerData } from './types/legendMarkerBadge.type';
 export type { LegendStrategy } from './types/legendStrategy.type';
 export type { LegendBadgeColorMode, LegendBadgeOptionConfig, LegendId, LegendMarkerOptionConfig, LegendOptionConfig, LegendOptionDisplayOption } from './types/legendType';
 export { useLegendMarkerChips } from './hooks/useLegendMarkerChips';
-export { useOpenWorkOrdersByTagNos } from './hooks/useWorkOrdersByTagNos';
-export { useWorkOrdersByTagsQuery } from './hooks/useWorkOrdersByTagsQuery';
+export { useOpenWorkOrdersByTagNos } from './hooks/useOpenWorkOrdersByTagNos';
 export { isCountMode, isIdMode, normalizeBadges } from './logic/normalizeBadges';
 export { getColorForLegendStatus } from './logic/getColorForLegendStatus';
 export { createArrayAccessor, createDateAccessor, createStringAccessor, getPropertyValues } from './logic/propertyAccessor.utils';

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/hooks/useIocAnnotationMarkers.utils.d.ts

@@ -1,13 +1,11 @@
 import type { RawItemAppearance, RawMarkerData } from '../../../types/legendMarkerBadge.type';
-import type { IocAnnotationDto, IocAnnotationFunctionalLocationLookup, IocAnnotationMarkerData, IocAnnotationMarkerDataByTagKey, IocAnnotationState, IocAnnotationTagKey, IocAnnotationTagLookup } from '../iocAnnotationStrategy.types';
+import type { LegendBadgeOptionConfig, LegendMarkerOptionConfig } from '../../../types/legendType';
+import { IocAnnotationDto, IocAnnotationFunctionalLocationLookup, IocAnnotationLegendStatus, IocAnnotationMarkerData, IocAnnotationMarkerDataByTagKey, IocAnnotationTagKey, IocAnnotationTagLookup } from '../iocAnnotationStrategy.types';
 /**
- * Maps an IOC annotation state code (e.g. `ow`, `ip`, `er`) to its corresponding
- * `LegendStatus`. Single source of truth for the conversion — re-exported via
- * `@equinor/echo-framework` so legacy code paths in echopedia-web can consume
- * the same mapping while the new legend rolls out behind a feature flag.
+ * Maps an IOC annotation state code (e.g. `ow`, `ip`, `er`) to its corresponding `IocAnnotationState`.
  */
-export declare function convertIocAnnotationStateToLegendStatus(state: string): IocAnnotationState;
-export declare function getPrioritizedIocAnnotationLegendStatus(iocAnnotationStates: ReadonlyArray<string>): IocAnnotationState;
+export declare function convertIocAnnotationStateToLegendStatus(state: string): IocAnnotationLegendStatus;
+export declare function getPrioritizedIocAnnotationLegendStatus(iocAnnotationStates: ReadonlyArray<string>): IocAnnotationLegendStatus;
 export declare function createIocAnnotationTagKey(tagLookup: IocAnnotationTagLookup): IocAnnotationTagKey;
 export declare function getUniqueSortedIocAnnotationTagLookups(tagLookups: ReadonlyArray<IocAnnotationTagLookup>): ReadonlyArray<IocAnnotationTagLookup>;
 export declare function createIocAnnotationTagLookupQueryKey(sortedTagLookups: ReadonlyArray<IocAnnotationTagLookup>): ReadonlyArray<IocAnnotationTagKey>;
@@ -16,6 +14,6 @@ export declare function buildIocAnnotationMarkerDataByTagKey({ iocAnnotations, f
     readonly iocAnnotations: ReadonlyArray<IocAnnotationDto>;
     readonly functionalLocationLookups: ReadonlyArray<IocAnnotationFunctionalLocationLookup>;
 }): IocAnnotationMarkerDataByTagKey;
-export declare function createIocAnnotationMarkers(markerData: IocAnnotationMarkerData): ReadonlyArray<RawMarkerData>;
-export declare const getIOCMarkerAppearances: (iocAnnotation: IocAnnotationDto) => ReadonlyArray<RawItemAppearance>;
-export declare const getIOCBadgeAppearances: (iocAnnotation: IocAnnotationDto) => ReadonlyArray<RawItemAppearance>;
+export declare function createIocAnnotationMarkers(markerData: IocAnnotationMarkerData, selectedMarkerOption: LegendMarkerOptionConfig, selectedBadgeOption: LegendBadgeOptionConfig): ReadonlyArray<RawMarkerData>;
+export declare const getIOCMarkerAppearances: (iocAnnotation: IocAnnotationDto, selectedMarkerOption: LegendMarkerOptionConfig) => ReadonlyArray<RawItemAppearance>;
+export declare const getIOCBadgeAppearances: (iocAnnotation: IocAnnotationDto, selectedBadgeOption: LegendBadgeOptionConfig) => ReadonlyArray<RawItemAppearance>;

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/iocAnnotationStrategy.types.d.ts

@@ -1,5 +1,4 @@
 import type { IocAnnotationData } from '@equinor/echo-search';
-import { LegendStatus } from '../../../legacyLegend/legend';
 import { type LegendId } from '../../types/legendType';
 export declare const iocAnnotationLegendId: LegendId;
 export type IocAnnotationDto = IocAnnotationData;
@@ -8,7 +7,8 @@ export type TagNo = string;
 export type FunctionalLocation = string;
 export type IocAnnotationTagKey = string;
 export type IocAnnotationMarkerOptions = 'status';
-export type IocAnnotationBadgeOptions = 'count';
+type BadgeKeysFromIocAnnotationLegendData = Pick<IocAnnotationData, 'id'>;
+export type IocAnnotationBadgeOptions = keyof BadgeKeysFromIocAnnotationLegendData | 'count' | 'notificationType';
 export interface IocAnnotationTagLookup {
     readonly tagNo: TagNo;
     readonly instCode: InstCode;
@@ -16,10 +16,20 @@ export interface IocAnnotationTagLookup {
 export interface IocAnnotationFunctionalLocationLookup extends IocAnnotationTagLookup {
     readonly functionalLocation: FunctionalLocation;
 }
-export type IocAnnotationState = LegendStatus.OnWatch | LegendStatus.InProgress | LegendStatus.IocAnnotationError | LegendStatus.Note | LegendStatus.Archived | LegendStatus.Unknown;
+export declare const IocAnnotationLegendStatus: {
+    readonly OnWatch: "On watch";
+    readonly InProgress: "In progress";
+    readonly Error: "Error";
+    readonly Note: "Note";
+    readonly Archived: "Archived";
+    readonly Unknown: "Unknown";
+    readonly Multiple: "Multiple";
+};
+export type IocAnnotationLegendStatus = (typeof IocAnnotationLegendStatus)[keyof typeof IocAnnotationLegendStatus];
 export interface IocAnnotationMarkerData {
-    readonly status: IocAnnotationState;
+    readonly status: IocAnnotationLegendStatus;
     readonly tagNo: TagNo;
     readonly iocAnnotations: ReadonlyArray<IocAnnotationDto>;
 }
 export type IocAnnotationMarkerDataByTagKey = ReadonlyMap<IocAnnotationTagKey, IocAnnotationMarkerData>;
+export {};

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/utils/getColorForIocAnnotationLegendStatus.d.ts

@@ -0,0 +1,2 @@
+import type { LegendOptionConfig } from '../../../types/legendType';
+export declare const getColorForIocAnnotationLegendStatus: (title: string, selectedProperty: LegendOptionConfig) => string;

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/utils/getIocAnnotationBadgesByPropertyName.d.ts

@@ -0,0 +1,7 @@
+import type { LegendDataId } from '../../../types/legendType';
+import type { IocAnnotationDto } from '../iocAnnotationStrategy.types';
+export type IocAnnotationBadge = {
+    readonly title: string;
+    readonly itemId: LegendDataId | undefined;
+};
+export declare function getIocAnnotationBadgesByPropertyName(propertyName: string, iocAnnotation: IocAnnotationDto): ReadonlyArray<IocAnnotationBadge>;

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/utils/getLegendStatusForIocAnnotationLegend.d.ts

@@ -0,0 +1 @@
+export declare function getStatusColorForIocAnnotation(iocAnnotationStatus: string): string;

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/utils/getNotificationTypeColor.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolves the color for a given notification type.
+ * Falls back to the default color if the notification type is not recognized.
+ *
+ * @param notificationType - The notification type identifier (M1-M9)
+ * @returns The color string (hex code or CSS variable) for the notification type
+ */
+export declare function getColorForNotificationType(notificationType: string): string;

package/src/lib/feature/legend/legendStrategies/iocAnnotationStrategy/utils/notificationType.utils.d.ts

@@ -0,0 +1,3 @@
+import { NotificationTypes } from '../../../../../types/notificationTypes';
+export declare function isNotificationType(value: string): value is NotificationTypes;
+export declare function normalizeNotificationType(notificationType: string): NotificationTypes | undefined;

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

@@ -4,5 +4,5 @@ interface NotificationPopoverProps {
     legendDataId: LegendDataId;
     notification: NotificationItemCardData;
 }
-export declare const NotificationPopover: (props: NotificationPopoverProps) => import("react/jsx-runtime").JSX.Element;
+export declare const NotificationPopover: (props: NotificationPopoverProps) => import("react").JSX.Element;
 export {};

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

@@ -1,5 +1,5 @@
 import { type LegendDataId, type LegendNotificationId } from '../../../types/legendType';
-import type { EndDateStatusText, NotificationLegendData } from '../notificationStrategy.types';
+import type { NotificationLegendData } from '../notificationStrategy.types';
 /**
  * Type guard for notification legend data IDs.
  * Notification is not a selection-based legend, so the dataId is not directly tied to global selection item IDs.
@@ -9,7 +9,3 @@ export declare const isNotificationDataId: (dataId: LegendDataId) => dataId is L
  * Determines the appropriate icon name for a marker based on the record type
  */
 export declare const getIconForMarker: (notification: NotificationLegendData) => string;
-/**
- * Returns user-friendly end date status text based on the required end date of a notification.
- */
-export declare function getEndDateStatusText(date: Date | undefined): EndDateStatusText;

package/src/lib/feature/legend/legendStrategies/workOrderStrategy/api/fetchWorkOrdersByLegendIdType.d.ts

@@ -0,0 +1,7 @@
+import { PopoverProps, WorkOrderPopover } from '../workOrder.types';
+/**
+ * Fetches work orders for a given legend data ID and filters them by the provided item IDs.
+ * Only supports tag-based lookups; returns undefined for non-tag legend data IDs
+ * or when no matching work orders are found.
+ */
+export declare function fetchWorkOrdersByLegendIdType({ legendDataId, itemIds }: PopoverProps): Promise<WorkOrderPopover[] | undefined>;

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

@@ -1,4 +1,4 @@
-import { WorkOrderPopover } from '../workOrderPopover.types';
+import { WorkOrderPopover } from '../workOrder.types';
 /**
  * Renders the popover content for a single work order entry in the legend UI.
  *
@@ -13,4 +13,4 @@ import { WorkOrderPopover } from '../workOrderPopover.types';
  */
 export declare const WorkOrderPopoverContent: ({ wo }: {
     wo: WorkOrderPopover;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => import("react").JSX.Element;

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

@@ -0,0 +1,13 @@
+import { LegendDataId } from '../../../types/legendType';
+import { RawMarkerData } from '../../../types/legendMarkerBadge.type';
+/**
+ * Creates legend markers for work orders grouped by tag.
+ *
+ * Fully synchronous — all data (including work permits) is resolved upstream
+ * by {@link useOpenWorkOrdersWithWorkPermits}, so this hook stays a single
+ * synchronous pass with no effects or local state.
+ *
+ * @param itemIds - Current legend selection ids.
+ * @returns An array of `RawMarkerData`, or an empty array when no data is available.
+ */
+export declare const useCreateWorkOrderMarkers: (itemIds: ReadonlyArray<LegendDataId>) => ReadonlyArray<RawMarkerData>;

package/src/lib/feature/legend/legendStrategies/workOrderStrategy/logic/getColorForStatus.d.ts

@@ -0,0 +1,2 @@
+/** Returns the EDS color token for 'Active' or 'Completed' status titles, or undefined for unknown values. */
+export declare const getColorForStatus: (title: string) => string | undefined;

package/src/lib/feature/legend/legendStrategies/workOrderStrategy/logic/getStatusColorForWorkPermit.d.ts

@@ -0,0 +1 @@
+export declare function getStatusColorForWorkPermit(workPermitStatus: string): string;

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

@@ -0,0 +1,24 @@
+import { LegendDataId } from '../../types/legendType';
+import { LegendStatus } from '../../../legacyLegend/legend';
+import { WorkOrderBadgeProperty, WorkOrderMarkerProperty } from './workOrderLegendStrategy.constants';
+import { TagNo, WorkOrderDto } from '@equinor/echo-search';
+export interface TagNoWithOpenWorkOrders {
+    readonly tagNo: TagNo;
+    readonly openWorkOrders: ReadonlyArray<WorkOrderDto>;
+}
+export type PopoverProps = {
+    readonly legendDataId: LegendDataId;
+    readonly itemIds?: ReadonlyArray<LegendDataId>;
+};
+export interface WorkOrderPopover {
+    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;
+}
+export type AllWorkOrderPropertyOptions = WorkOrderMarkerProperty | WorkOrderBadgeProperty;
+export type EndDateStatusText = 'Expired' | '0-7 days' | '8 days - 1 month' | '1-3 months' | '3-6 months' | '6-12 months' | '> 1 year' | LegendStatus.Unknown;

package/src/lib/feature/legend/legendStrategies/workOrderStrategy/workOrder.utils.d.ts

@@ -1,16 +1,16 @@
 import { WorkOrderDto } from '@equinor/echo-search';
-import { PopoverProps, WorkOrderPopover } from './workOrderPopover.types';
+import { RawItemAppearance } from '../../types/legendMarkerBadge.type';
+import { WorkOrderWithWorkPermits } from '../../types/legendWorkPermits.type';
+type WorkOrderTypeId = Readonly<Pick<WorkOrderDto, 'orderTypeId'>>;
 /**
- * Fetches work orders for a given legend data ID and filters them by the provided item IDs.
- * Only supports tag-based lookups; returns undefined for non-tag legend data IDs
- * or when no matching work orders are found.
+ * Determines the icon name for a work order from its order type ID.
+ * Delegates icon selection to setWorkOrderIconName.
  */
-export declare function fetchWorkOrdersByLegendIdType({ legendDataId, itemIds }: PopoverProps): Promise<WorkOrderPopover[] | undefined>;
-type WorkOrderIconSource = Readonly<Pick<WorkOrderDto, 'orderTypeId'>>;
+export declare function getIconForWorkOrder(workOrder: WorkOrderTypeId): string;
 /**
- * Determines the icon name for a collection of work orders based on their order type IDs.
- * Returns a group icon when multiple distinct order types are present,
- * or a type-specific icon when all work orders share the same order type.
+ * Creates raw appearance entries for a work order based on the selected property.
+ * Fully synchronous — `workPermit` data is resolved upstream by
+ * {@link useOpenWorkOrdersWithWorkPermits} and read from the augmented work order.
  */
-export declare function getIconForWorkOrder(workOrders: ReadonlyArray<WorkOrderIconSource>): "workorders_pm01" | "workorders_pm02" | "workorders_pm03" | "workorders_pm04" | "workorders_pm05" | "workorders_pm06" | "workorders_pm10" | "workorders_pm15" | "workorders_pm20" | "workorders_main_group";
+export declare function getAppearances(workOrder: WorkOrderWithWorkPermits, propertyName: string): ReadonlyArray<RawItemAppearance>;
 export {};

package/src/lib/feature/legend/legendStrategies/workOrderStrategy/workOrderLegendStrategy.constants.d.ts

@@ -0,0 +1,6 @@
+import { LegendBadgeOptionConfig, LegendMarkerOptionConfig } from '../../types/legendType';
+import { WorkOrderDto } from '@equinor/echo-search';
+export type WorkOrderMarkerProperty = keyof Pick<WorkOrderDto, 'orderTypeId' | 'basicFinishDateTime'> | 'activeStatusIds';
+export type WorkOrderBadgeProperty = keyof Pick<WorkOrderDto, 'workOrderId' | 'revisionId' | 'orderTypeId'> | 'count' | 'workPermit';
+export declare const LEGEND_MARKER_OPTIONS: ReadonlyArray<LegendMarkerOptionConfig<WorkOrderMarkerProperty>>;
+export declare const LEGEND_BADGE_OPTIONS: ReadonlyArray<LegendBadgeOptionConfig<WorkOrderBadgeProperty>>;

package/src/lib/feature/legend/logic/getColorForLegendStatus.d.ts

@@ -1,5 +1,6 @@
+import { LegendStatus } from '../types/legendType';
 /**
  * Wrapper for pre-existing legend status colors, to avoid importing legacy utils into new legend code.
  * Also handles new 'Unknown' and 'Multiple' statuses correctly, which legacy utils do not.
  */
-export declare const getColorForLegendStatus: (status: string) => string;
+export declare const getColorForLegendStatus: (status: LegendStatus | string) => string;

package/src/lib/feature/legend/logic/getEndDateStatusText.logic.d.ts

@@ -0,0 +1,5 @@
+import { EndDateStatusText } from '../legendStrategies/workOrderStrategy/workOrder.types';
+/**
+ * Returns user-friendly end date status text based on the required end date of a notification.
+ */
+export declare function getEndDateStatusText(date: Date | undefined): EndDateStatusText;

package/src/lib/feature/legend/logic/getRequiredEndDateTimeColor.logic.d.ts

@@ -0,0 +1,2 @@
+/** Returns the EDS color token for a required-end-date time bucket (e.g. "0-7 days"), or undefined for unrecognised values. */
+export declare const getRequiredEndDateTimeColor: (title: string) => string | undefined;

package/src/lib/feature/legend/logic/legendChips.logic.d.ts

@@ -1,8 +1,9 @@
 import type { LegendChipProps } from '@equinor/echo-components';
 import type { LegendChipData, RawMarkerData, ToggleableItem } from '../types/legendMarkerBadge.type';
-import type { LegendId } from '../types/legendType';
+import { type LegendId } from '../types/legendType';
 export declare const toChipProps: (chip: LegendChipData, hiddenItems: ReadonlyArray<string>, legendId: LegendId) => LegendChipProps;
 export declare const toMarkerChipData: (rawMarker: RawMarkerData) => ReadonlyArray<LegendChipData>;
 export declare const toBadgeChipData: (rawMarker: RawMarkerData) => ReadonlyArray<LegendChipData>;
 export declare function isHiddenItem(item: ToggleableItem, hiddenItems: ReadonlyArray<string>): boolean;
 export declare const setHiddenItem: (item: ToggleableItem, isHidden: boolean, legendId: LegendId) => void;
+export declare const createMultipleChipProps: () => LegendChipProps;

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

@@ -30,10 +30,10 @@ export declare const selectionGuards: SelectionGuardMap;
  */
 export declare const isGlobalSelectionItemId: (id: LegendDataId) => id is GlobalSelectionLegendDataId;
 /**
- * Converts any LegendDataId to a stable, unique string.
+ * Converts any LegendDataId to a stable, human-readable 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.
+ * For non-selection types (e.g. notifications, IOC annotations) this prefers
+ * dedicated conversion logic and falls back to joining object values.
  */
 export declare const dataIdToString: (id: LegendDataId) => LegendDataIdString;
 /**

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

@@ -3,6 +3,7 @@ import type { LegendDataId } from './legendType';
 export interface RawItemAppearance {
     readonly getTitle: () => string;
     readonly getColor: () => string;
+    readonly getItemId?: () => LegendDataId;
 }
 /**
  * Raw marker data from strategy. Contains the source information and marker data.
@@ -80,8 +81,8 @@ export interface ProcessedMarker extends CombinedMarker {
     /** Individual marker appearances used for per-appearance counting */
     getMarkerAppearances: () => ReadonlyArray<RawItemAppearance>;
     /**
-     * Selection group key for toggle tracking (selection legend toggles).
-     * Used to determine if this marker should be hidden when a selection group is toggled off.
+     * All selection group keys this marker belongs to.
+     * A marker is hidden only when ALL its group keys are toggled off.
      */
-    getSelectionGroupKey: () => LegendSelectionGroupKey;
+    getSelectionGroupKeys: () => ReadonlyArray<LegendSelectionGroupKey>;
 }

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

@@ -11,6 +11,11 @@ export declare const knownLegendIds: {
     notificationLegendId: "Notification Legend";
     iocAnnotationLegendId: "IOC Annotation Legend";
 };
+export declare const LegendStatus: {
+    readonly Multiple: "Multiple";
+    readonly Unknown: "Unknown";
+};
+export type LegendStatus = (typeof LegendStatus)[keyof typeof LegendStatus];
 export interface LegendState<MarkerOptionType = string, BadgeOptionType = string> {
     readonly legendId: LegendId;
     readonly isEnabled: boolean;
@@ -46,7 +51,7 @@ interface LegendOptionConfigBase<T = string> {
     readonly showChipsInViewportOnly?: boolean;
 }
 export type LegendMarkerOptionConfig<T = string> = LegendOptionConfigBase<T>;
-export type LegendBadgeColorMode = 'status' | 'marker';
+export type LegendBadgeColorMode = 'marker';
 /**
  * Configuration for badge options. Badges can have display options to control
  * how badge text is rendered (displayName, id, or count).
@@ -54,8 +59,9 @@ export type LegendBadgeColorMode = 'status' | 'marker';
 export interface LegendBadgeOptionConfig<T = string> extends LegendOptionConfigBase<T> {
     readonly enableDisplayOptions?: boolean;
     readonly displayOption?: LegendOptionDisplayOption;
+    readonly displayOptionLabel?: string;
     /**
-     * Controls how badge color is determined. 'status' uses the same status color resolver as markers, while 'marker' inherits the marker color.
+     * Controls how badge color is determined. 'marker' inherits the marker color.
      * When set to 'marker', the generic processRawBadges resolves badge color from marker appearances automatically.
      */
     readonly badgeColorMode?: LegendBadgeColorMode;

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

@@ -0,0 +1,12 @@
+import { TagNo, WorkOrderDto } from '@equinor/echo-search';
+/**
+ * A {@link WorkOrderDto} extended with the resolved work-permit statuses for its tag.
+ * The field is optional so plain `WorkOrderDto` values remain assignable.
+ */
+export interface WorkOrderWithWorkPermits extends WorkOrderDto {
+    readonly workPermitStatuses?: ReadonlyArray<string>;
+}
+export interface TagNoWithWorkOrdersWithPermits {
+    readonly tagNo: TagNo;
+    readonly workOrders: ReadonlyArray<WorkOrderWithWorkPermits>;
+}

package/src/lib/feature/measuringPoint/FullMeasuringPointItem.d.ts

@@ -21,5 +21,5 @@ type FullMeasuringPointItemProps = {
  *          - Detailed measuring point information, including measurements.
  *
  **/
-export declare const FullMeasuringPointItem: ({ measuringPointProps, measurements }: FullMeasuringPointItemProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FullMeasuringPointItem: ({ measuringPointProps, measurements }: FullMeasuringPointItemProps) => import("react").JSX.Element;
 export {};

package/src/lib/feature/measuringPoint/components/measuringPointDetails/labelledImageList.d.ts

@@ -3,5 +3,5 @@ interface LabelledImageListProps {
     documentId: string;
     attachments: Attachment[];
 }
-export declare const LabelledImageList: ({ documentId, attachments }: LabelledImageListProps) => import("react/jsx-runtime").JSX.Element;
+export declare const LabelledImageList: ({ documentId, attachments }: LabelledImageListProps) => import("react").JSX.Element;
 export {};

package/src/lib/feature/measuringPoint/components/measuringPointDetails/lastReportedFields.d.ts

@@ -4,5 +4,5 @@ type LastReportedFieldsProps = {
     measuringPointProps: Pick<MeasuringPointData, 'measuringPosition' | 'measuringPointId' | 'quantitativeCharacteristicId' | 'tagPlantId' | 'tagId' | 'measuringPoint' | 'equipmentId'>;
     lastRecordedMeasurement: MeasurementDto;
 };
-export declare const LastReportedFields: ({ measuringPointProps, lastRecordedMeasurement }: LastReportedFieldsProps) => import("react/jsx-runtime").JSX.Element;
+export declare const LastReportedFields: ({ measuringPointProps, lastRecordedMeasurement }: LastReportedFieldsProps) => import("react").JSX.Element;
 export {};