@mui/x-date-pickers 7.0.0-alpha.4 → 7.0.0-alpha.6

package/internals/components/PickersInput/PickersInput.types.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="react" />
+import { BoxProps } from '@mui/material/Box';
+import { PickersSectionListProps } from '../../../PickersSectionList';
+export interface PickersInputPropsUsedByField extends Pick<PickersSectionListProps, 'elements' | 'sectionListRef' | 'contentEditable' | 'tabIndex'> {
+    /**
+     * Is `true` if the current values equals the empty value.
+     * For a single item value, it means that `value === null`
+     * For a range value, it means that `value === [null, null]`
+     */
+    areAllSectionsEmpty: boolean;
+    onClick: React.MouseEventHandler<HTMLDivElement>;
+    onKeyDown: React.KeyboardEventHandler<HTMLDivElement>;
+    onInput: React.FormEventHandler<HTMLDivElement>;
+    onPaste: React.ClipboardEventHandler<HTMLDivElement>;
+    endAdornment?: React.ReactNode;
+    startAdornment?: React.ReactNode;
+    value: string;
+    onChange: React.ChangeEventHandler<HTMLInputElement>;
+    label?: React.ReactNode;
+    id?: string;
+    fullWidth?: boolean;
+    readOnly?: boolean;
+    inputProps?: React.HTMLAttributes<HTMLInputElement> & {
+        ref?: React.Ref<HTMLInputElement>;
+    };
+    inputRef?: React.Ref<HTMLInputElement>;
+}
+export interface PickersInputProps extends Omit<BoxProps, keyof PickersInputPropsUsedByField>, PickersInputPropsUsedByField {
+    ownerState?: any;
+    margin?: 'dense' | 'none' | 'normal';
+    renderSuffix?: (state: {
+        disabled?: boolean;
+        error?: boolean;
+        filled?: boolean;
+        focused?: boolean;
+        margin?: 'dense' | 'none' | 'normal';
+        required?: boolean;
+        adornedStart?: boolean;
+    }) => React.ReactNode;
+    ref?: React.Ref<HTMLDivElement>;
+    /**
+     * The components used for each slot inside.
+     *
+     * @default {}
+     */
+    slots?: {
+        root?: React.ElementType;
+        input?: React.ElementType;
+    };
+}
+export interface PickersOutlinedInputProps extends PickersInputProps {
+    notched?: boolean;
+}
+export interface PickersStandardInputProps extends PickersInputProps {
+    disableUnderline?: boolean;
+}
+export interface PickersFilledInputProps extends PickersInputProps {
+    disableUnderline?: boolean;
+    hiddenLabel?: boolean;
+}

package/internals/components/PickersInput/PickersOutlinedInput.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import { PickersOutlinedInputProps } from './PickersInput.types';
+export declare const PickersOutlinedInput: React.ForwardRefExoticComponent<Omit<PickersOutlinedInputProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/internals/components/PickersInput/PickersOutlinedInput.js

@@ -0,0 +1,117 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+const _excluded = ["label", "autoFocus", "ownerState", "notched"];
+import * as React from 'react';
+import { useFormControl } from '@mui/material/FormControl';
+import { styled } from '@mui/material/styles';
+import { unstable_composeClasses as composeClasses, unstable_capitalize as capitalize } from '@mui/utils';
+import { pickersOutlinedInputClasses, getPickersOutlinedInputUtilityClass } from './pickersInputClasses';
+import Outline from './Outline';
+import { PickersInputRoot, PickersInput, PickersInputSectionsContainer } from './PickersInput';
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
+const OutlinedInputRoot = styled(PickersInputRoot, {
+  name: 'MuiPickersOutlinedInput',
+  slot: 'Root',
+  overridesResolver: (props, styles) => styles.root
+})(({
+  theme,
+  ownerState
+}) => {
+  const borderColor = theme.palette.mode === 'light' ? 'rgba(0, 0, 0, 0.23)' : 'rgba(255, 255, 255, 0.23)';
+  return {
+    padding: '0 14px',
+    borderRadius: (theme.vars || theme).shape.borderRadius,
+    [`&:hover .${pickersOutlinedInputClasses.notchedOutline}`]: {
+      borderColor: (theme.vars || theme).palette.text.primary
+    },
+    // Reset on touch devices, it doesn't add specificity
+    '@media (hover: none)': {
+      [`&:hover .${pickersOutlinedInputClasses.notchedOutline}`]: {
+        borderColor: theme.vars ? `rgba(${theme.vars.palette.common.onBackgroundChannel} / 0.23)` : borderColor
+      }
+    },
+    [`&.${pickersOutlinedInputClasses.focused} .${pickersOutlinedInputClasses.notchedOutline}`]: {
+      borderStyle: 'solid',
+      borderColor: (theme.vars || theme).palette[ownerState.color].main,
+      borderWidth: 2
+    },
+    [`&.${pickersOutlinedInputClasses.disabled}`]: {
+      [`& .${pickersOutlinedInputClasses.notchedOutline}`]: {
+        borderColor: (theme.vars || theme).palette.action.disabled
+      },
+      '*': {
+        color: (theme.vars || theme).palette.action.disabled
+      }
+    },
+    [`&.${pickersOutlinedInputClasses.error} .${pickersOutlinedInputClasses.notchedOutline}`]: {
+      borderColor: (theme.vars || theme).palette.error.main
+    }
+  };
+});
+const OutlinedPickersInputSectionsContainer = styled(PickersInputSectionsContainer, {
+  name: 'MuiPickersOutlinedInput',
+  slot: 'SectionsContainer',
+  overridesResolver: (props, styles) => styles.sectionsContainer
+})(({
+  ownerState
+}) => _extends({
+  padding: '16.5px 0'
+}, ownerState.size === 'small' && {
+  padding: '8.5px 0'
+}));
+const useUtilityClasses = ownerState => {
+  const {
+    focused,
+    disabled,
+    error,
+    classes,
+    fullWidth,
+    color,
+    size,
+    endAdornment,
+    startAdornment
+  } = ownerState;
+  const slots = {
+    root: ['root', focused && !disabled && 'focused', disabled && 'disabled', error && 'error', fullWidth && 'fullWidth', `color${color ? capitalize(color) : ''}`, size === 'small' && 'inputSizeSmall', Boolean(startAdornment) && 'adornedStart', Boolean(endAdornment) && 'adornedEnd'],
+    notchedOutline: ['notchedOutline'],
+    before: ['before'],
+    after: ['after'],
+    content: ['content'],
+    input: ['input']
+  };
+  return composeClasses(slots, getPickersOutlinedInputUtilityClass, classes);
+};
+export const PickersOutlinedInput = /*#__PURE__*/React.forwardRef(function PickersOutlinedInput(props, ref) {
+  const {
+      label,
+      ownerState: ownerStateProp,
+      notched
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const muiFormControl = useFormControl();
+  const ownerState = _extends({}, props, ownerStateProp, muiFormControl, {
+    color: (muiFormControl == null ? void 0 : muiFormControl.color) || 'primary'
+  });
+  const classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/_jsx(PickersInput, _extends({
+    slots: {
+      root: OutlinedInputRoot,
+      input: OutlinedPickersInputSectionsContainer
+    },
+    renderSuffix: state => /*#__PURE__*/_jsx(Outline, {
+      shrink: Boolean(notched || state.adornedStart || state.focused || state.filled),
+      notched: Boolean(notched || state.adornedStart || state.focused || state.filled),
+      className: classes.notchedOutline,
+      label: label != null && label !== '' && muiFormControl != null && muiFormControl.required ? /*#__PURE__*/_jsxs(React.Fragment, {
+        children: [label, "\u2009", '*']
+      }) : label,
+      ownerState: ownerState
+    })
+  }, other, {
+    label: label,
+    classes: classes,
+    ref: ref
+  }));
+});
+PickersInput.muiName = 'Input';

package/internals/components/PickersInput/PickersStandardInput.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import { PickersStandardInputProps } from './PickersInput.types';
+export declare const PickersStandardInput: React.ForwardRefExoticComponent<Omit<PickersStandardInputProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/internals/components/PickersInput/PickersStandardInput.js

@@ -0,0 +1,123 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+const _excluded = ["label", "autoFocus", "ownerState"];
+import * as React from 'react';
+import { useFormControl } from '@mui/material/FormControl';
+import { styled } from '@mui/material/styles';
+import { unstable_composeClasses as composeClasses, unstable_capitalize as capitalize } from '@mui/utils';
+import { pickersStandardInputClasses, getPickersStandardInputUtilityClass } from './pickersInputClasses';
+import { PickersInputRoot, PickersInput } from './PickersInput';
+import { jsx as _jsx } from "react/jsx-runtime";
+const StandardInputRoot = styled(PickersInputRoot, {
+  name: 'MuiPickersStandardInput',
+  slot: 'Root',
+  overridesResolver: (props, styles) => styles.root
+})(({
+  theme,
+  ownerState
+}) => {
+  const light = theme.palette.mode === 'light';
+  let bottomLineColor = light ? 'rgba(0, 0, 0, 0.42)' : 'rgba(255, 255, 255, 0.7)';
+  if (theme.vars) {
+    bottomLineColor = `rgba(${theme.vars.palette.common.onBackgroundChannel} / ${theme.vars.opacity.inputUnderline})`;
+  }
+  return _extends({
+    'label + &': {
+      marginTop: 16
+    }
+  }, !ownerState.disableUnderline && {
+    '&:after': {
+      background: 'red',
+      borderBottom: `2px solid ${(theme.vars || theme).palette[ownerState.color].main}`,
+      left: 0,
+      bottom: 0,
+      // Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
+      content: '""',
+      position: 'absolute',
+      right: 0,
+      transform: 'scaleX(0)',
+      transition: theme.transitions.create('transform', {
+        duration: theme.transitions.duration.shorter,
+        easing: theme.transitions.easing.easeOut
+      }),
+      pointerEvents: 'none' // Transparent to the hover style.
+    },
+    [`&.${pickersStandardInputClasses.focused}:after`]: {
+      // translateX(0) is a workaround for Safari transform scale bug
+      // See https://github.com/mui/material-ui/issues/31766
+      transform: 'scaleX(1) translateX(0)'
+    },
+    [`&.${pickersStandardInputClasses.error}`]: {
+      '&:before, &:after': {
+        borderBottomColor: (theme.vars || theme).palette.error.main
+      }
+    },
+    '&:before': {
+      borderBottom: `1px solid ${bottomLineColor}`,
+      left: 0,
+      bottom: 0,
+      // Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
+      content: '"\\00a0"',
+      position: 'absolute',
+      right: 0,
+      transition: theme.transitions.create('border-bottom-color', {
+        duration: theme.transitions.duration.shorter
+      }),
+      pointerEvents: 'none' // Transparent to the hover style.
+    },
+    [`&:hover:not(.${pickersStandardInputClasses.disabled}, .${pickersStandardInputClasses.error}):before`]: {
+      borderBottom: `2px solid ${(theme.vars || theme).palette.text.primary}`,
+      // Reset on touch devices, it doesn't add specificity
+      '@media (hover: none)': {
+        borderBottom: `1px solid ${bottomLineColor}`
+      }
+    },
+    [`&.${pickersStandardInputClasses.disabled}:before`]: {
+      borderBottomStyle: 'dotted'
+    }
+  });
+});
+const useUtilityClasses = ownerState => {
+  const {
+    focused,
+    disabled,
+    error,
+    classes,
+    fullWidth,
+    color,
+    size,
+    endAdornment,
+    startAdornment
+  } = ownerState;
+  const slots = {
+    root: ['root', focused && !disabled && 'focused', disabled && 'disabled', error && 'error', fullWidth && 'fullWidth', `color${capitalize(color)}`, size === 'small' && 'inputSizeSmall', Boolean(startAdornment) && 'adornedStart', Boolean(endAdornment) && 'adornedEnd'],
+    notchedOutline: ['notchedOutline'],
+    before: ['before'],
+    after: ['after'],
+    content: ['content'],
+    input: ['input']
+  };
+  return composeClasses(slots, getPickersStandardInputUtilityClass, classes);
+};
+export const PickersStandardInput = /*#__PURE__*/React.forwardRef(function PickersStandardInput(props, ref) {
+  const {
+      label,
+      ownerState: ownerStateProp
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const muiFormControl = useFormControl();
+  const ownerState = _extends({}, props, ownerStateProp, muiFormControl, {
+    color: (muiFormControl == null ? void 0 : muiFormControl.color) || 'primary'
+  });
+  const classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/_jsx(PickersInput, _extends({
+    slots: {
+      root: StandardInputRoot
+    }
+  }, other, {
+    label: label,
+    classes: classes,
+    ref: ref
+  }));
+});
+PickersInput.muiName = 'Input';

package/internals/components/PickersInput/index.d.ts

@@ -0,0 +1,4 @@
+export { PickersInput } from './PickersInput';
+export { PickersInputProps } from './PickersInput.types';
+export { pickersInputClasses, getPickersInputUtilityClass } from './pickersInputClasses';
+export type { PickersInputClasses, PickersInputClassKey } from './pickersInputClasses';

package/internals/components/PickersInput/index.js

@@ -0,0 +1,3 @@
+export { PickersInput } from './PickersInput';
+export { PickersInputProps } from './PickersInput.types';
+export { pickersInputClasses, getPickersInputUtilityClass } from './pickersInputClasses';

package/internals/components/PickersInput/pickersInputClasses.d.ts

@@ -0,0 +1,84 @@
+export interface PickersInputClasses {
+    /** Styles applied to the root element. */
+    root: string;
+    /** Styles applied to the root element if focused. */
+    focused: string;
+    /** State class applied to the root element if `disabled=true`. */
+    disabled: string;
+    /** State class applied to the root element if `readOnly=true`. */
+    readOnly: string;
+    /** State class applied to the root element if `error=true`. */
+    error: string;
+    /** Styles applied to the NotchedOutline element. */
+    notchedOutline: string;
+    /** Styles applied to the real hidden input element. */
+    input: string;
+    /** Styles applied to the container of the sections. */
+    sectionsContainer: string;
+    /** Styles applied to the content of a section. */
+    sectionContent: string;
+    /** Styles applied to the separator before a section */
+    sectionBefore: string;
+    /** Styles applied to the separator after a section */
+    sectionAfter: string;
+    /** Styles applied to the root if there is a startAdornment present */
+    adornedStart: string;
+    /** Styles applied to the root if there is an endAdornment present */
+    adornedEnd: string;
+    /** Styles applied to the root element unless `disableUnderline={true}`. */
+    underline?: string;
+}
+export type PickersInputClassKey = keyof PickersInputClasses;
+export declare function getPickersInputUtilityClass(slot: string): string;
+export declare function getPickersOutlinedInputUtilityClass(slot: string): string;
+export declare function getPickersFilledInputUtilityClass(slot: string): string;
+export declare function getPickersStandardInputUtilityClass(slot: string): string;
+export declare const pickersInputClasses: Record<keyof PickersInputClasses, string>;
+export declare const pickersOutlinedInputClasses: {
+    underline: string;
+    disabled: string;
+    input: string;
+    readOnly: string;
+    error: string;
+    focused: string;
+    root: string;
+    adornedStart: string;
+    adornedEnd: string;
+    notchedOutline: string;
+    sectionContent: string;
+    sectionsContainer: string;
+    sectionBefore: string;
+    sectionAfter: string;
+};
+export declare const pickersFilledInputClasses: {
+    underline: string;
+    disabled: string;
+    input: string;
+    readOnly: string;
+    error: string;
+    focused: string;
+    root: string;
+    adornedStart: string;
+    adornedEnd: string;
+    notchedOutline: string;
+    sectionContent: string;
+    sectionsContainer: string;
+    sectionBefore: string;
+    sectionAfter: string;
+};
+export declare const pickersStandardInputClasses: {
+    underline: string;
+    disabled: string;
+    input: string;
+    readOnly: string;
+    error: string;
+    focused: string;
+    root: string;
+    adornedStart: string;
+    adornedEnd: string;
+    notchedOutline: string;
+    sectionContent: string;
+    sectionsContainer: string;
+    sectionBefore: string;
+    sectionAfter: string;
+};

package/internals/components/PickersInput/pickersInputClasses.js

@@ -0,0 +1,18 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { unstable_generateUtilityClass as generateUtilityClass, unstable_generateUtilityClasses as generateUtilityClasses } from '@mui/utils';
+export function getPickersInputUtilityClass(slot) {
+  return generateUtilityClass('MuiPickersInput', slot);
+}
+export function getPickersOutlinedInputUtilityClass(slot) {
+  return generateUtilityClass('MuiPickersOutlinedInput', slot);
+}
+export function getPickersFilledInputUtilityClass(slot) {
+  return generateUtilityClass('MuiPickersFilledInput', slot);
+}
+export function getPickersStandardInputUtilityClass(slot) {
+  return generateUtilityClass('MuiPickersStandardInput', slot);
+}
+export const pickersInputClasses = generateUtilityClasses('MuiPickersInput', ['root', 'focused', 'disabled', 'error', 'notchedOutline', 'sectionContent', 'sectionBefore', 'sectionAfter', 'adornedStart', 'adornedEnd', 'input']);
+export const pickersOutlinedInputClasses = _extends({}, pickersInputClasses, generateUtilityClasses('MuiPickersOutlinedInput', ['root', 'notchedOutline', 'input']));
+export const pickersFilledInputClasses = _extends({}, pickersInputClasses, generateUtilityClasses('MuiPickersFilledInput', ['root', 'underline', 'input']));
+export const pickersStandardInputClasses = _extends({}, pickersInputClasses, generateUtilityClasses('MuiPickersStandardInput', ['root', 'underline', 'input']));

package/internals/components/PickersModalDialog.d.ts

@@ -3,7 +3,7 @@ import { DialogProps as MuiDialogProps } from '@mui/material/Dialog';
 import { PaperProps as MuiPaperProps } from '@mui/material/Paper/Paper';
 import { TransitionProps as MuiTransitionProps } from '@mui/material/transitions/transition';
 import { UsePickerValueActions } from '../hooks/usePicker/usePickerValue.types';
-export interface PickersModalDialogSlotsComponent {
+export interface PickersModalDialogSlots {
     /**
      * Custom component for the dialog inside which the views are rendered on mobile.
      * @default PickersModalDialogRoot
@@ -20,7 +20,7 @@ export interface PickersModalDialogSlotsComponent {
      */
     mobileTransition?: React.JSXElementConstructor<MuiTransitionProps>;
 }
-export interface PickersModalDialogSlotsComponentsProps {
+export interface PickersModalDialogSlotProps {
     /**
      * Props passed down to the [`Dialog`](https://mui.com/material-ui/api/dialog/) component.
      */
@@ -39,12 +39,12 @@ export interface PickersModalDialogProps extends UsePickerValueActions {
      * Overridable component slots.
      * @default {}
      */
-    slots?: PickersModalDialogSlotsComponent;
+    slots?: PickersModalDialogSlots;
     /**
      * The props used for each component slot.
      * @default {}
      */
-    slotProps?: PickersModalDialogSlotsComponentsProps;
+    slotProps?: PickersModalDialogSlotProps;
     open: boolean;
 }
 export declare function PickersModalDialog(props: React.PropsWithChildren<PickersModalDialogProps>): React.JSX.Element;

package/internals/components/PickersPopper.d.ts

@@ -9,7 +9,7 @@ import { UsePickerValueActions } from '../hooks/usePicker/usePickerValue.types';
 interface PickersPopperOwnerState extends PickerPopperProps {
     placement: PopperPlacementType;
 }
-export interface PickersPopperSlotsComponent {
+export interface PickersPopperSlots {
     /**
      * Custom component for the paper rendered inside the desktop picker's Popper.
      * @default PickersPopperPaper
@@ -31,7 +31,7 @@ export interface PickersPopperSlotsComponent {
      */
     popper?: React.ElementType<MuiPopperProps>;
 }
-export interface PickersPopperSlotsComponentsProps {
+export interface PickersPopperSlotProps {
     /**
      * Props passed down to the desktop [Paper](https://mui.com/material-ui/api/paper/) component.
      */
@@ -57,8 +57,8 @@ export interface PickerPopperProps extends UsePickerValueActions {
     containerRef?: React.Ref<HTMLDivElement>;
     children?: React.ReactNode;
     onBlur?: () => void;
-    slots?: PickersPopperSlotsComponent;
-    slotProps?: PickersPopperSlotsComponentsProps;
+    slots?: PickersPopperSlots;
+    slotProps?: PickersPopperSlotProps;
     classes?: Partial<PickersPopperClasses>;
     shouldRestoreFocus?: () => boolean;
     reduceAnimations?: boolean;

package/internals/components/PickersTextField/PickersTextField.d.ts

@@ -1,3 +1,2 @@
 import * as React from 'react';
-import { PickersTextFieldProps } from './PickersTextField.types';
-export declare const PickersTextField: React.ForwardRefExoticComponent<Omit<PickersTextFieldProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const PickersTextField: React.ForwardRefExoticComponent<(Omit<import("./PickersTextField.types").PickersStandardTextFieldProps, "ref"> | Omit<import("./PickersTextField.types").PickersOutlinedTextFieldProps, "ref"> | Omit<import("./PickersTextField.types").PickersFilledTextFieldProps, "ref">) & React.RefAttributes<HTMLDivElement>>;

package/internals/components/PickersTextField/PickersTextField.js

@@ -1,6 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["onFocus", "onBlur", "className", "color", "disabled", "error", "required", "variant", "InputProps", "inputProps", "inputRef", "sectionsContainerRef", "elements", "areAllSectionsEmpty", "onClick", "onKeyDown", "onKeyUp", "onPaste", "onInput", "endAdornment", "startAdornment", "tabIndex", "contentEditable", "focused", "value", "onChange", "fullWidth", "id", "helperText", "FormHelperTextProps", "label", "InputLabelProps"];
+const _excluded = ["onFocus", "onBlur", "className", "color", "disabled", "error", "variant", "required", "InputProps", "inputProps", "inputRef", "sectionListRef", "elements", "areAllSectionsEmpty", "onClick", "onKeyDown", "onKeyUp", "onPaste", "onInput", "endAdornment", "startAdornment", "tabIndex", "contentEditable", "focused", "value", "onChange", "fullWidth", "id", "helperText", "FormHelperTextProps", "label", "InputLabelProps"];
 import * as React from 'react';
 import clsx from 'clsx';
 import { styled } from '@mui/material/styles';
@@ -10,9 +10,16 @@ import InputLabel from '@mui/material/InputLabel';
 import FormHelperText from '@mui/material/FormHelperText';
 import FormControl from '@mui/material/FormControl';
 import { getPickersTextFieldUtilityClass } from './pickersTextFieldClasses';
-import { PickersInput } from './PickersInput';
+import { PickersOutlinedInput } from '../PickersInput/PickersOutlinedInput';
+import { PickersFilledInput } from '../PickersInput/PickersFilledInput';
+import { PickersStandardInput } from '../PickersInput/PickersStandardInput';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
+const VARIANT_COMPONENT = {
+  standard: PickersStandardInput,
+  filled: PickersFilledInput,
+  outlined: PickersOutlinedInput
+};
 const PickersTextFieldRoot = styled(FormControl, {
   name: 'MuiPickersTextField',
   slot: 'Root',
@@ -39,13 +46,13 @@ export const PickersTextField = /*#__PURE__*/React.forwardRef(function PickersTe
       color = 'primary',
       disabled = false,
       error = false,
-      required = false,
       variant = 'outlined',
+      required = false,
       // Props used by PickersInput
       InputProps,
       inputProps,
       inputRef,
-      sectionsContainerRef,
+      sectionListRef,
       elements,
       areAllSectionsEmpty,
       onClick,
@@ -83,6 +90,7 @@ export const PickersTextField = /*#__PURE__*/React.forwardRef(function PickersTe
     variant
   });
   const classes = useUtilityClasses(ownerState);
+  const PickersInputComponent = VARIANT_COMPONENT[variant];
   return /*#__PURE__*/_jsxs(PickersTextFieldRoot, _extends({
     className: clsx(classes.root, className),
     ref: handleRootRef,
@@ -93,6 +101,7 @@ export const PickersTextField = /*#__PURE__*/React.forwardRef(function PickersTe
     variant: variant,
     error: error,
     color: color,
+    fullWidth: fullWidth,
     required: required,
     ownerState: ownerState
   }, other, {
@@ -101,7 +110,7 @@ export const PickersTextField = /*#__PURE__*/React.forwardRef(function PickersTe
       id: inputLabelId
     }, InputLabelProps, {
       children: label
-    })), /*#__PURE__*/_jsx(PickersInput, _extends({
+    })), /*#__PURE__*/_jsx(PickersInputComponent, _extends({
       elements: elements,
       areAllSectionsEmpty: areAllSectionsEmpty,
       onClick: onClick,
@@ -118,7 +127,7 @@ export const PickersTextField = /*#__PURE__*/React.forwardRef(function PickersTe
       fullWidth: fullWidth,
       inputProps: inputProps,
       inputRef: inputRef,
-      sectionsContainerRef: sectionsContainerRef,
+      sectionListRef: sectionListRef,
       label: label
     }, InputProps)), helperText && /*#__PURE__*/_jsx(FormHelperText, _extends({
       id: helperTextId

package/internals/components/PickersTextField/PickersTextField.types.d.ts

@@ -2,15 +2,15 @@ import * as React from 'react';
 import { FormControlProps } from '@mui/material/FormControl';
 import { FormHelperTextProps } from '@mui/material/FormHelperText';
 import { InputLabelProps } from '@mui/material/InputLabel';
-import { PickersInputOtherProps, PickersInputPropsUsedByField } from './PickersInput.types';
+import { TextFieldVariants } from '@mui/material/TextField';
+import { PickersFilledInputProps, PickersInputPropsUsedByField, PickersOutlinedInputProps, PickersStandardInputProps } from '../PickersInput/PickersInput.types';
 interface PickersTextFieldPropsUsedByField {
     onFocus: React.FocusEventHandler<HTMLDivElement>;
     onBlur: React.FocusEventHandler<HTMLDivElement>;
     disabled: boolean;
     error: boolean;
 }
-export interface PickersTextFieldProps extends PickersInputPropsUsedByField, PickersTextFieldPropsUsedByField, Omit<FormControlProps, keyof PickersInputPropsUsedByField | keyof PickersTextFieldPropsUsedByField> {
-    InputProps?: PickersInputOtherProps;
+export interface PickersBaseTextFieldProps extends PickersInputPropsUsedByField, PickersTextFieldPropsUsedByField, Omit<FormControlProps, keyof PickersInputPropsUsedByField | keyof PickersTextFieldPropsUsedByField> {
     FormHelperTextProps?: Partial<FormHelperTextProps>;
     InputLabelProps?: Partial<InputLabelProps>;
     /**
@@ -18,4 +18,47 @@ export interface PickersTextFieldProps extends PickersInputPropsUsedByField, Pic
      */
     helperText?: React.ReactNode;
 }
+export interface PickersStandardTextFieldProps extends PickersBaseTextFieldProps {
+    /**
+     * The variant to use.
+     * @default 'outlined'
+     */
+    variant?: 'standard';
+    /**
+     * Props applied to the Input element.
+     * It will be a [`FilledInput`](/material-ui/api/filled-input/),
+     * [`OutlinedInput`](/material-ui/api/outlined-input/) or [`Input`](/material-ui/api/input/)
+     * component depending on the `variant` prop value.
+     */
+    InputProps?: Partial<PickersStandardInputProps>;
+}
+export interface PickersOutlinedTextFieldProps extends PickersBaseTextFieldProps {
+    /**
+     * The variant to use.
+     * @default 'outlined'
+     */
+    variant?: 'outlined';
+    /**
+     * Props applied to the Input element.
+     * It will be a [`FilledInput`](/material-ui/api/filled-input/),
+     * [`OutlinedInput`](/material-ui/api/outlined-input/) or [`Input`](/material-ui/api/input/)
+     * component depending on the `variant` prop value.
+     */
+    InputProps?: Partial<PickersOutlinedInputProps>;
+}
+export interface PickersFilledTextFieldProps extends PickersBaseTextFieldProps {
+    /**
+     * The variant to use.
+     * @default 'outlined'
+     */
+    variant?: 'filled';
+    /**
+     * Props applied to the Input element.
+     * It will be a [`FilledInput`](/material-ui/api/filled-input/),
+     * [`OutlinedInput`](/material-ui/api/outlined-input/) or [`Input`](/material-ui/api/input/)
+     * component depending on the `variant` prop value.
+     */
+    InputProps?: Partial<PickersFilledInputProps>;
+}
+export type PickersTextFieldProps<Variant extends TextFieldVariants = TextFieldVariants> = Variant extends 'filled' ? PickersFilledTextFieldProps : Variant extends 'standard' ? PickersStandardTextFieldProps : PickersOutlinedTextFieldProps;
 export {};