@equinor/echo-framework 5.0.0 → 6.1.0

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

@@ -1,31 +1,33 @@
 import { ResultArray } from '@equinor/echo-search';
 import { GlobalSelectionItemType, GlobalSelectionItemTypeToDataMap, GlobalSelectionTypes, SelectionItemTypeToItemIdMap } from './globalSelectionStore.types';
-import { isEquipmentId, isMeasuringPointId, isTagId, isWorkOrderId } from './itemIdTypeGuards';
+import { isCoordinateId, isEquipmentId, isMeasuringPointId, isPdmsTagId, isTagId, isWorkOrderId } from './itemIdTypeGuards';
 declare function idsEqual(itemA: GlobalSelectionTypes.ItemId, itemB: GlobalSelectionTypes.ItemId): boolean;
 declare function mapToId(item: GlobalSelectionTypes.ItemId): GlobalSelectionTypes.ItemId;
 declare function itemIdToString(itemId: GlobalSelectionTypes.ItemId): GlobalSelectionTypes.ItemIdString;
 export declare function mapIdToItemType(itemId: GlobalSelectionTypes.ItemId): GlobalSelectionItemType;
 /**
- * A utility object that provides various functions for handling global selections.
- *
- * @namespace globalSelectionUtils
- * @property {Function} isMeasuringPointId - Checks if the passed object is a global selection MeasuringPointID.
- * @property {Function} isWorkOrderId - Checks if the passed object is a global selection WorkOrderID.
- * @property {Function} isEquipmentId - Checks if the passed object is a global selection EquipmentID.
- * @property {Function} isTagId - Checks if the passed object is a global selection TagID.
- * @property {Function} idsEqual - Compares two global selection item IDs for equality.
- * @property {Function} mapToId - Maps an object to its global selection item ID, preserving all properties (including PDMS).
- * @property {Function} mapIdToItemType - Returns the GlobalSelectionItemType enum value for a given ItemId.
- * @property {Function} itemIdToString - ONE-WAY conversion to string for Map keys. Cannot be reversed. For tags, uses only tagNo-instCode.
+ * Utility functions for handling global selection item IDs and types.
  */
 export declare const globalSelectionUtils: Readonly<{
+    /** Checks if the passed object is a global selection `MeasuringPointId`. */
     isMeasuringPointId: typeof isMeasuringPointId;
+    /** Checks if the passed object is a global selection `WorkOrderId`. */
     isWorkOrderId: typeof isWorkOrderId;
+    /** Checks if the passed object is a global selection `EquipmentId`. */
     isEquipmentId: typeof isEquipmentId;
+    /** Checks if the passed object is a global selection `TagId` (STID). */
     isTagId: typeof isTagId;
+    /** Checks if the passed object is a PDMS `TagId` — a `TagId` with `internalTagType`, `plantNo`, and `plantCode`. */
+    isPdmsTagId: typeof isPdmsTagId;
+    /** Checks if the passed object is a global selection `CoordinateId`. */
+    isCoordinateId: typeof isCoordinateId;
+    /** Compares two global selection item IDs for equality using the registered strategy for their type. */
     idsEqual: typeof idsEqual;
+    /** Normalizes an `ItemId` to its canonical form via the registered strategy (e.g. trims whitespace, uppercases instCode). Preserves all properties including PDMS fields. */
     mapToId: typeof mapToId;
+    /** Returns the `GlobalSelectionItemType` enum value for a given `ItemId`. */
     mapIdToItemType: typeof mapIdToItemType;
+    /** ONE-WAY conversion of an `ItemId` to a string suitable for use as a `Map` key. Cannot be reversed. For tags, uses only `tagNo-instCode` (PDMS fields are not included). */
     itemIdToString: typeof itemIdToString;
 }>;
 /**

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

@@ -1,15 +1,17 @@
-import { GlobalSelectionItemType, GlobalSelectionTypes, SelectionItemSystemStatus } from './globalSelectionStore.types';
+import { GlobalSelectionItemType, GlobalSelectionTypes, RelatedToItem, SelectionItemSystemStatus } from './globalSelectionStore.types';
 export declare function toGlobalSelectionItem<T extends GlobalSelectionTypes.ItemTypeToDataMap[K], K extends GlobalSelectionItemType>(args: {
     item: T;
     type: K;
     systemStatus: SelectionItemSystemStatus;
     color?: string;
+    relatedTo?: ReadonlyArray<RelatedToItem>;
 }): GlobalSelectionTypes.GenericItem<K>;
 export declare function toGlobalSelectionItems<T extends GlobalSelectionTypes.ItemTypeToDataMap[K], K extends GlobalSelectionItemType>(args: {
     items: T[];
     type: K;
     systemStatus: SelectionItemSystemStatus;
     color?: string;
+    relatedTo?: ReadonlyArray<RelatedToItem>;
 }): GlobalSelectionTypes.GenericItem<K>[];
 export declare function setNotFoundStatusByItemIds(args: {
     itemType: GlobalSelectionItemType;

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

@@ -1,7 +1,9 @@
 import type { PdmsTagId } from '../pdmsTag/pdmsTag.types';
-import type { GlobalSelectionTypes } from './globalSelectionStore.types';
+import type { CustomDataId, GlobalSelectionTypes } from './globalSelectionStore.types';
 export declare function isWorkOrderId(itemId: GlobalSelectionTypes.ItemId): itemId is GlobalSelectionTypes.WorkOrderId;
 export declare function isEquipmentId(itemId: GlobalSelectionTypes.ItemId): itemId is GlobalSelectionTypes.EquipmentId;
 export declare function isTagId(itemId: GlobalSelectionTypes.ItemId): itemId is GlobalSelectionTypes.TagId;
 export declare function isMeasuringPointId(itemId: GlobalSelectionTypes.ItemId): itemId is GlobalSelectionTypes.MeasuringPointId;
 export declare function isPdmsTagId(itemId: GlobalSelectionTypes.ItemId): itemId is PdmsTagId;
+export declare function isCustomDataId(itemId: GlobalSelectionTypes.RelatedToItemId): itemId is CustomDataId;
+export declare function isCoordinateId(itemId: GlobalSelectionTypes.ItemId): itemId is GlobalSelectionTypes.CoordinateId;

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

@@ -0,0 +1,3 @@
+import type { CoordinateData } from '../../coordinate/coordinate.types';
+import type { GlobalSelectionTypes } from '../globalSelectionStore.types';
+export declare function createNullCoordinateData(itemId: GlobalSelectionTypes.CoordinateId): CoordinateData;

package/src/lib/feature/globalSelection/hooks/useIsInGlobalSelection.d.ts

@@ -1,6 +1,11 @@
 import { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionStore.types';
 /**
- * Hook to check if an item is in the global selection
+ * Hook to check if an item is in the global selection.
+ *
+ * The check runs inside the Zustand selector and returns a boolean.
+ * Zustand's `Object.is` comparison on the boolean means the component only
+ * re-renders when the actual in-selection status changes, not on every store mutation.
+ *
  * @param {GlobalSelectionTypes.ItemId} itemId - The itemId
  * @returns {boolean} - True if the item is in global selection, false otherwise
  */

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

@@ -1,16 +1,15 @@
 export * from './globalSelectionStore/globalSelectionStore.types';
 export * from './selectionMenu/selectionTreeStore/selectionTree.api.types';
 export * from './selectionMenu/selectionTreeStore/selectionTree.store.types';
-export { PDMS_INTERNAL_TAG_TYPES, isPdmsInternalTagType } from './pdmsTag/pdmsTag.types';
+export { isPdmsInternalTagType, PDMS_INTERNAL_TAG_TYPES } from './pdmsTag/pdmsTag.types';
 export type { PdmsInternalTagType, PdmsTagId, PdmsTagSummaryDto, StidTagId } from './pdmsTag/pdmsTag.types';
+export type { CoordinateData, CoordinateId } from './coordinate/coordinate.types';
 export { useAreAllItemsVisible } from './hooks/useAreAllItemsVisible';
 export { useGlobalSelectionByItemId } from './hooks/useGlobalSelectionByItemId';
 export { useGlobalSelectionItems } from './hooks/useGlobalSelectionItems';
 export { useGlobalSelectionItemsByType } from './hooks/useGlobalSelectionItemsByType';
 export { useGlobalSelectionItemsByTypeAsMap } from './hooks/useGlobalSelectionItemsByTypeAsMap';
 export { useGlobalSelectionLists } from './hooks/useGlobalSelectionLists';
-export { useGlobalSelectionTags } from './hooks/useGlobalSelectionTags';
-export { useGlobalSelectionWorkOrders } from './hooks/useGlobalSelectionWorkOrders';
 export { useIsInGlobalSelection } from './hooks/useIsInGlobalSelection';
 export { useItemGroupMembership } from './hooks/useItemGroupMembership';
 export { useSelectionCategoriesByGroupId } from './hooks/useSelectionCategoriesByGroupId';
@@ -29,6 +28,4 @@ export { invalidateHistorySelectionQuery } from './selectionMenu/invalidateHisto
 export { saveEquipmentAsNewSelectionToApi } from './selectionMenu/selectionTreeStore/api/selectionTree.equipment';
 export { SelectionColorConflictDialog } from './selectionMenu/selectionTreeStore/colorConflictHandling/SelectionColorConflictDialog';
 export { simulatedSelectionTreeApiError } from './selectionMenu/selectionTreeStore/persist/devOnlySimulateOffline';
-export { isPdmsTagId } from './globalSelectionStore/itemIdTypeGuards';
-export { isPdmsTagInSelection } from './pdmsTag/pdmsTag.logic';
 export { createPdmsTagSummaryDto, isPdmsTagSummaryDto } from './pdmsTag/pdmsTag.utils';

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/actions/addItems.action.d.ts

@@ -7,8 +7,8 @@ export type AddItemsActionArgs = {
     readonly useDefaultSelectionTypeColors?: boolean;
 };
 /**
- * Adds items to the selection tree store by categorizing them into tags, work orders,
- * equipments, and measuring points, then dispatching the appropriate add actions for each type.
+ * Adds items to the selection tree store by categorizing them by type using the strategy registry,
+ * then dispatching addItemsByType for each type group.
  *
  * @param get - A function that returns the current instance of the SelectionTreeStore.
  * @param args - The arguments for adding items, including an array of item IDs and additional label arguments.

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/actions/addItemsByType.action.d.ts

@@ -0,0 +1,15 @@
+import { StoreApi } from 'zustand';
+import { GlobalSelectionItemType, SelectionItemTypeToItemIdMap } from '../../../globalSelectionStore/globalSelectionStore.types';
+import { SelectionTreeStore } from '../selectionTree.store.types';
+import { AddItemArgs, AddItemsResponse } from './selectionTree.action.types';
+type SetFunction = (set: (state: SelectionTreeStore) => void, shouldReplace: boolean | undefined, action: string | undefined) => void;
+/**
+ * Generic tree action for adding items of any registered type to the selection tree.
+ * Replaces the 4 per-type action files (addTags, addWorkOrders, addEquipments, addMeasuringPoints).
+ *
+ * Reads category config (categoryId, categoryOrderIndex) from the strategy registry so no
+ * per-type branching is needed here or in the store.
+ */
+export declare function createAddItemsByTypeAction<T extends GlobalSelectionItemType>(itemType: T): (set: (set: (state: SelectionTreeStore) => void, shouldReplace?: boolean | undefined, action?: string) => void, get: StoreApi<SelectionTreeStore>["getState"], args: AddItemArgs<SelectionItemTypeToItemIdMap[T]>) => Promise<AddItemsResponse<T>>;
+export declare function addItemsByTypeAction<T extends GlobalSelectionItemType>(set: SetFunction, get: StoreApi<SelectionTreeStore>['getState'], itemType: T, args: AddItemArgs<SelectionItemTypeToItemIdMap[T]>): Promise<AddItemsResponse<T>>;
+export {};

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/initialData.d.ts

@@ -1,12 +1,6 @@
 import { SelectionCategory, SelectionGroup } from './selectionTree.store.types';
 export declare const selectionTreeInitialData: Readonly<{
     localSelectionGroup: SelectionGroup;
-    categoryOrder: {
-        tagIndex: number;
-        workOrderIndex: number;
-        equipmentIndex: number;
-        measuringPointIndex: number;
-    };
     localSelectionGroupIndex: 0;
     getInitialCategories: () => SelectionCategory[];
 }>;

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

@@ -7,7 +7,7 @@ import { SelectionGroup } from '../selectionTree.store.types';
  * This function takes the `data` property from an API selection tree root object,
  * extracts all items from the nested structure, and groups their normalized IDs
  * by their corresponding `GlobalSelectionItemType`. It then creates selection lists
- * for each type using the `selectionTreeLoader.createListByType` utility.
+ * for each type using the strategy registry (null/loading-state items).
  *
  * @param param0 - An object containing the `data` array from the API selection tree root.
  * @returns An object containing:

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

@@ -1,6 +1,7 @@
 import { Guid } from '@equinor/echo-utils';
-import { GlobalSelectionItemType, SelectionItemTypeToItemIdMap } from '../../globalSelectionStore/globalSelectionStore.types';
+import { GlobalSelectionItemType, RelatedToItemType, RelatedToItemTypeToIdMap, SelectionItemTypeToItemIdMap } from '../../globalSelectionStore/globalSelectionStore.types';
 export type ApiSelectionTreeItemId = SelectionItemTypeToItemIdMap[GlobalSelectionItemType];
+export type ApiRelatedToItemId = RelatedToItemTypeToIdMap[RelatedToItemType];
 export interface ApiGlobalSelectionMetaData {
     readonly color: string | undefined;
     readonly isHiddenByUser: boolean | undefined;
@@ -29,10 +30,15 @@ export interface ApiSelectionGroup {
 export interface ApiSelectionCategory {
     readonly items: ApiSelectionTreeItem[];
 }
+export interface ApiRelatedToItem {
+    readonly id: ApiRelatedToItemId;
+    readonly type: RelatedToItemType;
+}
 export interface ApiSelectionTreeItem {
     readonly type: GlobalSelectionItemType;
     readonly id: ApiSelectionTreeItemId;
     readonly metaData?: ApiGlobalSelectionMetaData;
+    readonly relatedTo?: ReadonlyArray<ApiRelatedToItem>;
 }
 export interface ApiSelectionHistory {
     readonly id: Guid;

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

@@ -11,7 +11,7 @@ import { SelectionGroup, SelectionTreeStore } from './selectionTree.store.types'
  *
  * @example
  * const selectionTree = useSelectionTreeStore();
- * selectionTree.addTags({ ... });
+ * selectionTree.addItemsByType(GlobalSelectionItemType.Tag, { ... });
  *
  * @see SelectionTreeStore
  */
@@ -37,10 +37,7 @@ export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit
             groupId?: Guid;
             useDefaultSelectionTypeColors?: boolean;
         }) => Promise<void>;
-        addTags: (args: import("./actions/selectionTree.action.types").AddItemArgs<import("../..").GlobalSelectionTypes.TagId>) => import("./selectionTree.store.types").AddTagsReturnType;
-        addWorkOrders: (args: import("./actions/selectionTree.action.types").AddItemArgs<import("../..").GlobalSelectionTypes.WorkOrderId>) => import("./selectionTree.store.types").AddWorkOrdersReturnType;
-        addEquipments: (args: import("./actions/selectionTree.action.types").AddItemArgs<import("../..").GlobalSelectionTypes.EquipmentId>) => import("./selectionTree.store.types").AddEquipmentsReturnType;
-        addMeasuringPoints: (args: import("./actions/selectionTree.action.types").AddItemArgs<import("../..").GlobalSelectionTypes.MeasuringPointId>) => import("./selectionTree.store.types").AddMeasuringPointsReturnType;
+        addItemsByType: <T extends import("../..").GlobalSelectionItemType>(itemType: T, args: import("./actions/selectionTree.action.types").AddItemArgs<import("../..").SelectionItemTypeToItemIdMap[T]>) => Promise<import("./actions/selectionTree.action.types").AddItemsResponse<T>>;
         createGroup: (args: {
             groupId?: string;
             label: string;
@@ -87,6 +84,15 @@ export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit
                 label: string;
                 items: Map<import("../..").GlobalSelectionTypes.ItemIdString, {
                     id: {
+                        x: number;
+                        y: number;
+                        z: number;
+                        name: string;
+                        description: string | undefined;
+                        instCode: string;
+                        plantCode: string;
+                        plantNo: string;
+                    } | {
                         workOrderId: string;
                     } | {
                         instCode: string;
@@ -103,6 +109,37 @@ export declare const useSelectionTreeStore: import("zustand").UseBoundStore<Omit
                         measuringPointId: string;
                     };
                     type: import("../..").GlobalSelectionItemType;
+                    relatedTo?: {
+                        id: {
+                            x: number;
+                            y: number;
+                            z: number;
+                            name: string;
+                            description: string | undefined;
+                            instCode: string;
+                            plantCode: string;
+                            plantNo: string;
+                        } | {
+                            workOrderId: string;
+                        } | {
+                            instCode: string;
+                            tagNo: string;
+                        } | {
+                            internalTagType: import("../..").PdmsInternalTagType;
+                            plantNo: string;
+                            plantCode: string;
+                            instCode: string;
+                            tagNo: string;
+                        } | {
+                            equipmentId: string;
+                        } | {
+                            measuringPointId: string;
+                        } | {
+                            key: string;
+                            value: string;
+                        };
+                        type: import("../..").RelatedToItemType;
+                    }[] | undefined;
                 }>;
             }[];
             groupId: Guid;

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

@@ -1,16 +1,18 @@
 import { Guid } from '@equinor/echo-utils';
-import { GlobalSelectionItemType, GlobalSelectionTypes, SelectionItemTypeToItemIdMap } from '../../globalSelectionStore/globalSelectionStore.types';
+import { GlobalSelectionItemType, GlobalSelectionTypes, RelatedToItem, SelectionItemTypeToItemIdMap } from '../../globalSelectionStore/globalSelectionStore.types';
 import { AddItemArgs, AddItemsResponse, SelectionTreeActionResult } from './actions/selectionTree.action.types';
 export declare enum GlobalSelectionCategoryId {
     Tags = "DEFAULT_TAG_LIST_ID",
     WorkOrders = "DEFAULT_WORK_ORDER_LIST_ID",
     Equipments = "DEFAULT_EQUIPMENT_LIST_ID",
-    MeasuringPoints = "DEFAULT_MEASURING_POINT_LIST_ID"
+    MeasuringPoints = "DEFAULT_MEASURING_POINT_LIST_ID",
+    Coordinates = "DEFAULT_COORDINATE_LIST_ID"
 }
 export declare const globalSelectionDefaultGroupId: Guid;
 export type SelectionTreeItem<T extends GlobalSelectionItemType> = {
     readonly id: SelectionItemTypeToItemIdMap[T];
     readonly type: T;
+    readonly relatedTo?: RelatedToItem[];
 };
 export interface SelectionBase {
     readonly groupId: Guid;
@@ -39,10 +41,7 @@ export interface SelectionTreeStore extends SelectionTreeData {
         groupId?: Guid;
         useDefaultSelectionTypeColors?: boolean;
     }) => Promise<void>;
-    addTags: (args: AddItemArgs<GlobalSelectionTypes.TagId>) => AddTagsReturnType;
-    addWorkOrders: (args: AddItemArgs<GlobalSelectionTypes.WorkOrderId>) => AddWorkOrdersReturnType;
-    addEquipments: (args: AddItemArgs<GlobalSelectionTypes.EquipmentId>) => AddEquipmentsReturnType;
-    addMeasuringPoints: (args: AddItemArgs<GlobalSelectionTypes.MeasuringPointId>) => AddMeasuringPointsReturnType;
+    addItemsByType: <T extends GlobalSelectionItemType>(itemType: T, args: AddItemArgs<SelectionItemTypeToItemIdMap[T]>) => Promise<AddItemsResponse<T>>;
     createGroup: (args: {
         groupId?: string;
         label: string;
@@ -89,7 +88,3 @@ export declare namespace SelectionTreeTypes {
     type ActionResult = SelectionTreeActionResult;
     type Item = SelectionTreeItem<GlobalSelectionItemType>;
 }
-export type AddTagsReturnType = Promise<AddItemsResponse<GlobalSelectionItemType.Tag>>;
-export type AddWorkOrdersReturnType = Promise<AddItemsResponse<GlobalSelectionItemType.WorkOrder>>;
-export type AddEquipmentsReturnType = Promise<AddItemsResponse<GlobalSelectionItemType.Equipment>>;
-export type AddMeasuringPointsReturnType = Promise<AddItemsResponse<GlobalSelectionItemType.MeasuringPoint>>;

package/src/lib/feature/globalSelection/strategies/coordinateSelection.strategy.d.ts

@@ -0,0 +1,3 @@
+import { GlobalSelectionItemType } from '../globalSelectionStore/globalSelectionStore.types';
+import type { SelectionItemTypeStrategy } from './selectionItemTypeStrategy.types';
+export declare const coordinateSelectionStrategy: SelectionItemTypeStrategy<GlobalSelectionItemType.Coordinate>;

package/src/lib/feature/globalSelection/strategies/selectionItemTypeStrategy.types.d.ts

@@ -18,6 +18,8 @@ export interface SelectionItemTypeStrategy<T extends GlobalSelectionItemType> {
     idsEqual(itemA: SelectionItemTypeToItemIdMap[T], itemB: SelectionItemTypeToItemIdMap[T]): boolean;
     /** Create a placeholder item for loading state */
     createNullItem(itemId: SelectionItemTypeToItemIdMap[T]): GlobalSelectionItemTypeToDataMap[T];
+    /** Extract the canonical ItemId from a fetched data object. Used as a type-safe Map key. */
+    getItemId(data: GlobalSelectionItemTypeToDataMap[T]): SelectionItemTypeToItemIdMap[T];
     /**
      * Resolve items synchronously from the ID alone — no loading state, no API call.
      * Only implement when item data is embedded in the ID itself (e.g. PDMS tags).

package/src/lib/services/api/api-plantinfo.d.ts

@@ -1,5 +1,5 @@
 import { EchoHubPlant } from '../../types/echoHubPlant';
 import { ModelPermissions } from '../../types/modelPermissions';
 export declare function getPlantsInfo(instCode?: string): Promise<EchoHubPlant[]>;
-export declare function check3dPermissionForPlant(plantCode: string): Promise<ModelPermissions>;
+export declare function check3dPermissionForPlant(plantCode: string): Promise<boolean>;
 export declare function getPermitted3dModels(): Promise<ModelPermissions>;

package/src/lib/services/echoViewService/echoView.type.d.ts

@@ -9,7 +9,6 @@ export interface EchoView extends EchoViewBaseItem {
     readonly tagNo: string | undefined;
     readonly search: string | undefined;
     readonly skipOnboarding: boolean | undefined;
-    readonly useMaintenanceDevData: boolean | undefined;
     readonly syncSettings: EchoViewSyncSettings | undefined;
     readonly ecmPdfInspectionTool: EchoViewEcmPdfInspectionToolConfig | undefined;
     readonly echo3D: Record<string, unknown> | undefined;

package/src/lib/utils/plantInfo.d.ts

@@ -46,8 +46,8 @@ export declare function allPlantCodesOnInstallation(instCode: string): Promise<s
  * Method for checking a users access to a given installation
  *
  * @export
- * @param {string} instCode installation code to check access for
- * @return {*}  {Promise<boolean>} returns whether the user has access to that given installation
+ * @param instCode installation code to check access for
+ * @return returns whether the user has access to one or more 3d models on the given installation
  */
 export declare function check3dPermissionOnInstallation(instCode: string): Promise<boolean>;
 /**

package/src/lib/feature/globalSelection/hooks/useGlobalSelectionTags.d.ts

@@ -1,6 +0,0 @@
-import { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionStore.types';
-/**
- * Returns with the stored Tags from the global selection store
- * @returns {GlobalSelectionTypes.TagItem[]} Array of Tags with some global selection meta data.
- */
-export declare function useGlobalSelectionTags(): GlobalSelectionTypes.TagItem[];

package/src/lib/feature/globalSelection/hooks/useGlobalSelectionWorkOrders.d.ts

@@ -1,6 +0,0 @@
-import { GlobalSelectionTypes } from '../globalSelectionStore/globalSelectionStore.types';
-/**
- * Returns with the stored Work Orders from the global selection store
- * @returns {GlobalSelectionTypes.WorkOrderItem[]} Array of Work Orders
- */
-export declare function useGlobalSelectionWorkOrders(): GlobalSelectionTypes.WorkOrderItem[];

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/actions/addEquipments.action.d.ts

@@ -1,2 +0,0 @@
-import { GlobalSelectionItemType } from '../../../globalSelectionStore/globalSelectionStore.types';
-export declare const addEquipmentsAction: (set: (set: (state: import("../selectionTree.store.types").SelectionTreeStore) => void, shouldReplace?: boolean | undefined, action?: string) => void, get: import("zustand").StoreApi<import("../selectionTree.store.types").SelectionTreeStore>["getState"], args: import("./selectionTree.action.types").AddItemArgs<import("../../../globalSelectionStore/globalSelectionStore.types").GlobalSelectionTypes.EquipmentId>) => Promise<import("./selectionTree.action.types").AddItemsResponse<GlobalSelectionItemType.Equipment>>;

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/actions/addMeasuringPoints.action.d.ts

@@ -1,2 +0,0 @@
-import { GlobalSelectionItemType } from '../../../globalSelectionStore/globalSelectionStore.types';
-export declare const addMeasuringPointsAction: (set: (set: (state: import("../selectionTree.store.types").SelectionTreeStore) => void, shouldReplace?: boolean | undefined, action?: string) => void, get: import("zustand").StoreApi<import("../selectionTree.store.types").SelectionTreeStore>["getState"], args: import("./selectionTree.action.types").AddItemArgs<import("../../../globalSelectionStore/globalSelectionStore.types").GlobalSelectionTypes.MeasuringPointId>) => Promise<import("./selectionTree.action.types").AddItemsResponse<GlobalSelectionItemType.MeasuringPoint>>;

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/actions/addTags.action.d.ts

@@ -1,2 +0,0 @@
-import { GlobalSelectionItemType } from '../../../globalSelectionStore/globalSelectionStore.types';
-export declare const addTagsAction: (set: (set: (state: import("../selectionTree.store.types").SelectionTreeStore) => void, shouldReplace?: boolean | undefined, action?: string) => void, get: import("zustand").StoreApi<import("../selectionTree.store.types").SelectionTreeStore>["getState"], args: import("./selectionTree.action.types").AddItemArgs<import("../../../globalSelectionStore/globalSelectionStore.types").GlobalSelectionTypes.TagId>) => Promise<import("./selectionTree.action.types").AddItemsResponse<GlobalSelectionItemType.Tag>>;

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/actions/addWorkOrders.action.d.ts

@@ -1,2 +0,0 @@
-import { GlobalSelectionItemType } from '../../../globalSelectionStore/globalSelectionStore.types';
-export declare const addWorkOrdersAction: (set: (set: (state: import("../selectionTree.store.types").SelectionTreeStore) => void, shouldReplace?: boolean | undefined, action?: string) => void, get: import("zustand").StoreApi<import("../selectionTree.store.types").SelectionTreeStore>["getState"], args: import("./selectionTree.action.types").AddItemArgs<import("../../../globalSelectionStore/globalSelectionStore.types").GlobalSelectionTypes.WorkOrderId>) => Promise<import("./selectionTree.action.types").AddItemsResponse<GlobalSelectionItemType.WorkOrder>>;

package/src/lib/feature/globalSelection/selectionMenu/selectionTreeStore/persist/selectionTreeLoader.service.d.ts

@@ -1,42 +0,0 @@
-import { ResultArray } from '@equinor/echo-search';
-import { GlobalSelectionItemType, GlobalSelectionItemTypeToDataMap, GlobalSelectionTypes, SelectionItemTypeToItemIdMap } from '../../../globalSelectionStore/globalSelectionStore.types';
-type ListCreatorParams<T extends GlobalSelectionItemType> = {
-    nullItemGenerator: (itemId: SelectionItemTypeToItemIdMap[T]) => GlobalSelectionItemTypeToDataMap[T];
-};
-/**
- * Service responsible for managing the registration and execution of list creators and API loaders
- * for different global selection item types within the selection tree.
- *
- * Mainly used for loading and setting huge amount of data when loading selections from API and or from disk.
- *
- * This service allows dynamic registration of functions that can create selection lists or fetch
- * and update selection data for specific item types. It provides methods to register these handlers,
- * create lists, and fetch/store data by type.
- *
- * @remarks
- * - `registerListCreator` associates a list creation function with a specific item type.
- * - `registerApiLoader` associates an asynchronous data loader with a specific item type.
- * - `createListByType` uses the registered creator to generate a selection list for the given type and item IDs.
- * - `fetchAndStoreDataByType` uses the registered loader to fetch and update data for the given type and item IDs.
- *
- * @template T - The global selection item type.
- */
-declare class SelectionTreeLoaderService {
-    private listCreators;
-    private apiLoaders;
-    registerGroupCreator<T extends GlobalSelectionItemType>(type: T, params: ListCreatorParams<T>): void;
-    registerApiLoader<T extends GlobalSelectionItemType>(type: T, fetchFunction: (itemIds: SelectionItemTypeToItemIdMap[T][]) => Promise<{
-        result: ResultArray<GlobalSelectionItemTypeToDataMap[T]>;
-        itemIdsUsed: SelectionItemTypeToItemIdMap[T][];
-    }[]>): void;
-    createListByType<T extends GlobalSelectionItemType>(type: T, itemIds: SelectionItemTypeToItemIdMap[T][]): GlobalSelectionTypes.List<T>;
-    fetchAndStoreDataByType<T extends GlobalSelectionItemType>(type: T, itemIds: SelectionItemTypeToItemIdMap[T][]): Promise<void>;
-}
-/**
- * Service responsible for managing the registration and execution of list creators and API loaders
- * for different global selection item types within the selection tree.
- *
- * Used for loading and setting huge amount of data when loading selections from API and or from disk.
- */
-export declare const selectionTreeLoader: SelectionTreeLoaderService;
-export {};