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

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

@@ -1,21 +1,20 @@
 import { UsePickerValueParams, UsePickerValueProps, UsePickerValueBaseProps, UsePickerValueResponse } from './usePickerValue.types';
 import { UsePickerViewsProps, UsePickerViewParams, UsePickerViewsResponse, UsePickerViewsBaseProps } from './usePickerViews';
-import { PickerOwnerState } from '../../../models';
+import { InferError, PickerOwnerState } from '../../../models';
 import { DateOrTimeViewWithMeridiem, PickerValidValue } from '../../models';
 import { UsePickerProviderParameters, UsePickerProviderProps, UsePickerProviderReturnValue } from './usePickerProvider';
 /**
  * Props common to all picker headless implementations.
  */
-export interface UsePickerBaseProps<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UsePickerViewsProps<TValue, TView, any, any>, TAdditionalProps extends {}> extends UsePickerValueBaseProps<TValue, TError>, UsePickerViewsBaseProps<TValue, TView, TExternalProps, TAdditionalProps>, UsePickerProviderProps {
+export interface UsePickerBaseProps<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UsePickerViewsProps<TValue, TView, any>> extends UsePickerValueBaseProps<TValue, TError>, UsePickerViewsBaseProps<TValue, TView, TExternalProps>, UsePickerProviderProps {
 }
-export interface UsePickerProps<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UsePickerViewsProps<TValue, TView, any, any>, TAdditionalProps extends {}> extends UsePickerValueProps<TValue, TError>, UsePickerViewsProps<TValue, TView, TExternalProps, TAdditionalProps>, UsePickerProviderProps {
+export interface UsePickerProps<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UsePickerViewsProps<TValue, TView, any>> extends UsePickerValueProps<TValue, TError>, UsePickerViewsProps<TValue, TView, TExternalProps>, UsePickerProviderProps {
 }
-export interface UsePickerParams<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UsePickerProps<TValue, TView, any, any, any>, TAdditionalProps extends {}> extends Pick<UsePickerValueParams<TValue, TExternalProps>, 'valueManager' | 'valueType' | 'variant' | 'validator'>, Pick<UsePickerViewParams<TValue, TView, TExternalProps, TAdditionalProps>, 'additionalViewProps' | 'autoFocusView' | 'rendererInterceptor' | 'fieldRef'>, Pick<UsePickerProviderParameters<TValue, TView>, 'localeText'> {
+export interface UsePickerParams<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UsePickerProps<TValue, TView, any, any>> extends Pick<UsePickerValueParams<TValue, TExternalProps>, 'valueManager' | 'valueType' | 'validator'>, Pick<UsePickerViewParams<TValue, TView, TExternalProps>, 'autoFocusView' | 'rendererInterceptor' | 'fieldRef'>, Pick<UsePickerProviderParameters<TValue, TView, InferError<TExternalProps>>, 'localeText' | 'variant'> {
     props: TExternalProps;
 }
 export interface UsePickerResponse<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError> extends Pick<UsePickerValueResponse<TValue, TError>, 'fieldProps'>, Pick<UsePickerViewsResponse<TView>, 'shouldRestoreFocus' | 'renderCurrentView'> {
     ownerState: PickerOwnerState;
-    providerProps: UsePickerProviderReturnValue;
-    layoutProps: UsePickerValueResponse<TValue, TError>['layoutProps'];
+    providerProps: UsePickerProviderReturnValue<TValue>;
     hasUIView: boolean;
 }

package/internals/hooks/usePicker/usePickerProvider.d.ts

@@ -4,15 +4,15 @@ import type { UsePickerProps } from './usePicker.types';
 import { DateOrTimeViewWithMeridiem, FormProps, PickerOrientation, PickerValidValue, PickerVariant } from '../../models';
 import { UsePickerViewsProviderParams } from './usePickerViews';
 export declare const usePickerOrientation: (views: readonly DateOrTimeViewWithMeridiem[], customOrientation: PickerOrientation | undefined) => PickerOrientation;
-export declare function usePickerProvider<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem>(parameters: UsePickerProviderParameters<TValue, TView>): UsePickerProviderReturnValue;
-export interface UsePickerProviderParameters<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem> extends Pick<PickerProviderProps, 'localeText'> {
-    props: UsePickerProps<TValue, any, any, any, any>;
+export declare function usePickerProvider<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError>(parameters: UsePickerProviderParameters<TValue, TView, TError>): UsePickerProviderReturnValue<TValue>;
+export interface UsePickerProviderParameters<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError> extends Pick<PickerProviderProps<TValue>, 'localeText'> {
+    props: UsePickerProps<TValue, any, any, any>;
     valueManager: PickerValueManager<TValue, any>;
     variant: PickerVariant;
-    paramsFromUsePickerValue: UsePickerValueProviderParams<TValue>;
+    paramsFromUsePickerValue: UsePickerValueProviderParams<TValue, TError>;
     paramsFromUsePickerViews: UsePickerViewsProviderParams<TView>;
 }
-export interface UsePickerProviderReturnValue extends Omit<PickerProviderProps, 'children'> {
+export interface UsePickerProviderReturnValue<TValue extends PickerValidValue> extends Omit<PickerProviderProps<TValue>, 'children'> {
 }
 /**
  * Props used to create the picker's contexts.

package/internals/hooks/usePicker/usePickerProvider.js

@@ -62,11 +62,13 @@ export function usePickerProvider(parameters) {
   const privateContextValue = React.useMemo(() => _extends({}, paramsFromUsePickerValue.privateContextValue, {
     ownerState
   }), [paramsFromUsePickerValue, ownerState]);
+  const actionsContextValue = React.useMemo(() => _extends({}, paramsFromUsePickerValue.actionsContextValue, paramsFromUsePickerViews.actionsContextValue), [paramsFromUsePickerValue.actionsContextValue, paramsFromUsePickerViews.actionsContextValue]);
   return {
     localeText,
     contextValue,
-    actionsContextValue: paramsFromUsePickerValue.actionsContextValue,
-    privateContextValue
+    privateContextValue,
+    actionsContextValue,
+    isValidContextValue: paramsFromUsePickerValue.isValidContextValue
   };
 }
 

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

@@ -4,4 +4,4 @@ import { PickerValidValue } from '../../models';
 /**
  * Manage the value lifecycle of all the pickers.
  */
-export declare const usePickerValue: <TValue extends PickerValidValue, TExternalProps extends UsePickerValueProps<TValue, any>>({ props, valueManager, valueType, variant, validator, }: UsePickerValueParams<TValue, TExternalProps>) => UsePickerValueResponse<TValue, InferError<TExternalProps>>;
+export declare const usePickerValue: <TValue extends PickerValidValue, TExternalProps extends UsePickerValueProps<TValue, any>>({ props, valueManager, valueType, validator, }: UsePickerValueParams<TValue, TExternalProps>) => UsePickerValueResponse<TValue, InferError<TExternalProps>>;

package/internals/hooks/usePicker/usePickerValue.js

@@ -5,106 +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.
  */
@@ -112,7 +12,6 @@ export const usePickerValue = ({
   props,
   valueManager,
   valueType,
-  variant,
   validator
 }) => {
   const {
@@ -120,7 +19,7 @@ export const usePickerValue = ({
     onChange,
     value: inValueWithoutRenderTimezone,
     defaultValue: inDefaultValue,
-    closeOnSelect = variant === 'desktop',
+    closeOnSelect = false,
     timezone: timezoneProp,
     referenceDate
   } = props;
@@ -200,43 +99,49 @@ 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
+    } = 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) {
+    if (changeImportance === 'accept') {
       setOpen(false);
     }
   });
@@ -251,33 +156,6 @@ export const usePickerValue = ({
       hasBeenModifiedSinceMount: true
     }));
   }
-  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 fieldResponse = {
-    value: dateState.draft,
-    onChange: handleChangeFromField
-  };
-  const valueWithoutError = React.useMemo(() => valueManager.cleanValue(utils, dateState.draft), [utils, valueManager, dateState.draft]);
-  const viewResponse = {
-    value: valueWithoutError,
-    onChange: handleChange,
-    open,
-    setOpen
-  };
   const isValid = testedValue => {
     const error = validator({
       adapter,
@@ -287,49 +165,54 @@ export const usePickerValue = ({
     });
     return !valueManager.hasError(error);
   };
-  const layoutResponse = {
-    value: valueWithoutError,
-    onChange: handleChange,
-    onSelectShortcut: handleSelectShortcut,
-    isValid
-  };
-  const clearValue = useEventCallback(() => updateDate({
-    value: valueManager.emptyValue,
-    name: 'setValueFromAction',
-    pickerAction: 'clear'
-  }));
-  const setValueToToday = useEventCallback(() => updateDate({
-    value: valueManager.getTodayValue(utils, timezone, valueType),
-    name: 'setValueFromAction',
-    pickerAction: 'today'
-  }));
-  const acceptValueChanges = useEventCallback(() => updateDate({
-    value: dateState.lastPublishedValue,
-    name: 'setValueFromAction',
-    pickerAction: 'accept'
-  }));
-  const cancelValueChanges = useEventCallback(() => updateDate({
-    value: dateState.lastCommittedValue,
-    name: 'setValueFromAction',
-    pickerAction: 'cancel'
+  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(() => {
-    updateDate({
-      value: dateState.lastPublishedValue,
-      name: 'setValueFromAction',
-      pickerAction: 'dismiss'
+    setValue(dateState.lastPublishedValue, {
+      skipPublicationIfPristine: true
     });
   });
+  const fieldResponse = {
+    value: dateState.draft,
+    onChange: (newValue, context) => setValue(newValue, {
+      validationError: context.validationError
+    })
+  };
+  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
-  }), [setOpen, clearValue, setValueToToday, acceptValueChanges, cancelValueChanges]);
+  }), [setValue, setOpen, clearValue, setValueToToday, acceptValueChanges, cancelValueChanges]);
   const contextValue = React.useMemo(() => _extends({}, actionsContextValue, {
-    open
-  }), [actionsContextValue, open]);
+    open,
+    value: dateState.draft
+  }), [actionsContextValue, open, dateState.draft]);
   const privateContextValue = React.useMemo(() => ({
     dismissViews
   }), [dismissViews]);
@@ -337,12 +220,12 @@ export const usePickerValue = ({
     value: valueWithoutError,
     contextValue,
     actionsContextValue,
-    privateContextValue
+    privateContextValue,
+    isValidContextValue: isValid
   };
   return {
     fieldProps: fieldResponse,
     viewProps: viewResponse,
-    layoutProps: layoutResponse,
     provider: providerParams
   };
 };

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

@@ -1,10 +1,9 @@
 import * as React from 'react';
-import { FieldChangeHandlerContext, UseFieldInternalProps } from '../useField';
+import { UseFieldInternalProps } from '../useField';
 import { Validator } from '../../../validation';
-import { PickerVariant } from '../../models/common';
-import { 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';
+import type { PickersShortcutsItemContext } from '../../../PickersShortcuts';
 import { InferNonNullablePickerValue, PickerValidValue } from '../../models';
 export interface PickerValueManager<TValue extends PickerValidValue, TError> {
     /**
@@ -137,37 +136,6 @@ export interface UsePickerValueState<TValue extends PickerValidValue> {
      */
     hasBeenModifiedSinceMount: boolean;
 }
-export interface PickerValueUpdaterParams<TValue extends PickerValidValue, TError> {
-    action: PickerValueUpdateAction<TValue, TError>;
-    dateState: UsePickerValueState<TValue>;
-    /**
-     * Check if the new draft value has changed compared to some given value.
-     * @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 {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 extends PickerValidValue, 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.
  */
@@ -204,8 +172,8 @@ export interface UsePickerValueBaseProps<TValue extends PickerValidValue, TError
  */
 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;
     /**
@@ -234,7 +202,6 @@ export interface UsePickerValueParams<TValue extends PickerValidValue, TExternal
     props: TExternalProps;
     valueManager: PickerValueManager<TValue, InferError<TExternalProps>>;
     valueType: PickerValueType;
-    variant: PickerVariant;
     validator: Validator<TValue, InferError<TExternalProps>, TExternalProps>;
 }
 export type UsePickerValueFieldResponse<TValue extends PickerValidValue, TError> = Required<Pick<UseFieldInternalProps<TValue, any, TError>, 'value' | 'onChange'>>;
@@ -247,37 +214,38 @@ export interface UsePickerValueViewsResponse<TValue extends PickerValidValue> {
     open: boolean;
     setOpen: React.Dispatch<React.SetStateAction<boolean>>;
 }
-/**
- * Props passed to `usePickerLayoutProps`.
- */
-export interface UsePickerValueLayoutResponse<TValue extends PickerValidValue> {
-    value: TValue;
-    onChange: (newValue: TValue) => void;
-    onSelectShortcut: (newValue: TValue, changeImportance: PickerShortcutChangeImportance, shortcut: PickersShortcutsItemContext) => void;
-    isValid: (value: TValue) => boolean;
-}
 /**
  * Params passed to `usePickerProvider`.
  */
-export interface UsePickerValueProviderParams<TValue extends PickerValidValue> {
+export interface UsePickerValueProviderParams<TValue extends PickerValidValue, TError> {
     value: TValue;
-    contextValue: UsePickerValueContextValue;
-    actionsContextValue: UsePickerValueActionsContextValue;
+    contextValue: UsePickerValueContextValue<TValue, TError>;
+    actionsContextValue: UsePickerValueActionsContextValue<TValue, TError>;
     privateContextValue: UsePickerValuePrivateContextValue;
+    isValidContextValue: (value: TValue) => boolean;
 }
 export interface UsePickerValueResponse<TValue extends PickerValidValue, TError> {
     viewProps: UsePickerValueViewsResponse<TValue>;
     fieldProps: UsePickerValueFieldResponse<TValue, TError>;
-    layoutProps: UsePickerValueLayoutResponse<TValue>;
-    provider: UsePickerValueProviderParams<TValue>;
+    provider: UsePickerValueProviderParams<TValue, TError>;
 }
-export interface UsePickerValueContextValue extends UsePickerValueActionsContextValue {
+export interface UsePickerValueContextValue<TValue extends PickerValidValue, TError> extends UsePickerValueActionsContextValue<TValue, TError> {
+    /**
+     * The current value of the picker.
+     */
+    value: TValue;
     /**
      * `true` if the picker is open, `false` otherwise.
      */
     open: boolean;
 }
-export interface UsePickerValueActionsContextValue {
+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
@@ -318,3 +286,29 @@ export interface UsePickerValuePrivateContextValue {
      */
     dismissViews: () => void;
 }
+export interface SetValueActionOptions<TError = string> {
+    /**
+     * 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 re-applied by the picker.
+     */
+    validationError?: TError;
+    /**
+     * The shortcut that triggered this change.
+     * Should not be defined if the change does not come from a shortcut.
+     */
+    shortcut?: PickersShortcutsItemContext;
+    /**
+     * Decide if 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;
+}