@retailcrm/datalens-ui 0.0.0

package/pages/CollectionsNavigationPage.js

@@ -0,0 +1,2579 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import React__default, { createContext } from "react";
+import { useDispatch, useSelector, batch } from "react-redux";
+import { Link, useHistory, useLocation, useParams, Redirect, Switch, Route } from "react-router-dom";
+import { DropdownMenu, Button, Icon, Dialog, TextInput, Breadcrumbs, Skeleton, Tooltip, Alert, spacing, Flex } from "@gravity-ui/uikit";
+import block from "bem-cn-lite";
+import { S as SmartLoader } from "../components/SmartLoader.js";
+import { V as ViewError } from "../components/ViewError.js";
+import { r as registry, F as Feature, d as EntryScope, cT as CreateEntityButton, V as CollectionItemEntities, l as I18n, cU as WorkbookPageQa, D as DL, z as DEFAULT_DATE_FORMAT, cP as getUserId, I as I18N, cV as WorkbookPageActionsMoreQA } from "../components/AccessRights.js";
+import { g as getSharedEntryMockText, M as MOBILE_SIZE, a as COLLECTIONS_PATH, W as WORKBOOKS_PATH } from "../components/CollectionFilters.js";
+import { ap as selectWorkbookFilters, o as openDialog, i as isEnabledFeature, aq as setCreateWorkbookEntryType, ar as bindSharedEntryToWorkbook, c as closeDialog, as as getWorkbookSharedEntries, d as showToast, U as Utils, _ as S3_BASED_CONNECTORS, at as changeFavoriteEntry, g as getSdk, l as logger, au as selectCreateWorkbookEntryType, N as selectWorkbookId, av as resetCreateWorkbookEntryType, aw as selectDeleteEntryIsLoading, ax as deleteEntry, ay as selectRenameEntryIsLoading, az as renameEntry, ab as getResolveUsersByIdsAction, aA as selectWorkbookSharedEntriesIsLoading, aB as selectWorkbookSharedEntriesError, aC as selectSharedNextPageToken, aD as selectWorkbookItems, aE as selectWorkbookSharedItems, aF as selectWorkbookEntriesIsLoading, aG as resetWorkbookEntries, aH as resetWorkbookSharedEntries, aI as getAllWorkbookEntriesSeparately, aJ as getWorkbookEntries, aK as resetWorkbookEntriesByScope, aL as selectWorkbook, aM as changeFilters, aN as selectWorkbookEntriesError, aO as selectNextPageToken, u as useRouter, aP as selectPageError, aQ as selectCollectionId, aR as getWorkbook, aS as resetWorkbookState } from "../components/ActionPanel.js";
+import { createSelector } from "reselect";
+import { b as EntryDialogues, D as DialogCreateWorkbookEntry, E as EntryDialogName } from "../components/EntryDialogues.js";
+import { D as DebouncedInput } from "../components/DebouncedInput.js";
+import { O as OrderBySelect, S as SORT_TYPE } from "../components/OrderBySelect.js";
+import { D as DIALOG_SHARED_ENTRY_PERMISSIONS } from "../components/DialogSharedEntryPermissions.js";
+import { D as DIALOG_SHARED_RELATED_ENTITIES } from "../components/DialogSharedRelatedEntities.js";
+import { c as copyTextWithToast } from "../components/DialogRelatedEntities.js";
+import { a as DialogConfirm, b as DialogConfirmApplyStatus } from "../components/DialogConfirm.js";
+import { D as DialogManager } from "../components/DialogManager.js";
+import { aO as isEntryAlreadyExists, bp as reducerRegistry } from "../components/ControlComponents.js";
+import { useInView } from "react-intersection-observer";
+import { dateTime } from "@gravity-ui/date-utils";
+import { E as EntryIcon } from "../components/EntryIcon.js";
+import { CodeTrunk, ChevronDown, FontCursor, Copy, CopyArrowRight, Shield, TrashBin, ArrowRight, FileArrowUp, LockOpen, ArrowLeft, PencilToLine } from "@gravity-ui/icons";
+import { u as useCapabilities, a as Capability } from "../components/Breadcrumbs.js";
+import { D as DropdownAction } from "../components/DropdownAction.js";
+import { i as iconId } from "../components/EntryContextMenu.js";
+import { D as DIALOG_COPY_ENTRIES_TO_WORKBOOK } from "../components/CopyEntriesToWorkbookDialog.js";
+import _ from "lodash";
+import { A as AnimateBlock } from "../components/AnimateBlock.js";
+import { Waypoint } from "react-waypoint";
+import { P as PlaceholderIllustration } from "../components/PlaceholderIllustration.js";
+import { Y as YfmWrapper } from "../components/YfmWrapper.js";
+import { D as DIALOG_SELECT_SHARED_ENTRY } from "../components/DialogSelectSharedEntry.js";
+import { N as NavigationTabs } from "../components/NavigationTabs.js";
+import { a as DL_ADAPTIVE_TABS_BREAK_POINT_CONFIG } from "../components/DialogFilter.js";
+import { useHistory as useHistory$1 } from "react-router";
+import { q as DIALOG_MOVE_WORKBOOK, r as DIALOG_COPY_WORKBOOK, t as DIALOG_EXPORT_WORKBOOK, v as DIALOG_DELETE_WORKBOOK, w as DIALOG_EDIT_WORKBOOK } from "../components/CollectionsStructure.js";
+import { I as IamAccessDialog } from "../components/IamAccessDialog.js";
+import { ActionBar } from "@gravity-ui/navigation";
+const b$d = block("dl-shared-entry-actions-notice");
+const SharedEntryNotice = () => {
+  return /* @__PURE__ */ jsx("div", { className: b$d(), children: /* @__PURE__ */ jsx("div", { className: b$d("notice-container"), children: /* @__PURE__ */ jsx("p", { className: b$d("notice-text"), children: getSharedEntryMockText("collection-actions-menu-notice") }) }) });
+};
+const getSharedEntriesMenuItems = ({
+  datasetAction,
+  connectionAction,
+  noticeClassName
+}) => {
+  return [
+    {
+      text: getSharedEntryMockText("collection-actions-menu-item"),
+      iconStart: /* @__PURE__ */ jsx(CodeTrunk, {}),
+      items: [
+        {
+          text: /* @__PURE__ */ jsx(SharedEntryNotice, {}),
+          className: noticeClassName,
+          action: () => {
+          },
+          selected: false
+        },
+        {
+          iconStart: /* @__PURE__ */ jsx(EntryIcon, { entry: { scope: "connection" }, overrideIconType: "connection" }),
+          text: getSharedEntryMockText("label-shared-connection"),
+          action: connectionAction
+        },
+        {
+          iconStart: /* @__PURE__ */ jsx(EntryIcon, { entry: { scope: "dataset" } }),
+          text: getSharedEntryMockText("label-shared-dataset"),
+          action: datasetAction
+        }
+      ]
+    }
+  ];
+};
+const b$c = block("dl-workbook-create-entry");
+const CreateEntry = React__default.memo(
+  ({ className, workbook, scope, size = "m", view = "normal" }) => {
+    const dispatch = useDispatch();
+    const filters = useSelector(selectWorkbookFilters);
+    const handleAction = (type) => {
+      dispatch(setCreateWorkbookEntryType(type));
+    };
+    const handleSharedEntryAction = React__default.useCallback(
+      (scope2, collectionId, workbookId) => () => dispatch(
+        openDialog({
+          id: DIALOG_SELECT_SHARED_ENTRY,
+          props: {
+            open: true,
+            onClose: () => dispatch(closeDialog()),
+            collectionId,
+            dialogTitle: getSharedEntryMockText(
+              `title-select-shared-entry-dialog-${scope2}`
+            ),
+            onSelectEntry: (entry) => {
+              dispatch(
+                openDialog({
+                  id: DIALOG_SHARED_ENTRY_PERMISSIONS,
+                  props: {
+                    open: true,
+                    onClose: () => dispatch(closeDialog()),
+                    entry,
+                    onApply: async (delegation) => {
+                      const success = await dispatch(
+                        bindSharedEntryToWorkbook({
+                          sourceId: entry.entryId,
+                          targetId: workbookId,
+                          delegation
+                        })
+                      );
+                      if (success) {
+                        dispatch(closeDialog());
+                        dispatch(closeDialog());
+                        const entries = await dispatch(
+                          getWorkbookSharedEntries({
+                            scope: scope2,
+                            workbookId,
+                            filters
+                          })
+                        );
+                        const addedEntry = entries?.entries.find(
+                          (item) => item.entryId === entry.entryId
+                        );
+                        dispatch(
+                          showToast({
+                            type: "success",
+                            title: getSharedEntryMockText(
+                              `add-entry-workbook-toast-title-${scope2}`
+                            ),
+                            content: getSharedEntryMockText(
+                              "add-entry-workbook-toast-message",
+                              {
+                                name: Utils.getEntryNameFromKey(
+                                  addedEntry?.key ?? ""
+                                )
+                              }
+                            )
+                          })
+                        );
+                      }
+                    }
+                  }
+                })
+              );
+            },
+            getIsInactiveEntity: (entry) => entry.entity === CollectionItemEntities.ENTRY && entry.scope !== scope2
+          }
+        })
+      ),
+      [dispatch, filters]
+    );
+    const { useCreateEntryOptions } = registry.workbooks.functions.getAll();
+    const { buttonText, handleClick, items, hasMenu } = useCreateEntryOptions({
+      scope,
+      handleAction
+    });
+    if (isEnabledFeature(Feature.EnableSharedEntries) && workbook?.collectionId && workbook?.workbookId) {
+      items.push(
+        getSharedEntriesMenuItems({
+          datasetAction: handleSharedEntryAction(
+            EntryScope.Dataset,
+            workbook.collectionId,
+            workbook.workbookId
+          ),
+          connectionAction: handleSharedEntryAction(
+            EntryScope.Connection,
+            workbook.collectionId,
+            workbook.workbookId
+          ),
+          noticeClassName: b$c("shared-entry-notice")
+        })
+      );
+    }
+    return /* @__PURE__ */ jsx("div", { className, children: hasMenu ? /* @__PURE__ */ jsx(
+      DropdownMenu,
+      {
+        size: "s",
+        items,
+        popupProps: { qa: CreateEntityButton.Popup },
+        renderSwitcher: ({ onClick }) => /* @__PURE__ */ jsxs(
+          Button,
+          {
+            view,
+            size,
+            qa: CreateEntityButton.Button,
+            onClick,
+            children: [
+              buttonText,
+              /* @__PURE__ */ jsx(Icon, { data: ChevronDown, size: "16" })
+            ]
+          }
+        )
+      }
+    ) : /* @__PURE__ */ jsx(Button, { view, onClick: handleClick, size, children: buttonText }) });
+  }
+);
+CreateEntry.displayName = "CreateEntry";
+var CreateEntryActionType = /* @__PURE__ */ ((CreateEntryActionType2) => {
+  CreateEntryActionType2["Dashboard"] = "dashboard";
+  CreateEntryActionType2["Dataset"] = "dataset";
+  CreateEntryActionType2["Connection"] = "connection";
+  CreateEntryActionType2["Report"] = "report";
+  CreateEntryActionType2["Editor"] = "editor";
+  CreateEntryActionType2["QL"] = "ql";
+  CreateEntryActionType2["Wizard"] = "wizard";
+  return CreateEntryActionType2;
+})(CreateEntryActionType || {});
+const CHUNK_SIZE = 100;
+const i18n$b = I18n.keyset("new-workbooks");
+const commonMenuI18n = I18n.keyset("component.entry-context-menu.view");
+const copyEntriesToWorkbookEnabled = isEnabledFeature(Feature.CopyEntriesToWorkbook);
+const EntryActions = ({
+  workbook,
+  entry,
+  onRenameClick,
+  onDeleteClick,
+  onDuplicateEntry,
+  onCopyEntry,
+  onShowRelatedClick,
+  onCopyId,
+  onUpdateSharedEntryBindings
+}) => {
+  const capabilities = useCapabilities();
+  const { useAdditionalWorkbookEntryActions } = registry.workbooks.functions.getAll();
+  const isConnection = entry.scope === EntryScope.Connection;
+  const isS3BasedConnector = S3_BASED_CONNECTORS.includes(entry.type);
+  const isFileConnection = isConnection && isS3BasedConnector;
+  const items = [];
+  if (onRenameClick) {
+    items.push({
+      action: onRenameClick,
+      text: /* @__PURE__ */ jsx(DropdownAction, { icon: FontCursor, text: i18n$b("action_rename") })
+    });
+  }
+  if (!isFileConnection && capabilities[Capability.AccessibleWorkbookDuplication] && onDuplicateEntry) {
+    items.push({
+      action: onDuplicateEntry,
+      text: /* @__PURE__ */ jsx(DropdownAction, { icon: Copy, text: i18n$b("action_duplicate") }),
+      qa: WorkbookPageQa.MenuItemDuplicate
+    });
+  }
+  if (!isFileConnection && copyEntriesToWorkbookEnabled && onCopyEntry) {
+    items.push({
+      action: onCopyEntry,
+      text: /* @__PURE__ */ jsx(DropdownAction, { icon: CopyArrowRight, text: i18n$b("action_copy") })
+    });
+  }
+  const additionalWorkbookEntryActions = useAdditionalWorkbookEntryActions(entry, workbook);
+  if (additionalWorkbookEntryActions.length) {
+    items.push(...additionalWorkbookEntryActions);
+  }
+  const subMenu = [];
+  if (onShowRelatedClick) {
+    subMenu.push({
+      action: onShowRelatedClick,
+      text: /* @__PURE__ */ jsx(
+        DropdownAction,
+        {
+          icon: CodeTrunk,
+          text: commonMenuI18n("value_show-related-entities")
+        }
+      )
+    });
+  }
+  if (onCopyId) {
+    subMenu.push({
+      action: onCopyId,
+      text: /* @__PURE__ */ jsx(DropdownAction, { size: 16, icon: iconId, text: commonMenuI18n("value_copy-id") })
+    });
+  }
+  if (subMenu.length) {
+    items.push(subMenu);
+  }
+  if (onUpdateSharedEntryBindings) {
+    items.push({
+      action: onUpdateSharedEntryBindings,
+      text: /* @__PURE__ */ jsx(
+        DropdownAction,
+        {
+          icon: Shield,
+          text: getSharedEntryMockText("shared-entry-bindings-dropdown-menu-title")
+        }
+      )
+    });
+  }
+  const otherActions = [];
+  if (onDeleteClick) {
+    otherActions.push([
+      {
+        action: onDeleteClick,
+        text: /* @__PURE__ */ jsx(DropdownAction, { icon: TrashBin, text: i18n$b("action_delete") }),
+        theme: "danger"
+      }
+    ]);
+  }
+  if (otherActions.length) {
+    items.push(...otherActions);
+  }
+  if (items.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    DropdownMenu,
+    {
+      size: "m",
+      items,
+      defaultSwitcherProps: { qa: WorkbookPageQa.MenuDropDownBtn }
+    }
+  );
+};
+const ROW_HEIGHT = 48;
+const MOBILE_ROW_HEIGHT = 44;
+const defaultRowStyle = {
+  height: ROW_HEIGHT
+};
+const mobileRowStyle = {
+  height: MOBILE_ROW_HEIGHT
+};
+const options = {
+  rootMargin: "200% 0px"
+};
+const i18n$a = I18n.keyset("new-workbooks");
+const onClickStopPropogation = (e) => {
+  e.stopPropagation();
+  e.preventDefault();
+};
+const b$b = block("dl-content-row");
+const Row = ({
+  item,
+  workbook,
+  onRenameEntry,
+  onDeleteEntry,
+  onDuplicateEntry,
+  onCopyEntry,
+  onShowRelatedClick,
+  onCopyId,
+  onUpdateSharedEntryBindings
+}) => {
+  const { getWorkbookEntryUrl } = registry.workbooks.functions.getAll();
+  const { WorkbookTableRowExtendedContent } = registry.workbooks.components.getAll();
+  const { getLoginById } = registry.common.functions.getAll();
+  const dispatch = useDispatch();
+  const isSharedEntry = Boolean(item.collectionId);
+  const url = getWorkbookEntryUrl(item, workbook, isSharedEntry);
+  const LoginById = getLoginById();
+  const isShowLogin = LoginById && item.createdBy;
+  const onChangeFavorite = () => {
+    const { entryId, isFavorite } = item;
+    dispatch(
+      changeFavoriteEntry({
+        entryId,
+        isFavorite: !isFavorite,
+        updateInline: true
+      })
+    );
+  };
+  const { ButtonFavorite } = registry.common.components.getAll();
+  if (DL.IS_MOBILE) {
+    return /* @__PURE__ */ jsxs(
+      Link,
+      {
+        to: url,
+        className: b$b({ mobile: true }),
+        style: mobileRowStyle,
+        "data-qa": WorkbookPageQa.ListItem,
+        children: [
+          /* @__PURE__ */ jsx("div", { className: b$b("content-cell", { title: true }), "data-qa": item.entryId, children: /* @__PURE__ */ jsxs("div", { className: b$b("title-col"), children: [
+            /* @__PURE__ */ jsx(EntryIcon, { entry: item, entityIconSize: "xl" }),
+            /* @__PURE__ */ jsx(
+              "div",
+              {
+                className: b$b("title-col-text"),
+                "data-qa": WorkbookPageQa.ListItemName,
+                title: item.name,
+                children: item.name
+              }
+            )
+          ] }) }),
+          /* @__PURE__ */ jsx("div", { className: b$b("content-cell", { date: true }), children: dateTime({
+            input: item.updatedAt
+          }).format(DEFAULT_DATE_FORMAT) })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(Link, { to: url, className: b$b(), style: defaultRowStyle, "data-qa": WorkbookPageQa.ListItem, children: [
+    /* @__PURE__ */ jsx("div", { className: b$b("content-cell", { title: true }), "data-qa": item.entryId, children: /* @__PURE__ */ jsxs("div", { className: b$b("title-col", { "is-mobile": DL.IS_MOBILE }), children: [
+      /* @__PURE__ */ jsx(EntryIcon, { entry: item, width: 24, height: 24 }),
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: b$b("title-col-text"),
+          "data-qa": WorkbookPageQa.ListItemName,
+          title: item.name,
+          children: item.name
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        WorkbookTableRowExtendedContent,
+        {
+          item,
+          workbook,
+          onUpdateSharedEntryBindings: onUpdateSharedEntryBindings && (() => onUpdateSharedEntryBindings(item))
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx("div", { className: b$b("content-cell", { author: true }), children: isShowLogin && /* @__PURE__ */ jsx(
+      LoginById,
+      {
+        className: b$b("author-text"),
+        loginOrId: item.createdBy,
+        view: "secondary"
+      }
+    ) }),
+    /* @__PURE__ */ jsx("div", { className: b$b("content-cell", { date: true }), children: dateTime({
+      input: item.updatedAt
+    }).fromNow() }),
+    /* @__PURE__ */ jsx("div", { className: b$b("content-cell", { controls: true }), onClick: onClickStopPropogation, children: /* @__PURE__ */ jsxs("div", { className: b$b("control-col"), children: [
+      /* @__PURE__ */ jsx(
+        ButtonFavorite,
+        {
+          className: b$b("btn-favorite", { "is-favorite": item.isFavorite }),
+          onClick: onChangeFavorite,
+          isFavorite: item.isFavorite
+        }
+      ),
+      workbook.permissions.update && /* @__PURE__ */ jsx("div", { className: b$b("btn-actions"), children: /* @__PURE__ */ jsx(
+        EntryActions,
+        {
+          workbook,
+          entry: item,
+          onRenameClick: onRenameEntry && (() => onRenameEntry(item)),
+          onDeleteClick: onDeleteEntry && (() => onDeleteEntry(item)),
+          onDuplicateEntry: onDuplicateEntry && (() => onDuplicateEntry(item)),
+          onCopyEntry: onCopyEntry && (() => onCopyEntry(item)),
+          onShowRelatedClick: onShowRelatedClick && (() => onShowRelatedClick(item)),
+          onCopyId: onCopyId && (() => onCopyId(item)),
+          onUpdateSharedEntryBindings: onUpdateSharedEntryBindings && (() => onUpdateSharedEntryBindings(item))
+        }
+      ) })
+    ] }) })
+  ] });
+};
+const EmptyRow = ({ label }) => {
+  return /* @__PURE__ */ jsxs("div", { className: b$b("empty-row"), style: defaultRowStyle, children: [
+    /* @__PURE__ */ jsx("div", { className: b$b("empty-cell"), children: label || i18n$a("label_no-data") }),
+    /* @__PURE__ */ jsx("div", { className: b$b("empty-cell") }),
+    /* @__PURE__ */ jsx("div", { className: b$b("empty-cell") }),
+    /* @__PURE__ */ jsx("div", { className: b$b("empty-cell") })
+  ] });
+};
+const b$a = block("dl-workbook-entries-chunk-group");
+function ChunkGroup({
+  chunk,
+  workbook,
+  onRenameEntry,
+  onDeleteEntry,
+  onDuplicateEntry,
+  onCopyEntry,
+  onShowRelatedClick,
+  onCopyId,
+  onUpdateSharedEntryBindings
+}) {
+  const { ref, inView } = useInView(options);
+  const height = chunk.length * ROW_HEIGHT;
+  const chunkScopeQa = chunk[0]?.type === "entry" ? `${WorkbookPageQa.ChunkScope}${chunk[0].item.scope}` : void 0;
+  const renderContent = () => chunk.map((chunkItem) => {
+    switch (chunkItem.type) {
+      case "entry":
+        return /* @__PURE__ */ jsx(
+          Row,
+          {
+            workbook,
+            item: chunkItem.item,
+            onRenameEntry,
+            onDeleteEntry,
+            onDuplicateEntry,
+            onCopyEntry,
+            onShowRelatedClick,
+            onUpdateSharedEntryBindings,
+            onCopyId
+          },
+          chunkItem.key
+        );
+      case "empty":
+        return /* @__PURE__ */ jsx(EmptyRow, {}, chunkItem.key);
+      default:
+        return null;
+    }
+  });
+  return /* @__PURE__ */ jsx("div", { ref, className: b$a(), "data-qa": chunkScopeQa, children: inView ? renderContent() : /* @__PURE__ */ jsx("div", { className: b$a("hidden-row"), style: { height } }) });
+}
+const TAB_ALL = "";
+var ResourceType = /* @__PURE__ */ ((ResourceType2) => {
+  ResourceType2["Collection"] = "collection";
+  ResourceType2["Workbook"] = "workbook";
+  ResourceType2["SharedEntry"] = "sharedEntry";
+  return ResourceType2;
+})(ResourceType || {});
+const RESET_STATE$1 = /* @__PURE__ */ Symbol("collections-navigation/RESET_STATE");
+const GET_COLLECTION_BREADCRUMBS_LOADING = /* @__PURE__ */ Symbol(
+  "collections-navigation/GET_COLLECTION_BREADCRUMBS_LOADING"
+);
+const GET_COLLECTION_BREADCRUMBS_SUCCESS = /* @__PURE__ */ Symbol(
+  "collections-navigation/GET_COLLECTION_BREADCRUMBS_SUCCESS"
+);
+const GET_COLLECTION_BREADCRUMBS_FAILED = /* @__PURE__ */ Symbol(
+  "collections-navigation/GET_COLLECTION_BREADCRUMBS_FAILED"
+);
+const SET_COLLECTION_BREDCRUMBS = /* @__PURE__ */ Symbol("collections-navigation/SET_COLLECTION_BREDCRUMBS");
+const initialState$1 = {
+  getCollectionBreadcrumbs: {
+    isLoading: false,
+    data: null,
+    error: null
+  }
+};
+const collectionsNavigationReducer = (state = initialState$1, action) => {
+  switch (action.type) {
+    case RESET_STATE$1: {
+      return {
+        ...initialState$1
+      };
+    }
+    case GET_COLLECTION_BREADCRUMBS_LOADING: {
+      return {
+        ...state,
+        getCollectionBreadcrumbs: {
+          ...state.getCollectionBreadcrumbs,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_COLLECTION_BREADCRUMBS_SUCCESS: {
+      return {
+        ...state,
+        getCollectionBreadcrumbs: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case GET_COLLECTION_BREADCRUMBS_FAILED: {
+      return {
+        ...state,
+        getCollectionBreadcrumbs: {
+          ...state.getCollectionBreadcrumbs,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case SET_COLLECTION_BREDCRUMBS: {
+      return {
+        ...state,
+        getCollectionBreadcrumbs: {
+          isLoading: false,
+          data: action.data.collectionBreadcrumbs,
+          error: null
+        }
+      };
+    }
+    default: {
+      return state;
+    }
+  }
+};
+const RESET_STATE = /* @__PURE__ */ Symbol("collections/RESET_STATE");
+const GET_COLLECTION_LOADING = /* @__PURE__ */ Symbol("collections/GET_COLLECTION_LOADING");
+const GET_COLLECTION_SUCCESS = /* @__PURE__ */ Symbol("collections/GET_COLLECTION_SUCCESS");
+const GET_COLLECTION_FAILED = /* @__PURE__ */ Symbol("collections/GET_COLLECTION_FAILED");
+const SET_COLLECTION = /* @__PURE__ */ Symbol("collections/SET_COLLECTION");
+const RESET_COLLECTION = /* @__PURE__ */ Symbol("collections/RESET_COLLECTION");
+const GET_STRUCTURE_ITEMS_LOADING = /* @__PURE__ */ Symbol("collections/GET_STRUCTURE_ITEMS_LOADING");
+const GET_STRUCTURE_ITEMS_SUCCESS = /* @__PURE__ */ Symbol("collections/GET_STRUCTURE_ITEMS_SUCCESS");
+const GET_STRUCTURE_ITEMS_FAILED = /* @__PURE__ */ Symbol("collections/GET_STRUCTURE_ITEMS_FAILED");
+const GET_ROOT_COLLECTION_PERMISSIONS_LOADING = /* @__PURE__ */ Symbol(
+  "collections/GET_ROOT_COLLECTION_PERMISSIONS_LOADING"
+);
+const GET_ROOT_COLLECTION_PERMISSIONS_SUCCESS = /* @__PURE__ */ Symbol(
+  "collections/GET_ROOT_COLLECTION_PERMISSIONS_SUCCESS"
+);
+const GET_ROOT_COLLECTION_PERMISSIONS_FAILED = /* @__PURE__ */ Symbol(
+  "collections/GET_ROOT_COLLECTION_PERMISSIONS_FAILED"
+);
+const RESET_STRUCTURE_ITEMS = /* @__PURE__ */ Symbol("collections/RESET_STRUCTURE_ITEMS");
+const DELETE_COLLECTION_IN_ITEMS = /* @__PURE__ */ Symbol("collections/DELETE_COLLECTION_IN_ITEMS");
+const DELETE_WORKBOOK_IN_ITEMS = /* @__PURE__ */ Symbol("collections/DELETE_WORKBOOK_IN_ITEMS");
+const DELETE_SHARED_ENTRY_IN_ITEMS = /* @__PURE__ */ Symbol("collections/DELETE_SHARED_ENTRY_IN_ITEMS");
+const initialState = {
+  getCollection: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  getStructureItems: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  items: [],
+  getRootCollectionPermissions: {
+    isLoading: false,
+    data: null,
+    error: null
+  }
+};
+const collectionsReducer = (state = initialState, action) => {
+  switch (action.type) {
+    case RESET_STATE: {
+      return {
+        ...initialState
+      };
+    }
+    case GET_COLLECTION_LOADING: {
+      return {
+        ...state,
+        getCollection: {
+          ...state.getCollection,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_COLLECTION_SUCCESS: {
+      return {
+        ...state,
+        getCollection: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case GET_COLLECTION_FAILED: {
+      return {
+        ...state,
+        getCollection: {
+          ...state.getCollection,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case SET_COLLECTION: {
+      return {
+        ...state,
+        getCollection: {
+          isLoading: false,
+          data: action.data.collection,
+          error: null
+        }
+      };
+    }
+    case RESET_COLLECTION: {
+      return {
+        ...state,
+        getCollection: initialState.getCollection
+      };
+    }
+    case GET_STRUCTURE_ITEMS_LOADING: {
+      return {
+        ...state,
+        getStructureItems: {
+          ...state.getStructureItems,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_STRUCTURE_ITEMS_SUCCESS: {
+      const loadedIds = state.items.map((item) => {
+        if ("workbookId" in item) {
+          return item.workbookId;
+        }
+        return item.collectionId;
+      });
+      const newItems = action.data.items.filter((item) => {
+        const id = "workbookId" in item ? item.workbookId : item.collectionId;
+        return !loadedIds.includes(id);
+      });
+      return {
+        ...state,
+        getStructureItems: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        },
+        items: [...state.items, ...newItems]
+      };
+    }
+    case GET_STRUCTURE_ITEMS_FAILED: {
+      return {
+        ...state,
+        getStructureItems: {
+          ...state.getStructureItems,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case RESET_STRUCTURE_ITEMS: {
+      return {
+        ...state,
+        getStructureItems: initialState.getStructureItems,
+        items: initialState.items
+      };
+    }
+    case GET_ROOT_COLLECTION_PERMISSIONS_LOADING: {
+      return {
+        ...state,
+        getRootCollectionPermissions: {
+          ...state.getRootCollectionPermissions,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_ROOT_COLLECTION_PERMISSIONS_SUCCESS: {
+      return {
+        ...state,
+        getRootCollectionPermissions: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case GET_ROOT_COLLECTION_PERMISSIONS_FAILED: {
+      return {
+        ...state,
+        getRootCollectionPermissions: {
+          ...state.getRootCollectionPermissions,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case DELETE_COLLECTION_IN_ITEMS: {
+      return {
+        ...state,
+        items: state.items.filter((item) => {
+          if (!("workbookId" in item) && action.data.collectionId === item.collectionId) {
+            return false;
+          }
+          return true;
+        })
+      };
+    }
+    case DELETE_WORKBOOK_IN_ITEMS: {
+      return {
+        ...state,
+        items: state.items.filter((item) => {
+          if ("workbookId" in item && action.data.workbookId === item.workbookId) {
+            return false;
+          }
+          return true;
+        })
+      };
+    }
+    case DELETE_SHARED_ENTRY_IN_ITEMS: {
+      return {
+        ...state,
+        items: state.items.filter((item) => {
+          if ("entryId" in item && action.data.entryId === item.entryId) {
+            return false;
+          }
+          return true;
+        })
+      };
+    }
+    default: {
+      return state;
+    }
+  }
+};
+const resetState$1 = () => {
+  return {
+    type: RESET_STATE
+  };
+};
+const setCollection = (collection) => {
+  return {
+    type: SET_COLLECTION,
+    data: {
+      collection
+    }
+  };
+};
+const WORKBOOK_STATUS = {
+  CREATING: "creating"
+};
+const resetState = () => {
+  return {
+    type: RESET_STATE$1
+  };
+};
+const getCollectionBreadcrumbs = ({ collectionId }) => {
+  return (dispatch) => {
+    dispatch({
+      type: GET_COLLECTION_BREADCRUMBS_LOADING
+    });
+    return getSdk().sdk.us.getCollectionBreadcrumbs({
+      collectionId
+    }).then((data) => {
+      dispatch({
+        type: GET_COLLECTION_BREADCRUMBS_SUCCESS,
+        data
+      });
+      return data;
+    }).catch((error) => {
+      if (!getSdk().sdk.isCancel(error)) {
+        logger.logError(
+          "collections-navigation/getCollectionBreadcrumbs failed",
+          error
+        );
+      }
+      dispatch({
+        type: GET_COLLECTION_BREADCRUMBS_FAILED,
+        error
+      });
+      return null;
+    });
+  };
+};
+const setCollectionBreadcrumbs = (collectionBreadcrumbs) => {
+  return {
+    type: SET_COLLECTION_BREDCRUMBS,
+    data: {
+      collectionBreadcrumbs
+    }
+  };
+};
+const selectGetCollectionBreadcrumbs = (state) => state.collectionsNavigation.getCollectionBreadcrumbs;
+const selectCollectionBreadcrumbs = createSelector(
+  [selectGetCollectionBreadcrumbs],
+  (getCollectionBreadcrumbs2) => getCollectionBreadcrumbs2.data
+);
+createSelector(
+  [selectGetCollectionBreadcrumbs],
+  (getCollectionBreadcrumbs2) => getCollectionBreadcrumbs2.data === null || getCollectionBreadcrumbs2.isLoading
+);
+const selectCollectionBreadcrumbsError = createSelector(
+  [selectGetCollectionBreadcrumbs],
+  (getCollectionBreadcrumbs2) => getCollectionBreadcrumbs2.error
+);
+const CreateEntryDialog = React__default.memo(() => {
+  const entryDialoguesRef = React__default.useRef(null);
+  const history = useHistory();
+  const dispatch = useDispatch();
+  const type = useSelector(selectCreateWorkbookEntryType);
+  const workbookId = useSelector(selectWorkbookId);
+  const { getWorkbookDashboardEntryUrl } = registry.workbooks.functions.getAll();
+  const { getNewDashUrl } = registry.dash.functions.getAll();
+  React__default.useEffect(() => {
+    async function create() {
+      if (type && workbookId) {
+        dispatch(resetCreateWorkbookEntryType());
+        switch (type) {
+          case CreateEntryActionType.Dashboard: {
+            const url = getNewDashUrl(workbookId);
+            history.push(url);
+            break;
+          }
+          case CreateEntryActionType.Dataset: {
+            history.push(`/workbooks/${workbookId}/datasets/new`);
+            break;
+          }
+          case CreateEntryActionType.Connection: {
+            history.push(`/workbooks/${workbookId}/connections/new`);
+            break;
+          }
+          case CreateEntryActionType.QL: {
+            history.push(`/workbooks/${workbookId}/ql`);
+            break;
+          }
+          case CreateEntryActionType.Wizard: {
+            history.push(`/workbooks/${workbookId}/wizard`);
+            break;
+          }
+          case CreateEntryActionType.Editor: {
+            history.push(`/workbooks/${workbookId}/editor`);
+            break;
+          }
+          case CreateEntryActionType.Report: {
+            history.push(`/workbooks/${workbookId}/reports`);
+            break;
+          }
+        }
+      }
+    }
+    create();
+  }, [dispatch, getWorkbookDashboardEntryUrl, history, type, workbookId, getNewDashUrl]);
+  return /* @__PURE__ */ jsx(EntryDialogues, { ref: entryDialoguesRef });
+});
+CreateEntryDialog.displayName = "CreateEntryDialog";
+const b$9 = block("dl-workbook-filters");
+const i18n$9 = I18n.keyset("new-workbooks.table-filters");
+const SORT_TYPE_VALUES = {
+  [SORT_TYPE.FIRST_NEW]: {
+    field: "createdAt",
+    direction: "desc",
+    content: i18n$9("label_sort-first-new")
+  },
+  [SORT_TYPE.FIRST_OLD]: {
+    field: "createdAt",
+    direction: "asc",
+    content: i18n$9("label_sort-first-old")
+  },
+  [SORT_TYPE.ALPHABET_ASC]: {
+    field: "name",
+    direction: "asc",
+    content: i18n$9("label_sort-first-alphabet-asc")
+  },
+  [SORT_TYPE.ALPHABET_DESC]: {
+    field: "name",
+    direction: "desc",
+    content: i18n$9("label_sort-first-alphabet-desc")
+  }
+};
+const WorkbookFilters = ({ className, filters, onChange }) => {
+  const { filterString, orderField, orderDirection } = filters;
+  const handleChangeFilters = React__default.useCallback(
+    (updatedValues) => onChange({ ...filters, ...updatedValues }),
+    [filters, onChange]
+  );
+  const handleChangeFilterString = React__default.useCallback(
+    (value) => handleChangeFilters({
+      filterString: value || void 0
+    }),
+    [handleChangeFilters]
+  );
+  const handleChangeSort = React__default.useCallback(
+    ({ field, direction }) => {
+      handleChangeFilters({
+        orderField: field,
+        orderDirection: direction
+      });
+    },
+    [handleChangeFilters]
+  );
+  const orderBy = React__default.useMemo(() => {
+    return {
+      field: orderField,
+      direction: orderDirection
+    };
+  }, [orderField, orderDirection]);
+  return /* @__PURE__ */ jsx("div", { className: b$9(null, className), children: /* @__PURE__ */ jsxs("div", { className: b$9("controls"), "data-qa": WorkbookPageQa.Filters, children: [
+    /* @__PURE__ */ jsx(
+      DebouncedInput,
+      {
+        className: b$9("filter-string"),
+        value: filterString,
+        size: "l",
+        onUpdate: handleChangeFilterString,
+        placeholder: i18n$9("label_filter-string-placeholder"),
+        hasClear: true
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      OrderBySelect,
+      {
+        className: b$9("sort"),
+        orderBy,
+        orderByOptions: SORT_TYPE_VALUES,
+        size: "l",
+        onChange: handleChangeSort
+      }
+    )
+  ] }) });
+};
+const i18n$8 = I18n.keyset("new-workbooks");
+const DIALOG_DELETE_ENTRY_IN_NEW_WORKBOOK = /* @__PURE__ */ Symbol("DIALOG_DELETE_ENTRY_IN_NEW_WORKBOOK");
+const DeleteEntryDialog = React__default.memo(({ open, data, onClose }) => {
+  const dispatch = useDispatch();
+  const isLoading = useSelector(selectDeleteEntryIsLoading);
+  const handleApply = React__default.useCallback(() => {
+    dispatch(
+      deleteEntry({
+        entry: data,
+        deleteInline: true
+      })
+    ).then(() => {
+      onClose();
+    });
+  }, [data.entryId, data.scope, dispatch, onClose]);
+  return /* @__PURE__ */ jsx(
+    DialogConfirm,
+    {
+      visible: open,
+      widthType: "medium",
+      confirmHeaderText: i18n$8("label_delete-entry"),
+      message: i18n$8("section_delete-entry", { entryName: data.name }),
+      onApply: handleApply,
+      confirmButtonText: i18n$8("action_delete"),
+      cancelButtonText: i18n$8("action_cancel"),
+      applyBtnLoadingStatus: isLoading ? DialogConfirmApplyStatus.Loading : void 0,
+      onCancel: onClose,
+      confirmOnEnterPress: true,
+      confirmButtonView: "outlined-danger",
+      isWarningConfirm: true,
+      cancelButtonView: "flat",
+      showIcon: false
+    }
+  );
+});
+DeleteEntryDialog.displayName = "DeleteEntryDialog";
+DialogManager.registerDialog(DIALOG_DELETE_ENTRY_IN_NEW_WORKBOOK, DeleteEntryDialog);
+const DIALOG_DUPLICATE_ENTRY_IN_WORKBOOK = /* @__PURE__ */ Symbol("DIALOG_DUPLICATE_ENTRY_IN_WORKBOOK");
+const i18n$7 = I18n.keyset("new-workbooks");
+const DuplicateEntryDialog = ({ open, onClose, onApply, initName, entryId }) => {
+  const dispatch = useDispatch();
+  const handleApply = React__default.useCallback(
+    async ({ name: name2 }) => {
+      const duplicatedEntry = await getSdk().sdk.us.copyWorkbookEntry({
+        entryId,
+        name: name2
+      });
+      onApply(duplicatedEntry, entryId);
+    },
+    [entryId, onApply]
+  );
+  const onError = (error) => {
+    if (isEntryAlreadyExists(error)) {
+      return {
+        inputError: i18n$7("label_entry-name-already-exists")
+      };
+    }
+    dispatch(
+      showToast({
+        title: i18n$7("toast_duplicate-failed"),
+        name: "DialogDuplicateEntry",
+        error,
+        withReport: true
+      })
+    );
+    return null;
+  };
+  const name = `${initName} - ${i18n$7("label_copy")}`;
+  return /* @__PURE__ */ jsx(
+    DialogCreateWorkbookEntry,
+    {
+      visible: open,
+      name,
+      defaultName: name,
+      caption: i18n$7("action_duplicate"),
+      textButtonApply: i18n$7("button_apply"),
+      textButtonCancel: i18n$7("button_cancel"),
+      onClose,
+      onApply: handleApply,
+      onSuccess: onClose,
+      onError,
+      placeholder: i18n$7("label_placeholder")
+    }
+  );
+};
+DialogManager.registerDialog(DIALOG_DUPLICATE_ENTRY_IN_WORKBOOK, DuplicateEntryDialog);
+const b$8 = block("dl-workbook-rename-entry-dialog");
+const i18n$6 = I18n.keyset("new-workbooks");
+const DIALOG_RENAME_ENTRY_IN_NEW_WORKBOOK = /* @__PURE__ */ Symbol("DIALOG_RENAME_ENTRY_IN_NEW_WORKBOOK");
+const RenameEntryDialog = React__default.memo(({ open, data, onClose }) => {
+  const dispatch = useDispatch();
+  const isLoading = useSelector(selectRenameEntryIsLoading);
+  const [newNameValue, setNewNameValue] = React__default.useState(data.name);
+  const textInputControlRef = React__default.useRef(null);
+  const handleApply = React__default.useCallback(() => {
+    dispatch(
+      renameEntry({
+        entryId: data.entryId,
+        name: newNameValue,
+        updateInline: true
+      })
+    ).then(() => {
+      onClose();
+    });
+  }, [data.entryId, dispatch, newNameValue, onClose]);
+  const propsButtonApply = React__default.useMemo(() => {
+    return {
+      disabled: !newNameValue || newNameValue === data.name
+    };
+  }, [data.name, newNameValue]);
+  return /* @__PURE__ */ jsxs(
+    Dialog,
+    {
+      size: "s",
+      open,
+      onClose,
+      onEnterKeyDown: handleApply,
+      initialFocus: textInputControlRef,
+      children: [
+        /* @__PURE__ */ jsx(Dialog.Header, { caption: i18n$6("label_rename-entry") }),
+        /* @__PURE__ */ jsxs(Dialog.Body, { children: [
+          /* @__PURE__ */ jsx("div", { className: b$8("label"), children: i18n$6("label_title") }),
+          /* @__PURE__ */ jsx(
+            TextInput,
+            {
+              value: newNameValue,
+              controlRef: textInputControlRef,
+              onUpdate: setNewNameValue
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(
+          Dialog.Footer,
+          {
+            onClickButtonCancel: onClose,
+            onClickButtonApply: handleApply,
+            textButtonApply: i18n$6("action_rename"),
+            textButtonCancel: i18n$6("action_cancel"),
+            loading: isLoading,
+            propsButtonApply
+          }
+        )
+      ]
+    }
+  );
+});
+RenameEntryDialog.displayName = "RenameEntryDialog";
+DialogManager.registerDialog(DIALOG_RENAME_ENTRY_IN_NEW_WORKBOOK, RenameEntryDialog);
+const i18n$5 = I18n.keyset("new-workbooks");
+const contextMenuI18n = I18n.keyset("component.entry-context-menu.view");
+const b$7 = block("dl-workbook-entries-table");
+const WorkbookEntriesTable = React__default.memo(
+  ({
+    workbook,
+    entries,
+    refreshEntries,
+    retryLoadEntries,
+    loadMoreEntries,
+    scope,
+    mapTokens,
+    mapErrors,
+    mapLoaders,
+    chunks,
+    availableScopes,
+    sharedChunks,
+    loadMoreSharedEntries,
+    retryLoadSharedEntries,
+    sharedError,
+    sharedLoader,
+    sharedToken,
+    refreshSharedEntries
+  }) => {
+    const dispatch = useDispatch();
+    const entryDialoguesRef = React__default.useRef(null);
+    React__default.useEffect(() => {
+      const resolveUsersByIds = getResolveUsersByIdsAction();
+      const userIds = /* @__PURE__ */ new Set();
+      entries.forEach((entry) => {
+        userIds.add(getUserId(entry.createdBy));
+      });
+      dispatch(resolveUsersByIds(Array.from(userIds)));
+    }, [dispatch, entries]);
+    const onRenameEntry = React__default.useCallback(
+      (entity) => {
+        dispatch(
+          openDialog({
+            id: DIALOG_RENAME_ENTRY_IN_NEW_WORKBOOK,
+            props: {
+              open: true,
+              data: entity,
+              onClose: () => dispatch(closeDialog())
+            }
+          })
+        );
+      },
+      [dispatch]
+    );
+    const onDeleteEntry = React__default.useCallback(
+      (entity) => {
+        dispatch(
+          openDialog({
+            id: DIALOG_DELETE_ENTRY_IN_NEW_WORKBOOK,
+            props: {
+              open: true,
+              data: entity,
+              onClose: () => dispatch(closeDialog())
+            }
+          })
+        );
+      },
+      [dispatch]
+    );
+    const onApplyDuplicate = React__default.useCallback(
+      (entryScope) => {
+        refreshEntries(entryScope);
+      },
+      [refreshEntries]
+    );
+    const onDuplicateEntry = React__default.useCallback(
+      (entity) => {
+        dispatch(
+          openDialog({
+            id: DIALOG_DUPLICATE_ENTRY_IN_WORKBOOK,
+            props: {
+              open: true,
+              onClose: () => dispatch(closeDialog()),
+              onApply: () => onApplyDuplicate(entity.scope),
+              initName: entity.name,
+              entryId: entity.entryId
+            }
+          })
+        );
+      },
+      [dispatch, onApplyDuplicate]
+    );
+    const onDeleteSharedEntry = React__default.useCallback(
+      (entity) => {
+        dispatch(
+          openDialog({
+            id: DIALOG_SHARED_RELATED_ENTITIES,
+            props: {
+              open: true,
+              onClose: () => dispatch(closeDialog()),
+              entry: entity,
+              workbookId: workbook.workbookId,
+              isDeleteDialog: true,
+              onDeleteSuccess: () => {
+                dispatch(closeDialog());
+                refreshSharedEntries(scope);
+              }
+            }
+          })
+        );
+      },
+      [dispatch, workbook, refreshSharedEntries, scope]
+    );
+    const onUpdateSharedEntryBindings = React__default.useCallback(
+      (entity) => {
+        dispatch(
+          openDialog({
+            id: DIALOG_SHARED_ENTRY_PERMISSIONS,
+            props: {
+              open: true,
+              onClose: () => dispatch(closeDialog()),
+              entry: entity,
+              delegation: entity.isDelegated,
+              onApply: async (delegation) => {
+                try {
+                  await getSdk().sdk.us.updateSharedEntryBinding({
+                    sourceId: entity.entryId,
+                    targetId: workbook.workbookId,
+                    delegation
+                  });
+                  dispatch(closeDialog());
+                  refreshSharedEntries(scope);
+                } catch (error) {
+                  dispatch(
+                    showToast({
+                      title: error.message,
+                      error
+                    })
+                  );
+                }
+              }
+            }
+          })
+        );
+      },
+      [dispatch, workbook, refreshSharedEntries, scope]
+    );
+    const onCopyEntry = React__default.useCallback(
+      (entity) => {
+        dispatch(
+          openDialog({
+            id: DIALOG_COPY_ENTRIES_TO_WORKBOOK,
+            props: {
+              open: true,
+              initialCollectionId: workbook.collectionId,
+              onClose: () => dispatch(closeDialog()),
+              entryId: entity.entryId
+            }
+          })
+        );
+      },
+      [dispatch, workbook.collectionId]
+    );
+    const onShowRelated = async (entity) => {
+      await entryDialoguesRef.current?.open({
+        dialog: EntryDialogName.ShowRelatedEntities,
+        dialogProps: {
+          entry: entity
+        }
+      });
+    };
+    const onCopyId = (entity) => {
+      copyTextWithToast({
+        successText: contextMenuI18n("toast_copy-id-success"),
+        errorText: contextMenuI18n("toast_copy-error"),
+        toastName: "toast-menu-copy-id",
+        copyText: entity.entryId
+      });
+    };
+    const { WorkbookEntriesTableTabs, WorkbookEntryExtended } = registry.common.components.getAll();
+    return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+      /* @__PURE__ */ jsx("div", { className: b$7(), children: /* @__PURE__ */ jsxs("div", { className: b$7("table"), children: [
+        !DL.IS_MOBILE && /* @__PURE__ */ jsxs("div", { className: b$7("header"), style: defaultRowStyle, children: [
+          /* @__PURE__ */ jsx("div", { className: b$7("header-cell"), children: i18n$5("label_title") }),
+          /* @__PURE__ */ jsx("div", { className: b$7("header-cell", { author: true }), children: i18n$5("label_author") }),
+          /* @__PURE__ */ jsx("div", { className: b$7("header-cell", { date: true }), children: i18n$5("label_last-modified") }),
+          /* @__PURE__ */ jsx("div", { className: b$7("header-cell", { controls: true }) })
+        ] }),
+        scope && chunks.map((chunk) => /* @__PURE__ */ jsx(
+          ChunkGroup,
+          {
+            workbook,
+            chunk,
+            onRenameEntry,
+            onDeleteEntry,
+            onDuplicateEntry,
+            onCopyEntry,
+            onShowRelatedClick: onShowRelated,
+            onCopyId
+          },
+          chunk[0].key
+        ))
+      ] }) }),
+      scope && /* @__PURE__ */ jsx(
+        WorkbookEntryExtended,
+        {
+          sharedChunks,
+          loadMoreSharedEntries: () => loadMoreSharedEntries?.(scope),
+          retryLoadSharedEntries: () => retryLoadSharedEntries?.(scope),
+          onDeleteSharedEntry,
+          onUpdateSharedEntryBindings,
+          sharedError,
+          sharedLoader,
+          sharedToken,
+          workbook
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        WorkbookEntriesTableTabs,
+        {
+          workbook,
+          retryLoadEntries,
+          loadMoreEntries,
+          scope,
+          mapTokens,
+          mapErrors,
+          mapLoaders,
+          chunks,
+          sharedChunks,
+          sharedToken,
+          sharedError,
+          sharedLoader,
+          retryLoadSharedEntries,
+          loadMoreSharedEntries,
+          availableScopes,
+          onRenameEntry,
+          onDeleteEntry,
+          onDeleteSharedEntry,
+          onUpdateSharedEntryBindings,
+          onDuplicateEntry,
+          onCopyEntry,
+          onShowRelated,
+          onCopyId
+        }
+      ),
+      /* @__PURE__ */ jsx(EntryDialogues, { ref: entryDialoguesRef })
+    ] });
+  }
+);
+WorkbookEntriesTable.displayName = "WorkbookEntriesTable";
+const useChunkedEntries$1 = ({
+  entries,
+  availableScopes
+}) => {
+  const chunks = React__default.useMemo(() => {
+    const allowedScopes = new Set(availableScopes);
+    const workbookEntries = entries.filter((item) => allowedScopes.has(item.scope)).map((item) => {
+      const workbookEntry = {
+        name: Utils.getEntryNameFromKey(item.key),
+        ...item
+      };
+      return workbookEntry;
+    });
+    const items = [];
+    if (workbookEntries.length === 0) {
+      items.push({
+        type: "empty",
+        key: "empty"
+      });
+    } else {
+      items.push(
+        ...workbookEntries.map((item) => ({
+          type: "entry",
+          item,
+          key: item.entryId
+        }))
+      );
+    }
+    return _.chunk(items, CHUNK_SIZE);
+  }, [availableScopes, entries]);
+  return chunks;
+};
+const useChunkedEntries = ({
+  entries,
+  availableScopes
+}) => {
+  const chunks = React__default.useMemo(() => {
+    const allowedScopes = new Set(availableScopes);
+    const workbookEntries = entries.filter((item) => allowedScopes.has(item.scope)).map((item) => {
+      const workbookEntry = {
+        name: Utils.getEntryNameFromKey(item.key),
+        ...item
+      };
+      return workbookEntry;
+    });
+    if (workbookEntries.length === 0) {
+      return [];
+    } else {
+      const chunkArrays = availableScopes.map(
+        () => []
+      );
+      workbookEntries.forEach((chunkItem) => {
+        const item = {
+          type: "entry",
+          item: chunkItem,
+          key: chunkItem.entryId
+        };
+        const chunkIndex = availableScopes.findIndex((scope) => scope === chunkItem.scope);
+        if (chunkIndex > -1) {
+          chunkArrays[chunkIndex].push(item);
+        }
+      });
+      return chunkArrays;
+    }
+  }, [availableScopes, entries]);
+  return chunks;
+};
+const PAGE_SIZE_MAIN_TAB = 10;
+const WorkbookMainTabContent = React__default.memo(({ filters, workbookId, workbook }) => {
+  const [mapTokens, setMapTokens] = React__default.useState({});
+  const [mapErrors, setMapErrors] = React__default.useState({});
+  const [mapLoaders, setMapLoaders] = React__default.useState({});
+  const [isLoading, setIsLoading] = React__default.useState(false);
+  const isSharedEntriesLoading = useSelector(selectWorkbookSharedEntriesIsLoading);
+  const workbookSharedEntriesError = useSelector(selectWorkbookSharedEntriesError);
+  const sharedNextPageToken = useSelector(selectSharedNextPageToken);
+  const isSharedEntriesEnabled = isEnabledFeature(Feature.EnableSharedEntries);
+  const dispatch = useDispatch();
+  const entries = useSelector(selectWorkbookItems);
+  const sharedEntries = useSelector(selectWorkbookSharedItems);
+  const isEntriesLoading = useSelector(selectWorkbookEntriesIsLoading);
+  const { getWorkbookTabs } = registry.workbooks.functions.getAll();
+  const availableScopes = React__default.useMemo(() => {
+    return workbook ? getWorkbookTabs(workbook).map(({ id }) => id).filter((item) => item !== TAB_ALL) : [];
+  }, [getWorkbookTabs, workbook]);
+  const chunks = useChunkedEntries({
+    entries,
+    availableScopes
+  });
+  const sharedChunks = useChunkedEntries$1({
+    entries: sharedEntries,
+    availableScopes: [EntryScope.Connection, EntryScope.Dataset]
+  });
+  React__default.useEffect(() => {
+    if (workbook?.workbookId === workbookId) {
+      (async () => {
+        batch(() => {
+          dispatch(resetWorkbookEntries());
+          dispatch(resetWorkbookSharedEntries());
+        });
+        setIsLoading(true);
+        const data = await dispatch(
+          getAllWorkbookEntriesSeparately({
+            workbookId,
+            filters,
+            scopes: availableScopes,
+            pageSize: PAGE_SIZE_MAIN_TAB
+          })
+        );
+        if (isSharedEntriesEnabled) {
+          dispatch(
+            getWorkbookSharedEntries({
+              workbookId,
+              filters,
+              pageSize: PAGE_SIZE_MAIN_TAB
+            })
+          );
+        }
+        const errors = {};
+        const tokensMap = {};
+        availableScopes.forEach((scope, i) => {
+          if (data[i] === null) {
+            errors[scope] = true;
+          }
+          tokensMap[scope] = data[i]?.nextPageToken || "";
+        });
+        setMapTokens(tokensMap);
+        setMapErrors(errors);
+        setIsLoading(false);
+      })();
+    }
+  }, [
+    dispatch,
+    filters,
+    workbook?.workbookId,
+    workbook.permissions.view,
+    workbookId,
+    availableScopes,
+    isSharedEntriesEnabled
+  ]);
+  const loadMoreEntries = React__default.useCallback(
+    (entryScope) => {
+      if (mapTokens[entryScope]) {
+        dispatch(
+          getWorkbookEntries({
+            workbookId,
+            filters,
+            scope: entryScope,
+            nextPageToken: mapTokens[entryScope],
+            pageSize: PAGE_SIZE_MAIN_TAB
+          })
+        ).then((data) => {
+          if (data) {
+            setMapTokens({
+              ...mapTokens,
+              [entryScope]: data?.nextPageToken || ""
+            });
+          }
+        });
+      }
+    },
+    [dispatch, filters, mapTokens, workbookId]
+  );
+  const loadMoreSharedEntries = React__default.useCallback(
+    (entryScope) => {
+      if (sharedNextPageToken) {
+        dispatch(
+          getWorkbookSharedEntries({
+            workbookId,
+            filters,
+            scope: entryScope,
+            nextPageToken: sharedNextPageToken,
+            pageSize: PAGE_SIZE_MAIN_TAB
+          })
+        );
+      }
+    },
+    [dispatch, filters, sharedNextPageToken, workbookId]
+  );
+  const retryLoadEntries = React__default.useCallback(
+    (entryScope) => {
+      setMapLoaders({
+        [entryScope]: true
+      });
+      dispatch(
+        getWorkbookEntries({
+          workbookId,
+          filters,
+          scope: entryScope,
+          nextPageToken: mapTokens[entryScope],
+          pageSize: PAGE_SIZE_MAIN_TAB
+        })
+      ).then((data) => {
+        if (data) {
+          setMapErrors({
+            ...mapErrors,
+            [entryScope]: false
+          });
+          setMapTokens({
+            ...mapTokens,
+            [entryScope]: data?.nextPageToken || ""
+          });
+        }
+      }).finally(() => {
+        setMapLoaders({
+          [entryScope]: false
+        });
+      });
+    },
+    [dispatch, workbookId, filters, mapErrors, mapTokens]
+  );
+  const retryLoadSharedEntries = React__default.useCallback(
+    (entryScope) => {
+      dispatch(
+        getWorkbookSharedEntries({
+          workbookId,
+          filters,
+          scope: entryScope,
+          nextPageToken: sharedNextPageToken,
+          pageSize: PAGE_SIZE_MAIN_TAB
+        })
+      );
+    },
+    [dispatch, workbookId, filters, sharedNextPageToken]
+  );
+  const refreshEntries = React__default.useCallback(
+    (entryScope) => {
+      setMapLoaders({
+        [entryScope]: true
+      });
+      batch(() => {
+        dispatch(resetWorkbookEntriesByScope(entryScope));
+        dispatch(
+          getWorkbookEntries({
+            workbookId,
+            filters,
+            scope: entryScope,
+            pageSize: PAGE_SIZE_MAIN_TAB
+          })
+        ).then((data) => {
+          if (data) {
+            setMapTokens({
+              ...mapTokens,
+              [entryScope]: data?.nextPageToken || ""
+            });
+          }
+        }).finally(() => {
+          setMapLoaders({
+            [entryScope]: false
+          });
+        });
+      });
+    },
+    [dispatch, workbookId, filters, mapTokens]
+  );
+  const refreshSharedEntries = React__default.useCallback(() => {
+    batch(() => {
+      dispatch(resetWorkbookSharedEntries());
+      dispatch(
+        getWorkbookSharedEntries({
+          workbookId,
+          filters,
+          pageSize: PAGE_SIZE_MAIN_TAB
+        })
+      );
+    });
+  }, [dispatch, workbookId, filters]);
+  if ((isEntriesLoading || isLoading) && entries.length === 0 && Object.keys(mapErrors).length === 0) {
+    return /* @__PURE__ */ jsx(SmartLoader, { size: "l" });
+  }
+  return /* @__PURE__ */ jsx(AnimateBlock, { children: /* @__PURE__ */ jsx(
+    WorkbookEntriesTable,
+    {
+      refreshEntries,
+      refreshSharedEntries,
+      workbook,
+      entries,
+      loadMoreEntries,
+      retryLoadEntries,
+      mapTokens,
+      mapErrors,
+      mapLoaders,
+      chunks,
+      sharedChunks,
+      loadMoreSharedEntries,
+      retryLoadSharedEntries,
+      availableScopes,
+      sharedError: Boolean(workbookSharedEntriesError),
+      sharedLoader: isSharedEntriesLoading,
+      sharedToken: sharedNextPageToken
+    }
+  ) });
+});
+WorkbookMainTabContent.displayName = "WorkbookMainTabContent";
+const b$6 = block("dl-workbook-empty");
+const i18n$4 = I18n.keyset("new-workbooks.empty-table");
+const EmptyWorkbook = ({ workbook, filters, onChangeFilters, scope }) => {
+  const { checkWbCreateEntryButtonVisibility, getWorkbookEmptyStateTexts } = registry.workbooks.functions.getAll();
+  const isFiltersChanged = Boolean(filters.filterString);
+  const handleClearFilters = () => onChangeFilters({ filterString: void 0 });
+  const { title, description } = getWorkbookEmptyStateTexts(scope);
+  const renderClearFiltersAction = () => {
+    return /* @__PURE__ */ jsx(Button, { className: b$6("controls"), view: "normal", onClick: handleClearFilters, children: i18n$4("button_clear-filters") });
+  };
+  const renderCreateEntryAction = () => {
+    if (checkWbCreateEntryButtonVisibility(workbook, scope)) {
+      return /* @__PURE__ */ jsx(
+        CreateEntry,
+        {
+          workbook,
+          className: b$6("controls"),
+          scope: scope || EntryScope.Connection
+        }
+      );
+    }
+    return null;
+  };
+  if (isFiltersChanged && !DL.IS_MOBILE) {
+    return /* @__PURE__ */ jsx("div", { className: b$6(), children: /* @__PURE__ */ jsx(
+      PlaceholderIllustration,
+      {
+        name: "notFound",
+        title: i18n$4("section_not-found"),
+        description: /* @__PURE__ */ jsx(
+          YfmWrapper,
+          {
+            content: i18n$4("label_not-found-description"),
+            setByInnerHtml: true
+          }
+        ),
+        renderAction: renderClearFiltersAction
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsx("div", { className: b$6(), children: /* @__PURE__ */ jsx(
+    PlaceholderIllustration,
+    {
+      name: "template",
+      title,
+      description: workbook.permissions.update ? /* @__PURE__ */ jsx(YfmWrapper, { content: description, setByInnerHtml: true }) : void 0,
+      renderAction: renderCreateEntryAction
+    }
+  ) });
+};
+const EmptyWorkbookContainer = React__default.memo(({ scope }) => {
+  const dispatch = useDispatch();
+  const workbook = useSelector(selectWorkbook);
+  const filters = useSelector(selectWorkbookFilters);
+  if (!workbook) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    EmptyWorkbook,
+    {
+      workbook,
+      filters,
+      scope,
+      onChangeFilters: (data) => dispatch(changeFilters(data))
+    }
+  );
+});
+EmptyWorkbookContainer.displayName = "EmptyWorkbookContainer";
+const b$5 = block("dl-workbook-tab-content");
+const i18n$3 = I18n.keyset("new-workbooks");
+const WorkbookTabContent = React__default.memo(({ workbookId, workbook, filters, scope }) => {
+  const entries = useSelector(selectWorkbookItems);
+  const sharedEntries = useSelector(selectWorkbookSharedItems).filter(
+    (item) => item.scope === scope
+  );
+  const isEntriesLoading = useSelector(selectWorkbookEntriesIsLoading);
+  const isSharedEntriesLoading = useSelector(selectWorkbookSharedEntriesIsLoading);
+  const workbookEntriesError = useSelector(selectWorkbookEntriesError);
+  const workbookSharedEntriesError = useSelector(selectWorkbookSharedEntriesError);
+  const nextPageToken = useSelector(selectNextPageToken);
+  const sharedNextPageToken = useSelector(selectSharedNextPageToken);
+  const isSharedEntriesEnabled = isEnabledFeature(Feature.EnableSharedEntries) && (scope === EntryScope.Connection || scope === EntryScope.Dataset);
+  const { getWorkbookTabs } = registry.workbooks.functions.getAll();
+  const availableScopes = React__default.useMemo(() => {
+    return workbook ? getWorkbookTabs(workbook).map(({ id }) => id).filter((item) => item !== TAB_ALL) : [];
+  }, [getWorkbookTabs, workbook]);
+  const chunks = useChunkedEntries$1({ entries, availableScopes });
+  const sharedChunks = useChunkedEntries$1({
+    entries: sharedEntries,
+    availableScopes: [EntryScope.Connection, EntryScope.Dataset]
+  });
+  const dispatch = useDispatch();
+  React__default.useEffect(() => {
+    batch(() => {
+      dispatch(resetWorkbookEntries());
+      dispatch(resetWorkbookSharedEntries());
+      dispatch(getWorkbookEntries({ workbookId, filters, scope }));
+      if (isSharedEntriesEnabled) {
+        dispatch(getWorkbookSharedEntries({ workbookId, filters, scope }));
+      }
+    });
+  }, [dispatch, filters, scope, workbook, workbookId, isSharedEntriesEnabled]);
+  const refreshEntries = React__default.useCallback(
+    (entryScope) => {
+      batch(() => {
+        dispatch(resetWorkbookEntries());
+        dispatch(getWorkbookEntries({ workbookId, filters, scope: entryScope }));
+      });
+    },
+    [dispatch, workbookId, filters]
+  );
+  const refreshSharedEntries = React__default.useCallback(
+    (entryScope) => {
+      batch(() => {
+        dispatch(resetWorkbookSharedEntries());
+        dispatch(getWorkbookSharedEntries({ workbookId, filters, scope: entryScope }));
+      });
+    },
+    [dispatch, workbookId, filters]
+  );
+  const retryLoadEntries = React__default.useCallback(() => {
+    dispatch(
+      getWorkbookEntries({
+        workbookId,
+        filters,
+        scope,
+        nextPageToken
+      })
+    );
+  }, [dispatch, workbookId, filters, scope, nextPageToken]);
+  const retryLoadSharedEntries = React__default.useCallback(() => {
+    dispatch(
+      getWorkbookSharedEntries({
+        workbookId,
+        filters,
+        scope,
+        nextPageToken
+      })
+    );
+  }, [dispatch, workbookId, filters, scope, nextPageToken]);
+  const loadMoreEntries = React__default.useCallback(() => {
+    if (nextPageToken) {
+      dispatch(
+        getWorkbookEntries({
+          workbookId,
+          filters,
+          scope,
+          nextPageToken
+        })
+      );
+    }
+  }, [nextPageToken, dispatch, workbookId, filters, scope]);
+  const loadMoreSharedEntries = React__default.useCallback(() => {
+    if (nextPageToken) {
+      dispatch(
+        getWorkbookSharedEntries({
+          workbookId,
+          filters,
+          scope,
+          nextPageToken
+        })
+      );
+    }
+  }, [nextPageToken, dispatch, workbookId, filters, scope]);
+  if (isEntriesLoading && entries.length === 0) {
+    return /* @__PURE__ */ jsx(SmartLoader, { size: "l" });
+  }
+  const firstPageError = workbookEntriesError && entries.length === 0;
+  const buttonRetry = /* @__PURE__ */ jsx("div", { className: b$5("btn-retry"), children: /* @__PURE__ */ jsx(Button, { view: "action", size: "m", onClick: retryLoadEntries, children: i18n$3(
+    firstPageError ? "button_workbook-table-retry" : "button_workbook-table-load-more"
+  ) }) });
+  if (firstPageError) {
+    return buttonRetry;
+  }
+  if (!workbook || entries.length === 0 && sharedEntries.length === 0) {
+    return /* @__PURE__ */ jsx(AnimateBlock, { children: /* @__PURE__ */ jsx(EmptyWorkbookContainer, { scope }) });
+  }
+  let footer = null;
+  if (scope) {
+    if (isEntriesLoading) {
+      footer = /* @__PURE__ */ jsx(SmartLoader, { size: "m", showAfter: 0 });
+    } else if (workbookEntriesError) {
+      footer = buttonRetry;
+    } else {
+      footer = /* @__PURE__ */ jsx(Waypoint, { onEnter: loadMoreEntries });
+    }
+  }
+  return /* @__PURE__ */ jsxs(AnimateBlock, { children: [
+    /* @__PURE__ */ jsx(
+      WorkbookEntriesTable,
+      {
+        refreshSharedEntries,
+        refreshEntries,
+        workbook,
+        entries,
+        scope,
+        sharedChunks,
+        chunks,
+        sharedLoader: isSharedEntriesLoading,
+        sharedError: Boolean(workbookSharedEntriesError),
+        sharedToken: sharedNextPageToken,
+        loadMoreSharedEntries,
+        retryLoadSharedEntries
+      }
+    ),
+    footer
+  ] });
+});
+WorkbookTabContent.displayName = "WorkbookTabContent";
+const WorkbookTabs = ({ workbook }) => {
+  const { getWorkbookTabs } = registry.workbooks.functions.getAll();
+  const items = React__default.useMemo(() => {
+    return getWorkbookTabs(workbook);
+  }, [getWorkbookTabs, workbook]);
+  const size = DL.IS_MOBILE ? MOBILE_SIZE.TABS : void 0;
+  return /* @__PURE__ */ jsx(
+    NavigationTabs,
+    {
+      items,
+      defaultTab: TAB_ALL,
+      breakpointsConfig: DL_ADAPTIVE_TABS_BREAK_POINT_CONFIG,
+      size
+    }
+  );
+};
+const getParentCollectionPath = (entity) => {
+  const parentId = "parentId" in entity ? entity.parentId : entity.collectionId;
+  return parentId ? `${COLLECTIONS_PATH}/${parentId}` : COLLECTIONS_PATH;
+};
+const b$4 = block("dl-collection-breadcrumbs");
+const LOADING_ITEM_ID = "__loading";
+const getFallbackItem = () => ({
+  id: LOADING_ITEM_ID,
+  text: "",
+  action: () => {
+  },
+  path: ""
+});
+const getWorkbookItem = (workbook, router) => ({
+  id: workbook.workbookId,
+  text: workbook.title,
+  action: () => {
+    router.push(`${WORKBOOKS_PATH}/${workbook.workbookId}`);
+  },
+  path: `${WORKBOOKS_PATH}/${workbook.workbookId}`
+});
+const CollectionBreadcrumbs = React__default.memo(
+  ({ className, isLoading = false, collections, workbook, onItemClick }) => {
+    const router = useRouter();
+    const items = React__default.useMemo(() => {
+      return isLoading ? [getFallbackItem()] : collections.map((item) => ({
+        id: item.collectionId,
+        text: item.title,
+        action: () => {
+          router.push(`${COLLECTIONS_PATH}/${item.collectionId}`);
+        },
+        path: `${COLLECTIONS_PATH}/${item.collectionId}`
+      })).concat(workbook ? [getWorkbookItem(workbook, router)] : []);
+    }, [isLoading, router, collections, workbook]);
+    return /* @__PURE__ */ jsx("div", { className: b$4(null, className), children: /* @__PURE__ */ jsx(Breadcrumbs, { className: b$4("container"), children: items.map((item, index, list) => {
+      const isLast = index === list.length - 1;
+      return /* @__PURE__ */ jsx(
+        Breadcrumbs.Item,
+        {
+          onClick: (event) => {
+            if (!event.metaKey && onItemClick) {
+              event.preventDefault();
+              onItemClick({ id: item.id, isCurrent: isLast });
+              item.action(event);
+            }
+          },
+          className: b$4("item"),
+          disabled: isLast,
+          href: item.path,
+          children: item.id === LOADING_ITEM_ID ? /* @__PURE__ */ jsx(Skeleton, { className: b$4("skeleton") }) : item.text
+        },
+        index
+      );
+    }) }) });
+  }
+);
+CollectionBreadcrumbs.displayName = "CollectionBreadcrumbs";
+const cutBreadcrumbs = (id, breadcrumbs) => {
+  let isFound = false;
+  const result = breadcrumbs.reduce((acc, item) => {
+    if (!isFound) {
+      acc.push(item);
+    }
+    if (id === item.collectionId) {
+      isFound = true;
+    }
+    return acc;
+  }, []);
+  return result;
+};
+const LayoutContext = createContext({
+  setLayout: () => {
+  },
+  setSkeletonsSettings: () => {
+  }
+});
+const b$3 = block("dl-workbook-actions");
+const i18n$2 = I18N.keyset("new-workbooks");
+const DIALOG_QUERY_PARAM_NAME = "dialog";
+const WorkbookActions = ({ workbook, refreshWorkbookInfo }) => {
+  const history = useHistory();
+  const { search } = useLocation();
+  const dispatch = useDispatch();
+  const preopenedAccessDialog = new URLSearchParams(search).get(DIALOG_QUERY_PARAM_NAME) === "access";
+  const [iamAccessDialogIsOpen, setIamAccessDialogIsOpen] = React__default.useState(preopenedAccessDialog);
+  React__default.useEffect(() => {
+    setIamAccessDialogIsOpen(preopenedAccessDialog);
+  }, [preopenedAccessDialog]);
+  const handleCloseIamAccessDialog = React__default.useCallback(() => {
+    const queryParams = new URLSearchParams(search);
+    if (queryParams.has(DIALOG_QUERY_PARAM_NAME)) {
+      queryParams.delete(DIALOG_QUERY_PARAM_NAME);
+      history.replace({
+        search: queryParams.toString()
+      });
+    }
+    setIamAccessDialogIsOpen(false);
+  }, [search, history]);
+  const collectionsAccessEnabled = isEnabledFeature(Feature.CollectionsAccessEnabled);
+  const onApplyCopy = (workbookId) => {
+    if (workbookId) {
+      history.push(`/workbooks/${workbookId}`);
+    }
+  };
+  const { useAdditionalWorkbookActions } = registry.workbooks.functions.getAll();
+  const { CustomActionPanelWorkbookActions } = registry.workbooks.components.getAll();
+  const { getCurrentUserRights, getGloballyEntrySettings } = registry.common.functions.getAll();
+  const currentUserRights = getCurrentUserRights();
+  const globallyEntrySettings = getGloballyEntrySettings();
+  const isWorkbookExportDisabled = Boolean(globallyEntrySettings?.isWorkbookExportDisabled);
+  const additionalActions = useAdditionalWorkbookActions(workbook);
+  const breadcrumbsError = useSelector(selectCollectionBreadcrumbsError);
+  const dropdownActions = [...additionalActions];
+  const collectionAccessPermissionDenied = workbook.collectionId && breadcrumbsError && Utils.parseErrorResponse(breadcrumbsError).status === 403;
+  const initialCollectionId = collectionAccessPermissionDenied ? void 0 : workbook.collectionId;
+  if (workbook.permissions.move) {
+    dropdownActions.push({
+      action: () => {
+        dispatch(
+          openDialog({
+            id: DIALOG_MOVE_WORKBOOK,
+            props: {
+              open: true,
+              workbookId: workbook.workbookId,
+              workbookTitle: workbook.title,
+              initialCollectionId,
+              onApply: refreshWorkbookInfo,
+              onClose: () => {
+                dispatch(closeDialog());
+              }
+            }
+          })
+        );
+      },
+      text: /* @__PURE__ */ jsx(DropdownAction, { icon: ArrowRight, text: i18n$2("action_move") })
+    });
+  }
+  if (workbook.permissions.copy) {
+    dropdownActions.push({
+      action: () => {
+        dispatch(
+          openDialog({
+            id: DIALOG_COPY_WORKBOOK,
+            props: {
+              open: true,
+              workbookId: workbook.workbookId,
+              workbookTitle: workbook.title,
+              initialCollectionId,
+              onApply: onApplyCopy,
+              onClose: () => {
+                dispatch(closeDialog());
+              }
+            }
+          })
+        );
+      },
+      text: /* @__PURE__ */ jsx(DropdownAction, { icon: Copy, text: i18n$2("action_copy") })
+    });
+  }
+  if (isEnabledFeature(Feature.EnableExportWorkbookFile) && currentUserRights.admin && !isWorkbookExportDisabled) {
+    dropdownActions.push({
+      action: () => {
+        dispatch(
+          openDialog({
+            id: DIALOG_EXPORT_WORKBOOK,
+            props: {
+              open: true,
+              workbookId: workbook.workbookId,
+              workbookTitle: workbook.title,
+              onClose: () => {
+                dispatch(closeDialog());
+              }
+            }
+          })
+        );
+      },
+      text: /* @__PURE__ */ jsx(DropdownAction, { icon: FileArrowUp, text: i18n$2("action_export") })
+    });
+  }
+  const otherActions = [];
+  if (workbook.permissions.delete) {
+    otherActions.push({
+      text: /* @__PURE__ */ jsx(DropdownAction, { icon: TrashBin, text: i18n$2("action_delete") }),
+      action: () => {
+        dispatch(
+          openDialog({
+            id: DIALOG_DELETE_WORKBOOK,
+            props: {
+              open: true,
+              workbookId: workbook.workbookId,
+              workbookTitle: workbook.title,
+              onSuccessApply: () => {
+                if (workbook.collectionId) {
+                  history.push(`${COLLECTIONS_PATH}/${workbook.collectionId}`);
+                } else {
+                  history.push(COLLECTIONS_PATH);
+                }
+              },
+              onClose: () => {
+                dispatch(closeDialog());
+              }
+            }
+          })
+        );
+      },
+      theme: "danger",
+      qa: WorkbookPageActionsMoreQA.DELETE_ITEM
+    });
+  }
+  if (otherActions.length > 0) {
+    dropdownActions.push([...otherActions]);
+  }
+  return /* @__PURE__ */ jsxs("div", { className: b$3(), children: [
+    Boolean(dropdownActions.length) && /* @__PURE__ */ jsx(
+      DropdownMenu,
+      {
+        defaultSwitcherProps: { view: "normal", qa: WorkbookPageActionsMoreQA.SWITCHER },
+        switcherWrapperClassName: b$3("item"),
+        items: dropdownActions
+      }
+    ),
+    /* @__PURE__ */ jsx(CustomActionPanelWorkbookActions, {}),
+    collectionsAccessEnabled && workbook.permissions.listAccessBindings && /* @__PURE__ */ jsx(Tooltip, { content: i18n$2("action_access"), children: /* @__PURE__ */ jsx("div", { className: b$3("item"), children: /* @__PURE__ */ jsx(
+      Button,
+      {
+        onClick: () => {
+          setIamAccessDialogIsOpen(true);
+        },
+        children: /* @__PURE__ */ jsx(Icon, { data: LockOpen })
+      }
+    ) }) }),
+    workbook.permissions.update && /* @__PURE__ */ jsx("div", { className: b$3("item"), children: /* @__PURE__ */ jsx(CreateEntry, { workbook, view: "action" }) }),
+    collectionsAccessEnabled && workbook.permissions.listAccessBindings && /* @__PURE__ */ jsx(
+      IamAccessDialog,
+      {
+        open: iamAccessDialogIsOpen,
+        resourceId: workbook.workbookId,
+        resourceType: ResourceType.Workbook,
+        resourceTitle: workbook.title,
+        parentId: workbook.collectionId,
+        canUpdate: workbook.permissions.updateAccessBindings,
+        onClose: handleCloseIamAccessDialog
+      }
+    )
+  ] });
+};
+const b$2 = block("dl-workbook-page");
+const i18n$1 = I18N.keyset("new-workbooks");
+const useLayout = ({ workbookId, refreshWorkbookInfo }) => {
+  const { ActionPanelEntrySelect } = registry.common.components.getAll();
+  const { setLayout } = React__default.useContext(LayoutContext);
+  const dispatch = useDispatch();
+  const history = useHistory$1();
+  const workbook = useSelector(selectWorkbook);
+  const filters = useSelector(selectWorkbookFilters);
+  const breadcrumbs = useSelector(selectCollectionBreadcrumbs);
+  const breadcrumbsError = useSelector(selectCollectionBreadcrumbsError);
+  const pageError = useSelector(selectPageError);
+  const isCorrectWorkbook = workbook && workbook.workbookId === workbookId;
+  const isCorrectBreadcrumbs = Boolean(
+    workbook && (workbook.collectionId === null || breadcrumbs && breadcrumbs[breadcrumbs.length - 1]?.collectionId === workbook.collectionId)
+  );
+  const goToParentCollection = React__default.useCallback(() => {
+    if (!workbook) {
+      return;
+    }
+    history.push(getParentCollectionPath(workbook));
+  }, [history, workbook]);
+  React__default.useEffect(() => {
+    setLayout({
+      actionsPanelLeftBlock: {
+        content: /* @__PURE__ */ jsxs("div", { className: b$2("action-bar-left-item"), children: [
+          /* @__PURE__ */ jsx(ActionPanelEntrySelect, {}),
+          /* @__PURE__ */ jsx(
+            CollectionBreadcrumbs,
+            {
+              className: b$2("breadcrumbs", { "is-mobile": DL.IS_MOBILE }),
+              isLoading: !(isCorrectBreadcrumbs || breadcrumbsError),
+              collections: breadcrumbs ?? [],
+              workbook,
+              onItemClick: ({ isCurrent, id }) => {
+                if (!isCurrent && id !== null) {
+                  batch(() => {
+                    const newBreadcrumbs = cutBreadcrumbs(
+                      id,
+                      breadcrumbs ?? []
+                    );
+                    dispatch(setCollectionBreadcrumbs(newBreadcrumbs));
+                    const curBreadcrumb = newBreadcrumbs[newBreadcrumbs.length - 1];
+                    if (newBreadcrumbs[newBreadcrumbs.length - 1]) {
+                      dispatch(setCollection(curBreadcrumb));
+                    }
+                  });
+                }
+              }
+            }
+          )
+        ] })
+      }
+    });
+  }, [
+    ActionPanelEntrySelect,
+    breadcrumbs,
+    breadcrumbsError,
+    dispatch,
+    filters,
+    isCorrectBreadcrumbs,
+    isCorrectWorkbook,
+    setLayout,
+    workbook,
+    workbookId
+  ]);
+  React__default.useEffect(() => {
+    if (isCorrectWorkbook && workbook) {
+      setLayout({
+        actionsPanelRightBlock: {
+          content: /* @__PURE__ */ jsx(
+            WorkbookActions,
+            {
+              workbook,
+              refreshWorkbookInfo
+            }
+          )
+        }
+      });
+    } else {
+      setLayout({
+        actionsPanelRightBlock: {
+          isLoading: true
+        }
+      });
+    }
+  }, [dispatch, isCorrectWorkbook, refreshWorkbookInfo, setLayout, workbook]);
+  React__default.useEffect(() => {
+    if (isCorrectWorkbook && workbook) {
+      setLayout({
+        titleActionsBlock: {
+          content: workbook?.permissions.update ? /* @__PURE__ */ jsx(Tooltip, { content: i18n$1("action_edit"), children: /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(
+            Button,
+            {
+              onClick: () => {
+                dispatch(
+                  openDialog({
+                    id: DIALOG_EDIT_WORKBOOK,
+                    props: {
+                      open: true,
+                      workbookId: workbook.workbookId,
+                      title: workbook.title,
+                      description: workbook?.description ?? "",
+                      onApply: refreshWorkbookInfo,
+                      onClose: () => {
+                        dispatch(closeDialog());
+                      }
+                    }
+                  })
+                );
+              },
+              children: /* @__PURE__ */ jsx(Icon, { data: PencilToLine })
+            }
+          ) }) }) : null
+        },
+        titleBeforeActionsBlock: {
+          content: DL.IS_MOBILE ? /* @__PURE__ */ jsx(
+            Button,
+            {
+              view: "flat",
+              size: "l",
+              onClick: goToParentCollection,
+              className: b$2("return-button"),
+              children: /* @__PURE__ */ jsx(Icon, { data: ArrowLeft, size: 16 })
+            }
+          ) : null
+        },
+        title: {
+          content: workbook.title
+        },
+        description: workbook.description ? {
+          content: workbook.description
+        } : null
+      });
+    } else {
+      setLayout({
+        titleActionsBlock: {
+          isLoading: true
+        },
+        title: {
+          isLoading: true
+        },
+        description: null
+      });
+    }
+  }, [dispatch, isCorrectWorkbook, refreshWorkbookInfo, setLayout, workbook]);
+  React__default.useEffect(() => {
+    setLayout({
+      titleRightBlock: null
+    });
+  }, [dispatch, setLayout]);
+  React__default.useEffect(() => {
+    if (pageError) {
+      setLayout({
+        actionsPanelLeftBlock: null,
+        actionsPanelRightBlock: null,
+        title: null,
+        titleActionsBlock: null,
+        titleRightBlock: null,
+        description: null
+      });
+    }
+  }, [pageError, setLayout]);
+};
+const b$1 = block("dl-workbook-page");
+const i18n = I18n.keyset("new-workbooks");
+const WorkbookPage = () => {
+  const { search } = useLocation();
+  const { workbookId } = useParams();
+  const dispatch = useDispatch();
+  const collectionId = useSelector(selectCollectionId);
+  const workbook = useSelector(selectWorkbook);
+  const pageError = useSelector(selectPageError);
+  const breadcrumbsError = useSelector(selectCollectionBreadcrumbsError);
+  const [showImportAlert, setShowImportAlert] = React__default.useState(
+    // TODO (Export workbook): enable when logic of alert is ready
+    // isEnabledFeature(Feature.EnableExportWorkbookFile) &&
+    //     workbook?.meta &&
+    //     'importId' in workbook.meta,
+    false
+  );
+  const { getWorkbookTabs } = registry.workbooks.functions.getAll();
+  const availableItems = React__default.useMemo(() => {
+    return workbook ? getWorkbookTabs(workbook).map(({ id }) => id) : [];
+  }, [getWorkbookTabs, workbook]);
+  const activeTab = React__default.useMemo(() => {
+    const queryTab = new URLSearchParams(search).get("tab");
+    return queryTab && availableItems.includes(queryTab) ? queryTab : TAB_ALL;
+  }, [availableItems, search]);
+  const filters = useSelector(selectWorkbookFilters);
+  const showContentLoader = !workbook || workbook.workbookId !== workbookId;
+  const isMainTab = activeTab === TAB_ALL;
+  const scope = isMainTab ? void 0 : activeTab;
+  const initLoadWorkbook = React__default.useCallback(() => {
+    dispatch(getWorkbook({ workbookId }));
+  }, [dispatch, workbookId]);
+  const refreshWorkbookInfo = React__default.useCallback(() => {
+    dispatch(getWorkbook({ workbookId }));
+  }, [dispatch, workbookId]);
+  const handleChangeFilters = React__default.useCallback(
+    (newFilters) => {
+      dispatch(changeFilters(newFilters));
+    },
+    [dispatch]
+  );
+  React__default.useEffect(() => {
+    initLoadWorkbook();
+  }, [initLoadWorkbook, dispatch]);
+  React__default.useEffect(() => {
+    if (collectionId) {
+      dispatch(getCollectionBreadcrumbs({ collectionId }));
+    }
+  }, [dispatch, collectionId]);
+  useLayout({ workbookId, refreshWorkbookInfo });
+  if (isEnabledFeature(Feature.EnableExportWorkbookFile) && workbook?.status === WORKBOOK_STATUS.CREATING && workbook?.meta.importId) {
+    const redirectPath = collectionId ? `${COLLECTIONS_PATH}/${collectionId}` : COLLECTIONS_PATH;
+    return /* @__PURE__ */ jsx(
+      Redirect,
+      {
+        to: {
+          pathname: `${redirectPath}`,
+          state: { importId: workbook.meta.importId }
+        }
+      }
+    );
+  }
+  if (pageError || breadcrumbsError && Utils.parseErrorResponse(breadcrumbsError).status !== 403) {
+    return /* @__PURE__ */ jsx("div", { className: b$1(), children: /* @__PURE__ */ jsx(ViewError, { retry: initLoadWorkbook, error: pageError }) });
+  }
+  const handleCloseImportAlert = () => {
+    setShowImportAlert(false);
+  };
+  const renderAlertActions = () => {
+    return /* @__PURE__ */ jsx(Flex, { gap: 3, children: /* @__PURE__ */ jsx(Button, { view: "normal-contrast", onClick: handleCloseImportAlert, children: i18n("button_import-alert-close") }) });
+  };
+  return /* @__PURE__ */ jsxs("div", { className: b$1(), "data-qa": WorkbookPageQa.Layout, children: [
+    showContentLoader ? /* @__PURE__ */ jsx(SmartLoader, { size: "l" }) : /* @__PURE__ */ jsx("div", { className: b$1("layout"), children: /* @__PURE__ */ jsxs("div", { className: b$1("container"), children: [
+      /* @__PURE__ */ jsxs("div", { className: b$1("controls"), children: [
+        !DL.IS_MOBILE && /* @__PURE__ */ jsx(WorkbookFilters, { filters, onChange: handleChangeFilters }),
+        workbook && /* @__PURE__ */ jsx(WorkbookTabs, { workbook }),
+        showImportAlert && /* @__PURE__ */ jsx(
+          Alert,
+          {
+            theme: "info",
+            title: i18n("label_import-alert-title"),
+            actions: renderAlertActions(),
+            onClose: handleCloseImportAlert,
+            className: spacing({ mt: 6 })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx("div", { className: b$1("content"), children: isMainTab ? /* @__PURE__ */ jsx(
+        WorkbookMainTabContent,
+        {
+          workbook,
+          filters,
+          workbookId
+        }
+      ) : /* @__PURE__ */ jsx(
+        WorkbookTabContent,
+        {
+          filters,
+          scope,
+          workbookId,
+          workbook
+        }
+      ) })
+    ] }) }),
+    /* @__PURE__ */ jsx(CreateEntryDialog, {})
+  ] });
+};
+const b = block("dl-collections-navigation-layout");
+const DEFAULT_SKELETONS_SETTINGS = {
+  actionsPanelLeftBlock: {
+    width: "250px",
+    height: "26px"
+  },
+  actionsPanelRightBlock: {
+    width: "170px",
+    height: "26px"
+  },
+  title: {
+    width: "150px",
+    height: "28px"
+  },
+  titleActionsBlock: {
+    width: "28px",
+    height: "28px"
+  },
+  titleRightBlock: {
+    width: "80px",
+    height: "28px"
+  },
+  description: {
+    width: "100%",
+    height: "28px"
+  }
+};
+const CollectionsNavigationLayout = React__default.memo(
+  // eslint-disable-next-line complexity
+  ({ layout, skeletonsSettings, children }) => {
+    const { Footer } = registry.common.components.getAll();
+    const showTitleActionsBlock = !DL.IS_MOBILE && layout.titleActionsBlock;
+    const showTitleRightBlock = !DL.IS_MOBILE && layout.titleRightBlock;
+    const showDescription = !DL.IS_MOBILE && layout.description;
+    const title = typeof layout.title?.content === "string" ? layout.title.content : "";
+    return /* @__PURE__ */ jsxs("div", { className: b({ mobile: DL.IS_MOBILE }), children: [
+      (layout.actionsPanelLeftBlock || layout.actionsPanelRightBlock) && !DL.IS_MOBILE && /* @__PURE__ */ jsx(ActionBar, { children: /* @__PURE__ */ jsxs(ActionBar.Section, { type: "primary", children: [
+        /* @__PURE__ */ jsx(ActionBar.Group, { pull: "left", className: b("action-bar-group-left"), children: layout.actionsPanelLeftBlock && /* @__PURE__ */ jsx(ActionBar.Item, { className: b("action-bar-group-item"), children: layout.actionsPanelLeftBlock.isLoading ? /* @__PURE__ */ jsx(
+          Skeleton,
+          {
+            style: skeletonsSettings.actionsPanelLeftBlock ? skeletonsSettings.actionsPanelLeftBlock : DEFAULT_SKELETONS_SETTINGS.actionsPanelLeftBlock
+          }
+        ) : layout.actionsPanelLeftBlock.content }) }),
+        /* @__PURE__ */ jsx(ActionBar.Group, { pull: "right", children: /* @__PURE__ */ jsx(ActionBar.Item, { children: layout.actionsPanelRightBlock && /* @__PURE__ */ jsx("div", { children: layout.actionsPanelRightBlock.isLoading ? /* @__PURE__ */ jsx(
+          Skeleton,
+          {
+            style: skeletonsSettings.actionsPanelRightBlock ? skeletonsSettings.actionsPanelRightBlock : DEFAULT_SKELETONS_SETTINGS.actionsPanelRightBlock
+          }
+        ) : layout.actionsPanelRightBlock.content }) }) })
+      ] }) }),
+      /* @__PURE__ */ jsxs("div", { className: b("page-wrapper"), children: [
+        /* @__PURE__ */ jsxs("div", { className: b("page"), children: [
+          /* @__PURE__ */ jsxs("div", { className: b("header"), children: [
+            layout.title || layout.titleActionsBlock ? /* @__PURE__ */ jsxs("div", { className: b("header-title-wrapper"), children: [
+              layout.titleBeforeActionsBlock?.content && /* @__PURE__ */ jsx("div", { children: layout.titleBeforeActionsBlock.content }),
+              layout.title && /* @__PURE__ */ jsx("h1", { className: b("header-title"), title, children: layout.title.isLoading ? /* @__PURE__ */ jsx(
+                Skeleton,
+                {
+                  style: skeletonsSettings.title ? skeletonsSettings.title : DEFAULT_SKELETONS_SETTINGS.title
+                }
+              ) : layout.title.content }),
+              showTitleActionsBlock && /* @__PURE__ */ jsx("div", { className: b("header-title-actions-block"), children: layout.titleActionsBlock?.isLoading ? /* @__PURE__ */ jsx(
+                Skeleton,
+                {
+                  style: skeletonsSettings.titleActionsBlock ? skeletonsSettings.titleActionsBlock : DEFAULT_SKELETONS_SETTINGS.titleActionsBlock
+                }
+              ) : layout.titleActionsBlock?.content })
+            ] }) : null,
+            showTitleRightBlock && /* @__PURE__ */ jsx("div", { className: b("header-right-block"), children: layout.titleRightBlock?.isLoading ? /* @__PURE__ */ jsx(
+              Skeleton,
+              {
+                style: skeletonsSettings.titleRightBlock ? skeletonsSettings.titleRightBlock : DEFAULT_SKELETONS_SETTINGS.titleRightBlock
+              }
+            ) : layout.titleRightBlock?.content })
+          ] }),
+          showDescription && /* @__PURE__ */ jsx("div", { className: b("header-description"), children: layout.description?.isLoading ? /* @__PURE__ */ jsx(
+            Skeleton,
+            {
+              style: skeletonsSettings.description ? skeletonsSettings.description : DEFAULT_SKELETONS_SETTINGS.description
+            }
+          ) : layout.description?.content }),
+          children && /* @__PURE__ */ jsx("div", { className: b("content"), children })
+        ] }),
+        isEnabledFeature(Feature.EnableFooter) && /* @__PURE__ */ jsx(Footer, {})
+      ] })
+    ] });
+  }
+);
+CollectionsNavigationLayout.displayName = "CollectionsNavigationLayout";
+const CollectionsNavigationApp = () => {
+  const dispatch = useDispatch();
+  const [actionsPanelLeftBlock, setActionsPanelLeftBlock] = React__default.useState(null);
+  const [actionsPanelRightBlock, setActionsPanelRightBlock] = React__default.useState(null);
+  const [title, setTitle] = React__default.useState(null);
+  const [titleActionsBlock, setTitleActionsBlock] = React__default.useState(null);
+  const [titleRightBlock, setTitleRightBlock] = React__default.useState(null);
+  const [titleBeforeActionsBlock, setTitleBeforeActionsBlock] = React__default.useState(null);
+  const [description, setDescription] = React__default.useState(null);
+  const setLayout = React__default.useCallback((layout) => {
+    if (layout.actionsPanelLeftBlock !== void 0) {
+      setActionsPanelLeftBlock(layout.actionsPanelLeftBlock);
+    }
+    if (layout.actionsPanelRightBlock !== void 0) {
+      setActionsPanelRightBlock(layout.actionsPanelRightBlock);
+    }
+    if (layout.title !== void 0) {
+      setTitle(layout.title);
+    }
+    if (layout.titleActionsBlock !== void 0) {
+      setTitleActionsBlock(layout.titleActionsBlock);
+    }
+    if (layout.titleRightBlock !== void 0) {
+      setTitleRightBlock(layout.titleRightBlock);
+    }
+    if (layout.titleBeforeActionsBlock !== void 0) {
+      setTitleBeforeActionsBlock(layout.titleBeforeActionsBlock);
+    }
+    if (layout.description !== void 0) {
+      setDescription(layout.description);
+    }
+  }, []);
+  const [skeletonsSettings, setSkeletonsSettings] = React__default.useState({});
+  React__default.useEffect(() => {
+    return () => {
+      dispatch(resetState());
+      dispatch(resetState$1());
+      dispatch(resetWorkbookState());
+    };
+  }, [dispatch]);
+  return /* @__PURE__ */ jsx(
+    LayoutContext.Provider,
+    {
+      value: {
+        setLayout,
+        setSkeletonsSettings
+      },
+      children: /* @__PURE__ */ jsx(
+        CollectionsNavigationLayout,
+        {
+          layout: {
+            actionsPanelLeftBlock,
+            actionsPanelRightBlock,
+            title,
+            titleActionsBlock,
+            titleRightBlock,
+            titleBeforeActionsBlock,
+            description
+          },
+          skeletonsSettings,
+          children: /* @__PURE__ */ jsxs(Switch, { children: [
+            /* @__PURE__ */ jsx(Route, { exact: true, path: `${WORKBOOKS_PATH}/:workbookId`, component: WorkbookPage }),
+            /* @__PURE__ */ jsx(Route, { path: "*", component: () => /* @__PURE__ */ jsx(Redirect, { to: "/" }) })
+          ] })
+        }
+      )
+    }
+  );
+};
+reducerRegistry.register({
+  collectionsNavigation: collectionsNavigationReducer,
+  collections: collectionsReducer
+  // workbooksReducer is already included as core reducer
+});
+const CollectionsNavigationPage = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: CollectionsNavigationApp
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  ChunkGroup as C,
+  EmptyRow as E,
+  ResourceType as R,
+  TAB_ALL as T,
+  CreateEntryActionType as a,
+  CreateEntry as b,
+  CollectionsNavigationPage as c
+};