diff --git a/docs/data/tree-view/rich-tree-view/headless/LogExpandedItems.tsx b/docs/data/tree-view/rich-tree-view/headless/LogExpandedItems.tsx
index 75c05b7c6b9ab..c1a70f335c0e6 100644
--- a/docs/data/tree-view/rich-tree-view/headless/LogExpandedItems.tsx
+++ b/docs/data/tree-view/rich-tree-view/headless/LogExpandedItems.tsx
@@ -21,6 +21,7 @@ import {
   extractPluginParamsFromProps,
   useTreeView,
   TreeViewProvider,
+  ConvertPluginsIntoSignatures,
 } from '@mui/x-tree-view/internals';
 
 interface TreeViewLogExpandedParameters {
@@ -88,7 +89,7 @@ function TreeView<R extends {}, Multiple extends boolean | undefined>(
   const ownerState = themeProps as TreeViewProps<any, any>;
 
   const { pluginParams, otherProps } = extractPluginParamsFromProps<
-    typeof TREE_VIEW_PLUGINS,
+    ConvertPluginsIntoSignatures<typeof TREE_VIEW_PLUGINS>,
     DefaultTreeViewPluginSlots,
     DefaultTreeViewPluginSlotProps,
     TreeViewProps<R, Multiple>
diff --git a/docs/data/tree-view/rich-tree-view/headless/headless.md b/docs/data/tree-view/rich-tree-view/headless/headless.md
index 99955f9962855..86ca7bfccbc56 100644
--- a/docs/data/tree-view/rich-tree-view/headless/headless.md
+++ b/docs/data/tree-view/rich-tree-view/headless/headless.md
@@ -237,7 +237,7 @@ function useTreeItemState(itemId: string) {
   const {
     customPlugin,
     // ...other elements returned by the context
-  } = useTreeViewContext<DefaultTreeViewPlugins>();
+  } = useTreeViewContext<DefaultTreeViewPluginSignatures>();
 
   // ...rest of the `useTreeItemState` hook content
 
diff --git a/packages/x-tree-view-pro/src/RichTreeViewPro/RichTreeViewPro.tsx b/packages/x-tree-view-pro/src/RichTreeViewPro/RichTreeViewPro.tsx
index c2699d8d82c26..5e5111eccb959 100644
--- a/packages/x-tree-view-pro/src/RichTreeViewPro/RichTreeViewPro.tsx
+++ b/packages/x-tree-view-pro/src/RichTreeViewPro/RichTreeViewPro.tsx
@@ -16,7 +16,10 @@ import {
   RichTreeViewProSlotProps,
   RichTreeViewProSlots,
 } from './RichTreeViewPro.types';
-import { DEFAULT_TREE_VIEW_PRO_PLUGINS } from '../internals/plugins';
+import {
+  DEFAULT_TREE_VIEW_PRO_PLUGINS,
+  DefaultTreeViewProPluginSignatures,
+} from '../internals/plugins';
 import { getReleaseInfo } from '../internals/utils/releaseInfo';
 
 const useUtilityClasses = <R extends {}, Multiple extends boolean | undefined>(
@@ -100,7 +103,7 @@ const RichTreeViewPro = React.forwardRef(function RichTreeViewPro<
   }
 
   const { pluginParams, slots, slotProps, otherProps } = extractPluginParamsFromProps<
-    typeof DEFAULT_TREE_VIEW_PRO_PLUGINS,
+    DefaultTreeViewProPluginSignatures,
     RichTreeViewProSlots,
     RichTreeViewProSlotProps<R, Multiple>,
     RichTreeViewProProps<R, Multiple>
diff --git a/packages/x-tree-view-pro/src/RichTreeViewPro/RichTreeViewPro.types.ts b/packages/x-tree-view-pro/src/RichTreeViewPro/RichTreeViewPro.types.ts
index 7603b6fde12d8..c0df5ad46263e 100644
--- a/packages/x-tree-view-pro/src/RichTreeViewPro/RichTreeViewPro.types.ts
+++ b/packages/x-tree-view-pro/src/RichTreeViewPro/RichTreeViewPro.types.ts
@@ -11,7 +11,7 @@ import {
   DefaultTreeViewProPluginParameters,
   DefaultTreeViewProPluginSlotProps,
   DefaultTreeViewProPluginSlots,
-  DefaultTreeViewProPlugins,
+  DefaultTreeViewProPluginSignatures,
 } from '../internals/plugins/defaultPlugins';
 
 interface RichTreeViewItemProSlotOwnerState {
@@ -39,7 +39,7 @@ export interface RichTreeViewProSlotProps<R extends {}, Multiple extends boolean
 }
 
 export type RichTreeViewProApiRef = React.MutableRefObject<
-  TreeViewPublicAPI<DefaultTreeViewProPlugins> | undefined
+  TreeViewPublicAPI<DefaultTreeViewProPluginSignatures> | undefined
 >;
 
 export interface RichTreeViewProPropsBase extends React.HTMLAttributes<HTMLUListElement> {
@@ -76,5 +76,5 @@ export interface RichTreeViewProProps<R extends {}, Multiple extends boolean | u
    * For each feature, if the flag is not explicitly set to `true`,
    * the feature will be fully disabled and any property / method call will not have any effect.
    */
-  experimentalFeatures?: TreeViewExperimentalFeatures<DefaultTreeViewProPlugins>;
+  experimentalFeatures?: TreeViewExperimentalFeatures<DefaultTreeViewProPluginSignatures>;
 }
diff --git a/packages/x-tree-view-pro/src/internals/plugins/defaultPlugins.ts b/packages/x-tree-view-pro/src/internals/plugins/defaultPlugins.ts
index 8f12846c5043a..d720b60872666 100644
--- a/packages/x-tree-view-pro/src/internals/plugins/defaultPlugins.ts
+++ b/packages/x-tree-view-pro/src/internals/plugins/defaultPlugins.ts
@@ -13,7 +13,7 @@ import {
   useTreeViewIcons,
   UseTreeViewIconsParameters,
   ConvertPluginsIntoSignatures,
-  MergePluginsProperty,
+  MergeSignaturesProperty,
 } from '@mui/x-tree-view/internals';
 
 export const DEFAULT_TREE_VIEW_PRO_PLUGINS = [
@@ -26,17 +26,17 @@ export const DEFAULT_TREE_VIEW_PRO_PLUGINS = [
   useTreeViewIcons,
 ] as const;
 
-export type DefaultTreeViewProPlugins = ConvertPluginsIntoSignatures<
+export type DefaultTreeViewProPluginSignatures = ConvertPluginsIntoSignatures<
   typeof DEFAULT_TREE_VIEW_PRO_PLUGINS
 >;
 
-export type DefaultTreeViewProPluginSlots = MergePluginsProperty<
-  DefaultTreeViewProPlugins,
+export type DefaultTreeViewProPluginSlots = MergeSignaturesProperty<
+  DefaultTreeViewProPluginSignatures,
   'slots'
 >;
 
-export type DefaultTreeViewProPluginSlotProps = MergePluginsProperty<
-  DefaultTreeViewProPlugins,
+export type DefaultTreeViewProPluginSlotProps = MergeSignaturesProperty<
+  DefaultTreeViewProPluginSignatures,
   'slotProps'
 >;
 
diff --git a/packages/x-tree-view-pro/src/internals/plugins/index.ts b/packages/x-tree-view-pro/src/internals/plugins/index.ts
index 43574e246824a..96523fc228141 100644
--- a/packages/x-tree-view-pro/src/internals/plugins/index.ts
+++ b/packages/x-tree-view-pro/src/internals/plugins/index.ts
@@ -1,2 +1,2 @@
 export { DEFAULT_TREE_VIEW_PRO_PLUGINS } from './defaultPlugins';
-export type { DefaultTreeViewProPlugins } from './defaultPlugins';
+export type { DefaultTreeViewProPluginSignatures } from './defaultPlugins';
diff --git a/packages/x-tree-view/src/RichTreeView/RichTreeView.tsx b/packages/x-tree-view/src/RichTreeView/RichTreeView.tsx
index 15cea0fe567f1..6493a4abf9020 100644
--- a/packages/x-tree-view/src/RichTreeView/RichTreeView.tsx
+++ b/packages/x-tree-view/src/RichTreeView/RichTreeView.tsx
@@ -7,7 +7,7 @@ import { getRichTreeViewUtilityClass } from './richTreeViewClasses';
 import { RichTreeViewProps, RichTreeViewSlotProps, RichTreeViewSlots } from './RichTreeView.types';
 import { useTreeView } from '../internals/useTreeView';
 import { TreeViewProvider } from '../internals/TreeViewProvider';
-import { DEFAULT_TREE_VIEW_PLUGINS } from '../internals/plugins';
+import { DEFAULT_TREE_VIEW_PLUGINS, DefaultTreeViewPluginSignatures } from '../internals/plugins';
 import { TreeItem, TreeItemProps } from '../TreeItem';
 import { buildWarning } from '../internals/utils/warning';
 import { extractPluginParamsFromProps } from '../internals/utils/extractPluginParamsFromProps';
@@ -89,7 +89,7 @@ const RichTreeView = React.forwardRef(function RichTreeView<
   }
 
   const { pluginParams, slots, slotProps, otherProps } = extractPluginParamsFromProps<
-    typeof DEFAULT_TREE_VIEW_PLUGINS,
+    DefaultTreeViewPluginSignatures,
     RichTreeViewSlots,
     RichTreeViewSlotProps<R, Multiple>,
     RichTreeViewProps<R, Multiple>
diff --git a/packages/x-tree-view/src/RichTreeView/RichTreeView.types.ts b/packages/x-tree-view/src/RichTreeView/RichTreeView.types.ts
index 974a665b69a46..9b71ae3c7a579 100644
--- a/packages/x-tree-view/src/RichTreeView/RichTreeView.types.ts
+++ b/packages/x-tree-view/src/RichTreeView/RichTreeView.types.ts
@@ -7,7 +7,7 @@ import {
   DefaultTreeViewPluginParameters,
   DefaultTreeViewPluginSlotProps,
   DefaultTreeViewPluginSlots,
-  DefaultTreeViewPlugins,
+  DefaultTreeViewPluginSignatures,
 } from '../internals/plugins/defaultPlugins';
 import { TreeItemProps } from '../TreeItem';
 import { TreeItem2Props } from '../TreeItem2';
@@ -47,7 +47,7 @@ export interface RichTreeViewSlotProps<R extends {}, Multiple extends boolean |
 }
 
 export type RichTreeViewApiRef = React.MutableRefObject<
-  TreeViewPublicAPI<DefaultTreeViewPlugins> | undefined
+  TreeViewPublicAPI<DefaultTreeViewPluginSignatures> | undefined
 >;
 
 export interface RichTreeViewPropsBase extends React.HTMLAttributes<HTMLUListElement> {
@@ -84,5 +84,5 @@ export interface RichTreeViewProps<R extends {}, Multiple extends boolean | unde
    * For each feature, if the flag is not explicitly set to `true`,
    * the feature will be fully disabled and any property / method call will not have any effect.
    */
-  experimentalFeatures?: TreeViewExperimentalFeatures<DefaultTreeViewPlugins>;
+  experimentalFeatures?: TreeViewExperimentalFeatures<DefaultTreeViewPluginSignatures>;
 }
diff --git a/packages/x-tree-view/src/SimpleTreeView/SimpleTreeView.plugins.ts b/packages/x-tree-view/src/SimpleTreeView/SimpleTreeView.plugins.ts
index 7d2cabef636fe..f380f55d4cdad 100644
--- a/packages/x-tree-view/src/SimpleTreeView/SimpleTreeView.plugins.ts
+++ b/packages/x-tree-view/src/SimpleTreeView/SimpleTreeView.plugins.ts
@@ -12,7 +12,9 @@ export const SIMPLE_TREE_VIEW_PLUGINS = [
   useTreeViewJSXItems,
 ] as const;
 
-export type SimpleTreeViewPlugins = ConvertPluginsIntoSignatures<typeof SIMPLE_TREE_VIEW_PLUGINS>;
+export type SimpleTreeViewPluginSignatures = ConvertPluginsIntoSignatures<
+  typeof SIMPLE_TREE_VIEW_PLUGINS
+>;
 
 export type SimpleTreeViewPluginSlots = DefaultTreeViewPluginSlots;
 
diff --git a/packages/x-tree-view/src/SimpleTreeView/SimpleTreeView.tsx b/packages/x-tree-view/src/SimpleTreeView/SimpleTreeView.tsx
index 297792cd511cf..f16185817fd17 100644
--- a/packages/x-tree-view/src/SimpleTreeView/SimpleTreeView.tsx
+++ b/packages/x-tree-view/src/SimpleTreeView/SimpleTreeView.tsx
@@ -6,12 +6,12 @@ import { useSlotProps } from '@mui/base/utils';
 import { getSimpleTreeViewUtilityClass } from './simpleTreeViewClasses';
 import {
   SimpleTreeViewProps,
-  SimpleTreeViewSlotProps,
   SimpleTreeViewSlots,
+  SimpleTreeViewSlotProps,
 } from './SimpleTreeView.types';
 import { useTreeView } from '../internals/useTreeView';
 import { TreeViewProvider } from '../internals/TreeViewProvider';
-import { SIMPLE_TREE_VIEW_PLUGINS } from './SimpleTreeView.plugins';
+import { SIMPLE_TREE_VIEW_PLUGINS, SimpleTreeViewPluginSignatures } from './SimpleTreeView.plugins';
 import { buildWarning } from '../internals/utils/warning';
 import { extractPluginParamsFromProps } from '../internals/utils/extractPluginParamsFromProps';
 
@@ -74,7 +74,7 @@ const SimpleTreeView = React.forwardRef(function SimpleTreeView<
   }
 
   const { pluginParams, slots, slotProps, otherProps } = extractPluginParamsFromProps<
-    typeof SIMPLE_TREE_VIEW_PLUGINS,
+    SimpleTreeViewPluginSignatures,
     SimpleTreeViewSlots,
     SimpleTreeViewSlotProps,
     SimpleTreeViewProps<Multiple> & { items: any }
diff --git a/packages/x-tree-view/src/SimpleTreeView/SimpleTreeView.types.ts b/packages/x-tree-view/src/SimpleTreeView/SimpleTreeView.types.ts
index b7e0ddcbbcdb2..958dbcbf83482 100644
--- a/packages/x-tree-view/src/SimpleTreeView/SimpleTreeView.types.ts
+++ b/packages/x-tree-view/src/SimpleTreeView/SimpleTreeView.types.ts
@@ -7,7 +7,7 @@ import {
   SimpleTreeViewPluginParameters,
   SimpleTreeViewPluginSlotProps,
   SimpleTreeViewPluginSlots,
-  SimpleTreeViewPlugins,
+  SimpleTreeViewPluginSignatures,
 } from './SimpleTreeView.plugins';
 import { TreeViewExperimentalFeatures, TreeViewPublicAPI } from '../internals/models';
 
@@ -24,7 +24,7 @@ export interface SimpleTreeViewSlotProps extends SimpleTreeViewPluginSlotProps {
 }
 
 export type SimpleTreeViewApiRef = React.MutableRefObject<
-  TreeViewPublicAPI<SimpleTreeViewPlugins> | undefined
+  TreeViewPublicAPI<SimpleTreeViewPluginSignatures> | undefined
 >;
 
 export interface SimpleTreeViewProps<Multiple extends boolean | undefined>
@@ -60,5 +60,5 @@ export interface SimpleTreeViewProps<Multiple extends boolean | undefined>
    * For each feature, if the flag is not explicitly set to `true`,
    * the feature will be fully disabled and any property / method call will not have any effect.
    */
-  experimentalFeatures?: TreeViewExperimentalFeatures<SimpleTreeViewPlugins>;
+  experimentalFeatures?: TreeViewExperimentalFeatures<SimpleTreeViewPluginSignatures>;
 }
diff --git a/packages/x-tree-view/src/TreeItem/TreeItem.test.tsx b/packages/x-tree-view/src/TreeItem/TreeItem.test.tsx
index 6256ac0bb6a75..49a9702b6f238 100644
--- a/packages/x-tree-view/src/TreeItem/TreeItem.test.tsx
+++ b/packages/x-tree-view/src/TreeItem/TreeItem.test.tsx
@@ -2,14 +2,14 @@ import * as React from 'react';
 import { expect } from 'chai';
 import PropTypes from 'prop-types';
 import { createRenderer } from '@mui/internal-test-utils';
-import { SimpleTreeViewPlugins } from '@mui/x-tree-view/SimpleTreeView/SimpleTreeView.plugins';
+import { SimpleTreeViewPluginSignatures } from '@mui/x-tree-view/SimpleTreeView/SimpleTreeView.plugins';
 import { TreeItem, treeItemClasses as classes } from '@mui/x-tree-view/TreeItem';
 import { TreeViewContextValue } from '@mui/x-tree-view/internals/TreeViewProvider';
 import { TreeViewContext } from '@mui/x-tree-view/internals/TreeViewProvider/TreeViewContext';
 import { describeConformance } from 'test/utils/describeConformance';
 import { describeTreeView } from 'test/utils/tree-view/describeTreeView';
 
-const TEST_TREE_VIEW_CONTEXT_VALUE: TreeViewContextValue<SimpleTreeViewPlugins> = {
+const TEST_TREE_VIEW_CONTEXT_VALUE: TreeViewContextValue<SimpleTreeViewPluginSignatures> = {
   instance: {
     isItemExpandable: () => false,
     isItemExpanded: () => false,
diff --git a/packages/x-tree-view/src/TreeItem/TreeItem.tsx b/packages/x-tree-view/src/TreeItem/TreeItem.tsx
index a330de1af8d98..853f0371cffaf 100644
--- a/packages/x-tree-view/src/TreeItem/TreeItem.tsx
+++ b/packages/x-tree-view/src/TreeItem/TreeItem.tsx
@@ -14,7 +14,7 @@ import { TreeItemContent } from './TreeItemContent';
 import { treeItemClasses, getTreeItemUtilityClass } from './treeItemClasses';
 import { TreeItemOwnerState, TreeItemProps } from './TreeItem.types';
 import { useTreeViewContext } from '../internals/TreeViewProvider/useTreeViewContext';
-import { DefaultTreeViewPlugins } from '../internals/plugins';
+import { DefaultTreeViewPluginSignatures } from '../internals/plugins';
 import { TreeViewCollapseIcon, TreeViewExpandIcon } from '../icons';
 import { TreeItem2Provider } from '../TreeItem2Provider';
 import { TreeViewItemDepthContext } from '../internals/TreeViewItemDepthContext';
@@ -183,7 +183,7 @@ export const TreeItem = React.forwardRef(function TreeItem(
     disabledItemsFocusable,
     indentationAtItemLevel,
     instance,
-  } = useTreeViewContext<DefaultTreeViewPlugins>();
+  } = useTreeViewContext<DefaultTreeViewPluginSignatures>();
   const depthContext = React.useContext(TreeViewItemDepthContext);
 
   const props = useThemeProps({ props: inProps, name: 'MuiTreeItem' });
diff --git a/packages/x-tree-view/src/TreeItem/useTreeItemState.ts b/packages/x-tree-view/src/TreeItem/useTreeItemState.ts
index f429ac981d20b..0da618865f953 100644
--- a/packages/x-tree-view/src/TreeItem/useTreeItemState.ts
+++ b/packages/x-tree-view/src/TreeItem/useTreeItemState.ts
@@ -1,12 +1,12 @@
 import * as React from 'react';
 import { useTreeViewContext } from '../internals/TreeViewProvider/useTreeViewContext';
-import { DefaultTreeViewPlugins } from '../internals/plugins';
+import { DefaultTreeViewPluginSignatures } from '../internals/plugins';
 
 export function useTreeItemState(itemId: string) {
   const {
     instance,
     selection: { multiSelect, checkboxSelection, disableSelection },
-  } = useTreeViewContext<DefaultTreeViewPlugins>();
+  } = useTreeViewContext<DefaultTreeViewPluginSignatures>();
 
   const expandable = instance.isItemExpandable(itemId);
   const expanded = instance.isItemExpanded(itemId);
diff --git a/packages/x-tree-view/src/hooks/useTreeItem2Utils/useTreeItem2Utils.tsx b/packages/x-tree-view/src/hooks/useTreeItem2Utils/useTreeItem2Utils.tsx
index 911322d477666..deff0a1d89e5c 100644
--- a/packages/x-tree-view/src/hooks/useTreeItem2Utils/useTreeItem2Utils.tsx
+++ b/packages/x-tree-view/src/hooks/useTreeItem2Utils/useTreeItem2Utils.tsx
@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { useTreeViewContext } from '../../internals/TreeViewProvider/useTreeViewContext';
-import { DefaultTreeViewPlugins } from '../../internals/plugins';
+import { DefaultTreeViewPluginSignatures } from '../../internals/plugins';
 import type { UseTreeItem2Status } from '../../useTreeItem2';
 
 interface UseTreeItem2Interactions {
@@ -31,7 +31,7 @@ export const useTreeItem2Utils = ({
   const {
     instance,
     selection: { multiSelect },
-  } = useTreeViewContext<DefaultTreeViewPlugins>();
+  } = useTreeViewContext<DefaultTreeViewPluginSignatures>();
 
   const status: UseTreeItem2Status = {
     expandable: isItemExpandable(children),
diff --git a/packages/x-tree-view/src/hooks/useTreeViewApiRef.tsx b/packages/x-tree-view/src/hooks/useTreeViewApiRef.tsx
index 8ef984c577967..b27410f757376 100644
--- a/packages/x-tree-view/src/hooks/useTreeViewApiRef.tsx
+++ b/packages/x-tree-view/src/hooks/useTreeViewApiRef.tsx
@@ -1,10 +1,11 @@
 import * as React from 'react';
 import { TreeViewAnyPluginSignature, TreeViewPublicAPI } from '../internals/models';
-import { DefaultTreeViewPlugins } from '../internals';
+import { DefaultTreeViewPluginSignatures } from '../internals';
 
 /**
  * Hook that instantiates a [[TreeViewApiRef]].
  */
 export const useTreeViewApiRef = <
-  TPlugins extends readonly TreeViewAnyPluginSignature[] = DefaultTreeViewPlugins,
->() => React.useRef(undefined) as React.MutableRefObject<TreeViewPublicAPI<TPlugins> | undefined>;
+  TSignatures extends readonly TreeViewAnyPluginSignature[] = DefaultTreeViewPluginSignatures,
+>() =>
+  React.useRef(undefined) as React.MutableRefObject<TreeViewPublicAPI<TSignatures> | undefined>;
diff --git a/packages/x-tree-view/src/internals/TreeViewProvider/TreeViewProvider.tsx b/packages/x-tree-view/src/internals/TreeViewProvider/TreeViewProvider.tsx
index de246ec61ea3c..d855127369500 100644
--- a/packages/x-tree-view/src/internals/TreeViewProvider/TreeViewProvider.tsx
+++ b/packages/x-tree-view/src/internals/TreeViewProvider/TreeViewProvider.tsx
@@ -8,8 +8,8 @@ import { TreeViewAnyPluginSignature } from '../models';
  *
  * @ignore - do not document.
  */
-export function TreeViewProvider<TPlugins extends readonly TreeViewAnyPluginSignature[]>(
-  props: TreeViewProviderProps<TPlugins>,
+export function TreeViewProvider<TSignatures extends readonly TreeViewAnyPluginSignature[]>(
+  props: TreeViewProviderProps<TSignatures>,
 ) {
   const { value, children } = props;
 
diff --git a/packages/x-tree-view/src/internals/TreeViewProvider/TreeViewProvider.types.ts b/packages/x-tree-view/src/internals/TreeViewProvider/TreeViewProvider.types.ts
index 2d42554e5d8d5..f0af466f0f215 100644
--- a/packages/x-tree-view/src/internals/TreeViewProvider/TreeViewProvider.types.ts
+++ b/packages/x-tree-view/src/internals/TreeViewProvider/TreeViewProvider.types.ts
@@ -1,6 +1,6 @@
 import * as React from 'react';
 import {
-  MergePluginsProperty,
+  MergeSignaturesProperty,
   TreeItemWrapper,
   TreeRootWrapper,
   TreeViewAnyPluginSignature,
@@ -9,17 +9,21 @@ import {
   TreeViewPublicAPI,
 } from '../models';
 
-export type TreeViewContextValue<TPlugins extends readonly TreeViewAnyPluginSignature[]> =
-  MergePluginsProperty<TPlugins, 'contextValue'> & {
-    instance: TreeViewInstance<TPlugins>;
-    publicAPI: TreeViewPublicAPI<TPlugins>;
+export type TreeViewItemPluginsRunner = <TProps extends {}>(
+  props: TProps,
+) => Required<TreeViewItemPluginResponse>;
+
+export type TreeViewContextValue<TSignatures extends readonly TreeViewAnyPluginSignature[]> =
+  MergeSignaturesProperty<TSignatures, 'contextValue'> & {
+    instance: TreeViewInstance<TSignatures>;
+    publicAPI: TreeViewPublicAPI<TSignatures>;
     rootRef: React.RefObject<HTMLUListElement>;
-    wrapItem: TreeItemWrapper<TPlugins>;
-    wrapRoot: TreeRootWrapper<TPlugins>;
-    runItemPlugins: <TProps extends {}>(props: TProps) => Required<TreeViewItemPluginResponse>;
+    wrapItem: TreeItemWrapper<TSignatures>;
+    wrapRoot: TreeRootWrapper<TSignatures>;
+    runItemPlugins: TreeViewItemPluginsRunner;
   };
 
-export interface TreeViewProviderProps<TPlugins extends readonly TreeViewAnyPluginSignature[]> {
-  value: TreeViewContextValue<TPlugins>;
+export interface TreeViewProviderProps<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
+  value: TreeViewContextValue<TSignatures>;
   children: React.ReactNode;
 }
diff --git a/packages/x-tree-view/src/internals/TreeViewProvider/index.ts b/packages/x-tree-view/src/internals/TreeViewProvider/index.ts
index 28aff7c61d46f..ffee8fb725aa3 100644
--- a/packages/x-tree-view/src/internals/TreeViewProvider/index.ts
+++ b/packages/x-tree-view/src/internals/TreeViewProvider/index.ts
@@ -1,2 +1,6 @@
 export { TreeViewProvider } from './TreeViewProvider';
-export type { TreeViewProviderProps, TreeViewContextValue } from './TreeViewProvider.types';
+export type {
+  TreeViewProviderProps,
+  TreeViewContextValue,
+  TreeViewItemPluginsRunner,
+} from './TreeViewProvider.types';
diff --git a/packages/x-tree-view/src/internals/TreeViewProvider/useTreeViewContext.ts b/packages/x-tree-view/src/internals/TreeViewProvider/useTreeViewContext.ts
index 8da83b9b56ebb..62fbce3ad7397 100644
--- a/packages/x-tree-view/src/internals/TreeViewProvider/useTreeViewContext.ts
+++ b/packages/x-tree-view/src/internals/TreeViewProvider/useTreeViewContext.ts
@@ -3,8 +3,8 @@ import { TreeViewAnyPluginSignature } from '../models';
 import { TreeViewContext } from './TreeViewContext';
 import { TreeViewContextValue } from './TreeViewProvider.types';
 
-export const useTreeViewContext = <TPlugins extends readonly TreeViewAnyPluginSignature[]>() => {
-  const context = React.useContext(TreeViewContext) as TreeViewContextValue<TPlugins>;
+export const useTreeViewContext = <TSignatures extends readonly TreeViewAnyPluginSignature[]>() => {
+  const context = React.useContext(TreeViewContext) as TreeViewContextValue<TSignatures>;
   if (context == null) {
     throw new Error(
       [
diff --git a/packages/x-tree-view/src/internals/corePlugins/corePlugins.ts b/packages/x-tree-view/src/internals/corePlugins/corePlugins.ts
index feb26ae78c804..0d55e29829ab0 100644
--- a/packages/x-tree-view/src/internals/corePlugins/corePlugins.ts
+++ b/packages/x-tree-view/src/internals/corePlugins/corePlugins.ts
@@ -1,5 +1,5 @@
 import { useTreeViewInstanceEvents } from './useTreeViewInstanceEvents';
-import { ConvertPluginsIntoSignatures, MergePlugins } from '../models';
+import { ConvertPluginsIntoSignatures } from '../models';
 
 /**
  * Internal plugins that create the tools used by the other plugins.
@@ -7,6 +7,6 @@ import { ConvertPluginsIntoSignatures, MergePlugins } from '../models';
  */
 export const TREE_VIEW_CORE_PLUGINS = [useTreeViewInstanceEvents] as const;
 
-export type TreeViewCorePluginsSignature = MergePlugins<
-  ConvertPluginsIntoSignatures<typeof TREE_VIEW_CORE_PLUGINS>
+export type TreeViewCorePluginSignatures = ConvertPluginsIntoSignatures<
+  typeof TREE_VIEW_CORE_PLUGINS
 >;
diff --git a/packages/x-tree-view/src/internals/corePlugins/index.ts b/packages/x-tree-view/src/internals/corePlugins/index.ts
index 556277c739cec..55cb778e2bd98 100644
--- a/packages/x-tree-view/src/internals/corePlugins/index.ts
+++ b/packages/x-tree-view/src/internals/corePlugins/index.ts
@@ -1,2 +1,2 @@
 export { TREE_VIEW_CORE_PLUGINS } from './corePlugins';
-export type { TreeViewCorePluginsSignature } from './corePlugins';
+export type { TreeViewCorePluginSignatures } from './corePlugins';
diff --git a/packages/x-tree-view/src/internals/index.ts b/packages/x-tree-view/src/internals/index.ts
index 9500d00e37f34..752818a77fa09 100644
--- a/packages/x-tree-view/src/internals/index.ts
+++ b/packages/x-tree-view/src/internals/index.ts
@@ -7,7 +7,7 @@ export type {
   TreeViewPlugin,
   TreeViewPluginSignature,
   ConvertPluginsIntoSignatures,
-  MergePluginsProperty,
+  MergeSignaturesProperty,
   TreeViewPublicAPI,
   TreeViewExperimentalFeatures,
 } from './models';
@@ -15,7 +15,7 @@ export type {
 // Plugins
 export { DEFAULT_TREE_VIEW_PLUGINS } from './plugins/defaultPlugins';
 export type {
-  DefaultTreeViewPlugins,
+  DefaultTreeViewPluginSignatures,
   DefaultTreeViewPluginSlots,
   DefaultTreeViewPluginSlotProps,
 } from './plugins/defaultPlugins';
diff --git a/packages/x-tree-view/src/internals/models/helpers.ts b/packages/x-tree-view/src/internals/models/helpers.ts
index d8b259e45f467..f404e670cd90a 100644
--- a/packages/x-tree-view/src/internals/models/helpers.ts
+++ b/packages/x-tree-view/src/internals/models/helpers.ts
@@ -22,33 +22,31 @@ export type OptionalIfEmpty<A extends string, B> = keyof B extends never
     ? Partial<Record<A, B>>
     : Record<A, B>;
 
-export type MergePluginsProperty<
-  TPlugins extends readonly any[],
+export type MergeSignaturesProperty<
+  TSignatures extends readonly any[],
   TProperty extends keyof TreeViewAnyPluginSignature,
-> = TPlugins extends readonly [plugin: infer P, ...otherPlugin: infer R]
+> = TSignatures extends readonly [plugin: infer P, ...otherPlugin: infer R]
   ? P extends TreeViewAnyPluginSignature
-    ? P[TProperty] & MergePluginsProperty<R, TProperty>
+    ? P[TProperty] & MergeSignaturesProperty<R, TProperty>
     : {}
   : {};
 
-export type ConvertPluginsIntoSignatures<TPlugins extends readonly any[]> =
-  TPlugins extends readonly [plugin: infer P, ...otherPlugin: infer R]
-    ? P extends TreeViewPlugin<infer TSignature>
-      ? [TSignature, ...ConvertPluginsIntoSignatures<R>]
-      : ConvertPluginsIntoSignatures<R>
-    : [];
+export type ConvertPluginsIntoSignatures<
+  TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[],
+> = TPlugins extends readonly [plugin: infer TPlugin, ...otherPlugin: infer R]
+  ? R extends readonly TreeViewPlugin<any>[]
+    ? TPlugin extends TreeViewPlugin<infer TSignature>
+      ? readonly [TSignature, ...ConvertPluginsIntoSignatures<R>]
+      : never
+    : never
+  : [];
 
-export interface MergePlugins<TPlugins extends readonly any[]> {
-  state: MergePluginsProperty<TPlugins, 'state'>;
-  instance: MergePluginsProperty<TPlugins, 'instance'>;
-  publicAPI: MergePluginsProperty<TPlugins, 'publicAPI'>;
-  params: MergePluginsProperty<TPlugins, 'params'>;
-  defaultizedParams: MergePluginsProperty<TPlugins, 'defaultizedParams'>;
-  dependantPlugins: MergePluginsProperty<TPlugins, 'dependantPlugins'>;
-  contextValue: MergePluginsProperty<TPlugins, 'contextValue'>;
-  slots: MergePluginsProperty<TPlugins, 'slots'>;
-  slotProps: MergePluginsProperty<TPlugins, 'slotProps'>;
-  events: MergePluginsProperty<TPlugins, 'events'>;
-  models: MergePluginsProperty<TPlugins, 'models'>;
-  experimentalFeatures: MergePluginsProperty<TPlugins, 'experimentalFeatures'>;
-}
+export type ConvertSignaturesIntoPlugins<
+  TSignatures extends readonly TreeViewAnyPluginSignature[],
+> = TSignatures extends readonly [signature: infer TSignature, ...otherSignatures: infer R]
+  ? R extends readonly TreeViewAnyPluginSignature[]
+    ? TSignature extends TreeViewAnyPluginSignature
+      ? readonly [TreeViewPlugin<TSignature>, ...ConvertSignaturesIntoPlugins<R>]
+      : never
+    : never
+  : [];
diff --git a/packages/x-tree-view/src/internals/models/plugin.ts b/packages/x-tree-view/src/internals/models/plugin.ts
index 0d85c8b61754d..fd26dd4c42d7a 100644
--- a/packages/x-tree-view/src/internals/models/plugin.ts
+++ b/packages/x-tree-view/src/internals/models/plugin.ts
@@ -1,9 +1,9 @@
 import * as React from 'react';
 import { EventHandlers } from '@mui/base/utils';
 import { TreeViewExperimentalFeatures, TreeViewInstance, TreeViewModel } from './treeView';
-import type { MergePluginsProperty, OptionalIfEmpty } from './helpers';
+import type { MergeSignaturesProperty, OptionalIfEmpty } from './helpers';
 import { TreeViewEventLookupElement } from './events';
-import type { TreeViewCorePluginsSignature } from '../corePlugins';
+import type { TreeViewCorePluginSignatures } from '../corePlugins';
 import { TreeViewItemId } from '../../models';
 
 export interface TreeViewPluginOptions<TSignature extends TreeViewAnyPluginSignature> {
@@ -86,20 +86,20 @@ export type TreeViewAnyPluginSignature = {
 };
 
 type TreeViewUsedPlugins<TSignature extends TreeViewAnyPluginSignature> = [
-  TreeViewCorePluginsSignature,
+  ...TreeViewCorePluginSignatures,
   ...TSignature['dependantPlugins'],
 ];
 
 export type TreeViewUsedParams<TSignature extends TreeViewAnyPluginSignature> =
-  TSignature['params'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'params'>;
+  TSignature['params'] & MergeSignaturesProperty<TreeViewUsedPlugins<TSignature>, 'params'>;
 
 type TreeViewUsedDefaultizedParams<TSignature extends TreeViewAnyPluginSignature> =
   TSignature['defaultizedParams'] &
-    MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'defaultizedParams'>;
+    MergeSignaturesProperty<TreeViewUsedPlugins<TSignature>, 'defaultizedParams'>;
 
 export type TreeViewUsedInstance<TSignature extends TreeViewAnyPluginSignature> =
   TSignature['instance'] &
-    MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'instance'> & {
+    MergeSignaturesProperty<TreeViewUsedPlugins<TSignature>, 'instance'> & {
       /**
        * Private property only defined in TypeScript to be able to access the plugin signature from the instance object.
        */
@@ -107,7 +107,7 @@ export type TreeViewUsedInstance<TSignature extends TreeViewAnyPluginSignature>
     };
 
 type TreeViewUsedState<TSignature extends TreeViewAnyPluginSignature> = TSignature['state'] &
-  MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'state'>;
+  MergeSignaturesProperty<TreeViewUsedPlugins<TSignature>, 'state'>;
 
 type TreeViewUsedExperimentalFeatures<TSignature extends TreeViewAnyPluginSignature> =
   TreeViewExperimentalFeatures<[TSignature, ...TSignature['dependantPlugins']]>;
@@ -118,10 +118,10 @@ type RemoveSetValue<Models extends Record<string, TreeViewModel<any>>> = {
 
 export type TreeViewUsedModels<TSignature extends TreeViewAnyPluginSignature> =
   TSignature['models'] &
-    RemoveSetValue<MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'models'>>;
+    RemoveSetValue<MergeSignaturesProperty<TreeViewUsedPlugins<TSignature>, 'models'>>;
 
 export type TreeViewUsedEvents<TSignature extends TreeViewAnyPluginSignature> =
-  TSignature['events'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'events'>;
+  TSignature['events'] & MergeSignaturesProperty<TreeViewUsedPlugins<TSignature>, 'events'>;
 
 export interface TreeViewItemPluginOptions<TProps extends {}> extends TreeViewItemPluginResponse {
   props: TProps;
diff --git a/packages/x-tree-view/src/internals/models/treeView.ts b/packages/x-tree-view/src/internals/models/treeView.ts
index 80937aa10b554..e513e0f8bff52 100644
--- a/packages/x-tree-view/src/internals/models/treeView.ts
+++ b/packages/x-tree-view/src/internals/models/treeView.ts
@@ -1,5 +1,6 @@
 import type { TreeViewAnyPluginSignature } from './plugin';
-import type { MergePluginsProperty } from './helpers';
+import type { MergeSignaturesProperty } from './helpers';
+import type { TreeViewCorePluginSignatures } from '../corePlugins';
 
 export interface TreeViewItemMeta {
   id: string;
@@ -24,11 +25,11 @@ export interface TreeViewModel<TValue> {
 }
 
 export type TreeViewInstance<TSignatures extends readonly TreeViewAnyPluginSignature[]> =
-  MergePluginsProperty<TSignatures, 'instance'>;
+  MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'instance'>;
 
 export type TreeViewPublicAPI<TSignatures extends readonly TreeViewAnyPluginSignature[]> =
-  MergePluginsProperty<TSignatures, 'publicAPI'>;
+  MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'publicAPI'>;
 
 export type TreeViewExperimentalFeatures<
   TSignatures extends readonly TreeViewAnyPluginSignature[],
-> = { [key in MergePluginsProperty<TSignatures, 'experimentalFeatures'>]?: boolean };
+> = { [key in MergeSignaturesProperty<TSignatures, 'experimentalFeatures'>]?: boolean };
diff --git a/packages/x-tree-view/src/internals/plugins/defaultPlugins.ts b/packages/x-tree-view/src/internals/plugins/defaultPlugins.ts
index f737c5dcc8c9b..c6b376aac744b 100644
--- a/packages/x-tree-view/src/internals/plugins/defaultPlugins.ts
+++ b/packages/x-tree-view/src/internals/plugins/defaultPlugins.ts
@@ -5,7 +5,7 @@ import { useTreeViewSelection, UseTreeViewSelectionParameters } from './useTreeV
 import { useTreeViewFocus, UseTreeViewFocusParameters } from './useTreeViewFocus';
 import { useTreeViewKeyboardNavigation } from './useTreeViewKeyboardNavigation';
 import { useTreeViewIcons, UseTreeViewIconsParameters } from './useTreeViewIcons';
-import { ConvertPluginsIntoSignatures, MergePluginsProperty } from '../models';
+import { ConvertPluginsIntoSignatures, MergeSignaturesProperty } from '../models';
 
 export const DEFAULT_TREE_VIEW_PLUGINS = [
   useTreeViewId,
@@ -17,12 +17,17 @@ export const DEFAULT_TREE_VIEW_PLUGINS = [
   useTreeViewIcons,
 ] as const;
 
-export type DefaultTreeViewPlugins = ConvertPluginsIntoSignatures<typeof DEFAULT_TREE_VIEW_PLUGINS>;
+export type DefaultTreeViewPluginSignatures = ConvertPluginsIntoSignatures<
+  typeof DEFAULT_TREE_VIEW_PLUGINS
+>;
 
-export type DefaultTreeViewPluginSlots = MergePluginsProperty<DefaultTreeViewPlugins, 'slots'>;
+export type DefaultTreeViewPluginSlots = MergeSignaturesProperty<
+  DefaultTreeViewPluginSignatures,
+  'slots'
+>;
 
-export type DefaultTreeViewPluginSlotProps = MergePluginsProperty<
-  DefaultTreeViewPlugins,
+export type DefaultTreeViewPluginSlotProps = MergeSignaturesProperty<
+  DefaultTreeViewPluginSignatures,
   'slotProps'
 >;
 
diff --git a/packages/x-tree-view/src/internals/plugins/index.ts b/packages/x-tree-view/src/internals/plugins/index.ts
index 8b18e513cab0a..75445ff5057c8 100644
--- a/packages/x-tree-view/src/internals/plugins/index.ts
+++ b/packages/x-tree-view/src/internals/plugins/index.ts
@@ -1,2 +1,2 @@
 export { DEFAULT_TREE_VIEW_PLUGINS } from './defaultPlugins';
-export type { DefaultTreeViewPlugins } from './defaultPlugins';
+export type { DefaultTreeViewPluginSignatures } from './defaultPlugins';
diff --git a/packages/x-tree-view/src/internals/useTreeView/useTreeView.ts b/packages/x-tree-view/src/internals/useTreeView/useTreeView.ts
index 464da635e65e2..1bc1b6ed22797 100644
--- a/packages/x-tree-view/src/internals/useTreeView/useTreeView.ts
+++ b/packages/x-tree-view/src/internals/useTreeView/useTreeView.ts
@@ -5,11 +5,11 @@ import {
   TreeViewAnyPluginSignature,
   TreeViewInstance,
   TreeViewPlugin,
-  ConvertPluginsIntoSignatures,
-  MergePluginsProperty,
+  MergeSignaturesProperty,
   TreeItemWrapper,
   TreeRootWrapper,
   TreeViewPublicAPI,
+  ConvertSignaturesIntoPlugins,
 } from '../models';
 import {
   UseTreeViewDefaultizedParameters,
@@ -18,8 +18,8 @@ import {
   UseTreeViewRootSlotProps,
 } from './useTreeView.types';
 import { useTreeViewModels } from './useTreeViewModels';
-import { TreeViewContextValue } from '../TreeViewProvider';
-import { TREE_VIEW_CORE_PLUGINS } from '../corePlugins';
+import { TreeViewContextValue, TreeViewItemPluginsRunner } from '../TreeViewProvider';
+import { TREE_VIEW_CORE_PLUGINS, TreeViewCorePluginSignatures } from '../corePlugins';
 
 export function useTreeViewApiInitialization<T>(
   inputApiRef: React.MutableRefObject<T> | undefined,
@@ -36,36 +36,37 @@ export function useTreeViewApiInitialization<T>(
   return fallbackPublicApiRef.current;
 }
 
-export const useTreeView = <Plugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[]>(
-  inParams: UseTreeViewParameters<Plugins>,
-): UseTreeViewReturnValue<ConvertPluginsIntoSignatures<Plugins>> => {
-  const plugins = [...TREE_VIEW_CORE_PLUGINS, ...inParams.plugins];
-  type Signatures = ConvertPluginsIntoSignatures<typeof plugins>;
+export const useTreeView = <TSignatures extends readonly TreeViewAnyPluginSignature[]>(
+  inParams: UseTreeViewParameters<TSignatures>,
+): UseTreeViewReturnValue<TSignatures> => {
+  type TSignaturesWithCorePluginSignatures = readonly [
+    ...TreeViewCorePluginSignatures,
+    ...TSignatures,
+  ];
+  const plugins = [
+    ...TREE_VIEW_CORE_PLUGINS,
+    ...inParams.plugins,
+  ] as unknown as ConvertSignaturesIntoPlugins<TSignaturesWithCorePluginSignatures>;
 
   const params = plugins.reduce((acc, plugin) => {
     if (plugin.getDefaultizedParams) {
-      return plugin.getDefaultizedParams(acc);
+      return plugin.getDefaultizedParams(acc) as typeof acc;
     }
 
     return acc;
-  }, inParams) as unknown as UseTreeViewDefaultizedParameters<Plugins>;
+  }, inParams) as unknown as UseTreeViewDefaultizedParameters<TSignatures>;
 
-  const models = useTreeViewModels(
-    plugins,
-    params as MergePluginsProperty<Signatures, 'defaultizedParams'>,
-  );
-  const instanceRef = React.useRef<TreeViewInstance<Signatures>>(
-    {} as TreeViewInstance<Signatures>,
-  );
-  const instance = instanceRef.current as TreeViewInstance<Signatures>;
+  const models = useTreeViewModels<TSignaturesWithCorePluginSignatures>(plugins, params);
+  const instanceRef = React.useRef({} as TreeViewInstance<TSignatures>);
+  const instance = instanceRef.current as TreeViewInstance<TSignatures>;
 
-  const publicAPI = useTreeViewApiInitialization<TreeViewPublicAPI<Signatures>>(inParams.apiRef);
+  const publicAPI = useTreeViewApiInitialization<TreeViewPublicAPI<TSignatures>>(inParams.apiRef);
 
   const innerRootRef: React.RefObject<HTMLUListElement> = React.useRef(null);
   const handleRootRef = useForkRef(innerRootRef, inParams.rootRef);
 
   const [state, setState] = React.useState(() => {
-    const temp = {} as MergePluginsProperty<Signatures, 'state'>;
+    const temp = {} as MergeSignaturesProperty<TSignaturesWithCorePluginSignatures, 'state'>;
     plugins.forEach((plugin) => {
       if (plugin.getInitialState) {
         Object.assign(
@@ -78,48 +79,33 @@ export const useTreeView = <Plugins extends readonly TreeViewPlugin<TreeViewAnyP
     return temp;
   });
 
-  const rootPropsGetters: (<TOther extends EventHandlers = {}>(
-    otherHandlers: TOther,
-  ) => React.HTMLAttributes<HTMLUListElement>)[] = [];
-  const contextValue = {
-    publicAPI,
-    instance: instance as TreeViewInstance<any>,
-    rootRef: innerRootRef,
-  } as TreeViewContextValue<Signatures>;
-
-  const runPlugin = (plugin: TreeViewPlugin<TreeViewAnyPluginSignature>) => {
-    const pluginResponse = plugin({
-      instance,
-      params,
-      slots: params.slots,
-      slotProps: params.slotProps,
-      experimentalFeatures: params.experimentalFeatures,
-      state,
-      setState,
-      rootRef: innerRootRef,
-      models,
+  const itemWrappers = plugins
+    .map((plugin) => plugin.wrapItem)
+    .filter((wrapItem): wrapItem is TreeItemWrapper<any> => !!wrapItem);
+  const wrapItem: TreeItemWrapper<TSignatures> = ({ itemId, children }) => {
+    let finalChildren: React.ReactNode = children;
+    itemWrappers.forEach((itemWrapper) => {
+      finalChildren = itemWrapper({ itemId, children: finalChildren, instance });
     });
 
-    if (pluginResponse.getRootProps) {
-      rootPropsGetters.push(pluginResponse.getRootProps);
-    }
-
-    if (pluginResponse.publicAPI) {
-      Object.assign(publicAPI, pluginResponse.publicAPI);
-    }
+    return finalChildren;
+  };
 
-    if (pluginResponse.instance) {
-      Object.assign(instance, pluginResponse.instance);
-    }
+  const rootWrappers = plugins
+    .map((plugin) => plugin.wrapRoot)
+    .filter((wrapRoot): wrapRoot is TreeRootWrapper<any> => !!wrapRoot)
+    // The wrappers are reversed to ensure that the first wrapper is the outermost one.
+    .reverse();
+  const wrapRoot: TreeRootWrapper<TSignatures> = ({ children }) => {
+    let finalChildren: React.ReactNode = children;
+    rootWrappers.forEach((rootWrapper) => {
+      finalChildren = rootWrapper({ children: finalChildren, instance });
+    });
 
-    if (pluginResponse.contextValue) {
-      Object.assign(contextValue, pluginResponse.contextValue);
-    }
+    return finalChildren;
   };
 
-  plugins.forEach(runPlugin);
-
-  contextValue.runItemPlugins = (itemPluginProps) => {
+  const runItemPlugins: TreeViewItemPluginsRunner = (itemPluginProps) => {
     let finalRootRef: React.RefCallback<HTMLLIElement> | null = null;
     let finalContentRef: React.RefCallback<HTMLElement> | null = null;
 
@@ -147,33 +133,50 @@ export const useTreeView = <Plugins extends readonly TreeViewPlugin<TreeViewAnyP
     };
   };
 
-  const itemWrappers = plugins
-    .map((plugin) => plugin.wrapItem)
-    .filter((wrapItem): wrapItem is TreeItemWrapper<any> => !!wrapItem);
-  contextValue.wrapItem = ({ itemId, children }) => {
-    let finalChildren: React.ReactNode = children;
-    itemWrappers.forEach((itemWrapper) => {
-      finalChildren = itemWrapper({ itemId, children: finalChildren, instance });
+  const contextValue = {
+    publicAPI,
+    wrapItem,
+    wrapRoot,
+    runItemPlugins,
+    instance: instance as TreeViewInstance<any>,
+    rootRef: innerRootRef,
+  } as TreeViewContextValue<TSignatures>;
+
+  const rootPropsGetters: (<TOther extends EventHandlers = {}>(
+    otherHandlers: TOther,
+  ) => React.HTMLAttributes<HTMLUListElement>)[] = [];
+  const runPlugin = (plugin: TreeViewPlugin<TreeViewAnyPluginSignature>) => {
+    const pluginResponse = plugin({
+      instance,
+      params,
+      slots: params.slots,
+      slotProps: params.slotProps,
+      experimentalFeatures: params.experimentalFeatures,
+      state,
+      setState,
+      rootRef: innerRootRef,
+      models,
     });
 
-    return finalChildren;
-  };
+    if (pluginResponse.getRootProps) {
+      rootPropsGetters.push(pluginResponse.getRootProps);
+    }
 
-  const rootWrappers = plugins
-    .map((plugin) => plugin.wrapRoot)
-    .filter((wrapRoot): wrapRoot is TreeRootWrapper<any> => !!wrapRoot)
-    // The wrappers are reversed to ensure that the first wrapper is the outermost one.
-    .reverse();
+    if (pluginResponse.publicAPI) {
+      Object.assign(publicAPI, pluginResponse.publicAPI);
+    }
 
-  contextValue.wrapRoot = ({ children }) => {
-    let finalChildren: React.ReactNode = children;
-    rootWrappers.forEach((rootWrapper) => {
-      finalChildren = rootWrapper({ children: finalChildren, instance });
-    });
+    if (pluginResponse.instance) {
+      Object.assign(instance, pluginResponse.instance);
+    }
 
-    return finalChildren;
+    if (pluginResponse.contextValue) {
+      Object.assign(contextValue, pluginResponse.contextValue);
+    }
   };
 
+  plugins.forEach(runPlugin);
+
   const getRootProps = <TOther extends EventHandlers = {}>(
     otherHandlers: TOther = {} as TOther,
   ) => {
@@ -193,7 +196,7 @@ export const useTreeView = <Plugins extends readonly TreeViewPlugin<TreeViewAnyP
   return {
     getRootProps,
     rootRef: handleRootRef,
-    contextValue: contextValue as any,
-    instance: instance as any,
+    contextValue,
+    instance,
   };
 };
diff --git a/packages/x-tree-view/src/internals/useTreeView/useTreeView.types.ts b/packages/x-tree-view/src/internals/useTreeView/useTreeView.types.ts
index a4221edcf5f46..e01053f06b07e 100644
--- a/packages/x-tree-view/src/internals/useTreeView/useTreeView.types.ts
+++ b/packages/x-tree-view/src/internals/useTreeView/useTreeView.types.ts
@@ -3,36 +3,33 @@ import { EventHandlers } from '@mui/base/utils';
 import type { TreeViewContextValue } from '../TreeViewProvider';
 import {
   TreeViewAnyPluginSignature,
-  TreeViewPlugin,
-  ConvertPluginsIntoSignatures,
-  MergePluginsProperty,
+  ConvertSignaturesIntoPlugins,
+  MergeSignaturesProperty,
   TreeViewInstance,
   TreeViewPublicAPI,
   TreeViewExperimentalFeatures,
 } from '../models';
+import { TreeViewCorePluginSignatures } from '../corePlugins';
 
-export type UseTreeViewParameters<
-  TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[],
-> = UseTreeViewBaseParameters<TPlugins> &
-  MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'params'>;
+export type UseTreeViewParameters<TSignatures extends readonly TreeViewAnyPluginSignature[]> =
+  UseTreeViewBaseParameters<TSignatures> &
+    Omit<MergeSignaturesProperty<TSignatures, 'params'>, keyof UseTreeViewBaseParameters<any>>;
 
 export interface UseTreeViewBaseParameters<
-  TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[],
+  TSignatures extends readonly TreeViewAnyPluginSignature[],
 > {
-  apiRef:
-    | React.MutableRefObject<TreeViewPublicAPI<ConvertPluginsIntoSignatures<TPlugins>>>
-    | undefined;
+  apiRef: React.MutableRefObject<TreeViewPublicAPI<TSignatures>> | undefined;
   rootRef?: React.Ref<HTMLUListElement> | undefined;
-  plugins: TPlugins;
-  slots: MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'slots'>;
-  slotProps: MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'slotProps'>;
-  experimentalFeatures: TreeViewExperimentalFeatures<ConvertPluginsIntoSignatures<TPlugins>>;
+  plugins: ConvertSignaturesIntoPlugins<TSignatures>;
+  slots: MergeSignaturesProperty<TSignatures, 'slots'>;
+  slotProps: MergeSignaturesProperty<TSignatures, 'slotProps'>;
+  experimentalFeatures: TreeViewExperimentalFeatures<TSignatures>;
 }
 
 export type UseTreeViewDefaultizedParameters<
-  TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[],
-> = UseTreeViewBaseParameters<TPlugins> &
-  MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'defaultizedParams'>;
+  TSignatures extends readonly TreeViewAnyPluginSignature[],
+> = UseTreeViewBaseParameters<TSignatures> &
+  MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'defaultizedParams'>;
 
 export interface UseTreeViewRootSlotProps
   extends Pick<
@@ -42,11 +39,11 @@ export interface UseTreeViewRootSlotProps
   ref: React.Ref<HTMLUListElement>;
 }
 
-export interface UseTreeViewReturnValue<TPlugins extends readonly TreeViewAnyPluginSignature[]> {
+export interface UseTreeViewReturnValue<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
   getRootProps: <TOther extends EventHandlers = {}>(
     otherHandlers?: TOther,
   ) => UseTreeViewRootSlotProps;
   rootRef: React.RefCallback<HTMLUListElement> | null;
-  contextValue: TreeViewContextValue<TPlugins>;
-  instance: TreeViewInstance<TPlugins>;
+  contextValue: TreeViewContextValue<TSignatures>;
+  instance: TreeViewInstance<TSignatures>;
 }
diff --git a/packages/x-tree-view/src/internals/useTreeView/useTreeViewModels.ts b/packages/x-tree-view/src/internals/useTreeView/useTreeViewModels.ts
index 4e785b9b08dac..42d861fb7fa22 100644
--- a/packages/x-tree-view/src/internals/useTreeView/useTreeViewModels.ts
+++ b/packages/x-tree-view/src/internals/useTreeView/useTreeViewModels.ts
@@ -1,25 +1,19 @@
 import * as React from 'react';
 import {
   TreeViewAnyPluginSignature,
-  TreeViewPlugin,
-  ConvertPluginsIntoSignatures,
-  MergePluginsProperty,
+  ConvertSignaturesIntoPlugins,
+  MergeSignaturesProperty,
 } from '../models';
 
 /**
  * Implements the same behavior as `useControlled` but for several models.
  * The controlled models are never stored in the state, and the state is only updated if the model is not controlled.
  */
-export const useTreeViewModels = <
-  TPlugins extends readonly TreeViewPlugin<TreeViewAnyPluginSignature>[],
->(
-  plugins: TPlugins,
-  props: MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'defaultizedParams'>,
+export const useTreeViewModels = <TSignatures extends readonly TreeViewAnyPluginSignature[]>(
+  plugins: ConvertSignaturesIntoPlugins<TSignatures>,
+  props: MergeSignaturesProperty<TSignatures, 'defaultizedParams'>,
 ) => {
-  type DefaultizedParams = MergePluginsProperty<
-    ConvertPluginsIntoSignatures<TPlugins>,
-    'defaultizedParams'
-  >;
+  type DefaultizedParams = MergeSignaturesProperty<TSignatures, 'defaultizedParams'>;
 
   const modelsRef = React.useRef<{
     [modelName: string]: {
@@ -65,7 +59,7 @@ export const useTreeViewModels = <
         },
       ];
     }),
-  ) as MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'models'>;
+  ) as MergeSignaturesProperty<TSignatures, 'models'>;
 
   // We know that `modelsRef` do not vary across renders.
   /* eslint-disable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps */
diff --git a/packages/x-tree-view/src/internals/utils/extractPluginParamsFromProps.ts b/packages/x-tree-view/src/internals/utils/extractPluginParamsFromProps.ts
index 2f1f139aeb048..facfbd3bc3d00 100644
--- a/packages/x-tree-view/src/internals/utils/extractPluginParamsFromProps.ts
+++ b/packages/x-tree-view/src/internals/utils/extractPluginParamsFromProps.ts
@@ -1,24 +1,22 @@
 import * as React from 'react';
 import {
-  ConvertPluginsIntoSignatures,
-  MergePluginsProperty,
+  ConvertSignaturesIntoPlugins,
+  MergeSignaturesProperty,
+  TreeViewAnyPluginSignature,
   TreeViewExperimentalFeatures,
-  TreeViewPlugin,
   TreeViewPublicAPI,
 } from '../models';
 import { UseTreeViewBaseParameters } from '../useTreeView/useTreeView.types';
 
 export const extractPluginParamsFromProps = <
-  TPlugins extends readonly TreeViewPlugin<any>[],
-  TSlots extends MergePluginsProperty<TPlugins, 'slots'>,
-  TSlotProps extends MergePluginsProperty<TPlugins, 'slotProps'>,
+  TSignatures extends readonly TreeViewAnyPluginSignature[],
+  TSlots extends MergeSignaturesProperty<TSignatures, 'slots'>,
+  TSlotProps extends MergeSignaturesProperty<TSignatures, 'slotProps'>,
   TProps extends {
     slots?: TSlots;
     slotProps?: TSlotProps;
-    apiRef?: React.MutableRefObject<
-      TreeViewPublicAPI<ConvertPluginsIntoSignatures<TPlugins>> | undefined
-    >;
-    experimentalFeatures?: TreeViewExperimentalFeatures<ConvertPluginsIntoSignatures<TPlugins>>;
+    apiRef?: React.MutableRefObject<TreeViewPublicAPI<TSignatures> | undefined>;
+    experimentalFeatures?: TreeViewExperimentalFeatures<TSignatures>;
   },
 >({
   props: { slots, slotProps, apiRef, experimentalFeatures, ...props },
@@ -26,10 +24,10 @@ export const extractPluginParamsFromProps = <
   rootRef,
 }: {
   props: TProps;
-  plugins: TPlugins;
+  plugins: ConvertSignaturesIntoPlugins<TSignatures>;
   rootRef?: React.Ref<HTMLUListElement>;
 }) => {
-  type PluginParams = MergePluginsProperty<ConvertPluginsIntoSignatures<TPlugins>, 'params'>;
+  type PluginParams = MergeSignaturesProperty<TSignatures, 'params'>;
 
   const paramsLookup = {} as Record<keyof PluginParams, true>;
   plugins.forEach((plugin) => {
@@ -43,7 +41,7 @@ export const extractPluginParamsFromProps = <
     slotProps: slotProps ?? {},
     experimentalFeatures: experimentalFeatures ?? {},
     apiRef,
-  } as UseTreeViewBaseParameters<TPlugins> & PluginParams;
+  } as UseTreeViewBaseParameters<TSignatures> & PluginParams;
   const otherProps = {} as Omit<TProps, keyof PluginParams>;
 
   Object.keys(props).forEach((propName) => {
diff --git a/packages/x-tree-view/src/useTreeItem2/useTreeItem2.ts b/packages/x-tree-view/src/useTreeItem2/useTreeItem2.ts
index 7efc38056a9d4..479e022efa9cc 100644
--- a/packages/x-tree-view/src/useTreeItem2/useTreeItem2.ts
+++ b/packages/x-tree-view/src/useTreeItem2/useTreeItem2.ts
@@ -12,14 +12,16 @@ import {
   UseTreeItem2CheckboxSlotProps,
 } from './useTreeItem2.types';
 import { useTreeViewContext } from '../internals/TreeViewProvider/useTreeViewContext';
-import { DefaultTreeViewPlugins } from '../internals/plugins/defaultPlugins';
+import { DefaultTreeViewPluginSignatures } from '../internals/plugins/defaultPlugins';
 import { MuiCancellableEvent } from '../internals/models/MuiCancellableEvent';
 import { useTreeItem2Utils } from '../hooks/useTreeItem2Utils';
 import { TreeViewItemDepthContext } from '../internals/TreeViewItemDepthContext';
 
-export const useTreeItem2 = <TPlugins extends DefaultTreeViewPlugins = DefaultTreeViewPlugins>(
+export const useTreeItem2 = <
+  TSignatures extends DefaultTreeViewPluginSignatures = DefaultTreeViewPluginSignatures,
+>(
   parameters: UseTreeItem2Parameters,
-): UseTreeItem2ReturnValue<TPlugins> => {
+): UseTreeItem2ReturnValue<TSignatures> => {
   const {
     runItemPlugins,
     selection: { multiSelect, disableSelection, checkboxSelection },
@@ -27,7 +29,7 @@ export const useTreeItem2 = <TPlugins extends DefaultTreeViewPlugins = DefaultTr
     indentationAtItemLevel,
     instance,
     publicAPI,
-  } = useTreeViewContext<TPlugins>();
+  } = useTreeViewContext<TSignatures>();
   const depthContext = React.useContext(TreeViewItemDepthContext);
 
   const { id, itemId, label, children, rootRef } = parameters;
diff --git a/packages/x-tree-view/src/useTreeItem2/useTreeItem2.types.ts b/packages/x-tree-view/src/useTreeItem2/useTreeItem2.types.ts
index 1caae45592dbf..530c0db1ec4d6 100644
--- a/packages/x-tree-view/src/useTreeItem2/useTreeItem2.types.ts
+++ b/packages/x-tree-view/src/useTreeItem2/useTreeItem2.types.ts
@@ -110,7 +110,9 @@ export interface UseTreeItem2Status {
   disabled: boolean;
 }
 
-export interface UseTreeItem2ReturnValue<TPlugins extends readonly TreeViewAnyPluginSignature[]> {
+export interface UseTreeItem2ReturnValue<
+  TSignatures extends readonly TreeViewAnyPluginSignature[],
+> {
   /**
    * Resolver for the root slot's props.
    * @param {ExternalProps} externalProps Additional props for the root slot
@@ -170,5 +172,5 @@ export interface UseTreeItem2ReturnValue<TPlugins extends readonly TreeViewAnyPl
   /**
    * The object the allows Tree View manipulation.
    */
-  publicAPI: TreeViewPublicAPI<TPlugins>;
+  publicAPI: TreeViewPublicAPI<TSignatures>;
 }
diff --git a/test/utils/tree-view/describeTreeView/describeTreeView.tsx b/test/utils/tree-view/describeTreeView/describeTreeView.tsx
index 7cb6c9a9c8e82..82feb196b5435 100644
--- a/test/utils/tree-view/describeTreeView/describeTreeView.tsx
+++ b/test/utils/tree-view/describeTreeView/describeTreeView.tsx
@@ -16,9 +16,9 @@ import {
   DescribeTreeViewRendererUtils,
 } from './describeTreeView.types';
 
-const innerDescribeTreeView = <TPlugins extends TreeViewAnyPluginSignature[]>(
+const innerDescribeTreeView = <TSignatures extends TreeViewAnyPluginSignature[]>(
   message: string,
-  testRunner: DescribeTreeViewTestRunner<TPlugins>,
+  testRunner: DescribeTreeViewTestRunner<TSignatures>,
 ): void => {
   const { render } = createRenderer();
 
@@ -89,7 +89,7 @@ const innerDescribeTreeView = <TPlugins extends TreeViewAnyPluginSignature[]>(
     TreeViewComponent: typeof RichTreeView,
     TreeItemComponent: typeof TreeItem | typeof TreeItem2,
   ) => {
-    const objectRenderer: DescribeTreeViewRenderer<TPlugins> = ({
+    const objectRenderer: DescribeTreeViewRenderer<TSignatures> = ({
       items: rawItems,
       withErrorBoundary,
       slotProps,
@@ -132,7 +132,7 @@ const innerDescribeTreeView = <TPlugins extends TreeViewAnyPluginSignature[]>(
       return {
         setProps: result.setProps,
         setItems: (newItems) => result.setProps({ items: newItems }),
-        apiRef: apiRef as unknown as { current: TreeViewPublicAPI<TPlugins> },
+        apiRef: apiRef as unknown as { current: TreeViewPublicAPI<TSignatures> },
         ...getUtils(result),
       };
     };
@@ -147,7 +147,7 @@ const innerDescribeTreeView = <TPlugins extends TreeViewAnyPluginSignature[]>(
     TreeViewComponent: typeof SimpleTreeView,
     TreeItemComponent: typeof TreeItem | typeof TreeItem2,
   ) => {
-    const objectRenderer: DescribeTreeViewRenderer<TPlugins> = ({
+    const objectRenderer: DescribeTreeViewRenderer<TSignatures> = ({
       items: rawItems,
       withErrorBoundary,
       slots,
@@ -182,7 +182,7 @@ const innerDescribeTreeView = <TPlugins extends TreeViewAnyPluginSignature[]>(
       return {
         setProps: result.setProps,
         setItems: (newItems) => result.setProps({ children: newItems.map(renderItem) }),
-        apiRef: apiRef as unknown as { current: TreeViewPublicAPI<TPlugins> },
+        apiRef: apiRef as unknown as { current: TreeViewPublicAPI<TSignatures> },
         ...getUtils(result),
       };
     };
@@ -262,15 +262,15 @@ const innerDescribeTreeView = <TPlugins extends TreeViewAnyPluginSignature[]>(
   });
 };
 
-type Params<TPlugins extends TreeViewAnyPluginSignature[]> = [
+type Params<TSignatures extends TreeViewAnyPluginSignature[]> = [
   string,
-  DescribeTreeViewTestRunner<TPlugins>,
+  DescribeTreeViewTestRunner<TSignatures>,
 ];
 
 type DescribeTreeView = {
-  <TPlugins extends TreeViewAnyPluginSignature[]>(...args: Params<TPlugins>): void;
-  skip: <TPlugins extends TreeViewAnyPluginSignature[]>(...args: Params<TPlugins>) => void;
-  only: <TPlugins extends TreeViewAnyPluginSignature[]>(...args: Params<TPlugins>) => void;
+  <TSignatures extends TreeViewAnyPluginSignature[]>(...args: Params<TSignatures>): void;
+  skip: <TSignatures extends TreeViewAnyPluginSignature[]>(...args: Params<TSignatures>) => void;
+  only: <TSignatures extends TreeViewAnyPluginSignature[]>(...args: Params<TSignatures>) => void;
 };
 
 /**
diff --git a/test/utils/tree-view/describeTreeView/describeTreeView.types.ts b/test/utils/tree-view/describeTreeView/describeTreeView.types.ts
index daf2330aa115e..8aff13f693ed9 100644
--- a/test/utils/tree-view/describeTreeView/describeTreeView.types.ts
+++ b/test/utils/tree-view/describeTreeView/describeTreeView.types.ts
@@ -1,14 +1,14 @@
 import * as React from 'react';
 import {
-  MergePluginsProperty,
+  MergeSignaturesProperty,
   TreeViewAnyPluginSignature,
   TreeViewPublicAPI,
 } from '@mui/x-tree-view/internals/models';
 import { TreeItemProps } from '@mui/x-tree-view/TreeItem';
 import { TreeItem2Props } from '@mui/x-tree-view/TreeItem2';
 
-export type DescribeTreeViewTestRunner<TPlugins extends TreeViewAnyPluginSignature[]> = (
-  params: DescribeTreeViewTestRunnerParams<TPlugins>,
+export type DescribeTreeViewTestRunner<TSignatures extends TreeViewAnyPluginSignature[]> = (
+  params: DescribeTreeViewTestRunnerParams<TSignatures>,
 ) => void;
 
 export interface DescribeTreeViewRendererUtils {
@@ -85,17 +85,18 @@ export interface DescribeTreeViewRendererUtils {
   getSelectedTreeItems: () => string[];
 }
 
-export interface DescribeTreeViewRendererReturnValue<TPlugins extends TreeViewAnyPluginSignature[]>
-  extends DescribeTreeViewRendererUtils {
+export interface DescribeTreeViewRendererReturnValue<
+  TSignatures extends TreeViewAnyPluginSignature[],
+> extends DescribeTreeViewRendererUtils {
   /**
    * The ref object that allows Tree View manipulation.
    */
-  apiRef: { current: TreeViewPublicAPI<TPlugins> };
+  apiRef: { current: TreeViewPublicAPI<TSignatures> };
   /**
    * Passes new props to the Tree View.
-   * @param {Partial<TreeViewUsedParams<TPlugin>>} props A subset of the props accepted by the Tree View.
+   * @param {Partial<TreeViewUsedParams<TSignatures>>} props A subset of the props accepted by the Tree View.
    */
-  setProps: (props: Partial<MergePluginsProperty<TPlugins, 'params'>>) => void;
+  setProps: (props: Partial<MergeSignaturesProperty<TSignatures, 'params'>>) => void;
   /**
    * Passes new items to the Tree View.
    * @param {readyonly DescribeTreeViewItem[]} items The new items.
@@ -103,7 +104,7 @@ export interface DescribeTreeViewRendererReturnValue<TPlugins extends TreeViewAn
   setItems: (items: readonly DescribeTreeViewItem[]) => void;
 }
 
-export type DescribeTreeViewRenderer<TPlugins extends TreeViewAnyPluginSignature[]> = <
+export type DescribeTreeViewRenderer<TSignatures extends TreeViewAnyPluginSignature[]> = <
   R extends DescribeTreeViewItem,
 >(
   params: {
@@ -112,15 +113,15 @@ export type DescribeTreeViewRenderer<TPlugins extends TreeViewAnyPluginSignature
      * If `true`, the Tree View will be wrapped with an error boundary.
      */
     withErrorBoundary?: boolean;
-  } & Omit<MergePluginsProperty<TPlugins, 'params'>, 'slots' | 'slotProps'> & {
-      slots?: MergePluginsProperty<TPlugins, 'slots'> & {
+  } & Omit<MergeSignaturesProperty<TSignatures, 'params'>, 'slots' | 'slotProps'> & {
+      slots?: MergeSignaturesProperty<TSignatures, 'slots'> & {
         item?: React.ElementType<TreeItemProps | TreeItem2Props>;
       };
-      slotProps?: MergePluginsProperty<TPlugins, 'slotProps'> & {
+      slotProps?: MergeSignaturesProperty<TSignatures, 'slotProps'> & {
         item?: Partial<TreeItemProps> | Partial<TreeItem2Props>;
       };
     },
-) => DescribeTreeViewRendererReturnValue<TPlugins>;
+) => DescribeTreeViewRendererReturnValue<TSignatures>;
 
 export type DescribeTreeViewJSXRenderer = (
   element: React.ReactElement,
@@ -129,7 +130,7 @@ export type DescribeTreeViewJSXRenderer = (
 type TreeViewComponentName = 'RichTreeView' | 'RichTreeViewPro' | 'SimpleTreeView';
 type TreeItemComponentName = 'TreeItem' | 'TreeItem2';
 
-interface DescribeTreeViewTestRunnerParams<TPlugins extends TreeViewAnyPluginSignature[]> {
+interface DescribeTreeViewTestRunnerParams<TSignatures extends TreeViewAnyPluginSignature[]> {
   /**
    * Render the Tree View with its props and items defined as parameters of the "render" function as follows:
    *
@@ -140,7 +141,7 @@ interface DescribeTreeViewTestRunnerParams<TPlugins extends TreeViewAnyPluginSig
    * });
    * ```
    */
-  render: DescribeTreeViewRenderer<TPlugins>;
+  render: DescribeTreeViewRenderer<TSignatures>;
   /**
    * Render the Tree View by passing the JSX element to the renderFromJSX function as follows:
    *