@mui/x-data-grid 8.0.0-beta.1 → 8.0.0-beta.2

package/esm/components/quickFilter/QuickFilter.js

@@ -1,19 +1,25 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["render", "className", "parser", "formatter", "debounceMs", "defaultExpanded", "expanded", "onExpandedChange"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import { unstable_debounce as debounce } from '@mui/utils';
+import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
+import useId from '@mui/utils/useId';
+import { isDeepEqual } from '@mui/x-internals/isDeepEqual';
 import { QuickFilterContext } from "./QuickFilterContext.js";
+import { useGridComponentRenderer } from "../../hooks/utils/useGridComponentRenderer.js";
 import { useGridApiContext } from "../../hooks/utils/useGridApiContext.js";
 import { useGridSelector } from "../../hooks/utils/useGridSelector.js";
 import { gridQuickFilterValuesSelector } from "../../hooks/features/filter/index.js";
 import { useGridRootProps } from "../../hooks/utils/useGridRootProps.js";
-import { isDeepEqual } from "../../utils/utils.js";
 import { jsx as _jsx } from "react/jsx-runtime";
 const DEFAULT_PARSER = searchText => searchText.split(' ').filter(word => word !== '');
 const DEFAULT_FORMATTER = values => values.join(' ');
 
 /**
  * The top level Quick Filter component that provides context to child components.
- * It does not render any DOM elements.
+ * It renders a `<div />` element.
  *
  * Demos:
  *
@@ -26,16 +32,38 @@ const DEFAULT_FORMATTER = values => values.join(' ');
 function QuickFilter(props) {
   const rootProps = useGridRootProps();
   const {
-    parser = DEFAULT_PARSER,
-    formatter = DEFAULT_FORMATTER,
-    debounceMs = rootProps.filterDebounceMs,
-    children
-  } = props;
+      render,
+      className,
+      parser = DEFAULT_PARSER,
+      formatter = DEFAULT_FORMATTER,
+      debounceMs = rootProps.filterDebounceMs,
+      defaultExpanded,
+      expanded,
+      onExpandedChange
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
   const apiRef = useGridApiContext();
   const controlRef = React.useRef(null);
   const triggerRef = React.useRef(null);
   const quickFilterValues = useGridSelector(apiRef, gridQuickFilterValuesSelector);
   const [value, setValue] = React.useState(formatter(quickFilterValues ?? []));
+  const [internalExpanded, setInternalExpanded] = React.useState(defaultExpanded ?? value.length > 0);
+  const expandedValue = expanded ?? internalExpanded;
+  const state = React.useMemo(() => ({
+    value,
+    expanded: expandedValue
+  }), [value, expandedValue]);
+  const resolvedClassName = typeof className === 'function' ? className(state) : className;
+  const ref = React.useRef(null);
+  const controlId = useId();
+  const handleExpandedChange = React.useCallback(newExpanded => {
+    if (onExpandedChange) {
+      onExpandedChange(newExpanded);
+    }
+    if (expanded === undefined) {
+      setInternalExpanded(newExpanded);
+    }
+  }, [onExpandedChange, expanded]);
   const prevQuickFilterValuesRef = React.useRef(quickFilterValues);
   React.useEffect(() => {
     if (!isDeepEqual(prevQuickFilterValuesRef.current, quickFilterValues)) {
@@ -46,6 +74,31 @@ function QuickFilter(props) {
       setValue(prevSearchValue => isDeepEqual(parser(prevSearchValue), quickFilterValues) ? prevSearchValue : formatter(quickFilterValues ?? []));
     }
   }, [quickFilterValues, formatter, parser]);
+  const isFirstRender = React.useRef(true);
+  const previousExpandedValue = React.useRef(expandedValue);
+  React.useEffect(() => {
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+      return;
+    }
+
+    // Ensure the expanded state has actually changed before focusing
+    if (previousExpandedValue.current !== expandedValue) {
+      if (expandedValue) {
+        // Ensures the focus does not interupt CSS transitions and animations on the control
+        requestAnimationFrame(() => {
+          controlRef.current?.focus({
+            preventScroll: true
+          });
+        });
+      } else {
+        triggerRef.current?.focus({
+          preventScroll: true
+        });
+      }
+      previousExpandedValue.current = expandedValue;
+    }
+  }, [expandedValue]);
   const setQuickFilterValueDebounced = React.useMemo(() => debounce(newValue => {
     const newQuickFilterValues = parser(newValue);
     prevQuickFilterValuesRef.current = newQuickFilterValues;
@@ -57,7 +110,7 @@ function QuickFilter(props) {
     setValue(newValue);
     setQuickFilterValueDebounced(newValue);
   }, [setQuickFilterValueDebounced]);
-  const handleClear = React.useCallback(() => {
+  const handleClearValue = React.useCallback(() => {
     setValue('');
     apiRef.current.setQuickFilterValues([]);
     controlRef.current?.focus();
@@ -65,15 +118,25 @@ function QuickFilter(props) {
   const contextValue = React.useMemo(() => ({
     controlRef,
     triggerRef,
-    state: {
-      value
-    },
-    clearValue: handleClear,
-    onValueChange: handleValueChange
-  }), [value, handleValueChange, handleClear]);
+    state,
+    controlId,
+    clearValue: handleClearValue,
+    onValueChange: handleValueChange,
+    onExpandedChange: handleExpandedChange
+  }), [controlId, state, handleValueChange, handleClearValue, handleExpandedChange]);
+  useEnhancedEffect(() => {
+    if (ref.current && triggerRef.current) {
+      ref.current.style.setProperty('--trigger-width', `${triggerRef.current?.offsetWidth}px`);
+    }
+  }, []);
+  const element = useGridComponentRenderer('div', render, _extends({
+    className: resolvedClassName
+  }, other, {
+    ref
+  }), state);
   return /*#__PURE__*/_jsx(QuickFilterContext.Provider, {
     value: contextValue,
-    children: children
+    children: element
   });
 }
 process.env.NODE_ENV !== "production" ? QuickFilter.propTypes = {
@@ -81,12 +144,24 @@ process.env.NODE_ENV !== "production" ? QuickFilter.propTypes = {
   // | These PropTypes are generated from the TypeScript type definitions |
   // | To update them edit the TypeScript types and run "pnpm proptypes"  |
   // ----------------------------------------------------------------------
-  children: PropTypes.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
   /**
    * The debounce time in milliseconds.
    * @default 150
    */
   debounceMs: PropTypes.number,
+  /**
+   * The default expanded state of the quick filter control.
+   * @default false
+   */
+  defaultExpanded: PropTypes.bool,
+  /**
+   * The expanded state of the quick filter control.
+   */
+  expanded: PropTypes.bool,
   /**
    * Function responsible for formatting values of quick filter in a string when the model is modified
    * @param {any[]} values The new values passed to the quick filter model
@@ -94,12 +169,21 @@ process.env.NODE_ENV !== "production" ? QuickFilter.propTypes = {
    * @default (values: string[]) => values.join(' ')
    */
   formatter: PropTypes.func,
+  /**
+   * Callback function that is called when the quick filter input is expanded or collapsed.
+   * @param {boolean} expanded The new expanded state of the quick filter control
+   */
+  onExpandedChange: PropTypes.func,
   /**
    * Function responsible for parsing text input in an array of independent values for quick filtering.
    * @param {string} input The value entered by the user
    * @returns {any[]} The array of value on which quick filter is applied
    * @default (searchText: string) => searchText.split(' ').filter((word) => word !== '')
    */
-  parser: PropTypes.func
+  parser: PropTypes.func,
+  /**
+   * A function to customize rendering of the component.
+   */
+  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])
 } : void 0;
 export { QuickFilter };

package/esm/components/quickFilter/QuickFilterClear.js

@@ -1,6 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["render", "className"];
+const _excluded = ["render", "className", "onClick"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import { forwardRef } from '@mui/x-internals/forwardRef';
@@ -23,7 +23,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
 const QuickFilterClear = forwardRef(function QuickFilterClear(props, ref) {
   const {
       render,
-      className
+      className,
+      onClick
     } = props,
     other = _objectWithoutPropertiesLoose(props, _excluded);
   const rootProps = useGridRootProps();
@@ -32,10 +33,15 @@ const QuickFilterClear = forwardRef(function QuickFilterClear(props, ref) {
     clearValue
   } = useQuickFilterContext();
   const resolvedClassName = typeof className === 'function' ? className(state) : className;
+  const handleClick = event => {
+    clearValue();
+    onClick?.(event);
+  };
   const element = useGridComponentRenderer(rootProps.slots.baseIconButton, render, _extends({}, rootProps.slotProps?.baseIconButton, {
-    onClick: clearValue,
-    className: resolvedClassName
+    className: resolvedClassName,
+    tabIndex: -1
   }, other, {
+    onClick: handleClick,
     ref
   }), state);
   return /*#__PURE__*/_jsx(React.Fragment, {

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

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

package/esm/components/quickFilter/QuickFilterControl.js

@@ -1,6 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["render", "className"];
+const _excluded = ["render", "className", "slotProps", "onKeyDown", "onChange"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import { unstable_useForkRef as useForkRef } from '@mui/utils';
@@ -24,35 +24,61 @@ import { jsx as _jsx } from "react/jsx-runtime";
 const QuickFilterControl = forwardRef(function QuickFilterControl(props, ref) {
   const {
       render,
-      className
+      className,
+      slotProps,
+      onKeyDown,
+      onChange
     } = props,
     other = _objectWithoutPropertiesLoose(props, _excluded);
   const rootProps = useGridRootProps();
   const {
     state,
+    controlId,
     controlRef,
     onValueChange,
+    onExpandedChange,
     clearValue
   } = useQuickFilterContext();
   const resolvedClassName = typeof className === 'function' ? className(state) : className;
   const handleRef = useForkRef(controlRef, ref);
   const handleKeyDown = event => {
     if (event.key === 'Escape') {
-      clearValue();
+      if (state.value === '') {
+        onExpandedChange(false);
+      } else {
+        clearValue();
+      }
     }
-    props.onKeyDown?.(event);
+    onKeyDown?.(event);
+  };
+  const handleBlur = event => {
+    if (state.value === '') {
+      onExpandedChange(false);
+    }
+    slotProps?.htmlInput?.onBlur?.(event);
+  };
+  const handleChange = event => {
+    if (!state.expanded) {
+      onExpandedChange(true);
+    }
+    onValueChange(event);
+    onChange?.(event);
   };
   const element = useGridComponentRenderer(rootProps.slots.baseTextField, render, _extends({}, rootProps.slotProps?.baseTextField, {
     slotProps: _extends({
       htmlInput: _extends({
-        role: 'searchbox'
-      }, props.slotProps?.htmlInput)
-    }, props.slotProps),
+        role: 'searchbox',
+        id: controlId,
+        tabIndex: state.expanded ? undefined : -1
+      }, slotProps?.htmlInput, {
+        onBlur: handleBlur
+      })
+    }, slotProps),
     value: state.value,
-    className: resolvedClassName,
-    onChange: onValueChange,
-    onKeyDown: handleKeyDown
+    className: resolvedClassName
   }, other, {
+    onChange: handleChange,
+    onKeyDown: handleKeyDown,
     ref: handleRef
   }), state);
   return /*#__PURE__*/_jsx(React.Fragment, {

package/esm/components/quickFilter/QuickFilterTrigger.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 QuickFilterTriggerProps = Omit<GridSlotProps['baseButton'], 'className'> & {
+  /**
+   * A function to customize rendering of the component.
+   */
+  render?: RenderProp<GridSlotProps['baseButton'], QuickFilterState>;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  className?: string | ((state: QuickFilterState) => string);
+};
+/**
+ * A button that expands/collapses the quick filter.
+ * It renders the `baseButton` slot.
+ *
+ * Demos:
+ *
+ * - [Quick Filter](https://mui.com/x/react-data-grid/components/quick-filter/)
+ *
+ * API:
+ *
+ * - [QuickFilterTrigger API](https://mui.com/x/api/data-grid/quick-filter-trigger/)
+ */
+declare const QuickFilterTrigger: React.ForwardRefExoticComponent<QuickFilterTriggerProps> | React.ForwardRefExoticComponent<Omit<QuickFilterTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { QuickFilterTrigger };

package/esm/components/quickFilter/QuickFilterTrigger.js

@@ -0,0 +1,204 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["render", "className", "onClick"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { forwardRef } from '@mui/x-internals/forwardRef';
+import { unstable_useForkRef as useForkRef } from '@mui/utils';
+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 button that expands/collapses the quick filter.
+ * It renders the `baseButton` slot.
+ *
+ * Demos:
+ *
+ * - [Quick Filter](https://mui.com/x/react-data-grid/components/quick-filter/)
+ *
+ * API:
+ *
+ * - [QuickFilterTrigger API](https://mui.com/x/api/data-grid/quick-filter-trigger/)
+ */
+const QuickFilterTrigger = forwardRef(function QuickFilterTrigger(props, ref) {
+  const {
+      render,
+      className,
+      onClick
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const rootProps = useGridRootProps();
+  const {
+    state,
+    controlId,
+    onExpandedChange,
+    triggerRef
+  } = useQuickFilterContext();
+  const resolvedClassName = typeof className === 'function' ? className(state) : className;
+  const handleRef = useForkRef(triggerRef, ref);
+  const handleClick = event => {
+    onExpandedChange(!state.expanded);
+    onClick?.(event);
+  };
+  const element = useGridComponentRenderer(rootProps.slots.baseButton, render, _extends({}, rootProps.slotProps?.baseButton, {
+    className: resolvedClassName,
+    'aria-controls': controlId,
+    'aria-expanded': state.expanded
+  }, other, {
+    onClick: handleClick,
+    ref: handleRef
+  }), state);
+  return /*#__PURE__*/_jsx(React.Fragment, {
+    children: element
+  });
+});
+process.env.NODE_ENV !== "production" ? QuickFilterTrigger.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * A ref for imperative actions.
+   * It currently only supports `focusVisible()` action.
+   */
+  action: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
+    current: PropTypes.shape({
+      focusVisible: PropTypes.func.isRequired
+    })
+  })]),
+  /**
+   * If `true`, the ripples are centered.
+   * They won't start at the cursor interaction position.
+   * @default false
+   */
+  centerRipple: PropTypes.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   * @default 'primary'
+   */
+  color: PropTypes.oneOf(['error', 'info', 'inherit', 'primary', 'secondary', 'success', 'warning']),
+  component: PropTypes.elementType,
+  /**
+   * If `true`, the component is disabled.
+   */
+  disabled: PropTypes.bool,
+  /**
+   * If `true`, no elevation is used.
+   * @default false
+   */
+  disableElevation: PropTypes.bool,
+  /**
+   * If `true`, the  keyboard focus ripple is disabled.
+   * @default false
+   */
+  disableFocusRipple: PropTypes.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   *
+   * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
+   * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
+   * @default false
+   */
+  disableRipple: PropTypes.bool,
+  /**
+   * If `true`, the touch ripple effect is disabled.
+   * @default false
+   */
+  disableTouchRipple: PropTypes.bool,
+  /**
+   * Element placed after the children.
+   */
+  endIcon: PropTypes.node,
+  /**
+   * If `true`, the base button will have a keyboard focus ripple.
+   * @default false
+   */
+  focusRipple: PropTypes.bool,
+  /**
+   * This prop can help identify which element has keyboard focus.
+   * The class name will be applied when the element gains the focus through keyboard interaction.
+   * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
+   * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
+   * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
+   * if needed.
+   */
+  focusVisibleClassName: PropTypes.string,
+  /**
+   * If `true`, the button will take up the full width of its container.
+   * @default false
+   */
+  fullWidth: PropTypes.bool,
+  /**
+   * The URL to link to when the button is clicked.
+   * If defined, an `a` element will be used as the root node.
+   */
+  href: PropTypes.string,
+  /**
+   * The component used to render a link when the `href` prop is provided.
+   * @default 'a'
+   */
+  LinkComponent: PropTypes.elementType,
+  /**
+   * If `true`, the loading indicator is visible and the button is disabled.
+   * If `true | false`, the loading wrapper is always rendered before the children to prevent [Google Translation Crash](https://github.com/mui/material-ui/issues/27853).
+   * @default null
+   */
+  loading: PropTypes.bool,
+  /**
+   * Element placed before the children if the button is in loading state.
+   * The node should contain an element with `role="progressbar"` with an accessible name.
+   * By default, it renders a `CircularProgress` that is labeled by the button itself.
+   * @default <CircularProgress color="inherit" size={16} />
+   */
+  loadingIndicator: PropTypes.node,
+  /**
+   * The loading indicator can be positioned on the start, end, or the center of the button.
+   * @default 'center'
+   */
+  loadingPosition: PropTypes.oneOf(['center', 'end', 'start']),
+  /**
+   * Callback fired when the component is focused with a keyboard.
+   * We trigger a `onFocus` callback too.
+   */
+  onFocusVisible: PropTypes.func,
+  /**
+   * A function to customize rendering of the component.
+   */
+  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),
+  /**
+   * The size of the component.
+   * `small` is equivalent to the dense button styling.
+   */
+  size: PropTypes.oneOf(['large', 'medium', 'small']),
+  /**
+   * Element placed before the children.
+   */
+  startIcon: PropTypes.node,
+  style: PropTypes.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
+  tabIndex: PropTypes.number,
+  /**
+   * Props applied to the `TouchRipple` element.
+   */
+  TouchRippleProps: PropTypes.object,
+  /**
+   * A ref that points to the `TouchRipple` element.
+   */
+  touchRippleRef: PropTypes.any,
+  /**
+   * The variant to use.
+   * @default 'text'
+   */
+  variant: PropTypes.oneOf(['contained', 'outlined', 'text'])
+} : void 0;
+export { QuickFilterTrigger };

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

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

package/esm/components/quickFilter/index.js

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

package/esm/components/toolbar/GridToolbarColumnsButton.d.ts

@@ -1,14 +1,13 @@
 import * as React from 'react';
-import { ButtonProps } from '@mui/material/Button';
-import { TooltipProps } from '@mui/material/Tooltip';
+import type { GridSlotProps } from '../../models/gridSlotsComponentsProps';
 interface GridToolbarColumnsButtonProps {
   /**
    * The props used for each slot inside.
    * @default {}
    */
   slotProps?: {
-    button?: Partial<ButtonProps>;
-    tooltip?: Partial<TooltipProps>;
+    button?: Partial<GridSlotProps['baseButton']>;
+    tooltip?: Partial<GridSlotProps['baseTooltip']>;
   };
 }
 declare const GridToolbarColumnsButton: React.ForwardRefExoticComponent<GridToolbarColumnsButtonProps> | React.ForwardRefExoticComponent<GridToolbarColumnsButtonProps & React.RefAttributes<HTMLButtonElement>>;

package/esm/components/toolbar/GridToolbarDensitySelector.d.ts

@@ -1,14 +1,13 @@
 import * as React from 'react';
-import { ButtonProps } from '@mui/material/Button';
-import { TooltipProps } from '@mui/material/Tooltip';
+import type { GridSlotProps } from '../../models/gridSlotsComponentsProps';
 interface GridToolbarDensitySelectorProps {
   /**
    * The props used for each slot inside.
    * @default {}
    */
   slotProps?: {
-    button?: Partial<ButtonProps>;
-    tooltip?: Partial<TooltipProps>;
+    button?: Partial<GridSlotProps['baseButton']>;
+    tooltip?: Partial<GridSlotProps['baseTooltip']>;
   };
 }
 declare const GridToolbarDensitySelector: React.ForwardRefExoticComponent<GridToolbarDensitySelectorProps> | React.ForwardRefExoticComponent<GridToolbarDensitySelectorProps & React.RefAttributes<HTMLButtonElement>>;

package/esm/components/toolbar/GridToolbarExport.d.ts

@@ -1,6 +1,5 @@
 import * as React from 'react';
-import { ButtonProps } from '@mui/material/Button';
-import { TooltipProps } from '@mui/material/Tooltip';
+import type { GridSlotProps } from '../../models/gridSlotsComponentsProps';
 import { GridCsvExportOptions, GridPrintExportOptions } from "../../models/gridExport.js";
 export interface GridExportDisplayOptions {
   /**
@@ -23,8 +22,8 @@ export interface GridToolbarExportProps {
    * @default {}
    */
   slotProps?: {
-    button?: Partial<ButtonProps>;
-    tooltip?: Partial<TooltipProps>;
+    button?: Partial<GridSlotProps['baseButton']>;
+    tooltip?: Partial<GridSlotProps['baseTooltip']>;
   };
   [x: `data-${string}`]: string;
 }

package/esm/components/toolbar/GridToolbarExportContainer.d.ts

@@ -1,14 +1,13 @@
 import * as React from 'react';
-import { ButtonProps } from '@mui/material/Button';
-import { TooltipProps } from '@mui/material/Tooltip';
+import type { GridSlotProps } from '../../models/gridSlotsComponentsProps';
 interface GridToolbarExportContainerProps {
   /**
    * The props used for each slot inside.
    * @default {}
    */
   slotProps?: {
-    button?: Partial<ButtonProps>;
-    tooltip?: Partial<TooltipProps>;
+    button?: Partial<GridSlotProps['baseButton']>;
+    tooltip?: Partial<GridSlotProps['baseTooltip']>;
   };
 }
 declare const GridToolbarExportContainer: React.ForwardRefExoticComponent<React.PropsWithChildren<GridToolbarExportContainerProps>> | React.ForwardRefExoticComponent<GridToolbarExportContainerProps & {

package/esm/components/toolbar/GridToolbarFilterButton.d.ts

@@ -1,16 +1,14 @@
 import * as React from 'react';
-import { ButtonProps } from '@mui/material/Button';
-import { TooltipProps } from '@mui/material/Tooltip';
-import { BadgeProps } from "../../models/gridBaseSlots.js";
+import type { GridSlotProps } from '../../models/gridSlotsComponentsProps';
 export interface GridToolbarFilterButtonProps {
   /**
    * The props used for each slot inside.
    * @default {}
    */
   slotProps?: {
-    button?: Partial<ButtonProps>;
-    tooltip?: Partial<TooltipProps>;
-    badge?: Partial<BadgeProps>;
+    button?: Partial<GridSlotProps['baseButton']>;
+    tooltip?: Partial<GridSlotProps['baseTooltip']>;
+    badge?: Partial<GridSlotProps['baseBadge']>;
   };
 }
 declare const GridToolbarFilterButton: React.ForwardRefExoticComponent<GridToolbarFilterButtonProps> | React.ForwardRefExoticComponent<GridToolbarFilterButtonProps & React.RefAttributes<HTMLButtonElement>>;