@topconsultnpm/sdkui-react 6.20.0-test1 → 6.21.0-dev1.2

package/lib/hooks/useDocumentOperations.js

@@ -0,0 +1,1275 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { AccessLevels, AccessLevelsEx, AppModules, DcmtOpers, DcmtTypeListCacheService, FileFormats, GeneralRetrieveFormats, LayoutModes, RetrieveFileOptions, SDK_Globals } from "@topconsultnpm/sdk-ts";
+import { DcmtOperationTypes, DownloadTypes, SearchResultContext } from "../ts";
+import { ButtonNames, ShowAlert, StyledModalContainer, StyledMultiViewPanel, TMBlogCommentForm, TMChooserForm, TMExceptionBoxManager, TMMessageBoxManager, TMModal, TMSpinner, WorkFlowApproveRejectPopUp, WorkFlowMoreInfoPopUp, WorkFlowReAssignPopUp } from "../components";
+import { useDeviceType, DeviceType } from '../components/base/TMDeviceProvider';
+import TMCustomButton from "../components/base/TMCustomButton";
+import TMDataGridExportForm from "../components/base/TMDataGridExportForm";
+import TMArchive from "../components/features/archive/TMArchive";
+import TMBatchUpdateForm from "../components/features/documents/TMBatchUpdateForm";
+import TMDcmtForm from "../components/features/documents/TMDcmtForm";
+import TMMasterDetailDcmts from "../components/features/documents/TMMasterDetailDcmts";
+import TMDcmtCheckoutInfoForm from "../components/features/search/TMDcmtCheckoutInfoForm";
+import TMSearch from "../components/features/search/TMSearch";
+import TMSearchResult from "../components/features/search/TMSearchResult";
+import TMSignatureInfoContent from "../components/features/search/TMSignatureInfoContent";
+import TMViewHistoryDcmt from "../components/features/search/TMViewHistoryDcmt";
+import TMFloatingMenuBar from "../components/NewComponents/FloatingMenuBar";
+import { useCheckInOutOperations } from "./useCheckInOutOperations";
+import { useDcmtOperations } from "./useDcmtOperations";
+import useFloatingBarPinnedItems from "./useFloatingBarPinnedItems";
+import { useInputAttachmentsDialog, useInputCvtFormatDialog } from "./useInputDialog";
+import { useRelatedDocuments } from "./useRelatedDocuments";
+import { convertSearchResultDescriptorToFileItems, dcmtsFileCachePreview, getDcmtCicoStatus, getMoreInfoTasksForDocument, IconActivity, IconArchiveDetail, IconArchiveDoc, IconArchiveMaster, IconBatchUpdate, IconCheck, IconCheckFile, IconCheckIn, IconCircleInfo, IconCloseCircle, IconConvertFilePdf, IconCopy, IconCustom, IconDelete, IconDetailDcmts, IconDotsVerticalCircleOutline, IconDownload, IconEdit, IconExportTo, IconFileDots, IconHide, IconInfo, IconMenuCAArchive, IconMoveToFolder, IconPair, IconPin, IconPlatform, IconPreview, IconRelation, IconSearch, IconShare, IconSharedDcmt, IconShow, IconSignaturePencil, IconStar, IconSubstFile, IconUndo, IconUnpair, IconUserGroupOutline, isPdfEditorAvailable, SDKUI_Localizator, searchResultToMetadataValues, TMImageLibrary } from '../helper';
+import { isXMLFileExt } from "../helper/dcmtsHelper";
+export const getSelectedDcmtsOrFocused = (selectedItems, focusedItem, fileFormat) => {
+    if (selectedItems.length <= 0 && !focusedItem)
+        return [];
+    if (selectedItems.length > 0) {
+        // Filtra solo gli item che hanno TID e DID validi
+        return selectedItems
+            .filter((item) => item.TID !== undefined && item.DID !== undefined)
+            .map((item) => { return { TID: item.TID, DID: item.DID, FILEEXT: item.FILEEXT, ISSIGNED: Number(item.ISSIGNED ?? 0), fileFormat: fileFormat, rowIndex: item.rowIndex }; });
+    }
+    else if (focusedItem !== undefined && focusedItem.TID !== undefined && focusedItem.DID !== undefined) {
+        return [{ TID: focusedItem.TID, DID: focusedItem.DID, FILEEXT: focusedItem.FILEEXT, ISSIGNED: Number(focusedItem.ISSIGNED ?? 0), fileFormat: fileFormat, rowIndex: focusedItem.rowIndex }];
+    }
+    return [];
+};
+export const getAllFieldSelectedDcmtsOrFocused = (selectedItems, focusedItem, fileFormat) => {
+    if (selectedItems.length <= 0 && !focusedItem)
+        return [];
+    if (selectedItems.length > 0) {
+        return selectedItems;
+    }
+    else if (focusedItem !== undefined) {
+        return [focusedItem];
+    }
+    return [];
+};
+export const useDocumentOperations = (props) => {
+    const { context, documentData, exportData, uiConfig, tasks, callbacks, } = props;
+    const { dtd, selectedItems, focusedItem, searchResult, currentSearchResults, currentMetadataValues, allUsers = [], datagridUtility, dcmtUtility, } = documentData;
+    /** State for managing the document(s) to process */
+    const [selectedDcmtInfos, setSelectedDcmtInfos] = useState([]);
+    const [selectedItemsFull, setSelectedItemsFull] = useState([]);
+    // Refs per evitare loop causati da nuove reference di array
+    const prevSelectedItemsRef = useRef([]);
+    const prevFocusedItemRef = useRef(undefined);
+    useEffect(() => {
+        // Confronto basato su TID/DID per evitare loop causati da nuove reference
+        const areItemsEqual = (a, b) => {
+            if (a.length !== b.length)
+                return false;
+            return a.every((item, index) => {
+                const other = b[index];
+                return item?.TID === other?.TID && item?.DID === other?.DID;
+            });
+        };
+        const selectedChanged = !areItemsEqual(selectedItems, prevSelectedItemsRef.current);
+        const focusedChanged = focusedItem?.TID !== prevFocusedItemRef.current?.TID || focusedItem?.DID !== prevFocusedItemRef.current?.DID;
+        if (selectedChanged || focusedChanged) {
+            prevSelectedItemsRef.current = selectedItems;
+            prevFocusedItemRef.current = focusedItem;
+            setSelectedDcmtInfos(getSelectedDcmtsOrFocused(selectedItems, focusedItem));
+            setSelectedItemsFull(getAllFieldSelectedDcmtsOrFocused(selectedItems, focusedItem));
+        }
+    }, [selectedItems, focusedItem]);
+    const onRefreshPreviewCallback = async () => {
+        await onRefreshPreviewForm?.();
+        await onRefreshPreviewDatagrid?.();
+    };
+    const { dataColumns, dataSource, selectedRowKeys, } = exportData ?? {};
+    const { visibleItems = [], onRefreshSearchAsyncDatagrid, onRefreshDataRowsAsync, refreshFocusedDataRowAsync, onRefreshBlogDatagrid, onRefreshPreviewDatagrid, refreshOperationsTrigger = 0, onRefreshOperationsDatagrid, } = datagridUtility ?? {};
+    const { approvalVID, dcmtDataRowForCicoStatus, selectedDcmtSearchResultRelations, dcmtTIDHasDetailRelations = false, dcmtTIDHasMasterRelations = false, updateCurrentDcmt, onCloseDcmtForm, onRefreshBlogForm, onRefreshPreviewForm, taskFormDialogComponent, s4TViewerDialogComponent } = dcmtUtility ?? {};
+    const { floatingBarContainerRef, customButtonsLayout, workingGroupContext, openS4TViewer = false, openDcmtFormAsModal = false, showDcmtFormSidebar = true, allowFloatingBar = true, enablePinIcons = true, allowRelations = true, showTodoDcmtForm = false, showToppyDraggableHelpCenter = true, toppyHelpCenterUsePortal = false, editPdfForm = false, inputDcmtFormLayoutMode = LayoutModes.Update, } = uiConfig;
+    const { allTasks = [], getAllTasks, deleteTaskByIdsCallback, addTaskCallback, editTaskCallback } = tasks;
+    const { 
+    // Refresh operations (data consistency)
+    onSavedAsyncCallback, onRefreshAfterAddDcmtToFavs, 
+    // Workflow operations
+    onWFOperationCompleted, 
+    // Navigation
+    canNavigateHandler, onNavigateHandler, handleNavigateToWGs, handleNavigateToDossiers, onReferenceClick, 
+    // Document forms/operations
+    openAddDocumentForm, openCommentFormCallback, onFileOpened, passToArchiveCallback, openWGsCopyMoveForm, onOpenS4TViewerRequest, onOpenPdfEditorRequest, 
+    // Task related
+    onTaskCreateRequest, openTaskFormHandler, } = callbacks;
+    // Force recalculation of selectedDcmtInfos when refreshOperationsTrigger changes (e.g., after file substitution where FILEEXT may change)
+    useEffect(() => {
+        if (refreshOperationsTrigger > 0) {
+            setSelectedDcmtInfos(getSelectedDcmtsOrFocused(selectedItems, focusedItem));
+            setSelectedItemsFull(getAllFieldSelectedDcmtsOrFocused(selectedItems, focusedItem));
+        }
+    }, [refreshOperationsTrigger]);
+    // Context helpers
+    const isDcmtFormContext = context === SearchResultContext.DCMT_FORM;
+    const { showHistory, showHistoryCallback, hideHistoryCallback, showCheckoutInformationForm, commentFormState, hideCommentFormCallback, showCheckoutInformationFormCallback, hideCheckoutInformationFormCallback, copyCheckoutPathToClipboardCallback, handleCheckOutCallback, handleCheckInCallback, showCicoWaitPanel, cicoWaitPanelTitle, showCicoPrimaryProgress, cicoPrimaryProgressText, cicoPrimaryProgressValue, cicoPrimaryProgressMax, } = useCheckInOutOperations({
+        onRefreshPreview: onRefreshPreviewCallback
+    });
+    const { abortController, showWaitPanel, waitPanelTitle, showPrimary, waitPanelTextPrimary, waitPanelValuePrimary, waitPanelMaxValuePrimary, showSecondary, waitPanelTextSecondary, waitPanelValueSecondary, waitPanelMaxValueSecondary, downloadDcmtsAsync, runOperationAsync, getDcmtFileAsync, clearDcmtsFileCache, removeDcmtsFileCache, isDcmtFileInCache } = useDcmtOperations();
+    const { 
+    // Data
+    relatedDcmts, pairedSearchResults, manyToManyRelations, selectedManyToManyRelation, manyToManyChooserDataSource, relatedDcmtsChooserDataSource, 
+    // Flags / State booleans
+    showRelatedDcmtsChooser, isOpenDetails, isOpenMaster, isOpenArchiveRelationForm, isPairingManyToMany, showManyToManyChooser, showPairSearchModal, currentTIDHasDetailRelations, currentTIDHasMasterRelations, canArchiveMasterRelation, canArchiveDetailRelation, hasManyToManyRelation, showPairDcmtsModal, 
+    // Pair search modal state
+    pairSearchModalTargetTID, pairSearchModalParentTID, pairSearchModalParentDID, pairSearchModalRelation, pairSearchModalInputMids, 
+    // Config
+    pairFloatingActionConfig, pairSearchModalFloatingActionConfig, 
+    // Archive state
+    archiveRelatedDcmtFormTID, archiveRelatedDcmtFormMids, archiveType, 
+    // Setters
+    setIsOpenDetails, setIsOpenMaster, setShowRelatedDcmtsChooser, setIsOpenArchiveRelationForm, setArchiveType, setArchiveRelatedDcmtFormTID, setArchiveRelatedDcmtFormMids, setShowManyToManyChooser, setShowPairDcmtsModal, setShowPairSearchModal, 
+    // Logic / Helpers
+    checkRelatedDcmtsArchiveCapability, checkManyToManyCapability, 
+    // Actions
+    pairManyToMany, executeManyToManyPairing, archiveDetailDocuments, archiveMasterDocuments, archiveRelatedDcmtHandler } = useRelatedDocuments({
+        selectedSearchResult: isDcmtFormContext ? selectedDcmtSearchResultRelations : searchResult,
+        focusedItem: focusedItem,
+        currentSearchResults
+    });
+    // Context-aware configuration for relations and other context-dependent logic
+    const contextConfig = {
+        hasMasterRelations: isDcmtFormContext ? dcmtTIDHasMasterRelations : currentTIDHasMasterRelations,
+        hasDetailRelations: isDcmtFormContext ? dcmtTIDHasDetailRelations : currentTIDHasDetailRelations,
+        canShowRelations: !isDcmtFormContext || inputDcmtFormLayoutMode === LayoutModes.Update,
+        approvalTID: isDcmtFormContext ? (approvalVID ?? focusedItem?.TID) : focusedItem?.TID,
+    };
+    const { openConfirmAttachmentsDialog, ConfirmAttachmentsDialog } = useInputAttachmentsDialog();
+    const [confirmFormat, ConfirmFormatDialog] = useInputCvtFormatDialog();
+    const MAX_DCMTS_FOR_SELECTION_REFRESH = 100;
+    const { pinnedItemIds, togglePin, setPinnedItemIds } = useFloatingBarPinnedItems();
+    const deviceType = useDeviceType();
+    const isMobile = deviceType === DeviceType.MOBILE;
+    const [showFloatingBar, setShowFloatingBar] = useState(allowFloatingBar);
+    const [isOpenDcmtForm, setIsOpenDcmtForm] = useState(false);
+    const [dcmtFormLayoutMode, setDcmtFormLayoutMode] = useState(LayoutModes.Update);
+    const [currentCustomButton, setCurrentCustomButton] = useState();
+    // State to control the visibility of the details form
+    const [showSearchTMDatagrid, setShowSearchTMDatagrid] = useState(false);
+    const [secondaryMasterDcmts, setSecondaryMasterDcmts] = useState([]);
+    const [isOpenSharedArchive, setIsOpenSharedArchive] = useState(false);
+    const [sharedDcmtFile, setSharedDcmtFile] = useState(undefined);
+    // State to control the shared document search results
+    const [sharedDcmtSearchResults, setSharedDcmtSearchResults] = useState([]);
+    /** Toppy Operations */
+    const [showApprovePopup, setShowApprovePopup] = useState(false);
+    const [showRejectPopup, setShowRejectPopup] = useState(false);
+    const [showReAssignPopup, setShowReAssignPopup] = useState(false);
+    const [showMoreInfoPopup, setShowMoreInfoPopup] = useState(false);
+    const [isOpenBatchUpdate, setIsOpenBatchUpdate] = useState(false);
+    const [isModifiedBatchUpdate, setIsModifiedBatchUpdate] = useState(false);
+    const openDetailDcmtsFormHandler = (value) => { setIsOpenDetails(value); };
+    const openMasterDcmtsFormHandler = (value) => { setIsOpenMaster(value); };
+    // State to control whether the export form (for exporting to Excel/CSV/txt and others) should be shown
+    const [showExportForm, setShowExportForm] = useState(false);
+    const updateShowApprovePopup = (value) => {
+        setShowApprovePopup(value);
+    };
+    const updateShowRejectPopup = (value) => {
+        setShowRejectPopup(value);
+    };
+    const updateShowReAssignPopup = (value) => {
+        setShowReAssignPopup(value);
+    };
+    const updateShowMoreInfoPopup = (value) => {
+        setShowMoreInfoPopup(value);
+    };
+    const onDcmtFormOpenChange = (isOpen, layoutMode) => {
+        setIsOpenDcmtForm(isOpen);
+        setDcmtFormLayoutMode(layoutMode);
+    };
+    const handleAddItem = (tid, did) => {
+        let newItem = { TID: tid ?? 0, DID: did ?? 0 };
+        setSecondaryMasterDcmts((prevItems) => [...prevItems, newItem]);
+    };
+    const handleRemoveItem = (tid, did) => {
+        setSecondaryMasterDcmts((prevItems) => prevItems.filter(item => item.TID !== tid && item.DID !== did));
+    };
+    const updateBatchUpdateForm = (value) => { setIsOpenBatchUpdate(value); };
+    // Disabilita se ci sono più documenti da processare o se non c'è un documento valido
+    const isDisabledForSingleRow = () => {
+        return selectedDcmtInfos.length !== 1 || selectedDcmtInfos[0]?.TID === undefined || selectedDcmtInfos[0]?.DID === undefined;
+    };
+    // Disabilita se non ci sono documenti validi da processare
+    const isDisabledForMultiRow = () => {
+        return selectedDcmtInfos.length === 0 || selectedDcmtInfos.every(d => d.TID === undefined || d.DID === undefined);
+    };
+    const onRefreshBlog = async () => {
+        await onRefreshBlogForm?.();
+        await onRefreshBlogDatagrid?.();
+    };
+    const signatureInformationCallback = async (isMobile, inputDcmts) => {
+        try {
+            TMSpinner.show({ description: SDKUI_Localizator.Loading });
+            if (!inputDcmts || inputDcmts.length === 0) {
+                ShowAlert({
+                    message: SDKUI_Localizator.NoDcmtSelected,
+                    mode: 'warning',
+                    title: SDKUI_Localizator.SignatureInformation,
+                    duration: 3000
+                });
+                return;
+            }
+            if (inputDcmts.length > 1) {
+                ShowAlert({
+                    message: "Selezionare un solo documento per visualizzare le informazioni di firma",
+                    mode: 'warning',
+                    title: SDKUI_Localizator.SignatureInformation,
+                    duration: 3000
+                });
+                return;
+            }
+            TMMessageBoxManager.show({
+                title: SDKUI_Localizator.SignatureInformation,
+                buttons: [ButtonNames.OK],
+                showToppy: false,
+                resizable: true,
+                initialWidth: !isMobile ? '700px' : undefined,
+                message: _jsx(TMSignatureInfoContent, { inputDcmt: inputDcmts[0] })
+            });
+        }
+        catch (error) {
+            console.error(error);
+            TMExceptionBoxManager.show({ exception: error });
+        }
+        finally {
+            TMSpinner.hide();
+        }
+    };
+    const openFormHandler = (layoutMode) => {
+        const currentDcmt = selectedDcmtInfos?.[0];
+        // Verifica che ci sia un documento selezionato con TID e DID validi
+        if (!currentDcmt || currentDcmt.TID === undefined || currentDcmt.DID === undefined) {
+            ShowAlert({
+                message: SDKUI_Localizator.InvalidDcmt,
+                mode: "warning",
+                title: layoutMode === LayoutModes.Ark ? SDKUI_Localizator.Archive : SDKUI_Localizator.OpenTheDocument,
+                duration: 3000
+            });
+            return;
+        }
+        onDcmtFormOpenChange(true, layoutMode);
+    };
+    const openSharedArchiveHandler = async () => {
+        if (selectedDcmtInfos.length === 0) {
+            ShowAlert({ message: "Nessun documento selezionato", mode: "warning", title: 'Archiviazione Condivisa', duration: 3000 });
+            return;
+        }
+        if (dtd?.perm?.canArchive !== AccessLevelsEx.Yes && dtd?.perm?.canArchive !== AccessLevelsEx.Mixed) {
+            ShowAlert({
+                message: "Non hai i permessi per archiviare documenti di questo tipo.",
+                mode: 'warning',
+                title: 'Archivio Condivisa',
+                duration: 5000
+            });
+            return;
+        }
+        try {
+            const rfo = new RetrieveFileOptions();
+            rfo.retrieveReason = DcmtOpers.None;
+            rfo.generalRetrieveFormat = GeneralRetrieveFormats.OriginalUnsigned;
+            const dcmt = selectedDcmtInfos[0];
+            let dcmtFile = await getDcmtFileAsync({ TID: dcmt?.TID, DID: dcmt?.DID }, rfo, 'Archiviazione Condivisa', false, true);
+            if (dcmtFile) {
+                setSharedDcmtFile(dcmtFile?.file);
+            }
+            setIsOpenSharedArchive(true);
+        }
+        catch (e) {
+            TMExceptionBoxManager.show({ exception: e });
+        }
+    };
+    const showSharedDcmtsHandler = async () => {
+        try {
+            if (selectedDcmtInfos.length === 0) {
+                ShowAlert({ message: "Nessun documento selezionato", mode: "warning", title: 'Documenti Condivisi', duration: 3000 });
+                return;
+            }
+            const dcmt = selectedDcmtInfos[0];
+            TMSpinner.show({ description: "Caricamento documenti condivisi..." });
+            const se = SDK_Globals.tmSession?.NewSearchEngine();
+            const sharedDcmts = await se?.GetSharedDcmtsAsync(dcmt.TID, dcmt.DID);
+            if (sharedDcmts && sharedDcmts.length > 0) {
+                setSharedDcmtSearchResults(sharedDcmts);
+            }
+            else {
+                ShowAlert({ message: "Nessun documento condiviso trovato.", mode: "info", title: 'Documenti Condivisi', duration: 5000 });
+            }
+        }
+        catch (e) {
+            TMExceptionBoxManager.show({ exception: e });
+        }
+        finally {
+            TMSpinner.hide();
+        }
+    };
+    const addPinIconToItems = (items) => {
+        if (isMobile || !enablePinIcons)
+            return items;
+        return items.map(item => {
+            const newItem = { ...item };
+            if (item.id && item.onClick && !item.submenu) {
+                newItem.rightIconProps = {
+                    icon: _jsx(IconPin, {}),
+                    activeColor: 'red',
+                    inactiveColor: 'black',
+                    isActive: pinnedItemIds?.includes(item.id) ?? false,
+                    onClick: () => togglePin(item.id),
+                };
+            }
+            if (item.submenu && item.submenu.length > 0) {
+                newItem.submenu = addPinIconToItems(item.submenu);
+            }
+            return newItem;
+        });
+    };
+    const addToFavoriteOperation = () => {
+        return {
+            id: 'fav',
+            icon: _jsx(IconStar, {}),
+            name: SDKUI_Localizator.AddTo + ' ' + SDKUI_Localizator.Favorites,
+            operationType: 'multiRow',
+            disabled: context === SearchResultContext.FAVORITES_AND_RECENTS || isDisabledForMultiRow(),
+            onClick: async () => { await runOperationAsync(selectedDcmtInfos, DcmtOperationTypes.AddToFavs); onRefreshAfterAddDcmtToFavs?.(); },
+        };
+    };
+    const addReplaceFileOperation = () => {
+        return {
+            id: 'repl',
+            icon: _jsx(IconSubstFile, {}),
+            name: SDKUI_Localizator.AddOrSubstFile,
+            operationType: 'singleRow',
+            disabled: dtd?.perm?.canSubstFile !== AccessLevels.Yes ? true : isDisabledForSingleRow(),
+            onClick: async () => {
+                const currentDcmt = selectedDcmtInfos?.[0];
+                if (!currentDcmt || currentDcmt.TID === undefined || currentDcmt.DID === undefined) {
+                    ShowAlert({
+                        message: SDKUI_Localizator.InvalidDcmt,
+                        mode: "warning",
+                    });
+                    return;
+                }
+                await runOperationAsync(selectedDcmtInfos, DcmtOperationTypes.SubstituteFile, async () => {
+                    await refreshDocumentPreview();
+                    await onRefreshOperationsDatagrid?.();
+                });
+            }
+        };
+    };
+    const openFormOperation = () => {
+        return {
+            id: 'open-form',
+            icon: _jsx(IconPreview, {}),
+            name: SDKUI_Localizator.OpenForm,
+            operationType: 'singleRow',
+            disabled: isDisabledForSingleRow(),
+            onClick: () => openFormHandler(LayoutModes.Update)
+        };
+    };
+    const deletetionMenuItem = () => {
+        return {
+            id: 'del',
+            icon: _jsx(IconDelete, {}),
+            name: SDKUI_Localizator.Deletion,
+            operationType: 'multiRow',
+            disabled: isDisabledForMultiRow(),
+            submenu: [
+                {
+                    id: 'del-log',
+                    icon: _jsx(IconDelete, {}),
+                    name: SDKUI_Localizator.LogDelete,
+                    operationType: 'multiRow',
+                    disabled: dtd?.perm?.canLogicalDelete !== AccessLevels.Yes ? true : isDisabledForMultiRow(),
+                    onClick: async () => {
+                        await runOperationAsync(selectedDcmtInfos, DcmtOperationTypes.LogDelete, selectedDcmtInfos.length <= MAX_DCMTS_FOR_SELECTION_REFRESH ? onRefreshDataRowsAsync : onRefreshSearchAsyncDatagrid);
+                    }
+                },
+                {
+                    id: 'del-rest',
+                    icon: _jsx(IconUndo, {}),
+                    name: SDKUI_Localizator.Restore,
+                    operationType: 'multiRow',
+                    disabled: dtd?.perm?.canLogicalDelete !== AccessLevels.Yes ? true : isDisabledForMultiRow(),
+                    onClick: async () => {
+                        await runOperationAsync(selectedDcmtInfos, DcmtOperationTypes.Undelete, selectedDcmtInfos.length <= MAX_DCMTS_FOR_SELECTION_REFRESH ? onRefreshDataRowsAsync : onRefreshSearchAsyncDatagrid);
+                    }
+                },
+                {
+                    id: 'del-phys',
+                    icon: _jsx(IconCloseCircle, {}),
+                    name: SDKUI_Localizator.PhysDelete,
+                    operationType: 'multiRow',
+                    disabled: dtd?.perm?.canPhysicalDelete !== AccessLevels.Yes ? true : isDisabledForMultiRow(),
+                    onClick: async () => { await runOperationAsync(selectedDcmtInfos, DcmtOperationTypes.PhysDelete, onRefreshSearchAsyncDatagrid); }
+                },
+            ]
+        };
+    };
+    const fileCheckMenuItem = () => {
+        return {
+            id: 'chk',
+            icon: _jsx(IconCheckFile, {}),
+            name: SDKUI_Localizator.FileCheck,
+            operationType: 'multiRow',
+            disabled: isDisabledForMultiRow(),
+            onClick: async () => { await runOperationAsync(selectedDcmtInfos, DcmtOperationTypes.CheckFile); }
+        };
+    };
+    const fileConversionsMenuItem = () => {
+        return {
+            id: 'conv',
+            icon: _jsx(IconConvertFilePdf, {}),
+            name: SDKUI_Localizator.FileConversion,
+            operationType: 'multiRow',
+            disabled: isDisabledForMultiRow(),
+            onClick: async () => {
+                let format = await confirmFormat();
+                if (format === FileFormats.None)
+                    return;
+                const dcmts = selectedDcmtInfos.map(dcmt => {
+                    const cacheKey = `${dcmt.TID}-${dcmt.DID}`;
+                    if (dcmtsFileCachePreview.has(cacheKey)) {
+                        removeDcmtsFileCache(cacheKey);
+                    }
+                    return { ...dcmt, fileFormat: format };
+                });
+                const refreshFn = async () => {
+                    const baseRefreshFn = dcmts.length <= MAX_DCMTS_FOR_SELECTION_REFRESH ? onRefreshDataRowsAsync : onRefreshSearchAsyncDatagrid;
+                    await onRefreshPreviewCallback();
+                    await baseRefreshFn?.();
+                    await onRefreshOperationsDatagrid?.();
+                };
+                await runOperationAsync(dcmts, DcmtOperationTypes.ConvertFile, refreshFn);
+            }
+        };
+    };
+    const createContextualTaskMenuItem = () => {
+        return {
+            id: 'task',
+            icon: _jsx(IconActivity, {}),
+            name: SDKUI_Localizator.CreateContextualTask,
+            operationType: 'singleRow',
+            disabled: isDisabledForSingleRow(),
+            onClick: () => { openTaskFormHandler?.(); }
+        };
+    };
+    const downloadFileMenuItem = () => {
+        return {
+            id: 'dl',
+            icon: _jsx(IconDownload, {}),
+            operationType: 'multiRow',
+            disabled: dtd?.perm?.canRetrieveFile !== AccessLevels.Yes ? true : isDisabledForMultiRow(),
+            name: SDKUI_Localizator.DownloadFile, onClick: () => downloadDcmtsAsync(selectedDcmtInfos, DownloadTypes.Dcmt, "download", undefined, undefined, true)
+        };
+    };
+    const downloadXMLAttachmentsMenuItem = () => {
+        return {
+            id: 'dl-xml',
+            icon: _jsx(IconDownload, {}),
+            operationType: 'singleRow',
+            disabled: !isXMLFileExt(selectedDcmtInfos?.[0]?.FILEEXT) ? true : isDisabledForSingleRow(),
+            name: SDKUI_Localizator.DownloadXMLAttachments, onClick: () => downloadDcmtsAsync(selectedDcmtInfos, DownloadTypes.Attachment, "download", undefined, openConfirmAttachmentsDialog, true)
+        };
+    };
+    const duplicateDocumentMenuItem = () => {
+        return {
+            id: 'dup',
+            icon: _jsx(IconArchiveDoc, {}),
+            name: SDKUI_Localizator.DuplicateDocument,
+            operationType: 'singleRow',
+            disabled: dtd?.perm?.canArchive !== AccessLevelsEx.Yes && dtd?.perm?.canArchive !== AccessLevelsEx.Mixed ? true : isDisabledForSingleRow(),
+            onClick: () => { openFormHandler(LayoutModes.Ark); }
+        };
+    };
+    const batchUpdateMenuItem = () => {
+        return {
+            id: 'batch',
+            icon: _jsx(IconBatchUpdate, {}),
+            name: SDKUI_Localizator.BatchUpdate,
+            operationType: 'multiRow',
+            disabled: dtd?.perm?.canUpdate !== AccessLevelsEx.Yes && dtd?.perm?.canUpdate !== AccessLevelsEx.Mixed ? true : isDisabledForMultiRow(),
+            onClick: () => updateBatchUpdateForm(true)
+        };
+    };
+    const passToArchive = () => {
+        return {
+            id: 'p2a',
+            icon: _jsx(IconMenuCAArchive, { fontSize: 16, viewBox: '11 11.5 26 27', strokeWidth: 2 }),
+            name: SDKUI_Localizator.PassToArchive,
+            operationType: 'singleRow',
+            disabled: dtd?.perm?.canArchive !== AccessLevelsEx.Yes && dtd?.perm?.canArchive !== AccessLevelsEx.Mixed ? true : isDisabledForSingleRow(),
+            onClick: async () => {
+                try {
+                    const item = selectedDcmtInfos.length === 1 ? selectedDcmtInfos[0] : undefined;
+                    if (!item?.TID || !item?.DID)
+                        return;
+                    TMSpinner.show({ description: SDKUI_Localizator.Loading });
+                    const getMetadataResult = await SDK_Globals.tmSession?.NewSearchEngine().GetMetadataAsync(item.TID, item.DID, true);
+                    const dtdFull = getMetadataResult?.dtdResult;
+                    const rowsFull = dtdFull?.rows ? dtdFull.rows[0] : [];
+                    const midsFull = getMetadataResult?.selectMIDs;
+                    const dtdWithMetadata = await DcmtTypeListCacheService.GetWithNotGrantedAsync(item.TID, item.DID, getMetadataResult);
+                    const allMetadataValues = searchResultToMetadataValues(item.TID, dtdFull, rowsFull, midsFull, dtdWithMetadata?.metadata, LayoutModes.Update);
+                    const outputMids = allMetadataValues
+                        ?.filter(md => md.mid && md.mid > 100 && md.value && md.value.length > 0)
+                        .map(md => ({ mid: md.mid, value: md.value })) || [];
+                    TMSpinner.hide();
+                    passToArchiveCallback?.(outputMids, item.TID);
+                }
+                catch (error) {
+                    TMSpinner.hide();
+                    TMExceptionBoxManager.show({ exception: error });
+                }
+            }
+        };
+    };
+    const refreshDocumentPreview = async () => {
+        const currentDcmt = selectedDcmtInfos?.[0];
+        if (!currentDcmt)
+            return;
+        const cacheKey = `${currentDcmt.TID}-${currentDcmt.DID}`;
+        if (dcmtsFileCachePreview.has(cacheKey))
+            removeDcmtsFileCache(cacheKey);
+        await onRefreshPreviewCallback();
+        await onRefreshDataRowsAsync?.();
+    };
+    const pdfEditorMenuItem = (openEditPdfCallback) => {
+        // Take the first document (used for validation checks)
+        const firstDoc = selectedDcmtInfos?.[0];
+        // Check if the selected document is a PDF
+        const isPdf = firstDoc?.FILEEXT?.toLowerCase() === "pdf";
+        // Check if the document has been signed
+        const isSigned = firstDoc?.ISSIGNED === 1;
+        // Check if the user has permission to substitute files
+        const canSubstitute = dtd?.perm?.canSubstFile === AccessLevels.Yes;
+        // Determine whether the menu item should be disabled
+        const isDisabled = !canSubstitute || isDisabledForSingleRow() || !isPdf || isSigned;
+        return {
+            id: 'pdf-ed',
+            icon: _jsx(IconEdit, {}),
+            name: "PDF Editor",
+            operationType: 'singleRow',
+            disabled: isDisabled,
+            onClick: () => openEditPdfCallback(selectedDcmtInfos, refreshDocumentPreview),
+        };
+    };
+    const handleSignApprove = () => {
+        if (!onOpenS4TViewerRequest) {
+            ShowAlert({
+                message: "Non è stato possibile proseguire con la firma e l'approvazione.",
+                mode: "warning",
+                duration: 3000,
+                title: SDKUI_Localizator.SignatureAndApprove,
+            });
+            return;
+        }
+        onOpenS4TViewerRequest(selectedDcmtInfos, refreshDocumentPreview);
+    };
+    const signatureMenuItem = () => {
+        return {
+            id: 'sign',
+            icon: _jsx(IconSignaturePencil, {}),
+            name: SDKUI_Localizator.Signature,
+            disabled: isDisabledForSingleRow() && isDisabledForMultiRow(),
+            submenu: [
+                {
+                    id: 'sign-do',
+                    icon: _jsx(IconSignaturePencil, {}),
+                    operationType: 'singleRow',
+                    disabled: isDisabledForSingleRow(),
+                    name: SDKUI_Localizator.Signature,
+                    onClick: handleSignApprove
+                },
+                {
+                    id: 'sign-info',
+                    icon: _jsx(IconCircleInfo, {}),
+                    name: SDKUI_Localizator.SignatureInformation,
+                    operationType: 'singleRow',
+                    disabled: isDisabledForSingleRow(),
+                    onClick: () => signatureInformationCallback(isMobile, selectedDcmtInfos)
+                },
+                {
+                    id: 'sign-verify',
+                    icon: _jsx(IconCheckIn, {}),
+                    name: SDKUI_Localizator.VerifySignature,
+                    operationType: 'multiRow',
+                    disabled: isDisabledForMultiRow(),
+                    onClick: async () => { await runOperationAsync(selectedDcmtInfos, DcmtOperationTypes.VerifySign); }
+                },
+            ]
+        };
+    };
+    const handleCheckOutOperationCallback = async (checkout) => {
+        const firstDoc = selectedDcmtInfos?.[0];
+        if (!firstDoc)
+            return;
+        const onRefreshAsync = async () => {
+            await updateCurrentDcmt?.();
+            await refreshFocusedDataRowAsync?.(firstDoc.TID, firstDoc.DID, true);
+        };
+        await handleCheckOutCallback(firstDoc, checkout, dtd?.name ?? SDKUI_Localizator.SearchResult, downloadDcmtsAsync, onRefreshAsync);
+    };
+    const handleCheckInOperationCallback = async () => {
+        const firstDoc = selectedDcmtInfos?.[0];
+        if (!firstDoc)
+            return;
+        firstDoc.fileName = dtd?.name ?? SDKUI_Localizator.SearchResult;
+        const onRefreshAsync = async () => {
+            await updateCurrentDcmt?.();
+            await refreshFocusedDataRowAsync?.(firstDoc.TID, firstDoc.DID, true);
+        };
+        await handleCheckInCallback(firstDoc, onRefreshAsync);
+    };
+    const copyCheckoutPathToClipboardOperationCallback = () => {
+        const firstDoc = selectedDcmtInfos?.[0];
+        if (!firstDoc)
+            return;
+        copyCheckoutPathToClipboardCallback(firstDoc, dtd?.name ?? SDKUI_Localizator.SearchResult);
+    };
+    const checkinMenuItem = () => {
+        // Take the first document (used for validation checks)
+        let dcmt = focusedItem;
+        if (isDcmtFormContext) {
+            dcmt = dcmtDataRowForCicoStatus;
+        }
+        const { cicoEnabled, checkoutStatus } = getDcmtCicoStatus(dcmt, allUsers, dtd);
+        return {
+            id: 'cico',
+            icon: _jsx(IconFileDots, {}),
+            name: "Check in/Check out",
+            disabled: dcmt === undefined || isDisabledForSingleRow(),
+            submenu: [
+                {
+                    id: 'co',
+                    icon: _jsx("span", { style: { fontSize: '18px' }, className: "dx-icon-edit" }),
+                    name: 'Check out',
+                    disabled: !cicoEnabled || checkoutStatus.isCheckedOut || isDisabledForSingleRow(),
+                    onClick: () => handleCheckOutOperationCallback(true),
+                },
+                {
+                    id: 'ci',
+                    icon: _jsx("span", { style: { fontSize: '18px' }, className: "dx-icon-unlock" }),
+                    name: 'Check in',
+                    onClick: () => handleCheckInOperationCallback(),
+                    disabled: !cicoEnabled || !checkoutStatus.isCheckedOut || checkoutStatus.mode === 'lockMode' || isDisabledForSingleRow()
+                },
+                {
+                    id: 'co-cancel',
+                    icon: _jsx("span", { style: { fontSize: '18px' }, className: "dx-icon-remove" }),
+                    name: SDKUI_Localizator.CancelCheckOut,
+                    disabled: !cicoEnabled || !checkoutStatus.isCheckedOut || checkoutStatus.mode === 'lockMode' || isDisabledForSingleRow(),
+                    onClick: () => handleCheckOutOperationCallback(false),
+                },
+                {
+                    id: 'co-info',
+                    icon: _jsx("span", { style: { fontSize: '18px' }, className: "dx-icon-info" }),
+                    name: SDKUI_Localizator.CheckoutInfo,
+                    onClick: showCheckoutInformationFormCallback,
+                    disabled: !checkoutStatus.isCheckedOut || isDisabledForSingleRow()
+                },
+                {
+                    id: 'co-path',
+                    icon: _jsx("span", { style: { fontSize: '18px' }, className: "dx-icon-copy" }),
+                    name: SDKUI_Localizator.CopyCheckoutPath,
+                    onClick: copyCheckoutPathToClipboardOperationCallback,
+                    disabled: !checkoutStatus.isCheckedOut || isDisabledForSingleRow()
+                },
+                {
+                    id: 'co-hist',
+                    icon: _jsx("span", { style: { fontSize: '18px' }, className: "dx-icon-clock" }),
+                    name: SDKUI_Localizator.History,
+                    disabled: !cicoEnabled || isDisabledForSingleRow(),
+                    onClick: showHistoryCallback,
+                },
+            ]
+        };
+    };
+    const relationsMenuItem = () => {
+        return {
+            id: 'rel',
+            icon: _jsx(IconRelation, {}),
+            name: SDKUI_Localizator.Relations,
+            operationType: 'multiRow',
+            disabled: isDisabledForMultiRow(),
+            submenu: [
+                {
+                    id: 'rel-pair',
+                    icon: _jsx(IconPair, {}),
+                    name: SDKUI_Localizator.MatchManyDocumentsManyToMany,
+                    operationType: 'multiRow',
+                    disabled: !hasManyToManyRelation || isDisabledForMultiRow(),
+                    onClick: async () => await pairManyToMany(true)
+                },
+                {
+                    id: 'rel-unpair',
+                    icon: _jsx(IconUnpair, {}),
+                    name: SDKUI_Localizator.UnmatchManyDocumentsManyToMany,
+                    operationType: 'multiRow',
+                    disabled: !hasManyToManyRelation || isDisabledForMultiRow(),
+                    onClick: async () => await pairManyToMany(false)
+                },
+                {
+                    id: 'rel-ark-mst',
+                    icon: _jsx(IconArchiveMaster, {}),
+                    name: SDKUI_Localizator.ArchiveMasterDocument,
+                    operationType: 'multiRow',
+                    beginGroup: true,
+                    disabled: canArchiveMasterRelation !== true,
+                    onClick: async () => await archiveMasterDocuments(selectedDcmtInfos?.[0]?.TID)
+                },
+                {
+                    id: 'rel-ark-det',
+                    icon: _jsx(IconArchiveDetail, {}),
+                    name: SDKUI_Localizator.ArchiveDetailDocument,
+                    operationType: 'multiRow',
+                    disabled: canArchiveDetailRelation !== true,
+                    onClick: async () => await archiveDetailDocuments?.(selectedDcmtInfos?.[0]?.TID)
+                },
+                {
+                    id: 'rel-mst',
+                    icon: _jsx(IconDetailDcmts, { transform: 'scale(-1, 1)' }),
+                    name: SDKUI_Localizator.DcmtsMaster,
+                    operationType: 'singleRow',
+                    visible: true,
+                    beginGroup: true,
+                    disabled: !contextConfig.hasMasterRelations || !contextConfig.canShowRelations || isDisabledForMultiRow(),
+                    onClick: () => openMasterDcmtsFormHandler(true)
+                },
+                {
+                    id: 'rel-det',
+                    icon: _jsx(IconDetailDcmts, {}),
+                    name: SDKUI_Localizator.DcmtsDetail,
+                    operationType: 'multiRow',
+                    disabled: !contextConfig.hasDetailRelations || !contextConfig.canShowRelations || isDisabledForMultiRow(),
+                    visible: true,
+                    onClick: () => openDetailDcmtsFormHandler(true)
+                }
+            ]
+        };
+    };
+    /* const shareMenuItem = (): TMContextMenuItemProps => {
+        return {
+            icon: <IconShare />,
+            name: "Condivisione",
+            operationType: 'multiRow',
+            disabled: fromDatagrid ? false : isDisabledForMultiRow(),
+            submenu: [
+                {
+                    icon: <IconShare />,
+                    name: "Archiviazione condivisa",
+                    operationType: 'multiRow',
+                    disabled: fromDatagrid ? false : isDisabledForMultiRow(),
+                    onClick: () => ShowAlert({ message: "TODO Archiviazione condivisa", mode: 'info', title: `${"TODO"}`, duration: 3000 })
+                },
+                {
+                    icon: <IconSharedDcmt />,
+                    name: "Documenti condivisi",
+                    operationType: 'multiRow',
+                    disabled: fromDatagrid ? false : isDisabledForMultiRow(),
+                    onClick: () => ShowAlert({ message: "TODO Documenti condivisi", mode: 'info', title: `${"TODO"}`, duration: 3000 })
+                }
+            ]
+        }
+    } */
+    const sharedDcmtsMenuItem = () => {
+        return {
+            id: 'shr',
+            icon: _jsx(IconSharedDcmt, {}),
+            name: SDKUI_Localizator.SharedDocuments,
+            operationType: 'multiRow',
+            disabled: isDisabledForSingleRow(),
+            submenu: [
+                {
+                    id: 'shr-ark',
+                    icon: _jsx(IconSharedDcmt, {}),
+                    name: SDKUI_Localizator.SharedArchiving,
+                    operationType: 'singleRow',
+                    disabled: isDisabledForSingleRow(),
+                    onClick: async () => { await openSharedArchiveHandler(); }
+                },
+                {
+                    id: 'shr-show',
+                    icon: _jsx(IconSharedDcmt, {}),
+                    name: SDKUI_Localizator.ShowSharedDocuments,
+                    operationType: 'multiRow',
+                    disabled: isDisabledForSingleRow(),
+                    onClick: async () => { await showSharedDcmtsHandler(); }
+                }
+            ]
+        };
+    };
+    const fullTextSearchMenuItem = () => {
+        const dcmt = selectedItemsFull?.[0];
+        return {
+            id: 'ft',
+            icon: _jsx(IconSearch, {}),
+            name: SDKUI_Localizator.FullTextSearch,
+            operationType: 'multiRow',
+            disabled: isDisabledForMultiRow(),
+            submenu: [
+                {
+                    id: 'ft-info',
+                    icon: _jsx(IconInfo, {}),
+                    name: SDKUI_Localizator.IndexingInformation,
+                    operationType: 'singleRow',
+                    disabled: isDisabledForSingleRow(),
+                    onClick: async () => {
+                        try {
+                            TMSpinner.show({ description: `${SDKUI_Localizator.Loading}...` });
+                            const msg = await SDK_Globals.tmSession?.NewSearchEngine().FreeSearchGetDcmtInfoAsync(dcmt.TID, dcmt.DID);
+                            TMMessageBoxManager.show({ buttons: [ButtonNames.OK], message: msg, title: SDKUI_Localizator.IndexingInformation });
+                        }
+                        catch (e) {
+                            TMExceptionBoxManager.show({ exception: e });
+                        }
+                        finally {
+                            TMSpinner.hide();
+                        }
+                    }
+                },
+                {
+                    id: 'ft-idx',
+                    icon: _jsx(IconArchiveDoc, {}),
+                    name: SDKUI_Localizator.IndexOrReindex,
+                    operationType: 'multiRow',
+                    disabled: isDisabledForMultiRow(),
+                    onClick: async () => { await runOperationAsync(selectedDcmtInfos, DcmtOperationTypes.FreeSearchReindex); }
+                },
+                {
+                    id: 'ft-del',
+                    icon: _jsx(IconDelete, {}),
+                    name: SDKUI_Localizator.IndexingDelete,
+                    operationType: 'multiRow',
+                    disabled: isDisabledForMultiRow(),
+                    onClick: async () => { await runOperationAsync(selectedDcmtInfos, DcmtOperationTypes.FreeSearchPurge); }
+                },
+                ...(dcmt?.FTExplanations !== undefined
+                    ? [{
+                            id: 'ft-det',
+                            icon: _jsx(IconPlatform, {}),
+                            name: SDKUI_Localizator.ResultDetails,
+                            operationType: 'singleRow',
+                            disabled: isDisabledForSingleRow(),
+                            onClick: () => {
+                                TMMessageBoxManager.show({
+                                    showToppy: false,
+                                    buttons: [ButtonNames.OK],
+                                    message: dcmt?.FTExplanations, title: "Dettagli del risultato"
+                                });
+                            }
+                        }] : []),
+            ]
+        };
+    };
+    const otherOperationsMenuItem = () => {
+        return {
+            id: 'oth',
+            icon: _jsx(IconDotsVerticalCircleOutline, {}),
+            name: SDKUI_Localizator.Other,
+            submenu: [
+                {
+                    id: 'oth-search',
+                    icon: _jsx(IconSearch, {}),
+                    name: showSearchTMDatagrid ? SDKUI_Localizator.HideSearch : SDKUI_Localizator.ShowSearch,
+                    disabled: false,
+                    onClick: () => setShowSearchTMDatagrid(prev => !prev)
+                },
+                {
+                    id: 'oth-exp',
+                    icon: _jsx(IconExportTo, {}),
+                    name: SDKUI_Localizator.ExportTo,
+                    operationType: 'multiRow',
+                    disabled: false,
+                    onClick: () => setShowExportForm(true)
+                },
+                ...(enablePinIcons
+                    ? [{
+                            id: 'oth-float',
+                            icon: showFloatingBar ? _jsx(IconHide, {}) : _jsx(IconShow, {}),
+                            name: showFloatingBar
+                                ? SDKUI_Localizator.HideFloatingBar
+                                : SDKUI_Localizator.ShowFloatingBar,
+                            disabled: false,
+                            onClick: () => setShowFloatingBar(prev => !prev)
+                        }]
+                    : [])
+            ]
+        };
+    };
+    /** MENU SPECIFICO ARCHIVED WORKGROUP */
+    const shareFromWgMenuItem = () => {
+        return {
+            id: 'wg-share',
+            icon: _jsx(IconShare, {}),
+            name: SDKUI_Localizator.Share,
+            visible: workingGroupContext !== undefined && openAddDocumentForm !== undefined,
+            disabled: workingGroupContext === undefined,
+            onClick: () => openAddDocumentForm && openAddDocumentForm(),
+        };
+    };
+    const copyFromWgMenuItem = () => {
+        return {
+            id: 'wg-copy',
+            icon: _jsx(IconCopy, {}),
+            name: SDKUI_Localizator.CopyToDrafts,
+            operationType: 'multiRow',
+            visible: openWGsCopyMoveForm !== undefined,
+            disabled: isDisabledForMultiRow(),
+            onClick: () => { (dtd && openWGsCopyMoveForm) && openWGsCopyMoveForm('copyToWgDraft', dtd, selectedDcmtInfos); },
+        };
+    };
+    const movetofolderFromWgMenuItem = () => {
+        return {
+            id: 'wg-move',
+            icon: _jsx(IconMoveToFolder, {}),
+            name: !isMobile ? SDKUI_Localizator.CopyToArchivedDocuments : SDKUI_Localizator.CopyToArchived,
+            operationType: 'multiRow',
+            visible: openWGsCopyMoveForm !== undefined,
+            disabled: isDisabledForMultiRow(),
+            onClick: () => { (dtd && openWGsCopyMoveForm) && openWGsCopyMoveForm('copyToWgArchivedDoc', dtd, selectedDcmtInfos); },
+        };
+    };
+    const commentFromWgMenuItem = (beginGroup) => {
+        return {
+            id: 'wg-cmt',
+            icon: _jsx("span", { className: "dx-icon-chat" }),
+            name: SDKUI_Localizator.Comment,
+            operationType: 'multiRow',
+            visible: workingGroupContext !== undefined && openCommentFormCallback !== undefined,
+            disabled: workingGroupContext === undefined,
+            onClick: () => openCommentFormCallback && openCommentFormCallback(selectedDcmtInfos),
+            beginGroup: beginGroup,
+        };
+    };
+    const removeFromWgMenuItem = (name) => {
+        return {
+            id: 'wg-rm',
+            icon: _jsx(IconDelete, {}),
+            name: name,
+            operationType: 'multiRow',
+            visible: workingGroupContext !== undefined,
+            disabled: workingGroupContext === undefined || isDisabledForMultiRow(),
+            onClick: async () => {
+                if (workingGroupContext)
+                    selectedDcmtInfos.forEach(dcmt => dcmt.workingGroupId = workingGroupContext.id);
+                await runOperationAsync(selectedDcmtInfos, DcmtOperationTypes.RemoveFromWorkgroup, onRefreshSearchAsyncDatagrid);
+            }
+        };
+    };
+    const handleWFOperationCompleted = async () => {
+        await onWFOperationCompleted?.();
+        if (context !== SearchResultContext.DCMT_FORM && !showMoreInfoPopup) {
+            onCloseDcmtForm?.();
+        }
+    };
+    const customButtonMenuItems = () => {
+        const customButtonsItems = customButtonsLayout?.customButtons?.filter((customButton) => customButton.isForSearchResult && customButton.isForSearchResult > 0)
+            .map((customButton) => ({
+            icon: TMImageLibrary({ imageID: customButton.glyphID }),
+            name: customButton.title || 'Bottone personalizzato',
+            onClick: () => setCurrentCustomButton(customButton)
+        }));
+        return customButtonsItems && customButtonsItems.length > 0 ? {
+            icon: _jsx(IconCustom, {}),
+            name: SDKUI_Localizator.CustomButtons,
+            submenu: customButtonsItems
+        } : {};
+    };
+    // MENU STANDARD
+    const getDefaultMenuItems = () => {
+        return [
+            {
+                id: 'doc',
+                icon: _jsx(IconFileDots, {}),
+                name: !isMobile ? SDKUI_Localizator.DocumentOperations : SDKUI_Localizator.Documents,
+                disabled: isDisabledForSingleRow() && isDisabledForMultiRow(),
+                submenu: [
+                    addToFavoriteOperation(),
+                    addReplaceFileOperation(),
+                    openFormOperation(),
+                    deletetionMenuItem(),
+                    fileCheckMenuItem(),
+                    fileConversionsMenuItem(),
+                    ...(SDK_Globals.tmSession?.SessionDescr?.appModuleID === AppModules.SURFER ? [createContextualTaskMenuItem()] : []),
+                    downloadFileMenuItem(),
+                    downloadXMLAttachmentsMenuItem(),
+                    duplicateDocumentMenuItem(),
+                    batchUpdateMenuItem(),
+                    passToArchive(),
+                    ...(selectedDcmtInfos.length > 0 && isPdfEditorAvailable(dtd, selectedDcmtInfos[0]?.FILEEXT) && onOpenPdfEditorRequest ? [pdfEditorMenuItem(onOpenPdfEditorRequest)] : []),
+                ]
+            },
+            signatureMenuItem(),
+            checkinMenuItem(),
+            allowRelations ? relationsMenuItem() : null,
+            sharedDcmtsMenuItem(),
+            // shareMenuItem(),
+            fullTextSearchMenuItem(),
+            otherOperationsMenuItem(),
+            {
+                id: 'wg',
+                icon: _jsx(IconUserGroupOutline, {}),
+                name: !isMobile ? SDKUI_Localizator.WorkgroupOperations : SDKUI_Localizator.WorkingGroups,
+                operationType: 'multiRow',
+                visible: openWGsCopyMoveForm !== undefined || workingGroupContext !== undefined,
+                disabled: isDisabledForMultiRow(),
+                beginGroup: true,
+                submenu: [
+                    shareFromWgMenuItem(),
+                    copyFromWgMenuItem(),
+                    movetofolderFromWgMenuItem(),
+                    commentFromWgMenuItem(true),
+                    removeFromWgMenuItem(SDKUI_Localizator.Remove)
+                ]
+            },
+        ];
+    };
+    const getArchivedWorkgroupMenuItems = () => {
+        const items = [
+            addReplaceFileOperation(),
+            openFormOperation(),
+            deletetionMenuItem(),
+            fileConversionsMenuItem(),
+            ...(SDK_Globals.tmSession?.SessionDescr?.appModuleID === AppModules.SURFER ? [createContextualTaskMenuItem()] : []),
+            downloadFileMenuItem(),
+            shareFromWgMenuItem(),
+            copyFromWgMenuItem(),
+            movetofolderFromWgMenuItem(),
+            commentFromWgMenuItem(false),
+            removeFromWgMenuItem(SDKUI_Localizator.RemoveFromWorkgroup),
+        ];
+        return items.sort((a, b) => a.name.localeCompare(b.name));
+    };
+    const getDcmtFormMenuItems = () => {
+        return [
+            {
+                id: 'doc',
+                icon: _jsx(IconCheck, {}),
+                name: !isMobile ? SDKUI_Localizator.DocumentOperations : SDKUI_Localizator.Documents,
+                disabled: isDisabledForSingleRow() && isDisabledForMultiRow(),
+                submenu: [
+                    ...(inputDcmtFormLayoutMode === LayoutModes.Update ? [addToFavoriteOperation()] : []),
+                    ...((onTaskCreateRequest && inputDcmtFormLayoutMode === LayoutModes.Update && SDK_Globals.tmSession?.SessionDescr?.appModuleID === AppModules.SURFER) ? [createContextualTaskMenuItem()] : []),
+                    downloadFileMenuItem(),
+                    downloadXMLAttachmentsMenuItem(),
+                    ...(selectedDcmtInfos.length > 0 && isPdfEditorAvailable(dtd, selectedDcmtInfos[0]?.FILEEXT) && onOpenPdfEditorRequest ? [pdfEditorMenuItem(onOpenPdfEditorRequest)] : []),
+                ]
+            },
+            signatureMenuItem(),
+            checkinMenuItem(),
+            ...(allowRelations && inputDcmtFormLayoutMode === LayoutModes.Update ? [relationsMenuItem()] : []),
+            ...((inputDcmtFormLayoutMode === LayoutModes.Update) ? [fullTextSearchMenuItem()] : []),
+        ];
+    };
+    const getOperationMenuItems = () => {
+        const getMenuItemsByContext = () => {
+            switch (context) {
+                case SearchResultContext.DCMT_FORM:
+                    return getDcmtFormMenuItems();
+                case SearchResultContext.ARCHIVED_WORKGROUP:
+                    return getArchivedWorkgroupMenuItems();
+                default:
+                    return getDefaultMenuItems();
+            }
+        };
+        const baseMenuItems = getMenuItemsByContext().filter((item) => item !== null);
+        const customButtons = customButtonMenuItems();
+        return customButtons.name ? baseMenuItems.concat([customButtons]) : baseMenuItems;
+    };
+    const operationItems = () => {
+        return addPinIconToItems(getOperationMenuItems());
+    };
+    const renderFloatingBar = (floatingBarContainerRef && floatingBarContainerRef.current && allowFloatingBar && showFloatingBar && deviceType !== DeviceType.MOBILE) ? (_jsx(TMFloatingMenuBar, { containerRef: floatingBarContainerRef, contextMenuItems: operationItems(), isConstrained: true, defaultPosition: { x: 1, y: 88 }, defaultPinnedItems: ['rel-det', 'rel-mst', 'dl'], defaultOrientation: 'horizontal', hasContextMenu: false, pinnedItemIds: pinnedItemIds, onPinChange: setPinnedItemIds })) : null;
+    const renderDcmtOperations = (_jsxs(_Fragment, { children: [(showExportForm && searchResult && dataColumns && dataSource && selectedRowKeys) && (_jsx(TMDataGridExportForm, { dataColumns: dataColumns, dataSource: dataSource, selectedRowKeys: selectedRowKeys, onCloseExportForm: () => setShowExportForm(false), searchResult: searchResult })), _jsx(StyledMultiViewPanel, { "$isVisible": isOpenDcmtForm, children: ((isOpenDcmtForm && focusedItem?.TID !== undefined && focusedItem?.DID !== undefined) &&
+                    _jsx(TMDcmtForm, { isModal: openDcmtFormAsModal || (dcmtFormLayoutMode === LayoutModes.Ark && focusedItem?.DID !== undefined), titleModal: dtd?.name ?? '', TID: focusedItem.TID, DID: focusedItem.DID, allowButtonsRefs: true, layoutMode: dcmtFormLayoutMode, count: visibleItems?.length, itemIndex: visibleItems ? visibleItems.findIndex(o => o.rowIndex === focusedItem?.rowIndex) + 1 : undefined, canNext: canNavigateHandler ? canNavigateHandler('next') : false, canPrev: canNavigateHandler ? canNavigateHandler('prev') : false, onNext: () => onNavigateHandler && onNavigateHandler('next'), onPrev: () => onNavigateHandler && onNavigateHandler('prev'), onClose: () => { setIsOpenDcmtForm(false); onDcmtFormOpenChange(false, LayoutModes.Update); }, onWFOperationCompleted: onWFOperationCompleted, onTaskCreateRequest: onTaskCreateRequest, onSavedAsyncCallback: onSavedAsyncCallback, openS4TViewer: openS4TViewer, onOpenS4TViewerRequest: onOpenS4TViewerRequest, onOpenPdfEditorRequest: onOpenPdfEditorRequest, onReferenceClick: onReferenceClick, allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers, moreInfoTasks: getMoreInfoTasksForDocument(allTasks, focusedItem?.TID, focusedItem?.DID), showDcmtFormSidebar: showDcmtFormSidebar, datagridUtility: {
+                            onRefreshSearchAsyncDatagrid,
+                            onRefreshDataRowsAsync,
+                            refreshFocusedDataRowAsync,
+                            onRefreshBlogDatagrid,
+                            onRefreshPreviewDatagrid
+                        } })) }), (showHistory && dtd && selectedDcmtInfos.length > 0) && _jsx(TMViewHistoryDcmt, { fromDTD: dtd, deviceType: deviceType, inputDcmt: selectedDcmtInfos[0], onClose: hideHistoryCallback, allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers }), (commentFormState.show && selectedDcmtInfos.length > 0) && _jsx(TMBlogCommentForm, { context: { engine: 'SearchEngine', object: { tid: selectedDcmtInfos[0].TID, did: selectedDcmtInfos[0].DID } }, onClose: hideCommentFormCallback, refreshCallback: onRefreshBlog, participants: [], showAttachmentsSection: true, allArchivedDocumentsFileItems: convertSearchResultDescriptorToFileItems(currentSearchResults ?? []), isCommentRequired: commentFormState.isRequired, removeAndEditAttachment: commentFormState.removeAndEditAttachment, selectedAttachmentDid: [Number(selectedDcmtInfos[0].DID)] }), (showCheckoutInformationForm && dtd && selectedDcmtInfos.length > 0) &&
+                _jsx(TMDcmtCheckoutInfoForm, { dtdName: dtd.name ?? SDKUI_Localizator.SearchResult, selectedDcmtOrFocused: selectedDcmtInfos[0], onClose: hideCheckoutInformationFormCallback }), _jsx(StyledMultiViewPanel, { "$isVisible": isOpenDetails, children: isOpenDetails && _jsx(TMMasterDetailDcmts, { deviceType: deviceType, isForMaster: false, inputDcmts: selectedDcmtInfos, allowNavigation: selectedDcmtInfos.length === 1, canNext: canNavigateHandler ? canNavigateHandler('next') : false, canPrev: canNavigateHandler ? canNavigateHandler('prev') : false, onNext: () => onNavigateHandler && onNavigateHandler('next'), onPrev: () => onNavigateHandler && onNavigateHandler('prev'), onBack: () => setIsOpenDetails(false), allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers }) }), _jsxs(StyledMultiViewPanel, { "$isVisible": isOpenMaster, children: [isOpenMaster && _jsx(TMMasterDetailDcmts, { deviceType: deviceType, inputDcmts: selectedDcmtInfos, isForMaster: true, allowNavigation: selectedDcmtInfos.length === 1, canNext: canNavigateHandler ? canNavigateHandler('next') : false, canPrev: canNavigateHandler ? canNavigateHandler('prev') : false, onNext: () => onNavigateHandler && onNavigateHandler('next'), onPrev: () => onNavigateHandler && onNavigateHandler('prev'), onBack: () => setIsOpenMaster(false), appendMasterDcmts: handleAddItem, allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers }), secondaryMasterDcmts.length > 0 && secondaryMasterDcmts.map((dcmt, index) => {
+                        return (_jsx(StyledModalContainer, { style: { backgroundColor: 'white' }, children: _jsx(TMMasterDetailDcmts, { deviceType: deviceType, inputDcmts: [dcmt], isForMaster: true, allowNavigation: false, onBack: () => handleRemoveItem(dcmt.TID, dcmt.DID), appendMasterDcmts: handleAddItem, allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers }) }, `${index}-${dcmt.DID}`));
+                    })] }), isOpenArchiveRelationForm && _jsx(TMDcmtForm, { isModal: true, titleModal: SDKUI_Localizator.Archive + ' - ' + (archiveType === 'detail' ? SDKUI_Localizator.DcmtsDetail : SDKUI_Localizator.DcmtsMaster), TID: archiveRelatedDcmtFormTID, layoutMode: LayoutModes.Ark, inputMids: archiveRelatedDcmtFormMids, showBackButton: false, allowButtonsRefs: false, onClose: () => {
+                    setIsOpenArchiveRelationForm(false);
+                    setArchiveType(undefined);
+                    setArchiveRelatedDcmtFormTID(undefined);
+                    setArchiveRelatedDcmtFormMids([]);
+                }, onSavedAsyncCallback: async (tid, did, metadataResult) => {
+                    setIsOpenArchiveRelationForm(false);
+                    setArchiveType(undefined);
+                    setArchiveRelatedDcmtFormTID(undefined);
+                    setArchiveRelatedDcmtFormMids([]);
+                    await onRefreshSearchAsyncDatagrid?.();
+                }, allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers, showDcmtFormSidebar: showDcmtFormSidebar }), showRelatedDcmtsChooser &&
+                _jsx(TMChooserForm, { dataSource: relatedDcmtsChooserDataSource, onChoose: async (selectedRelation) => {
+                        try {
+                            setShowRelatedDcmtsChooser(false);
+                            TMSpinner.show({ description: SDKUI_Localizator.Loading });
+                            const relation = relatedDcmts?.find(r => r.id === selectedRelation[0]);
+                            if (!relation || !archiveType)
+                                return;
+                            await archiveRelatedDcmtHandler(relation, archiveType);
+                        }
+                        catch (error) {
+                            TMExceptionBoxManager.show({ exception: error });
+                        }
+                        finally {
+                            TMSpinner.hide();
+                        }
+                    }, onClose: () => setShowRelatedDcmtsChooser(false), manageUseLocalizedName: false }), showManyToManyChooser &&
+                _jsx(TMChooserForm, { dataSource: manyToManyChooserDataSource, onChoose: async (selectedRelation) => {
+                        try {
+                            setShowManyToManyChooser(false);
+                            TMSpinner.show({ description: SDKUI_Localizator.Loading });
+                            const relation = manyToManyRelations?.find(r => r.id === selectedRelation[0]);
+                            if (!relation)
+                                return;
+                            await executeManyToManyPairing(relation, isPairingManyToMany);
+                        }
+                        catch (error) {
+                            TMExceptionBoxManager.show({ exception: error });
+                        }
+                        finally {
+                            TMSpinner.hide();
+                        }
+                    }, onClose: () => setShowManyToManyChooser(false), manageUseLocalizedName: false }), showPairDcmtsModal &&
+                _jsx(TMModal, { title: (isPairingManyToMany ? "Abbina" : "Disabbina") + " documenti", onClose: () => setShowPairDcmtsModal(false), width: isMobile ? '90%' : '50%', height: isMobile ? '90%' : '70%', children: _jsx(TMSearchResult, { searchResults: pairedSearchResults, onRefreshAfterAddDcmtToFavs: onRefreshAfterAddDcmtToFavs, onRefreshSearchAsyncDatagrid: onRefreshSearchAsyncDatagrid, onFileOpened: onFileOpened, onTaskCreateRequest: onTaskCreateRequest, openWGsCopyMoveForm: openWGsCopyMoveForm, editPdfForm: editPdfForm, openS4TViewer: openS4TViewer, onOpenS4TViewerRequest: onOpenS4TViewerRequest, onOpenPdfEditorRequest: onOpenPdfEditorRequest, passToArchiveCallback: passToArchiveCallback, showTodoDcmtForm: showTodoDcmtForm, allowFloatingBar: false, floatingActionConfig: pairFloatingActionConfig, showBackButton: false, allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers, toppyHelpCenterUsePortal: toppyHelpCenterUsePortal, showToppyDraggableHelpCenter: showToppyDraggableHelpCenter }) }), showPairSearchModal &&
+                _jsx(TMModal, { title: "Ricerca documenti", onClose: () => setShowPairSearchModal(false), width: isMobile ? '90%' : '50%', height: isMobile ? '90%' : '70%', children: _jsx(TMSearch, { onlyShowSearchQueryPanel: true, inputTID: pairSearchModalTargetTID, inputMids: pairSearchModalInputMids, floatingActionConfig: pairSearchModalFloatingActionConfig, allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers }) }), isOpenSharedArchive && _jsx(TMModal, { title: "Archiviazione condivisa", onClose: () => {
+                    setIsOpenSharedArchive(false);
+                }, width: isMobile ? '90%' : '60%', height: isMobile ? '90%' : '80%', children: _jsx(TMArchive, { inputDID: selectedDcmtInfos?.[0].DID, inputTID: selectedDcmtInfos?.[0].TID, inputMids: currentMetadataValues.filter(md => md.mid && md.mid > 100).map(md => ({ mid: md.mid, value: md.value ?? '' })), isSharedArchive: true, inputFile: sharedDcmtFile, onSavedAsyncCallback: async (tid, did) => {
+                        setIsOpenSharedArchive(false);
+                        await onRefreshSearchAsyncDatagrid?.();
+                    }, allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers }) }), sharedDcmtSearchResults.length > 0 &&
+                _jsx(TMModal, { title: "Documenti condivisi", onClose: () => {
+                        setSharedDcmtSearchResults([]);
+                    }, width: isMobile ? '90%' : '60%', height: isMobile ? '90%' : '80%', children: _jsx(TMSearchResult, { searchResults: sharedDcmtSearchResults, allowFloatingBar: false, showSelector: true, disableAccordionIfSingleCategory: true, showBackButton: isMobile, allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers }) }), isOpenBatchUpdate && _jsx(TMBatchUpdateForm, { isModal: true, titleModal: `${SDKUI_Localizator.BatchUpdate} (${selectedDcmtInfos.length} documenti selezionati)`, inputDcmts: selectedDcmtInfos, TID: selectedDcmtInfos.length > 0 ? selectedDcmtInfos[0]?.TID : undefined, DID: selectedDcmtInfos.length > 0 ? selectedDcmtInfos[0]?.DID : undefined, onBack: () => updateBatchUpdateForm(false), onSavedCallbackAsync: async () => {
+                    updateBatchUpdateForm(false);
+                    setIsModifiedBatchUpdate(false);
+                    await onRefreshDataRowsAsync?.();
+                }, onStatusChanged: (isModified) => { setIsModifiedBatchUpdate(isModified); } }), showApprovePopup && _jsx(WorkFlowApproveRejectPopUp, { deviceType: deviceType, onCompleted: handleWFOperationCompleted, selectedItems: selectedDcmtInfos, isReject: 0, onClose: () => updateShowApprovePopup(false) }), showRejectPopup && _jsx(WorkFlowApproveRejectPopUp, { deviceType: deviceType, onCompleted: handleWFOperationCompleted, selectedItems: selectedDcmtInfos, isReject: 1, onClose: () => updateShowRejectPopup(false) }), showReAssignPopup && _jsx(WorkFlowReAssignPopUp, { deviceType: deviceType, onCompleted: handleWFOperationCompleted, selectedItems: selectedDcmtInfos, onClose: () => updateShowReAssignPopup(false) }), showMoreInfoPopup && _jsx(WorkFlowMoreInfoPopUp, { fromDTD: dtd, TID: contextConfig.approvalTID, DID: focusedItem?.DID, deviceType: deviceType, onCompleted: handleWFOperationCompleted, onClose: () => updateShowMoreInfoPopup(false), allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers, triggerBlogRefresh: onRefreshBlogDatagrid }), _jsx(ConfirmFormatDialog, {}), _jsx(ConfirmAttachmentsDialog, {}), taskFormDialogComponent, s4TViewerDialogComponent, currentCustomButton && _jsx(TMCustomButton, { button: currentCustomButton, formData: currentMetadataValues, selectedItems: selectedItemsFull, onClose: () => setCurrentCustomButton(undefined) })] }));
+    return {
+        operationItems: operationItems(),
+        renderFloatingBar,
+        renderDcmtOperations,
+        features: {
+            isOpenDcmtForm,
+            openFormHandler,
+            dcmtFormLayoutMode,
+            onDcmtFormOpenChange,
+            showSearchTMDatagrid,
+            showExportForm,
+            isOpenBatchUpdate,
+            isModifiedBatchUpdate,
+            updateBatchUpdateForm,
+            handleSignApprove,
+            checkoutInfo: {
+                showHistory,
+                showHistoryCallback,
+                hideHistoryCallback,
+                showCheckoutInformationForm,
+                showCheckoutInformationFormCallback,
+                hideCheckoutInformationFormCallback,
+                commentFormState,
+                hideCommentFormCallback,
+                copyCheckoutPathToClipboardCallback,
+                handleCheckOutCallback,
+                handleCheckInCallback,
+                showCicoWaitPanel,
+                cicoWaitPanelTitle,
+                showCicoPrimaryProgress,
+                cicoPrimaryProgressText,
+                cicoPrimaryProgressValue,
+                cicoPrimaryProgressMax,
+            },
+            dcmtOperations: {
+                abortController,
+                showWaitPanel,
+                showPrimary,
+                waitPanelTitle,
+                waitPanelTextPrimary,
+                waitPanelValuePrimary,
+                waitPanelMaxValuePrimary,
+                showSecondary,
+                waitPanelTextSecondary,
+                waitPanelValueSecondary,
+                waitPanelMaxValueSecondary,
+                downloadDcmtsAsync,
+                getDcmtFileAsync,
+                clearDcmtsFileCache,
+                removeDcmtsFileCache,
+                isDcmtFileInCache,
+                runOperationAsync,
+            },
+            relatedDocumentsInfo: {
+                // Data
+                relatedDcmts,
+                pairedSearchResults,
+                manyToManyRelations,
+                selectedManyToManyRelation,
+                manyToManyChooserDataSource,
+                relatedDcmtsChooserDataSource,
+                // Flags / State booleans
+                showRelatedDcmtsChooser,
+                isOpenDetails,
+                isOpenMaster,
+                isOpenArchiveRelationForm,
+                isPairingManyToMany,
+                showManyToManyChooser,
+                showPairSearchModal,
+                currentTIDHasDetailRelations,
+                currentTIDHasMasterRelations,
+                canArchiveMasterRelation,
+                canArchiveDetailRelation,
+                hasManyToManyRelation,
+                showPairDcmtsModal,
+                // Pair search modal state
+                pairSearchModalTargetTID,
+                pairSearchModalParentTID,
+                pairSearchModalParentDID,
+                pairSearchModalRelation,
+                pairSearchModalInputMids,
+                // Config
+                pairFloatingActionConfig,
+                pairSearchModalFloatingActionConfig,
+                // Archive state
+                archiveRelatedDcmtFormTID,
+                archiveRelatedDcmtFormMids,
+                archiveType,
+                // Setters
+                setIsOpenDetails,
+                setIsOpenMaster,
+                setShowRelatedDcmtsChooser,
+                setIsOpenArchiveRelationForm,
+                setArchiveType,
+                setArchiveRelatedDcmtFormTID,
+                setArchiveRelatedDcmtFormMids,
+                setShowManyToManyChooser,
+                setShowPairDcmtsModal,
+                setShowPairSearchModal,
+                // Logic / Helpers
+                checkRelatedDcmtsArchiveCapability,
+                checkManyToManyCapability,
+                // Actions
+                pairManyToMany,
+                executeManyToManyPairing,
+                archiveDetailDocuments,
+                archiveMasterDocuments,
+                archiveRelatedDcmtHandler
+            },
+            toppyOperations: {
+                showApprovePopup,
+                showRejectPopup,
+                showReAssignPopup,
+                showMoreInfoPopup,
+                updateShowApprovePopup,
+                updateShowRejectPopup,
+                updateShowReAssignPopup,
+                updateShowMoreInfoPopup
+            }
+        }
+    };
+};