@mui/x-tree-view 8.0.0-alpha.8 → 8.0.0-beta.0

package/internals/plugins/useTreeViewLabel/useTreeViewLabel.itemPlugin.js

@@ -1,8 +1,15 @@
-import * as React from 'react';
-import { useTreeViewContext } from "../../TreeViewProvider/index.js";
-import { useSelector } from "../../hooks/useSelector.js";
-import { selectorIsItemBeingEdited, selectorIsItemEditable } from "./useTreeViewLabel.selectors.js";
-export const useTreeViewLabelItemPlugin = ({
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewLabelItemPlugin = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _TreeViewProvider = require("../../TreeViewProvider");
+var _useSelector = require("../../hooks/useSelector");
+var _useTreeViewLabel = require("./useTreeViewLabel.selectors");
+const useTreeViewLabelItemPlugin = ({
   props
 }) => {
   const {
@@ -10,17 +17,17 @@ export const useTreeViewLabelItemPlugin = ({
     label: {
       isItemEditable
     }
-  } = useTreeViewContext();
+  } = (0, _TreeViewProvider.useTreeViewContext)();
   const {
     label,
     itemId
   } = props;
   const [labelInputValue, setLabelInputValue] = React.useState(label);
-  const editable = useSelector(store, selectorIsItemEditable, {
+  const editable = (0, _useSelector.useSelector)(store, _useTreeViewLabel.selectorIsItemEditable, {
     itemId,
     isItemEditable
   });
-  const editing = useSelector(store, selectorIsItemBeingEdited, itemId);
+  const editing = (0, _useSelector.useSelector)(store, _useTreeViewLabel.selectorIsItemBeingEdited, itemId);
   React.useEffect(() => {
     if (!editing) {
       setLabelInputValue(label);
@@ -72,4 +79,5 @@ export const useTreeViewLabelItemPlugin = ({
       }
     }
   };
-};
+};
+exports.useTreeViewLabelItemPlugin = useTreeViewLabelItemPlugin;

package/internals/plugins/useTreeViewLabel/useTreeViewLabel.js

@@ -1,13 +1,20 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { warnOnce } from '@mui/x-internals/warning';
-import { useTreeViewLabelItemPlugin } from "./useTreeViewLabel.itemPlugin.js";
-export const useTreeViewLabel = ({
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewLabel = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _useTreeViewLabel = require("./useTreeViewLabel.itemPlugin");
+const useTreeViewLabel = ({
   store,
   params
 }) => {
   const setEditedItemId = editedItemId => {
-    store.update(prevState => _extends({}, prevState, {
+    store.update(prevState => (0, _extends2.default)({}, prevState, {
       label: {
         editedItemId
       }
@@ -20,10 +27,10 @@ export const useTreeViewLabel = ({
     store.update(prevState => {
       const item = prevState.items.itemMetaLookup[itemId];
       if (item.label !== label) {
-        return _extends({}, prevState, {
-          items: _extends({}, prevState.items, {
-            itemMetaLookup: _extends({}, prevState.items.itemMetaLookup, {
-              [itemId]: _extends({}, item, {
+        return (0, _extends2.default)({}, prevState, {
+          items: (0, _extends2.default)({}, prevState.items, {
+            itemMetaLookup: (0, _extends2.default)({}, prevState.items.itemMetaLookup, {
+              [itemId]: (0, _extends2.default)({}, item, {
                 label
               })
             })
@@ -52,21 +59,13 @@ export const useTreeViewLabel = ({
     contextValue: pluginContextValue
   };
 };
-useTreeViewLabel.itemPlugin = useTreeViewLabelItemPlugin;
+exports.useTreeViewLabel = useTreeViewLabel;
+useTreeViewLabel.itemPlugin = _useTreeViewLabel.useTreeViewLabelItemPlugin;
 useTreeViewLabel.getDefaultizedParams = ({
-  params,
-  experimentalFeatures
-}) => {
-  const canUseFeature = experimentalFeatures?.labelEditing;
-  if (process.env.NODE_ENV !== 'production') {
-    if (params.isItemEditable && !canUseFeature) {
-      warnOnce(['MUI X: The label editing feature requires the `labelEditing` experimental feature to be enabled.', 'You can do it by passing `experimentalFeatures={{ labelEditing: true}}` to the Rich Tree View Pro component.', 'Check the documentation for more details: https://mui.com/x/react-tree-view/rich-tree-view/editing/']);
-    }
-  }
-  return _extends({}, params, {
-    isItemEditable: canUseFeature ? params.isItemEditable ?? false : false
-  });
-};
+  params
+}) => (0, _extends2.default)({}, params, {
+  isItemEditable: params.isItemEditable ?? false
+});
 useTreeViewLabel.getInitialState = () => ({
   label: {
     editedItemId: null

package/internals/plugins/useTreeViewLabel/useTreeViewLabel.selectors.d.ts

@@ -1,5 +1,5 @@
-import { UseTreeViewLabelSignature } from './useTreeViewLabel.types';
-import { TreeViewRootSelector } from '../../utils/selectors';
+import { UseTreeViewLabelSignature } from "./useTreeViewLabel.types.js";
+import { TreeViewRootSelector } from "../../utils/selectors.js";
 /**
  * Check if an item is editable.
  * @param {TreeViewState<[UseTreeViewItemsSignature]>} state The state of the tree view.
@@ -9,37 +9,37 @@ import { TreeViewRootSelector } from '../../utils/selectors';
  * @returns {boolean} `true` if the item is editable, `false` otherwise.
  */
 export declare const selectorIsItemEditable: ((state: any, args: any) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    itemId: string;
+    isItemEditable: ((item: any) => boolean) | boolean;
+  }, resultFuncArgs_1: import("../../..").TreeViewBaseItem<import("../../..").TreeViewDefaultItemModelProperties>) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    itemId: string;
+    isItemEditable: ((item: any) => boolean) | boolean;
+  }, resultFuncArgs_1: import("../../..").TreeViewBaseItem<import("../../..").TreeViewDefaultItemModelProperties>) => boolean) & {
     clearCache: () => void;
     resultsCount: () => number;
     resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [(_: any, args: {
+    itemId: string;
+    isItemEditable: ((item: any) => boolean) | boolean;
+  }) => {
+    itemId: string;
+    isItemEditable: ((item: any) => boolean) | boolean;
+  }, (state: any, args: any) => import("../../..").TreeViewBaseItem<import("../../..").TreeViewDefaultItemModelProperties>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
 } & {
-    resultFunc: (resultFuncArgs_0: {
-        itemId: string;
-        isItemEditable: ((item: any) => boolean) | boolean;
-    }, resultFuncArgs_1: import("../../..").TreeViewBaseItem<import("../../..").TreeViewDefaultItemModelProperties>) => boolean;
-    memoizedResultFunc: ((resultFuncArgs_0: {
-        itemId: string;
-        isItemEditable: ((item: any) => boolean) | boolean;
-    }, resultFuncArgs_1: import("../../..").TreeViewBaseItem<import("../../..").TreeViewDefaultItemModelProperties>) => boolean) & {
-        clearCache: () => void;
-        resultsCount: () => number;
-        resetResultsCount: () => void;
-    };
-    lastResult: () => boolean;
-    dependencies: [(_: any, args: {
-        itemId: string;
-        isItemEditable: ((item: any) => boolean) | boolean;
-    }) => {
-        itemId: string;
-        isItemEditable: ((item: any) => boolean) | boolean;
-    }, (state: any, args: any) => import("../../..").TreeViewBaseItem<import("../../..").TreeViewDefaultItemModelProperties>];
-    recomputations: () => number;
-    resetRecomputations: () => void;
-    dependencyRecomputations: () => number;
-    resetDependencyRecomputations: () => void;
-} & {
-    argsMemoize: typeof import("reselect").weakMapMemoize;
-    memoize: typeof import("reselect").weakMapMemoize;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
 };
 /**
  * Check if an item is being edited.
@@ -48,27 +48,27 @@ export declare const selectorIsItemEditable: ((state: any, args: any) => boolean
  * @returns {boolean} `true` if the item is being edited, `false` otherwise.
  */
 export declare const selectorIsItemBeingEdited: ((state: any, itemId: string) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    editedItemId: string | null;
+  }, resultFuncArgs_1: string) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    editedItemId: string | null;
+  }, resultFuncArgs_1: string) => boolean) & {
     clearCache: () => void;
     resultsCount: () => number;
     resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [TreeViewRootSelector<UseTreeViewLabelSignature>, (_: any, itemId: string) => string];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
 } & {
-    resultFunc: (resultFuncArgs_0: {
-        editedItemId: string | null;
-    }, resultFuncArgs_1: string) => boolean;
-    memoizedResultFunc: ((resultFuncArgs_0: {
-        editedItemId: string | null;
-    }, resultFuncArgs_1: string) => boolean) & {
-        clearCache: () => void;
-        resultsCount: () => number;
-        resetResultsCount: () => void;
-    };
-    lastResult: () => boolean;
-    dependencies: [TreeViewRootSelector<UseTreeViewLabelSignature>, (_: any, itemId: string) => string];
-    recomputations: () => number;
-    resetRecomputations: () => void;
-    dependencyRecomputations: () => number;
-    resetDependencyRecomputations: () => void;
-} & {
-    argsMemoize: typeof import("reselect").weakMapMemoize;
-    memoize: typeof import("reselect").weakMapMemoize;
-};
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};

package/internals/plugins/useTreeViewLabel/useTreeViewLabel.selectors.js

@@ -1,5 +1,11 @@
-import { createSelector } from "../../utils/selectors.js";
-import { selectorItemModel } from "../useTreeViewItems/useTreeViewItems.selectors.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectorIsItemEditable = exports.selectorIsItemBeingEdited = void 0;
+var _selectors = require("../../utils/selectors");
+var _useTreeViewItems = require("../useTreeViewItems/useTreeViewItems.selectors");
 const selectorTreeViewLabelState = state => state.label;
 
 /**
@@ -10,7 +16,7 @@ const selectorTreeViewLabelState = state => state.label;
  * @param {((item: any) => boolean) | boolean} params.isItemEditable The function to determine if an item is editable.
  * @returns {boolean} `true` if the item is editable, `false` otherwise.
  */
-export const selectorIsItemEditable = createSelector([(_, args) => args, (state, args) => selectorItemModel(state, args.itemId)], (args, itemModel) => {
+const selectorIsItemEditable = exports.selectorIsItemEditable = (0, _selectors.createSelector)([(_, args) => args, (state, args) => (0, _useTreeViewItems.selectorItemModel)(state, args.itemId)], (args, itemModel) => {
   if (!itemModel || !args.isItemEditable) {
     return false;
   }
@@ -23,4 +29,4 @@ export const selectorIsItemEditable = createSelector([(_, args) => args, (state,
  * @param {TreeViewItemId} itemId The id of the item to check.
  * @returns {boolean} `true` if the item is being edited, `false` otherwise.
  */
-export const selectorIsItemBeingEdited = createSelector([selectorTreeViewLabelState, (_, itemId) => itemId], (labelState, itemId) => labelState.editedItemId === itemId);
+const selectorIsItemBeingEdited = exports.selectorIsItemBeingEdited = (0, _selectors.createSelector)([selectorTreeViewLabelState, (_, itemId) => itemId], (labelState, itemId) => labelState.editedItemId === itemId);

package/internals/plugins/useTreeViewLabel/useTreeViewLabel.types.d.ts

@@ -1,64 +1,59 @@
 import { DefaultizedProps } from '@mui/x-internals/types';
-import { TreeViewPluginSignature } from '../../models';
-import { TreeViewItemId } from '../../../models';
-import { UseTreeViewItemsSignature } from '../useTreeViewItems';
-import { TreeItemLabelInputProps } from '../../../TreeItemLabelInput';
+import { TreeViewPluginSignature } from "../../models/index.js";
+import { TreeViewItemId } from "../../../models/index.js";
+import { UseTreeViewItemsSignature } from "../useTreeViewItems/index.js";
+import { TreeItemLabelInputProps } from "../../../TreeItemLabelInput/index.js";
 export interface UseTreeViewLabelPublicAPI {
-    /**
-     * Used to update the label of an item.
-     * @param {TreeViewItemId} itemId The id of the item to update the label of.
-     * @param {string} newLabel The new label of the item.
-     */
-    updateItemLabel: (itemId: TreeViewItemId, newLabel: string) => void;
+  /**
+   * Used to update the label of an item.
+   * @param {TreeViewItemId} itemId The id of the item to update the label of.
+   * @param {string} newLabel The new label of the item.
+   */
+  updateItemLabel: (itemId: TreeViewItemId, newLabel: string) => void;
 }
 export interface UseTreeViewLabelInstance extends UseTreeViewLabelPublicAPI {
-    /**
-     * Updates which item is currently being edited.
-     * @param {TreeViewItemId} itemId The id of the item that is currently being edited.
-     * @returns {void}.
-     */
-    setEditedItemId: (itemId: TreeViewItemId | null) => void;
+  /**
+   * Updates which item is currently being edited.
+   * @param {TreeViewItemId} itemId The id of the item that is currently being edited.
+   * @returns {void}.
+   */
+  setEditedItemId: (itemId: TreeViewItemId | null) => void;
 }
 export interface UseTreeViewLabelParameters<R extends {}> {
-    /**
-     * Callback fired when the label of an item changes.
-     * @param {TreeViewItemId} itemId The id of the item that was edited.
-     * @param {string} newLabel The new label of the items.
-     */
-    onItemLabelChange?: (itemId: TreeViewItemId, newLabel: string) => void;
-    /**
-     * Determines if a given item is editable or not.
-     * Make sure to also enable the `labelEditing` experimental feature:
-     * `<RichTreeViewPro experimentalFeatures={{ labelEditing: true }}  />`.
-     * By default, the items are not editable.
-     * @template R
-     * @param {R} item The item to check.
-     * @returns {boolean} `true` if the item is editable.
-     */
-    isItemEditable?: boolean | ((item: R) => boolean);
+  /**
+   * Callback fired when the label of an item changes.
+   * @param {TreeViewItemId} itemId The id of the item that was edited.
+   * @param {string} newLabel The new label of the items.
+   */
+  onItemLabelChange?: (itemId: TreeViewItemId, newLabel: string) => void;
+  /**
+   * Determine if a given item can be edited.
+   * @template R
+   * @param {R} item The item to check.
+   * @returns {boolean} `true` if the item can be edited.
+   * @default () => false
+   */
+  isItemEditable?: boolean | ((item: R) => boolean);
 }
 export type UseTreeViewLabelDefaultizedParameters<R extends {}> = DefaultizedProps<UseTreeViewLabelParameters<R>, 'isItemEditable'>;
 export interface UseTreeViewLabelState {
-    label: {
-        editedItemId: string | null;
-    };
+  label: {
+    editedItemId: string | null;
+  };
 }
 export interface UseTreeViewLabelContextValue {
-    label: Pick<UseTreeViewLabelDefaultizedParameters<any>, 'isItemEditable'>;
+  label: Pick<UseTreeViewLabelDefaultizedParameters<any>, 'isItemEditable'>;
 }
 export type UseTreeViewLabelSignature = TreeViewPluginSignature<{
-    params: UseTreeViewLabelParameters<any>;
-    defaultizedParams: UseTreeViewLabelDefaultizedParameters<any>;
-    publicAPI: UseTreeViewLabelPublicAPI;
-    instance: UseTreeViewLabelInstance;
-    state: UseTreeViewLabelState;
-    contextValue: UseTreeViewLabelContextValue;
-    experimentalFeatures: 'labelEditing';
-    dependencies: [UseTreeViewItemsSignature];
+  params: UseTreeViewLabelParameters<any>;
+  defaultizedParams: UseTreeViewLabelDefaultizedParameters<any>;
+  publicAPI: UseTreeViewLabelPublicAPI;
+  instance: UseTreeViewLabelInstance;
+  state: UseTreeViewLabelState;
+  contextValue: UseTreeViewLabelContextValue;
+  dependencies: [UseTreeViewItemsSignature];
 }>;
-export interface UseTreeItemLabelInputSlotPropsFromLabelEditing extends TreeItemLabelInputProps {
-}
+export interface UseTreeItemLabelInputSlotPropsFromLabelEditing extends TreeItemLabelInputProps {}
 declare module '@mui/x-tree-view/useTreeItem' {
-    interface UseTreeItemLabelInputSlotOwnProps extends UseTreeItemLabelInputSlotPropsFromLabelEditing {
-    }
-}
+  interface UseTreeItemLabelInputSlotOwnProps extends UseTreeItemLabelInputSlotPropsFromLabelEditing {}
+}

package/internals/plugins/useTreeViewLabel/useTreeViewLabel.types.js

@@ -1 +1,5 @@
-export {};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/internals/plugins/useTreeViewLazyLoading/index.d.ts

@@ -0,0 +1 @@
+export type { UseTreeViewLazyLoadingSignature, UseTreeViewLazyLoadingParameters } from './useTreeViewLazyLoading.types';

package/internals/plugins/useTreeViewLazyLoading/useTreeViewLazyLoading.selectors.d.ts

@@ -0,0 +1,249 @@
+import { TreeViewAnyPluginSignature, TreeViewState } from "../../models/index.js";
+import { TreeViewRootSelector, TreeViewRootSelectorForOptionalPlugin } from "../../utils/selectors.js";
+import { UseTreeViewLazyLoadingSignature } from "./useTreeViewLazyLoading.types.js";
+export type Temp<TSignature extends TreeViewAnyPluginSignature> = <TSignatures extends [], TOptionalSignatures extends [TSignature]>(state: TreeViewState<TSignatures, TOptionalSignatures>) => TSignature['state'][keyof TSignature['state']];
+export declare const selectorDataSourceState: ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewLazyLoading.types").UseTreeViewLazyLoadingState & Partial<{}> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => {
+  loading: Record<import("../../..").TreeViewItemId, boolean>;
+  errors: Record<import("../../..").TreeViewItemId, Error | null>;
+}) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    enabled: boolean;
+    dataSource: {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+  }) => {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  };
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    enabled: boolean;
+    dataSource: {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+  }) => {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  }) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  };
+  dependencies: [TreeViewRootSelector<UseTreeViewLazyLoadingSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if lazy loading is enabled.
+ * @param {TreeViewState<[UseTreeViewLazyLoadingSignature]>} state The state of the tree view.
+ * @returns {boolean} True if lazy loading is enabled, false if it isn't.
+ */
+export declare const selectorIsLazyLoadingEnabled: ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & Partial<import("./useTreeViewLazyLoading.types").UseTreeViewLazyLoadingState> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    enabled: boolean;
+    dataSource: {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+  } | undefined) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    enabled: boolean;
+    dataSource: {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+  } | undefined) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [TreeViewRootSelectorForOptionalPlugin<UseTreeViewLazyLoadingSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Get the loading state for a tree item.
+ * @param {TreeViewState<[UseTreeViewLazyLoadingSignature]>} state The state of the tree view.
+ * @param {TreeViewItemId} itemId The id of the item to get the loading state of.
+ * @returns {boolean} The loading state for the Tree Item.
+ */
+export declare const selectorIsItemLoading: ((state: any, itemId: string) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  }, resultFuncArgs_1: string) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  }, resultFuncArgs_1: string) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewLazyLoading.types").UseTreeViewLazyLoadingState & Partial<{}> & {
+    cacheKey: import("../../models").TreeViewStateCacheKey;
+  }) => {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  }) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: {
+      enabled: boolean;
+      dataSource: {
+        loading: Record<import("../../..").TreeViewItemId, boolean>;
+        errors: Record<import("../../..").TreeViewItemId, Error | null>;
+      };
+    }) => {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: {
+      enabled: boolean;
+      dataSource: {
+        loading: Record<import("../../..").TreeViewItemId, boolean>;
+        errors: Record<import("../../..").TreeViewItemId, Error | null>;
+      };
+    }) => {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    }) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+    dependencies: [TreeViewRootSelector<UseTreeViewLazyLoadingSignature>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+  }, (_: any, itemId: string) => string];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Get the error for a tree item.
+ * @param {TreeViewState<[UseTreeViewLazyLoadingSignature]>} state The state of the tree view.
+ * @param {TreeViewItemId} itemId The id of the item to get the error for.
+ * @returns {boolean} The error for the Tree Item.
+ */
+export declare const selectorGetTreeItemError: ((state: any, itemId: string) => Error | null) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  }, resultFuncArgs_1: string) => Error | null;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  }, resultFuncArgs_1: string) => Error | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => Error | null;
+  dependencies: [((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewLazyLoading.types").UseTreeViewLazyLoadingState & Partial<{}> & {
+    cacheKey: import("../../models").TreeViewStateCacheKey;
+  }) => {
+    loading: Record<import("../../..").TreeViewItemId, boolean>;
+    errors: Record<import("../../..").TreeViewItemId, Error | null>;
+  }) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: {
+      enabled: boolean;
+      dataSource: {
+        loading: Record<import("../../..").TreeViewItemId, boolean>;
+        errors: Record<import("../../..").TreeViewItemId, Error | null>;
+      };
+    }) => {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: {
+      enabled: boolean;
+      dataSource: {
+        loading: Record<import("../../..").TreeViewItemId, boolean>;
+        errors: Record<import("../../..").TreeViewItemId, Error | null>;
+      };
+    }) => {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    }) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => {
+      loading: Record<import("../../..").TreeViewItemId, boolean>;
+      errors: Record<import("../../..").TreeViewItemId, Error | null>;
+    };
+    dependencies: [TreeViewRootSelector<UseTreeViewLazyLoadingSignature>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+  }, (_: any, itemId: string) => string];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};