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

package/internals/hooks/usePicker/usePickerValue.js

@@ -5,107 +5,6 @@ import { useOpenState } from "../useOpenState.js";
 import { useLocalizationContext, useUtils } from "../useUtils.js";
 import { useValidation } from "../../../validation/index.js";
 import { useValueWithTimezone } from "../useValueWithTimezone.js";
-
-/**
- * Decide if the new value should be published
- * The published value will be passed to `onChange` if defined.
- */
-const shouldPublishValue = params => {
-  const {
-    action,
-    hasChanged,
-    dateState,
-    isControlled
-  } = params;
-  const isCurrentValueTheDefaultValue = !isControlled && !dateState.hasBeenModifiedSinceMount;
-
-  // The field is responsible for only calling `onChange` when needed.
-  if (action.name === 'setValueFromField') {
-    return true;
-  }
-  if (action.name === 'setValueFromAction') {
-    // If the component is not controlled, and the value has not been modified since the mount,
-    // Then we want to publish the default value whenever the user pressed the "Accept", "Today" or "Clear" button.
-    if (isCurrentValueTheDefaultValue && ['accept', 'today', 'clear'].includes(action.pickerAction)) {
-      return true;
-    }
-    return hasChanged(dateState.lastPublishedValue);
-  }
-  if (action.name === 'setValueFromView' && action.selectionState !== 'shallow') {
-    // On the first view,
-    // If the value is not controlled, then clicking on any value (including the one equal to `defaultValue`) should call `onChange`
-    if (isCurrentValueTheDefaultValue) {
-      return true;
-    }
-    return hasChanged(dateState.lastPublishedValue);
-  }
-  if (action.name === 'setValueFromShortcut') {
-    // On the first view,
-    // If the value is not controlled, then clicking on any value (including the one equal to `defaultValue`) should call `onChange`
-    if (isCurrentValueTheDefaultValue) {
-      return true;
-    }
-    return hasChanged(dateState.lastPublishedValue);
-  }
-  return false;
-};
-
-/**
- * Decide if the new value should be committed.
- * The committed value will be passed to `onAccept` if defined.
- * It will also be used as a reset target when calling the `cancel` picker action (when clicking on the "Cancel" button).
- */
-const shouldCommitValue = params => {
-  const {
-    action,
-    hasChanged,
-    dateState,
-    isControlled,
-    closeOnSelect
-  } = params;
-  const isCurrentValueTheDefaultValue = !isControlled && !dateState.hasBeenModifiedSinceMount;
-  if (action.name === 'setValueFromAction') {
-    // If the component is not controlled, and the value has not been modified since the mount,
-    // Then we want to commit the default value whenever the user pressed the "Accept", "Today" or "Clear" button.
-    if (isCurrentValueTheDefaultValue && ['accept', 'today', 'clear'].includes(action.pickerAction)) {
-      return true;
-    }
-    return hasChanged(dateState.lastCommittedValue);
-  }
-  if (action.name === 'setValueFromView' && action.selectionState === 'finish' && closeOnSelect) {
-    // On picker where the 1st view is also the last view,
-    // If the value is not controlled, then clicking on any value (including the one equal to `defaultValue`) should call `onAccept`
-    if (isCurrentValueTheDefaultValue) {
-      return true;
-    }
-    return hasChanged(dateState.lastCommittedValue);
-  }
-  if (action.name === 'setValueFromShortcut') {
-    return action.changeImportance === 'accept' && hasChanged(dateState.lastCommittedValue);
-  }
-  return false;
-};
-
-/**
- * Decide if the picker should be closed after the value is updated.
- */
-const shouldClosePicker = params => {
-  const {
-    action,
-    closeOnSelect
-  } = params;
-  if (action.name === 'setValueFromAction') {
-    return true;
-  }
-  if (action.name === 'setValueFromView') {
-    return action.selectionState === 'finish' && closeOnSelect;
-  }
-  if (action.name === 'setValueFromShortcut') {
-    return action.changeImportance === 'accept';
-  }
-  return false;
-};
-
 /**
  * Manage the value lifecycle of all the pickers.
  */
@@ -113,7 +12,6 @@ export const usePickerValue = ({
   props,
   valueManager,
   valueType,
-  variant,
   validator
 }) => {
   const {
@@ -121,7 +19,7 @@ export const usePickerValue = ({
     onChange,
     value: inValueWithoutRenderTimezone,
     defaultValue: inDefaultValue,
-    closeOnSelect = variant === 'desktop',
+    closeOnSelect = false,
     timezone: timezoneProp,
     referenceDate
   } = props;
@@ -151,8 +49,8 @@ export const usePickerValue = ({
   const utils = useUtils();
   const adapter = useLocalizationContext();
   const {
-    isOpen,
-    setIsOpen
+    open,
+    setOpen
   } = useOpenState(props);
   const {
     timezone,
@@ -201,44 +99,51 @@ export const usePickerValue = ({
     value: dateState.draft,
     onError: props.onError
   });
-  const updateDate = useEventCallback(action => {
-    const updaterParams = {
-      action,
-      dateState,
-      hasChanged: comparison => !valueManager.areValuesEqual(utils, action.value, comparison),
-      isControlled,
-      closeOnSelect
-    };
-    const shouldPublish = shouldPublishValue(updaterParams);
-    const shouldCommit = shouldCommitValue(updaterParams);
-    const shouldClose = shouldClosePicker(updaterParams);
+  const setValue = useEventCallback((newValue, options) => {
+    const {
+      changeImportance = 'accept',
+      skipPublicationIfPristine = false,
+      validationError,
+      shortcut,
+      shouldClose = changeImportance === 'accept'
+    } = options ?? {};
+    let shouldPublish;
+    let shouldCommit;
+    if (!skipPublicationIfPristine && !isControlled && !dateState.hasBeenModifiedSinceMount) {
+      // If the value is not controlled and the value has never been modified before,
+      // Then clicking on any value (including the one equal to `defaultValue`) should call `onChange` and `onAccept`
+      shouldPublish = true;
+      shouldCommit = changeImportance === 'accept';
+    } else {
+      shouldPublish = !valueManager.areValuesEqual(utils, newValue, dateState.lastPublishedValue);
+      shouldCommit = changeImportance === 'accept' && !valueManager.areValuesEqual(utils, newValue, dateState.lastCommittedValue);
+    }
     setDateState(prev => _extends({}, prev, {
-      draft: action.value,
-      lastPublishedValue: shouldPublish ? action.value : prev.lastPublishedValue,
-      lastCommittedValue: shouldCommit ? action.value : prev.lastCommittedValue,
+      draft: newValue,
+      lastPublishedValue: shouldPublish ? newValue : prev.lastPublishedValue,
+      lastCommittedValue: shouldCommit ? newValue : prev.lastCommittedValue,
       hasBeenModifiedSinceMount: true
     }));
     let cachedContext = null;
     const getContext = () => {
       if (!cachedContext) {
-        const validationError = action.name === 'setValueFromField' ? action.context.validationError : getValidationErrorForNewValue(action.value);
         cachedContext = {
-          validationError
+          validationError: validationError == null ? getValidationErrorForNewValue(newValue) : validationError
         };
-        if (action.name === 'setValueFromShortcut') {
-          cachedContext.shortcut = action.shortcut;
+        if (shortcut) {
+          cachedContext.shortcut = shortcut;
         }
       }
       return cachedContext;
     };
     if (shouldPublish) {
-      handleValueChange(action.value, getContext());
+      handleValueChange(newValue, getContext());
     }
     if (shouldCommit && onAccept) {
-      onAccept(action.value, getContext());
+      onAccept(newValue, getContext());
     }
     if (shouldClose) {
-      setIsOpen(false);
+      setOpen(false);
     }
   });
   if (dateState.lastControlledValue !== inValueWithoutRenderTimezone) {
@@ -252,85 +157,6 @@ export const usePickerValue = ({
       hasBeenModifiedSinceMount: true
     }));
   }
-  const handleClear = useEventCallback(() => {
-    updateDate({
-      value: valueManager.emptyValue,
-      name: 'setValueFromAction',
-      pickerAction: 'clear'
-    });
-  });
-  const handleAccept = useEventCallback(() => {
-    updateDate({
-      value: dateState.lastPublishedValue,
-      name: 'setValueFromAction',
-      pickerAction: 'accept'
-    });
-  });
-  const handleDismiss = useEventCallback(() => {
-    updateDate({
-      value: dateState.lastPublishedValue,
-      name: 'setValueFromAction',
-      pickerAction: 'dismiss'
-    });
-  });
-  const handleCancel = useEventCallback(() => {
-    updateDate({
-      value: dateState.lastCommittedValue,
-      name: 'setValueFromAction',
-      pickerAction: 'cancel'
-    });
-  });
-  const handleSetToday = useEventCallback(() => {
-    updateDate({
-      value: valueManager.getTodayValue(utils, timezone, valueType),
-      name: 'setValueFromAction',
-      pickerAction: 'today'
-    });
-  });
-  const handleOpen = useEventCallback(event => {
-    event.preventDefault();
-    setIsOpen(true);
-  });
-  const handleClose = useEventCallback(event => {
-    event?.preventDefault();
-    setIsOpen(false);
-  });
-  const handleChange = useEventCallback((newValue, selectionState = 'partial') => updateDate({
-    name: 'setValueFromView',
-    value: newValue,
-    selectionState
-  }));
-  const handleSelectShortcut = useEventCallback((newValue, changeImportance, shortcut) => updateDate({
-    name: 'setValueFromShortcut',
-    value: newValue,
-    changeImportance,
-    shortcut
-  }));
-  const handleChangeFromField = useEventCallback((newValue, context) => updateDate({
-    name: 'setValueFromField',
-    value: newValue,
-    context
-  }));
-  const actions = {
-    onClear: handleClear,
-    onAccept: handleAccept,
-    onDismiss: handleDismiss,
-    onCancel: handleCancel,
-    onSetToday: handleSetToday,
-    onOpen: handleOpen,
-    onClose: handleClose
-  };
-  const fieldResponse = {
-    value: dateState.draft,
-    onChange: handleChangeFromField
-  };
-  const viewValue = React.useMemo(() => valueManager.cleanValue(utils, dateState.draft), [utils, valueManager, dateState.draft]);
-  const viewResponse = {
-    value: viewValue,
-    onChange: handleChange,
-    onClose: handleClose,
-    open: isOpen
-  };
   const isValid = testedValue => {
     const error = validator({
       adapter,
@@ -340,17 +166,61 @@ export const usePickerValue = ({
     });
     return !valueManager.hasError(error);
   };
-  const layoutResponse = _extends({}, actions, {
-    value: viewValue,
-    onChange: handleChange,
-    onSelectShortcut: handleSelectShortcut,
-    isValid
+  const clearValue = useEventCallback(() => setValue(valueManager.emptyValue));
+  const setValueToToday = useEventCallback(() => setValue(valueManager.getTodayValue(utils, timezone, valueType)));
+  const acceptValueChanges = useEventCallback(() => setValue(dateState.lastPublishedValue));
+  const cancelValueChanges = useEventCallback(() => setValue(dateState.lastCommittedValue, {
+    skipPublicationIfPristine: true
+  }));
+  const dismissViews = useEventCallback(() => {
+    setValue(dateState.lastPublishedValue, {
+      skipPublicationIfPristine: true
+    });
+  });
+  const setValueFromView = useEventCallback((newValue, selectionState = 'partial') => {
+    // TODO: Expose a new method (private?) like `setView` that only updates the draft value.
+    if (selectionState === 'shallow') {
+      setDateState(prev => _extends({}, prev, {
+        draft: newValue,
+        hasBeenModifiedSinceMount: true
+      }));
+    }
+    setValue(newValue, {
+      changeImportance: selectionState === 'finish' && closeOnSelect ? 'accept' : 'set'
+    });
   });
+  const valueWithoutError = React.useMemo(() => valueManager.cleanValue(utils, dateState.draft), [utils, valueManager, dateState.draft]);
+  const viewResponse = {
+    value: valueWithoutError,
+    onChange: setValueFromView,
+    open,
+    setOpen
+  };
+  const actionsContextValue = React.useMemo(() => ({
+    setValue,
+    setOpen,
+    clearValue,
+    setValueToToday,
+    acceptValueChanges,
+    cancelValueChanges
+  }), [setValue, setOpen, clearValue, setValueToToday, acceptValueChanges, cancelValueChanges]);
+  const contextValue = React.useMemo(() => _extends({}, actionsContextValue, {
+    value: dateState.draft,
+    timezone,
+    open
+  }), [actionsContextValue, timezone, open, dateState.draft]);
+  const privateContextValue = React.useMemo(() => ({
+    dismissViews
+  }), [dismissViews]);
+  const providerParams = {
+    value: dateState.draft,
+    contextValue,
+    actionsContextValue,
+    privateContextValue,
+    isValidContextValue: isValid
+  };
   return {
-    open: isOpen,
-    fieldProps: fieldResponse,
     viewProps: viewResponse,
-    layoutProps: layoutResponse,
-    actions
+    provider: providerParams
   };
 };

package/internals/hooks/usePicker/usePickerValue.types.d.ts

@@ -1,13 +1,14 @@
-import { FieldChangeHandlerContext, UseFieldInternalProps } from '../useField';
+import * as React from 'react';
+import { UseFieldInternalProps } from '../useField';
 import { Validator } from '../../../validation';
-import { PickerVariant } from '../../models/common';
-import { FieldSection, TimezoneProps, MuiPickersAdapter, PickersTimezone, PickerChangeHandlerContext, PickerValidDate, OnErrorProps, InferError, PickerValueType } from '../../../models';
+import { TimezoneProps, MuiPickersAdapter, PickersTimezone, PickerChangeHandlerContext, PickerValidDate, OnErrorProps, InferError, PickerValueType, PickerChangeImportance } from '../../../models';
 import { GetDefaultReferenceDateProps } from '../../utils/getDefaultReferenceDate';
-import { PickerShortcutChangeImportance, PickersShortcutsItemContext } from '../../../PickersShortcuts';
-export interface PickerValueManager<TValue, TError> {
+import type { PickersShortcutsItemContext } from '../../../PickersShortcuts';
+import { InferNonNullablePickerValue, PickerValidValue } from '../../models';
+export interface PickerValueManager<TValue extends PickerValidValue, TError> {
     /**
      * Determines if two values are equal.
-     * @template TValue
+     * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
      * @param {MuiPickersAdapter} utils The adapter.
      * @param {TValue} valueLeft The first value to compare.
      * @param {TValue} valueRight The second value to compare.
@@ -20,7 +21,7 @@ export interface PickerValueManager<TValue, TError> {
     emptyValue: TValue;
     /**
      * Method returning the value to set when clicking the "Today" button
-     * @template TValue
+     * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
      * @param {MuiPickersAdapter} utils The adapter.
      * @param {PickersTimezone} timezone The current timezone.
      * @param {PickerValueType} valueType The type of the value being edited.
@@ -28,7 +29,7 @@ export interface PickerValueManager<TValue, TError> {
      */
     getTodayValue: (utils: MuiPickersAdapter, timezone: PickersTimezone, valueType: PickerValueType) => TValue;
     /**
-     * @template TValue
+     * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
      * Method returning the reference value to use when mounting the component.
      * @param {object} params The params of the method.
      * @param {PickerValidDate | undefined} params.referenceDate The referenceDate provided by the user.
@@ -48,10 +49,10 @@ export interface PickerValueManager<TValue, TError> {
         granularity: number;
         timezone: PickersTimezone;
         getTodayDate?: () => PickerValidDate;
-    }) => TValue;
+    }) => InferNonNullablePickerValue<TValue>;
     /**
      * Method parsing the input value to replace all invalid dates by `null`.
-     * @template TValue
+     * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
      * @param {MuiPickersAdapter} utils The adapter.
      * @param {TValue} value The value to parse.
      * @returns {TValue} The value without invalid date.
@@ -59,7 +60,7 @@ export interface PickerValueManager<TValue, TError> {
     cleanValue: (utils: MuiPickersAdapter, value: TValue) => TValue;
     /**
      * Generates the new value, given the previous value and the new proposed value.
-     * @template TValue
+     * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
      * @param {MuiPickersAdapter} utils The adapter.
      * @param {TValue} lastValidDateValue The last valid value.
      * @param {TValue} value The proposed value.
@@ -88,7 +89,7 @@ export interface PickerValueManager<TValue, TError> {
     /**
      * Return the timezone of the date inside a value.
      * Throw an error on range picker if both values don't have the same timezone.
-     @template TValue
+     * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
      @param {MuiPickersAdapter} utils The utils to manipulate the date.
      @param {TValue} value The current value.
      @returns {string | null} The timezone of the current value.
@@ -96,7 +97,7 @@ export interface PickerValueManager<TValue, TError> {
     getTimezone: (utils: MuiPickersAdapter, value: TValue) => string | null;
     /**
      * Change the timezone of the dates inside a value.
-     @template TValue
+     * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
      @param {MuiPickersAdapter} utils The utils to manipulate the date.
      @param {PickersTimezone} timezone The current timezone.
      @param {TValue} value The value to convert.
@@ -105,19 +106,19 @@ export interface PickerValueManager<TValue, TError> {
     setTimezone: (utils: MuiPickersAdapter, timezone: PickersTimezone, value: TValue) => TValue;
 }
 export type PickerSelectionState = 'partial' | 'shallow' | 'finish';
-export interface UsePickerValueState<TValue> {
+export interface UsePickerValueState<TValue extends PickerValidValue> {
     /**
      * Date displayed on the views and the field.
      * It is updated whenever the user modifies something.
      */
     draft: TValue;
     /**
-     * Last value published (e.g: the last value for which `shouldPublishValue` returned `true`).
+     * Last value published (the last value for which `shouldPublishValue` returned `true`).
      * If `onChange` is defined, it's the value that was passed on the last call to this callback.
      */
     lastPublishedValue: TValue;
     /**
-     * Last value committed (e.g: the last value for which `shouldCommitValue` returned `true`).
+     * Last value committed (the last value for which `shouldCommitValue` returned `true`).
      * If `onAccept` is defined, it's the value that was passed on the last call to this callback.
      */
     lastCommittedValue: TValue;
@@ -135,41 +136,10 @@ export interface UsePickerValueState<TValue> {
      */
     hasBeenModifiedSinceMount: boolean;
 }
-export interface PickerValueUpdaterParams<TValue, TError> {
-    action: PickerValueUpdateAction<TValue, TError>;
-    dateState: UsePickerValueState<TValue>;
-    /**
-     * Check if the new draft value has changed compared to some given value.
-     * @template TValue
-     * @param {TValue} comparisonValue The value to compare the new draft value with.
-     * @returns {boolean} `true` if the new draft value is equal to the comparison value.
-     */
-    hasChanged: (comparisonValue: TValue) => boolean;
-    isControlled: boolean;
-    closeOnSelect: boolean;
-}
-export type PickerValueUpdateAction<TValue, TError> = {
-    name: 'setValueFromView';
-    value: TValue;
-    selectionState: PickerSelectionState;
-} | {
-    name: 'setValueFromField';
-    value: TValue;
-    context: FieldChangeHandlerContext<TError>;
-} | {
-    name: 'setValueFromAction';
-    value: TValue;
-    pickerAction: 'accept' | 'today' | 'cancel' | 'dismiss' | 'clear';
-} | {
-    name: 'setValueFromShortcut';
-    value: TValue;
-    changeImportance: PickerShortcutChangeImportance;
-    shortcut: PickersShortcutsItemContext;
-};
 /**
  * Props used to handle the value that are common to all pickers.
  */
-export interface UsePickerValueBaseProps<TValue, TError> extends OnErrorProps<TValue, TError> {
+export interface UsePickerValueBaseProps<TValue extends PickerValidValue, TError> extends OnErrorProps<TValue, TError> {
     /**
      * The selected value.
      * Used when the component is controlled.
@@ -202,8 +172,8 @@ export interface UsePickerValueBaseProps<TValue, TError> extends OnErrorProps<TV
  */
 export interface UsePickerValueNonStaticProps {
     /**
-     * If `true`, the popover or modal will close after submitting the full date.
-     * @default `true` for desktop, `false` for mobile (based on the chosen wrapper and `desktopModeMediaQuery` prop).
+     * If `true`, the Picker will close after submitting the full date.
+     * @default false
      */
     closeOnSelect?: boolean;
     /**
@@ -225,48 +195,133 @@ export interface UsePickerValueNonStaticProps {
 /**
  * Props used to handle the value of the pickers.
  */
-export interface UsePickerValueProps<TValue, TError> extends UsePickerValueBaseProps<TValue, TError>, UsePickerValueNonStaticProps, TimezoneProps {
+export interface UsePickerValueProps<TValue extends PickerValidValue, TError> extends UsePickerValueBaseProps<TValue, TError>, UsePickerValueNonStaticProps, TimezoneProps {
     referenceDate?: PickerValidDate;
 }
-export interface UsePickerValueParams<TValue, TExternalProps extends UsePickerValueProps<TValue, any>> {
+export interface UsePickerValueParams<TValue extends PickerValidValue, TExternalProps extends UsePickerValueProps<TValue, any>> {
     props: TExternalProps;
     valueManager: PickerValueManager<TValue, InferError<TExternalProps>>;
     valueType: PickerValueType;
-    variant: PickerVariant;
     validator: Validator<TValue, InferError<TExternalProps>, TExternalProps>;
 }
-export interface UsePickerValueActions {
-    onAccept: () => void;
-    onClear: () => void;
-    onDismiss: () => void;
-    onCancel: () => void;
-    onSetToday: () => void;
-    onOpen: (event: React.UIEvent) => void;
-    onClose: (event?: React.UIEvent) => void;
-}
-export type UsePickerValueFieldResponse<TValue, TSection extends FieldSection, TError> = Required<Pick<UseFieldInternalProps<TValue, TSection, any, TError>, 'value' | 'onChange'>>;
+export type UsePickerValueFieldResponse<TValue extends PickerValidValue, TError> = Required<Pick<UseFieldInternalProps<TValue, any, TError>, 'value' | 'onChange'>>;
 /**
  * Props passed to `usePickerViews`.
  */
-export interface UsePickerValueViewsResponse<TValue> {
+export interface UsePickerValueViewsResponse<TValue extends PickerValidValue> {
     value: TValue;
     onChange: (value: TValue, selectionState?: PickerSelectionState) => void;
     open: boolean;
-    onClose: (event?: React.MouseEvent) => void;
+    setOpen: React.Dispatch<React.SetStateAction<boolean>>;
 }
 /**
- * Props passed to `usePickerLayoutProps`.
+ * Params passed to `usePickerProvider`.
  */
-export interface UsePickerValueLayoutResponse<TValue> extends UsePickerValueActions {
+export interface UsePickerValueProviderParams<TValue extends PickerValidValue, TError> {
     value: TValue;
-    onChange: (newValue: TValue) => void;
-    onSelectShortcut: (newValue: TValue, changeImportance: PickerShortcutChangeImportance, shortcut: PickersShortcutsItemContext) => void;
-    isValid: (value: TValue) => boolean;
+    contextValue: UsePickerValueContextValue<TValue, TError>;
+    actionsContextValue: UsePickerValueActionsContextValue<TValue, TError>;
+    privateContextValue: UsePickerValuePrivateContextValue;
+    isValidContextValue: (value: TValue) => boolean;
 }
-export interface UsePickerValueResponse<TValue, TSection extends FieldSection, TError> {
-    open: boolean;
-    actions: UsePickerValueActions;
+export interface UsePickerValueResponse<TValue extends PickerValidValue, TError> {
     viewProps: UsePickerValueViewsResponse<TValue>;
-    fieldProps: UsePickerValueFieldResponse<TValue, TSection, TError>;
-    layoutProps: UsePickerValueLayoutResponse<TValue>;
+    provider: UsePickerValueProviderParams<TValue, TError>;
+}
+export interface UsePickerValueContextValue<TValue extends PickerValidValue, TError> extends UsePickerValueActionsContextValue<TValue, TError> {
+    /**
+     * The current value of the picker.
+     */
+    value: TValue;
+    /**
+     * The timezone to use when rendering the dates.
+     * If a `timezone` prop is provided, it will be used.
+     * If the `value` prop contains a valid date, its timezone will be used.
+     * If no `value` prop is provided, but the `defaultValue` contains a valid date, its timezone will be used.
+     * If no `value` or `defaultValue` is provided, but the `referenceDate` is provided, its timezone will be used.
+     * Otherwise, the timezone will be the default one of your date library.
+     */
+    timezone: PickersTimezone;
+    /**
+     * Whether the picker is open.
+     */
+    open: boolean;
+}
+export interface UsePickerValueActionsContextValue<TValue extends PickerValidValue, TError> {
+    /**
+     * Set the current value of the picker.
+     * @param {TValue} value The new value of the picker.
+     * @param {SetValueActionOptions<TError>} options The options to customize the behavior of this update.
+     */
+    setValue: (value: TValue, options?: SetValueActionOptions<TError>) => void;
+    /**
+     * Set the current open state of the Picker.
+     * ```ts
+     * setOpen(true); // Opens the picker.
+     * setOpen(false); // Closes the picker.
+     * setOpen((prevOpen) => !prevOpen); // Toggles the open state.
+     * ```
+     * @param {React.SetStateAction<boolean>} action The new open state of the Picker.
+     * It can be a function that will receive the current open state.
+     */
+    setOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    /**
+     * Set the current value of the picker to be empty.
+     * The value will be `null` on single pickers and `[null, null]` on range pickers.
+     */
+    clearValue: () => void;
+    /**
+     * Set the current value of the picker to be the current date.
+     * The value will be `today` on single pickers and `[today, today]` on range pickers.
+     * With `today` being the current date, with its time set to `00:00:00` on Date Pickers and its time set to the current time on Time and Date Pickers.
+     */
+    setValueToToday: () => void;
+    /**
+     * Accept the current value of the picker.
+     * Will call `onAccept` if defined.
+     * If the picker is re-opened, this value will be the one used to initialize the views.
+     */
+    acceptValueChanges: () => void;
+    /**
+     * Cancel the changes made to the current value of the picker.
+     * The value will be reset to the last accepted value.
+     */
+    cancelValueChanges: () => void;
+}
+export interface UsePickerValuePrivateContextValue {
+    /**
+     * Close the picker and accepts the current value if it is not equal to the last accepted value.
+     */
+    dismissViews: () => void;
+}
+export interface SetValueActionOptions<TError = string | null> {
+    /**
+     * The 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"
+     */
+    changeImportance?: PickerChangeImportance;
+    /**
+     * The validation error associated to the current value.
+     * If not defined, the validation will be computed by the picker.
+     */
+    validationError?: TError;
+    /**
+     * The shortcut that triggered this change.
+     * It should not be defined if the change does not come from a shortcut.
+     */
+    shortcut?: PickersShortcutsItemContext;
+    /**
+     * Whether the value should call `onChange` and `onAccept` when the value is not controlled and has never been modified.
+     * If `true`, the `onChange` and `onAccept` callback will only be fired if the value has been modified (and is not equal to the last published value).
+     * If `false`, the `onChange` and `onAccept` callback will be fired when the value has never been modified (`onAccept` only if `changeImportance` is set to "accept").
+     * @default false
+     */
+    skipPublicationIfPristine?: boolean;
+    /**
+     * Whether the picker should close.
+     * @default changeImportance === "accept"
+     */
+    shouldClose?: boolean;
 }