@mui/x-date-pickers 8.0.0-beta.2 → 8.0.0

package/modern/MonthCalendar/MonthCalendar.js

@@ -1,360 +0,0 @@
-'use client';
-
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-import _extends from "@babel/runtime/helpers/esm/extends";
-const _excluded = ["autoFocus", "className", "classes", "value", "defaultValue", "referenceDate", "disabled", "disableFuture", "disablePast", "maxDate", "minDate", "onChange", "shouldDisableMonth", "readOnly", "disableHighlightToday", "onMonthFocus", "hasFocus", "onFocusedViewChange", "monthsPerRow", "timezone", "gridLabelId", "slots", "slotProps"];
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import clsx from 'clsx';
-import { useRtl } from '@mui/system/RtlProvider';
-import { shouldForwardProp } from '@mui/system/createStyled';
-import { styled, useThemeProps } from '@mui/material/styles';
-import { unstable_useControlled as useControlled, unstable_composeClasses as composeClasses, unstable_useEventCallback as useEventCallback } from '@mui/utils';
-import { MonthCalendarButton } from "./MonthCalendarButton.js";
-import { useUtils, useNow } from "../internals/hooks/useUtils.js";
-import { getMonthCalendarUtilityClass } from "./monthCalendarClasses.js";
-import { getMonthsInYear } from "../internals/utils/date-utils.js";
-import { singleItemValueManager } from "../internals/utils/valueManagers.js";
-import { SECTION_TYPE_GRANULARITY } from "../internals/utils/getDefaultReferenceDate.js";
-import { useControlledValue } from "../internals/hooks/useControlledValue.js";
-import { DIALOG_WIDTH } from "../internals/constants/dimensions.js";
-import { usePickerPrivateContext } from "../internals/hooks/usePickerPrivateContext.js";
-import { useApplyDefaultValuesToDateValidationProps } from "../managers/useDateManager.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-const useUtilityClasses = classes => {
-  const slots = {
-    root: ['root']
-  };
-  return composeClasses(slots, getMonthCalendarUtilityClass, classes);
-};
-export function useMonthCalendarDefaultizedProps(props, name) {
-  const themeProps = useThemeProps({
-    props,
-    name
-  });
-  const validationProps = useApplyDefaultValuesToDateValidationProps(themeProps);
-  return _extends({}, themeProps, validationProps, {
-    monthsPerRow: themeProps.monthsPerRow ?? 3
-  });
-}
-const MonthCalendarRoot = styled('div', {
-  name: 'MuiMonthCalendar',
-  slot: 'Root',
-  overridesResolver: (props, styles) => styles.root,
-  shouldForwardProp: prop => shouldForwardProp(prop) && prop !== 'monthsPerRow'
-})({
-  display: 'flex',
-  flexWrap: 'wrap',
-  justifyContent: 'space-evenly',
-  rowGap: 16,
-  padding: '8px 0',
-  width: DIALOG_WIDTH,
-  // avoid padding increasing width over defined
-  boxSizing: 'border-box',
-  variants: [{
-    props: {
-      monthsPerRow: 3
-    },
-    style: {
-      columnGap: 24
-    }
-  }, {
-    props: {
-      monthsPerRow: 4
-    },
-    style: {
-      columnGap: 0
-    }
-  }]
-});
-/**
- * Demos:
- *
- * - [DateCalendar](https://mui.com/x/react-date-pickers/date-calendar/)
- *
- * API:
- *
- * - [MonthCalendar API](https://mui.com/x/api/date-pickers/month-calendar/)
- */
-export const MonthCalendar = /*#__PURE__*/React.forwardRef(function MonthCalendar(inProps, ref) {
-  const props = useMonthCalendarDefaultizedProps(inProps, 'MuiMonthCalendar');
-  const {
-      autoFocus,
-      className,
-      classes: classesProp,
-      value: valueProp,
-      defaultValue,
-      referenceDate: referenceDateProp,
-      disabled,
-      disableFuture,
-      disablePast,
-      maxDate,
-      minDate,
-      onChange,
-      shouldDisableMonth,
-      readOnly,
-      onMonthFocus,
-      hasFocus,
-      onFocusedViewChange,
-      monthsPerRow,
-      timezone: timezoneProp,
-      gridLabelId,
-      slots,
-      slotProps
-    } = props,
-    other = _objectWithoutPropertiesLoose(props, _excluded);
-  const {
-    value,
-    handleValueChange,
-    timezone
-  } = useControlledValue({
-    name: 'MonthCalendar',
-    timezone: timezoneProp,
-    value: valueProp,
-    defaultValue,
-    referenceDate: referenceDateProp,
-    onChange,
-    valueManager: singleItemValueManager
-  });
-  const now = useNow(timezone);
-  const isRtl = useRtl();
-  const utils = useUtils();
-  const {
-    ownerState
-  } = usePickerPrivateContext();
-  const referenceDate = React.useMemo(() => singleItemValueManager.getInitialReferenceValue({
-    value,
-    utils,
-    props,
-    timezone,
-    referenceDate: referenceDateProp,
-    granularity: SECTION_TYPE_GRANULARITY.month
-  }), [] // eslint-disable-line react-hooks/exhaustive-deps
-  );
-  const classes = useUtilityClasses(classesProp);
-  const todayMonth = React.useMemo(() => utils.getMonth(now), [utils, now]);
-  const selectedMonth = React.useMemo(() => {
-    if (value != null) {
-      return utils.getMonth(value);
-    }
-    return null;
-  }, [value, utils]);
-  const [focusedMonth, setFocusedMonth] = React.useState(() => selectedMonth || utils.getMonth(referenceDate));
-  const [internalHasFocus, setInternalHasFocus] = useControlled({
-    name: 'MonthCalendar',
-    state: 'hasFocus',
-    controlled: hasFocus,
-    default: autoFocus ?? false
-  });
-  const changeHasFocus = useEventCallback(newHasFocus => {
-    setInternalHasFocus(newHasFocus);
-    if (onFocusedViewChange) {
-      onFocusedViewChange(newHasFocus);
-    }
-  });
-  const isMonthDisabled = React.useCallback(dateToValidate => {
-    const firstEnabledMonth = utils.startOfMonth(disablePast && utils.isAfter(now, minDate) ? now : minDate);
-    const lastEnabledMonth = utils.startOfMonth(disableFuture && utils.isBefore(now, maxDate) ? now : maxDate);
-    const monthToValidate = utils.startOfMonth(dateToValidate);
-    if (utils.isBefore(monthToValidate, firstEnabledMonth)) {
-      return true;
-    }
-    if (utils.isAfter(monthToValidate, lastEnabledMonth)) {
-      return true;
-    }
-    if (!shouldDisableMonth) {
-      return false;
-    }
-    return shouldDisableMonth(monthToValidate);
-  }, [disableFuture, disablePast, maxDate, minDate, now, shouldDisableMonth, utils]);
-  const handleMonthSelection = useEventCallback((event, month) => {
-    if (readOnly) {
-      return;
-    }
-    const newDate = utils.setMonth(value ?? referenceDate, month);
-    handleValueChange(newDate);
-  });
-  const focusMonth = useEventCallback(month => {
-    if (!isMonthDisabled(utils.setMonth(value ?? referenceDate, month))) {
-      setFocusedMonth(month);
-      changeHasFocus(true);
-      if (onMonthFocus) {
-        onMonthFocus(month);
-      }
-    }
-  });
-  React.useEffect(() => {
-    setFocusedMonth(prevFocusedMonth => selectedMonth !== null && prevFocusedMonth !== selectedMonth ? selectedMonth : prevFocusedMonth);
-  }, [selectedMonth]);
-  const handleKeyDown = useEventCallback((event, month) => {
-    const monthsInYear = 12;
-    const monthsInRow = 3;
-    switch (event.key) {
-      case 'ArrowUp':
-        focusMonth((monthsInYear + month - monthsInRow) % monthsInYear);
-        event.preventDefault();
-        break;
-      case 'ArrowDown':
-        focusMonth((monthsInYear + month + monthsInRow) % monthsInYear);
-        event.preventDefault();
-        break;
-      case 'ArrowLeft':
-        focusMonth((monthsInYear + month + (isRtl ? 1 : -1)) % monthsInYear);
-        event.preventDefault();
-        break;
-      case 'ArrowRight':
-        focusMonth((monthsInYear + month + (isRtl ? -1 : 1)) % monthsInYear);
-        event.preventDefault();
-        break;
-      default:
-        break;
-    }
-  });
-  const handleMonthFocus = useEventCallback((event, month) => {
-    focusMonth(month);
-  });
-  const handleMonthBlur = useEventCallback((event, month) => {
-    if (focusedMonth === month) {
-      changeHasFocus(false);
-    }
-  });
-  return /*#__PURE__*/_jsx(MonthCalendarRoot, _extends({
-    ref: ref,
-    className: clsx(classes.root, className),
-    ownerState: ownerState,
-    role: "radiogroup",
-    "aria-labelledby": gridLabelId,
-    monthsPerRow: monthsPerRow
-  }, other, {
-    children: getMonthsInYear(utils, value ?? referenceDate).map(month => {
-      const monthNumber = utils.getMonth(month);
-      const monthText = utils.format(month, 'monthShort');
-      const monthLabel = utils.format(month, 'month');
-      const isSelected = monthNumber === selectedMonth;
-      const isDisabled = disabled || isMonthDisabled(month);
-      return /*#__PURE__*/_jsx(MonthCalendarButton, {
-        selected: isSelected,
-        value: monthNumber,
-        onClick: handleMonthSelection,
-        onKeyDown: handleKeyDown,
-        autoFocus: internalHasFocus && monthNumber === focusedMonth,
-        disabled: isDisabled,
-        tabIndex: monthNumber === focusedMonth && !isDisabled ? 0 : -1,
-        onFocus: handleMonthFocus,
-        onBlur: handleMonthBlur,
-        "aria-current": todayMonth === monthNumber ? 'date' : undefined,
-        "aria-label": monthLabel,
-        slots: slots,
-        slotProps: slotProps,
-        classes: classesProp,
-        children: monthText
-      }, monthText);
-    })
-  }));
-});
-process.env.NODE_ENV !== "production" ? MonthCalendar.propTypes = {
-  // ----------------------------- Warning --------------------------------
-  // | These PropTypes are generated from the TypeScript type definitions |
-  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
-  // ----------------------------------------------------------------------
-  autoFocus: PropTypes.bool,
-  /**
-   * Override or extend the styles applied to the component.
-   */
-  classes: PropTypes.object,
-  className: PropTypes.string,
-  /**
-   * The default selected value.
-   * Used when the component is not controlled.
-   */
-  defaultValue: PropTypes.object,
-  /**
-   * If `true`, the component is disabled.
-   * When disabled, the value cannot be changed and no interaction is possible.
-   * @default false
-   */
-  disabled: PropTypes.bool,
-  /**
-   * If `true`, disable values after the current date for date components, time for time components and both for date time components.
-   * @default false
-   */
-  disableFuture: PropTypes.bool,
-  /**
-   * If `true`, today's date is rendering without highlighting with circle.
-   * @default false
-   */
-  disableHighlightToday: PropTypes.bool,
-  /**
-   * If `true`, disable values before the current date for date components, time for time components and both for date time components.
-   * @default false
-   */
-  disablePast: PropTypes.bool,
-  gridLabelId: PropTypes.string,
-  hasFocus: PropTypes.bool,
-  /**
-   * Maximal selectable date.
-   * @default 2099-12-31
-   */
-  maxDate: PropTypes.object,
-  /**
-   * Minimal selectable date.
-   * @default 1900-01-01
-   */
-  minDate: PropTypes.object,
-  /**
-   * Months rendered per row.
-   * @default 3
-   */
-  monthsPerRow: PropTypes.oneOf([3, 4]),
-  /**
-   * Callback fired when the value changes.
-   * @param {PickerValidDate} value The new value.
-   */
-  onChange: PropTypes.func,
-  onFocusedViewChange: PropTypes.func,
-  onMonthFocus: PropTypes.func,
-  /**
-   * If `true`, the component is read-only.
-   * When read-only, the value cannot be changed but the user can interact with the interface.
-   * @default false
-   */
-  readOnly: PropTypes.bool,
-  /**
-   * The date used to generate the new value when both `value` and `defaultValue` are empty.
-   * @default The closest valid month using the validation props, except callbacks such as `shouldDisableMonth`.
-   */
-  referenceDate: PropTypes.object,
-  /**
-   * Disable specific month.
-   * @param {PickerValidDate} month The month to test.
-   * @returns {boolean} If `true`, the month will be disabled.
-   */
-  shouldDisableMonth: PropTypes.func,
-  /**
-   * The props used for each component slot.
-   * @default {}
-   */
-  slotProps: PropTypes.object,
-  /**
-   * Overridable component slots.
-   * @default {}
-   */
-  slots: 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]),
-  /**
-   * Choose which timezone to use for the value.
-   * Example: "default", "system", "UTC", "America/New_York".
-   * If you pass values from other timezones to some props, they will be converted to this timezone before being used.
-   * @see See the {@link https://mui.com/x/react-date-pickers/timezone/ timezones documentation} for more details.
-   * @default The timezone of the `value` or `defaultValue` prop is defined, 'default' otherwise.
-   */
-  timezone: PropTypes.string,
-  /**
-   * The selected value.
-   * Used when the component is controlled.
-   */
-  value: PropTypes.object
-} : void 0;

package/modern/MonthCalendar/MonthCalendar.types.d.ts

@@ -1,82 +0,0 @@
-import * as React from 'react';
-import { SxProps } from '@mui/system';
-import { Theme } from '@mui/material/styles';
-import { SlotComponentPropsFromProps } from '@mui/x-internals/types';
-import { MonthCalendarClasses } from "./monthCalendarClasses.js";
-import { BaseDateValidationProps, MonthValidationProps } from "../internals/models/validation.js";
-import { PickerOwnerState, PickerValidDate, TimezoneProps } from "../models/index.js";
-import { FormProps } from "../internals/models/formProps.js";
-export interface MonthButtonOwnerState extends PickerOwnerState {
-  isMonthSelected: boolean;
-  isMonthDisabled: boolean;
-}
-export interface MonthCalendarSlots {
-  /**
-   * Button displayed to render a single month in the `month` view.
-   * @default MonthCalendarButton
-   */
-  monthButton?: React.ElementType;
-}
-export interface MonthCalendarSlotProps {
-  monthButton?: SlotComponentPropsFromProps<React.HTMLAttributes<HTMLButtonElement> & {
-    sx: SxProps;
-  }, {}, MonthButtonOwnerState>;
-}
-export interface ExportedMonthCalendarProps {
-  /**
-   * Months rendered per row.
-   * @default 3
-   */
-  monthsPerRow?: 3 | 4;
-}
-export interface MonthCalendarProps extends ExportedMonthCalendarProps, MonthValidationProps, BaseDateValidationProps, TimezoneProps, FormProps {
-  autoFocus?: boolean;
-  className?: string;
-  /**
-   * Override or extend the styles applied to the component.
-   */
-  classes?: Partial<MonthCalendarClasses>;
-  /**
-   * Overridable component slots.
-   * @default {}
-   */
-  slots?: MonthCalendarSlots;
-  /**
-   * The props used for each component slot.
-   * @default {}
-   */
-  slotProps?: MonthCalendarSlotProps;
-  /**
-   * The system prop that allows defining system overrides as well as additional CSS styles.
-   */
-  sx?: SxProps<Theme>;
-  /**
-   * The selected value.
-   * Used when the component is controlled.
-   */
-  value?: PickerValidDate | null;
-  /**
-   * The default selected value.
-   * Used when the component is not controlled.
-   */
-  defaultValue?: PickerValidDate | null;
-  /**
-   * The date used to generate the new value when both `value` and `defaultValue` are empty.
-   * @default The closest valid month using the validation props, except callbacks such as `shouldDisableMonth`.
-   */
-  referenceDate?: PickerValidDate;
-  /**
-   * Callback fired when the value changes.
-   * @param {PickerValidDate} value The new value.
-   */
-  onChange?: (value: PickerValidDate) => void;
-  /**
-   * If `true`, today's date is rendering without highlighting with circle.
-   * @default false
-   */
-  disableHighlightToday?: boolean;
-  onMonthFocus?: (month: number) => void;
-  hasFocus?: boolean;
-  onFocusedViewChange?: (hasFocus: boolean) => void;
-  gridLabelId?: string;
-}

package/modern/MonthCalendar/MonthCalendar.types.js

@@ -1 +0,0 @@
-export {};

package/modern/MonthCalendar/MonthCalendarButton.d.ts

@@ -1,24 +0,0 @@
-import * as React from 'react';
-import { MonthCalendarSlotProps, MonthCalendarSlots } from "./MonthCalendar.types.js";
-import { MonthCalendarClasses } from "./monthCalendarClasses.js";
-export interface MonthCalendarButtonProps {
-  value: number;
-  tabIndex: number;
-  selected: boolean;
-  disabled: boolean;
-  autoFocus: boolean;
-  classes: Partial<MonthCalendarClasses> | undefined;
-  slots: MonthCalendarSlots | undefined;
-  slotProps: MonthCalendarSlotProps | undefined;
-  'aria-current': React.AriaAttributes['aria-current'];
-  'aria-label': React.AriaAttributes['aria-label'];
-  children: React.ReactNode;
-  onClick: (event: React.MouseEvent, month: number) => void;
-  onKeyDown: (event: React.KeyboardEvent, month: number) => void;
-  onFocus: (event: React.FocusEvent, month: number) => void;
-  onBlur: (event: React.FocusEvent, month: number) => void;
-}
-/**
- * @ignore - do not document.
- */
-export declare const MonthCalendarButton: React.NamedExoticComponent<MonthCalendarButtonProps>;

package/modern/MonthCalendar/MonthCalendarButton.js

@@ -1,115 +0,0 @@
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-import _extends from "@babel/runtime/helpers/esm/extends";
-const _excluded = ["autoFocus", "classes", "disabled", "selected", "value", "onClick", "onKeyDown", "onFocus", "onBlur", "slots", "slotProps"];
-import * as React from 'react';
-import { styled, alpha } from '@mui/material/styles';
-import useSlotProps from '@mui/utils/useSlotProps';
-import composeClasses from '@mui/utils/composeClasses';
-import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
-import { usePickerPrivateContext } from "../internals/hooks/usePickerPrivateContext.js";
-import { getMonthCalendarUtilityClass, monthCalendarClasses } from "./monthCalendarClasses.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-const useUtilityClasses = (classes, ownerState) => {
-  const slots = {
-    button: ['button', ownerState.isMonthDisabled && 'disabled', ownerState.isMonthSelected && 'selected']
-  };
-  return composeClasses(slots, getMonthCalendarUtilityClass, classes);
-};
-const DefaultMonthButton = styled('button', {
-  name: 'MuiMonthCalendar',
-  slot: 'Button',
-  overridesResolver: (_, styles) => [styles.button, {
-    [`&.${monthCalendarClasses.disabled}`]: styles.disabled
-  }, {
-    [`&.${monthCalendarClasses.selected}`]: styles.selected
-  }]
-})(({
-  theme
-}) => _extends({
-  color: 'unset',
-  backgroundColor: 'transparent',
-  border: 0,
-  outline: 0
-}, theme.typography.subtitle1, {
-  height: 36,
-  width: 72,
-  borderRadius: 18,
-  cursor: 'pointer',
-  '&:focus': {
-    backgroundColor: theme.vars ? `rgba(${theme.vars.palette.action.activeChannel} / ${theme.vars.palette.action.hoverOpacity})` : alpha(theme.palette.action.active, theme.palette.action.hoverOpacity)
-  },
-  '&:hover': {
-    backgroundColor: theme.vars ? `rgba(${theme.vars.palette.action.activeChannel} / ${theme.vars.palette.action.hoverOpacity})` : alpha(theme.palette.action.active, theme.palette.action.hoverOpacity)
-  },
-  '&:disabled': {
-    cursor: 'auto',
-    pointerEvents: 'none'
-  },
-  [`&.${monthCalendarClasses.disabled}`]: {
-    color: (theme.vars || theme).palette.text.secondary
-  },
-  [`&.${monthCalendarClasses.selected}`]: {
-    color: (theme.vars || theme).palette.primary.contrastText,
-    backgroundColor: (theme.vars || theme).palette.primary.main,
-    '&:focus, &:hover': {
-      backgroundColor: (theme.vars || theme).palette.primary.dark
-    }
-  }
-}));
-
-/**
- * @ignore - do not document.
- */
-export const MonthCalendarButton = /*#__PURE__*/React.memo(function MonthCalendarButton(props) {
-  const {
-      autoFocus,
-      classes: classesProp,
-      disabled,
-      selected,
-      value,
-      onClick,
-      onKeyDown,
-      onFocus,
-      onBlur,
-      slots,
-      slotProps
-    } = props,
-    other = _objectWithoutPropertiesLoose(props, _excluded);
-  const ref = React.useRef(null);
-  const {
-    ownerState: pickerOwnerState
-  } = usePickerPrivateContext();
-  const ownerState = _extends({}, pickerOwnerState, {
-    isMonthDisabled: disabled,
-    isMonthSelected: selected
-  });
-  const classes = useUtilityClasses(classesProp, ownerState);
-
-  // We can't forward the `autoFocus` to the button because it is a native button, not a MUI Button
-  useEnhancedEffect(() => {
-    if (autoFocus) {
-      // `ref.current` being `null` would be a bug in MUI.
-      ref.current?.focus();
-    }
-  }, [autoFocus]);
-  const MonthButton = slots?.monthButton ?? DefaultMonthButton;
-  const monthButtonProps = useSlotProps({
-    elementType: MonthButton,
-    externalSlotProps: slotProps?.monthButton,
-    externalForwardedProps: other,
-    additionalProps: {
-      disabled,
-      ref,
-      type: 'button',
-      role: 'radio',
-      'aria-checked': selected,
-      onClick: event => onClick(event, value),
-      onKeyDown: event => onKeyDown(event, value),
-      onFocus: event => onFocus(event, value),
-      onBlur: event => onBlur(event, value)
-    },
-    ownerState,
-    className: classes.button
-  });
-  return /*#__PURE__*/_jsx(MonthButton, _extends({}, monthButtonProps));
-});

package/modern/MonthCalendar/index.d.ts

@@ -1,4 +0,0 @@
-export { MonthCalendar } from "./MonthCalendar.js";
-export type { MonthCalendarProps, MonthCalendarSlots, MonthCalendarSlotProps } from './MonthCalendar.types';
-export { monthCalendarClasses, getMonthCalendarUtilityClass } from "./monthCalendarClasses.js";
-export type { MonthCalendarClasses, MonthCalendarClassKey } from './monthCalendarClasses';

package/modern/MonthCalendar/index.js

@@ -1,2 +0,0 @@
-export { MonthCalendar } from "./MonthCalendar.js";
-export { monthCalendarClasses, getMonthCalendarUtilityClass } from "./monthCalendarClasses.js";

package/modern/MonthCalendar/monthCalendarClasses.d.ts

@@ -1,13 +0,0 @@
-export declare function getMonthCalendarUtilityClass(slot: string): string;
-export interface MonthCalendarClasses {
-  /** Styles applied to the root element. */
-  root: string;
-  /** Styles applied to the button element that represents a single month */
-  button: string;
-  /** Styles applied to a disabled button element. */
-  disabled: string;
-  /** Styles applied to a selected button element. */
-  selected: string;
-}
-export type MonthCalendarClassKey = keyof MonthCalendarClasses;
-export declare const monthCalendarClasses: Record<keyof MonthCalendarClasses, string>;

package/modern/MonthCalendar/monthCalendarClasses.js

@@ -1,5 +0,0 @@
-import { unstable_generateUtilityClass as generateUtilityClass, unstable_generateUtilityClasses as generateUtilityClasses } from '@mui/utils';
-export function getMonthCalendarUtilityClass(slot) {
-  return generateUtilityClass('MuiMonthCalendar', slot);
-}
-export const monthCalendarClasses = generateUtilityClasses('MuiMonthCalendar', ['root', 'button', 'disabled', 'selected']);

package/modern/MultiSectionDigitalClock/MultiSectionDigitalClock.d.ts

@@ -1,17 +0,0 @@
-import * as React from 'react';
-import { MultiSectionDigitalClockProps } from "./MultiSectionDigitalClock.types.js";
-type MultiSectionDigitalClockComponent = ((props: MultiSectionDigitalClockProps & React.RefAttributes<HTMLDivElement>) => React.JSX.Element) & {
-  propTypes?: any;
-};
-/**
- * Demos:
- *
- * - [TimePicker](https://mui.com/x/react-date-pickers/time-picker/)
- * - [DigitalClock](https://mui.com/x/react-date-pickers/digital-clock/)
- *
- * API:
- *
- * - [MultiSectionDigitalClock API](https://mui.com/x/api/date-pickers/multi-section-digital-clock/)
- */
-export declare const MultiSectionDigitalClock: MultiSectionDigitalClockComponent;
-export {};