@retailcrm/datalens-ui 0.0.0

package/components/CollectionsStructure.js

@@ -0,0 +1,3262 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import React__default from "react";
+import { n as ErrorCode, l as I18n, V as CollectionItemEntities, W as DialogCollectionStructureQa, X as WorkbookDialogQA, F as Feature } from "./AccessRights.js";
+import { useDispatch, useSelector } from "react-redux";
+import { D as DialogManager } from "./DialogManager.js";
+import { Dialog, TextInput, useThemeType, Card, Icon, Loader, Button, TextArea, useFileInput, Flex, Text, HelpMark, Label, Disclosure, spacing, Link } from "@gravity-ui/uikit";
+import { toaster } from "@gravity-ui/uikit/toaster-singleton";
+import block from "bem-cn-lite";
+import { D as DIALOG_DEFAULT } from "./DialogDefault.js";
+import { g as getSdk, l as logger, d as showToast, e as isSdkError, f as openDialogErrorWithTabs, h as formDocsEndpointDL, j as useMountedState, o as openDialog, c as closeDialog, i as isEnabledFeature } from "./ActionPanel.js";
+import { Paperclip, CircleExclamation, File, Clock, Key, Thunderbolt } from "@gravity-ui/icons";
+import { I as InterpolatedText } from "./InterpolatedText.js";
+import { P as ProgressBar } from "./ProgressBar.js";
+import { V as ViewError } from "./ViewError.js";
+import { createSelector } from "reselect";
+import { a as DialogConfirm, b as DialogConfirmApplyStatus } from "./DialogConfirm.js";
+import { useHistory } from "react-router-dom";
+import axios from "axios";
+import { C as CollectionFilters } from "./CollectionFilters.js";
+import { Waypoint } from "react-waypoint";
+import { P as PlaceholderIllustration } from "./PlaceholderIllustration.js";
+import { C as CollectionsStructureBreadcrumbs } from "./Breadcrumbs.js";
+import { S as SmartLoader } from "./SmartLoader.js";
+import { I as IconById } from "./IconById.js";
+import { E as EntryIcon } from "./EntryIcon.js";
+import { W as WorkbookIcon } from "./WorkbookIcon.js";
+import { E as EntryRow } from "./EntryRow.js";
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function waitOperation({
+  operation: initialOperation,
+  loader,
+  timeout = 60 * 60 * 1e3,
+  interval = 1e3
+}) {
+  const cancelSource = axios.CancelToken.source();
+  const cancelToken = cancelSource.token;
+  const concurrentId = getSdk().sdk.getConcurrentId();
+  let cancelOperation;
+  let timeouted = false;
+  let cancelled = false;
+  function createCancelOperation(reject) {
+    return function() {
+      cancelled = true;
+      reject("cancel");
+    };
+  }
+  const timeoutPromise = sleep(timeout).then(() => {
+    logger.logError("waitOperation: timeout has occurred");
+    timeouted = true;
+    return Promise.reject("timeout");
+  });
+  const cancellationPromise = new Promise((_resolve, reject) => {
+    cancelOperation = createCancelOperation(reject);
+  });
+  const operationPromise = (async () => {
+    let operation = initialOperation;
+    try {
+      while (!operation.done) {
+        if (timeouted || cancelled) {
+          break;
+        }
+        operation = await loader({ operation, cancelToken, concurrentId });
+        if (!operation.done) {
+          await sleep(interval);
+        }
+      }
+    } catch (error) {
+      if (axios.isCancel(error)) {
+        return Promise.reject("cancel");
+      } else {
+        logger.logError("waitOperation: loader failed");
+        return Promise.reject(error);
+      }
+    }
+    if (operation && operation.error) {
+      logger.logError("waitOperation: operation.error");
+      return Promise.reject(operation.error);
+    } else if (operation) {
+      return Promise.resolve(operation?.response);
+    } else {
+      logger.logError("waitOperation: operation not defined");
+      return Promise.reject();
+    }
+  })();
+  return {
+    promise: Promise.race([timeoutPromise, cancellationPromise, operationPromise]),
+    cancel: function() {
+      cancelOperation();
+      cancelSource.cancel();
+      getSdk().cancelRequest(concurrentId);
+    }
+  };
+}
+const RESET_STATE = /* @__PURE__ */ Symbol("collectionsStructure/RESET_STATE");
+const GET_ROOT_COLLECTION_PERMISSIONS_LOADING = /* @__PURE__ */ Symbol(
+  "collectionsStructure/GET_ROOT_COLLECTION_PERMISSIONS_LOADING"
+);
+const GET_ROOT_COLLECTION_PERMISSIONS_SUCCESS = /* @__PURE__ */ Symbol(
+  "collectionsStructure/GET_ROOT_COLLECTION_PERMISSIONS_SUCCESS"
+);
+const GET_ROOT_COLLECTION_PERMISSIONS_FAILED = /* @__PURE__ */ Symbol(
+  "collectionsStructure/GET_ROOT_COLLECTION_PERMISSIONS_FAILED"
+);
+const RESET_COLLECTION_BREADCRUMBS = /* @__PURE__ */ Symbol(
+  "collectionsStructure/RESET_COLLECTION_BREADCRUMBS"
+);
+const GET_COLLECTION_BREADCRUMBS_LOADING = /* @__PURE__ */ Symbol(
+  "collectionsStructure/GET_COLLECTION_BREADCRUMBS_LOADING"
+);
+const GET_COLLECTION_BREADCRUMBS_SUCCESS = /* @__PURE__ */ Symbol(
+  "collectionsStructure/GET_COLLECTION_BREADCRUMBS_SUCCESS"
+);
+const GET_COLLECTION_BREADCRUMBS_FAILED = /* @__PURE__ */ Symbol(
+  "collectionsStructure/GET_COLLECTION_BREADCRUMBS_FAILED"
+);
+const GET_COLLECTION_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/GET_COLLECTION_LOADING");
+const GET_COLLECTION_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/GET_COLLECTION_SUCCESS");
+const GET_COLLECTION_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/GET_COLLECTION_FAILED");
+const RESET_STRUCTURE_ITEMS = /* @__PURE__ */ Symbol("collectionsStructure/RESET_STRUCTURE_ITEMS");
+const GET_STRUCTURE_ITEMS_LOADING = /* @__PURE__ */ Symbol(
+  "collectionsStructure/GET_STRUCTURE_ITEMS_LOADING"
+);
+const GET_STRUCTURE_ITEMS_SUCCESS = /* @__PURE__ */ Symbol(
+  "collectionsStructure/GET_STRUCTURE_ITEMS_SUCCESS"
+);
+const GET_STRUCTURE_ITEMS_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/GET_STRUCTURE_ITEMS_FAILED");
+const COPY_TEMPLATE_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/COPY_TEMPLATE_LOADING");
+const COPY_TEMPLATE_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/COPY_TEMPLATE_SUCCESS");
+const COPY_TEMPLATE_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/COPY_TEMPLATE_FAILED");
+const CREATE_COLLECTION_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/CREATE_COLLECTION_LOADING");
+const CREATE_COLLECTION_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/CREATE_COLLECTION_SUCCESS");
+const CREATE_COLLECTION_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/CREATE_COLLECTION_FAILED");
+const CREATE_WORKBOOK_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/CREATE_WORKBOOK_LOADING");
+const CREATE_WORKBOOK_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/CREATE_WORKBOOK_SUCCESS");
+const CREATE_WORKBOOK_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/CREATE_WORKBOOK_FAILED");
+const DELETE_COLLECTIONS_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/DELETE_COLLECTIONS_LOADING");
+const DELETE_COLLECTIONS_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/DELETE_COLLECTIONS_SUCCESS");
+const DELETE_COLLECTIONS_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/DELETE_COLLECTIONS_FAILED");
+const DELETE_WORKBOOKS_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/DELETE_WORKBOOKS_LOADING");
+const DELETE_WORKBOOKS_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/DELETE_WORKBOOKS_SUCCESS");
+const DELETE_WORKBOOKS_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/DELETE_WORKBOOKS_FAILED");
+const MOVE_COLLECTIONS_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/MOVE_COLLECTIONS_LOADING");
+const MOVE_COLLECTIONS_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/MOVE_COLLECTIONS_SUCCESS");
+const MOVE_COLLECTIONS_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/MOVE_COLLECTIONS_FAILED");
+const MOVE_COLLECTION_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/MOVE_COLLECTION_LOADING");
+const MOVE_COLLECTION_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/MOVE_COLLECTION_SUCCESS");
+const MOVE_COLLECTION_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/MOVE_COLLECTION_FAILED");
+const MOVE_WORKBOOKS_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/MOVE_WORKBOOKS_LOADING");
+const MOVE_WORKBOOKS_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/MOVE_WORKBOOKS_SUCCESS");
+const MOVE_WORKBOOKS_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/MOVE_WORKBOOKS_FAILED");
+const MOVE_WORKBOOK_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/MOVE_WORKBOOK_LOADING");
+const MOVE_WORKBOOK_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/MOVE_WORKBOOK_SUCCESS");
+const MOVE_WORKBOOK_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/MOVE_WORKBOOK_FAILED");
+const MOVE_SHARED_ENTRY_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/MOVE_SHARED_ENTRY_LOADING");
+const MOVE_SHARED_ENTRY_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/MOVE_SHARED_ENTRY_SUCCESS");
+const MOVE_SHARED_ENTRY_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/MOVE_SHARED_ENTRY_FAILED");
+const COPY_WORKBOOK_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/COPY_WORKBOOK_LOADING");
+const COPY_WORKBOOK_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/COPY_WORKBOOK_SUCCESS");
+const COPY_WORKBOOK_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/COPY_WORKBOOK_FAILED");
+const UPDATE_WORKBOOK_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/UPDATE_WORKBOOK_LOADING");
+const UPDATE_WORKBOOK_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/UPDATE_WORKBOOK_SUCCESS");
+const UPDATE_WORKBOOK_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/UPDATE_WORKBOOK_FAILED");
+const UPDATE_COLLECTION_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/UPDATE_COLLECTION_LOADING");
+const UPDATE_COLLECTION_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/UPDATE_COLLECTION_SUCCESS");
+const UPDATE_COLLECTION_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/UPDATE_COLLECTION_FAILED");
+const DELETE_COLLECTION_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/DELETE_COLLECTION_LOADING");
+const DELETE_COLLECTION_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/DELETE_COLLECTION_SUCCESS");
+const DELETE_COLLECTION_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/DELETE_COLLECTION_FAILED");
+const DELETE_WORKBOOK_LOADING = /* @__PURE__ */ Symbol("collectionsStructure/DELETE_WORKBOOK_LOADING");
+const DELETE_WORKBOOK_SUCCESS = /* @__PURE__ */ Symbol("collectionsStructure/DELETE_WORKBOOK_SUCCESS");
+const DELETE_WORKBOOK_FAILED = /* @__PURE__ */ Symbol("collectionsStructure/DELETE_WORKBOOK_FAILED");
+const EXPORT_WORKBOOK_LOADING = /* @__PURE__ */ Symbol("collections/EXPORT_WORKBOOK_LOADING");
+const EXPORT_WORKBOOK_SUCCESS = /* @__PURE__ */ Symbol("collections/EXPORT_WORKBOOK_SUCCESS");
+const EXPORT_WORKBOOK_FAILED = /* @__PURE__ */ Symbol("collections/EXPORT_WORKBOOK_FAILED");
+const RESET_EXPORT_WORKBOOK = /* @__PURE__ */ Symbol("collections/RESET_EXPORT_WORKBOOK");
+const IMPORT_WORKBOOK_LOADING = /* @__PURE__ */ Symbol("collections/IMPORT_WORKBOOK_LOADING");
+const IMPORT_WORKBOOK_SUCCESS = /* @__PURE__ */ Symbol("collections/IMPORT_WORKBOOK_SUCCESS");
+const IMPORT_WORKBOOK_FAILED = /* @__PURE__ */ Symbol("collections/IMPORT_WORKBOOK_FAILED");
+const RESET_IMPORT_WORKBOOK = /* @__PURE__ */ Symbol("collections/RESET_IMPORT_WORKBOOK");
+const GET_IMPORT_PROGRESS_LOADING = /* @__PURE__ */ Symbol("collections/GET_IMPORT_PROGRESS_LOADING");
+const GET_IMPORT_PROGRESS_SUCCESS = /* @__PURE__ */ Symbol("collections/GET_IMPORT_PROGRESS_SUCCESS");
+const GET_IMPORT_PROGRESS_FAILED = /* @__PURE__ */ Symbol("collections/GET_IMPORT_PROGRESS_FAILED");
+const RESET_IMPORT_PROGRESS = /* @__PURE__ */ Symbol("collections/RESET_IMPORT_PROGRESS");
+const GET_EXPORT_PROGRESS_LOADING = /* @__PURE__ */ Symbol("collections/GET_EXPORT_PROGRESS_LOADING");
+const GET_EXPORT_PROGRESS_SUCCESS = /* @__PURE__ */ Symbol("collections/GET_EXPORT_PROGRESS_SUCCESS");
+const GET_EXPORT_PROGRESS_FAILED = /* @__PURE__ */ Symbol("collections/GET_EXPORT_PROGRESS_FAILED");
+const RESET_EXPORT_PROGRESS = /* @__PURE__ */ Symbol("collections/RESET_EXPORT_PROGRESS");
+const GET_EXPORT_RESULT_LOADING = /* @__PURE__ */ Symbol("collections/GET_EXPORT_RESULT_LOADING");
+const GET_EXPORT_RESULT_SUCCESS = /* @__PURE__ */ Symbol("collections/GET_EXPORT_RESULT_SUCCESS");
+const GET_EXPORT_RESULT_FAILED = /* @__PURE__ */ Symbol("collections/GET_EXPORT_RESULT_FAILED");
+const RESET_EXPORT_RESULT = /* @__PURE__ */ Symbol("collections/RESET_EXPORT_RESULT");
+const i18n$m = I18n.keyset("component.collections-structure");
+const showCollectionEntityErrorToast = (error) => (dispatch) => {
+  let title = error.message;
+  if ("code" in error) {
+    switch (error.code) {
+      case ErrorCode.CollectionAlreadyExists:
+        title = i18n$m("toast_collection-already-exists-error");
+        break;
+      case ErrorCode.WorkbookAlreadyExists:
+      case ErrorCode.MetaManagerWorkbookAlreadyExists:
+        title = i18n$m("label_workbook-already-exists-error");
+        break;
+      default:
+        title = error.message;
+    }
+  }
+  return dispatch(
+    showToast({
+      title,
+      error
+    })
+  );
+};
+const resetState = () => (dispatch) => {
+  dispatch({
+    type: RESET_STATE
+  });
+};
+const getRootCollectionPermissions = () => {
+  return (dispatch) => {
+    dispatch({
+      type: GET_ROOT_COLLECTION_PERMISSIONS_LOADING
+    });
+    return getSdk().sdk.us.getRootCollectionPermissions().then((data) => {
+      dispatch({
+        type: GET_ROOT_COLLECTION_PERMISSIONS_SUCCESS,
+        data
+      });
+      return data;
+    }).catch((error) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      if (!isCanceled) {
+        logger.logError(
+          "collectionsStructure/getRootCollectionPermissions failed",
+          error
+        );
+        dispatch(
+          showToast({
+            title: error.message,
+            error
+          })
+        );
+      }
+      return null;
+    });
+  };
+};
+const resetCollectionBreadcrumbs = () => {
+  return (dispatch) => {
+    dispatch({
+      type: RESET_COLLECTION_BREADCRUMBS
+    });
+  };
+};
+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) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      dispatch({
+        type: GET_COLLECTION_BREADCRUMBS_FAILED,
+        error: isCanceled ? null : error
+      });
+      return null;
+    });
+  };
+};
+const getCollection = ({ collectionId }) => {
+  return (dispatch) => {
+    dispatch({
+      type: GET_COLLECTION_LOADING
+    });
+    return getSdk().sdk.us.getCollection({
+      collectionId,
+      includePermissionsInfo: true
+    }).then((data) => {
+      dispatch({
+        type: GET_COLLECTION_SUCCESS,
+        data
+      });
+      return data;
+    }).catch((error) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      if (!isCanceled) {
+        logger.logError("collectionsStructure/getCollection failed", error);
+        dispatch(
+          showToast({
+            title: error.message,
+            error
+          })
+        );
+      }
+      dispatch({
+        type: GET_COLLECTION_FAILED,
+        error: isCanceled ? null : error
+      });
+      return null;
+    });
+  };
+};
+const resetStructureItems = () => {
+  return (dispatch) => {
+    dispatch({
+      type: RESET_STRUCTURE_ITEMS
+    });
+  };
+};
+const getStructureItems = ({
+  collectionId,
+  includePermissionsInfo,
+  page,
+  filterString,
+  orderField,
+  orderDirection,
+  onlyMy,
+  mode,
+  pageSize
+}) => {
+  return (dispatch) => {
+    dispatch({
+      type: GET_STRUCTURE_ITEMS_LOADING
+    });
+    return getSdk().sdk.us.getStructureItems({
+      collectionId,
+      includePermissionsInfo,
+      page,
+      filterString,
+      orderField,
+      orderDirection,
+      onlyMy,
+      mode,
+      pageSize
+    }).then((data) => {
+      dispatch({
+        type: GET_STRUCTURE_ITEMS_SUCCESS,
+        data
+      });
+      return data;
+    }).catch((error) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      if (!isCanceled) {
+        logger.logError("collectionsStructure/getStructureItems failed", error);
+        dispatch(
+          showToast({
+            title: error.message,
+            error
+          })
+        );
+      }
+      dispatch({
+        type: GET_STRUCTURE_ITEMS_FAILED,
+        error: isCanceled ? null : error
+      });
+      return null;
+    });
+  };
+};
+const createCollection = ({
+  title,
+  description,
+  parentId
+}, shouldThrow = false) => {
+  return (dispatch) => {
+    dispatch({
+      type: CREATE_COLLECTION_LOADING
+    });
+    return getSdk().sdk.us.createCollection({
+      title,
+      description,
+      parentId
+    }).then(async (result) => {
+      const { operation } = result;
+      if (operation && operation.id) {
+        await waitOperation({
+          operation,
+          loader: ({ concurrentId }) => getSdk().sdk.us.getOperation(
+            { operationId: operation.id },
+            { concurrentId }
+          )
+        }).promise;
+      }
+      return result;
+    }).then((data) => {
+      dispatch({
+        type: CREATE_COLLECTION_SUCCESS,
+        data
+      });
+      return data;
+    }).catch((error) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      if (!isCanceled) {
+        logger.logError("collectionsStructure/createCollection failed", error);
+        dispatch(showCollectionEntityErrorToast(error));
+      }
+      dispatch({
+        type: CREATE_COLLECTION_FAILED,
+        error: isCanceled ? null : error
+      });
+      if (shouldThrow) {
+        throw error;
+      }
+      return null;
+    });
+  };
+};
+const createWorkbook = ({
+  title,
+  description,
+  collectionId
+}, shouldThrow = false) => {
+  return (dispatch) => {
+    dispatch({
+      type: CREATE_WORKBOOK_LOADING
+    });
+    return getSdk().sdk.us.createWorkbook({
+      title,
+      description,
+      collectionId
+    }).then(async (result) => {
+      const { operation } = result;
+      if (operation && operation.id) {
+        await waitOperation({
+          operation,
+          loader: ({ concurrentId }) => getSdk().sdk.us.getOperation(
+            { operationId: operation.id },
+            { concurrentId }
+          )
+        }).promise;
+      }
+      return result;
+    }).then((data) => {
+      dispatch({
+        type: CREATE_WORKBOOK_SUCCESS,
+        data
+      });
+      return data;
+    }).catch((error) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      if (!isCanceled) {
+        logger.logError("collectionsStructure/createWorkbook failed", error);
+        dispatch(showCollectionEntityErrorToast(error));
+      }
+      dispatch({
+        type: CREATE_WORKBOOK_FAILED,
+        error: isCanceled ? null : error
+      });
+      if (shouldThrow) {
+        throw error;
+      }
+      return null;
+    });
+  };
+};
+const moveWorkbook = ({
+  workbookId,
+  collectionId,
+  title
+}) => {
+  return (dispatch) => {
+    dispatch({
+      type: MOVE_WORKBOOK_LOADING
+    });
+    return getSdk().sdk.us.moveWorkbook({
+      workbookId,
+      collectionId,
+      title
+    }).then((data) => {
+      dispatch({
+        type: MOVE_WORKBOOK_SUCCESS,
+        data
+      });
+      return data;
+    }).catch((error) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      if (!isCanceled) {
+        logger.logError("collectionsStructure/moveWorkbook failed", error);
+        dispatch(
+          showToast({
+            title: error.message,
+            error
+          })
+        );
+      }
+      dispatch({
+        type: MOVE_WORKBOOK_FAILED,
+        error: isCanceled ? null : error
+      });
+      return null;
+    });
+  };
+};
+const copyWorkbook = ({
+  workbookId,
+  collectionId,
+  title
+}) => {
+  return (dispatch) => {
+    dispatch({
+      type: COPY_WORKBOOK_LOADING
+    });
+    return getSdk().sdk.us.copyWorkbook({
+      workbookId,
+      collectionId,
+      title
+    }).then(async (result) => {
+      const { operation } = result;
+      if (operation && operation.id) {
+        await waitOperation({
+          operation,
+          loader: ({ concurrentId }) => getSdk().sdk.us.getOperation(
+            { operationId: operation.id },
+            { concurrentId }
+          )
+        }).promise;
+      }
+      return result;
+    }).then((data) => {
+      dispatch({
+        type: COPY_WORKBOOK_SUCCESS,
+        data
+      });
+      return data;
+    }).catch((error) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      if (!isCanceled) {
+        logger.logError("collectionsStructure/copyWorkbook failed", error);
+        dispatch(
+          showToast({
+            title: error.message,
+            error
+          })
+        );
+      }
+      dispatch({
+        type: COPY_WORKBOOK_FAILED,
+        error: isCanceled ? null : error
+      });
+      return null;
+    });
+  };
+};
+const updateWorkbook = ({
+  workbookId,
+  title,
+  description
+}, shouldThrow = false) => {
+  return (dispatch) => {
+    dispatch({
+      type: UPDATE_WORKBOOK_LOADING
+    });
+    return getSdk().sdk.us.updateWorkbook({
+      workbookId,
+      title,
+      description
+    }).then((data) => {
+      dispatch({
+        type: UPDATE_WORKBOOK_SUCCESS,
+        data
+      });
+      return data;
+    }).catch((error) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      if (!isCanceled) {
+        logger.logError("collectionsStructure/updateWorkbook failed", error);
+        dispatch(showCollectionEntityErrorToast(error));
+      }
+      dispatch({
+        type: UPDATE_WORKBOOK_FAILED,
+        error: isCanceled ? null : error
+      });
+      if (shouldThrow) {
+        throw error;
+      }
+      return null;
+    });
+  };
+};
+const deleteWorkbook = ({ workbookId }) => {
+  return (dispatch) => {
+    dispatch({
+      type: DELETE_WORKBOOK_LOADING
+    });
+    return getSdk().sdk.us.deleteWorkbook({
+      workbookId
+    }).then((data) => {
+      dispatch({
+        type: DELETE_WORKBOOK_SUCCESS,
+        data
+      });
+      return data;
+    }).catch((error) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      if (!isCanceled) {
+        logger.logError("collectionsStructure/deleteWorkbook failed", error);
+        dispatch(
+          showToast({
+            title: error.message,
+            error
+          })
+        );
+      }
+      dispatch({
+        type: DELETE_WORKBOOK_FAILED,
+        error: isCanceled ? null : error
+      });
+      return null;
+    });
+  };
+};
+const getStatusFromOperation = ({
+  progessOperation,
+  initialOperation
+}) => {
+  if (progessOperation.data?.status === "error" && progessOperation.data?.notifications?.some((item) => item.level === "critical")) {
+    return "notification-error";
+  }
+  if (progessOperation.error) {
+    return "fatal-error";
+  }
+  if (progessOperation.data?.status === "pending") {
+    return "pending";
+  }
+  if (initialOperation?.isLoading || progessOperation.isLoading) {
+    return "loading";
+  }
+  if (progessOperation.data?.status === "success") {
+    return "success";
+  }
+  return null;
+};
+const convertFileToJSON = (file) => {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      try {
+        const json = JSON.parse(reader.result);
+        resolve(json);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    reader.readAsText(file);
+  });
+};
+const i18n$l = I18n.keyset("component.collections-structure");
+const exportWorkbook = ({ workbookId }) => {
+  return (dispatch) => {
+    dispatch({
+      type: EXPORT_WORKBOOK_LOADING
+    });
+    return getSdk().sdk.metaManager.startWorkbookExport({ workbookId }).then((data) => {
+      dispatch({
+        type: EXPORT_WORKBOOK_SUCCESS,
+        data
+      });
+      return data;
+    }).catch((error) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      if (!isCanceled) {
+        logger.logError("collectionsStructure/exportWorkbook failed", error);
+        dispatch(
+          showToast({
+            title: error.message,
+            error
+          })
+        );
+      }
+      dispatch({
+        type: EXPORT_WORKBOOK_FAILED,
+        error: isCanceled ? null : error
+      });
+      return null;
+    });
+  };
+};
+const resetExportWorkbook = () => {
+  return (dispatch) => {
+    dispatch({
+      type: RESET_EXPORT_WORKBOOK
+    });
+    dispatch({
+      type: RESET_EXPORT_PROGRESS
+    });
+    dispatch({
+      type: RESET_EXPORT_RESULT
+    });
+  };
+};
+const getEntriesMap = async (data) => {
+  const ids = [];
+  data.notifications?.forEach((notification) => {
+    if (notification.entryId) {
+      ids.push(notification.entryId);
+    }
+  });
+  try {
+    if (ids.length === 0) {
+      return null;
+    }
+    const notificationEntries = await getSdk().sdk.mix.getBatchEntriesByIds({ ids });
+    const entriesMap = notificationEntries.entries.reduce(
+      (acc, entry) => {
+        acc[entry.entryId] = entry;
+        return acc;
+      },
+      {}
+    );
+    return entriesMap;
+  } catch (error) {
+    const isCanceled = getSdk().sdk.isCancel(error);
+    if (!isCanceled) {
+      logger.logError("collectionsStructure/getEntriesMap failed", error);
+    }
+    return null;
+  }
+};
+const getExportProgress = ({ exportId }) => {
+  return (dispatch) => {
+    dispatch({
+      type: GET_EXPORT_PROGRESS_LOADING
+    });
+    return getSdk().sdk.metaManager.getWorkbookExportStatus({ exportId }).then(async (data) => {
+      const notificationEntries = await getEntriesMap(data);
+      dispatch({
+        type: GET_EXPORT_PROGRESS_SUCCESS,
+        data,
+        notificationEntries
+      });
+      return data;
+    }).catch((error) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      if (!isCanceled) {
+        logger.logError("collectionsStructure/getExportProgress failed", error);
+      }
+      dispatch({
+        type: GET_EXPORT_PROGRESS_FAILED,
+        error: isCanceled ? null : error
+      });
+    });
+  };
+};
+const cancelExportProcess = (exportId) => {
+  return (dispatch) => {
+    return getSdk().sdk.metaManager.cancelWorkbookExport({ exportId }).then(() => {
+      dispatch(resetExportWorkbook());
+    }).catch((error) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      if (!isCanceled) {
+        logger.logError("collectionsStructure/cancelExportProcess failed", error);
+      }
+    });
+  };
+};
+const importWorkbook = ({
+  title,
+  description,
+  collectionId,
+  importFile,
+  publicGalleryUrl
+}, shouldThrow = false) => {
+  return async (dispatch) => {
+    let data;
+    if (importFile) {
+      try {
+        data = await convertFileToJSON(importFile);
+      } catch (err) {
+        dispatch(
+          showToast({
+            title: i18n$l("toast_get-json-error"),
+            error: err
+          })
+        );
+        if (shouldThrow) {
+          throw err;
+        }
+        return Promise.resolve();
+      }
+    } else {
+      try {
+        const request = await fetch(publicGalleryUrl);
+        data = await request.json();
+      } catch (err) {
+        dispatch(
+          showToast({
+            title: i18n$l("toast_get-json-error"),
+            error: err
+          })
+        );
+        if (shouldThrow) {
+          throw err;
+        }
+        return Promise.resolve();
+      }
+    }
+    dispatch({
+      type: IMPORT_WORKBOOK_LOADING
+    });
+    return getSdk().sdk.metaManager.startWorkbookImport({
+      title: title.trim(),
+      description: description?.trim(),
+      collectionId,
+      data
+    }).then((resultData) => {
+      dispatch({
+        type: IMPORT_WORKBOOK_SUCCESS,
+        data: resultData
+      });
+      return resultData;
+    }).catch((error) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      if (!isCanceled) {
+        logger.logError("collectionsStructure/importWorkbook failed", error);
+        dispatch(showCollectionEntityErrorToast(error));
+      }
+      dispatch({
+        type: IMPORT_WORKBOOK_FAILED,
+        error: isCanceled ? null : error
+      });
+      if (shouldThrow) {
+        throw error;
+      }
+      return null;
+    });
+  };
+};
+const resetImportWorkbook = () => {
+  return (dispatch) => {
+    dispatch({
+      type: RESET_IMPORT_WORKBOOK
+    });
+    dispatch({
+      type: RESET_IMPORT_PROGRESS
+    });
+  };
+};
+const getExportResult = ({ exportId }) => {
+  return (dispatch) => {
+    dispatch({
+      type: GET_EXPORT_RESULT_LOADING
+    });
+    return getSdk().sdk.metaManager.getWorkbookExportResult({
+      exportId
+    }).then((data) => {
+      dispatch({
+        type: GET_EXPORT_RESULT_SUCCESS,
+        data
+      });
+      return data;
+    }).catch((error) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      if (!isCanceled) {
+        logger.logError("collectionsStructure/getExportResult failed", error);
+        dispatch(
+          showToast({
+            title: error.message,
+            error
+          })
+        );
+      }
+      dispatch({
+        type: GET_EXPORT_RESULT_FAILED,
+        error: isCanceled ? null : error
+      });
+      return null;
+    });
+  };
+};
+const getImportProgress = ({ importId }) => {
+  return (dispatch) => {
+    dispatch({
+      type: GET_IMPORT_PROGRESS_LOADING
+    });
+    return getSdk().sdk.metaManager.getWorkbookImportStatus({ importId }).then(async (data) => {
+      const notificationEntries = await getEntriesMap(data);
+      dispatch({
+        type: GET_IMPORT_PROGRESS_SUCCESS,
+        data,
+        notificationEntries
+      });
+      return data;
+    }).catch((error) => {
+      const isCanceled = getSdk().sdk.isCancel(error);
+      if (!isCanceled) {
+        logger.logError("collectionsStructure/getImportProgress failed", error);
+      }
+      const finalError = isSdkError(error) && error.status === 404 ? { ...error, message: i18n$l("toast_outdated-workbook-info") } : error;
+      dispatch({
+        type: GET_IMPORT_PROGRESS_FAILED,
+        error: isCanceled ? null : finalError
+      });
+    });
+  };
+};
+const selectGetRootCollectionPermissions = (state) => state.collectionsStructure.getRootCollectionPermissions;
+const selectGetCollectionBreadcrumbs = (state) => state.collectionsStructure.getCollectionBreadcrumbs;
+const selectGetCollection = (state) => state.collectionsStructure.getCollection;
+const selectGetStructureItems = (state) => state.collectionsStructure.getStructureItems;
+const selectStructureItems = (state) => state.collectionsStructure.items ?? [];
+const selectFilteredStructureItems = (state) => state.collectionsStructure.items?.filter(
+  (item) => item.entity !== CollectionItemEntities.ENTRY
+) ?? [];
+const selectCopyTemplate = (state) => state.collectionsStructure.copyTemplate;
+const selectCreateCollection = (state) => state.collectionsStructure.createCollection;
+const selectCreateWorkbook = (state) => state.collectionsStructure.createWorkbook;
+const selectMoveCollection = (state) => state.collectionsStructure.moveCollection;
+const selectMoveWorkbook = (state) => state.collectionsStructure.moveWorkbook;
+const selectMoveSharedEntry = (state) => state.collectionsStructure.moveSharedEntry;
+const selectCopyWorkbook = (state) => state.collectionsStructure.copyWorkbook;
+const selectUpdateWorkbook = (state) => state.collectionsStructure.updateWorkbook;
+const selectUpdateCollection = (state) => state.collectionsStructure.updateCollection;
+const selectDeleteCollection = (state) => state.collectionsStructure.deleteCollection;
+const selectDeleteWorkbook = (state) => state.collectionsStructure.deleteWorkbook;
+const selectDeleteCollections = (state) => state.collectionsStructure.deleteCollections;
+const selectDeleteWorkbooks = (state) => state.collectionsStructure.deleteWorkbooks;
+const selectGetExportProgress = (state) => state.collectionsStructure.getExportProgress;
+const selectExportWorkbook = (state) => state.collectionsStructure.exportWorkbook;
+const selectGetExportResult = (state) => state.collectionsStructure.getExportResult;
+const selectGetExportProgressData = createSelector(
+  [selectGetExportProgress],
+  (getExportProgress2) => getExportProgress2.data
+);
+const selectGetExportProgressEntriesMap = createSelector(
+  [selectGetExportProgress],
+  (data) => data.notificationEntries
+);
+const selectGetExportResultLoading = createSelector(
+  [selectGetExportResult],
+  (getExportResult2) => getExportResult2.isLoading
+);
+const selectExportError = createSelector(
+  [selectExportWorkbook, selectGetExportProgress],
+  (exportWorkbook2, getExportProgress2) => exportWorkbook2.error || getExportProgress2.error
+);
+const selectExportWorkbookStatus = createSelector(
+  [selectExportWorkbook, selectGetExportProgress],
+  (exportWorkbook2, getExportProgress2) => getStatusFromOperation({
+    initialOperation: exportWorkbook2,
+    progessOperation: getExportProgress2
+  })
+);
+const selectImportWorkbook = (state) => state.collectionsStructure.importWorkbook;
+const selectGetImportProgress = (state) => state.collectionsStructure.getImportProgress;
+const selectImportWorkbookData = createSelector(
+  [selectImportWorkbook],
+  (importWorkbook2) => importWorkbook2.data
+);
+const selectGetImportProgressEntriesMap = createSelector(
+  [selectGetImportProgress],
+  (data) => data.notificationEntries
+);
+const selectGetImportProgressData = createSelector(
+  [selectGetImportProgress],
+  (getImportProgress2) => getImportProgress2.data
+);
+const selectImportError = createSelector(
+  [selectImportWorkbook, selectGetImportProgress],
+  (importWorkbook2, getImportProgress2) => importWorkbook2.error || getImportProgress2.error
+);
+const selectImportWorkbookStatus = createSelector(
+  [selectGetImportProgress],
+  (getImportProgress2) => getStatusFromOperation({
+    progessOperation: getImportProgress2
+  })
+);
+const selectExportData = createSelector(
+  [selectExportWorkbook],
+  (exportWorkbook2) => exportWorkbook2.data
+);
+createSelector(
+  [selectGetExportResult],
+  (getExportResult2) => getExportResult2.data
+);
+createSelector(
+  [selectGetExportResult],
+  (getExportResult2) => getExportResult2.isLoading
+);
+const selectRootPermissionsData = createSelector(
+  [selectGetRootCollectionPermissions],
+  (permissions) => permissions.data
+);
+const selectCollectionIsLoading = createSelector(
+  [selectGetCollection],
+  (getCollection2) => getCollection2.isLoading
+);
+const selectCollectionData = createSelector(
+  [selectGetCollection],
+  (getCollection2) => getCollection2.data
+);
+const selectBreadcrumbsIsLoading = createSelector(
+  [selectGetCollectionBreadcrumbs],
+  (getCollectionBreadcrumbs2) => getCollectionBreadcrumbs2.isLoading
+);
+const selectBreadcrumbs = createSelector(
+  [selectGetCollectionBreadcrumbs],
+  (getCollectionBreadcrumbs2) => getCollectionBreadcrumbs2.data ?? []
+);
+const selectStructureItemsIsLoading = createSelector(
+  [selectGetStructureItems],
+  (getStructureItems2) => getStructureItems2.isLoading
+);
+const selectStructureItemsError = createSelector(
+  [selectGetStructureItems],
+  (getStructureItems2) => getStructureItems2.error
+);
+const selectNextPageToken = createSelector(
+  [selectGetStructureItems],
+  (content) => content.data?.nextPageToken || null
+);
+createSelector(
+  [selectCopyTemplate],
+  (copyTemplate) => copyTemplate.isLoading
+);
+const selectCreateCollectionIsLoading = createSelector(
+  [selectCreateCollection],
+  (createCollection2) => createCollection2.isLoading
+);
+const selectCreateWorkbookIsLoading = createSelector(
+  [selectCreateWorkbook],
+  (createWorkbook2) => createWorkbook2.isLoading
+);
+const selectMoveIsLoading = createSelector(
+  [selectMoveCollection, selectMoveWorkbook, selectMoveSharedEntry],
+  (moveCollection, moveWorkbook2, moveSharedEntry) => moveCollection.isLoading || moveWorkbook2.isLoading || moveSharedEntry.isLoading
+);
+const selectCopyWorkbookIsLoading = createSelector(
+  [selectCopyWorkbook],
+  (copyWorkbook2) => copyWorkbook2.isLoading
+);
+createSelector(
+  selectUpdateCollection,
+  (result) => result.isLoading
+);
+const selectUpdateWorkbookIsLoading = createSelector(
+  selectUpdateWorkbook,
+  (result) => result.isLoading
+);
+createSelector(
+  [selectDeleteCollections, selectDeleteWorkbooks],
+  (deleteCollections, deleteWorkbooks) => deleteCollections.isLoading || deleteWorkbooks.isLoading
+);
+createSelector(
+  selectDeleteCollection,
+  (result) => result.isLoading
+);
+const selectDeleteWorkbookIsLoading = createSelector(
+  selectDeleteWorkbook,
+  (result) => result.isLoading
+);
+const PAGE_SIZE$1 = 50;
+const DEFAULT_FILTERS = {
+  filterString: void 0,
+  orderField: "createdAt",
+  orderDirection: "desc",
+  mode: "all",
+  onlyMy: false
+};
+const useCollectionStructureDialogState = ({
+  includePermissionsInfo,
+  initialCollectionId,
+  open
+}) => {
+  const dispatch = useDispatch();
+  const [filters, setFilters] = React__default.useState(DEFAULT_FILTERS);
+  const [targetCollectionId, setTargetCollectionId] = React__default.useState(initialCollectionId);
+  const [targetWorkbookId, setTargetWorkbookId] = React__default.useState(null);
+  const getStructureItemsRecursively = React__default.useCallback(
+    (args) => {
+      let curPage = args.page;
+      return dispatch(getStructureItems({ ...args, includePermissionsInfo })).then((result) => {
+        if (result?.items.length === 0 && result.nextPageToken !== null) {
+          curPage = result.nextPageToken;
+          return getStructureItemsRecursively({
+            ...args,
+            includePermissionsInfo,
+            page: curPage
+          });
+        } else {
+          return result;
+        }
+      });
+    },
+    [dispatch, includePermissionsInfo]
+  );
+  const handleChangeCollection = React__default.useCallback((newValue) => {
+    setTargetCollectionId(newValue);
+    setTargetWorkbookId(null);
+    setFilters((prevFilters) => ({ ...prevFilters, filterString: void 0 }));
+  }, []);
+  const handleChangeWorkbook = React__default.useCallback((newValue) => {
+    setTargetWorkbookId(newValue);
+  }, []);
+  const fetchData = React__default.useCallback(() => {
+    const promises = [];
+    dispatch(resetStructureItems());
+    promises.push(
+      getStructureItemsRecursively({
+        collectionId: targetCollectionId,
+        pageSize: PAGE_SIZE$1,
+        ...filters
+      })
+    );
+    if (targetCollectionId) {
+      promises.push(dispatch(getCollection({ collectionId: targetCollectionId })));
+      promises.push(dispatch(getCollectionBreadcrumbs({ collectionId: targetCollectionId })));
+    } else {
+      dispatch(resetCollectionBreadcrumbs());
+    }
+    return promises;
+  }, [dispatch, filters, getStructureItemsRecursively, targetCollectionId]);
+  React__default.useEffect(() => {
+    setTargetCollectionId(initialCollectionId);
+  }, [initialCollectionId]);
+  React__default.useEffect(() => {
+    const promises = [];
+    if (open) {
+      dispatch(resetState());
+      promises.push(dispatch(getRootCollectionPermissions()));
+    }
+    return () => {
+      promises.forEach((promise) => {
+        promise.cancel();
+      });
+    };
+  }, [dispatch, open]);
+  React__default.useEffect(() => {
+    const promises = [];
+    if (open) {
+      promises.push(...fetchData());
+    }
+    return () => {
+      promises.forEach((promise) => {
+        promise.cancel();
+      });
+    };
+  }, [fetchData, open]);
+  return {
+    getStructureItemsRecursively,
+    filters,
+    setFilters,
+    targetCollectionId,
+    handleChangeCollection,
+    targetWorkbookId,
+    handleChangeWorkbook
+  };
+};
+const i18n$k = I18n.keyset("component.collections-structure");
+const b$9 = block("dl-collections-structure-create-entity-dialog");
+const CreateEntityDialog = React__default.memo(
+  ({ open, title, isLoading, defaultTitleValue, onApply, onClose }) => {
+    const [titleValue, setTitleValue] = React__default.useState(defaultTitleValue ?? "");
+    const handleApply = React__default.useCallback(() => {
+      onApply(titleValue).then(() => {
+        onClose();
+      });
+    }, [onApply, onClose, titleValue]);
+    React__default.useEffect(() => {
+      if (open) {
+        setTitleValue(defaultTitleValue ?? "");
+      }
+    }, [open, defaultTitleValue]);
+    return /* @__PURE__ */ jsxs(
+      Dialog,
+      {
+        className: b$9(),
+        size: "s",
+        open,
+        onClose,
+        onEnterKeyDown: handleApply,
+        children: [
+          /* @__PURE__ */ jsx(Dialog.Header, { caption: title }),
+          /* @__PURE__ */ jsx(Dialog.Body, { children: /* @__PURE__ */ jsxs("div", { className: b$9("field"), children: [
+            /* @__PURE__ */ jsx("div", { className: b$9("title"), children: i18n$k("label_title") }),
+            /* @__PURE__ */ jsx(TextInput, { value: titleValue, onUpdate: setTitleValue, autoFocus: true })
+          ] }) }),
+          /* @__PURE__ */ jsx(
+            Dialog.Footer,
+            {
+              onClickButtonCancel: onClose,
+              onClickButtonApply: handleApply,
+              textButtonApply: i18n$k("action_create"),
+              propsButtonApply: {
+                disabled: !titleValue
+              },
+              textButtonCancel: i18n$k("action_cancel"),
+              loading: isLoading
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+CreateEntityDialog.displayName = "CreateEntityDialog";
+const i18n$j = I18n.keyset("component.collections-structure");
+const NewTitleDialog = React__default.memo(
+  ({ open, isLoading, defaultTitle, textButtonApply, onApply, onClose }) => {
+    const [titleValue, setTitleValue] = React__default.useState(defaultTitle);
+    const handleApply = React__default.useCallback(() => {
+      if (titleValue) {
+        onApply(titleValue);
+        onClose();
+      }
+    }, [onApply, onClose, titleValue]);
+    React__default.useEffect(() => {
+      if (open) {
+        setTitleValue(defaultTitle);
+      }
+    }, [open, defaultTitle]);
+    return /* @__PURE__ */ jsxs(Dialog, { size: "s", open, onClose, onEnterKeyDown: handleApply, children: [
+      /* @__PURE__ */ jsx(Dialog.Header, { caption: i18n$j("label_title") }),
+      /* @__PURE__ */ jsx(Dialog.Body, { children: /* @__PURE__ */ jsx(TextInput, { value: titleValue, onUpdate: setTitleValue, autoFocus: true }) }),
+      /* @__PURE__ */ jsx(
+        Dialog.Footer,
+        {
+          onClickButtonCancel: onClose,
+          onClickButtonApply: handleApply,
+          textButtonApply,
+          propsButtonApply: {
+            disabled: !titleValue
+          },
+          textButtonCancel: i18n$j("action_cancel"),
+          loading: isLoading
+        }
+      )
+    ] });
+  }
+);
+NewTitleDialog.displayName = "NewTitleDialog";
+const b$8 = block("dl-collections-structure-collection-select-item");
+const ItemIcon = ({ item }) => {
+  const theme = useThemeType();
+  switch (item.entity) {
+    case CollectionItemEntities.WORKBOOK:
+      return /* @__PURE__ */ jsx(WorkbookIcon, { title: item.title, size: "s" });
+    case CollectionItemEntities.COLLECTION:
+      return /* @__PURE__ */ jsx(
+        IconById,
+        {
+          id: theme === "dark" ? "collectionColoredDark" : "collectionColored",
+          size: 20
+        }
+      );
+    case CollectionItemEntities.ENTRY:
+      return /* @__PURE__ */ jsx(
+        EntryIcon,
+        {
+          entry: item,
+          entityIconProps: {
+            classNameColorBox: "custom-color-box"
+          },
+          className: b$8("entry-icon")
+        }
+      );
+    default:
+      return null;
+  }
+};
+const Item = React__default.memo(({ item, active, canSelectWorkbook, inactive, onSelect }) => {
+  const isWorkbook = item.entity === CollectionItemEntities.WORKBOOK;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: b$8({
+        inactive: inactive || Boolean(isWorkbook && !canSelectWorkbook),
+        active: Boolean(isWorkbook && canSelectWorkbook && active)
+      }),
+      onClick: () => {
+        onSelect(item);
+      },
+      "data-qa": DialogCollectionStructureQa.ListItem,
+      children: [
+        /* @__PURE__ */ jsx("div", { className: b$8("icon"), children: /* @__PURE__ */ jsx(ItemIcon, { item }) }),
+        /* @__PURE__ */ jsx("div", { className: b$8("title"), children: item.title })
+      ]
+    }
+  );
+});
+Item.displayName = "Item";
+const iconInfo = "data:image/svg+xml,%3csvg%20width='14'%20height='14'%20viewBox='0%200%2014%2014'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cpath%20d='M7%20.828C3.521.828.703%203.672.703%207.125A6.296%206.296%200%200%200%207%2013.422c3.453%200%206.297-2.819%206.297-6.297C13.297%203.672%2010.453.828%207%20.828Zm0%2011.375a5.06%205.06%200%200%201-5.078-5.078A5.077%205.077%200%200%201%207%202.047c2.793%200%205.078%202.285%205.078%205.078A5.077%205.077%200%200%201%207%2012.203Zm0-8.582c-.61%200-1.066.483-1.066%201.067%200%20.609.457%201.066%201.066%201.066.584%200%201.066-.457%201.066-1.066%200-.584-.482-1.067-1.066-1.067Zm1.422%206.45v-.61a.328.328%200%200%200-.305-.305h-.305V6.617a.328.328%200%200%200-.304-.304H5.883a.309.309%200%200%200-.305.304v.61c0%20.177.127.304.305.304h.304v1.625h-.304a.309.309%200%200%200-.305.305v.61c0%20.177.127.304.305.304h2.234a.309.309%200%200%200%20.305-.305Z'%20fill='currentColor'/%3e%3c/svg%3e";
+const i18n$i = I18n.keyset("component.collections-structure");
+const b$7 = block("dl-collections-structure-structure-item-select");
+const StructureItemSelect = React__default.memo(
+  ({
+    collectionId,
+    workbookId,
+    contentIsLoading,
+    contentError,
+    breadcrumbs,
+    items,
+    nextPageToken,
+    pageSize,
+    isSelectionAllowed,
+    operationDeniedMessage,
+    canSelectWorkbook,
+    disabled,
+    getStructureItemsRecursively,
+    onChangeCollection,
+    getIsInactiveItem,
+    onChangeWorkbook = () => {
+    },
+    onSelectEntry = () => {
+    }
+  }) => {
+    const [waypointDisabled, setWaypointDisabled] = React__default.useState(false);
+    React__default.useEffect(() => {
+      if (contentError) {
+        setWaypointDisabled(true);
+      }
+    }, [contentError]);
+    const onWaypointEnter = React__default.useCallback(() => {
+      if (nextPageToken) {
+        getStructureItemsRecursively({
+          collectionId,
+          page: nextPageToken,
+          pageSize
+        }).then((res) => {
+          if (res?.nextPageToken && res?.nextPageToken === nextPageToken) {
+            setWaypointDisabled(true);
+          }
+          return res;
+        });
+      }
+    }, [collectionId, getStructureItemsRecursively, nextPageToken, pageSize]);
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: b$7({
+          disabled,
+          "denied-and-empty": !isSelectionAllowed && !items.length
+        }),
+        children: contentIsLoading && items.length === 0 ? /* @__PURE__ */ jsx("div", { className: b$7("main-loader"), children: /* @__PURE__ */ jsx(SmartLoader, { size: "m", showAfter: 0 }) }) : /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+          /* @__PURE__ */ jsx("div", { className: b$7("breadcrumbs"), children: /* @__PURE__ */ jsx(
+            CollectionsStructureBreadcrumbs,
+            {
+              items: breadcrumbs,
+              onChange: onChangeCollection
+            }
+          ) }),
+          !isSelectionAllowed && /* @__PURE__ */ jsx("div", { className: b$7("denied-message-wrapper"), children: /* @__PURE__ */ jsx(Card, { theme: "info", type: "container", view: "filled", children: /* @__PURE__ */ jsxs("div", { className: b$7("denied-message"), children: [
+            /* @__PURE__ */ jsx("div", { className: b$7("denied-message-icon"), children: /* @__PURE__ */ jsx(Icon, { data: iconInfo, size: 15 }) }),
+            /* @__PURE__ */ jsx("div", { className: b$7("denied-message-text"), children: operationDeniedMessage })
+          ] }) }) }),
+          items.length > 0 ? /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+            /* @__PURE__ */ jsx("div", { className: b$7("items"), children: items.map((item) => {
+              const isInactive = getIsInactiveItem?.(item) ?? false;
+              return /* @__PURE__ */ jsx(
+                Item,
+                {
+                  inactive: isInactive,
+                  item,
+                  active: "workbookId" in item && canSelectWorkbook && item.workbookId === workbookId,
+                  canSelectWorkbook,
+                  onSelect: (selectedItem) => {
+                    switch (selectedItem.entity) {
+                      case CollectionItemEntities.WORKBOOK:
+                        if (canSelectWorkbook) {
+                          onChangeWorkbook(
+                            selectedItem.workbookId
+                          );
+                        }
+                        break;
+                      case CollectionItemEntities.COLLECTION:
+                        onChangeCollection(
+                          selectedItem.collectionId
+                        );
+                        break;
+                      case CollectionItemEntities.ENTRY:
+                        if (!isInactive) {
+                          onSelectEntry(selectedItem);
+                        }
+                        break;
+                    }
+                  }
+                },
+                "workbookId" in item ? item.workbookId : item.collectionId
+              );
+            }) }),
+            contentIsLoading && /* @__PURE__ */ jsx("div", { className: b$7("page-loader"), children: /* @__PURE__ */ jsx(Loader, { size: "m" }) }),
+            !contentIsLoading && !waypointDisabled && /* @__PURE__ */ jsx(Waypoint, { onEnter: onWaypointEnter })
+          ] }) : /* @__PURE__ */ jsx(
+            PlaceholderIllustration,
+            {
+              title: i18n$i("label_empty-collection"),
+              name: "emptyDirectory",
+              direction: "column"
+            }
+          )
+        ] })
+      }
+    );
+  }
+);
+StructureItemSelect.displayName = "StructureItemSelect";
+const i18n$h = I18n.keyset("component.collections-structure");
+const b$6 = block("dl-collection-structure-dialog");
+const PAGE_SIZE = 50;
+var ResourceType = /* @__PURE__ */ ((ResourceType2) => {
+  ResourceType2["Collection"] = "collection";
+  ResourceType2["Workbook"] = "workbook";
+  return ResourceType2;
+})(ResourceType || {});
+const CollectionStructureDialog = React__default.memo(
+  ({
+    open,
+    type,
+    initialCollectionId,
+    defaultTitle = "",
+    defaultNewWorkbookTitle = "",
+    operationDeniedMessage,
+    canSelectInitialCollectionId = true,
+    caption,
+    textButtonApply,
+    applyIsLoading = false,
+    closeDialogAfterSuccessfulApply = true,
+    workbookSelectionMode,
+    massMoveMode,
+    onApply,
+    onClose,
+    additionalButtons,
+    useCustomDialog
+  }) => {
+    const {
+      targetCollectionId,
+      filters,
+      setFilters,
+      getStructureItemsRecursively,
+      handleChangeCollection,
+      targetWorkbookId,
+      handleChangeWorkbook
+    } = useCollectionStructureDialogState({
+      open,
+      initialCollectionId,
+      includePermissionsInfo: workbookSelectionMode
+    });
+    const dispatch = useDispatch();
+    const rootPermissionsData = useSelector(selectRootPermissionsData);
+    const collectionIsLoading = useSelector(selectCollectionIsLoading);
+    const collectionData = useSelector(selectCollectionData);
+    const breadcrumbsIsLoading = useSelector(selectBreadcrumbsIsLoading);
+    const breadcrumbs = useSelector(selectBreadcrumbs);
+    const structureItems = useSelector(selectFilteredStructureItems);
+    const structureItemsIsLoading = useSelector(selectStructureItemsIsLoading);
+    const structureItemsError = useSelector(selectStructureItemsError);
+    const nextPageToken = useSelector(selectNextPageToken);
+    const createCollectionIsLoading = useSelector(selectCreateCollectionIsLoading);
+    const createWorkbookIsLoading = useSelector(selectCreateWorkbookIsLoading);
+    const [createCollectionDialogIsOpen, setCreateCollectionDialogIsOpen] = React__default.useState(false);
+    const [createWorkbookDialogIsOpen, setCreateWorkbookDialogIsOpen] = React__default.useState(false);
+    const [structureChanged, setStructureChanged] = React__default.useState(false);
+    const [newTitleDialogIsOpen, setNewTitleDialogIsOpen] = React__default.useState(false);
+    const handleClose = React__default.useCallback(() => {
+      onClose(structureChanged);
+    }, [structureChanged, onClose]);
+    const canCreateCollection = React__default.useMemo(() => {
+      if (targetCollectionId) {
+        return collectionData?.permissions.createCollection || false;
+      }
+      return rootPermissionsData?.createCollectionInRoot || false;
+    }, [targetCollectionId, rootPermissionsData, collectionData]);
+    const canCreateWorkbook = React__default.useMemo(() => {
+      if (targetCollectionId) {
+        return collectionData?.permissions.createWorkbook || false;
+      }
+      return rootPermissionsData?.createWorkbookInRoot || false;
+    }, [targetCollectionId, rootPermissionsData, collectionData]);
+    const isSelectionAllowed = React__default.useMemo(() => {
+      if (workbookSelectionMode) {
+        return true;
+      }
+      let result = true;
+      if (targetCollectionId && collectionData) {
+        result = (type === "collection" ? collectionData?.permissions.createCollection : collectionData?.permissions.createWorkbook) ?? false;
+      } else if (rootPermissionsData) {
+        result = (type === "collection" ? rootPermissionsData?.createCollectionInRoot : rootPermissionsData?.createWorkbookInRoot) ?? false;
+      }
+      return result;
+    }, [collectionData, rootPermissionsData, targetCollectionId, type, workbookSelectionMode]);
+    let applyButtonDisabled = collectionIsLoading || !isSelectionAllowed;
+    if (!applyButtonDisabled) {
+      if (workbookSelectionMode) {
+        if (targetWorkbookId) {
+          const targetWorkbook = structureItems.find(
+            (item) => "workbookId" in item && item.workbookId === targetWorkbookId
+          );
+          if (targetWorkbook) {
+            applyButtonDisabled = targetWorkbook?.permissions.update !== true;
+          } else {
+            applyButtonDisabled = true;
+          }
+        } else {
+          applyButtonDisabled = true;
+        }
+      } else if (!canSelectInitialCollectionId) {
+        applyButtonDisabled = targetCollectionId === initialCollectionId;
+      }
+    }
+    const handleClickApplyButton = React__default.useCallback(() => {
+      if (!applyButtonDisabled) {
+        if (workbookSelectionMode) {
+          onApply({ targetCollectionId: null, targetWorkbookId }).then(() => {
+            if (closeDialogAfterSuccessfulApply) {
+              handleClose();
+            }
+          });
+        } else if (massMoveMode) {
+          onApply({ targetCollectionId, targetWorkbookId: null }).then(() => {
+            if (closeDialogAfterSuccessfulApply) {
+              handleClose();
+            }
+          });
+        } else if (useCustomDialog) {
+          onApply({ targetCollectionId, targetWorkbookId });
+        } else {
+          setNewTitleDialogIsOpen(true);
+        }
+      }
+    }, [
+      applyButtonDisabled,
+      workbookSelectionMode,
+      massMoveMode,
+      useCustomDialog,
+      onApply,
+      targetWorkbookId,
+      closeDialogAfterSuccessfulApply,
+      handleClose,
+      targetCollectionId
+    ]);
+    const handleApply = React__default.useCallback(
+      (targetTitle) => {
+        onApply({ targetCollectionId, targetWorkbookId, targetTitle }).then(() => {
+          if (closeDialogAfterSuccessfulApply) {
+            handleClose();
+          }
+        });
+      },
+      [
+        onApply,
+        handleClose,
+        targetCollectionId,
+        targetWorkbookId,
+        closeDialogAfterSuccessfulApply
+      ]
+    );
+    return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+      /* @__PURE__ */ jsxs(
+        Dialog,
+        {
+          className: b$6(),
+          size: "m",
+          open,
+          onClose: handleClose,
+          onEnterKeyDown: handleClickApplyButton,
+          disableHeightTransition: true,
+          children: [
+            /* @__PURE__ */ jsx(Dialog.Header, { caption }),
+            /* @__PURE__ */ jsxs(Dialog.Body, { children: [
+              /* @__PURE__ */ jsx(
+                CollectionFilters,
+                {
+                  className: b$6("filters"),
+                  filters,
+                  onChange: setFilters,
+                  compactMode: true
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                StructureItemSelect,
+                {
+                  collectionId: targetCollectionId,
+                  workbookId: targetWorkbookId,
+                  contentIsLoading: structureItemsIsLoading || breadcrumbsIsLoading,
+                  contentError: structureItemsError,
+                  breadcrumbs,
+                  items: structureItems,
+                  nextPageToken,
+                  pageSize: PAGE_SIZE,
+                  isSelectionAllowed,
+                  canSelectWorkbook: workbookSelectionMode,
+                  operationDeniedMessage,
+                  getStructureItemsRecursively,
+                  onChangeCollection: handleChangeCollection,
+                  onChangeWorkbook: handleChangeWorkbook,
+                  disabled: applyIsLoading
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsx(
+              Dialog.Footer,
+              {
+                onClickButtonCancel: handleClose,
+                onClickButtonApply: handleClickApplyButton,
+                textButtonApply,
+                propsButtonApply: {
+                  disabled: applyButtonDisabled,
+                  qa: DialogCollectionStructureQa.ApplyButton
+                },
+                textButtonCancel: i18n$h("action_cancel"),
+                loading: applyIsLoading,
+                children: /* @__PURE__ */ jsxs("div", { className: b$6("footer-buttons"), children: [
+                  canCreateCollection && !workbookSelectionMode && /* @__PURE__ */ jsx(
+                    Button,
+                    {
+                      size: "l",
+                      view: "outlined",
+                      onClick: () => {
+                        setCreateCollectionDialogIsOpen(true);
+                      },
+                      children: i18n$h("action_create-collection")
+                    }
+                  ),
+                  canCreateWorkbook && workbookSelectionMode && /* @__PURE__ */ jsx(
+                    Button,
+                    {
+                      size: "l",
+                      view: "outlined",
+                      onClick: () => {
+                        setCreateWorkbookDialogIsOpen(true);
+                      },
+                      children: i18n$h("action_create-workbook")
+                    }
+                  ),
+                  additionalButtons
+                ] })
+              }
+            )
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        NewTitleDialog,
+        {
+          open: newTitleDialogIsOpen,
+          isLoading: applyIsLoading,
+          defaultTitle,
+          textButtonApply,
+          onApply: (targetTitle) => {
+            handleApply(targetTitle);
+          },
+          onClose: () => {
+            setNewTitleDialogIsOpen(false);
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        CreateEntityDialog,
+        {
+          open: createCollectionDialogIsOpen,
+          title: i18n$h("action_create-collection"),
+          isLoading: createCollectionIsLoading,
+          onApply: async (title) => {
+            await dispatch(createCollection({ title, parentId: targetCollectionId }));
+            setStructureChanged(true);
+            dispatch(resetStructureItems());
+            getStructureItemsRecursively({
+              collectionId: targetCollectionId,
+              pageSize: PAGE_SIZE,
+              ...filters
+            });
+          },
+          onClose: () => {
+            setCreateCollectionDialogIsOpen(false);
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        CreateEntityDialog,
+        {
+          open: createWorkbookDialogIsOpen,
+          title: i18n$h("action_create-workbook"),
+          isLoading: createWorkbookIsLoading,
+          defaultTitleValue: defaultNewWorkbookTitle,
+          onApply: async (title) => {
+            await dispatch(createWorkbook({ title, collectionId: targetCollectionId }));
+            setStructureChanged(true);
+            dispatch(resetStructureItems());
+            getStructureItemsRecursively({
+              collectionId: targetCollectionId,
+              pageSize: PAGE_SIZE,
+              ...filters
+            });
+          },
+          onClose: () => {
+            setCreateWorkbookDialogIsOpen(false);
+          }
+        }
+      )
+    ] });
+  }
+);
+CollectionStructureDialog.displayName = "CollectionStructureDialog";
+const i18n$g = I18n.keyset("component.collections-structure");
+const DIALOG_MOVE_WORKBOOK = /* @__PURE__ */ Symbol("DIALOG_MOVE_WORKBOOK");
+const MoveWorkbookDialog = ({
+  open,
+  workbookId,
+  workbookTitle,
+  initialCollectionId = null,
+  onApply,
+  onClose
+}) => {
+  const dispatch = useDispatch();
+  const moveIsLoading = useSelector(selectMoveIsLoading);
+  const handleMoveWorkbook = React__default.useCallback(
+    async ({
+      targetCollectionId,
+      targetTitle
+    }) => {
+      await dispatch(
+        moveWorkbook({
+          workbookId,
+          collectionId: targetCollectionId,
+          title: targetTitle ?? workbookTitle
+        })
+      );
+      onApply();
+    },
+    [workbookId, workbookTitle, onApply, dispatch]
+  );
+  return /* @__PURE__ */ jsx(
+    CollectionStructureDialog,
+    {
+      open,
+      type: ResourceType.Workbook,
+      initialCollectionId,
+      defaultTitle: workbookTitle,
+      canSelectInitialCollectionId: false,
+      caption: i18n$g("label_move"),
+      textButtonApply: i18n$g("action_move"),
+      operationDeniedMessage: i18n$g("label_move-denied-title"),
+      applyIsLoading: moveIsLoading,
+      workbookSelectionMode: false,
+      onApply: handleMoveWorkbook,
+      onClose
+    }
+  );
+};
+DialogManager.registerDialog(DIALOG_MOVE_WORKBOOK, MoveWorkbookDialog);
+const i18n$f = I18n.keyset("component.collections-structure");
+const DeleteDialog = React__default.memo(
+  ({ title, description, textButtonApply, open, isLoading, onApply, onClose }) => {
+    const handleApply = React__default.useCallback(() => {
+      onApply().then(() => {
+        onClose();
+      });
+    }, [onApply, onClose]);
+    return /* @__PURE__ */ jsx(
+      DialogConfirm,
+      {
+        visible: open,
+        onCancel: onClose,
+        confirmOnEnterPress: true,
+        onApply: handleApply,
+        confirmHeaderText: title,
+        applyBtnLoadingStatus: isLoading ? DialogConfirmApplyStatus.Loading : void 0,
+        confirmButtonText: textButtonApply,
+        confirmButtonView: "outlined-danger",
+        cancelButtonView: "flat",
+        cancelButtonText: i18n$f("action_cancel"),
+        message: description,
+        showIcon: false,
+        isWarningConfirm: true
+      }
+    );
+  }
+);
+DeleteDialog.displayName = "DeleteDialog";
+const i18n$e = I18n.keyset("component.collections-structure");
+const DIALOG_COPY_WORKBOOK = /* @__PURE__ */ Symbol("DIALOG_COPY_WORKBOOK");
+const CopyWorkbookDialog = ({
+  open,
+  workbookId,
+  workbookTitle,
+  initialCollectionId = null,
+  onApply,
+  onClose
+}) => {
+  const dispatch = useDispatch();
+  const copyIsLoading = useSelector(selectCopyWorkbookIsLoading);
+  const handleCopyWorkbook = React__default.useCallback(
+    async ({
+      targetCollectionId,
+      targetTitle
+    }) => {
+      const result = await dispatch(
+        copyWorkbook({
+          workbookId,
+          collectionId: targetCollectionId,
+          title: targetTitle ?? workbookTitle
+        })
+      );
+      onApply(result?.workbookId);
+    },
+    [workbookId, workbookTitle, onApply, dispatch]
+  );
+  return /* @__PURE__ */ jsx(
+    CollectionStructureDialog,
+    {
+      open,
+      type: ResourceType.Workbook,
+      initialCollectionId,
+      defaultTitle: workbookTitle,
+      caption: i18n$e("label_copy"),
+      textButtonApply: i18n$e("action_copy"),
+      operationDeniedMessage: i18n$e("label_copy-denied-title"),
+      applyIsLoading: copyIsLoading,
+      workbookSelectionMode: false,
+      onApply: handleCopyWorkbook,
+      onClose
+    }
+  );
+};
+DialogManager.registerDialog(DIALOG_COPY_WORKBOOK, CopyWorkbookDialog);
+const i18n$d = I18n.keyset("component.collections-structure");
+const b$5 = block("dl-workbook-dialog");
+const WorkbookDialog = React__default.memo(
+  ({
+    values,
+    errors,
+    title,
+    textButtonApply,
+    open,
+    isLoading,
+    isHiddenDescription = false,
+    titleAutoFocus = false,
+    onChange,
+    onApply,
+    onClose,
+    customActions,
+    customBody,
+    getDialogFooterPropsOverride,
+    qa
+  }) => {
+    const handleChange = React__default.useCallback(
+      (params) => {
+        const { target } = params;
+        onChange({
+          ...values,
+          [target.name]: target.value
+        });
+      },
+      [onChange, values]
+    );
+    const handleApply = React__default.useCallback(() => {
+      onApply(values, onClose);
+    }, [onApply, values, onClose]);
+    const dialogFooterProps = React__default.useMemo(() => {
+      const defaultDialogFooterProps = {
+        onClickButtonCancel: onClose,
+        onClickButtonApply: handleApply,
+        textButtonApply,
+        propsButtonApply: {
+          disabled: !values.title,
+          qa: WorkbookDialogQA.APPLY_BUTTON
+        },
+        textButtonCancel: i18n$d("action_cancel"),
+        loading: isLoading,
+        qaApplyButton: WorkbookDialogQA.APPLY_BUTTON
+      };
+      return getDialogFooterPropsOverride ? getDialogFooterPropsOverride(defaultDialogFooterProps) : defaultDialogFooterProps;
+    }, [
+      getDialogFooterPropsOverride,
+      handleApply,
+      isLoading,
+      onClose,
+      textButtonApply,
+      values.title
+    ]);
+    const renderBody = () => {
+      if (customBody) {
+        return customBody;
+      }
+      return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+        /* @__PURE__ */ jsxs("div", { className: b$5("field"), children: [
+          /* @__PURE__ */ jsx("div", { className: b$5("title"), children: i18n$d("label_title") }),
+          /* @__PURE__ */ jsx(
+            TextInput,
+            {
+              name: "title",
+              error: errors?.title,
+              value: values.title,
+              onChange: handleChange,
+              autoFocus: titleAutoFocus,
+              qa: WorkbookDialogQA.TITLE_INPUT
+            }
+          )
+        ] }),
+        !isHiddenDescription && /* @__PURE__ */ jsxs("div", { className: b$5("field"), children: [
+          /* @__PURE__ */ jsx("div", { className: b$5("title"), children: i18n$d("label_description") }),
+          /* @__PURE__ */ jsx(
+            TextArea,
+            {
+              name: "description",
+              error: errors?.description,
+              value: values.description,
+              onChange: handleChange,
+              minRows: 2
+            }
+          )
+        ] }),
+        customActions
+      ] });
+    };
+    return /* @__PURE__ */ jsxs(
+      Dialog,
+      {
+        className: b$5(),
+        size: "s",
+        open,
+        onClose,
+        onEnterKeyDown: handleApply,
+        qa,
+        children: [
+          /* @__PURE__ */ jsx(Dialog.Header, { caption: title }),
+          /* @__PURE__ */ jsx(Dialog.Body, { children: renderBody() }),
+          /* @__PURE__ */ jsx(Dialog.Footer, { ...dialogFooterProps, loading: isLoading })
+        ]
+      }
+    );
+  }
+);
+WorkbookDialog.displayName = "WorkbookDialog";
+const useCollectionEntityDialogState = (initialValues) => {
+  const [values, setValues] = React__default.useState(initialValues);
+  const [errors, setErrors] = React__default.useState({});
+  const handleChange = React__default.useCallback((nextValues) => {
+    setValues((prevValues) => ({ ...prevValues, ...nextValues }));
+    setErrors((prevErrors) => {
+      if (Object.keys(prevErrors).length < 1) {
+        return prevErrors;
+      }
+      const nextDialogErrors = { ...prevErrors };
+      for (const fieldName in nextValues) {
+        if (fieldName in nextDialogErrors) {
+          delete nextDialogErrors[fieldName];
+        }
+      }
+      return nextDialogErrors;
+    });
+  }, []);
+  const handleError = React__default.useCallback((nextErrors) => {
+    setErrors((prevErrors) => ({
+      ...prevErrors,
+      ...nextErrors
+    }));
+  }, []);
+  return { values, errors, handleChange, handleError };
+};
+const i18n$c = I18n.keyset("component.collections-structure");
+const DIALOG_EDIT_WORKBOOK = /* @__PURE__ */ Symbol("DIALOG_EDIT_WORKBOOK");
+const EditWorkbookDialog = (props) => {
+  const dispatch = useDispatch();
+  const { title, description, open, onClose } = props;
+  const {
+    values: dialogValues,
+    errors: dialogErrors,
+    handleChange: handleDialogChange,
+    handleError: handleDialogError
+  } = useCollectionEntityDialogState({
+    title,
+    description
+  });
+  const isLoading = useSelector(selectUpdateWorkbookIsLoading);
+  const handleApply = React__default.useCallback(
+    async ({ title: dialogTitle, description: dialogDescription }, dialogOnClose) => {
+      const { workbookId, onApply } = props;
+      try {
+        const result = await dispatch(
+          updateWorkbook(
+            {
+              workbookId,
+              title: dialogTitle,
+              description: dialogDescription ?? ""
+            },
+            true
+          )
+        );
+        if (onApply) {
+          onApply(result);
+        }
+        dialogOnClose();
+      } catch (error) {
+        if (error.code === ErrorCode.WorkbookAlreadyExists) {
+          handleDialogError({ title: i18n$c("label_workbook-already-exists-error") });
+        }
+      }
+    },
+    [dispatch, handleDialogError, props]
+  );
+  return /* @__PURE__ */ jsx(
+    WorkbookDialog,
+    {
+      values: dialogValues,
+      errors: dialogErrors,
+      title: i18n$c("action_edit-workbook"),
+      textButtonApply: i18n$c("action_save"),
+      open,
+      isLoading,
+      titleAutoFocus: true,
+      onChange: handleDialogChange,
+      onApply: handleApply,
+      onClose
+    }
+  );
+};
+DialogManager.registerDialog(DIALOG_EDIT_WORKBOOK, EditWorkbookDialog);
+const i18n$b = I18n.keyset("component.workbook-export.notifications");
+const NOTIFICATIONS_BY_CODE = {
+  "NOTIF.WB_EXPORT.DS.RLS": i18n$b("label_export-rls"),
+  "NOTIF.WB_IMPORT.DS.RLS": i18n$b("label_import-rls"),
+  "NOTIF.WB_EXPORT.CONN.CHECK_CREDENTIALS": i18n$b("label_export-check-connection-credentials"),
+  "NOTIF.WB_IMPORT.CONN.CHECK_CREDENTIALS": i18n$b("label_import-check-connections-credentials"),
+  "NOTIF.WB_IMPORT.CONN.CHECK_DELEGATION": i18n$b("label_import-check-delegation"),
+  "ERR.UI_API.TRANSFER_INVALID_VERSION": i18n$b("label_invalid-version"),
+  "ERR.UI_API.TRANSFER_MISSING_LINKED_ENTRY": i18n$b("label_missing-linked-entry"),
+  "ERR.UI_API.TRANSFER_INVALID_ENTRY_DATA": i18n$b("label_invalid-entry-data"),
+  "ERR.UI_API.TRANSFER_INVALID_ENTRY_SCOPE": i18n$b("label_invalid-entry-scope"),
+  UNEXPECTED_WORKFLOW_ERROR: i18n$b("label_unexpected-workflow-error"),
+  SCOPE_NOT_AVAILABLE_FOR_INSTALLATION: i18n$b("label_scope-not-available-for-installation"),
+  "ERR.DS_API.BAD_CONN_TYPE": i18n$b("label_bad-connection-type"),
+  "ERR.DS_API.UNSUPPORTED": i18n$b("label_unsupported-objects"),
+  "ERR.DS_API.WB_EXPORT.DS": i18n$b("label_error-export-dataset"),
+  "ERR.DS_API.WB_EXPORT.CONN": i18n$b("label_error-export-connection"),
+  "ERR.DS_API.WB_IMPORT.DS": i18n$b("label_error-import-dataset"),
+  "ERR.DS_API.WB_IMPORT.CONN": i18n$b("label_error-import-connection")
+};
+const transformNotifications = (notifications = []) => {
+  const notificationMap = /* @__PURE__ */ new Map();
+  const details = [];
+  let hasCritical = false;
+  notifications.forEach((notification) => {
+    const key = notification.code;
+    if (notification.details) {
+      details.push(JSON.stringify(notification.details));
+    }
+    if (!notificationMap.has(key)) {
+      notificationMap.set(key, {
+        code: notification.code,
+        message: notification.message,
+        level: notification.level,
+        entries: []
+      });
+    }
+    if (notification.level === "critical") {
+      hasCritical = true;
+    }
+    if (notification.scope && notification.entryId) {
+      notificationMap.get(key)?.entries.push({
+        entryId: notification.entryId,
+        scope: notification.scope || "connection"
+      });
+    }
+  });
+  const preparedNotifications = Array.from(notificationMap.values());
+  const preparedDetails = details.length > 0 ? details.join("\n") : null;
+  if (hasCritical) {
+    return {
+      notifications: preparedNotifications.filter(
+        (notification) => notification.level === "critical"
+      ),
+      details: preparedDetails
+    };
+  }
+  return { notifications: preparedNotifications, details: preparedDetails };
+};
+const getNotificationTitle = (code, message) => {
+  if (!code) {
+    return message;
+  }
+  return NOTIFICATIONS_BY_CODE[code] || message || i18n$b("label_invalid-error");
+};
+const i18n$a = I18n.keyset("component.workbook-export.notifications");
+const useNotificationsAndDetails = ({
+  notifications,
+  exportId,
+  importId
+}) => {
+  const dispatch = useDispatch();
+  const [notificationDetails, setNotificationDetails] = React__default.useState(null);
+  const preparedNotifications = React__default.useMemo(() => {
+    if (!notifications) {
+      setNotificationDetails(null);
+      return [];
+    }
+    const { notifications: transformedNotifications, details } = transformNotifications(notifications);
+    setNotificationDetails(details);
+    return transformedNotifications;
+  }, [notifications]);
+  const handleShowDetails = React__default.useCallback(() => {
+    if (notificationDetails) {
+      dispatch(
+        openDialogErrorWithTabs({
+          title: i18n$a("title_error-details"),
+          details: notificationDetails,
+          exportId,
+          importId
+        })
+      );
+    }
+  }, [notificationDetails, dispatch, exportId, importId]);
+  return {
+    notificationDetails,
+    preparedNotifications,
+    handleShowDetails
+  };
+};
+const b$4 = block("workbook-dialog-import-file-field");
+const i18n$9 = I18n.keyset("component.collections-structure");
+const FileLabel = ({ filename, handler }) => {
+  return /* @__PURE__ */ jsx(
+    Label,
+    {
+      size: "m",
+      theme: "clear",
+      onCloseClick: handler,
+      type: "close",
+      className: b$4("file-label"),
+      title: filename,
+      children: /* @__PURE__ */ jsx(Text, { color: "complementary", variant: "body-1", children: filename })
+    }
+  );
+};
+const ImportFileField = ({
+  onUpload,
+  onRemove,
+  files,
+  error,
+  publicGalleryFile
+}) => {
+  const handleFileUploading = (file) => {
+    onUpload(file[0]);
+  };
+  const handleRemoveFile = (index) => {
+    onRemove(index);
+  };
+  const { triggerProps, controlProps } = useFileInput({ onUpdate: handleFileUploading });
+  const docsUrl = formDocsEndpointDL("/workbooks-collections/export-and-import");
+  return /* @__PURE__ */ jsxs(Flex, { spacing: { mt: 3 }, className: b$4(), gap: 2, direction: "column", alignItems: "flex-start", children: [
+    /* @__PURE__ */ jsxs(Flex, { gap: 1, children: [
+      /* @__PURE__ */ jsx(Text, { variant: "body-1", children: i18n$9("label_import-from-file") }),
+      /* @__PURE__ */ jsx(HelpMark, { children: /* @__PURE__ */ jsx(
+        InterpolatedText,
+        {
+          href: docsUrl,
+          disableLink: !docsUrl,
+          text: i18n$9("label_help-import-hint")
+        }
+      ) })
+    ] }),
+    /* @__PURE__ */ jsx("input", { ...controlProps, accept: ".json" }),
+    /* @__PURE__ */ jsxs(Flex, { gap: 2, width: "100%", children: [
+      /* @__PURE__ */ jsxs(Button, { ...triggerProps, children: [
+        /* @__PURE__ */ jsx(Icon, { data: Paperclip }),
+        " ",
+        i18n$9("button_choose-file")
+      ] }),
+      files.map((file, index) => /* @__PURE__ */ jsx(
+        FileLabel,
+        {
+          filename: file.name,
+          handler: () => handleRemoveFile(index)
+        },
+        file.name
+      )),
+      publicGalleryFile && /* @__PURE__ */ jsx(
+        FileLabel,
+        {
+          filename: publicGalleryFile,
+          handler: () => handleRemoveFile("publicGallery")
+        }
+      )
+    ] }),
+    error && /* @__PURE__ */ jsx(Text, { variant: "body-1", color: "danger", children: error })
+  ] });
+};
+const b$3 = block("entries-notification-cut");
+const getEntry = (entriesMap, entry) => {
+  if (!entry.entryId || !entriesMap) {
+    return {
+      entryId: entry.entryId,
+      scope: entry.scope,
+      name: entry.entryId
+    };
+  }
+  return entriesMap[entry.entryId];
+};
+const LEVEL_TO_THEME_MAP = {
+  critical: "danger",
+  warning: "warning",
+  info: "info",
+  success: "success"
+};
+const NotificationSummary = ({
+  title,
+  count
+}) => {
+  return /* @__PURE__ */ jsxs(
+    Flex,
+    {
+      justifyContent: "space-between",
+      alignItems: "center",
+      gap: 7,
+      grow: 1,
+      className: b$3("summary"),
+      children: [
+        /* @__PURE__ */ jsx(Text, { className: b$3("title"), variant: "subheader-1", children: title }),
+        /* @__PURE__ */ jsx(Text, { variant: "subheader-1", color: "secondary", className: spacing({ mr: 3 }), children: count })
+      ]
+    }
+  );
+};
+const EntriesNotificationCut = ({
+  level,
+  title,
+  code,
+  entries,
+  link,
+  entriesMap
+}) => {
+  const defaultExpanded = level === "critical";
+  const theme = LEVEL_TO_THEME_MAP[level] || "info";
+  const notificationTitle = getNotificationTitle(code, title);
+  return /* @__PURE__ */ jsxs(Flex, { gap: 3, className: b$3("cut"), children: [
+    /* @__PURE__ */ jsx(Label, { theme, size: "s", icon: /* @__PURE__ */ jsx(Icon, { data: CircleExclamation, size: 14 }) }),
+    entries?.length ? /* @__PURE__ */ jsxs(
+      Disclosure,
+      {
+        defaultExpanded,
+        arrowPosition: "end",
+        summary: /* @__PURE__ */ jsx(NotificationSummary, { title: notificationTitle, count: entries.length }),
+        className: b$3("disclosure"),
+        children: [
+          /* @__PURE__ */ jsx("div", { className: spacing({ mt: 3 }), children: entries.map((entry) => {
+            const resolvedEntry = getEntry(entriesMap, entry);
+            const overrideIconType = !("type" in resolvedEntry) && entry.scope === "connection" ? entry.scope : void 0;
+            return /* @__PURE__ */ jsx(
+              EntryRow,
+              {
+                entry: resolvedEntry,
+                overrideIconType
+              },
+              entry.entryId
+            );
+          }) }),
+          link && /* @__PURE__ */ jsx(Link, { href: link.url, className: spacing({ mt: 3 }), children: link.text })
+        ]
+      }
+    ) : /* @__PURE__ */ jsx(Flex, { alignItems: "center", className: b$3("summary"), children: /* @__PURE__ */ jsx(Text, { variant: "subheader-2", children: notificationTitle }) })
+  ] });
+};
+const b$2 = block("import-workbook-file-view");
+const i18n$8 = I18n.keyset("component.workbook-import-view.view");
+const notificationsI18n$2 = I18n.keyset("component.workbook-export.notifications");
+const ImportWorkbookView = ({ status, importId, onRetry }) => {
+  const importProgressData = useSelector(selectGetImportProgressData);
+  const notificationEntriesMap = useSelector(selectGetImportProgressEntriesMap);
+  const error = useSelector(selectImportError);
+  const progress = importProgressData?.progress;
+  const notifications = importProgressData?.notifications;
+  switch (status) {
+    case "pending":
+      return /* @__PURE__ */ jsx(ProgressBar, { size: "s", className: b$2("progress"), value: progress ?? 0 });
+    case "loading":
+      return /* @__PURE__ */ jsx(Flex, { alignItems: "center", justifyContent: "center", children: /* @__PURE__ */ jsx(Loader, { size: "m" }) });
+    case "success":
+    case "notification-error":
+      if (status === "success" && !notifications) {
+        return /* @__PURE__ */ jsx(EntriesNotificationCut, { title: i18n$8("label_success-import"), level: "success" });
+      }
+      {
+        const docsUrl = formDocsEndpointDL(
+          "/workbooks-collections/export-import-notifications"
+        );
+        const preparedNotifications = notifications ? transformNotifications(notifications).notifications : [];
+        return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+          /* @__PURE__ */ jsx(Flex, { direction: "column", gap: 4, children: preparedNotifications.map(({ code, level, entries }) => /* @__PURE__ */ jsx(
+            EntriesNotificationCut,
+            {
+              code,
+              level,
+              entries,
+              entriesMap: notificationEntriesMap
+            },
+            code
+          )) }),
+          docsUrl && /* @__PURE__ */ jsx(Link, { target: "_blank", href: docsUrl, className: spacing({ mt: 4 }), children: notificationsI18n$2("label_info-documentation-notifications") })
+        ] });
+      }
+    case "fatal-error":
+    default:
+      return /* @__PURE__ */ jsx(
+        ViewError,
+        {
+          showDebugInfo: false,
+          containerClassName: b$2("error-content"),
+          error,
+          size: "s",
+          importId,
+          retry: onRetry
+        }
+      );
+  }
+};
+const i18n$7 = I18n.keyset("component.workbook-import-view.view");
+const getApplyButtonText$1 = (status, defaultText) => {
+  switch (status) {
+    case "loading":
+    case "pending":
+      return defaultText;
+    case "success":
+      return i18n$7("button_go-to-workbook");
+    case "fatal-error":
+    case "notification-error":
+    default:
+      return void 0;
+  }
+};
+const getCaption$1 = (status) => {
+  switch (status) {
+    case "loading":
+    case "pending":
+      return i18n$7("title_creating-workbook");
+    case "fatal-error":
+    case "notification-error":
+      return i18n$7("title_error-creating");
+    case "success":
+      return i18n$7("title_workbook-created");
+    default:
+      return i18n$7("title_creating-workbook");
+  }
+};
+const getCancelButtonText = (status, defaultText) => {
+  return status === "loading" || status === "pending" ? defaultText : i18n$7("button_close");
+};
+const i18n$6 = I18n.keyset("component.collections-structure");
+const notificationsI18n$1 = I18n.keyset("component.workbook-export.notifications");
+const GET_IMPORT_PROGRESS_INTERVAL = 1e3;
+const DIALOG_CREATE_WORKBOOK = /* @__PURE__ */ Symbol("DIALOG_CREATE_WORKBOOK");
+const b$1 = block("create-workbook-dialog");
+const CreateWorkbookDialog = ({
+  collectionId,
+  open,
+  dialogTitle,
+  defaultWorkbookTitle,
+  onClose,
+  onCreateWorkbook,
+  onApply,
+  defaultView = "default",
+  importId,
+  showImport,
+  publicGallery,
+  onImportAttempt
+}) => {
+  const dispatch = useDispatch();
+  const [publicGalleryState, setPublicGalleryState] = React__default.useState(
+    publicGallery || null
+  );
+  const {
+    values: dialogValues,
+    errors: dialogErrors,
+    handleChange: handleDialogChange,
+    handleError: handleDialogError
+  } = useCollectionEntityDialogState({
+    title: publicGalleryState?.title || defaultWorkbookTitle || "",
+    description: publicGalleryState?.description || ""
+  });
+  const isCreatingLoading = useSelector(selectCreateWorkbookIsLoading);
+  const importStatus = useSelector(selectImportWorkbookStatus);
+  const importData = useSelector(selectImportWorkbookData);
+  const importProgressData = useSelector(selectGetImportProgressData);
+  const notifications = importProgressData?.notifications;
+  const currentImportId = importData?.importId || importProgressData?.importId;
+  const [isExternalLoading, setIsExternalLoading] = React__default.useState(false);
+  const isImportLoading = importStatus === "loading" || importStatus === "pending";
+  const isLoading = isCreatingLoading || isImportLoading || isExternalLoading;
+  const [view, setView] = React__default.useState(defaultView);
+  const [importFiles, setImportFiles] = React__default.useState([]);
+  const [importValidationError, setImportValidationError] = React__default.useState(null);
+  const importProgressTimeout = React__default.useRef(null);
+  const isMounted = useMountedState();
+  const { notificationDetails, handleShowDetails } = useNotificationsAndDetails({
+    notifications,
+    importId: importData?.importId
+  });
+  React__default.useEffect(() => {
+    if (open) {
+      dispatch(resetImportWorkbook());
+      setView(defaultView);
+      setImportFiles([]);
+      setImportValidationError(null);
+    }
+  }, [defaultView, dispatch, open]);
+  React__default.useEffect(() => {
+    if (importFiles[0] && importFiles[0].name.toLowerCase().endsWith(".json")) {
+      handleDialogChange({
+        title: importFiles[0].name.replace(/\.json$/i, "")
+      });
+    }
+  }, [defaultWorkbookTitle, handleDialogChange, importFiles]);
+  const pollImportStatus = React__default.useCallback(
+    async (currentImportId2) => {
+      if (importProgressTimeout.current) {
+        clearTimeout(importProgressTimeout.current);
+      }
+      if (!isMounted()) {
+        return;
+      }
+      const startTime = Date.now();
+      const result = await dispatch(getImportProgress({ importId: currentImportId2 }));
+      const elapsedTime = Date.now() - startTime;
+      if (result && result.status === "pending") {
+        const nextPollDelay = Math.max(0, GET_IMPORT_PROGRESS_INTERVAL - elapsedTime);
+        importProgressTimeout.current = setTimeout(
+          () => pollImportStatus(currentImportId2),
+          nextPollDelay
+        );
+      }
+    },
+    [dispatch, isMounted]
+  );
+  React__default.useEffect(() => {
+    if (importId) {
+      pollImportStatus(importId);
+    }
+  }, [pollImportStatus, importId]);
+  const handleFileUploding = (file) => {
+    setImportFiles([file]);
+    setImportValidationError(null);
+    setPublicGalleryState(null);
+  };
+  const handleRemoveFile = (index) => {
+    if (index === "publicGallery") {
+      setPublicGalleryState(null);
+      handleDialogChange({ title: "" });
+    } else {
+      setImportFiles((prev) => prev.filter((_, i) => i !== index));
+      setImportValidationError(null);
+    }
+  };
+  const handleClose = React__default.useCallback(() => {
+    if (importStatus === "loading" || importStatus === "pending") {
+      dispatch(
+        openDialog({
+          id: DIALOG_DEFAULT,
+          props: {
+            open: true,
+            onApply: () => {
+              dispatch(closeDialog());
+              onClose(true);
+            },
+            onCancel: () => dispatch(closeDialog()),
+            message: i18n$6("label_import-exit-description"),
+            textButtonApply: i18n$6("action_exit"),
+            textButtonCancel: i18n$6("action_stay"),
+            caption: i18n$6("title_import-exit"),
+            className: b$1("import-cancel-dialog")
+          }
+        })
+      );
+      return;
+    }
+    onClose(importStatus === "success");
+  }, [dispatch, importStatus, onClose]);
+  const handleCreateCallback = React__default.useCallback(
+    async (workbookId) => {
+      const onCreateCallback = onApply || onCreateWorkbook;
+      if (onCreateCallback) {
+        const promise = onCreateCallback({ workbookId });
+        if (promise) {
+          setIsExternalLoading(true);
+          await promise;
+          setIsExternalLoading(false);
+        }
+      }
+    },
+    [onApply, onCreateWorkbook]
+  );
+  const startImport = React__default.useCallback(
+    async (workbookData) => {
+      try {
+        setIsExternalLoading(true);
+        const importResult = await dispatch(
+          importWorkbook(
+            publicGalleryState ? { ...workbookData, publicGalleryUrl: publicGalleryState.data } : { ...workbookData, importFile: importFiles[0] },
+            true
+          )
+        );
+        setIsExternalLoading(false);
+        if (importResult && importResult.importId) {
+          setView("import");
+          pollImportStatus(importResult.importId);
+          onImportAttempt?.(Boolean(publicGalleryState));
+        }
+      } catch (error) {
+        if (error.code === ErrorCode.MetaManagerWorkbookAlreadyExists) {
+          handleDialogError({ title: i18n$6("label_workbook-already-exists-error") });
+          setIsExternalLoading(false);
+        }
+      }
+    },
+    [
+      dispatch,
+      handleDialogError,
+      importFiles,
+      pollImportStatus,
+      publicGalleryState,
+      onImportAttempt
+    ]
+  );
+  const handleApply = React__default.useCallback(
+    async ({ title: title2, description }, dialogOnClose) => {
+      if (isEnabledFeature(Feature.EnableExportWorkbookFile) && importStatus === "success") {
+        dialogOnClose();
+        handleCreateCallback(importProgressData?.workbookId);
+        return;
+      }
+      if (isEnabledFeature(Feature.EnableExportWorkbookFile) && importFiles.length > 0 && !importFiles[0].name.toLowerCase().endsWith(".json")) {
+        setImportValidationError(i18n$6("label_error-file-type"));
+        return;
+      }
+      const workbookData = {
+        title: title2,
+        description: description ?? "",
+        collectionId
+      };
+      if (isEnabledFeature(Feature.EnableExportWorkbookFile) && (importFiles.length > 0 || publicGalleryState)) {
+        startImport(workbookData);
+        return;
+      }
+      try {
+        const result = await dispatch(
+          createWorkbook(workbookData, true)
+        );
+        handleCreateCallback(result?.workbookId);
+        dialogOnClose();
+      } catch (error) {
+        if (error.code === ErrorCode.WorkbookAlreadyExists) {
+          handleDialogError({ title: i18n$6("label_workbook-already-exists-error") });
+        }
+      }
+    },
+    [
+      collectionId,
+      dispatch,
+      handleCreateCallback,
+      importFiles,
+      importProgressData?.workbookId,
+      importStatus,
+      handleDialogError,
+      publicGalleryState,
+      startImport
+    ]
+  );
+  const getDialogFooterPropsOverride = React__default.useCallback(
+    ({
+      propsButtonApply,
+      onClickButtonApply,
+      textButtonCancel,
+      textButtonApply,
+      qaApplyButton
+    }) => {
+      return {
+        onClickButtonCancel: handleClose,
+        onClickButtonApply,
+        textButtonApply: importStatus ? getApplyButtonText$1(importStatus, textButtonApply) : textButtonApply,
+        propsButtonApply: {
+          disabled: currentImportId ? false : propsButtonApply?.disabled,
+          loading: isLoading,
+          qa: qaApplyButton
+        },
+        propsButtonCancel: {
+          view: importStatus?.endsWith("error") ? "normal" : "flat",
+          disabled: isLoading && !isImportLoading
+        },
+        textButtonCancel: importStatus ? getCancelButtonText(importStatus, textButtonCancel) : textButtonCancel,
+        children: importStatus && notificationDetails ? /* @__PURE__ */ jsx(Button, { size: "l", view: "outlined", onClick: handleShowDetails, children: notificationsI18n$1("button_show-details") }) : void 0
+      };
+    },
+    [
+      currentImportId,
+      handleClose,
+      handleShowDetails,
+      importStatus,
+      isImportLoading,
+      isLoading,
+      notificationDetails
+    ]
+  );
+  const handleRetry = React__default.useCallback(() => {
+    if (importStatus === "fatal-error" && currentImportId) {
+      pollImportStatus(currentImportId);
+      return;
+    }
+  }, [currentImportId, importStatus, pollImportStatus]);
+  const renderImportSection = () => {
+    if (!isEnabledFeature(Feature.EnableExportWorkbookFile) || !showImport) {
+      return null;
+    }
+    let publicGalleryFile;
+    try {
+      publicGalleryFile = publicGalleryState?.data?.split("/").pop() || void 0;
+    } catch (error) {
+      toaster.add({
+        theme: "danger",
+        name: "toastAfterParsingGalleryData",
+        title: i18n$6("toast_get-gallery-file-error")
+      });
+    }
+    return /* @__PURE__ */ jsx(
+      ImportFileField,
+      {
+        onUpload: handleFileUploding,
+        onRemove: handleRemoveFile,
+        files: importFiles,
+        error: importValidationError,
+        publicGalleryFile
+      }
+    );
+  };
+  const renderDialogView = () => {
+    if (view === "import") {
+      const canProgressBeRetried = importStatus === "fatal-error" && currentImportId;
+      const handleRetryFn = canProgressBeRetried ? handleRetry : void 0;
+      return /* @__PURE__ */ jsx(Flex, { direction: "column", children: /* @__PURE__ */ jsx(
+        ImportWorkbookView,
+        {
+          onRetry: handleRetryFn,
+          status: importStatus,
+          importId: currentImportId
+        }
+      ) });
+    }
+    return null;
+  };
+  const defaultTitle = dialogTitle ?? i18n$6("action_create-workbook");
+  const title = importStatus ? getCaption$1(importStatus) : defaultTitle;
+  return /* @__PURE__ */ jsx(
+    WorkbookDialog,
+    {
+      values: dialogValues,
+      errors: dialogErrors,
+      title,
+      textButtonApply: i18n$6("action_create"),
+      open,
+      isLoading,
+      onChange: handleDialogChange,
+      onApply: handleApply,
+      onClose: handleClose,
+      titleAutoFocus: true,
+      customActions: renderImportSection(),
+      customBody: renderDialogView(),
+      getDialogFooterPropsOverride,
+      qa: importStatus === "success" ? WorkbookDialogQA.ROOT_IMPORT_SUCCESS : void 0
+    }
+  );
+};
+DialogManager.registerDialog(DIALOG_CREATE_WORKBOOK, CreateWorkbookDialog);
+const selectGetEntry = (state) => state.migrationToWorkbook.getEntry;
+const selectMigrateEntriesToWorkbook = (state) => state.migrationToWorkbook.migrateEntriesToWorkbook;
+const selectIsLoadingMigrateEntriesToWorkbook = createSelector(
+  [selectMigrateEntriesToWorkbook],
+  (migrate) => migrate.isLoading
+);
+const selectGetRelationsGraph = (state) => state.migrationToWorkbook.getRelationsGraph;
+const selectGetRelations = (state) => state.migrationToWorkbook.getRelations;
+const selectIsLoadingTargetEntry = createSelector(
+  [selectGetEntry],
+  (getEntry2) => getEntry2.isLoading
+);
+const selectTargetEntry = createSelector([selectGetEntry], (getEntry2) => getEntry2.data);
+const selectTargetEntryError = createSelector(
+  [selectGetEntry],
+  (getEntry2) => getEntry2.error
+);
+const selectIsLoadingRelationsGraph = createSelector(
+  [selectGetRelationsGraph],
+  (getRelationsGraph) => getRelationsGraph.isLoading
+);
+const selectRelationsGraph = createSelector(
+  [selectGetRelationsGraph],
+  (getRelationsGraph) => getRelationsGraph.data
+);
+const selectRelationsGraphError = createSelector(
+  [selectGetRelationsGraph],
+  (getRelationsGraph) => getRelationsGraph.error
+);
+const selectIsLoadingRelations = createSelector(
+  [selectGetRelations],
+  (getRelations) => getRelations.isLoading
+);
+const selectRelations = createSelector(
+  [selectGetRelations],
+  (getRelations) => getRelations.data
+);
+const selectRelationsError = createSelector(
+  [selectGetRelations],
+  (getRelations) => getRelations.error
+);
+const i18n$5 = I18n.keyset("component.collections-structure");
+const DIALOG_MIGRATE_ENTRY_TO_WORKBOOK = /* @__PURE__ */ Symbol("DIALOG_MIGRATE_ENTRY_TO_WORKBOOK");
+const MigrateEntryToWorkbookDialog = ({ open, onApply, onClose }) => {
+  const handleMigrateEntry = React__default.useCallback(
+    async ({
+      targetWorkbookId
+    }) => {
+      if (targetWorkbookId) {
+        await onApply(targetWorkbookId);
+      }
+    },
+    [onApply]
+  );
+  const isLoadingMigrateEntry = useSelector(selectIsLoadingMigrateEntriesToWorkbook);
+  return /* @__PURE__ */ jsx(
+    CollectionStructureDialog,
+    {
+      open,
+      type: ResourceType.Workbook,
+      initialCollectionId: null,
+      canSelectInitialCollectionId: false,
+      caption: i18n$5("label_move"),
+      textButtonApply: i18n$5("action_move"),
+      operationDeniedMessage: i18n$5("label_move-denied-title"),
+      applyIsLoading: isLoadingMigrateEntry,
+      workbookSelectionMode: true,
+      onApply: handleMigrateEntry,
+      onClose
+    }
+  );
+};
+DialogManager.registerDialog(DIALOG_MIGRATE_ENTRY_TO_WORKBOOK, MigrateEntryToWorkbookDialog);
+const i18n$4 = I18n.keyset("component.collections-structure");
+const DIALOG_COPY_ENTRIES = /* @__PURE__ */ Symbol("DIALOG_COPY_ENTRIES");
+const CopyEntriesDialog = ({
+  open,
+  initialCollectionId = null,
+  onApply,
+  onClose
+}) => {
+  const copyIsLoading = useSelector(selectCopyWorkbookIsLoading);
+  const handleEntryCopy = React__default.useCallback(
+    async ({ targetWorkbookId }) => {
+      if (targetWorkbookId) {
+        await onApply(targetWorkbookId);
+      }
+    },
+    [onApply]
+  );
+  return /* @__PURE__ */ jsx(
+    CollectionStructureDialog,
+    {
+      open,
+      type: ResourceType.Workbook,
+      initialCollectionId,
+      caption: i18n$4("label_copy"),
+      textButtonApply: i18n$4("action_copy"),
+      operationDeniedMessage: i18n$4("label_copy-denied-title"),
+      applyIsLoading: copyIsLoading,
+      workbookSelectionMode: true,
+      onApply: handleEntryCopy,
+      onClose
+    }
+  );
+};
+DialogManager.registerDialog(DIALOG_COPY_ENTRIES, CopyEntriesDialog);
+const i18n$3 = I18n.keyset("component.collections-structure");
+const DIALOG_DELETE_WORKBOOK = /* @__PURE__ */ Symbol("DIALOG_DELETE_WORKBOOK");
+const DeleteWorkbookDialog = ({
+  open,
+  workbookId,
+  workbookTitle,
+  onClose,
+  onSuccessApply
+}) => {
+  const dispatch = useDispatch();
+  const isLoading = useSelector(selectDeleteWorkbookIsLoading);
+  const onApply = React__default.useCallback(async () => {
+    const result = await dispatch(
+      deleteWorkbook({
+        workbookId
+      })
+    );
+    if (onSuccessApply) {
+      onSuccessApply(workbookId);
+    }
+    return result;
+  }, [dispatch, onSuccessApply, workbookId]);
+  return /* @__PURE__ */ jsx(
+    DeleteDialog,
+    {
+      title: i18n$3("label_delete-workbook"),
+      description: i18n$3("section_delete-workbook", {
+        name: workbookTitle
+      }),
+      textButtonApply: i18n$3("action_delete"),
+      open,
+      isLoading,
+      onApply,
+      onClose
+    }
+  );
+};
+DialogManager.registerDialog(DIALOG_DELETE_WORKBOOK, DeleteWorkbookDialog);
+const i18n$2 = I18n.keyset("component.collections-structure");
+const DIALOG_CREATE_ENTRY_IN_WORKBOOK = /* @__PURE__ */ Symbol("DIALOG_CREATE_ENTRY_IN_WORKBOOK");
+const CreateEntryInWorkbookDialog = ({
+  entryType,
+  closeDialogAfterSuccessfulApply,
+  disableHistoryPush = false,
+  initialCollectionId = null,
+  onClose,
+  onApply
+}) => {
+  const history = useHistory();
+  const handleCreateEntry = React__default.useCallback(
+    ({ targetWorkbookId }) => {
+      if (targetWorkbookId) {
+        if (!disableHistoryPush) {
+          switch (entryType) {
+            case "connection":
+              history.push(`/workbooks/${targetWorkbookId}/connections/new`);
+              break;
+            case "dataset":
+              history.push(`/workbooks/${targetWorkbookId}/datasets/new`);
+              break;
+            case "wizard":
+              history.push(`/workbooks/${targetWorkbookId}/wizard`);
+              break;
+            case "ql":
+              history.push(`/workbooks/${targetWorkbookId}/ql`);
+              break;
+            case "dashboard": {
+              history.push(`/workbooks/${targetWorkbookId}/dashboards`);
+              break;
+            }
+          }
+        }
+        if (onApply) {
+          onApply(targetWorkbookId);
+        }
+      }
+      return Promise.resolve();
+    },
+    [entryType, history, disableHistoryPush, onApply]
+  );
+  return /* @__PURE__ */ jsx(
+    CollectionStructureDialog,
+    {
+      open: true,
+      type: ResourceType.Workbook,
+      initialCollectionId,
+      caption: `${i18n$2("label_create-entry-in-workbook")} ${i18n$2(`label_${entryType}`)}`,
+      operationDeniedMessage: i18n$2("label_create-denied-title"),
+      textButtonApply: i18n$2("action_create"),
+      workbookSelectionMode: true,
+      closeDialogAfterSuccessfulApply,
+      onApply: handleCreateEntry,
+      onClose
+    }
+  );
+};
+DialogManager.registerDialog(DIALOG_CREATE_ENTRY_IN_WORKBOOK, CreateEntryInWorkbookDialog);
+const i18n$1 = I18n.keyset("component.workbook-export-dialog.view");
+const InfoRow = ({ icon, text }) => {
+  return /* @__PURE__ */ jsxs(Flex, { gap: 3, alignItems: "center", children: [
+    /* @__PURE__ */ jsx(Label, { icon: /* @__PURE__ */ jsx(Icon, { data: icon }), size: "m", theme: "info" }),
+    /* @__PURE__ */ jsx(Text, { variant: "body-1", children: text })
+  ] });
+};
+const ExportInfo = () => {
+  const docsUrl = formDocsEndpointDL("/workbooks-collections/export-and-import");
+  return /* @__PURE__ */ jsxs(Flex, { gap: 3, direction: "column", children: [
+    /* @__PURE__ */ jsx(InfoRow, { text: i18n$1("label_info-file"), icon: File }),
+    /* @__PURE__ */ jsx(InfoRow, { text: i18n$1("label_info-time"), icon: Clock }),
+    /* @__PURE__ */ jsx(InfoRow, { text: i18n$1("label_info-secrets"), icon: Key }),
+    /* @__PURE__ */ jsx(
+      InfoRow,
+      {
+        text: /* @__PURE__ */ jsx(
+          InterpolatedText,
+          {
+            disableLink: !docsUrl,
+            href: `${docsUrl}#restrictions`,
+            text: i18n$1("label_info-versions")
+          }
+        ),
+        icon: Thunderbolt
+      }
+    ),
+    docsUrl && /* @__PURE__ */ jsx(Link, { href: docsUrl, target: "_blank", className: spacing({ mt: 1 }), children: i18n$1("label_info-documentation") })
+  ] });
+};
+const downloadObjectAsJSON = ({
+  obj,
+  name,
+  dialogRef
+}) => {
+  const jsonString = JSON.stringify(obj);
+  const blob = new Blob([jsonString], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = `${name}.json`;
+  dialogRef.current?.appendChild(a);
+  a.click();
+  dialogRef.current?.removeChild(a);
+  URL.revokeObjectURL(url);
+};
+const b = block("export-workbook-file-dialog");
+const i18n = I18n.keyset("component.workbook-export-dialog.view");
+const notificationsI18n = I18n.keyset("component.workbook-export.notifications");
+const GET_EXPORT_PROGRESS_INTERVAL = 1e3;
+const DIALOG_EXPORT_WORKBOOK = /* @__PURE__ */ Symbol("DIALOG_EXPORT_WORKBOOK");
+const getApplyButtonText = (view, status) => {
+  if (view === "info" || status === "loading" || status === "pending") {
+    return i18n("button_begin-export");
+  }
+  switch (status) {
+    case "success":
+      return i18n("button_download");
+    case "fatal-error":
+    case "notification-error":
+    default:
+      return void 0;
+  }
+};
+const getCaption = (view, status) => {
+  if (view === "info" || status === "loading" || status === "pending") {
+    return i18n("title_export");
+  }
+  switch (status) {
+    case "fatal-error":
+    case "notification-error":
+      return i18n("title_fatal-error");
+    case "success":
+      return i18n("title_export-success");
+    default:
+      return i18n("title_export");
+  }
+};
+const ExportWorkbookDialog = ({
+  workbookId,
+  workbookTitle,
+  open,
+  onClose
+}) => {
+  const dispatch = useDispatch();
+  const [view, setView] = React__default.useState("info");
+  const status = useSelector(selectExportWorkbookStatus);
+  const dialogRef = React__default.useRef(null);
+  const error = useSelector(selectExportError);
+  const isResultLoading = useSelector(selectGetExportResultLoading);
+  const exportData = useSelector(selectExportData);
+  const progressData = useSelector(selectGetExportProgressData);
+  const notificationEntriesMap = useSelector(selectGetExportProgressEntriesMap);
+  const progress = progressData?.progress;
+  const notifications = progressData?.notifications;
+  const exportProgressTimeout = React__default.useRef(null);
+  const isMounted = useMountedState();
+  const { notificationDetails, preparedNotifications, handleShowDetails } = useNotificationsAndDetails({
+    notifications,
+    exportId: exportData?.exportId
+  });
+  const isExportLoading = status === "loading" || status === "pending";
+  const isButtonLoading = isExportLoading || isResultLoading;
+  React__default.useEffect(() => {
+    if (open) {
+      dispatch(resetExportWorkbook());
+    }
+  }, [dispatch, open]);
+  const pollExportStatus = React__default.useCallback(
+    async (currentExportId) => {
+      if (exportProgressTimeout.current) {
+        clearTimeout(exportProgressTimeout.current);
+      }
+      if (!isMounted()) {
+        return;
+      }
+      const startTime = Date.now();
+      const result = await dispatch(getExportProgress({ exportId: currentExportId }));
+      const elapsedTime = Date.now() - startTime;
+      if (result && result.status === "pending") {
+        const nextPollDelay = Math.max(0, GET_EXPORT_PROGRESS_INTERVAL - elapsedTime);
+        exportProgressTimeout.current = setTimeout(
+          () => pollExportStatus(currentExportId),
+          nextPollDelay
+        );
+      }
+    },
+    [dispatch, isMounted]
+  );
+  const handleCancel = React__default.useCallback(() => {
+    if (isExportLoading && exportData?.exportId) {
+      dispatch(
+        openDialog({
+          id: DIALOG_DEFAULT,
+          props: {
+            open: true,
+            onApply: () => {
+              dispatch(cancelExportProcess(exportData.exportId));
+              dispatch(closeDialog());
+              onClose();
+            },
+            onCancel: () => {
+              dispatch(closeDialog());
+            },
+            message: i18n("label_cancel-export-description"),
+            textButtonApply: i18n("button_cancel-export"),
+            textButtonCancel: i18n("button_back-to-export"),
+            propsButtonApply: { view: "outlined-danger" },
+            caption: i18n("title_cancel-export"),
+            className: b("import-cancel-dialog")
+          }
+        })
+      );
+      return;
+    }
+    if (status === "success" && exportData?.exportId) {
+      dispatch(
+        openDialog({
+          id: DIALOG_DEFAULT,
+          props: {
+            open: true,
+            onApply: () => {
+              dispatch(closeDialog());
+              onClose();
+            },
+            onCancel: () => {
+              dispatch(closeDialog());
+            },
+            message: i18n("label_close-export-description"),
+            textButtonApply: i18n("button_close-export"),
+            textButtonCancel: i18n("button_back-to-export"),
+            propsButtonApply: { view: "outlined-danger" },
+            caption: i18n("title_close-export"),
+            className: b("import-cancel-dialog")
+          }
+        })
+      );
+      return;
+    }
+    onClose();
+  }, [dispatch, exportData?.exportId, isExportLoading, onClose, status]);
+  const startExport = React__default.useCallback(async () => {
+    const exportResult = await dispatch(exportWorkbook({ workbookId }));
+    if (exportResult && exportResult.exportId) {
+      setView("export");
+      pollExportStatus(exportResult.exportId);
+    }
+  }, [dispatch, pollExportStatus, workbookId]);
+  const getExportFile = React__default.useCallback(async () => {
+    if (exportData?.exportId) {
+      const result = await dispatch(getExportResult({ exportId: exportData?.exportId }));
+      if (result && result.status === "success") {
+        downloadObjectAsJSON({ obj: result.data, name: workbookTitle, dialogRef });
+        onClose();
+      }
+    }
+  }, [dispatch, exportData?.exportId, onClose, workbookTitle]);
+  const handleApply = React__default.useCallback(async () => {
+    if (view === "info") {
+      startExport();
+      return;
+    }
+    if (status === "success") {
+      getExportFile();
+    }
+  }, [getExportFile, startExport, status, view]);
+  const handleRetry = React__default.useCallback(() => {
+    if (exportData?.exportId) {
+      pollExportStatus(exportData.exportId);
+    }
+  }, [exportData?.exportId, pollExportStatus]);
+  const cancelButtonText = view === "info" || isExportLoading ? i18n("button_cancel") : i18n("button_close");
+  const docsUrl = formDocsEndpointDL("/workbooks-collections/export-import-notifications");
+  const renderBody = () => {
+    if (view === "info") {
+      return /* @__PURE__ */ jsx(ExportInfo, {});
+    }
+    switch (status) {
+      case "pending":
+        return /* @__PURE__ */ jsx(ProgressBar, { size: "s", className: b("progress"), value: progress ?? 0 });
+      case "loading":
+        return /* @__PURE__ */ jsx(Flex, { alignItems: "center", justifyContent: "center", children: /* @__PURE__ */ jsx(Loader, { size: "m" }) });
+      case "success":
+      case "notification-error":
+        if (!preparedNotifications.length && status === "success") {
+          return /* @__PURE__ */ jsx(
+            EntriesNotificationCut,
+            {
+              title: i18n("label_success-export"),
+              level: "success"
+            }
+          );
+        }
+        return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+          /* @__PURE__ */ jsx(Flex, { direction: "column", gap: 4, className: b("notifications"), children: preparedNotifications.map(({ code, message, level, entries }) => /* @__PURE__ */ jsx(
+            EntriesNotificationCut,
+            {
+              title: message,
+              level,
+              entries,
+              code,
+              entriesMap: notificationEntriesMap
+            },
+            code
+          )) }),
+          docsUrl && /* @__PURE__ */ jsx(Link, { target: "_blank", href: docsUrl, className: spacing({ mt: 4 }), children: notificationsI18n("label_info-documentation-notifications") })
+        ] });
+      case "fatal-error":
+      default: {
+        const handleRetryFn = exportData?.exportId ? handleRetry : void 0;
+        return /* @__PURE__ */ jsx(
+          ViewError,
+          {
+            showDebugInfo: false,
+            containerClassName: b("error-content"),
+            error,
+            size: "s",
+            exportId: exportData?.exportId,
+            retry: handleRetryFn
+          }
+        );
+      }
+    }
+  };
+  return /* @__PURE__ */ jsxs(Dialog, { className: b(), open, onClose: handleCancel, children: [
+    /* @__PURE__ */ jsx(Dialog.Header, { caption: getCaption(view, status) }),
+    /* @__PURE__ */ jsx(Dialog.Body, { children: /* @__PURE__ */ jsx(Flex, { direction: "column", ref: dialogRef, children: renderBody() }) }),
+    /* @__PURE__ */ jsx(
+      Dialog.Footer,
+      {
+        textButtonApply: getApplyButtonText(view, status),
+        textButtonCancel: cancelButtonText,
+        onClickButtonApply: handleApply,
+        onClickButtonCancel: handleCancel,
+        propsButtonApply: { loading: isButtonLoading },
+        propsButtonCancel: { disabled: isResultLoading },
+        children: notificationDetails && /* @__PURE__ */ jsx(Button, { size: "l", view: "outlined", onClick: handleShowDetails, children: notificationsI18n("button_show-details") })
+      }
+    )
+  ] });
+};
+DialogManager.registerDialog(DIALOG_EXPORT_WORKBOOK, ExportWorkbookDialog);
+export {
+  DELETE_COLLECTIONS_SUCCESS as $,
+  RESET_EXPORT_PROGRESS as A,
+  GET_EXPORT_PROGRESS_FAILED as B,
+  GET_EXPORT_PROGRESS_SUCCESS as C,
+  DIALOG_COPY_ENTRIES as D,
+  GET_EXPORT_PROGRESS_LOADING as E,
+  RESET_IMPORT_PROGRESS as F,
+  GET_EXPORT_RESULT_FAILED as G,
+  GET_IMPORT_PROGRESS_FAILED as H,
+  GET_IMPORT_PROGRESS_SUCCESS as I,
+  GET_IMPORT_PROGRESS_LOADING as J,
+  RESET_IMPORT_WORKBOOK as K,
+  IMPORT_WORKBOOK_FAILED as L,
+  IMPORT_WORKBOOK_SUCCESS as M,
+  IMPORT_WORKBOOK_LOADING as N,
+  RESET_EXPORT_WORKBOOK as O,
+  EXPORT_WORKBOOK_FAILED as P,
+  EXPORT_WORKBOOK_SUCCESS as Q,
+  RESET_EXPORT_RESULT as R,
+  StructureItemSelect as S,
+  EXPORT_WORKBOOK_LOADING as T,
+  DELETE_WORKBOOKS_FAILED as U,
+  DELETE_WORKBOOKS_SUCCESS as V,
+  DELETE_WORKBOOKS_LOADING as W,
+  DELETE_WORKBOOK_FAILED as X,
+  DELETE_WORKBOOK_SUCCESS as Y,
+  DELETE_WORKBOOK_LOADING as Z,
+  DELETE_COLLECTIONS_FAILED as _,
+  selectBreadcrumbs as a,
+  DELETE_COLLECTIONS_LOADING as a0,
+  DELETE_COLLECTION_FAILED as a1,
+  DELETE_COLLECTION_SUCCESS as a2,
+  DELETE_COLLECTION_LOADING as a3,
+  UPDATE_COLLECTION_FAILED as a4,
+  UPDATE_COLLECTION_SUCCESS as a5,
+  UPDATE_COLLECTION_LOADING as a6,
+  UPDATE_WORKBOOK_FAILED as a7,
+  UPDATE_WORKBOOK_SUCCESS as a8,
+  UPDATE_WORKBOOK_LOADING as a9,
+  COPY_TEMPLATE_LOADING as aA,
+  GET_STRUCTURE_ITEMS_FAILED as aB,
+  GET_STRUCTURE_ITEMS_SUCCESS as aC,
+  GET_STRUCTURE_ITEMS_LOADING as aD,
+  RESET_STRUCTURE_ITEMS as aE,
+  GET_COLLECTION_FAILED as aF,
+  GET_COLLECTION_SUCCESS as aG,
+  GET_COLLECTION_LOADING as aH,
+  GET_COLLECTION_BREADCRUMBS_FAILED as aI,
+  GET_COLLECTION_BREADCRUMBS_SUCCESS as aJ,
+  GET_COLLECTION_BREADCRUMBS_LOADING as aK,
+  RESET_COLLECTION_BREADCRUMBS as aL,
+  GET_ROOT_COLLECTION_PERMISSIONS_FAILED as aM,
+  GET_ROOT_COLLECTION_PERMISSIONS_SUCCESS as aN,
+  GET_ROOT_COLLECTION_PERMISSIONS_LOADING as aO,
+  RESET_STATE as aP,
+  DIALOG_CREATE_WORKBOOK as aQ,
+  COPY_WORKBOOK_FAILED as aa,
+  COPY_WORKBOOK_SUCCESS as ab,
+  COPY_WORKBOOK_LOADING as ac,
+  MOVE_SHARED_ENTRY_FAILED as ad,
+  MOVE_SHARED_ENTRY_SUCCESS as ae,
+  MOVE_SHARED_ENTRY_LOADING as af,
+  MOVE_WORKBOOKS_FAILED as ag,
+  MOVE_WORKBOOKS_SUCCESS as ah,
+  MOVE_WORKBOOKS_LOADING as ai,
+  MOVE_WORKBOOK_FAILED as aj,
+  MOVE_WORKBOOK_SUCCESS as ak,
+  MOVE_WORKBOOK_LOADING as al,
+  MOVE_COLLECTIONS_FAILED as am,
+  MOVE_COLLECTIONS_SUCCESS as an,
+  MOVE_COLLECTIONS_LOADING as ao,
+  MOVE_COLLECTION_FAILED as ap,
+  MOVE_COLLECTION_SUCCESS as aq,
+  MOVE_COLLECTION_LOADING as ar,
+  CREATE_WORKBOOK_FAILED as as,
+  CREATE_WORKBOOK_SUCCESS as at,
+  CREATE_WORKBOOK_LOADING as au,
+  CREATE_COLLECTION_FAILED as av,
+  CREATE_COLLECTION_SUCCESS as aw,
+  CREATE_COLLECTION_LOADING as ax,
+  COPY_TEMPLATE_FAILED as ay,
+  COPY_TEMPLATE_SUCCESS as az,
+  selectStructureItems as b,
+  selectStructureItemsIsLoading as c,
+  selectStructureItemsError as d,
+  selectNextPageToken as e,
+  selectIsLoadingTargetEntry as f,
+  selectIsLoadingRelationsGraph as g,
+  selectIsLoadingRelations as h,
+  iconInfo as i,
+  selectTargetEntry as j,
+  selectRelationsGraph as k,
+  selectRelations as l,
+  selectTargetEntryError as m,
+  selectRelationsGraphError as n,
+  selectRelationsError as o,
+  DIALOG_MIGRATE_ENTRY_TO_WORKBOOK as p,
+  DIALOG_MOVE_WORKBOOK as q,
+  DIALOG_COPY_WORKBOOK as r,
+  selectBreadcrumbsIsLoading as s,
+  DIALOG_EXPORT_WORKBOOK as t,
+  useCollectionStructureDialogState as u,
+  DIALOG_DELETE_WORKBOOK as v,
+  DIALOG_EDIT_WORKBOOK as w,
+  DIALOG_CREATE_ENTRY_IN_WORKBOOK as x,
+  GET_EXPORT_RESULT_SUCCESS as y,
+  GET_EXPORT_RESULT_LOADING as z
+};