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

package/modern/dateRangeViewRenderers/dateRangeViewRenderers.d.ts

@@ -0,0 +1,47 @@
+import * as React from 'react';
+import { DateOrTimeViewWithMeridiem } from '@mui/x-date-pickers/internals';
+import { DateRangeCalendarProps } from "../DateRangeCalendar/index.js";
+export interface DateRangeViewRendererProps<TView extends DateOrTimeViewWithMeridiem> extends Omit<DateRangeCalendarProps, 'views' | 'onRangePositionChange' | 'rangePosition' | 'defaultRangePosition'> {
+  views: readonly TView[];
+}
+/**
+ * We don't pass all the props down to `DateRangeCalendar`,
+ * because otherwise some unwanted props would be passed to the HTML element.
+ */
+export declare const renderDateRangeViewCalendar: ({
+  value,
+  defaultValue,
+  referenceDate,
+  onChange,
+  className,
+  classes,
+  disableFuture,
+  disablePast,
+  minDate,
+  maxDate,
+  shouldDisableDate,
+  reduceAnimations,
+  onMonthChange,
+  calendars,
+  currentMonthCalendarPosition,
+  slots,
+  slotProps,
+  loading,
+  renderLoading,
+  disableHighlightToday,
+  readOnly,
+  disabled,
+  showDaysOutsideCurrentMonth,
+  dayOfWeekFormatter,
+  disableAutoMonthSwitching,
+  sx,
+  autoFocus,
+  fixedWeekNumber,
+  disableDragEditing,
+  displayWeekNumber,
+  timezone,
+  availableRangePositions,
+  views,
+  view,
+  onViewChange
+}: DateRangeViewRendererProps<"day">) => React.JSX.Element;

package/modern/dateRangeViewRenderers/index.d.ts

@@ -0,0 +1,2 @@
+export { renderDateRangeViewCalendar } from "./dateRangeViewRenderers.js";
+export type { DateRangeViewRendererProps } from './dateRangeViewRenderers';

package/modern/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { usePickerRangePositionContext } from "./usePickerRangePositionContext.js";
+export { useMultiInputRangeField as unstable_useMultiInputRangeField } from "./useMultiInputRangeField/index.js";

package/modern/hooks/useMultiInputRangeField/index.d.ts

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

package/modern/hooks/useMultiInputRangeField/useMultiInputRangeField.d.ts

@@ -0,0 +1,53 @@
+import { PickerManagerEnableAccessibleFieldDOMStructure, PickerManagerFieldInternalProps, UseFieldResponse } from '@mui/x-date-pickers/internals';
+import { PickerAnyRangeManager } from "../../internals/models/managers.js";
+/**
+ * Basic example:
+ *
+ * ```tsx
+ * import Box from '@mui/material/Box';
+ * import { useSplitFieldProps } from '@mui/x-date-pickers/hooks';
+ * import { PickersTextField } from '@mui/x-date-pickers/PickersTextField';
+ * import { useDateRangeManager } from '@mui/x-date-pickers-pro/managers';
+ *
+ * function MultiInputField(props) {
+ *   const manager = useDateRangeManager();
+ *   const { internalProps, forwardedProps } = useSplitFieldProps(props, 'date');
+ *   const { startDate, endDate } = useMultiInputRangeField({
+ *     manager,
+ *     internalProps,
+ *     startForwardedProps: forwardedProps,
+ *     endForwardedProps: forwardedProps,
+ *   });
+ *
+ *   return (
+ *     <Box {...forwardedProps}>
+ *       <PickersTextField {...startDate} />
+ *       <span>{' – '}</span>
+ *       <PickersTextField {...endDate} />
+ *     </Box>
+ *   );
+ * }
+ * ```
+ *
+ * @param {UseMultiInputRangeFieldParameters<TManager, TForwardedProps>} parameters The parameters of the hook.
+ * @param {TManager} parameters.manager The manager of the field.
+ * @param {PickerManagerFieldInternalProps<TManager>} parameters.internalProps The internal props of the field.
+ * @param {TForwardedProps} parameters.startForwardedProps The forwarded props of the start field.
+ * @param {TForwardedProps} parameters.endForwardedProps The forwarded props of the end field.
+ * @returns {UseMultiInputRangeFieldReturnValue<TManager, TForwardedProps>} The props to pass to the start and the end components.
+ */
+export declare function useMultiInputRangeField<TManager extends PickerAnyRangeManager, TForwardedProps extends {
+  [key: string]: any;
+}>(parameters: UseMultiInputRangeFieldParameters<TManager, TForwardedProps>): UseMultiInputRangeFieldReturnValue<TManager, TForwardedProps>;
+interface UseMultiInputRangeFieldParameters<TManager extends PickerAnyRangeManager, TForwardedProps extends {}> {
+  manager: TManager;
+  internalProps: PickerManagerFieldInternalProps<TManager>;
+  startForwardedProps: TForwardedProps;
+  endForwardedProps: TForwardedProps;
+}
+interface UseMultiInputRangeFieldReturnValue<TManager extends PickerAnyRangeManager, TForwardedProps extends {}> {
+  startDate: Omit<UseFieldResponse<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TForwardedProps>, 'clearable' | 'onClear'>;
+  endDate: Omit<UseFieldResponse<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TForwardedProps>, 'clearable' | 'onClear'>;
+  enableAccessibleFieldDOMStructure: PickerManagerEnableAccessibleFieldDOMStructure<TManager>;
+}
+export {};

package/modern/hooks/useMultiInputRangeField/useMultiInputRangeFieldSelectedSections.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { PickerRangeValue, PickerValue, UseFieldInternalProps } from '@mui/x-date-pickers/internals';
+import { FieldRef, FieldSelectedSections } from '@mui/x-date-pickers/models';
+import { MultiInputFieldRefs } from "../../models/index.js";
+interface UseMultiInputRangeFieldSelectedSectionsParameters extends Pick<UseFieldInternalProps<PickerRangeValue, any, any>, 'selectedSections' | 'onSelectedSectionsChange'>, MultiInputFieldRefs {}
+interface UseMultiInputFieldSelectedSectionsResponseItem {
+  unstableFieldRef?: React.Ref<FieldRef<PickerValue>>;
+  selectedSections: FieldSelectedSections;
+  onSelectedSectionsChange: (newSelectedSections: FieldSelectedSections) => void;
+}
+interface UseMultiInputFieldSelectedSectionsResponse {
+  start: UseMultiInputFieldSelectedSectionsResponseItem;
+  end: UseMultiInputFieldSelectedSectionsResponseItem;
+}
+export declare const useMultiInputRangeFieldSelectedSections: (parameters: UseMultiInputRangeFieldSelectedSectionsParameters) => UseMultiInputFieldSelectedSectionsResponse;
+export {};

package/modern/hooks/useMultiInputRangeField/useMultiInputRangeFieldTextFieldProps.d.ts

@@ -0,0 +1,17 @@
+import { UseDateManagerReturnValue, UseDateTimeManagerReturnValue, UseTimeManagerReturnValue } from '@mui/x-date-pickers/managers';
+import { PickerValueType } from '@mui/x-date-pickers/models';
+import { PickerManagerEnableAccessibleFieldDOMStructure, PickerManagerFieldInternalProps, UseFieldResponse } from '@mui/x-date-pickers/internals';
+import { PickerAnyRangeManager } from "../../internals/models/managers.js";
+import { UseDateRangeManagerReturnValue, UseDateTimeRangeManagerReturnValue, UseTimeRangeManagerReturnValue } from "../../managers/index.js";
+/**
+ * @ignore - internal hook.
+ */
+export declare function useMultiInputRangeFieldTextFieldProps<TManager extends PickerAnyRangeManager, TForwardedProps extends {
+  [key: string]: any;
+}>(parameters: UseMultiInputRangeFieldTextFieldProps<TManager>): Omit<UseFieldResponse<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TForwardedProps>, "clearable" | "onClear">;
+interface UseMultiInputRangeFieldTextFieldProps<TManager extends PickerAnyRangeManager> {
+  valueType: PickerValueType;
+  fieldProps: PickerManagerFieldInternalProps<GetDerivedManager<TManager>>;
+}
+type GetDerivedManager<TManager extends PickerAnyRangeManager> = TManager extends UseDateRangeManagerReturnValue<infer TEnableAccessibleFieldDOMStructure> ? UseDateManagerReturnValue<TEnableAccessibleFieldDOMStructure> : TManager extends UseTimeRangeManagerReturnValue<infer TEnableAccessibleFieldDOMStructure> ? UseTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure> : TManager extends UseDateTimeRangeManagerReturnValue<infer TEnableAccessibleFieldDOMStructure> ? UseDateTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure> : never;
+export {};

package/modern/hooks/usePickerRangePositionContext.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { UseRangePositionResponse } from "../internals/hooks/useRangePosition.js";
+export declare const PickerRangePositionContext: React.Context<UseRangePositionResponse | null>;
+/**
+ * Returns information about the range position of the picker that wraps the current component.
+ */
+export declare function usePickerRangePositionContext(): UseRangePositionResponse;

package/modern/index.d.ts

@@ -0,0 +1,22 @@
+export * from '@mui/x-date-pickers';
+export * from "./DateRangePickerDay/index.js";
+export * from "./MultiInputDateRangeField/index.js";
+export * from "./MultiInputTimeRangeField/index.js";
+export * from "./MultiInputDateTimeRangeField/index.js";
+export * from "./SingleInputDateRangeField/index.js";
+export * from "./SingleInputTimeRangeField/index.js";
+export * from "./SingleInputDateTimeRangeField/index.js";
+export * from "./DateRangeCalendar/index.js";
+export * from "./PickersRangeCalendarHeader/index.js";
+export * from "./DateRangePicker/index.js";
+export * from "./DesktopDateRangePicker/index.js";
+export * from "./MobileDateRangePicker/index.js";
+export * from "./StaticDateRangePicker/index.js";
+export * from "./DateTimeRangePicker/index.js";
+export * from "./DesktopDateTimeRangePicker/index.js";
+export * from "./MobileDateTimeRangePicker/index.js";
+export * from "./dateRangeViewRenderers/index.js";
+export * from "./models/index.js";
+export * from "./hooks/index.js";
+export * from "./validation/index.js";
+export * from "./managers/index.js";

package/modern/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-date-pickers-pro v8.0.0-alpha.11
+ * @mui/x-date-pickers-pro v8.0.0-alpha.12
  *
  * @license MUI X Commercial
  * This source code is licensed under the commercial license found in the

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

@@ -0,0 +1,3 @@
+export { DAY_MARGIN } from '@mui/x-date-pickers/internals';
+export declare const DAY_RANGE_SIZE = 40;
+export declare const RANGE_VIEW_HEIGHT: number;

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

@@ -0,0 +1 @@
+export type { UseRangePickerSlots, UseRangePickerSlotProps, RangeOnlyPickerProps, UseRangePickerProps, UseRangePickerParams } from './useRangePicker';

package/modern/internals/hooks/models/useRangePicker.d.ts

@@ -0,0 +1,15 @@
+import { UsePickerParams, BasePickerProps, ExportedBaseToolbarProps, UsePickerViewsProps, UsePickerValueNonStaticProps, UsePickerProviderNonStaticProps, DateOrTimeViewWithMeridiem, ExportedBaseTabsProps, PickerRangeValue } from '@mui/x-date-pickers/internals';
+import { ExportedPickersLayoutSlots, ExportedPickersLayoutSlotProps } from '@mui/x-date-pickers/PickersLayout';
+import { BaseRangeNonStaticPickerProps } from "../../models/index.js";
+import { UseRangePositionProps } from "../useRangePosition.js";
+import { RangePickerFieldSlots, RangePickerFieldSlotProps } from "../useEnrichedRangePickerField.js";
+export interface UseRangePickerSlots extends ExportedPickersLayoutSlots<PickerRangeValue>, RangePickerFieldSlots {}
+export interface UseRangePickerSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> extends ExportedPickersLayoutSlotProps<PickerRangeValue>, RangePickerFieldSlotProps<TEnableAccessibleFieldDOMStructure> {
+  tabs?: ExportedBaseTabsProps;
+  toolbar?: ExportedBaseToolbarProps;
+}
+export interface RangeOnlyPickerProps extends UsePickerValueNonStaticProps, UsePickerProviderNonStaticProps, BaseRangeNonStaticPickerProps, UseRangePositionProps {}
+export interface UseRangePickerProps<TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UsePickerViewsProps<any, TView, any>> extends RangeOnlyPickerProps, BasePickerProps<PickerRangeValue, TView, TError, TExternalProps> {}
+export interface UseRangePickerParams<TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UseRangePickerProps<TView, any, TExternalProps>> extends Pick<UsePickerParams<PickerRangeValue, TView, TExternalProps>, 'valueManager' | 'valueType' | 'validator' | 'rendererInterceptor' | 'ref'> {
+  props: TExternalProps;
+}

package/modern/internals/hooks/useDesktopRangePicker/index.d.ts

@@ -0,0 +1,2 @@
+export { useDesktopRangePicker } from "./useDesktopRangePicker.js";
+export type { UseDesktopRangePickerSlots, UseDesktopRangePickerSlotProps, DesktopRangeOnlyPickerProps, UseDesktopRangePickerProps } from './useDesktopRangePicker.types';

package/modern/internals/hooks/useDesktopRangePicker/useDesktopRangePicker.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { DateOrTimeViewWithMeridiem } from '@mui/x-date-pickers/internals';
+import { UseDesktopRangePickerParams, UseDesktopRangePickerProps } from "./useDesktopRangePicker.types.js";
+export declare const useDesktopRangePicker: <TView extends DateOrTimeViewWithMeridiem, TEnableAccessibleFieldDOMStructure extends boolean, TExternalProps extends UseDesktopRangePickerProps<TView, TEnableAccessibleFieldDOMStructure, any, TExternalProps>>({
+  props,
+  ...pickerParams
+}: UseDesktopRangePickerParams<TView, TEnableAccessibleFieldDOMStructure, TExternalProps>) => {
+  renderPicker: () => React.JSX.Element;
+};

package/modern/internals/hooks/useDesktopRangePicker/useDesktopRangePicker.types.d.ts

@@ -0,0 +1,23 @@
+import { PickerPopperSlots, PickerPopperSlotProps, UsePickerViewsProps, DateOrTimeViewWithMeridiem } from '@mui/x-date-pickers/internals';
+import { RangeOnlyPickerProps, UseRangePickerParams, UseRangePickerProps, UseRangePickerSlotProps, UseRangePickerSlots } from "../models/useRangePicker.js";
+export interface UseDesktopRangePickerSlots extends UseRangePickerSlots, PickerPopperSlots {}
+export interface UseDesktopRangePickerSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> extends UseRangePickerSlotProps<TEnableAccessibleFieldDOMStructure>, PickerPopperSlotProps {}
+export interface DesktopRangeOnlyPickerProps extends RangeOnlyPickerProps {
+  /**
+   * If `true`, the start `input` element is focused during the first mount.
+   */
+  autoFocus?: boolean;
+}
+export interface UseDesktopRangePickerProps<TView extends DateOrTimeViewWithMeridiem, TEnableAccessibleFieldDOMStructure extends boolean, TError, TExternalProps extends UsePickerViewsProps<any, TView, any>> extends UseRangePickerProps<TView, TError, TExternalProps> {
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: UseDesktopRangePickerSlots;
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps?: UseDesktopRangePickerSlotProps<TEnableAccessibleFieldDOMStructure>;
+}
+export interface UseDesktopRangePickerParams<TView extends DateOrTimeViewWithMeridiem, TEnableAccessibleFieldDOMStructure extends boolean, TExternalProps extends UseDesktopRangePickerProps<TView, TEnableAccessibleFieldDOMStructure, any, TExternalProps>> extends UseRangePickerParams<TView, TExternalProps> {}

package/modern/internals/hooks/useEnrichedRangePickerField.d.ts

@@ -0,0 +1,70 @@
+import * as React from 'react';
+import Stack, { StackProps } from '@mui/material/Stack';
+import Typography, { TypographyProps } from '@mui/material/Typography';
+import { SlotComponentProps } from '@mui/utils';
+import { SlotComponentPropsFromProps } from '@mui/x-internals/types';
+import { FieldSelectedSections, FieldRef, PickerOwnerState, FieldOwnerState } from '@mui/x-date-pickers/models';
+import { UseClearableFieldSlots, UseClearableFieldSlotProps } from '@mui/x-date-pickers/hooks';
+import { PickersInputLocaleText } from '@mui/x-date-pickers/locales';
+import { PickerVariant, DateOrTimeViewWithMeridiem, BaseSingleInputFieldProps, PickerRangeValue, PickerValue, PickerContextValue, PickerFieldPrivateContextValue } from '@mui/x-date-pickers/internals';
+import { PickersTextField } from '@mui/x-date-pickers/PickersTextField';
+import { RangePosition, FieldType, PickerRangeFieldSlotProps } from "../../models/index.js";
+import { UseRangePositionResponse } from "./useRangePosition.js";
+import { BaseMultiInputFieldProps } from "../models/fields.js";
+export interface RangePickerFieldSlots extends UseClearableFieldSlots {
+  field: React.ElementType;
+  /**
+   * Element rendered at the root.
+   * Ignored if the field has only one input.
+   */
+  fieldRoot?: React.ElementType<StackProps>;
+  /**
+   * Element rendered between the two inputs.
+   * Ignored if the field has only one input.
+   */
+  fieldSeparator?: React.ElementType<TypographyProps>;
+  /**
+   * Form control with an input to render a date or time inside the default field.
+   * It is rendered twice: once for the start element and once for the end element.
+   * @default TextField from '@mui/material' or PickersTextField if `enableAccessibleFieldDOMStructure` is `true`.
+   */
+  textField?: React.ElementType;
+}
+export interface RangePickerFieldSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> extends UseClearableFieldSlotProps {
+  field?: SlotComponentPropsFromProps<PickerRangeFieldSlotProps<TEnableAccessibleFieldDOMStructure>, {}, PickerOwnerState>;
+  fieldRoot?: SlotComponentProps<typeof Stack, {}, FieldOwnerState>;
+  fieldSeparator?: SlotComponentProps<typeof Typography, {}, FieldOwnerState>;
+  textField?: SlotComponentProps<typeof PickersTextField, {}, FieldOwnerState & {
+    position?: RangePosition;
+  }>;
+}
+export type RangePickerPropsForFieldSlot<TIsSingleInput extends boolean> = (TIsSingleInput extends true ? BaseSingleInputFieldProps<PickerRangeValue> : never) | (TIsSingleInput extends false ? BaseMultiInputFieldProps : never);
+export interface UseEnrichedRangePickerFieldPropsParams<TIsSingleInput extends boolean, TView extends DateOrTimeViewWithMeridiem, TEnableAccessibleFieldDOMStructure extends boolean, TError> extends UseRangePositionResponse {
+  contextValue: PickerContextValue<PickerRangeValue, TView, TError>;
+  fieldPrivateContextValue: PickerFieldPrivateContextValue;
+  variant: PickerVariant;
+  fieldType: FieldType;
+  readOnly?: boolean;
+  labelId?: string;
+  disableOpenPicker?: boolean;
+  onBlur?: () => void;
+  localeText: PickersInputLocaleText | undefined;
+  pickerSlotProps: RangePickerFieldSlotProps<TEnableAccessibleFieldDOMStructure> | undefined;
+  pickerSlots: RangePickerFieldSlots | undefined;
+  fieldProps: RangePickerPropsForFieldSlot<TIsSingleInput>;
+  anchorRef?: React.Ref<HTMLElement>;
+  currentView?: TView | null;
+  initialView?: TView;
+  startFieldRef: React.RefObject<FieldRef<PickerValue> | null>;
+  endFieldRef: React.RefObject<FieldRef<PickerValue> | null>;
+  singleInputFieldRef: React.RefObject<FieldRef<PickerRangeValue> | null>;
+}
+export declare const useEnrichedRangePickerField: <TView extends DateOrTimeViewWithMeridiem, TEnableAccessibleFieldDOMStructure extends boolean, TError>(params: UseEnrichedRangePickerFieldPropsParams<boolean, TView, TEnableAccessibleFieldDOMStructure, TError>) => {
+  fieldProps: BaseMultiInputFieldProps;
+  fieldPrivateContextValue: {};
+} | {
+  fieldProps: BaseSingleInputFieldProps<PickerRangeValue>;
+  fieldPrivateContextValue: {
+    onSelectedSectionsChange: (selectedSection: FieldSelectedSections) => void;
+  };
+};

package/modern/internals/hooks/useEnrichedRangePickerField.js

@@ -43,6 +43,7 @@ const useMultiInputFieldSlotProps = ({
     }
 
     // bring back focus to the field
+    // currentView is present on DateTimeRangePicker
     currentFieldRef.current.setSelectedSections(
     // use the current view or `0` when the range position has just been swapped
     previousRangePosition.current === rangePosition ? currentView : 0);

package/modern/internals/hooks/useMobileRangePicker/index.d.ts

@@ -0,0 +1,2 @@
+export { useMobileRangePicker } from "./useMobileRangePicker.js";
+export type { UseMobileRangePickerSlots, UseMobileRangePickerSlotProps, MobileRangeOnlyPickerProps, UseMobileRangePickerProps } from './useMobileRangePicker.types';

package/modern/internals/hooks/useMobileRangePicker/useMobileRangePicker.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { DateOrTimeViewWithMeridiem } from '@mui/x-date-pickers/internals';
+import { UseMobileRangePickerParams, UseMobileRangePickerProps } from "./useMobileRangePicker.types.js";
+export declare const useMobileRangePicker: <TView extends DateOrTimeViewWithMeridiem, TEnableAccessibleFieldDOMStructure extends boolean, TExternalProps extends UseMobileRangePickerProps<TView, TEnableAccessibleFieldDOMStructure, any, TExternalProps>>({
+  props,
+  ...pickerParams
+}: UseMobileRangePickerParams<TView, TEnableAccessibleFieldDOMStructure, TExternalProps>) => {
+  renderPicker: () => React.JSX.Element;
+};

package/modern/internals/hooks/useMobileRangePicker/useMobileRangePicker.types.d.ts

@@ -0,0 +1,18 @@
+import { PickersModalDialogSlots, PickersModalDialogSlotProps, UsePickerViewsProps, DateOrTimeViewWithMeridiem } from '@mui/x-date-pickers/internals';
+import { RangeOnlyPickerProps, UseRangePickerParams, UseRangePickerProps, UseRangePickerSlotProps, UseRangePickerSlots } from "../models/useRangePicker.js";
+export interface UseMobileRangePickerSlots extends UseRangePickerSlots, PickersModalDialogSlots {}
+export interface UseMobileRangePickerSlotProps<TEnableAccessibleFieldDOMStructure extends boolean> extends UseRangePickerSlotProps<TEnableAccessibleFieldDOMStructure>, PickersModalDialogSlotProps {}
+export interface MobileRangeOnlyPickerProps extends RangeOnlyPickerProps {}
+export interface UseMobileRangePickerProps<TView extends DateOrTimeViewWithMeridiem, TEnableAccessibleFieldDOMStructure extends boolean, TError, TExternalProps extends UsePickerViewsProps<any, TView, any>> extends UseRangePickerProps<TView, TError, TExternalProps> {
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: UseMobileRangePickerSlots;
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps?: UseMobileRangePickerSlotProps<TEnableAccessibleFieldDOMStructure>;
+}
+export interface UseMobileRangePickerParams<TView extends DateOrTimeViewWithMeridiem, TEnableAccessibleFieldDOMStructure extends boolean, TExternalProps extends UseMobileRangePickerProps<TView, TEnableAccessibleFieldDOMStructure, any, TExternalProps>> extends UseRangePickerParams<TView, TExternalProps> {}

package/modern/internals/hooks/useNullablePickerRangePositionContext.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns information about the range position of the picker that wraps the current component.
+ * If no picker wraps the current component, returns `null`.
+ */
+export declare function useNullablePickerRangePositionContext(): import("./useRangePosition").UseRangePositionResponse | null;

package/modern/internals/hooks/useRangePosition.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import { FieldRef } from '@mui/x-date-pickers/models';
+import { PickerRangeValue } from '@mui/x-date-pickers/internals';
+import { RangePosition } from "../../models/index.js";
+export interface UseRangePositionProps {
+  /**
+   * The position in the currently edited date range.
+   * Used when the component position is controlled.
+   */
+  rangePosition?: RangePosition;
+  /**
+   * The initial position in the edited date range.
+   * Used when the component is not controlled.
+   * @default 'start'
+   */
+  defaultRangePosition?: RangePosition;
+  /**
+   * Callback fired when the range position changes.
+   * @param {RangePosition} rangePosition The new range position.
+   */
+  onRangePositionChange?: (rangePosition: RangePosition) => void;
+}
+export interface UseRangePositionResponse {
+  rangePosition: RangePosition;
+  setRangePosition: (newPosition: RangePosition) => void;
+}
+export declare const useRangePosition: (props: UseRangePositionProps, singleInputFieldRef?: React.RefObject<FieldRef<PickerRangeValue> | null>) => UseRangePositionResponse;

package/modern/internals/hooks/useRangePosition.js

@@ -16,6 +16,11 @@ export const useRangePosition = (props, singleInputFieldRef) => {
     }
     const sections = singleInputFieldRef.current.getSections();
     const targetActiveSectionIndex = newRangePosition === 'start' ? 0 : sections.length / 2;
+    const activeSectionIndex = singleInputFieldRef.current.getActiveSectionIndex();
+    // if the active section is already within the target range, we don't need to update it.
+    if (activeSectionIndex && activeSectionIndex >= targetActiveSectionIndex && activeSectionIndex < targetActiveSectionIndex + sections.length / 2) {
+      return;
+    }
     singleInputFieldRef.current.setSelectedSections(targetActiveSectionIndex);
   };
   const handleRangePositionChange = useEventCallback(newRangePosition => {

package/modern/internals/hooks/useStaticRangePicker/index.d.ts

@@ -0,0 +1,2 @@
+export { useStaticRangePicker } from "./useStaticRangePicker.js";
+export type { UseStaticRangePickerSlots, UseStaticRangePickerSlotProps, StaticRangeOnlyPickerProps } from './useStaticRangePicker.types';

package/modern/internals/hooks/useStaticRangePicker/useStaticRangePicker.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { DateOrTimeViewWithMeridiem } from '@mui/x-date-pickers/internals';
+import { UseStaticRangePickerParams, UseStaticRangePickerProps } from "./useStaticRangePicker.types.js";
+/**
+ * Hook managing all the range static pickers:
+ * - StaticDateRangePicker
+ */
+export declare const useStaticRangePicker: <TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UseStaticRangePickerProps<TView, any, TExternalProps>>({
+  props,
+  ...pickerParams
+}: UseStaticRangePickerParams<TView, TExternalProps>) => {
+  renderPicker: () => React.JSX.Element;
+};

package/modern/internals/hooks/useStaticRangePicker/useStaticRangePicker.types.d.ts

@@ -0,0 +1,23 @@
+import { BasePickerProps, UsePickerParams, ExportedBaseToolbarProps, StaticOnlyPickerProps, DateOrTimeViewWithMeridiem, PickerRangeValue } from '@mui/x-date-pickers/internals';
+import { ExportedPickersLayoutSlots, ExportedPickersLayoutSlotProps } from '@mui/x-date-pickers/PickersLayout';
+import { UseRangePositionProps } from "../useRangePosition.js";
+export interface UseStaticRangePickerSlots extends ExportedPickersLayoutSlots<PickerRangeValue> {}
+export interface UseStaticRangePickerSlotProps extends ExportedPickersLayoutSlotProps<PickerRangeValue> {
+  toolbar?: ExportedBaseToolbarProps;
+}
+export interface StaticRangeOnlyPickerProps extends StaticOnlyPickerProps, UseRangePositionProps {}
+export interface UseStaticRangePickerProps<TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UseStaticRangePickerProps<TView, any, TExternalProps>> extends BasePickerProps<PickerRangeValue, TView, TError, TExternalProps>, StaticRangeOnlyPickerProps {
+  /**
+   * Overridable components.
+   * @default {}
+   */
+  slots?: UseStaticRangePickerSlots;
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps?: UseStaticRangePickerSlotProps;
+}
+export interface UseStaticRangePickerParams<TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UseStaticRangePickerProps<TView, any, TExternalProps>> extends Pick<UsePickerParams<PickerRangeValue, TView, TExternalProps>, 'valueManager' | 'valueType' | 'validator' | 'ref'> {
+  props: TExternalProps;
+}

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.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";