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

package/modern/internals/components/PickerFieldUI.d.ts

@@ -0,0 +1,136 @@
+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/index.js";
+import { UseFieldOwnerStateParameters } from "../hooks/useFieldOwnerState.js";
+import type { UseFieldResponse } from '../hooks/useField';
+import { PickersTextFieldProps } from "../../PickersTextField/index.js";
+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/modern/internals/components/PickerPopper/PickerPopper.d.ts

@@ -0,0 +1,71 @@
+import * as React from 'react';
+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 { TransitionProps as MuiTransitionProps } from '@mui/material/transitions';
+import { SlotComponentPropsFromProps } from '@mui/x-internals/types';
+import { PickerPopperClasses } from "./pickerPopperClasses.js";
+import { PickerOwnerState } from "../../../models/index.js";
+interface PickerPopperOwnerState extends PickerOwnerState {
+  popperPlacement: PopperPlacementType;
+}
+export interface PickerPopperSlots {
+  /**
+   * Custom component for the paper rendered inside the desktop picker's Popper.
+   * @default PickerPopperPaper
+   */
+  desktopPaper?: React.JSXElementConstructor<MuiPaperProps>;
+  /**
+   * Custom component for the desktop popper [Transition](https://mui.com/material-ui/transitions/).
+   * @default Grow or Fade from '@mui/material' when `reduceAnimations` is `true`.
+   */
+  desktopTransition?: React.JSXElementConstructor<MuiTransitionProps>;
+  /**
+   * Custom component for trapping the focus inside the views on desktop.
+   * @default TrapFocus from '@mui/material'.
+   */
+  desktopTrapFocus?: React.JSXElementConstructor<MuiTrapFocusProps>;
+  /**
+   * Custom component for the popper inside which the views are rendered on desktop.
+   * @default Popper from '@mui/material'.
+   */
+  popper?: React.ElementType<MuiPopperProps>;
+}
+export interface PickerPopperSlotProps {
+  /**
+   * Props passed down to the desktop [Paper](https://mui.com/material-ui/api/paper/) component.
+   */
+  desktopPaper?: SlotComponentPropsFromProps<PaperProps, {}, PickerPopperOwnerState>;
+  /**
+   * Props passed down to the desktop [Transition](https://mui.com/material-ui/transitions/) component.
+   */
+  desktopTransition?: Partial<MuiTransitionProps>;
+  /**
+   * Props passed down to the [FocusTrap](https://mui.com/base-ui/react-focus-trap/) component on desktop.
+   */
+  desktopTrapFocus?: Partial<MuiTrapFocusProps>;
+  /**
+   * Props passed down to [Popper](https://mui.com/material-ui/api/popper/) component.
+   */
+  popper?: SlotComponentPropsFromProps<PopperProps, {}, PickerPopperOwnerState>;
+}
+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?: PickerPopperSlots;
+  slotProps?: PickerPopperSlotProps;
+}
+export declare function PickerPopper(inProps: PickerPopperProps): React.JSX.Element;
+export {};

package/modern/internals/components/PickerPopper/index.d.ts

@@ -0,0 +1,4 @@
+export { PickerPopper } from "./PickerPopper.js";
+export type { ExportedPickerPopperProps } from './PickerPopper';
+export { pickerPopperClasses, getPickerPopperUtilityClass } from "./pickerPopperClasses.js";
+export type { PickerPopperClassKey, PickerPopperClasses } from './pickerPopperClasses';

package/modern/internals/components/PickerPopper/pickerPopperClasses.d.ts

@@ -0,0 +1,9 @@
+export interface PickerPopperClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the paper element. */
+  paper: string;
+}
+export type PickerPopperClassKey = keyof PickerPopperClasses;
+export declare function getPickerPopperUtilityClass(slot: string): string;
+export declare const pickerPopperClasses: Record<"root" | "paper", string>;

package/modern/internals/components/PickerProvider.d.ts

@@ -0,0 +1,120 @@
+import * as React from 'react';
+import { SxProps } from '@mui/system';
+import { Theme } from '@mui/material/styles';
+import { PickerOwnerState } from "../../models/index.js";
+import { PickersInputLocaleText } from "../../locales/index.js";
+import { DateOrTimeViewWithMeridiem, PickerOrientation, PickerValidValue, PickerVariant } from "../models/index.js";
+import type { UsePickerValueActionsContextValue, UsePickerValueContextValue, UsePickerValuePrivateContextValue } from '../hooks/usePicker/usePickerValue.types';
+import { UsePickerViewsActionsContextValue, UsePickerViewsContextValue, UsePickerViewsPrivateContextValue } from "../hooks/usePicker/usePickerViews.js";
+import { PickerFieldPrivateContextValue } from "../hooks/useField/useFieldInternalPropsWithDefaults.js";
+export declare const PickerActionsContext: React.Context<PickerActionsContextValue<any, any, any> | null>;
+export declare const PickerPrivateContext: React.Context<PickerPrivateContextValue>;
+/**
+ * Provides the context for the various parts of a picker component:
+ * - contextValue: the context for the picker sub-components.
+ * - localizationProvider: the translations passed through the props and through a parent LocalizationProvider.
+ *
+ * @ignore - do not document.
+ */
+export declare function PickerProvider<TValue extends PickerValidValue>(props: PickerProviderProps<TValue>): React.JSX.Element;
+export interface PickerProviderProps<TValue extends PickerValidValue> {
+  contextValue: PickerContextValue<any, any, any>;
+  actionsContextValue: PickerActionsContextValue<any, any, any>;
+  privateContextValue: PickerPrivateContextValue;
+  fieldPrivateContextValue: PickerFieldPrivateContextValue;
+  isValidContextValue: (value: TValue) => boolean;
+  localeText: PickersInputLocaleText | undefined;
+  children: React.ReactNode;
+}
+export interface PickerContextValue<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError> extends UsePickerValueContextValue<TValue, TError>, UsePickerViewsContextValue<TView> {
+  /**
+   * Whether the picker is disabled.
+   */
+  disabled: boolean;
+  /**
+   * Whether the picker is read-only.
+   */
+  readOnly: boolean;
+  /**
+   * The responsive variant of the picker.
+   * It is equal to "desktop" when using a desktop picker (like <DesktopDatePicker />).
+   * It is equal to "mobile" when using a mobile picker (like <MobileDatePicker />).
+   * It is equal to "mobile" or "desktop" when using a responsive picker (like <DatePicker />) depending on the `desktopModeMediaQuery` prop.
+   * It is equal to "mobile" or "desktop" when using a static picker (like <StaticDatePicker />) depending on the `displayStaticWrapperAs` prop.
+   * It is always equal to "desktop" if the component you are accessing the context from is not wrapped by a picker.
+   */
+  variant: PickerVariant;
+  /**
+   * The orientation of the picker.
+   * On Time Pickers and Date Time Pickers, it is always equal to "portrait".
+   * On Date Pickers, it is equal to the picker `orientation` prop if defined, otherwise it is based on the current orientation of the user's screen.
+   * It is always equal to "portrait" if the component you are accessing the context from is not wrapped by a picker.
+   */
+  orientation: PickerOrientation;
+  /**
+   * Whether the heavy animations should be disabled.
+   * @default `@media(prefers-reduced-motion: reduce)` || `navigator.userAgent` matches Android <10 or iOS <13
+   */
+  reduceAnimations?: boolean;
+  /**
+   * The ref to attach to the element that triggers the Picker opening.
+   * When using a built-in field component, this property is automatically attached to the right element.
+   */
+  triggerRef: React.RefObject<any>;
+  /**
+   * The status of the element that triggers the Picker opening.
+   * If it is "hidden", the field should not render the UI to open the Picker.
+   * If it is "disabled", the field should render a disabled UI to open the Picker.
+   * If it is "enabled", the field should render an interactive UI to open the Picker.
+   */
+  triggerStatus: 'hidden' | 'disabled' | 'enabled';
+  /**
+   * The format to use when rendering the value in the field.
+   * It is equal to the picker `format` prop if defined.
+   * It is generated based on the available views if not defined.
+   * It is always equal to an empty string if the picker does not have a field (static pickers).
+   * It is always equal to an empty string if the component you are accessing the context from is not wrapped by a picker.
+   */
+  fieldFormat: string;
+  /**
+   * The name to apply to the <input /> element if the picker contains one.
+   * If the picker has a field, it should probably be applied to its input element.
+   * It is equal to the picker `name` prop if defined (the prop does not exist on static pickers).
+   * It is always equal to undefined if the component you are accessing the context from is not wrapped by a picker.
+   */
+  name: string | undefined;
+  /**
+   * The label to render by the field if the picker contains one.
+   * It is equal to the picker `label` prop if defined (the prop does not exist on static pickers).
+   * It is always equal to undefined if the component you are accessing the context from is not wrapped by a picker.
+   */
+  label: React.ReactNode | undefined;
+  /**
+   * The class name to apply to the root element.
+   * If the picker has a field, it should be applied to field root element, otherwise to the layout root element.
+   * It is equal to the picker `className` prop if defined.
+   * It is always equal to undefined if the component you are accessing the context from is not wrapped by a picker.
+   */
+  rootClassName: string | undefined;
+  /**
+   * The MUI style prop to apply to the root element.
+   * If the picker has a field, it should be applied to field root element, otherwise to the layout root element.
+   * It is equal to the picker `sx` prop if defined.
+   * It is always equal to undefined if the component you are accessing the context from is not wrapped by a picker.
+   */
+  rootSx: SxProps<Theme> | undefined;
+  /**
+   * The ref to attach to the root element.
+   * If the picker has a field, it should be attached to field root element, otherwise to the layout root element.
+   * It is equal to the ref passed to the picker component if defined.
+   * It is always equal to undefined if the component you are accessing the context from is not wrapped by a picker.
+   */
+  rootRef: React.ForwardedRef<HTMLDivElement> | undefined;
+}
+export interface PickerActionsContextValue<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError = string | null> extends UsePickerValueActionsContextValue<TValue, TError>, UsePickerViewsActionsContextValue<TView> {}
+export interface PickerPrivateContextValue extends UsePickerValuePrivateContextValue, UsePickerViewsPrivateContextValue {
+  /**
+   * The ownerState of the picker.
+   */
+  ownerState: PickerOwnerState;
+}

package/modern/internals/components/PickerViewRoot/PickerViewRoot.d.ts

@@ -0,0 +1 @@
+export declare const PickerViewRoot: import("@emotion/styled").StyledComponent<import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/modern/internals/components/PickerViewRoot/index.d.ts

@@ -0,0 +1 @@
+export { PickerViewRoot } from "./PickerViewRoot.js";

package/modern/internals/components/PickersArrowSwitcher/PickersArrowSwitcher.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import { PickersArrowSwitcherProps } from "./PickersArrowSwitcher.types.js";
+export declare const PickersArrowSwitcher: React.ForwardRefExoticComponent<PickersArrowSwitcherProps & React.RefAttributes<HTMLDivElement>>;

package/modern/internals/components/PickersArrowSwitcher/PickersArrowSwitcher.types.d.ts

@@ -0,0 +1,74 @@
+import * as React from 'react';
+import { SlotComponentProps } from '@mui/utils';
+import IconButton from '@mui/material/IconButton';
+import SvgIcon from '@mui/material/SvgIcon';
+import { PickersArrowSwitcherClasses } from "./pickersArrowSwitcherClasses.js";
+import { PickerOwnerState } from "../../../models/index.js";
+export interface ExportedPickersArrowSwitcherProps {
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots?: PickersArrowSwitcherSlots;
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps?: PickersArrowSwitcherSlotProps;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<PickersArrowSwitcherClasses>;
+  /**
+   * Format used to display the date.
+   * @default `${adapter.formats.month} ${adapter.formats.year}`
+   */
+  format?: string;
+}
+export interface PickersArrowSwitcherProps extends ExportedPickersArrowSwitcherProps, Omit<React.HTMLProps<HTMLDivElement>, 'ref' | 'as'> {
+  children?: React.ReactNode;
+  isPreviousDisabled: boolean;
+  isPreviousHidden?: boolean;
+  onGoToPrevious: () => void;
+  previousLabel: string;
+  isNextDisabled: boolean;
+  isNextHidden?: boolean;
+  onGoToNext: () => void;
+  nextLabel: string;
+  labelId?: string;
+}
+export interface PickersArrowSwitcherOwnerState extends PickerOwnerState {
+  /**
+   * If `true`, this button should be hidden.
+   */
+  isButtonHidden: boolean;
+}
+export interface PickersArrowSwitcherSlotPropsOverrides {}
+export interface PickersArrowSwitcherSlots {
+  /**
+   * Button allowing to switch to the left view.
+   * @default IconButton
+   */
+  previousIconButton?: React.ElementType;
+  /**
+   * Button allowing to switch to the right view.
+   * @default IconButton
+   */
+  nextIconButton?: React.ElementType;
+  /**
+   * Icon displayed in the left view switch button.
+   * @default ArrowLeft
+   */
+  leftArrowIcon?: React.ElementType;
+  /**
+   * Icon displayed in the right view switch button.
+   * @default ArrowRight
+   */
+  rightArrowIcon?: React.ElementType;
+}
+export interface PickersArrowSwitcherSlotProps {
+  previousIconButton?: SlotComponentProps<typeof IconButton, PickersArrowSwitcherSlotPropsOverrides, PickersArrowSwitcherOwnerState>;
+  nextIconButton?: SlotComponentProps<typeof IconButton, PickersArrowSwitcherSlotPropsOverrides, PickersArrowSwitcherOwnerState>;
+  leftArrowIcon?: SlotComponentProps<typeof SvgIcon, PickersArrowSwitcherSlotPropsOverrides, PickerOwnerState>;
+  rightArrowIcon?: SlotComponentProps<typeof SvgIcon, PickersArrowSwitcherSlotPropsOverrides, PickerOwnerState>;
+}

package/modern/internals/components/PickersArrowSwitcher/index.d.ts

@@ -0,0 +1,4 @@
+export { PickersArrowSwitcher } from "./PickersArrowSwitcher.js";
+export type { PickersArrowSwitcherSlots, PickersArrowSwitcherSlotProps, ExportedPickersArrowSwitcherProps } from './PickersArrowSwitcher.types';
+export { pickersArrowSwitcherClasses, getPickersArrowSwitcherUtilityClass } from "./pickersArrowSwitcherClasses.js";
+export type { PickersArrowSwitcherClassKey, PickersArrowSwitcherClasses } from './pickersArrowSwitcherClasses';

package/modern/internals/components/PickersArrowSwitcher/pickersArrowSwitcherClasses.d.ts

@@ -0,0 +1,19 @@
+export interface PickersArrowSwitcherClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the spacer element. */
+  spacer: string;
+  /** Styles applied to the button element. */
+  button: string;
+  /** Styles applied to the previous icon button element. */
+  previousIconButton: string;
+  /** Styles applied to the next icon button element. */
+  nextIconButton: string;
+  /** Styles applied to the left icon element. */
+  leftArrowIcon: string;
+  /** Styles applied to the right icon element. */
+  rightArrowIcon: string;
+}
+export type PickersArrowSwitcherClassKey = keyof PickersArrowSwitcherClasses;
+export declare function getPickersArrowSwitcherUtilityClass(slot: string): string;
+export declare const pickersArrowSwitcherClasses: Record<"button" | "root" | "spacer" | "previousIconButton" | "nextIconButton" | "leftArrowIcon" | "rightArrowIcon", string>;

package/modern/internals/components/PickersModalDialog.d.ts

@@ -0,0 +1,48 @@
+import * as React from 'react';
+import { DialogProps as MuiDialogProps } from '@mui/material/Dialog';
+import { PaperProps as MuiPaperProps } from '@mui/material/Paper';
+import { TransitionProps as MuiTransitionProps } from '@mui/material/transitions';
+export interface PickersModalDialogSlots {
+  /**
+   * Custom component for the dialog inside which the views are rendered on mobile.
+   * @default PickersModalDialogRoot
+   */
+  dialog?: React.ElementType<MuiDialogProps>;
+  /**
+   * Custom component for the paper rendered inside the mobile picker's Dialog.
+   * @default Paper from '@mui/material'.
+   */
+  mobilePaper?: React.JSXElementConstructor<MuiPaperProps>;
+  /**
+   * Custom component for the mobile dialog [Transition](https://mui.com/material-ui/transitions/).
+   * @default Fade from '@mui/material'.
+   */
+  mobileTransition?: React.JSXElementConstructor<MuiTransitionProps>;
+}
+export interface PickersModalDialogSlotProps {
+  /**
+   * Props passed down to the [`Dialog`](https://mui.com/material-ui/api/dialog/) component.
+   */
+  dialog?: Partial<MuiDialogProps>;
+  /**
+   * Props passed down to the mobile [Paper](https://mui.com/material-ui/api/paper/) component.
+   */
+  mobilePaper?: Partial<MuiPaperProps>;
+  /**
+   * Props passed down to the mobile [Transition](https://mui.com/material-ui/transitions/) component.
+   */
+  mobileTransition?: Partial<MuiTransitionProps>;
+}
+export interface PickersModalDialogProps {
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots?: PickersModalDialogSlots;
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps?: PickersModalDialogSlotProps;
+}
+export declare function PickersModalDialog(props: React.PropsWithChildren<PickersModalDialogProps>): React.JSX.Element;

package/modern/internals/components/PickersToolbar.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { BaseToolbarProps } from "../models/props/toolbar.js";
+import { PickersToolbarClasses } from "./pickersToolbarClasses.js";
+export interface PickersToolbarProps extends Pick<BaseToolbarProps, 'hidden' | 'titleId'> {
+  className?: string;
+  landscapeDirection?: 'row' | 'column';
+  toolbarTitle: React.ReactNode;
+  classes?: Partial<PickersToolbarClasses>;
+}
+type PickersToolbarComponent = ((props: React.PropsWithChildren<PickersToolbarProps> & React.RefAttributes<HTMLDivElement>) => React.JSX.Element) & {
+  propTypes?: any;
+};
+export declare const PickersToolbar: PickersToolbarComponent;
+export {};

package/modern/internals/components/PickersToolbarButton.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { ButtonProps } from '@mui/material/Button';
+import { TypographyProps } from '@mui/material/Typography';
+import { ExtendMui } from "../models/helpers.js";
+import { PickersToolbarButtonClasses } from "./pickersToolbarButtonClasses.js";
+export interface PickersToolbarButtonProps extends ExtendMui<ButtonProps, 'value' | 'variant'> {
+  align?: TypographyProps['align'];
+  selected: boolean;
+  typographyClassName?: string;
+  value: React.ReactNode;
+  variant: TypographyProps['variant'];
+  classes?: Partial<PickersToolbarButtonClasses>;
+  width?: number;
+}
+export declare const PickersToolbarButton: React.ForwardRefExoticComponent<Omit<PickersToolbarButtonProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;

package/modern/internals/components/PickersToolbarText.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { TypographyProps } from '@mui/material/Typography';
+import { PickersToolbarTextClasses } from "./pickersToolbarTextClasses.js";
+export interface ExportedPickersToolbarTextProps extends Omit<TypographyProps, 'classes' | 'variant' | 'align'> {
+  classes?: Partial<PickersToolbarTextClasses>;
+}
+export interface PickersToolbarTextProps extends Omit<TypographyProps, 'classes'>, Pick<ExportedPickersToolbarTextProps, 'classes'> {
+  selected?: boolean;
+  value: React.ReactNode;
+}
+export declare const PickersToolbarText: React.ForwardRefExoticComponent<Omit<PickersToolbarTextProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;

package/modern/internals/components/pickersToolbarButtonClasses.d.ts

@@ -0,0 +1,7 @@
+export interface PickersToolbarButtonClasses {
+  /** Styles applied to the root element. */
+  root: string;
+}
+export type PickersToolbarButtonClassKey = keyof PickersToolbarButtonClasses;
+export declare function getPickersToolbarButtonUtilityClass(slot: string): string;
+export declare const pickersToolbarButtonClasses: Record<"root", string>;

package/modern/internals/components/pickersToolbarClasses.d.ts

@@ -0,0 +1,9 @@
+export interface PickersToolbarClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the content element. */
+  content: string;
+}
+export type PickersToolbarClassKey = keyof PickersToolbarClasses;
+export declare function getPickersToolbarUtilityClass(slot: string): string;
+export declare const pickersToolbarClasses: Record<"content" | "root", string>;

package/modern/internals/components/pickersToolbarTextClasses.d.ts

@@ -0,0 +1,9 @@
+export interface PickersToolbarTextClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to a selected root element. */
+  selected: string;
+}
+export type PickersToolbarTextClassKey = keyof PickersToolbarTextClasses;
+export declare function getPickersToolbarTextUtilityClass(slot: string): string;
+export declare const pickersToolbarTextClasses: Record<"selected" | "root", string>;

package/modern/internals/constants/dimensions.d.ts

@@ -0,0 +1,7 @@
+export declare const DAY_SIZE = 36;
+export declare const DAY_MARGIN = 2;
+export declare const DIALOG_WIDTH = 320;
+export declare const MAX_CALENDAR_HEIGHT = 280;
+export declare const VIEW_HEIGHT = 336;
+export declare const DIGITAL_CLOCK_VIEW_HEIGHT = 232;
+export declare const MULTI_SECTION_CLOCK_SECTION_WIDTH = 48;

package/modern/internals/demo/DemoContainer.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import { SxProps, Theme } from '@mui/material/styles';
+interface DemoGridProps {
+  children: React.ReactNode;
+  components: string[];
+  sx?: SxProps<Theme>;
+}
+interface DemoItemProps {
+  label?: React.ReactNode;
+  component?: string;
+  children: React.ReactNode;
+  sx?: SxProps<Theme>;
+}
+/**
+ * WARNING: This is an internal component used in documentation to achieve a desired layout.
+ * Please do not use it in your application.
+ */
+export declare function DemoItem(props: DemoItemProps): React.JSX.Element;
+export declare namespace DemoItem {
+  var displayName: string;
+}
+/**
+ * WARNING: This is an internal component used in documentation to achieve a desired layout.
+ * Please do not use it in your application.
+ */
+export declare function DemoContainer(props: DemoGridProps): React.JSX.Element;
+export {};

package/modern/internals/demo/index.d.ts

@@ -0,0 +1 @@
+export { DemoContainer, DemoItem } from "./DemoContainer.js";

package/modern/internals/hooks/date-helpers-hooks.d.ts

@@ -0,0 +1,24 @@
+import { PickerOnChangeFn } from "./useViews.js";
+import { PickerSelectionState } from "./usePicker/index.js";
+import { PickersTimezone, PickerValidDate } from "../../models/index.js";
+export interface MonthValidationOptions {
+  disablePast?: boolean;
+  disableFuture?: boolean;
+  minDate: PickerValidDate;
+  maxDate: PickerValidDate;
+  timezone: PickersTimezone;
+}
+export declare function useNextMonthDisabled(month: PickerValidDate, {
+  disableFuture,
+  maxDate,
+  timezone
+}: Pick<MonthValidationOptions, 'disableFuture' | 'maxDate' | 'timezone'>): boolean;
+export declare function usePreviousMonthDisabled(month: PickerValidDate, {
+  disablePast,
+  minDate,
+  timezone
+}: Pick<MonthValidationOptions, 'disablePast' | 'minDate' | 'timezone'>): boolean;
+export declare function useMeridiemMode(date: PickerValidDate | null, ampm: boolean | undefined, onChange: PickerOnChangeFn, selectionState?: PickerSelectionState): {
+  meridiemMode: import("../utils/time-utils").Meridiem | null;
+  handleMeridiemChange: (mode: "am" | "pm") => void;
+};