@mui/x-date-pickers 8.0.0-alpha.6 → 8.0.0-alpha.8

package/locales/zhTW.d.ts

@@ -0,0 +1,80 @@
+import { TimeViewWithMeridiem } from '../internals/models';
+export declare const zhTW: {
+    components: {
+        MuiLocalizationProvider: {
+            defaultProps: {
+                localeText: {
+                    previousMonth?: string | undefined;
+                    nextMonth?: string | undefined;
+                    calendarWeekNumberHeaderLabel?: string | undefined;
+                    calendarWeekNumberHeaderText?: string | undefined;
+                    calendarWeekNumberAriaLabelText?: ((weekNumber: number) => string) | undefined;
+                    calendarWeekNumberText?: ((weekNumber: number) => string) | undefined;
+                    openPreviousView?: string | undefined;
+                    openNextView?: string | undefined;
+                    calendarViewSwitchingButtonAriaLabel?: ((currentView: import("@mui/x-date-pickers/models").DateView) => string) | undefined;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                    startDate?: string | undefined;
+                    startTime?: string | undefined;
+                    endDate?: string | undefined;
+                    endTime?: string | undefined;
+                    cancelButtonLabel?: string | undefined;
+                    clearButtonLabel?: string | undefined;
+                    okButtonLabel?: string | undefined;
+                    todayButtonLabel?: string | undefined;
+                    clockLabelText?: ((view: import("@mui/x-date-pickers/models").TimeView, formattedTime: string | null) => string) | undefined;
+                    hoursClockNumberText?: ((hours: string) => string) | undefined;
+                    minutesClockNumberText?: ((minutes: string) => string) | undefined;
+                    secondsClockNumberText?: ((seconds: string) => string) | undefined;
+                    selectViewText?: ((view: TimeViewWithMeridiem) => string) | undefined;
+                    openDatePickerDialogue?: ((formattedDate: string | null) => string) | undefined;
+                    openTimePickerDialogue?: ((formattedTime: string | null) => string) | undefined;
+                    fieldClearLabel?: string | undefined;
+                    timeTableLabel?: string | undefined;
+                    dateTableLabel?: string | undefined;
+                    fieldYearPlaceholder?: ((params: {
+                        digitAmount: number;
+                        format: string;
+                    }) => string) | undefined;
+                    fieldMonthPlaceholder?: ((params: {
+                        contentType: import("@mui/x-date-pickers/models").FieldSectionContentType;
+                        format: string;
+                    }) => string) | undefined;
+                    fieldDayPlaceholder?: ((params: {
+                        format: string;
+                    }) => string) | undefined;
+                    fieldWeekDayPlaceholder?: ((params: {
+                        contentType: import("@mui/x-date-pickers/models").FieldSectionContentType;
+                        format: string;
+                    }) => string) | undefined;
+                    fieldHoursPlaceholder?: ((params: {
+                        format: string;
+                    }) => string) | undefined;
+                    fieldMinutesPlaceholder?: ((params: {
+                        format: string;
+                    }) => string) | undefined;
+                    fieldSecondsPlaceholder?: ((params: {
+                        format: string;
+                    }) => string) | undefined;
+                    fieldMeridiemPlaceholder?: ((params: {
+                        format: string;
+                    }) => string) | undefined;
+                    year?: string | undefined;
+                    month?: string | undefined;
+                    day?: string | undefined;
+                    weekDay?: string | undefined;
+                    hours?: string | undefined;
+                    minutes?: string | undefined;
+                    seconds?: string | undefined;
+                    meridiem?: string | undefined;
+                    empty?: string | undefined;
+                    datePickerToolbarTitle?: string | undefined;
+                    timePickerToolbarTitle?: string | undefined;
+                    dateTimePickerToolbarTitle?: string | undefined;
+                    dateRangePickerToolbarTitle?: string | undefined;
+                };
+            };
+        };
+    };
+};

package/locales/zhTW.js

@@ -0,0 +1,73 @@
+import { getPickersLocalization } from "./utils/getPickersLocalization.js";
+const views = {
+  hours: '小時',
+  minutes: '分鐘',
+  seconds: '秒',
+  meridiem: '十二小時制'
+};
+const zhTWPickers = {
+  // Calendar navigation
+  previousMonth: '上個月',
+  nextMonth: '下個月',
+  // View navigation
+  openPreviousView: '前一個視圖',
+  openNextView: '下一個視圖',
+  calendarViewSwitchingButtonAriaLabel: view => view === 'year' ? '年視圖已打開，切換為日曆視圖' : '日曆視圖已打開，切換為年視圖',
+  // DateRange labels
+  start: '開始',
+  end: '結束',
+  startDate: '開始日期',
+  startTime: '開始時間',
+  endDate: '結束日期',
+  endTime: '結束時間',
+  // Action bar
+  cancelButtonLabel: '取消',
+  clearButtonLabel: '清除',
+  okButtonLabel: '確認',
+  todayButtonLabel: '今天',
+  // Toolbar titles
+  datePickerToolbarTitle: '選擇日期',
+  dateTimePickerToolbarTitle: '選擇日期和時間',
+  timePickerToolbarTitle: '選擇時間',
+  dateRangePickerToolbarTitle: '選擇時間範圍',
+  // Clock labels
+  clockLabelText: (view, formattedTime) => `選擇 ${views[view]}. ${!formattedTime ? '未選擇時間' : `已選擇${formattedTime}`}`,
+  hoursClockNumberText: hours => `${hours}小時`,
+  minutesClockNumberText: minutes => `${minutes}分鐘`,
+  secondsClockNumberText: seconds => `${seconds}秒`,
+  // Digital clock labels
+  selectViewText: view => `選擇 ${views[view]}`,
+  // Calendar labels
+  calendarWeekNumberHeaderLabel: '週數',
+  calendarWeekNumberHeaderText: '#',
+  calendarWeekNumberAriaLabelText: weekNumber => `第${weekNumber}週`,
+  calendarWeekNumberText: weekNumber => `${weekNumber}`,
+  // Open picker labels
+  openDatePickerDialogue: formattedDate => formattedDate ? `選擇日期，已選擇${formattedDate}` : '選擇日期',
+  openTimePickerDialogue: formattedTime => formattedTime ? `選擇時間，已選擇${formattedTime}` : '選擇時間',
+  fieldClearLabel: '清除',
+  // Table labels
+  timeTableLabel: '選擇時間',
+  dateTableLabel: '選擇日期',
+  // Field section placeholders
+  fieldYearPlaceholder: params => 'Y'.repeat(params.digitAmount),
+  fieldMonthPlaceholder: params => params.contentType === 'letter' ? 'MMMM' : 'MM',
+  fieldDayPlaceholder: () => 'DD',
+  fieldWeekDayPlaceholder: params => params.contentType === 'letter' ? 'EEEE' : 'EE',
+  fieldHoursPlaceholder: () => 'hh',
+  fieldMinutesPlaceholder: () => 'mm',
+  fieldSecondsPlaceholder: () => 'ss',
+  fieldMeridiemPlaceholder: () => 'aa',
+  // View names
+  year: '年份',
+  month: '月份',
+  day: '日期',
+  weekDay: '星期',
+  hours: '時',
+  minutes: '分',
+  seconds: '秒',
+  meridiem: '十二小時制',
+  // Common
+  empty: '空'
+};
+export const zhTW = getPickersLocalization(zhTWPickers);

package/managers/index.d.ts

@@ -0,0 +1,6 @@
+export { useDateManager } from './useDateManager';
+export type { UseDateManagerReturnValue, UseDateManagerParameters, DateManagerFieldInternalProps, } from './useDateManager';
+export { useTimeManager } from './useTimeManager';
+export type { UseTimeManagerReturnValue, UseTimeManagerParameters, TimeManagerFieldInternalProps, } from './useTimeManager';
+export { useDateTimeManager } from './useDateTimeManager';
+export type { UseDateTimeManagerReturnValue, UseDateTimeManagerParameters, DateTimeManagerFieldInternalProps, } from './useDateTimeManager';

package/managers/index.js

@@ -0,0 +1,3 @@
+export { useDateManager } from "./useDateManager.js";
+export { useTimeManager } from "./useTimeManager.js";
+export { useDateTimeManager } from "./useDateTimeManager.js";

package/managers/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/managers/index.js",
+  "types": "./index.d.ts"
+}

package/managers/useDateManager.d.ts

@@ -0,0 +1,27 @@
+import type { MakeOptional } from '@mui/x-internals/types';
+import { PickerManager, DateValidationError } from '../models';
+import { UseFieldInternalProps } from '../internals/hooks/useField';
+import { MuiPickersAdapterContextValue } from '../LocalizationProvider/LocalizationProvider';
+import { ExportedValidateDateProps, ValidateDatePropsToDefault, ValidateDateProps } from '../validation/validateDate';
+import { PickerValue } from '../internals/models';
+export declare function useDateManager<TEnableAccessibleFieldDOMStructure extends boolean = true>(parameters?: UseDateManagerParameters<TEnableAccessibleFieldDOMStructure>): UseDateManagerReturnValue<TEnableAccessibleFieldDOMStructure>;
+/**
+ * Private utility function to get the default internal props for the fields with date editing.
+ * Is used by the `useDateManager` and `useDateRangeManager` hooks.
+ */
+export declare function getDateFieldInternalPropsDefaults(parameters: GetDateFieldInternalPropsDefaultsParameters): GetDateFieldInternalPropsDefaultsReturnValue;
+export interface UseDateManagerParameters<TEnableAccessibleFieldDOMStructure extends boolean> {
+    enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
+}
+export type UseDateManagerReturnValue<TEnableAccessibleFieldDOMStructure extends boolean> = PickerManager<PickerValue, TEnableAccessibleFieldDOMStructure, DateValidationError, DateManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>, DateManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure>>;
+export interface DateManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, DateValidationError>, 'format'>, ExportedValidateDateProps {
+}
+interface DateManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure extends boolean> extends UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, DateValidationError>, ValidateDateProps {
+}
+type DateManagerFieldPropsToDefault = 'format' | ValidateDatePropsToDefault;
+interface GetDateFieldInternalPropsDefaultsParameters extends Pick<MuiPickersAdapterContextValue, 'defaultDates' | 'utils'> {
+    internalProps: Pick<DateManagerFieldInternalProps<true>, DateManagerFieldPropsToDefault>;
+}
+interface GetDateFieldInternalPropsDefaultsReturnValue extends Pick<DateManagerFieldInternalPropsWithDefaults<true>, DateManagerFieldPropsToDefault> {
+}
+export {};

package/managers/useDateManager.js

@@ -0,0 +1,55 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { applyDefaultDate } from "../internals/utils/date-utils.js";
+import { singleItemFieldValueManager, singleItemValueManager } from "../internals/utils/valueManagers.js";
+import { validateDate } from "../validation/index.js";
+export function useDateManager(parameters = {}) {
+  const {
+    enableAccessibleFieldDOMStructure = true
+  } = parameters;
+  return React.useMemo(() => ({
+    valueType: 'date',
+    validator: validateDate,
+    internal_valueManager: singleItemValueManager,
+    internal_fieldValueManager: singleItemFieldValueManager,
+    internal_enableAccessibleFieldDOMStructure: enableAccessibleFieldDOMStructure,
+    internal_applyDefaultsToFieldInternalProps: ({
+      internalProps,
+      utils,
+      defaultDates
+    }) => _extends({}, internalProps, getDateFieldInternalPropsDefaults({
+      defaultDates,
+      utils,
+      internalProps
+    })),
+    internal_getOpenPickerButtonAriaLabel: ({
+      value,
+      utils,
+      localeText
+    }) => {
+      const formattedValue = utils.isValid(value) ? utils.format(value, 'fullDate') : null;
+      return localeText.openDatePickerDialogue(formattedValue);
+    }
+  }), [enableAccessibleFieldDOMStructure]);
+}
+
+/**
+ * Private utility function to get the default internal props for the fields with date editing.
+ * Is used by the `useDateManager` and `useDateRangeManager` hooks.
+ */
+export function getDateFieldInternalPropsDefaults(parameters) {
+  const {
+    defaultDates,
+    utils,
+    internalProps
+  } = parameters;
+  return {
+    format: internalProps.format ?? utils.formats.keyboardDate,
+    disablePast: internalProps.disablePast ?? false,
+    disableFuture: internalProps.disableFuture ?? false,
+    minDate: applyDefaultDate(utils, internalProps.minDate, defaultDates.minDate),
+    maxDate: applyDefaultDate(utils, internalProps.maxDate, defaultDates.maxDate)
+  };
+}

package/managers/useDateTimeManager.d.ts

@@ -0,0 +1,28 @@
+import type { MakeOptional } from '@mui/x-internals/types';
+import { PickerManager, DateTimeValidationError } from '../models';
+import { UseFieldInternalProps } from '../internals/hooks/useField';
+import { MuiPickersAdapterContextValue } from '../LocalizationProvider/LocalizationProvider';
+import { AmPmProps } from '../internals/models/props/time';
+import { ExportedValidateDateTimeProps, ValidateDateTimeProps, ValidateDateTimePropsToDefault } from '../validation/validateDateTime';
+import { PickerValue } from '../internals/models';
+export declare function useDateTimeManager<TEnableAccessibleFieldDOMStructure extends boolean = true>(parameters?: UseDateTimeManagerParameters<TEnableAccessibleFieldDOMStructure>): UseDateTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure>;
+/**
+ * Private utility function to get the default internal props for the field with date time editing.
+ * Is used by the `useDateTimeManager` and `useDateTimeRangeManager` hooks.
+ */
+export declare function getDateTimeFieldInternalPropsDefaults(parameters: GetDateTimeFieldInternalPropsDefaultsParameters): GetDateTimeFieldInternalPropsDefaultsReturnValue;
+export interface UseDateTimeManagerParameters<TEnableAccessibleFieldDOMStructure extends boolean> {
+    enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
+}
+export type UseDateTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure extends boolean> = PickerManager<PickerValue, TEnableAccessibleFieldDOMStructure, DateTimeValidationError, DateTimeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>, DateTimeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure>>;
+export interface DateTimeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, DateTimeValidationError>, 'format'>, ExportedValidateDateTimeProps, AmPmProps {
+}
+interface DateTimeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure extends boolean> extends UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, DateTimeValidationError>, ValidateDateTimeProps {
+}
+type DateTimeManagerFieldPropsToDefault = 'format' | 'minTime' | 'maxTime' | ValidateDateTimePropsToDefault;
+interface GetDateTimeFieldInternalPropsDefaultsParameters extends Pick<MuiPickersAdapterContextValue, 'defaultDates' | 'utils'> {
+    internalProps: Pick<DateTimeManagerFieldInternalProps<true>, DateTimeManagerFieldPropsToDefault | 'minDateTime' | 'maxDateTime' | 'ampm'>;
+}
+interface GetDateTimeFieldInternalPropsDefaultsReturnValue extends Pick<DateTimeManagerFieldInternalPropsWithDefaults<true>, DateTimeManagerFieldPropsToDefault | 'disableIgnoringDatePartForTimeValidation'> {
+}
+export {};

package/managers/useDateTimeManager.js

@@ -0,0 +1,60 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { applyDefaultDate } from "../internals/utils/date-utils.js";
+import { singleItemFieldValueManager, singleItemValueManager } from "../internals/utils/valueManagers.js";
+import { validateDateTime } from "../validation/index.js";
+export function useDateTimeManager(parameters = {}) {
+  const {
+    enableAccessibleFieldDOMStructure = true
+  } = parameters;
+  return React.useMemo(() => ({
+    valueType: 'date-time',
+    validator: validateDateTime,
+    internal_valueManager: singleItemValueManager,
+    internal_fieldValueManager: singleItemFieldValueManager,
+    internal_enableAccessibleFieldDOMStructure: enableAccessibleFieldDOMStructure,
+    internal_applyDefaultsToFieldInternalProps: ({
+      internalProps,
+      utils,
+      defaultDates
+    }) => _extends({}, internalProps, getDateTimeFieldInternalPropsDefaults({
+      internalProps,
+      utils,
+      defaultDates
+    })),
+    internal_getOpenPickerButtonAriaLabel: ({
+      value,
+      utils,
+      localeText
+    }) => {
+      const formattedValue = utils.isValid(value) ? utils.format(value, 'fullDate') : null;
+      return localeText.openDatePickerDialogue(formattedValue);
+    }
+  }), [enableAccessibleFieldDOMStructure]);
+}
+
+/**
+ * Private utility function to get the default internal props for the field with date time editing.
+ * Is used by the `useDateTimeManager` and `useDateTimeRangeManager` hooks.
+ */
+export function getDateTimeFieldInternalPropsDefaults(parameters) {
+  const {
+    defaultDates,
+    utils,
+    internalProps
+  } = parameters;
+  const ampm = internalProps.ampm ?? utils.is12HourCycleInCurrentLocale();
+  const defaultFormat = ampm ? utils.formats.keyboardDateTime12h : utils.formats.keyboardDateTime24h;
+  return {
+    disablePast: internalProps.disablePast ?? false,
+    disableFuture: internalProps.disableFuture ?? false,
+    format: internalProps.format ?? defaultFormat,
+    disableIgnoringDatePartForTimeValidation: Boolean(internalProps.minDateTime || internalProps.maxDateTime),
+    minDate: applyDefaultDate(utils, internalProps.minDateTime ?? internalProps.minDate, defaultDates.minDate),
+    maxDate: applyDefaultDate(utils, internalProps.maxDateTime ?? internalProps.maxDate, defaultDates.maxDate),
+    minTime: internalProps.minDateTime ?? internalProps.minTime,
+    maxTime: internalProps.maxDateTime ?? internalProps.maxTime
+  };
+}

package/managers/useTimeManager.d.ts

@@ -0,0 +1,28 @@
+import type { MakeOptional } from '@mui/x-internals/types';
+import { PickerManager, TimeValidationError } from '../models';
+import { UseFieldInternalProps } from '../internals/hooks/useField';
+import { MuiPickersAdapterContextValue } from '../LocalizationProvider/LocalizationProvider';
+import { AmPmProps } from '../internals/models/props/time';
+import { ExportedValidateTimeProps, ValidateTimeProps, ValidateTimePropsToDefault } from '../validation/validateTime';
+import { PickerValue } from '../internals/models';
+export declare function useTimeManager<TEnableAccessibleFieldDOMStructure extends boolean = true>(parameters?: UseTimeManagerParameters<TEnableAccessibleFieldDOMStructure>): UseTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure>;
+/**
+ * Private utility function to get the default internal props for the fields with time editing.
+ * Is used by the `useTimeManager` and `useTimeRangeManager` hooks.
+ */
+export declare function getTimeFieldInternalPropsDefaults(parameters: GetTimeFieldInternalPropsDefaultsParameters): GetTimeFieldInternalPropsDefaultsReturnValue;
+export interface UseTimeManagerParameters<TEnableAccessibleFieldDOMStructure extends boolean> {
+    enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
+}
+export type UseTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure extends boolean> = PickerManager<PickerValue, TEnableAccessibleFieldDOMStructure, TimeValidationError, TimeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>, TimeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure>>;
+export interface TimeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, TimeValidationError>, 'format'>, ExportedValidateTimeProps, AmPmProps {
+}
+interface TimeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure extends boolean> extends UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, TimeValidationError>, ValidateTimeProps {
+}
+type TimeManagerFieldPropsToDefault = 'format' | ValidateTimePropsToDefault;
+interface GetTimeFieldInternalPropsDefaultsParameters extends Pick<MuiPickersAdapterContextValue, 'utils'> {
+    internalProps: Pick<TimeManagerFieldInternalProps<true>, TimeManagerFieldPropsToDefault | 'ampm'>;
+}
+interface GetTimeFieldInternalPropsDefaultsReturnValue extends Pick<TimeManagerFieldInternalPropsWithDefaults<true>, TimeManagerFieldPropsToDefault> {
+}
+export {};

package/managers/useTimeManager.js

@@ -0,0 +1,51 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { singleItemFieldValueManager, singleItemValueManager } from "../internals/utils/valueManagers.js";
+import { validateTime } from "../validation/index.js";
+export function useTimeManager(parameters = {}) {
+  const {
+    enableAccessibleFieldDOMStructure = true
+  } = parameters;
+  return React.useMemo(() => ({
+    valueType: 'time',
+    validator: validateTime,
+    internal_valueManager: singleItemValueManager,
+    internal_fieldValueManager: singleItemFieldValueManager,
+    internal_enableAccessibleFieldDOMStructure: enableAccessibleFieldDOMStructure,
+    internal_applyDefaultsToFieldInternalProps: ({
+      internalProps,
+      utils
+    }) => _extends({}, internalProps, getTimeFieldInternalPropsDefaults({
+      utils,
+      internalProps
+    })),
+    internal_getOpenPickerButtonAriaLabel: ({
+      value,
+      utils,
+      localeText
+    }) => {
+      const formattedValue = utils.isValid(value) ? utils.format(value, 'fullTime') : null;
+      return localeText.openTimePickerDialogue(formattedValue);
+    }
+  }), [enableAccessibleFieldDOMStructure]);
+}
+
+/**
+ * Private utility function to get the default internal props for the fields with time editing.
+ * Is used by the `useTimeManager` and `useTimeRangeManager` hooks.
+ */
+export function getTimeFieldInternalPropsDefaults(parameters) {
+  const {
+    utils,
+    internalProps
+  } = parameters;
+  const ampm = internalProps.ampm ?? utils.is12HourCycleInCurrentLocale();
+  const defaultFormat = ampm ? utils.formats.fullTime12h : utils.formats.fullTime24h;
+  return {
+    disablePast: internalProps.disablePast ?? false,
+    disableFuture: internalProps.disableFuture ?? false,
+    format: internalProps.format ?? defaultFormat
+  };
+}

package/models/adapters.d.ts

@@ -225,7 +225,7 @@ export interface MuiPickersAdapter<TLocale = any> {
      * @param {PickerValidDate | null} value The value to test.
      * @returns {boolean} `true` if the value is a valid date according to the date library.
      */
-    isValid(value: PickerValidDate | null): boolean;
+    isValid(value: PickerValidDate | null): value is PickerValidDate;
     /**
      * Format a date using an adapter format string (see the `AdapterFormats` interface)
      * @param {PickerValidDate} value The date to format.

package/models/fields.d.ts

@@ -1,11 +1,11 @@
 import * as React from 'react';
 import { TextFieldProps } from '@mui/material/TextField';
-import type { ExportedUseClearableFieldProps, UseClearableFieldResponse } from '../hooks/useClearableField';
 import type { ExportedPickersSectionListProps } from '../PickersSectionList';
 import type { UseFieldInternalProps, UseFieldResponse } from '../internals/hooks/useField';
 import type { PickersTextFieldProps } from '../PickersTextField';
 import { BaseForwardedSingleInputFieldProps, FieldRangeSection, PickerRangeValue, PickerValidValue } from '../internals/models';
 import { PickerOwnerState } from './pickers';
+import type { ExportedPickerFieldUIProps } from '../internals/components/PickerFieldUI';
 export type FieldSectionType = 'year' | 'month' | 'day' | 'weekDay' | 'hours' | 'minutes' | 'seconds' | 'meridiem' | 'empty';
 export type FieldSectionContentType = 'digit' | 'digit-with-letter' | 'letter';
 export interface FieldSection {
@@ -124,14 +124,14 @@ export interface FieldOwnerState extends PickerOwnerState {
 /**
  * Props the prop `slotProps.field` of a picker can receive.
  */
-export type PickerFieldSlotProps<TValue extends PickerValidValue, TEnableAccessibleFieldDOMStructure extends boolean> = ExportedUseClearableFieldProps & Pick<UseFieldInternalProps<TValue, TEnableAccessibleFieldDOMStructure, unknown>, 'shouldRespectLeadingZeros' | 'readOnly'> & React.HTMLAttributes<HTMLDivElement> & {
+export type PickerFieldSlotProps<TValue extends PickerValidValue, TEnableAccessibleFieldDOMStructure extends boolean> = ExportedPickerFieldUIProps & Pick<UseFieldInternalProps<TValue, TEnableAccessibleFieldDOMStructure, unknown>, 'shouldRespectLeadingZeros' | 'readOnly'> & React.HTMLAttributes<HTMLDivElement> & {
     ref?: React.Ref<HTMLDivElement>;
 };
 /**
- * Props the text field receives when used with a single input picker.
+ * Props the text field receives when used inside a single input picker.
  * Only contains what the MUI components are passing to the text field, not what users can pass using the `props.slotProps.field` and `props.slotProps.textField`.
  */
-export type BaseSingleInputPickersTextFieldProps<TEnableAccessibleFieldDOMStructure extends boolean> = UseClearableFieldResponse<UseFieldResponse<TEnableAccessibleFieldDOMStructure, BaseForwardedSingleInputFieldProps>>;
+export type BaseSingleInputPickersTextFieldProps<TEnableAccessibleFieldDOMStructure extends boolean> = Omit<UseFieldResponse<TEnableAccessibleFieldDOMStructure, BaseForwardedSingleInputFieldProps>, 'slots' | 'slotProps' | 'clearable' | 'onClear' | 'openPickerButtonPosition' | 'clearButtonPosition' | 'openPickerAriaLabel'>;
 /**
  * Props the built-in text field component can receive.
  */

package/models/index.d.ts

@@ -5,4 +5,5 @@ export * from './views';
 export * from './adapters';
 export * from './common';
 export * from './pickers';
+export * from './manager';
 export type { PropsFromSlot } from '@mui/x-internals/slots';

package/models/index.js

@@ -5,6 +5,7 @@ export * from "./views.js";
 export * from "./adapters.js";
 export * from "./common.js";
 export * from "./pickers.js";
+export * from "./manager.js";
 
 // Utils shared across the X packages
 export {};

package/models/manager.d.ts

@@ -0,0 +1,87 @@
+import type { FieldValueManager, UseFieldInternalProps } from '../internals/hooks/useField';
+import type { PickerValueManager } from '../internals/hooks/usePicker';
+import type { UseLocalizationContextReturnValue } from '../internals/hooks/useUtils';
+import type { PickerValidValue } from '../internals/models';
+import type { Validator } from '../validation';
+import type { PickerValueType } from './common';
+/**
+ * Object that contains all the necessary methods and properties to adapter a picker or a field for a given value type.
+ * You should never create your own manager.
+ * Instead, use the hooks exported from '@mui/x-date-pickers/managers' and '@mui/x-date-pickers-pro/managers'.
+ *
+ * ```tsx
+ * import { useDateManager } from '@mui/x-date-pickers/managers';
+ * import { useValidation } from '@mui/x-date-pickers/validation';
+ *
+ * const manager = useDateManager();
+ * const { hasValidationError } = useValidation({
+ *   validator: manager.validator,
+ *   value,
+ *   timezone,
+ *   props,
+ * });
+ * ```
+ */
+export interface PickerManager<TValue extends PickerValidValue, TEnableAccessibleFieldDOMStructure extends boolean, TError, TFieldInternalProps extends {}, TFieldInternalPropsWithDefaults extends UseFieldInternalProps<TValue, TEnableAccessibleFieldDOMStructure, TError>> {
+    /**
+     * The type of the value (e.g. 'date', 'date-time', 'time').
+     */
+    valueType: PickerValueType;
+    /**
+     * Checks if a value is valid and returns an error code otherwise.
+     * It can be passed to the `useValidation` hook to validate a value:
+     *
+     * ```tsx
+     * import { useDateManager } from '@mui/x-date-pickers/managers';
+     * import { useValidation } from '@mui/x-date-pickers/validation';
+     *
+     * const manager = useDateManager();
+     * const { hasValidationError } = useValidation({
+     *   validator: manager.validator,
+     *   value,
+     *   timezone,
+     *   props,
+     * });
+     * ```
+     */
+    validator: Validator<TValue, TError, TFieldInternalPropsWithDefaults>;
+    /**
+     * Object containing basic methods to interact with the value of the picker or field.
+     * This property is not part of the public API and should not be used directly.
+     */
+    internal_valueManager: PickerValueManager<TValue, TError>;
+    /**
+     * Object containing all the necessary methods to interact with the value of the field.
+     * This property is not part of the public API and should not be used directly.
+     */
+    internal_fieldValueManager: FieldValueManager<TValue>;
+    /**
+     * `true` if the field is using the accessible DOM structure.
+     * `false` if the field is using the non-accessible DOM structure.
+     * This property is not part of the public API and should not be used directly.
+     */
+    internal_enableAccessibleFieldDOMStructure: TEnableAccessibleFieldDOMStructure;
+    /**
+     * Applies the default values to the field internal props.
+     * This usually includes:
+     * - a default format to display the value in the field
+     * - some default validation props that are needed to validate the value (e.g: minDate, maxDate)
+     * This property is not part of the public API and should not be used directly.
+     * @param {ApplyDefaultsToFieldInternalPropsParameters<TFieldInternalProps>} parameters The parameters to apply the defaults.
+     * @returns {TFieldInternalPropsWithDefaults} The field internal props with the defaults applied.
+     */
+    internal_applyDefaultsToFieldInternalProps: (parameters: ApplyDefaultsToFieldInternalPropsParameters<TFieldInternalProps>) => TFieldInternalPropsWithDefaults;
+    /**
+     * Returns the aria-label to apply on the button that opens the picker.
+     * @param {GetOpenPickerButtonAriaLabelParameters<TValue>} params The parameters to get the aria-label.
+     * @returns {string} The aria-label to apply on the button that opens the picker.
+     */
+    internal_getOpenPickerButtonAriaLabel: (params: GetOpenPickerButtonAriaLabelParameters<TValue>) => string;
+}
+interface ApplyDefaultsToFieldInternalPropsParameters<TFieldInternalProps extends {}> extends UseLocalizationContextReturnValue {
+    internalProps: TFieldInternalProps;
+}
+interface GetOpenPickerButtonAriaLabelParameters<TValue extends PickerValidValue> extends UseLocalizationContextReturnValue {
+    value: TValue;
+}
+export {};

package/models/manager.js

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

package/models/pickers.d.ts

@@ -11,6 +11,13 @@ export interface PickerChangeHandlerContext<TError> {
 export interface PickerValidDateLookup {
 }
 export type PickerValidDate = keyof PickerValidDateLookup extends never ? any : PickerValidDateLookup[keyof PickerValidDateLookup];
+/**
+ * Importance of the change when picking a value:
+ * - "accept": fires `onChange`, fires `onAccept` and closes the picker.
+ * - "set": fires `onChange` but do not fire `onAccept` and does not close the picker.
+ * @default "accept"
+ */
+export type PickerChangeImportance = 'set' | 'accept';
 export interface PickerOwnerState {
     /**
      * `true` if the value of the picker is currently empty.