@equinor/echo-framework 0.20.15 → 0.20.17

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

@@ -1,11 +1,35 @@
 import { GlobalSelectionItemType, GlobalSelectionTypes } from './globalSelectionStore.types';
 export declare function toGlobalSelectionItem<T extends GlobalSelectionTypes.ItemTypeToDataMap[K], K extends GlobalSelectionItemType>(item: T, type: K): GlobalSelectionTypes.GenericItem<K>;
 export declare function toGlobalSelectionItems<T extends GlobalSelectionTypes.ItemTypeToDataMap[K], K extends GlobalSelectionItemType>(items: T[], type: K): GlobalSelectionTypes.GenericItem<K>[];
-export declare function findGlobalSelectionListByKey(state: GlobalSelectionTypes.Store, key: string): GlobalSelectionTypes.ListUnion | undefined;
 declare function idsEqual(itemA: GlobalSelectionTypes.ItemId, itemB: GlobalSelectionTypes.ItemId): boolean;
 declare function isWorkOrderId(itemId: GlobalSelectionTypes.ItemId): itemId is GlobalSelectionTypes.WorkOrderId;
 declare function isEquipmentId(itemId: GlobalSelectionTypes.ItemId): itemId is GlobalSelectionTypes.EquipmentId;
 declare function isTagId(itemId: GlobalSelectionTypes.ItemId): itemId is GlobalSelectionTypes.TagId;
+/**
+ * Overloaded function that maps an item to its corresponding ID type based on the item's properties.
+ * The return type is specific to the type of item passed to the function.
+ *
+ * @param {GlobalSelectionTypes.WorkOrderId} item - The work order item to be mapped.
+ * @returns {GlobalSelectionTypes.WorkOrderId} - The mapped work order ID.
+ */
+/**
+ * @param {GlobalSelectionTypes.EquipmentId} item - The equipment item to be mapped.
+ * @returns {GlobalSelectionTypes.EquipmentId} - The mapped equipment ID.
+ */
+/**
+ * @param {GlobalSelectionTypes.TagId} item - The tag item to be mapped.
+ * @returns {GlobalSelectionTypes.TagId} - The mapped tag ID.
+ */
+/**
+ * Maps an item to its corresponding ID object by checking the item's type and returning the appropriate ID object.
+ * If the item type is not recognized, an error is thrown.
+ *
+ * @param {GlobalSelectionTypes.ItemId} item - The data to be mapped to its ID type.
+ * @returns {GlobalSelectionTypes.ItemId} - The mapped tag ID.
+ */
+declare function mapToId(item: GlobalSelectionTypes.WorkOrderId): GlobalSelectionTypes.WorkOrderId;
+declare function mapToId(item: GlobalSelectionTypes.EquipmentId): GlobalSelectionTypes.EquipmentId;
+declare function mapToId(item: GlobalSelectionTypes.TagId): GlobalSelectionTypes.TagId;
 declare function mapToId(item: GlobalSelectionTypes.ItemId): GlobalSelectionTypes.ItemId;
 declare function itemIdToString(itemId: Record<string, string | number>): string;
 /**

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

@@ -1,4 +1,19 @@
 /**
  * Hook for returning all lists stored in the global selection.
  */
-export declare function useGlobalSelectionLists(): import("..").GlobalSelectionListUnion[];
+export declare function useGlobalSelectionLists(): ({
+    label: string;
+    type: import("..").GlobalSelectionItemType.WorkOrder;
+    items: import("..").GlobalSelectionTypes.GenericItem<import("..").GlobalSelectionItemType.WorkOrder>[];
+    itemsBeingLoaded: import("..").GlobalSelectionTypes.ItemId[];
+} | {
+    label: string;
+    type: import("..").GlobalSelectionItemType.Tag;
+    items: import("..").GlobalSelectionTypes.GenericItem<import("..").GlobalSelectionItemType.Tag>[];
+    itemsBeingLoaded: import("..").GlobalSelectionTypes.ItemId[];
+} | {
+    label: string;
+    type: import("..").GlobalSelectionItemType.Equipment;
+    items: import("..").GlobalSelectionTypes.GenericItem<import("..").GlobalSelectionItemType.Equipment>[];
+    itemsBeingLoaded: import("..").GlobalSelectionTypes.ItemId[];
+})[];

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

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

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

@@ -1,4 +1,4 @@
-export { getGlobalSelectionStoreState, useGlobalSelectionStore } from './globalSelectionStore/globalSelectionStore';
+export { globalSelectionApi, useGlobalSelectionStore } from './globalSelection.api';
 export * from './globalSelectionStore/globalSelectionStore.types';
 export { globalSelectionUtils } from './globalSelectionStore/globalSelectionStore.utils';
 export { convertGlobalSelectionItemsToPlantTagPairs } from './globalSelectionStore/globalSelectionStoreHelpers';

package/src/lib/feature/globalSelection/selectionMenu/hooks/useAllItemsHiddenByUser.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Custom hook to determine if all items in a selection list are hidden by the user.
+ *
+ * @param {string} listId - The ID of the selection list to check.
+ * @returns {boolean} - A boolean indicating whether all items in the list are hidden by the user.
+ *
+ * This hook uses the `useGlobalSelectionLists` hook to get the current global selection state and
+ * It then checks if all items in the target list are hidden by the user by comparing item IDs and their metadata.
+ *
+ * The hook returns `true` if all items in the list are hidden by the user, and `false` otherwise.
+ */
+export declare const useAllItemsHiddenByUser: (listId: string) => boolean;

package/src/lib/feature/globalSelection/selectionMenu/hooks/useSelectionMenuLists.d.ts

@@ -0,0 +1,7 @@
+import { SelectionMenuList } from '../selectionMenuStore/selectionMenu.store.types';
+/**
+ * Custom hook to get the selection menu lists from the selection menu store, displayed in the left selection panel.
+ *
+ * @returns {SelectionMenuList[]} - An array of selection menu lists.
+ */
+export declare function useSelectionMenuLists(): SelectionMenuList[];

package/src/lib/feature/globalSelection/selectionMenu/selectionMenuStore/selectionMenu.store.d.ts

@@ -0,0 +1,43 @@
+import { SelectionMenuStore } from './selectionMenu.store.types';
+export declare enum SelectionMenuDefaultListIds {
+    TagList = "DEFAULT_TAG_LIST_ID",
+    WorkOrderList = "DEFAULT_WORK_ORDER_LIST_ID"
+}
+/**
+ * Store for the selection menu, in a left panel.
+ *
+ * Stores the hierachry, tree structure of the items in Global Selection.
+ * With this, it is in charge of:
+ *   - tracking which item belongs to which list
+ *   - adding items to global selection
+ *   - remove items from global selection
+ *   - update items (visibility, removal etc.) via list ids
+ *   - maintaining the global selection store based on the changes in the items, in the selection menu panel
+ *
+ * You shouldn't use this store directly in any code, unless you have very special reason to do so.
+ *
+ * For accessing and using global selection features, use the globalSelectionApi from echo-framework.
+ */
+export declare const useSelectionMenuStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<SelectionMenuStore>, "setState"> & {
+    setState<A extends string | {
+        type: string;
+    }>(partial: SelectionMenuStore | Partial<SelectionMenuStore> | ((state: SelectionMenuStore) => SelectionMenuStore | Partial<SelectionMenuStore>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: SelectionMenuStore, previousSelectedState: SelectionMenuStore) => void): () => void;
+        <U>(selector: (state: SelectionMenuStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}, "setState"> & {
+    setState(nextStateOrUpdater: SelectionMenuStore | Partial<SelectionMenuStore> | ((state: import("immer").WritableDraft<SelectionMenuStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: string;
+    } | undefined): void;
+}>;
+/**
+ * Get a snapshot of the current selection menu store state.
+ *
+ * Selection menu: left panel, which holds items from global selection.
+ */
+export declare function getSelectionMenuStoreSnapshot(): SelectionMenuStore;

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

@@ -0,0 +1,52 @@
+import { ResultArray, TagSummaryDto } from '@equinor/echo-search';
+import { Guid } from '@equinor/echo-utils';
+import { GlobalSelectionItemType, GlobalSelectionTypes, OptimizedWorkOrderDto } from '../../globalSelectionStore/globalSelectionStore.types';
+import { SelectionMenuDefaultListIds } from './selectionMenu.store';
+export type SelectionMenuItem = SelectionMenuTag | SelectionMenuWorkOrder | SelectionMenuEquipment;
+export interface SelectionMenuTag {
+    id: GlobalSelectionTypes.TagId;
+    type: GlobalSelectionItemType.Tag;
+}
+export interface SelectionMenuWorkOrder {
+    id: GlobalSelectionTypes.WorkOrderId;
+    type: GlobalSelectionItemType.WorkOrder;
+}
+export interface SelectionMenuEquipment {
+    id: GlobalSelectionTypes.EquipmentId;
+    type: GlobalSelectionItemType.Equipment;
+}
+export type SelectionMenuList = SelectionMenuWithItems | SelectionMenuWithSubLists;
+interface SelectionMenuBase {
+    id: Guid | SelectionMenuDefaultListIds;
+    label: string;
+}
+interface SelectionMenuWithItems extends SelectionMenuBase {
+    items: SelectionMenuItem[];
+    subLists?: never;
+}
+interface SelectionMenuWithSubLists extends SelectionMenuBase {
+    subLists: SelectionMenuWithItems[];
+    items?: never;
+}
+export interface SelectionMenuStore {
+    lists: SelectionMenuList[];
+    addTags: (args: {
+        listId?: string;
+        itemIds: Readonly<GlobalSelectionTypes.TagId[]>;
+    }) => Promise<ResultArray<TagSummaryDto>[]>;
+    addWorkOrders: (args: {
+        listId?: string;
+        items: Readonly<Readonly<OptimizedWorkOrderDto>[]>;
+    }) => void;
+    addList: (args: SelectionMenuList) => void;
+    removeItemsByListId: (args: {
+        listId: string;
+        itemIds: GlobalSelectionTypes.ItemId[];
+    }) => void;
+    setVisibilityByListId: (args: {
+        listId: string;
+        isVisible: boolean;
+    }) => void;
+    resetState: () => void;
+}
+export {};

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

@@ -0,0 +1,56 @@
+import { GlobalSelectionTypes } from '../../globalSelectionStore/globalSelectionStore.types';
+import { SelectionMenuList } from './selectionMenu.store.types';
+/**
+ * Finds a selection list by its ID from a given list of selection menu lists.
+ * If the list is not found at the top level, it searches within the sublists of each top-level list.
+ *
+ * @param args - The arguments object.
+ * @param {string} args.listId - The ID of the selection list to find.
+ * @param {SelectionMenuList[]} args.lists - An optional array of selection menu lists to search within.
+ * If not provided, the function will use the lists from the selection menu store state.
+ * If you want to alter the store state, you should provide the lists as an argument.
+ * @returns {SelectionMenuList | undefined} The selection menu list with the specified ID, or `undefined` if not found.
+ */
+export declare function findSelectionListById(args: {
+    listId: string;
+    lists: SelectionMenuList[];
+}): SelectionMenuList | undefined;
+/**
+ * Checks if a given item ID is present in a specified list.
+ *
+ * @param args - An object containing the item ID and the list ID.
+ * @param {GlobalSelectionTypes.ItemId} args.itemId - The ID of the item to check for.
+ * @param {string} args.listId - The ID of the list to search within.
+ * @param {SelectionMenuList[]} args.lists - The selection menu lists where you would like to search for the given item.
+ * @returns {boolean} A boolean indicating whether the item ID is found in the list.
+ */
+export declare function isItemIdInList(args: {
+    itemId: GlobalSelectionTypes.ItemId;
+    listId: string;
+    lists: SelectionMenuList[];
+}): boolean;
+/**
+ * Checks if a given item ID is present in the selection lists.
+ *
+ * @param args - An object containing the item ID to check.
+ * @param {GlobalSelectionTypes.ItemId} args.itemId - The item ID to check for presence in the selection lists.
+ * @param {SelectionMenuList[]} args.lists - The selection menu lists where you would like to search for the given item.
+ * @returns {boolean} A boolean indicating whether the item ID is present in the selection lists.
+ */
+export declare function isItemIdInTheSelection(args: {
+    itemId?: GlobalSelectionTypes.ItemId;
+    lists: SelectionMenuList[];
+}): boolean;
+/**
+ * Retrieves an array of itemIds that were not found in the selection menu.
+ *
+ * @param {Object} args - The arguments containing the list and itemIds to check.
+ * @param {SelectionMenuList[]} args.list - The list of SelectionMenuList objects to search through.
+ * @param {GlobalSelectionTypes.ItemId[]} args.itemIds - An array of ItemId objects to check for presence in the list.
+ * @returns {string[]} An array of itemId strings that correspond to counts of 0 in the selection menu.
+ * itemIds object values are concatenated via '-' char
+ */
+export declare function itemsNotFoundInSelectionMenu(args: {
+    lists: SelectionMenuList[];
+    itemIds: GlobalSelectionTypes.ItemId[];
+}): string[];

package/src/lib/feature/hooks/useAddTagToLegendRegistry.d.ts

@@ -1,4 +1,4 @@
-import { LegendItemStatus } from '../legend';
+import { LegendItemStatus } from '../legacyLegend';
 /**
  * @deprecated Don't use this - the current legend registry service is a heavily outdated solution,
  * we shouldn't increase the tech dept even further.

package/src/lib/feature/measuringPoint/components/measuringPointDetails/mediaItemView/NavigationButton.d.ts

@@ -0,0 +1,8 @@
+type Direction = 'previous' | 'next';
+interface NavigationButtonProps {
+    direction: Direction;
+    onClick: () => void;
+    disabled?: boolean;
+}
+export declare const NavigationButton: React.FC<NavigationButtonProps>;
+export {};

package/src/lib/feature/measuringPoint/components/measuringPointDetails/mediaItemView/desktopMediaView.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface DesktopMediaViewProps {
+    imageSrc: string;
+    showPrevious: () => void;
+    showNext: () => void;
+    showNextIcon: boolean;
+    showPrevIcon: boolean;
+}
+export declare const DesktopMediaView: React.FC<React.PropsWithChildren<DesktopMediaViewProps>>;
+export {};

package/src/lib/feature/measuringPoint/components/measuringPointDetails/mediaItemView/mediaViewUtils.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { SwipeableProps } from 'react-swipeable';
+export declare const Swipeable: React.FC<React.PropsWithChildren<SwipeableProps>>;

package/src/lib/feature/measuringPoint/components/measuringPointDetails/mediaItemView/mobileMediaView.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface MobileMediaViewProps {
+    imageSrc: string;
+    showPrevious: () => void;
+    showNext: () => void;
+    showNextIcon: boolean;
+    showPrevIcon: boolean;
+}
+export declare const MobileMediaView: React.FC<React.PropsWithChildren<MobileMediaViewProps>>;
+export {};

package/src/lib/feature/openItemsIn3d/OpenIn3dSelectedItemsMenu.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface OpenIn3dSelectedItemsMenuProps {
+    onOpenIn3dButtonClick: () => void;
+    children?: React.ReactNode;
+    disabled?: boolean;
+}
+export declare const OpenIn3dSelectedItemsMenu: React.FC<OpenIn3dSelectedItemsMenuProps>;
+export {};

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

@@ -1,4 +1,4 @@
 export { tagIdPlantIdToPlantTagPairs } from './logic/convertToPlantTagPairs';
 export type { Plant3dInfo, PlantAndTagForOpenIn3d } from './logic/openItemsIn3d.utils';
+export { OpenIn3dSelectedItemsMenu } from './OpenIn3dSelectedItemsMenu';
 export { OpenItemsIn3dDialog } from './openItemsIn3dDialog';
-export { SelectedItemsMenu } from './SelectedItemsMenu';

package/src/lib/feature/openItemsIn3d/logic/openItemsIn3d.utils.d.ts

@@ -8,27 +8,6 @@
 export declare function getUniquePlantsWithItemCount(args: {
     items: PlantAndTagForOpenIn3d[];
 }): Plant3dInfoCount[];
-/**
- * Retrieves the items from the given array that have the same plant number as the selected plant number.
- *
- * @param selectedItems - The array of PlantTagPair objects.
- * @param selectedPlantNo - The selected plant number.
- * @returns An array of PlantTagPair objects that have the same plant number as the selected plant number.
- */
-export declare function getItemsForSelectedPlantNo(selectedItems: PlantAndTagForOpenIn3d[], selectedPlantNo: string): PlantAndTagForOpenIn3d[];
-/**
- * Checks if there are more then one unique plant numbers in the passed PlantTagPair[].
- *
- * @param items - The array of PlantTagPair objects to check.
- * @returns A boolean indicating whether multiple, unique plant numbers are present in the passed array.
- */
-export declare function isMultiplePlantNoSelected(items: PlantAndTagForOpenIn3d[]): boolean;
-/**
- * Retrieves the plant SAP ID from an array of PlantTagPair. It will return with the first, non empty plant SAP ID found.
- * @param items - The array of PlantTagPair items.
- * @returns The plant SAP ID if found, otherwise undefined.
- */
-export declare function getFirstPlantSapIdFromItems(items: PlantAndTagForOpenIn3d[]): string | undefined;
 export interface Plant3dInfo {
     instCode: string;
     sapId: string | undefined;

package/src/lib/feature/openItemsIn3d/openIn3dMenu.d.ts

@@ -1,7 +1,6 @@
 import React from 'react';
-import { ObjectsToSendTo3dTypes } from '../../utils/openIn3d/tagLists';
 interface OpenIn3dMenuProps {
-    onOpenIn3dButtonClick: (objectsToSendTo3d: ObjectsToSendTo3dTypes) => void;
+    onOpenIn3dButtonClick: () => void;
     disabled: boolean;
 }
 export declare const OpenIn3dMenu: React.FC<OpenIn3dMenuProps>;

package/src/lib/services/locationService/locationService.d.ts

@@ -0,0 +1,10 @@
+import { InternalApplicationLinks } from '../../types/navigation';
+export declare function setLocationServicePathname(pathname: InternalApplicationLinks | string): void;
+declare function isOnPage(applicationLink: InternalApplicationLinks | string): boolean;
+export declare const locationService: Readonly<{
+    isOnPage: typeof isOnPage;
+    isOnPdfViewer: () => boolean;
+    isOnEcho3dPage: () => boolean;
+    isOnHomePage: () => boolean;
+}>;
+export {};

package/src/lib/services/stores/createSimpleStore.d.ts

@@ -0,0 +1,29 @@
+type SimpleStore<T, Name extends string> = {
+    [K in Name]: T;
+} & {
+    [K in `set${Capitalize<Name>}`]: (value: T) => void;
+};
+/**
+ * Factory for creating a simple Zustand store with a value and a setter function. If more is needed, use a normal zustand store instead.
+ *
+ * The store will have the following structure:
+ * - A value corresponding to the `name` parameter.
+ * - A setter function dynamically named `set<Name>` to update the value.
+ *
+ * @template T The type of the value stored in the store (can be any type: string, number, object, etc.).
+ * @template Name The name of the state, used for both the key and the setter function.
+ *
+ * @param {T} initialValue The initial value of the store.
+ * @param {Name} name The name of the state, which will be used for the store key and setter function.
+ *
+ * @example
+ * const useCountStore = createSimpleStore(0, 'count');
+ *
+ * const { count, setCount } = useCountStore();
+ * console.log(count); // 0
+ *
+ * setCount(10);
+ * console.log(count); // 10
+ */
+export declare function createSimpleStore<T, Name extends string>(initialValue: T, name: Name): import("zustand").UseBoundStore<import("zustand").StoreApi<SimpleStore<T, Name>>>;
+export {};

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

@@ -0,0 +1 @@
+export { useUserSettingsStore, userSettingsSnapshot } from './userSettingStore';

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

@@ -0,0 +1,25 @@
+interface UserSettings {
+    measuringPointsEnabled: boolean;
+    setMeasuringPointsEnabled: (value: boolean) => void;
+}
+export declare function userSettingsSnapshot(): UserSettings;
+export declare const useUserSettingsStore: import("zustand").UseBoundStore<Omit<Omit<Omit<import("zustand").StoreApi<UserSettings>, "setState"> & {
+    setState<A extends string | {
+        type: string;
+    }>(partial: UserSettings | Partial<UserSettings> | ((state: UserSettings) => UserSettings | Partial<UserSettings>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<UserSettings, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: UserSettings) => void) => () => void;
+        onFinishHydration: (fn: (state: UserSettings) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<UserSettings, unknown>>;
+    };
+}, "setState"> & {
+    setState(nextStateOrUpdater: UserSettings | Partial<UserSettings> | ((state: import("immer").WritableDraft<UserSettings>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: string;
+    } | undefined): void;
+}>;
+export {};

package/src/lib/types/eventTypes/legendEvent.d.ts

@@ -1,4 +1,4 @@
-import { LegendItemStatus, LegendType } from '../../feature/legend/legend';
+import { LegendItemStatus, LegendType } from '../../feature/legacyLegend/legend';
 export interface LegendChangedEvent {
     newLegendType: LegendType;
 }

package/src/lib/types/hookLibrary.d.ts

@@ -7,6 +7,7 @@ export type SetActiveTagNo = (argsORtagNo: string | {
     keepLastNavigationItem?: boolean;
     openInPanel?: boolean;
     displayMessageOnItemNotFound?: boolean;
+    omitTagNoFromUrl?: boolean;
 }, activeTagTab?: string, activeTagSubTab?: string, instCode?: string, openInPanel?: boolean, displayMessageOnItemNotFound?: boolean) => void;
 export type TagData = [(tagNo: string, instCode: string) => void];
 export type SetActiveCommPackNo = (argsORcommPackNo: string | {

package/src/lib/types/navigation/internalApplicationLinks.d.ts

@@ -16,5 +16,6 @@ export declare enum InternalApplicationLinks {
     EchoMaps = "/maps",
     Echo3dWeb = "/echo3d",
     Turnaround = "/turnaround",
-    Sandbox = "/sandbox"
+    Sandbox = "/sandbox",
+    Home = "/"
 }

package/src/lib/utils/openIn3d/index.d.ts

@@ -1,2 +1,2 @@
-export { ObjectsToSendTo3dTypes, generateTemporaryTagListObject, getRandomColor, getTemporarilyEchoHubListFor3d } from './tagLists';
+export { generateTemporaryTagListObject, getRandomColor, getTemporarilyEchoHubListFor3d } from './tagLists';
 export type { HubListReturnType } from './tagLists';

package/src/lib/utils/openIn3d/tagLists.d.ts

@@ -3,10 +3,6 @@ export declare const getTemporarilyEchoHubListFor3d: (instCode: string, request:
     app3dUrl: string;
     web3dUrl: string;
 }>;
-export declare enum ObjectsToSendTo3dTypes {
-    workOrders = "workOrders",
-    tags = "tags"
-}
 export type HubListReturnType = {
     app3dUrl: string;
     web3dUrl: string;
@@ -23,7 +19,6 @@ export type HubListReturnType = {
  * @return {*} {TemporaryEchoHubListDto} temporary tag list object
  */
 export declare const generateTemporaryTagListObject: (args: {
-    ObjectsToSendTo3d: ObjectsToSendTo3dTypes;
     sourceModuleName: string;
     createdBy: string;
     plantCode: string;

package/src/lib/feature/openItemsIn3d/SelectedItemsMenu.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import { ObjectsToSendTo3dTypes } from '../../utils';
-interface SelectedItemsProps {
-    onOpenIn3dButtonClick: (ObjectsToSendTo3d: ObjectsToSendTo3dTypes) => void;
-    children?: React.ReactNode;
-    disabled?: boolean;
-}
-export declare const SelectedItemsMenu: React.FC<SelectedItemsProps>;
-export declare function getIsGlobalSelectionEnabled(): boolean;
-export {};