@mui/x-date-pickers 8.0.0-alpha.1 → 8.0.0-alpha.11

package/index.d.ts

@@ -36,3 +36,4 @@ export * from './models';
 export * from './icons';
 export * from './hooks';
 export * from './validation';
+export * from './managers';

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-date-pickers v8.0.0-alpha.1
+ * @mui/x-date-pickers v8.0.0-alpha.11
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the
@@ -57,4 +57,5 @@ export { DEFAULT_DESKTOP_MODE_MEDIA_QUERY } from "./internals/utils/utils.js";
 export * from "./models/index.js";
 export * from "./icons/index.js";
 export * from "./hooks/index.js";
-export * from "./validation/index.js";
+export * from "./validation/index.js";
+export * from "./managers/index.js";

package/internals/components/PickerFieldUI.d.ts

@@ -0,0 +1,133 @@
+import * as React from 'react';
+import { TextFieldProps } from '@mui/material/TextField';
+import { IconButtonProps } from '@mui/material/IconButton';
+import { InputAdornmentProps } from '@mui/material/InputAdornment';
+import { SvgIconProps } from '@mui/material/SvgIcon';
+import { MakeOptional, SlotComponentPropsFromProps } from '@mui/x-internals/types';
+import { FieldOwnerState } from '../../models';
+import { UseFieldOwnerStateParameters } from '../hooks/useFieldOwnerState';
+import type { UseFieldResponse } from '../hooks/useField';
+import { PickersTextFieldProps } from '../../PickersTextField';
+export declare const cleanFieldResponse: <TFieldResponse extends MakeOptional<UseFieldResponse<any, ExportedPickerFieldUIProps & {
+    [key: string]: any;
+}>, "onClear" | "clearable">>({ enableAccessibleFieldDOMStructure, ...fieldResponse }: TFieldResponse) => ExportedPickerFieldUIProps & {
+    openPickerAriaLabel: string;
+    textFieldProps: TextFieldProps | PickersTextFieldProps;
+};
+/**
+ * Adds the button to open the picker and the button to clear the value of the field.
+ * @ignore - internal component.
+ */
+export declare function PickerFieldUI(props: PickerFieldUIProps): React.JSX.Element;
+export interface ExportedPickerFieldUIProps {
+    /**
+     * If `true`, a clear button will be shown in the field allowing value clearing.
+     * @default false
+     */
+    clearable?: boolean;
+    /**
+     * Callback fired when the clear button is clicked.
+     */
+    onClear?: React.MouseEventHandler;
+    /**
+     * The position at which the clear button is placed.
+     * If the field is not clearable, the button is not rendered.
+     * @default 'end'
+     */
+    clearButtonPosition?: 'start' | 'end';
+    /**
+     * The position at which the opening button is placed.
+     * If there is no picker to open, the button is not rendered
+     * @default 'end'
+     */
+    openPickerButtonPosition?: 'start' | 'end';
+}
+export interface PickerFieldUIProps {
+    /**
+     * Overridable component slots.
+     * @default {}
+     */
+    slots?: PickerFieldUISlots;
+    /**
+     * The props used for each component slot.
+     * @default {}
+     */
+    slotProps?: PickerFieldUISlotProps;
+    /**
+     * Object returned by the `useField` hook or one of its wrapper (for example `useDateField`).
+     */
+    fieldResponse: UseFieldResponse<any, any>;
+    /**
+     * The component to use to render the picker opening icon if none is provided in the picker's slots.
+     */
+    defaultOpenPickerIcon: React.ElementType;
+}
+export interface PickerFieldUISlots {
+    /**
+     * Form control with an input to render the value.
+     * @default <PickersTextField />, or <TextField /> from '@mui/material' if `enableAccessibleFieldDOMStructure` is `false`.
+     */
+    textField?: React.ElementType;
+    /**
+     * Component displayed on the start or end input adornment used to open the picker on desktop.
+     * @default InputAdornment
+     */
+    inputAdornment?: React.ElementType<InputAdornmentProps>;
+    /**
+     * Icon to display inside the clear button.
+     * @default ClearIcon
+     */
+    clearIcon?: React.ElementType;
+    /**
+     * Button to clear the value.
+     * @default IconButton
+     */
+    clearButton?: React.ElementType;
+}
+export interface PickerFieldUISlotsFromContext extends PickerFieldUISlots {
+    /**
+     * Button to open the picker on desktop.
+     * @default IconButton
+     */
+    openPickerButton?: React.ElementType<IconButtonProps>;
+    /**
+     * Icon displayed in the open picker button on desktop.
+     */
+    openPickerIcon?: React.ElementType;
+}
+export interface PickerFieldUISlotProps {
+    textField?: SlotComponentPropsFromProps<PickersTextFieldProps | TextFieldProps, {}, FieldOwnerState>;
+    inputAdornment?: SlotComponentPropsFromProps<InputAdornmentProps, {}, FieldInputAdornmentOwnerState>;
+    clearIcon?: SlotComponentPropsFromProps<SvgIconProps, {}, FieldOwnerState>;
+    clearButton?: SlotComponentPropsFromProps<IconButtonProps, {}, FieldOwnerState>;
+}
+export interface PickerFieldUISlotPropsFromContext extends PickerFieldUISlotProps {
+    openPickerButton?: SlotComponentPropsFromProps<IconButtonProps, {}, FieldOwnerState>;
+    openPickerIcon?: SlotComponentPropsFromProps<SvgIconProps, {}, FieldOwnerState>;
+}
+interface FieldInputAdornmentOwnerState extends FieldOwnerState {
+    position: 'start' | 'end';
+}
+/**
+ * The `textField` slot props cannot be handled inside `PickerFieldUI` because it would be a breaking change to not pass the enriched props to `useField`.
+ * Once the non-accessible DOM structure will be removed, we will be able to remove the `textField` slot and clean this logic.
+ */
+export declare function useFieldTextFieldProps<TProps extends UseFieldOwnerStateParameters & {
+    inputProps?: {};
+    InputProps?: {};
+}>(parameters: UseFieldTextFieldPropsParameters): TProps;
+interface UseFieldTextFieldPropsParameters {
+    slotProps: {
+        textField?: SlotComponentPropsFromProps<PickersTextFieldProps | TextFieldProps, {}, FieldOwnerState>;
+    } | undefined;
+    ref: React.Ref<HTMLDivElement>;
+    externalForwardedProps: any;
+}
+export declare function PickerFieldUIContextProvider(props: PickerFieldUIContextProviderProps): React.JSX.Element;
+interface PickerFieldUIContextProviderProps {
+    children: React.ReactNode;
+    inputRef: React.Ref<HTMLInputElement> | undefined;
+    slots: PickerFieldUISlotsFromContext | undefined;
+    slotProps: PickerFieldUISlotPropsFromContext | undefined;
+}
+export {};

package/internals/components/PickerFieldUI.js

@@ -0,0 +1,317 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["enableAccessibleFieldDOMStructure"],
+  _excluded2 = ["InputProps", "readOnly", "onClear", "clearable", "clearButtonPosition", "openPickerButtonPosition", "openPickerAriaLabel"],
+  _excluded3 = ["onPaste", "onKeyDown", "inputMode", "readOnly", "InputProps", "inputProps", "inputRef", "onClear", "clearable", "clearButtonPosition", "openPickerButtonPosition", "openPickerAriaLabel"],
+  _excluded4 = ["ownerState"],
+  _excluded5 = ["ownerState"],
+  _excluded6 = ["ownerState"],
+  _excluded7 = ["ownerState"],
+  _excluded8 = ["InputProps", "inputProps"];
+import * as React from 'react';
+import useEventCallback from '@mui/utils/useEventCallback';
+import useForkRef from '@mui/utils/useForkRef';
+import resolveComponentProps from '@mui/utils/resolveComponentProps';
+import MuiTextField from '@mui/material/TextField';
+import MuiIconButton from '@mui/material/IconButton';
+import MuiInputAdornment from '@mui/material/InputAdornment';
+import useSlotProps from '@mui/utils/useSlotProps';
+import { useFieldOwnerState } from "../hooks/useFieldOwnerState.js";
+import { usePickerTranslations } from "../../hooks/index.js";
+import { ClearIcon as MuiClearIcon } from "../../icons/index.js";
+import { useNullablePickerContext } from "../hooks/useNullablePickerContext.js";
+import { PickersTextField } from "../../PickersTextField/index.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export const cleanFieldResponse = _ref => {
+  let {
+      enableAccessibleFieldDOMStructure
+    } = _ref,
+    fieldResponse = _objectWithoutPropertiesLoose(_ref, _excluded);
+  if (enableAccessibleFieldDOMStructure) {
+    const {
+        InputProps,
+        readOnly,
+        onClear,
+        clearable,
+        clearButtonPosition,
+        openPickerButtonPosition,
+        openPickerAriaLabel
+      } = fieldResponse,
+      other = _objectWithoutPropertiesLoose(fieldResponse, _excluded2);
+    return {
+      clearable,
+      onClear,
+      clearButtonPosition,
+      openPickerButtonPosition,
+      openPickerAriaLabel,
+      textFieldProps: _extends({}, other, {
+        InputProps: _extends({}, InputProps ?? {}, {
+          readOnly
+        })
+      })
+    };
+  }
+  const {
+      onPaste,
+      onKeyDown,
+      inputMode,
+      readOnly,
+      InputProps,
+      inputProps,
+      inputRef,
+      onClear,
+      clearable,
+      clearButtonPosition,
+      openPickerButtonPosition,
+      openPickerAriaLabel
+    } = fieldResponse,
+    other = _objectWithoutPropertiesLoose(fieldResponse, _excluded3);
+  return {
+    clearable,
+    onClear,
+    clearButtonPosition,
+    openPickerButtonPosition,
+    openPickerAriaLabel,
+    textFieldProps: _extends({}, other, {
+      InputProps: _extends({}, InputProps ?? {}, {
+        readOnly
+      }),
+      inputProps: _extends({}, inputProps ?? {}, {
+        inputMode,
+        onPaste,
+        onKeyDown,
+        ref: inputRef
+      })
+    })
+  };
+};
+const PickerFieldUIContext = /*#__PURE__*/React.createContext({
+  slots: {},
+  slotProps: {},
+  inputRef: undefined
+});
+
+/**
+ * Adds the button to open the picker and the button to clear the value of the field.
+ * @ignore - internal component.
+ */
+export function PickerFieldUI(props) {
+  const {
+    slots,
+    slotProps,
+    fieldResponse,
+    defaultOpenPickerIcon
+  } = props;
+  const translations = usePickerTranslations();
+  const pickerContext = useNullablePickerContext();
+  const pickerFieldUIContext = React.useContext(PickerFieldUIContext);
+  const {
+    textFieldProps,
+    onClear,
+    clearable,
+    openPickerAriaLabel,
+    clearButtonPosition: clearButtonPositionProp = 'end',
+    openPickerButtonPosition: openPickerButtonPositionProp = 'end'
+  } = cleanFieldResponse(fieldResponse);
+  const ownerState = useFieldOwnerState(textFieldProps);
+  const handleClickOpeningButton = useEventCallback(event => {
+    event.preventDefault();
+    pickerContext?.setOpen(prev => !prev);
+  });
+  const triggerStatus = pickerContext ? pickerContext.triggerStatus : 'hidden';
+  const clearButtonPosition = clearable ? clearButtonPositionProp : null;
+  const openPickerButtonPosition = triggerStatus !== 'hidden' ? openPickerButtonPositionProp : null;
+  const TextField = slots?.textField ?? pickerFieldUIContext.slots.textField ?? (fieldResponse.enableAccessibleFieldDOMStructure === false ? MuiTextField : PickersTextField);
+  const InputAdornment = slots?.inputAdornment ?? pickerFieldUIContext.slots.inputAdornment ?? MuiInputAdornment;
+  const _useSlotProps = useSlotProps({
+      elementType: InputAdornment,
+      externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.inputAdornment, slotProps?.inputAdornment),
+      additionalProps: {
+        position: 'start'
+      },
+      ownerState: _extends({}, ownerState, {
+        position: 'start'
+      })
+    }),
+    startInputAdornmentProps = _objectWithoutPropertiesLoose(_useSlotProps, _excluded4);
+  const _useSlotProps2 = useSlotProps({
+      elementType: InputAdornment,
+      externalSlotProps: slotProps?.inputAdornment,
+      additionalProps: {
+        position: 'end'
+      },
+      ownerState: _extends({}, ownerState, {
+        position: 'end'
+      })
+    }),
+    endInputAdornmentProps = _objectWithoutPropertiesLoose(_useSlotProps2, _excluded5);
+  const OpenPickerButton = pickerFieldUIContext.slots.openPickerButton ?? MuiIconButton;
+  // We don't want to forward the `ownerState` to the `<IconButton />` component, see mui/material-ui#34056
+  const _useSlotProps3 = useSlotProps({
+      elementType: OpenPickerButton,
+      externalSlotProps: pickerFieldUIContext.slotProps.openPickerButton,
+      additionalProps: {
+        disabled: triggerStatus === 'disabled',
+        onClick: handleClickOpeningButton,
+        'aria-label': openPickerAriaLabel,
+        edge: clearButtonPosition === 'start' && openPickerButtonPosition === 'start' ? undefined : openPickerButtonPosition
+      },
+      ownerState
+    }),
+    openPickerButtonProps = _objectWithoutPropertiesLoose(_useSlotProps3, _excluded6);
+  const OpenPickerIcon = pickerFieldUIContext.slots.openPickerIcon ?? defaultOpenPickerIcon;
+  const openPickerIconProps = useSlotProps({
+    elementType: OpenPickerIcon,
+    externalSlotProps: pickerFieldUIContext.slotProps.openPickerIcon,
+    ownerState
+  });
+  const ClearButton = slots?.clearButton ?? pickerFieldUIContext.slots.clearButton ?? MuiIconButton;
+  // We don't want to forward the `ownerState` to the `<IconButton />` component, see mui/material-ui#34056
+  const _useSlotProps4 = useSlotProps({
+      elementType: ClearButton,
+      externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.clearButton, slotProps?.clearButton),
+      className: 'clearButton',
+      additionalProps: {
+        title: translations.fieldClearLabel,
+        tabIndex: -1,
+        onClick: onClear,
+        disabled: fieldResponse.disabled || fieldResponse.readOnly,
+        edge: clearButtonPosition === 'end' && openPickerButtonPosition === 'end' ? undefined : clearButtonPosition
+      },
+      ownerState
+    }),
+    clearButtonProps = _objectWithoutPropertiesLoose(_useSlotProps4, _excluded7);
+  const ClearIcon = slots?.clearIcon ?? pickerFieldUIContext.slots.clearIcon ?? MuiClearIcon;
+  const clearIconProps = useSlotProps({
+    elementType: ClearIcon,
+    externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.clearIcon, slotProps?.clearIcon),
+    additionalProps: {
+      fontSize: 'small'
+    },
+    ownerState
+  });
+  textFieldProps.ref = useForkRef(textFieldProps.ref, pickerContext?.rootRef);
+  if (!textFieldProps.InputProps) {
+    textFieldProps.InputProps = {};
+  }
+  if (pickerContext) {
+    textFieldProps.InputProps.ref = pickerContext.triggerRef;
+  }
+  if (!textFieldProps.InputProps?.startAdornment && (clearButtonPosition === 'start' || openPickerButtonPosition === 'start')) {
+    textFieldProps.InputProps.startAdornment = /*#__PURE__*/_jsxs(InputAdornment, _extends({}, startInputAdornmentProps, {
+      children: [openPickerButtonPosition === 'start' && /*#__PURE__*/_jsx(OpenPickerButton, _extends({}, openPickerButtonProps, {
+        children: /*#__PURE__*/_jsx(OpenPickerIcon, _extends({}, openPickerIconProps))
+      })), clearButtonPosition === 'start' && /*#__PURE__*/_jsx(ClearButton, _extends({}, clearButtonProps, {
+        children: /*#__PURE__*/_jsx(ClearIcon, _extends({}, clearIconProps))
+      }))]
+    }));
+  }
+  if (!textFieldProps.InputProps?.endAdornment && (clearButtonPosition === 'end' || openPickerButtonPosition === 'end')) {
+    textFieldProps.InputProps.endAdornment = /*#__PURE__*/_jsxs(InputAdornment, _extends({}, endInputAdornmentProps, {
+      children: [clearButtonPosition === 'end' && /*#__PURE__*/_jsx(ClearButton, _extends({}, clearButtonProps, {
+        children: /*#__PURE__*/_jsx(ClearIcon, _extends({}, clearIconProps))
+      })), openPickerButtonPosition === 'end' && /*#__PURE__*/_jsx(OpenPickerButton, _extends({}, openPickerButtonProps, {
+        children: /*#__PURE__*/_jsx(OpenPickerIcon, _extends({}, openPickerIconProps))
+      }))]
+    }));
+  }
+  if (clearButtonPosition != null) {
+    textFieldProps.sx = [{
+      '& .clearButton': {
+        opacity: 1
+      },
+      '@media (pointer: fine)': {
+        '& .clearButton': {
+          opacity: 0
+        },
+        '&:hover, &:focus-within': {
+          '.clearButton': {
+            opacity: 1
+          }
+        }
+      }
+    }, ...(Array.isArray(textFieldProps.sx) ? textFieldProps.sx : [textFieldProps.sx])];
+  }
+  return /*#__PURE__*/_jsx(TextField, _extends({}, textFieldProps));
+}
+function mergeSlotProps(slotPropsA, slotPropsB) {
+  if (!slotPropsA) {
+    return slotPropsB;
+  }
+  if (!slotPropsB) {
+    return slotPropsA;
+  }
+  return ownerState => {
+    return _extends({}, resolveComponentProps(slotPropsB, ownerState), resolveComponentProps(slotPropsA, ownerState));
+  };
+}
+
+/**
+ * The `textField` slot props cannot be handled inside `PickerFieldUI` because it would be a breaking change to not pass the enriched props to `useField`.
+ * Once the non-accessible DOM structure will be removed, we will be able to remove the `textField` slot and clean this logic.
+ */
+export function useFieldTextFieldProps(parameters) {
+  const {
+    ref,
+    externalForwardedProps,
+    slotProps
+  } = parameters;
+  const pickerFieldUIContext = React.useContext(PickerFieldUIContext);
+  const pickerContext = useNullablePickerContext();
+  const ownerState = useFieldOwnerState(externalForwardedProps);
+  const {
+      InputProps,
+      inputProps
+    } = externalForwardedProps,
+    otherExternalForwardedProps = _objectWithoutPropertiesLoose(externalForwardedProps, _excluded8);
+  const textFieldProps = useSlotProps({
+    elementType: PickersTextField,
+    externalSlotProps: mergeSlotProps(pickerFieldUIContext.slotProps.textField, slotProps?.textField),
+    externalForwardedProps: otherExternalForwardedProps,
+    additionalProps: {
+      ref,
+      sx: pickerContext?.rootSx,
+      label: pickerContext?.label,
+      name: pickerContext?.name,
+      className: pickerContext?.rootClassName,
+      inputRef: pickerFieldUIContext.inputRef
+    },
+    ownerState
+  });
+
+  // TODO: Remove when mui/material-ui#35088 will be merged
+  textFieldProps.inputProps = _extends({}, inputProps, textFieldProps.inputProps);
+  textFieldProps.InputProps = _extends({}, InputProps, textFieldProps.InputProps);
+  return textFieldProps;
+}
+export function PickerFieldUIContextProvider(props) {
+  const {
+    slots = {},
+    slotProps = {},
+    inputRef,
+    children
+  } = props;
+  const contextValue = React.useMemo(() => ({
+    inputRef,
+    slots: {
+      openPickerButton: slots.openPickerButton,
+      openPickerIcon: slots.openPickerIcon,
+      textField: slots.textField,
+      inputAdornment: slots.inputAdornment,
+      clearIcon: slots.clearIcon,
+      clearButton: slots.clearButton
+    },
+    slotProps: {
+      openPickerButton: slotProps.openPickerButton,
+      openPickerIcon: slotProps.openPickerIcon,
+      textField: slotProps.textField,
+      inputAdornment: slotProps.inputAdornment,
+      clearIcon: slotProps.clearIcon,
+      clearButton: slotProps.clearButton
+    }
+  }), [inputRef, slots.openPickerButton, slots.openPickerIcon, slots.textField, slots.inputAdornment, slots.clearIcon, slots.clearButton, slotProps.openPickerButton, slotProps.openPickerIcon, slotProps.textField, slotProps.inputAdornment, slotProps.clearIcon, slotProps.clearButton]);
+  return /*#__PURE__*/_jsx(PickerFieldUIContext.Provider, {
+    value: contextValue,
+    children: children
+  });
+}

package/internals/components/{PickersPopper.d.ts → PickerPopper/PickerPopper.d.ts}

@@ -1,18 +1,18 @@
 import * as React from 'react';
-import MuiPaper, { PaperProps as MuiPaperProps } from '@mui/material/Paper';
-import MuiPopper, { PopperProps as MuiPopperProps, PopperPlacementType } from '@mui/material/Popper';
+import { PaperProps as MuiPaperProps, PaperProps } from '@mui/material/Paper';
+import { PopperProps as MuiPopperProps, PopperPlacementType, PopperProps } from '@mui/material/Popper';
 import { TrapFocusProps as MuiTrapFocusProps } from '@mui/material/Unstable_TrapFocus';
-import { SlotComponentProps } from '@mui/utils';
 import { TransitionProps as MuiTransitionProps } from '@mui/material/transitions';
-import { PickersPopperClasses } from './pickersPopperClasses';
-import { UsePickerValueActions } from '../hooks/usePicker/usePickerValue.types';
-interface PickersPopperOwnerState extends PickerPopperProps {
-    placement: PopperPlacementType;
+import { SlotComponentPropsFromProps } from '@mui/x-internals/types';
+import { PickerPopperClasses } from './pickerPopperClasses';
+import { PickerOwnerState } from '../../../models';
+interface PickerPopperOwnerState extends PickerOwnerState {
+    popperPlacement: PopperPlacementType;
 }
-export interface PickersPopperSlots {
+export interface PickerPopperSlots {
     /**
      * Custom component for the paper rendered inside the desktop picker's Popper.
-     * @default PickersPopperPaper
+     * @default PickerPopperPaper
      */
     desktopPaper?: React.JSXElementConstructor<MuiPaperProps>;
     /**
@@ -31,11 +31,11 @@ export interface PickersPopperSlots {
      */
     popper?: React.ElementType<MuiPopperProps>;
 }
-export interface PickersPopperSlotProps {
+export interface PickerPopperSlotProps {
     /**
      * Props passed down to the desktop [Paper](https://mui.com/material-ui/api/paper/) component.
      */
-    desktopPaper?: SlotComponentProps<typeof MuiPaper, {}, PickersPopperOwnerState>;
+    desktopPaper?: SlotComponentPropsFromProps<PaperProps, {}, PickerPopperOwnerState>;
     /**
      * Props passed down to the desktop [Transition](https://mui.com/material-ui/transitions/) component.
      */
@@ -47,24 +47,25 @@ export interface PickersPopperSlotProps {
     /**
      * Props passed down to [Popper](https://mui.com/material-ui/api/popper/) component.
      */
-    popper?: SlotComponentProps<typeof MuiPopper, {}, PickerPopperProps>;
+    popper?: SlotComponentPropsFromProps<PopperProps, {}, PickerPopperOwnerState>;
 }
-export interface PickerPopperProps extends UsePickerValueActions {
-    role: 'tooltip' | 'dialog';
-    anchorEl: MuiPopperProps['anchorEl'];
-    open: MuiPopperProps['open'];
+export interface ExportedPickerPopperProps {
+    /**
+     * Override or extend the styles applied to the component.
+     */
+    classes?: Partial<PickerPopperClasses>;
+    /**
+     * @default "bottom-start"
+     */
     placement?: MuiPopperProps['placement'];
+}
+export interface PickerPopperProps extends ExportedPickerPopperProps {
+    role: 'tooltip' | 'dialog';
     containerRef?: React.Ref<HTMLDivElement>;
     children?: React.ReactNode;
     onBlur?: () => void;
-    slots?: PickersPopperSlots;
-    slotProps?: PickersPopperSlotProps;
-    /**
-     * Override or extend the styles applied to the component.
-     */
-    classes?: Partial<PickersPopperClasses>;
-    shouldRestoreFocus?: () => boolean;
-    reduceAnimations?: boolean;
+    slots?: PickerPopperSlots;
+    slotProps?: PickerPopperSlotProps;
 }
-export declare function PickersPopper(inProps: PickerPopperProps): React.JSX.Element;
+export declare function PickerPopper(inProps: PickerPopperProps): React.JSX.Element;
 export {};