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

package/modern/internals/models/dateRange.d.ts

@@ -0,0 +1,16 @@
+import { PickerValidDate } from '@mui/x-date-pickers/models';
+/**
+ * Props used to validate a day value in range pickers.
+ */
+export interface DayRangeValidationProps {
+  /**
+   * Disable specific date.
+   *
+   * Warning: This function can be called multiple times (for example when rendering date calendar, checking if focus can be moved to a certain date, etc.). Expensive computations can impact performance.
+   *
+   * @param {PickerValidDate} day The date to test.
+   * @param {string} position The date to test, 'start' or 'end'.
+   * @returns {boolean} Returns `true` if the date should be disabled.
+   */
+  shouldDisableDate?: (day: PickerValidDate, position: 'start' | 'end') => boolean;
+}

package/modern/internals/models/dateTimeRange.d.ts

@@ -0,0 +1,3 @@
+import { DateOrTimeViewWithMeridiem } from '@mui/x-date-pickers/internals';
+export type DateTimeRangePickerView = Exclude<DateOrTimeViewWithMeridiem, 'month' | 'year'>;
+export type DateTimeRangePickerViewExternal = Exclude<DateTimeRangePickerView, 'meridiem'>;

package/modern/internals/models/fields.d.ts

@@ -0,0 +1,22 @@
+import { SlotComponentProps } from '@mui/utils';
+import { PickerRangeValue, UseFieldInternalProps } from '@mui/x-date-pickers/internals';
+import { FieldOwnerState } from '@mui/x-date-pickers/models';
+import { PickersTextField } from '@mui/x-date-pickers/PickersTextField';
+import type { MultiInputFieldRefs, MultiInputFieldSlotRootProps, RangePosition } from '../../models';
+/**
+ * Props the multi input field can receive when used inside a picker.
+ * Only contains what the MUI components are passing to the field, not what users can pass using the `props.slotProps.field`.
+ */
+export interface BaseMultiInputFieldProps extends Pick<UseFieldInternalProps<PickerRangeValue, boolean, unknown>, 'readOnly' | 'autoFocus'>, MultiInputFieldRefs {
+  slots?: {
+    root?: React.ElementType;
+    separator?: React.ElementType;
+    textField?: React.ElementType;
+  };
+  slotProps?: {
+    root?: SlotComponentProps<React.ElementType<MultiInputFieldSlotRootProps>, {}, FieldOwnerState>;
+    textField?: SlotComponentProps<typeof PickersTextField, {}, FieldOwnerState & {
+      position?: RangePosition;
+    }>;
+  };
+}

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

@@ -0,0 +1,3 @@
+export * from "./dateRange.js";
+export * from "./dateTimeRange.js";
+export * from "./rangePickerProps.js";

package/modern/internals/models/managers.d.ts

@@ -0,0 +1,3 @@
+import { PickerRangeValue } from '@mui/x-date-pickers/internals';
+import { PickerManager } from '@mui/x-date-pickers/models';
+export type PickerAnyRangeManager = PickerManager<PickerRangeValue, any, any, any, any>;

package/modern/internals/models/rangePickerProps.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+/**
+ * Props common to all range non-static pickers.
+ * These props are handled by the headless wrappers.
+ */
+export interface BaseRangeNonStaticPickerProps {
+  /**
+   * The label content.
+   * Ignored if the field has several inputs.
+   */
+  label?: React.ReactNode;
+  /**
+   * Pass a ref to the `input` element.
+   * Ignored if the field has several inputs.
+   */
+  inputRef?: React.Ref<HTMLInputElement>;
+  /**
+   * Name attribute used by the `input` element in the Field.
+   * Ignored if the field has several inputs.
+   */
+  name?: string;
+}

package/modern/internals/utils/createMultiInputRangeField/createMultiInputRangeField.d.ts

@@ -0,0 +1,7 @@
+import { CreateMultiInputRangeFieldParameters, CreateMultiInputRangeFieldReturnValue } from "./createMultiInputRangeField.types.js";
+import { PickerAnyRangeManager } from "../../models/managers.js";
+export declare function createMultiInputRangeField<TManager extends PickerAnyRangeManager>({
+  useManager,
+  name,
+  getUtilityClass
+}: CreateMultiInputRangeFieldParameters<TManager>): CreateMultiInputRangeFieldReturnValue<TManager>;

package/modern/internals/utils/createMultiInputRangeField/createMultiInputRangeField.js

@@ -33,7 +33,7 @@ export function createMultiInputRangeField({
     ref: ref,
     spacing: 2,
     direction: "row",
-    alignItems: "center"
+    alignItems: "baseline"
   }, props))), {
     name,
     slot: 'Root',

package/modern/internals/utils/createMultiInputRangeField/createMultiInputRangeField.types.d.ts

@@ -0,0 +1,72 @@
+import type { TypographyProps } from '@mui/material/Typography';
+import type { StackProps } from '@mui/material/Stack';
+import type { TextFieldProps } from '@mui/material/TextField';
+import { SlotComponentPropsFromProps } from '@mui/x-internals/types';
+import { PickersTextFieldProps } from '@mui/x-date-pickers/PickersTextField';
+import { FieldOwnerState } from '@mui/x-date-pickers/models';
+import { PickerManagerEnableAccessibleFieldDOMStructure, PickerManagerFieldInternalProps } from '@mui/x-date-pickers/internals';
+import { FieldType, MultiInputFieldRefs, RangeFieldSeparatorProps, RangePosition } from "../../../models/index.js";
+import { PickerAnyRangeManager } from "../../models/managers.js";
+export type MultiInputRangeFieldProps<TManager extends PickerAnyRangeManager> = MultiInputFieldRefs & RangeFieldSeparatorProps & Omit<PickerManagerFieldInternalProps<TManager>, 'unstableFieldRef' | 'clearable' | 'onClear'> & Omit<StackProps, 'position' | keyof PickerManagerFieldInternalProps<TManager>> & {
+  /**
+   * If `true`, the field is focused during the first mount.
+   * @default false
+   */
+  autoFocus?: boolean;
+  className?: string;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<MultiInputRangeFieldClasses>;
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots?: MultiInputRangeFieldSlots;
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps?: MultiInputRangeFieldSlotProps;
+};
+export interface MultiInputRangeFieldSlots {
+  /**
+   * Element rendered at the root.
+   * @default MultiInputRangeFieldRoot
+   */
+  root?: React.ElementType;
+  /**
+   * Form control with an input to render a date.
+   * It is rendered twice: once for the start date and once for the end date.
+   * @default <PickersTextField />, or <TextField /> from '@mui/material' if `enableAccessibleFieldDOMStructure` is `false`.
+   */
+  textField?: React.ElementType;
+  /**
+   * Element rendered between the two inputs.
+   * @default MultiInputRangeFieldSeparator
+   */
+  separator?: React.ElementType;
+}
+export interface MultiInputRangeFieldSlotProps {
+  root?: SlotComponentPropsFromProps<StackProps, {}, FieldOwnerState>;
+  textField?: SlotComponentPropsFromProps<PickersTextFieldProps | TextFieldProps, {}, FieldOwnerState & {
+    position: RangePosition;
+  }>;
+  separator?: SlotComponentPropsFromProps<TypographyProps, {}, FieldOwnerState>;
+}
+export interface MultiInputRangeFieldClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the separator element. */
+  separator: string;
+}
+export interface CreateMultiInputRangeFieldParameters<TManager extends PickerAnyRangeManager> {
+  name: string;
+  getUtilityClass: (slot: string) => string;
+  useManager: (params: RangeFieldSeparatorProps & {
+    enableAccessibleFieldDOMStructure: PickerManagerEnableAccessibleFieldDOMStructure<TManager>;
+  }) => TManager;
+}
+export type CreateMultiInputRangeFieldReturnValue<TManager extends PickerAnyRangeManager> = ((props: MultiInputRangeFieldProps<TManager> & React.RefAttributes<HTMLDivElement>) => React.JSX.Element) & {
+  fieldType?: FieldType;
+};

package/modern/internals/utils/createMultiInputRangeField/index.d.ts

@@ -0,0 +1,3 @@
+export { createMultiInputRangeField } from "./createMultiInputRangeField.js";
+export type { MultiInputRangeFieldProps, MultiInputRangeFieldSlots, MultiInputRangeFieldSlotProps, MultiInputRangeFieldClasses } from './createMultiInputRangeField.types';
+export { useMultiInputRangeField as unstable_useMultiInputRangeField } from "../../../hooks/useMultiInputRangeField/useMultiInputRangeField.js";

package/modern/internals/utils/date-fields-utils.d.ts

@@ -0,0 +1,20 @@
+import { FieldRangeSection } from '@mui/x-date-pickers/internals';
+export declare const splitDateRangeSections: (sections: FieldRangeSection[]) => {
+  startDate: FieldRangeSection[];
+  endDate: FieldRangeSection[];
+};
+export declare const removeLastSeparator: (dateSections: FieldRangeSection[]) => (FieldRangeSection | {
+  separator: null;
+  dateName: import("@mui/x-date-pickers/internals").RangePosition;
+  value: string;
+  format: string;
+  maxLength: number | null;
+  placeholder: string;
+  type: import("@mui/x-date-pickers").FieldSectionType;
+  contentType: import("@mui/x-date-pickers").FieldSectionContentType;
+  hasLeadingZerosInFormat: boolean;
+  hasLeadingZerosInInput: boolean;
+  modified: boolean;
+  startSeparator: string;
+  endSeparator: string;
+})[];

package/modern/internals/utils/date-range-manager.d.ts

@@ -0,0 +1,32 @@
+import { MuiPickersAdapter, PickerValidDate } from '@mui/x-date-pickers/models';
+import { PickerRangeValue } from '@mui/x-date-pickers/internals';
+import { RangePosition } from "../../models/index.js";
+interface CalculateRangeChangeOptions {
+  utils: MuiPickersAdapter;
+  range: PickerRangeValue;
+  newDate: PickerValidDate | null;
+  rangePosition: RangePosition;
+  /**
+   * Should allow flipping range `start` and `end` dates if the `newDate` would result in a new range creation.
+   *
+   * It is used to allow dragging range `start` date past `end` date essentially becoming the new `end` date and vice versa.
+   */
+  allowRangeFlip?: boolean;
+  shouldMergeDateAndTime?: boolean;
+  referenceDate?: PickerValidDate;
+}
+interface CalculateRangeChangeResponse {
+  nextSelection: RangePosition;
+  newRange: PickerRangeValue;
+}
+export declare function calculateRangeChange({
+  utils,
+  range,
+  newDate: selectedDate,
+  rangePosition,
+  allowRangeFlip,
+  shouldMergeDateAndTime,
+  referenceDate
+}: CalculateRangeChangeOptions): CalculateRangeChangeResponse;
+export declare function calculateRangePreview(options: CalculateRangeChangeOptions): PickerRangeValue;
+export {};

package/modern/internals/utils/date-utils.d.ts

@@ -0,0 +1,6 @@
+import { MuiPickersAdapter, PickerValidDate } from '@mui/x-date-pickers/models';
+import { PickerRangeValue } from '@mui/x-date-pickers/internals';
+export declare const isRangeValid: (utils: MuiPickersAdapter, range: PickerRangeValue | null) => range is [PickerValidDate, PickerValidDate];
+export declare const isWithinRange: (utils: MuiPickersAdapter, day: PickerValidDate, range: PickerRangeValue | null) => boolean;
+export declare const isStartOfRange: (utils: MuiPickersAdapter, day: PickerValidDate, range: PickerRangeValue | null) => boolean;
+export declare const isEndOfRange: (utils: MuiPickersAdapter, day: PickerValidDate, range: PickerRangeValue | null) => boolean;

package/modern/internals/utils/releaseInfo.d.ts

@@ -0,0 +1 @@
+export declare const getReleaseInfo: () => any;

package/modern/internals/utils/releaseInfo.js

@@ -1,6 +1,6 @@
 import { ponyfillGlobal } from '@mui/utils';
 export const getReleaseInfo = () => {
-  const releaseInfo = "MTczODI5OTYwMDAwMA==";
+  const releaseInfo = "MTczOTc0NjgwMDAwMA==";
   if (process.env.NODE_ENV !== 'production') {
     // A simple hack to set the value in the test environment (has no build step).
     // eslint-disable-next-line no-useless-concat

package/modern/internals/utils/valueManagers.d.ts

@@ -0,0 +1,10 @@
+import { PickerValueManager, FieldValueManager, PickerRangeValue } from '@mui/x-date-pickers/internals';
+import type { DateRangeValidationError, DateTimeRangeValidationError, TimeRangeValidationError } from '../../models';
+type RangePickerValueManager<TError extends DateRangeValidationError | TimeRangeValidationError | DateTimeRangeValidationError = any> = PickerValueManager<PickerRangeValue, TError>;
+export declare const rangeValueManager: RangePickerValueManager;
+export declare const getRangeFieldValueManager: ({
+  dateSeparator
+}: {
+  dateSeparator: string | undefined;
+}) => FieldValueManager<PickerRangeValue>;
+export {};

package/modern/locales/index.d.ts

@@ -0,0 +1 @@
+export * from '@mui/x-date-pickers/locales';

package/modern/managers/index.d.ts

@@ -0,0 +1,6 @@
+export { useDateRangeManager } from "./useDateRangeManager.js";
+export type { UseDateRangeManagerReturnValue, UseDateRangeManagerParameters, DateRangeManagerFieldInternalProps } from './useDateRangeManager';
+export { useTimeRangeManager } from "./useTimeRangeManager.js";
+export type { UseTimeRangeManagerReturnValue, UseTimeRangeManagerParameters, TimeRangeManagerFieldInternalProps } from './useTimeRangeManager';
+export { useDateTimeRangeManager } from "./useDateTimeRangeManager.js";
+export type { UseDateTimeRangeManagerReturnValue, UseDateTimeRangeManagerParameters, DateTimeRangeManagerFieldInternalProps } from './useDateTimeRangeManager';

package/modern/managers/useDateRangeManager.d.ts

@@ -0,0 +1,13 @@
+import type { MakeOptional } from '@mui/x-internals/types';
+import { PickerManager } from '@mui/x-date-pickers/models';
+import { PickerRangeValue, UseFieldInternalProps } from '@mui/x-date-pickers/internals';
+import { DateRangeValidationError, RangeFieldSeparatorProps } from "../models/index.js";
+import { ExportedValidateDateRangeProps, ValidateDateRangeProps } from "../validation/validateDateRange.js";
+export declare function useDateRangeManager<TEnableAccessibleFieldDOMStructure extends boolean = true>(parameters?: UseDateRangeManagerParameters<TEnableAccessibleFieldDOMStructure>): UseDateRangeManagerReturnValue<TEnableAccessibleFieldDOMStructure>;
+export interface UseDateRangeManagerParameters<TEnableAccessibleFieldDOMStructure extends boolean> extends RangeFieldSeparatorProps {
+  enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
+}
+export type UseDateRangeManagerReturnValue<TEnableAccessibleFieldDOMStructure extends boolean> = PickerManager<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateRangeValidationError, DateRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>, DateRangeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure>>;
+export interface DateRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateRangeValidationError>, 'format'>, RangeFieldSeparatorProps, ExportedValidateDateRangeProps {}
+interface DateRangeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure extends boolean> extends UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateRangeValidationError>, ValidateDateRangeProps, RangeFieldSeparatorProps {}
+export {};

package/modern/managers/useDateTimeRangeManager.d.ts

@@ -0,0 +1,13 @@
+import type { MakeOptional } from '@mui/x-internals/types';
+import { PickerManager } from '@mui/x-date-pickers/models';
+import { AmPmProps, PickerRangeValue, UseFieldInternalProps } from '@mui/x-date-pickers/internals';
+import { DateTimeRangeValidationError, RangeFieldSeparatorProps } from "../models/index.js";
+import { ExportedValidateDateTimeRangeProps, ValidateDateTimeRangeProps } from "../validation/validateDateTimeRange.js";
+export declare function useDateTimeRangeManager<TEnableAccessibleFieldDOMStructure extends boolean = true>(parameters?: UseDateTimeRangeManagerParameters<TEnableAccessibleFieldDOMStructure>): UseDateTimeRangeManagerReturnValue<TEnableAccessibleFieldDOMStructure>;
+export interface UseDateTimeRangeManagerParameters<TEnableAccessibleFieldDOMStructure extends boolean> extends RangeFieldSeparatorProps {
+  enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
+}
+export type UseDateTimeRangeManagerReturnValue<TEnableAccessibleFieldDOMStructure extends boolean> = PickerManager<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateTimeRangeValidationError, DateTimeRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>, DateTimeRangeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure>>;
+export interface DateTimeRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateTimeRangeValidationError>, 'format'>, ExportedValidateDateTimeRangeProps, AmPmProps, RangeFieldSeparatorProps {}
+interface DateTimeRangeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure extends boolean> extends UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, DateTimeRangeValidationError>, ValidateDateTimeRangeProps, RangeFieldSeparatorProps {}
+export {};

package/modern/managers/useTimeRangeManager.d.ts

@@ -0,0 +1,13 @@
+import type { MakeOptional } from '@mui/x-internals/types';
+import { PickerManager } from '@mui/x-date-pickers/models';
+import { AmPmProps, PickerRangeValue, UseFieldInternalProps } from '@mui/x-date-pickers/internals';
+import { TimeRangeValidationError, RangeFieldSeparatorProps } from "../models/index.js";
+import { ExportedValidateTimeRangeProps, ValidateTimeRangeProps } from "../validation/validateTimeRange.js";
+export declare function useTimeRangeManager<TEnableAccessibleFieldDOMStructure extends boolean = true>(parameters?: UseTimeRangeManagerParameters<TEnableAccessibleFieldDOMStructure>): UseTimeRangeManagerReturnValue<TEnableAccessibleFieldDOMStructure>;
+export interface UseTimeRangeManagerParameters<TEnableAccessibleFieldDOMStructure extends boolean> extends RangeFieldSeparatorProps {
+  enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
+}
+export type UseTimeRangeManagerReturnValue<TEnableAccessibleFieldDOMStructure extends boolean> = PickerManager<PickerRangeValue, TEnableAccessibleFieldDOMStructure, TimeRangeValidationError, TimeRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>, TimeRangeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure>>;
+export interface TimeRangeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, TimeRangeValidationError>, 'format'>, ExportedValidateTimeRangeProps, AmPmProps, RangeFieldSeparatorProps {}
+interface TimeRangeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure extends boolean> extends UseFieldInternalProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure, TimeRangeValidationError>, ValidateTimeRangeProps {}
+export {};

package/modern/models/fields.d.ts

@@ -0,0 +1,47 @@
+import * as React from 'react';
+import { UseFieldResponse, FormProps, PickerValue, PickerRangeValue } from '@mui/x-date-pickers/internals';
+import { FieldRef, PickerFieldSlotProps } from '@mui/x-date-pickers/models';
+export type { FieldRangeSection } from '@mui/x-date-pickers/internals';
+export type FieldType = 'single-input' | 'multi-input';
+/**
+ * Props the `textField` slot of the multi input field can receive when used inside a picker.
+ */
+export interface MultiInputFieldSlotTextFieldProps extends FormProps {
+  label?: React.ReactNode;
+  id?: string;
+  onKeyDown?: React.KeyboardEventHandler;
+  onClick?: React.MouseEventHandler;
+  onFocus?: React.FocusEventHandler;
+  focused?: boolean;
+  InputProps?: {
+    ref?: React.Ref<any>;
+    endAdornment?: React.ReactNode;
+    startAdornment?: React.ReactNode;
+  };
+}
+/**
+ * Props the `root` slot of the multi input field can receive when used inside a picker.
+ */
+export interface MultiInputFieldSlotRootProps {
+  onBlur?: React.FocusEventHandler;
+}
+export interface MultiInputFieldRefs {
+  unstableStartFieldRef?: React.Ref<FieldRef<PickerValue>>;
+  unstableEndFieldRef?: React.Ref<FieldRef<PickerValue>>;
+}
+export interface RangeFieldSeparatorProps {
+  /**
+   * String displayed between the start and the end dates.
+   * @default "–"
+   */
+  dateSeparator?: string;
+}
+/**
+ * Props the `slotProps.field` of a range picker component can receive.
+ */
+export type PickerRangeFieldSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> = PickerFieldSlotProps<PickerRangeValue, TEnableAccessibleFieldDOMStructure> & RangeFieldSeparatorProps;
+/**
+ * Props the text field receives when used with a multi input picker.
+ * Only contains what the MUI components are passing to the text field, not what users can pass using the `props.slotProps.textField`.
+ */
+export type BaseMultiInputPickersTextFieldProps<TEnableAccessibleFieldDOMStructure extends boolean> = Omit<UseFieldResponse<TEnableAccessibleFieldDOMStructure, MultiInputFieldSlotTextFieldProps>, 'slots' | 'slotProps' | 'clearable' | 'onClear' | 'openPickerButtonPosition' | 'clearButtonPosition' | 'openPickerAriaLabel'>;

package/modern/models/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./fields.js";
+export * from "./range.js";
+export * from "./validation.js";
+export type { RangePosition } from '@mui/x-date-pickers/internals';

package/modern/models/range.d.ts

@@ -0,0 +1,2 @@
+import { PickerValidDate } from '@mui/x-date-pickers/models';
+export type DateRange<TDate extends PickerValidDate> = [TDate | null, TDate | null];

package/modern/models/validation.d.ts

@@ -0,0 +1,6 @@
+import { DateTimeValidationError, DateValidationError, TimeValidationError } from '@mui/x-date-pickers/models';
+type RangeValidation<ItemError extends string | null> = [ItemError | 'invalidRange', ItemError | 'invalidRange'];
+export type DateRangeValidationError = RangeValidation<DateValidationError>;
+export type TimeRangeValidationError = RangeValidation<TimeValidationError>;
+export type DateTimeRangeValidationError = RangeValidation<DateTimeValidationError>;
+export {};

package/modern/package.json

@@ -0,0 +1 @@
+{"type":"module","sideEffects":false}

package/modern/themeAugmentation/components.d.ts

@@ -0,0 +1,79 @@
+import { ComponentsProps, ComponentsOverrides } from '@mui/material/styles';
+export interface PickersProComponents<Theme = unknown> {
+  MuiDateRangeCalendar?: {
+    defaultProps?: ComponentsProps['MuiDateRangeCalendar'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiDateRangeCalendar'];
+  };
+  MuiDateRangePickerDay?: {
+    defaultProps?: ComponentsProps['MuiDateRangePickerDay'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiDateRangePickerDay'];
+  };
+  MuiDateTimeRangePickerTabs?: {
+    defaultProps?: ComponentsProps['MuiDateTimeRangePickerTabs'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiDateTimeRangePickerTabs'];
+  };
+  MuiDateRangePickerToolbar?: {
+    defaultProps?: ComponentsProps['MuiDateRangePickerToolbar'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiDateRangePickerToolbar'];
+  };
+  MuiDateTimeRangePickerToolbar?: {
+    defaultProps?: ComponentsProps['MuiDateTimeRangePickerToolbar'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiDateTimeRangePickerToolbar'];
+  };
+  MuiPickersRangeCalendarHeader?: {
+    defaultProps?: ComponentsProps['MuiPickersRangeCalendarHeader'];
+  };
+
+  // Multi input range fields
+  MuiMultiInputDateRangeField?: {
+    defaultProps?: ComponentsProps['MuiMultiInputDateRangeField'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiMultiInputDateRangeField'];
+  };
+  MuiMultiInputDateTimeRangeField?: {
+    defaultProps?: ComponentsProps['MuiMultiInputDateTimeRangeField'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiMultiInputDateTimeRangeField'];
+  };
+  MuiMultiInputTimeRangeField?: {
+    defaultProps?: ComponentsProps['MuiMultiInputTimeRangeField'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiMultiInputTimeRangeField'];
+  };
+
+  // Single input range fields
+  MuiSingleInputDateRangeField?: {
+    defaultProps?: ComponentsProps['MuiSingleInputDateRangeField'];
+  };
+  MuiSingleInputDateTimeRangeField?: {
+    defaultProps?: ComponentsProps['MuiSingleInputDateTimeRangeField'];
+  };
+  MuiSingleInputTimeRangeField?: {
+    defaultProps?: ComponentsProps['MuiSingleInputTimeRangeField'];
+  };
+
+  // Date Range Pickers
+  MuiDateRangePicker?: {
+    defaultProps?: ComponentsProps['MuiDateRangePicker'];
+  };
+  MuiDesktopDateRangePicker?: {
+    defaultProps?: ComponentsProps['MuiDesktopDateRangePicker'];
+  };
+  MuiMobileDateRangePicker?: {
+    defaultProps?: ComponentsProps['MuiMobileDateRangePicker'];
+  };
+  MuiStaticDateRangePicker?: {
+    defaultProps?: ComponentsProps['MuiStaticDateRangePicker'];
+  };
+
+  // Date Time Range Pickers
+  MuiDateTimeRangePicker?: {
+    defaultProps?: ComponentsProps['MuiDateTimeRangePicker'];
+  };
+  MuiDesktopDateTimeRangePicker?: {
+    defaultProps?: ComponentsProps['MuiDesktopDateTimeRangePicker'];
+  };
+  MuiMobileDateTimeRangePicker?: {
+    defaultProps?: ComponentsProps['MuiMobileDateTimeRangePicker'];
+  };
+}
+declare module '@mui/material/styles' {
+  interface Components<Theme = unknown> extends PickersProComponents<Theme> {}
+}

package/modern/themeAugmentation/index.d.ts

@@ -0,0 +1,4 @@
+export * from '@mui/x-date-pickers/themeAugmentation';
+export type * from './overrides';
+export type * from './props';
+export type * from './components';

package/modern/themeAugmentation/overrides.d.ts

@@ -0,0 +1,27 @@
+import { DateRangePickerDayClassKey } from "../DateRangePickerDay/index.js";
+import { DateRangeCalendarClassKey } from "../DateRangeCalendar/index.js";
+import { DateRangePickerToolbarClassKey } from "../DateRangePicker/index.js";
+import { DateTimeRangePickerTabsClassKey, DateTimeRangePickerToolbarClassKey } from "../DateTimeRangePicker/index.js";
+import { MultiInputDateRangeFieldClassKey } from "../MultiInputDateRangeField/index.js";
+import { MultiInputDateTimeRangeFieldClassKey } from "../MultiInputDateTimeRangeField/index.js";
+import { MultiInputTimeRangeFieldClassKey } from "../MultiInputTimeRangeField/index.js";
+
+// prettier-ignore
+export interface PickersProComponentNameToClassKey {
+  MuiDateRangeCalendar: DateRangeCalendarClassKey;
+  MuiDateRangePickerDay: DateRangePickerDayClassKey;
+  MuiDateRangePickerToolbar: DateRangePickerToolbarClassKey;
+  MuiDateTimeRangePickerTabs: DateTimeRangePickerTabsClassKey;
+  MuiDateTimeRangePickerToolbar: DateTimeRangePickerToolbarClassKey;
+
+  // Multi input range fields
+  MuiMultiInputDateRangeField: MultiInputDateRangeFieldClassKey;
+  MuiMultiInputDateTimeRangeField: MultiInputDateTimeRangeFieldClassKey;
+  MuiMultiInputTimeRangeField: MultiInputTimeRangeFieldClassKey;
+}
+declare module '@mui/material/styles' {
+  interface ComponentNameToClassKey extends PickersProComponentNameToClassKey {}
+}
+
+// disable automatic export
+export {};

package/modern/themeAugmentation/props.d.ts

@@ -0,0 +1,54 @@
+import { DateRangePickerDayProps } from "../DateRangePickerDay/index.js";
+import { DateRangeCalendarProps } from "../DateRangeCalendar/index.js";
+import { DateRangePickerProps } from "../DateRangePicker/index.js";
+import { ExportedDateRangePickerToolbarProps } from "../DateRangePicker/DateRangePickerToolbar.js";
+import { DesktopDateRangePickerProps } from "../DesktopDateRangePicker/index.js";
+import { MobileDateRangePickerProps } from "../MobileDateRangePicker/index.js";
+import { StaticDateRangePickerProps } from "../StaticDateRangePicker/index.js";
+import { MultiInputDateRangeFieldProps } from "../MultiInputDateRangeField/index.js";
+import { MultiInputDateTimeRangeFieldProps } from "../MultiInputDateTimeRangeField/index.js";
+import { MultiInputTimeRangeFieldProps } from "../MultiInputTimeRangeField/index.js";
+import { SingleInputDateRangeFieldProps } from "../SingleInputDateRangeField/index.js";
+import { SingleInputDateTimeRangeFieldProps } from "../SingleInputDateTimeRangeField/index.js";
+import { SingleInputTimeRangeFieldProps } from "../SingleInputTimeRangeField/index.js";
+import { DateTimeRangePickerProps } from "../DateTimeRangePicker/index.js";
+import { DesktopDateTimeRangePickerProps } from "../DesktopDateTimeRangePicker/index.js";
+import { MobileDateTimeRangePickerProps } from "../MobileDateTimeRangePicker/index.js";
+import { ExportedDateTimeRangePickerTabsProps } from "../DateTimeRangePicker/DateTimeRangePickerTabs.js";
+import { ExportedDateTimeRangePickerToolbarProps } from "../DateTimeRangePicker/DateTimeRangePickerToolbar.js";
+import { ExportedPickersRangeCalendarHeaderProps } from "../PickersRangeCalendarHeader/index.js";
+export interface PickersProComponentsPropsList {
+  MuiDateRangeCalendar: DateRangeCalendarProps;
+  MuiDateRangePickerDay: DateRangePickerDayProps;
+  MuiDateTimeRangePickerTabs: ExportedDateTimeRangePickerTabsProps;
+  MuiDateRangePickerToolbar: ExportedDateRangePickerToolbarProps;
+  MuiDateTimeRangePickerToolbar: ExportedDateTimeRangePickerToolbarProps;
+  MuiPickersRangeCalendarHeader: ExportedPickersRangeCalendarHeaderProps;
+
+  // Multi input range fields
+  MuiMultiInputDateRangeField: MultiInputDateRangeFieldProps<any>;
+  MuiMultiInputDateTimeRangeField: MultiInputDateTimeRangeFieldProps<any>;
+  MuiMultiInputTimeRangeField: MultiInputTimeRangeFieldProps<any>;
+
+  // Single input range fields
+  MuiSingleInputDateRangeField: SingleInputDateRangeFieldProps<any>;
+  MuiSingleInputDateTimeRangeField: SingleInputDateTimeRangeFieldProps<any>;
+  MuiSingleInputTimeRangeField: SingleInputTimeRangeFieldProps<any>;
+
+  // Date Range Pickers
+  MuiDateRangePicker: DateRangePickerProps<any>;
+  MuiDesktopDateRangePicker: DesktopDateRangePickerProps<any>;
+  MuiMobileDateRangePicker: MobileDateRangePickerProps<any>;
+  MuiStaticDateRangePicker: StaticDateRangePickerProps;
+
+  // Date Time Range Pickers
+  MuiDateTimeRangePicker: DateTimeRangePickerProps<any>;
+  MuiDesktopDateTimeRangePicker: DesktopDateTimeRangePickerProps<any>;
+  MuiMobileDateTimeRangePicker: MobileDateTimeRangePickerProps<any>;
+}
+declare module '@mui/material/styles' {
+  interface ComponentsPropsList extends PickersProComponentsPropsList {}
+}
+
+// disable automatic export
+export {};

package/modern/validation/index.d.ts

@@ -0,0 +1,6 @@
+export { validateDateRange } from "./validateDateRange.js";
+export type { ValidateDateRangeProps } from './validateDateRange';
+export { validateTimeRange } from "./validateTimeRange.js";
+export type { ValidateTimeRangeProps } from './validateTimeRange';
+export { validateDateTimeRange } from "./validateDateTimeRange.js";
+export type { ValidateDateTimeRangeProps } from './validateDateTimeRange';

package/modern/validation/validateDateRange.d.ts

@@ -0,0 +1,18 @@
+import type { MakeRequired } from '@mui/x-internals/types';
+import { Validator } from '@mui/x-date-pickers/validation';
+import { BaseDateValidationProps, PickerRangeValue } from '@mui/x-date-pickers/internals';
+import { DayRangeValidationProps } from "../internals/models/dateRange.js";
+import { DateRangeValidationError } from "../models/index.js";
+/**
+ * Validation props used by the Date Range Picker, Date Range Field and Date Range Calendar components.
+ */
+export interface ExportedValidateDateRangeProps extends DayRangeValidationProps, BaseDateValidationProps {}
+/**
+ * Validation props as received by the validateDateRange method.
+ */
+export interface ValidateDateRangeProps extends MakeRequired<ExportedValidateDateRangeProps, ValidateDateRangePropsToDefault> {}
+/**
+ * Name of the props that should be defaulted before being passed to the validateDateRange method.
+ */
+export type ValidateDateRangePropsToDefault = keyof BaseDateValidationProps;
+export declare const validateDateRange: Validator<PickerRangeValue, DateRangeValidationError, ValidateDateRangeProps>;

package/modern/validation/validateDateTimeRange.d.ts

@@ -0,0 +1,15 @@
+import { DateTimeValidationProps, PickerRangeValue } from '@mui/x-date-pickers/internals';
+import { Validator } from '@mui/x-date-pickers/validation';
+import { DateTimeRangeValidationError } from "../models/index.js";
+import { ExportedValidateDateRangeProps, ValidateDateRangeProps, ValidateDateRangePropsToDefault } from "./validateDateRange.js";
+import { ExportedValidateTimeRangeProps, ValidateTimeRangeProps, ValidateTimeRangePropsToDefault } from "./validateTimeRange.js";
+/**
+ * Validation props used by the Date Time Range Picker and Date Time Range Field.
+ */
+export interface ExportedValidateDateTimeRangeProps extends ExportedValidateDateRangeProps, ExportedValidateTimeRangeProps, DateTimeValidationProps {}
+/**
+ * Validation props as received by the validateDateTimeRange method.
+ */
+export interface ValidateDateTimeRangeProps extends ValidateDateRangeProps, ValidateTimeRangeProps {}
+export type ValidateDateTimeRangePropsToDefault = ValidateDateRangePropsToDefault | ValidateTimeRangePropsToDefault;
+export declare const validateDateTimeRange: Validator<PickerRangeValue, DateTimeRangeValidationError, ValidateDateTimeRangeProps>;

package/modern/validation/validateTimeRange.d.ts

@@ -0,0 +1,17 @@
+import type { MakeRequired } from '@mui/x-internals/types';
+import { Validator } from '@mui/x-date-pickers/validation';
+import { TimeValidationProps, BaseTimeValidationProps, PickerRangeValue } from '@mui/x-date-pickers/internals';
+import { TimeRangeValidationError } from "../models/index.js";
+/**
+ * Validation props used by the Time Range Picker and Time Range Field.
+ */
+export interface ExportedValidateTimeRangeProps extends BaseTimeValidationProps, TimeValidationProps {}
+/**
+ * Validation props as received by the validateTimeRange method.
+ */
+export interface ValidateTimeRangeProps extends MakeRequired<ExportedValidateTimeRangeProps, ValidateTimeRangePropsToDefault> {}
+/**
+ * Name of the props that should be defaulted before being passed to the validateTimeRange method.
+ */
+export type ValidateTimeRangePropsToDefault = keyof BaseTimeValidationProps;
+export declare const validateTimeRange: Validator<PickerRangeValue, TimeRangeValidationError, ValidateTimeRangeProps>;