@mui/x-data-grid 8.0.0-alpha.12 → 8.0.0-alpha.14

package/modern/components/quickFilter/QuickFilterContext.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+export interface QuickFilterState {
+  value: string;
+}
+export interface QuickFilterContextValue {
+  state: QuickFilterState;
+  controlRef: React.RefObject<HTMLInputElement | null>;
+  triggerRef: React.RefObject<HTMLButtonElement | null>;
+  onValueChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
+  clearValue: () => void;
+}
+export declare const QuickFilterContext: React.Context<QuickFilterContextValue | undefined>;
+export declare function useQuickFilterContext(): QuickFilterContextValue;

package/modern/components/quickFilter/QuickFilterContext.js

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export const QuickFilterContext = /*#__PURE__*/React.createContext(undefined);
+export function useQuickFilterContext() {
+  const context = React.useContext(QuickFilterContext);
+  if (context === undefined) {
+    throw new Error('MUI X: Missing context. Quick Filter subcomponents must be placed within a <QuickFilter /> component.');
+  }
+  return context;
+}

package/modern/components/quickFilter/QuickFilterControl.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { RenderProp } from "../../hooks/utils/useGridComponentRenderer.js";
+import type { GridSlotProps } from '../../models';
+import { QuickFilterState } from "./QuickFilterContext.js";
+export type QuickFilterControlProps = Omit<GridSlotProps['baseTextField'], 'className'> & {
+  /**
+   * A function to customize rendering of the component.
+   */
+  render?: RenderProp<GridSlotProps['baseTextField'], QuickFilterState>;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  className?: string | ((state: QuickFilterState) => string);
+};
+/**
+ * A component that takes user input and filters row data.
+ * It renders the `baseTextField` slot.
+ *
+ * Demos:
+ *
+ * - [Quick Filter](https://mui.com/x/react-data-grid/components/quick-filter/)
+ *
+ * API:
+ *
+ * - [QuickFilterControl API](https://mui.com/x/api/data-grid/quick-filter-control/)
+ */
+declare const QuickFilterControl: React.ForwardRefExoticComponent<QuickFilterControlProps> | React.ForwardRefExoticComponent<Omit<QuickFilterControlProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { QuickFilterControl };

package/modern/components/quickFilter/QuickFilterControl.js

@@ -0,0 +1,97 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["render", "className"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { unstable_useForkRef as useForkRef } from '@mui/utils';
+import { forwardRef } from '@mui/x-internals/forwardRef';
+import { useGridRootProps } from "../../hooks/utils/useGridRootProps.js";
+import { useGridComponentRenderer } from "../../hooks/utils/useGridComponentRenderer.js";
+import { useQuickFilterContext } from "./QuickFilterContext.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * A component that takes user input and filters row data.
+ * It renders the `baseTextField` slot.
+ *
+ * Demos:
+ *
+ * - [Quick Filter](https://mui.com/x/react-data-grid/components/quick-filter/)
+ *
+ * API:
+ *
+ * - [QuickFilterControl API](https://mui.com/x/api/data-grid/quick-filter-control/)
+ */
+const QuickFilterControl = forwardRef(function QuickFilterControl(props, ref) {
+  const {
+      render,
+      className
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const rootProps = useGridRootProps();
+  const {
+    state,
+    controlRef,
+    onValueChange,
+    clearValue
+  } = useQuickFilterContext();
+  const resolvedClassName = typeof className === 'function' ? className(state) : className;
+  const handleRef = useForkRef(controlRef, ref);
+  const handleKeyDown = event => {
+    if (event.key === 'Escape') {
+      clearValue();
+    }
+    props.onKeyDown?.(event);
+  };
+  const element = useGridComponentRenderer(rootProps.slots.baseTextField, render, _extends({}, rootProps.slotProps?.baseTextField, {
+    slotProps: _extends({
+      htmlInput: _extends({
+        role: 'searchbox'
+      }, props.slotProps?.htmlInput)
+    }, props.slotProps),
+    value: state.value,
+    className: resolvedClassName,
+    onChange: onValueChange,
+    onKeyDown: handleKeyDown
+  }, other, {
+    ref: handleRef
+  }), state);
+  return /*#__PURE__*/_jsx(React.Fragment, {
+    children: element
+  });
+});
+process.env.NODE_ENV !== "production" ? QuickFilterControl.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  autoComplete: PropTypes.string,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
+  color: PropTypes.oneOf(['error', 'primary']),
+  disabled: PropTypes.bool,
+  error: PropTypes.bool,
+  fullWidth: PropTypes.bool,
+  helperText: PropTypes.string,
+  id: PropTypes.string,
+  inputRef: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
+    current: PropTypes.object
+  })]),
+  label: PropTypes.node,
+  onChange: PropTypes.func,
+  onKeyDown: PropTypes.func,
+  placeholder: PropTypes.string,
+  /**
+   * A function to customize rendering of the component.
+   */
+  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),
+  role: PropTypes.string,
+  size: PropTypes.oneOf(['medium', 'small']),
+  slotProps: PropTypes.object,
+  style: PropTypes.object,
+  tabIndex: PropTypes.number,
+  type: PropTypes.oneOfType([PropTypes.oneOf(['button', 'checkbox', 'color', 'date', 'datetime-local', 'email', 'file', 'hidden', 'image', 'month', 'number', 'password', 'radio', 'range', 'reset', 'search', 'submit', 'tel', 'text', 'time', 'url', 'week']), PropTypes.object]),
+  value: PropTypes.string
+} : void 0;
+export { QuickFilterControl };

package/modern/components/quickFilter/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./QuickFilter.js";
+export * from "./QuickFilterControl.js";
+export * from "./QuickFilterClear.js";

package/modern/components/quickFilter/index.js

@@ -0,0 +1,3 @@
+export * from "./QuickFilter.js";
+export * from "./QuickFilterControl.js";
+export * from "./QuickFilterClear.js";

package/modern/components/toolbar/GridToolbar.d.ts

@@ -5,7 +5,7 @@ import { GridToolbarQuickFilterProps } from "./GridToolbarQuickFilter.js";
 export interface GridToolbarProps extends GridToolbarContainerProps, GridToolbarExportProps {
   /**
    * Show the quick filter component.
-   * @default false
+   * @default true
    */
   showQuickFilter?: boolean;
   /**

package/modern/components/toolbar/GridToolbar.js

@@ -20,7 +20,7 @@ const GridToolbar = forwardRef(function GridToolbar(props, ref) {
       csvOptions,
       printOptions,
       excelOptions,
-      showQuickFilter = false,
+      showQuickFilter = true,
       quickFilterProps = {}
     } = _ref,
     other = _objectWithoutPropertiesLoose(_ref, _excluded);
@@ -62,7 +62,7 @@ process.env.NODE_ENV !== "production" ? GridToolbar.propTypes = {
   }),
   /**
    * Show the quick filter component.
-   * @default false
+   * @default true
    */
   showQuickFilter: PropTypes.bool,
   /**

package/modern/components/toolbar/GridToolbarFilterButton.js

@@ -4,6 +4,7 @@ import PropTypes from 'prop-types';
 import { styled } from '@mui/material/styles';
 import { unstable_composeClasses as composeClasses, unstable_capitalize as capitalize, unstable_useId as useId } from '@mui/utils';
 import { forwardRef } from '@mui/x-internals/forwardRef';
+import { vars } from "../../constants/cssVariables.js";
 import { gridColumnLookupSelector } from "../../hooks/features/columns/gridColumnsSelector.js";
 import { useGridSelector } from "../../hooks/utils/useGridSelector.js";
 import { gridFilterActiveItemsSelector } from "../../hooks/features/filter/gridFilterSelector.js";
@@ -26,12 +27,10 @@ const GridToolbarFilterListRoot = styled('ul', {
   name: 'MuiDataGrid',
   slot: 'ToolbarFilterList',
   overridesResolver: (_props, styles) => styles.toolbarFilterList
-})(({
-  theme
-}) => ({
-  margin: theme.spacing(1, 1, 0.5),
-  padding: theme.spacing(0, 1)
-}));
+})({
+  margin: vars.spacing(1, 1, 0.5),
+  padding: vars.spacing(0, 1)
+});
 
 // FIXME(v8:romgrk): override slotProps
 

package/modern/components/toolbar/GridToolbarQuickFilter.js

@@ -1,19 +1,18 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["quickFilterParser", "quickFilterFormatter", "debounceMs", "className", "slotProps"];
+const _excluded = ["quickFilterParser", "quickFilterFormatter", "debounceMs", "className", "slotProps"],
+  _excluded2 = ["ref", "slotProps"];
 import * as React from 'react';
-import clsx from 'clsx';
 import PropTypes from 'prop-types';
-import { styled } from '@mui/material/styles';
-import { unstable_debounce as debounce } from '@mui/utils';
 import composeClasses from '@mui/utils/composeClasses';
-import { outlinedInputClasses } from '@mui/material/OutlinedInput';
+import { styled } from '@mui/system';
+import clsx from 'clsx';
+// import { NotRendered } from '../../utils/assert';
+
 import { getDataGridUtilityClass } from "../../constants/index.js";
 import { useGridApiContext } from "../../hooks/utils/useGridApiContext.js";
 import { useGridRootProps } from "../../hooks/utils/useGridRootProps.js";
-import { useGridSelector } from "../../hooks/utils/useGridSelector.js";
-import { gridQuickFilterValuesSelector } from "../../hooks/features/filter/index.js";
-import { isDeepEqual } from "../../utils/utils.js";
+import { QuickFilter, QuickFilterClear, QuickFilterControl } from "../quickFilter/index.js";
 import { jsx as _jsx } from "react/jsx-runtime";
 const useUtilityClasses = ownerState => {
   const {
@@ -24,106 +23,69 @@ const useUtilityClasses = ownerState => {
   };
   return composeClasses(slots, getDataGridUtilityClass, classes);
 };
-const GridToolbarQuickFilterRoot = styled('div', {
+
+// TODO: Use NotRendered from /utils/assert
+// Currently causes react-docgen to fail
+const GridToolbarQuickFilterRoot = styled(_props => {
+  throw new Error('Failed assertion: should not be rendered');
+}, {
   name: 'MuiDataGrid',
-  slot: 'ToolbarQuickFilter',
-  overridesResolver: (props, styles) => styles.toolbarQuickFilter
-})(({
-  theme
-}) => ({
-  [`.${outlinedInputClasses.root}`]: {
-    fontSize: theme.typography.body2.fontSize
-  },
-  [`& input[type="search"]::-webkit-search-decoration,
-  & input[type="search"]::-webkit-search-cancel-button,
-  & input[type="search"]::-webkit-search-results-button,
-  & input[type="search"]::-webkit-search-results-decoration`]: {
-    /* clears the 'X' icon from Chrome */
-    display: 'none'
-  }
-}));
-const defaultSearchValueParser = searchText => searchText.split(' ').filter(word => word !== '');
-const defaultSearchValueFormatter = values => values.join(' ');
+  slot: 'ToolbarQuickFilter'
+})({
+  width: 260,
+  marginLeft: 'auto'
+});
 function GridToolbarQuickFilter(props) {
   const apiRef = useGridApiContext();
   const rootProps = useGridRootProps();
   const classes = useUtilityClasses(rootProps);
-  const quickFilterValues = useGridSelector(apiRef, gridQuickFilterValuesSelector);
   const {
-      quickFilterParser = defaultSearchValueParser,
-      quickFilterFormatter = defaultSearchValueFormatter,
-      debounceMs = rootProps.filterDebounceMs,
+      quickFilterParser,
+      quickFilterFormatter,
+      debounceMs,
       className,
       slotProps
     } = props,
     other = _objectWithoutPropertiesLoose(props, _excluded);
-  const [searchValue, setSearchValue] = React.useState(() => quickFilterFormatter(quickFilterValues ?? []));
-  const prevQuickFilterValuesRef = React.useRef(quickFilterValues);
-  React.useEffect(() => {
-    if (!isDeepEqual(prevQuickFilterValuesRef.current, quickFilterValues)) {
-      // The model of quick filter value has been updated
-      prevQuickFilterValuesRef.current = quickFilterValues;
-
-      // Update the input value if needed to match the new model
-      setSearchValue(prevSearchValue => isDeepEqual(quickFilterParser(prevSearchValue), quickFilterValues) ? prevSearchValue : quickFilterFormatter(quickFilterValues ?? []));
-    }
-  }, [quickFilterValues, quickFilterFormatter, quickFilterParser]);
-  const updateSearchValue = React.useCallback(newSearchValue => {
-    const newQuickFilterValues = quickFilterParser(newSearchValue);
-    prevQuickFilterValuesRef.current = newQuickFilterValues;
-    apiRef.current.setQuickFilterValues(newQuickFilterValues);
-  }, [apiRef, quickFilterParser]);
-  const debouncedUpdateSearchValue = React.useMemo(() => debounce(updateSearchValue, debounceMs), [updateSearchValue, debounceMs]);
-  React.useEffect(() => debouncedUpdateSearchValue.clear, [debouncedUpdateSearchValue]);
-  const handleSearchValueChange = React.useCallback(event => {
-    const newSearchValue = event.target.value;
-    setSearchValue(newSearchValue);
-    debouncedUpdateSearchValue(newSearchValue);
-  }, [debouncedUpdateSearchValue]);
-  const handleSearchReset = React.useCallback(() => {
-    setSearchValue('');
-    updateSearchValue('');
-  }, [updateSearchValue]);
-  return /*#__PURE__*/_jsx(GridToolbarQuickFilterRoot, _extends({
-    as: rootProps.slots.baseTextField,
-    ownerState: rootProps,
-    size: "small",
-    value: searchValue,
-    onChange: handleSearchValueChange,
-    className: clsx(classes.root, className),
-    placeholder: apiRef.current.getLocaleText('toolbarQuickFilterPlaceholder'),
-    "aria-label": apiRef.current.getLocaleText('toolbarQuickFilterLabel'),
-    type: "search"
-  }, other, {
-    slotProps: _extends({}, slotProps?.root.slotProps, {
-      input: _extends({
-        startAdornment: /*#__PURE__*/_jsx(rootProps.slots.baseInputAdornment, {
-          position: "start",
-          children: /*#__PURE__*/_jsx(rootProps.slots.quickFilterIcon, {
-            fontSize: "small"
-          })
-        }),
-        endAdornment: /*#__PURE__*/_jsx(rootProps.slots.baseInputAdornment, {
-          position: "end",
-          children: /*#__PURE__*/_jsx(rootProps.slots.baseIconButton, _extends({
-            "aria-label": apiRef.current.getLocaleText('toolbarQuickFilterDeleteIconLabel'),
-            size: "small",
-            edge: "end",
-            style: searchValue ? {
-              visibility: 'visible'
-            } : {
-              visibility: 'hidden'
-            },
-            onClick: handleSearchReset
-          }, rootProps.slotProps?.baseIconButton, {
-            children: /*#__PURE__*/_jsx(rootProps.slots.quickFilterClearIcon, {
-              fontSize: "small"
-            })
-          }))
-        })
-      }, slotProps?.root.slotProps?.input)
+  return /*#__PURE__*/_jsx(QuickFilter, {
+    parser: quickFilterParser,
+    formatter: quickFilterFormatter,
+    debounceMs: debounceMs,
+    children: /*#__PURE__*/_jsx(QuickFilterControl, {
+      render: _ref => {
+        let {
+            ref,
+            slotProps: controlSlotProps
+          } = _ref,
+          controlProps = _objectWithoutPropertiesLoose(_ref, _excluded2);
+        return /*#__PURE__*/_jsx(GridToolbarQuickFilterRoot, _extends({
+          as: rootProps.slots.baseTextField,
+          className: clsx(classes.root, className),
+          inputRef: ref,
+          "aria-label": apiRef.current.getLocaleText('toolbarQuickFilterLabel'),
+          placeholder: apiRef.current.getLocaleText('toolbarQuickFilterPlaceholder'),
+          size: "small",
+          slotProps: _extends({
+            input: _extends({
+              startAdornment: /*#__PURE__*/_jsx(rootProps.slots.quickFilterIcon, {
+                fontSize: "small"
+              }),
+              endAdornment: controlProps.value ? /*#__PURE__*/_jsx(QuickFilterClear, {
+                render: /*#__PURE__*/_jsx(rootProps.slots.baseIconButton, {
+                  size: "small",
+                  edge: "end",
+                  "aria-label": apiRef.current.getLocaleText('toolbarQuickFilterDeleteIconLabel'),
+                  children: /*#__PURE__*/_jsx(rootProps.slots.quickFilterClearIcon, {
+                    fontSize: "small"
+                  })
+                })
+              }) : null
+            }, controlSlotProps?.input)
+          }, controlSlotProps)
+        }, rootProps.slotProps?.baseTextField, controlProps, slotProps?.root, other));
+      }
     })
-  }, rootProps.slotProps?.baseTextField));
+  });
 }
 process.env.NODE_ENV !== "production" ? GridToolbarQuickFilter.propTypes = {
   // ----------------------------- Warning --------------------------------

package/modern/components/toolbarV8/GridToolbar.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { GridSlotProps } from "../../models/gridSlotsComponentsProps.js";
+interface GridToolbarInternalProps {
+  additionalExportMenuItems?: (onMenuItemClick: () => void) => React.ReactNode;
+}
+export type GridToolbarProps = GridSlotProps['toolbar'] & GridToolbarInternalProps;
+declare function GridToolbar(props: GridToolbarProps): React.JSX.Element;
+declare namespace GridToolbar {
+  var propTypes: any;
+}
+export { GridToolbar };

package/modern/components/toolbarV8/GridToolbar.js

@@ -0,0 +1,135 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import Menu from '@mui/material/Menu';
+import useId from '@mui/utils/useId';
+import { styled } from '@mui/system';
+import { Toolbar } from "./Toolbar.js";
+import { ToolbarButton } from "./ToolbarButton.js";
+import { FilterPanelTrigger } from "../filterPanel/index.js";
+import { ColumnsPanelTrigger } from "../columnsPanel/index.js";
+import { ExportCsv, ExportPrint } from "../export/index.js";
+import { GridToolbarQuickFilter } from "../toolbar/GridToolbarQuickFilter.js";
+import { useGridRootProps } from "../../hooks/utils/useGridRootProps.js";
+import { useGridApiContext } from "../../hooks/utils/useGridApiContext.js";
+import { NotRendered } from "../../utils/assert.js";
+import { vars } from "../../constants/cssVariables.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const Divider = styled(NotRendered, {
+  name: 'MuiDataGrid',
+  slot: 'ToolbarDivider'
+})({
+  height: '50%',
+  margin: vars.spacing(0, 0.5)
+});
+function GridToolbar(props) {
+  const {
+    showQuickFilter = true,
+    quickFilterProps,
+    csvOptions,
+    printOptions,
+    additionalExportMenuItems
+  } = props;
+  const apiRef = useGridApiContext();
+  const rootProps = useGridRootProps();
+  const [exportMenuOpen, setExportMenuOpen] = React.useState(false);
+  const exportMenuTriggerRef = React.useRef(null);
+  const exportMenuId = useId();
+  const exportMenuTriggerId = useId();
+  const showExportMenu = !csvOptions?.disableToolbarButton || !printOptions?.disableToolbarButton || additionalExportMenuItems;
+  const closeExportMenu = () => setExportMenuOpen(false);
+  return /*#__PURE__*/_jsxs(Toolbar, {
+    children: [!rootProps.disableColumnSelector && /*#__PURE__*/_jsx(rootProps.slots.baseTooltip, {
+      title: apiRef.current.getLocaleText('toolbarColumns'),
+      children: /*#__PURE__*/_jsx(ColumnsPanelTrigger, {
+        render: /*#__PURE__*/_jsx(ToolbarButton, {}),
+        children: /*#__PURE__*/_jsx(rootProps.slots.columnSelectorIcon, {
+          fontSize: "small"
+        })
+      })
+    }), !rootProps.disableColumnFilter && /*#__PURE__*/_jsx(rootProps.slots.baseTooltip, {
+      title: apiRef.current.getLocaleText('toolbarFilters'),
+      children: /*#__PURE__*/_jsx(FilterPanelTrigger, {
+        render: (triggerProps, state) => /*#__PURE__*/_jsx(ToolbarButton, _extends({}, triggerProps, {
+          color: "default",
+          children: /*#__PURE__*/_jsx(rootProps.slots.baseBadge, {
+            badgeContent: state.filterCount,
+            color: "primary",
+            variant: "dot",
+            children: /*#__PURE__*/_jsx(rootProps.slots.openFilterButtonIcon, {
+              fontSize: "small"
+            })
+          })
+        }))
+      })
+    }), showExportMenu && (!rootProps.disableColumnFilter || !rootProps.disableColumnSelector) && /*#__PURE__*/_jsx(Divider, {
+      as: rootProps.slots.baseDivider,
+      orientation: "vertical"
+    }), showExportMenu && /*#__PURE__*/_jsxs(React.Fragment, {
+      children: [/*#__PURE__*/_jsx(rootProps.slots.baseTooltip, {
+        title: apiRef.current.getLocaleText('toolbarExport'),
+        children: /*#__PURE__*/_jsx(ToolbarButton, {
+          ref: exportMenuTriggerRef,
+          id: exportMenuTriggerId,
+          "aria-controls": exportMenuId,
+          "aria-haspopup": "true",
+          "aria-expanded": exportMenuOpen ? 'true' : undefined,
+          onClick: () => setExportMenuOpen(true),
+          children: /*#__PURE__*/_jsx(rootProps.slots.exportIcon, {
+            fontSize: "small"
+          })
+        })
+      }), /*#__PURE__*/_jsxs(Menu, {
+        id: exportMenuId,
+        anchorEl: exportMenuTriggerRef.current,
+        open: exportMenuOpen,
+        onClose: closeExportMenu,
+        MenuListProps: {
+          'aria-labelledby': exportMenuTriggerId
+        },
+        children: [!printOptions?.disableToolbarButton && /*#__PURE__*/_jsx(ExportPrint, {
+          render: /*#__PURE__*/_jsx(rootProps.slots.baseMenuItem, _extends({}, rootProps.slotProps?.baseMenuItem)),
+          options: printOptions,
+          onClick: closeExportMenu,
+          children: apiRef.current.getLocaleText('toolbarExportPrint')
+        }), !csvOptions?.disableToolbarButton && /*#__PURE__*/_jsx(ExportCsv, {
+          render: /*#__PURE__*/_jsx(rootProps.slots.baseMenuItem, _extends({}, rootProps.slotProps?.baseMenuItem)),
+          options: csvOptions,
+          onClick: closeExportMenu,
+          children: apiRef.current.getLocaleText('toolbarExportCSV')
+        }), additionalExportMenuItems?.(closeExportMenu)]
+      })]
+    }), showQuickFilter && /*#__PURE__*/_jsx(GridToolbarQuickFilter, _extends({}, quickFilterProps))]
+  });
+}
+process.env.NODE_ENV !== "production" ? GridToolbar.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  additionalExportMenuItems: PropTypes.func,
+  csvOptions: PropTypes.object,
+  printOptions: PropTypes.object,
+  /**
+   * Props passed to the quick filter component.
+   */
+  quickFilterProps: PropTypes.shape({
+    className: PropTypes.string,
+    debounceMs: PropTypes.number,
+    quickFilterFormatter: PropTypes.func,
+    quickFilterParser: PropTypes.func,
+    slotProps: PropTypes.object
+  }),
+  /**
+   * Show the quick filter component.
+   * @default true
+   */
+  showQuickFilter: PropTypes.bool,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: PropTypes.object,
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
+} : void 0;
+export { GridToolbar };

package/modern/components/toolbarV8/Toolbar.d.ts

@@ -0,0 +1,32 @@
+import * as React from 'react';
+import { RenderProp } from "../../hooks/utils/useGridComponentRenderer.js";
+import type { DataGridProcessedProps } from '../../models/props/DataGridProps';
+export type ToolbarProps = React.HTMLAttributes<HTMLDivElement> & {
+  /**
+   * A function to customize rendering of the component.
+   */
+  render?: RenderProp<React.ComponentProps<typeof ToolbarRoot>>;
+};
+type OwnerState = DataGridProcessedProps;
+declare const ToolbarRoot: import("@emotion/styled").StyledComponent<import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme> & {
+  ownerState: OwnerState;
+}, Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.ClassAttributes<HTMLDivElement> | keyof React.HTMLAttributes<HTMLDivElement>>, {}>;
+/**
+ * The top level Toolbar component that provides context to child components.
+ * It renders a styled `<div />` element.
+ *
+ * Demos:
+ *
+ * - [Toolbar](https://mui.com/x/react-data-grid/components/toolbar/)
+ *
+ * API:
+ *
+ * - [Toolbar API](https://mui.com/x/api/data-grid/toolbar/)
+ */
+declare const Toolbar: React.ForwardRefExoticComponent<ToolbarProps> | React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+  /**
+   * A function to customize rendering of the component.
+   */
+  render?: RenderProp<React.ComponentProps<typeof ToolbarRoot>>;
+} & React.RefAttributes<HTMLDivElement>>;
+export { Toolbar };