@equinor/echo-framework 2.3.0 → 2.4.0

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

@@ -1,10 +1,13 @@
 import { Guid } from '@equinor/echo-utils';
+import { GlobalSelectionItemType } from '../../../../globalSelection';
 import { Badge, Marker } from '../../../types/legendMarkerBadge.type';
 export interface GroupKey {
-    /** Helper to get the full string representation of the group key based on groupId and color */
+    /** Helper to get the full string representation of the group key based on groupId, color, and optional itemType */
     toString: () => string;
     groupId: Guid;
     color: string;
+    /** Optional item type for local selection which will be split by type */
+    itemType?: GlobalSelectionItemType;
 }
 export interface BadgeGroup {
     groupKey: GroupKey;

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

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

package/src/lib/feature/legend/components/selectionLegend/hooks/useSelectionGroupsForLegendRenderer.d.ts

@@ -0,0 +1,5 @@
+import { SelectionGroupDisplay } from './useSelectionGroupsForLegendRenderer.utils';
+/**
+ * Hook to get selection groups formatted for the legend renderer.
+ */
+export declare const useSelectionGroupsForLegendRenderer: () => SelectionGroupDisplay[];

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

@@ -0,0 +1,17 @@
+import { Guid } from '@equinor/echo-utils';
+import { GlobalSelectionItemType, SelectionGroup } from '../../../../globalSelection';
+import { GroupedMarker } from '../../pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types';
+export interface SelectionGroupDisplay {
+    readonly label: string;
+    readonly highlightColors: string[];
+    readonly selectionGroupId: Guid;
+    readonly itemType?: GlobalSelectionItemType;
+}
+type GroupMapKey = string;
+type GroupMap = Record<GroupMapKey, SelectionGroupDisplay>;
+/**
+ * Builds a map of selection groups with their colors from grouped markers.
+ * Groups markers by selection group, collecting all unique colors for each group.
+ */
+export declare function buildSelectionGroupMap(allGroupedMarkers: GroupedMarker[] | undefined, selectionGroups: SelectionGroup[]): GroupMap;
+export {};

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

@@ -1,5 +1,5 @@
 import { Guid } from '@equinor/echo-utils';
-import { GlobalSelectionTypes, SelectionGroup } from '../../../globalSelection';
+import { GlobalSelectionItemType, GlobalSelectionTypes, SelectionGroup } from '../../../globalSelection';
 import { GroupedMarker, GroupKey } from '../pdfMarkers/utils/splitMarkerByBadgeSelectionGroup.types';
 /**
  * TODO: Remove this flag when Selection Legend is stable and ready for production
@@ -15,23 +15,26 @@ export declare const NOT_IN_SELECTION_GROUP_KEY: GroupKey;
  */
 export declare const extractSelectionGroupItemIds: (selectionGroup: SelectionGroup) => GlobalSelectionTypes.ItemId[];
 /**
- * Gets the most frequently used color for a selection group
+ * Determines if groups should be split by item type.
+ * Only true for the default local selection group (Local Selection).
  */
-export declare const getSelectionGroupMostUsedColor: (selectionGroup: SelectionGroup, allGroups: SelectionGroup[]) => string | undefined;
+export declare const shouldSplitGroupsByItemType: (groupId: Guid) => boolean;
 /**
  * Creates a standardized group key for a selection group.
- * This key is used across the legend system to:
+ *
+ * Used across the legend system to:
  * - Identify marker variants split by selection groups (viewport)
  * - Toggle visibility of selection groups (SelectionLegendRenderer)
  * - Filter hidden selection groups (groupMarkersBySelection)
  *
- * Format as string: `group_${groupId}_${color}`
+ * Format: `group_${groupId}_${color}` or `group_${groupId}_${itemType}_${color}` for global selection
  *
  * @param groupId - The unique identifier of the selection group
  * @param color - The highlight color for the group
+ * @param itemType - Optional item type for local selection which will be split by type
  * @returns The standardized group key
  */
-export declare const createSelectionGroupKey: (groupId: Guid, color: string) => GroupKey;
+export declare const createSelectionGroupKey: (groupId: Guid, color: string, itemType?: GlobalSelectionItemType) => GroupKey;
 /**
  * Checks if a marker belongs to the "Not in Selection" group.
  *

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

@@ -1,6 +1,6 @@
 import { getLegendStrategy, injectLegendStrategy } from './legendStrategies/legendCollections';
 import { isLegendDataIdEqualWithTag } from './logic/isLegendDataIdEqualWithTag';
-import { legendExistsInLegendStore, legendSnapShot, useAllLegends, useLegendById } from './stores/legendDataStore/legendStore';
+import { legendExistsInLegendStore, legendSnapShot, legendStoreSubscribe, useAllLegends, useLegendById } from './stores/legendDataStore/legendStore';
 import { legendExistsInLegendUIStore, useLegendUIById } from './stores/legendUIStore/legendUIStore';
 import { visibleDataAsTagsSnapshot } from './stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore';
 import { LegendId } from './types/legendType';
@@ -17,13 +17,7 @@ export declare const legendFacade: Readonly<{
         useById: typeof useLegendById;
         exists: typeof legendExistsInLegendStore;
         snapshot: typeof legendSnapShot;
-        subscribe: {
-            (listener: (selectedState: import("./stores/legendDataStore/legendStore").LegendStoreData & import("./stores/legendDataStore/legendStore").LegendStoreActions, previousSelectedState: import("./stores/legendDataStore/legendStore").LegendStoreData & import("./stores/legendDataStore/legendStore").LegendStoreActions) => void): () => void;
-            <U>(selector: (state: import("./stores/legendDataStore/legendStore").LegendStoreData & import("./stores/legendDataStore/legendStore").LegendStoreActions) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-                equalityFn?: ((a: U, b: U) => boolean) | undefined;
-                fireImmediately?: boolean;
-            } | undefined): () => void;
-        };
+        subscribe: typeof legendStoreSubscribe;
     };
     ui: {
         useById: typeof useLegendUIById;
@@ -97,7 +91,40 @@ export declare const legendFacade: Readonly<{
                 } | undefined): () => void;
             };
         }, "setState"> & {
-            setState(nextStateOrUpdater: import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore | Partial<import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore> | ((state: import("immer").WritableDraft<import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+            setState(nextStateOrUpdater: import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore | Partial<import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore").VisibleDataAsTagsStore> | ((state: {
+                tags: {
+                    tagNo: string;
+                    instCode: string;
+                    equipmentId: string | undefined;
+                    tagSummary: {
+                        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;
+                    };
+                }[];
+                isPending: boolean;
+                updateTags: (tags: import("./stores/legendVisibleDataAsTagsStore/legendVisibleDataAsTagsStore.type").TagWithEquipmentId[]) => void;
+                setIsPending: (isPending: boolean) => void;
+            }) => void), shouldReplace?: boolean | undefined, action?: string | {
                 type: string;
             } | undefined): void;
         }>;

package/src/lib/feature/legend/stores/legendDataStore/legendStore.d.ts

@@ -1,4 +1,3 @@
-import { PersistOptions } from 'zustand/middleware';
 import { LegendId, LegendState } from '../../types/legendType';
 type LegendsDictionary = Record<LegendId, LegendState>;
 export interface LegendStoreData {
@@ -12,37 +11,6 @@ export interface LegendStoreActions {
     initializeLegendInStore: (legendId: LegendId) => void;
 }
 type LegendStore = LegendStoreData & LegendStoreActions;
-type PersistedLegendState = Omit<LegendState, 'isLoading'>;
-type PersistedLegendStoreData = {
-    legends: Record<LegendId, PersistedLegendState>;
-};
-export declare const useLegendStore: import("zustand").UseBoundStore<Omit<Omit<Omit<Omit<import("zustand").StoreApi<LegendStore>, "setState"> & {
-    setState<A extends string | {
-        type: string;
-    }>(partial: LegendStore | Partial<LegendStore> | ((state: LegendStore) => LegendStore | Partial<LegendStore>), replace?: boolean | undefined, action?: A | undefined): void;
-}, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: LegendStore, previousSelectedState: LegendStore) => void): () => void;
-        <U>(selector: (state: LegendStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}, "persist"> & {
-    persist: {
-        setOptions: (options: Partial<PersistOptions<LegendStore, PersistedLegendStoreData>>) => void;
-        clearStorage: () => void;
-        rehydrate: () => Promise<void> | void;
-        hasHydrated: () => boolean;
-        onHydrate: (fn: (state: LegendStore) => void) => () => void;
-        onFinishHydration: (fn: (state: LegendStore) => void) => () => void;
-        getOptions: () => Partial<PersistOptions<LegendStore, PersistedLegendStoreData>>;
-    };
-}, "setState"> & {
-    setState(nextStateOrUpdater: LegendStore | Partial<LegendStore> | ((state: import("immer").WritableDraft<LegendStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
-        type: string;
-    } | undefined): void;
-}>;
 /**
  * Hook to access a legend by ID with optional property selection for optimized re-renders.
  *
@@ -90,11 +58,39 @@ export declare function legendExistsInLegendStore(legendId: LegendId): boolean;
 export declare function useAllLegends(): LegendState[];
 export declare function useAllLegends<T>(selector: (legends: LegendState[]) => T): T;
 export declare function legendSnapShot(): LegendStore;
-export declare const legendStoreSubscribe: {
-    (listener: (selectedState: LegendStore, previousSelectedState: LegendStore) => void): () => void;
-    <U>(selector: (state: LegendStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-        equalityFn?: ((a: U, b: U) => boolean) | undefined;
-        fireImmediately?: boolean;
-    } | undefined): () => void;
-};
+/**
+ * Subscribe to legend store changes with optional selector for granular updates.
+ *
+ * NOTE: This wrapper is required because useLegendStore has an explicit type annotation
+ * (UseBoundStore<StoreApi<T>>) to prevent rollup build errors with useLegacyTypescriptPlugin: false.
+ *
+ * Without explicit type, TypeScript infers Immer's internal types (WritableNonArrayDraft, etc.)
+ * which use complex generics that rollup's @rollup/plugin-typescript cannot "name" in generated
+ * .d.ts files, causing TS4023: "Exported variable has or is using name 'X' but cannot be named."
+ *
+ * The explicit type hides these internals from rollup, but also removes subscribeWithSelector's
+ * enhanced subscribe(selector, listener) signature. This wrapper manually restores both overloads.
+ *
+ * @example
+ * // Watch entire store:
+ * const unsubscribe = legendStoreSubscribe((state) => console.log('Changed:', state));
+ *
+ * @example
+ * // Watch specific property:
+ * const unsubscribe = legendStoreSubscribe(
+ *   (state) => state.legends['Tag Legend']?.isEnabled,
+ *   (isEnabled, prevIsEnabled) => console.log('Enabled changed:', isEnabled)
+ * );
+ */
+export declare function legendStoreSubscribe(listener: (state: LegendStore, prevState: LegendStore) => void): () => void;
+export declare function legendStoreSubscribe<U>(selector: (state: LegendStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+    equalityFn?: (a: U, b: U) => boolean;
+    fireImmediately?: boolean;
+}): () => void;
+export declare const getLegendStoreState: () => LegendStore;
+/**
+ * TEST ONLY: Reset legend store to a specific state.
+ * Only use this in tests for setup/cleanup.
+ */
+export declare const __TEST__resetLegendStore: (state: Partial<LegendStoreData>) => void;
 export {};

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

@@ -1,11 +1,10 @@
+import { type StoreApi, type UseBoundStore } from 'zustand';
 import { LegendId } from '../../types/legendType';
 import { LegendUIState, LegendUIStore } from './legendUIStore.types';
 /**
  * Non-persisted store for managing UI state of legends, such as accordion expansion and hidden markers/badges.
  */
-export declare const useLegendUIStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<LegendUIStore>, "setState"> & {
-    setState(nextStateOrUpdater: LegendUIStore | Partial<LegendUIStore> | ((state: import("immer").WritableDraft<LegendUIStore>) => void), shouldReplace?: boolean | undefined): void;
-}>;
+export declare const useLegendUIStore: UseBoundStore<StoreApi<LegendUIStore>>;
 /**
  * Hook to access a legend by ID with optional property selection for optimized re-renders.
  *

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

@@ -1,3 +1,4 @@
+import { MarkerId } from '../../components/pdfMarkers/utils/markerId.utils';
 import { LegendId } from '../../types/legendType';
 export interface LegendUIState {
     readonly isAccordionExpanded: boolean;
@@ -8,6 +9,10 @@ export type LegendUIDictionary = Record<LegendId, LegendUIState>;
 export type MarkersOutsideSelectionVisibility = 'Show' | 'Ghost' | 'Hide';
 export type LegendUIStoreValues = {
     readonly legends: LegendUIDictionary;
+    readonly activePopover: {
+        readonly id?: MarkerId;
+        readonly elements: ReadonlyArray<React.ReactElement>;
+    };
     readonly selectionLegend: {
         readonly isHighlightVisible: boolean;
         readonly markersOutsideSelectionVisibility: MarkersOutsideSelectionVisibility;
@@ -28,5 +33,7 @@ export interface LegendUIStoreActions {
     setMarkersOutsideSelectionVisibility: (visibility: MarkersOutsideSelectionVisibility) => void;
     initializeLegendInStore: (legendId: LegendId) => void;
     setSelectionLegendIsHighlightVisible: (visible: boolean) => void;
+    setActivePopoverId: (popoverId: MarkerId | undefined) => void;
+    setActivePopoverElements: (elements: ReadonlyArray<React.ReactElement>) => void;
 }
 export type LegendUIStore = LegendUIStoreValues & LegendUIStoreActions;

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

@@ -32,7 +32,40 @@ export declare const useVisibleDataAsTagsStore: import("zustand").UseBoundStore<
         } | undefined): () => void;
     };
 }, "setState"> & {
-    setState(nextStateOrUpdater: VisibleDataAsTagsStore | Partial<VisibleDataAsTagsStore> | ((state: import("immer").WritableDraft<VisibleDataAsTagsStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+    setState(nextStateOrUpdater: VisibleDataAsTagsStore | Partial<VisibleDataAsTagsStore> | ((state: {
+        tags: {
+            tagNo: string;
+            instCode: string;
+            equipmentId: string | undefined;
+            tagSummary: {
+                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;
+            };
+        }[];
+        isPending: boolean;
+        updateTags: (tags: TagWithEquipmentId[]) => void;
+        setIsPending: (isPending: boolean) => void;
+    }) => void), shouldReplace?: boolean | undefined, action?: string | {
         type: string;
     } | undefined): void;
 }>;

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

@@ -55,7 +55,26 @@ export declare const useLegendVisibleDataStore: import("zustand").UseBoundStore<
         } | undefined): () => void;
     };
 }, "setState"> & {
-    setState(nextStateOrUpdater: LegendVisibleDataStore | Partial<LegendVisibleDataStore> | ((state: import("immer").WritableDraft<LegendVisibleDataStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+    setState(nextStateOrUpdater: LegendVisibleDataStore | Partial<LegendVisibleDataStore> | ((state: {
+        data: {
+            Tag: {
+                [x: string]: {
+                    instCode: string;
+                    tagNo: string;
+                }[];
+            };
+            Equipment: {
+                [x: string]: {
+                    equipmentId: string;
+                }[];
+            };
+        };
+        addData: <T extends KnownDataTypeKeys>(type: T, key: string, value: ResolvedDataType<T>[]) => void;
+        removeData: (key: string) => void;
+        getData: <T extends KnownDataTypeKeys>(type: T) => ResolvedDataType<T>[];
+        useDataByType: <T extends KnownDataTypeKeys>(type: T) => ResolvedDataType<T>[];
+        getAll: () => LegendDataId[];
+    }) => void), shouldReplace?: boolean | undefined, action?: string | {
         type: string;
     } | undefined): void;
 }>;

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

@@ -1,3 +1,4 @@
+import { GlobalSelectionTypes } from '../../globalSelection';
 import { Marker } from './legendMarkerBadge.type';
 import { LegendDataId, LegendId, LegendOptionConfig } from './legendType';
 /**
@@ -28,14 +29,17 @@ export interface LegendStrategy {
      */
     useMarkers: (itemIds: ReadonlyArray<LegendDataId>, isViewport?: boolean) => ReadonlyArray<Marker>;
     /**
-     * Returns popover content that supports pagination for the given itemId.
+     * Returns popover content that supports pagination for the given legendDataId.
+     * One legendDataId can have multiple items associated with it, for example a tag can have multiple work orders.
+     * Often we don't want to show all items (eg. when items are grouped), so we provide itemIds to filter the content to only relevant items.
      *
      * 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} itemId - The identifier for the legend item for which to render popover content.
+     * @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.
      * @returns A Promise resolving to one or more React elements to display in the popover.
      */
-    popoverContent: (itemId: LegendDataId) => Promise<React.JSX.Element | ReadonlyArray<React.JSX.Element>>;
+    popoverContent: (legendDataId: LegendDataId, itemIds: ReadonlyArray<GlobalSelectionTypes.ItemId>) => 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/hooks/useOpenPrepview.d.ts

@@ -29,7 +29,7 @@ export declare function useOpenPrepview(): (args: {
         punchId?: string;
         instCode?: string;
     };
-    panelKey: string;
+    panelKey?: string;
     keepLastNavigationItem?: boolean;
     allowToggle?: boolean;
 }) => void;

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

@@ -1,4 +1,3 @@
-import { WritableDraft } from 'immer';
 export interface PanelUserSettings {
     isTagsVisible: boolean;
     isTagsFromDocumentVisible: boolean;
@@ -45,7 +44,35 @@ export declare const useDataLayerPanelStore: import("zustand").UseBoundStore<Omi
         } | undefined): () => void;
     };
 }, "setState"> & {
-    setState(nextStateOrUpdater: DataLayerPanelStore | Partial<DataLayerPanelStore> | ((state: WritableDraft<DataLayerPanelStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+    setState(nextStateOrUpdater: DataLayerPanelStore | Partial<DataLayerPanelStore> | ((state: {
+        isOpen: boolean;
+        userSettings: {
+            isTagsVisible: boolean;
+            isTagsFromDocumentVisible: boolean;
+            isTagsFromSelectionVisible: boolean;
+            isWorkOrdersVisible: boolean;
+            isWorkOrdersFromDocumentVisible: boolean;
+            isWorkOrdersFromSelectionVisible: boolean;
+            isEquipmentsVisible: boolean;
+            isEquipmentsFromDocumentVisible: boolean;
+            isEquipmentsFromSelectionVisible: boolean;
+            isIocAnnotationsVisible: boolean;
+            isDataFromStidAnnoDetails: boolean;
+        };
+        togglePanel: () => void;
+        toggleTags: () => void;
+        toggleTagsFromDocumentVisible: () => void;
+        toggleTagsFromSelectionVisible: () => void;
+        toggleWorkOrders: () => void;
+        toggleWorkOrdersFromDocumentVisible: () => void;
+        toggleWorkOrdersFromSelectionVisible: () => void;
+        toggleEquipments: () => void;
+        toggleEquipmentsFromDocumentVisible: () => void;
+        toggleEquipmentsFromSelectionVisible: () => void;
+        setEquipmentsForEcm: () => void;
+        toggleIocAnnotations: () => void;
+        setIsDataFromStidAnnoDetails: (value: boolean) => void;
+    }) => void), shouldReplace?: boolean | undefined, action?: string | {
         type: string;
     } | undefined): void;
 }>;

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

@@ -1,13 +1,16 @@
+import { StoreApi, UseBoundStore } from 'zustand';
 import { LeftPanelNavigationStore } from './leftPanelNavigation.store.types';
-export declare const useLeftPanelNavigationStore: import("zustand").UseBoundStore<Omit<Omit<import("zustand").StoreApi<LeftPanelNavigationStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: LeftPanelNavigationStore, previousSelectedState: LeftPanelNavigationStore) => void): () => void;
-        <U>(selector: (state: LeftPanelNavigationStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}, "setState"> & {
-    setState(nextStateOrUpdater: LeftPanelNavigationStore | Partial<LeftPanelNavigationStore> | ((state: import("immer").WritableDraft<LeftPanelNavigationStore>) => void), shouldReplace?: boolean | undefined): void;
-}>;
+/**
+ * IMPORTANT: Explicit type annotation required for rollup builds with useLegacyTypescriptPlugin: false
+ *
+ * Without explicit type, TypeScript infers the full type including Immer's internal types like
+ * WritableNonArrayDraft which use complex generics that rollup's @rollup/plugin-typescript cannot
+ * "name" in generated .d.ts files, causing TS4023 errors.
+ *
+ * Trade-off: UseBoundStore<StoreApi<T>> removes subscribeWithSelector's enhanced subscribe(selector, listener)
+ * signature, leaving only the base subscribe(listener). Store still fully functional via hook and .getState().
+ *
+ * Stores NOT exported from public API (index.ts) can omit this explicit type and preserve middleware signatures.
+ */
+export declare const useLeftPanelNavigationStore: UseBoundStore<StoreApi<LeftPanelNavigationStore>>;
 export declare function getLeftPanelNavigationState(): LeftPanelNavigationStore;

package/src/lib/services/userSetting/userSettingStore.d.ts

@@ -1,10 +1,8 @@
-import { SelectedLegend } from '../../feature/legacyLegend/legend';
+import { LegendType, SelectedLegend } from '../../feature/legacyLegend/legend';
 interface UserSettings {
-    measuringPointsEnabled: boolean;
     selectedLegacyLegend: SelectedLegend;
 }
 interface UserSettingsActions {
-    setMeasuringPointsEnabled: (value: boolean) => void;
     setSelectedLegacyLegend: (selectedLegend: SelectedLegend) => void;
 }
 type UserSettingsStore = UserSettings & UserSettingsActions;
@@ -31,7 +29,13 @@ export declare const useUserSettingsStore: import("zustand").UseBoundStore<Omit<
         getOptions: () => Partial<import("zustand/middleware").PersistOptions<UserSettingsStore, unknown>>;
     };
 }, "setState"> & {
-    setState(nextStateOrUpdater: UserSettingsStore | Partial<UserSettingsStore> | ((state: import("immer").WritableDraft<UserSettingsStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+    setState(nextStateOrUpdater: UserSettingsStore | Partial<UserSettingsStore> | ((state: {
+        selectedLegacyLegend: {
+            isEnabled: boolean;
+            legendType: LegendType;
+        };
+        setSelectedLegacyLegend: (selectedLegend: SelectedLegend) => void;
+    }) => void), shouldReplace?: boolean | undefined, action?: string | {
         type: string;
     } | undefined): void;
 }>;

package/src/lib/utils/dataAccess/accessGuidanceSections.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Represents a single link the user can follow to request or understand access.
+ */
+type AccessRequestLink = {
+    label: string;
+    url: string;
+};
+/**
+ * Group of related access request links, optionally with a heading describing who it applies to.
+ */
+type AccessRequestLinkGroup = {
+    heading?: string;
+    requestLinks: AccessRequestLink[];
+};
+/**
+ * Higher-level guidance section combining descriptive text and one or more link groups.
+ */
+export type AccessGuidanceSection = {
+    description: string;
+    descriptionBold?: string;
+    requestLinkGroups: AccessRequestLinkGroup[];
+    note?: string;
+};
+export declare const SapAccessGuidanceSection: AccessGuidanceSection;
+export declare const ProCoSysAccessGuidanceSection: (plantName: string) => AccessGuidanceSection;
+export declare const IocAccessGuidanceSection: AccessGuidanceSection;
+export {};

package/src/lib/{types → utils}/dataAccess/dataAccessLinks.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Central repository of link metadata used across the application.
+ *
+ * Keep raw URLs explicit (rather than generated) for traceability and to avoid
+ * accidental term changes when AccessIT search semantics evolve.
+ */
 export declare const dataAccessLinks: {
     YO900: {
         label: string;
@@ -44,4 +50,3 @@ export declare const dataAccessLinks: {
         url: string;
     };
 };
-export declare function createPlantNameQueryParam(plantName: string): string;

package/src/lib/utils/dataAccess/dataAccessLinks.utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Convert the displayed Echo plant name into the AccessIT search term.
+ *
+ * 1. Attempt to match any defined special-case fragment (substring match)
+ * 2. Fall back to taking the first N words of the raw plant name (default 3)
+ *
+ * Encoding is handled via encodeURIComponent; callers should not add additional encoding.
+ */
+export declare function createPlantNameQueryParam(plantName: string): string;

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

@@ -1,7 +0,0 @@
-import React from 'react';
-type RequestSapAccessProps = {
-    padding?: boolean;
-    onClicked?: () => void;
-};
-export declare const RequestSapAccess: React.FC<RequestSapAccessProps>;
-export {};

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

@@ -1,7 +0,0 @@
-import { LegendDataId, LegendId } from '../../../../types/legendType';
-import { PopoverContent } from './usePopoverHandler.types';
-export declare function usePopoverHandler(): {
-    currentPopover: PopoverContent | undefined;
-    handleOpenPopover: (itemId: LegendDataId, legendId: LegendId, uniqueIdentifier: string, fetchPopoverContent: () => Promise<ReadonlyArray<React.JSX.Element>>) => Promise<void>;
-    handleClosePopover: () => void;
-};

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

@@ -1,14 +0,0 @@
-import { LegendDataId, LegendId } from '../../../../types/legendType';
-export type RequestPopoverHandler = (itemId: LegendDataId, legendId: LegendId, uniqueIdentifier: string, fetchPopoverContent: () => Promise<ReadonlyArray<React.JSX.Element>>) => void;
-export interface PopoverContent {
-    elements: ReadonlyArray<JSX.Element>;
-    activeItem: ActiveItem;
-}
-/**
- * We use active for the icon. Several icons might be active if they have the same tagNo on the PDF, but only 1 of them is open.
- */
-export interface ActiveItem {
-    itemId: LegendDataId;
-    legendId: LegendId;
-    uniqueIdentifier: string;
-}

package/src/lib/types/dataAccess/index.d.ts

@@ -1 +0,0 @@
-export type { dataAccessLinks } from './dataAccessLinks';