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

package/esm/internals/hooks/useReduceAnimations.js

@@ -0,0 +1,17 @@
+import useMediaQuery from '@mui/material/useMediaQuery';
+const PREFERS_REDUCED_MOTION = '@media (prefers-reduced-motion: reduce)';
+
+// detect if user agent has Android version < 10 or iOS version < 13
+const mobileVersionMatches = typeof navigator !== 'undefined' && navigator.userAgent.match(/android\s(\d+)|OS\s(\d+)/i);
+const androidVersion = mobileVersionMatches && mobileVersionMatches[1] ? parseInt(mobileVersionMatches[1], 10) : null;
+const iOSVersion = mobileVersionMatches && mobileVersionMatches[2] ? parseInt(mobileVersionMatches[2], 10) : null;
+export const slowAnimationDevices = androidVersion && androidVersion < 10 || iOSVersion && iOSVersion < 13 || false;
+export function useReduceAnimations(customReduceAnimations) {
+  const prefersReduced = useMediaQuery(PREFERS_REDUCED_MOTION, {
+    defaultMatches: false
+  });
+  if (customReduceAnimations != null) {
+    return customReduceAnimations;
+  }
+  return prefersReduced || slowAnimationDevices;
+}

package/esm/internals/hooks/useStaticPicker/index.d.ts

@@ -0,0 +1,2 @@
+export { useStaticPicker } from "./useStaticPicker.js";
+export type { UseStaticPickerSlots, UseStaticPickerSlotProps, StaticOnlyPickerProps } from './useStaticPicker.types';

package/esm/internals/hooks/useStaticPicker/index.js

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

package/esm/internals/hooks/useStaticPicker/useStaticPicker.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { UseStaticPickerParams, UseStaticPickerProps } from "./useStaticPicker.types.js";
+import { DateOrTimeViewWithMeridiem } from "../../models/index.js";
+/**
+ * Hook managing all the single-date static pickers:
+ * - StaticDatePicker
+ * - StaticDateTimePicker
+ * - StaticTimePicker
+ */
+export declare const useStaticPicker: <TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UseStaticPickerProps<TView, any, TExternalProps>>({
+  props,
+  ...pickerParams
+}: UseStaticPickerParams<TView, TExternalProps>) => {
+  renderPicker: () => React.JSX.Element;
+};

package/esm/internals/hooks/useStaticPicker/useStaticPicker.js

@@ -0,0 +1,63 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["props"];
+import * as React from 'react';
+import clsx from 'clsx';
+import { styled } from '@mui/material/styles';
+import { usePicker } from "../usePicker/index.js";
+import { PickerProvider } from "../../components/PickerProvider.js";
+import { PickersLayout } from "../../../PickersLayout/index.js";
+import { DIALOG_WIDTH } from "../../constants/dimensions.js";
+import { mergeSx } from "../../utils/utils.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const PickerStaticLayout = styled(PickersLayout)(({
+  theme
+}) => ({
+  overflow: 'hidden',
+  minWidth: DIALOG_WIDTH,
+  backgroundColor: (theme.vars || theme).palette.background.paper
+}));
+
+/**
+ * Hook managing all the single-date static pickers:
+ * - StaticDatePicker
+ * - StaticDateTimePicker
+ * - StaticTimePicker
+ */
+export const useStaticPicker = _ref => {
+  let {
+      props
+    } = _ref,
+    pickerParams = _objectWithoutPropertiesLoose(_ref, _excluded);
+  const {
+    localeText,
+    slots,
+    slotProps,
+    displayStaticWrapperAs,
+    autoFocus
+  } = props;
+  const {
+    providerProps,
+    renderCurrentView
+  } = usePicker(_extends({}, pickerParams, {
+    props,
+    variant: displayStaticWrapperAs,
+    autoFocusView: autoFocus ?? false,
+    viewContainerRole: null,
+    localeText
+  }));
+  const Layout = slots?.layout ?? PickerStaticLayout;
+  const renderPicker = () => /*#__PURE__*/_jsx(PickerProvider, _extends({}, providerProps, {
+    children: /*#__PURE__*/_jsx(Layout, _extends({}, slotProps?.layout, {
+      slots: slots,
+      slotProps: slotProps,
+      sx: mergeSx(providerProps.contextValue.rootSx, slotProps?.layout?.sx),
+      className: clsx(providerProps.contextValue.rootClassName, slotProps?.layout?.className),
+      ref: providerProps.contextValue.rootRef,
+      children: renderCurrentView()
+    }))
+  }));
+  return {
+    renderPicker
+  };
+};

package/esm/internals/hooks/useStaticPicker/useStaticPicker.types.d.ts

@@ -0,0 +1,40 @@
+import { ExportedPickersLayoutSlots, ExportedPickersLayoutSlotProps } from "../../../PickersLayout/PickersLayout.types.js";
+import { BasePickerProps } from "../../models/props/basePickerProps.js";
+import { UsePickerParams } from "../usePicker/index.js";
+import { UsePickerViewsProps } from "../usePicker/usePickerViews.js";
+import { DateOrTimeViewWithMeridiem, PickerValue } from "../../models/index.js";
+export interface UseStaticPickerSlots extends ExportedPickersLayoutSlots<PickerValue> {}
+export interface UseStaticPickerSlotProps extends ExportedPickersLayoutSlotProps<PickerValue> {}
+export interface StaticOnlyPickerProps {
+  /**
+   * Force static wrapper inner components to be rendered in mobile or desktop mode.
+   * @default "mobile"
+   */
+  displayStaticWrapperAs: 'desktop' | 'mobile';
+  /**
+   * If `true`, the view is focused during the first mount.
+   * @default false
+   */
+  autoFocus?: boolean;
+  /**
+   * Callback fired when component requests to be closed.
+   * Can be fired when selecting (by default on `desktop` mode) or clearing a value.
+   * @deprecated Please avoid using as it will be removed in next major version.
+   */
+  onClose?: () => void;
+}
+export interface UseStaticPickerProps<TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UsePickerViewsProps<PickerValue, TView, any>> extends BasePickerProps<PickerValue, TView, TError, TExternalProps>, StaticOnlyPickerProps {
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots?: UseStaticPickerSlots;
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps?: UseStaticPickerSlotProps;
+}
+export interface UseStaticPickerParams<TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UseStaticPickerProps<TView, any, TExternalProps>> extends Pick<UsePickerParams<PickerValue, TView, TExternalProps>, 'valueManager' | 'valueType' | 'validator' | 'ref'> {
+  props: TExternalProps;
+}

package/esm/internals/hooks/useStaticPicker/useStaticPicker.types.js

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

package/esm/internals/hooks/useToolbarOwnerState.d.ts

@@ -0,0 +1,10 @@
+import { PickerOwnerState } from "../../models/index.js";
+export declare function useToolbarOwnerState(): PickerToolbarOwnerState;
+export interface PickerToolbarOwnerState extends PickerOwnerState {
+  /**
+   * The direction of the toolbar.
+   * Is equal to "ltr" when the toolbar is in left-to-right direction.
+   * Is equal to "rtl" when the toolbar is in right-to-left direction.
+   */
+  toolbarDirection: 'ltr' | 'rtl';
+}

package/esm/internals/hooks/useToolbarOwnerState.js

@@ -0,0 +1,13 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { useRtl } from '@mui/system/RtlProvider';
+import { usePickerPrivateContext } from "./usePickerPrivateContext.js";
+export function useToolbarOwnerState() {
+  const {
+    ownerState: pickerOwnerState
+  } = usePickerPrivateContext();
+  const isRtl = useRtl();
+  return React.useMemo(() => _extends({}, pickerOwnerState, {
+    toolbarDirection: isRtl ? 'rtl' : 'ltr'
+  }), [pickerOwnerState, isRtl]);
+}

package/esm/internals/hooks/useUtils.d.ts

@@ -0,0 +1,13 @@
+import { MuiPickersAdapterContextValue } from "../../LocalizationProvider/LocalizationProvider.js";
+import { PickersLocaleText } from "../../locales/utils/pickersLocaleTextApi.js";
+import { PickersTimezone, PickerValidDate } from "../../models/index.js";
+export declare const useLocalizationContext: () => UseLocalizationContextReturnValue;
+export declare const useUtils: () => import("@mui/x-date-pickers/models").MuiPickersAdapter<any>;
+export declare const useDefaultDates: () => {
+  minDate: PickerValidDate;
+  maxDate: PickerValidDate;
+};
+export declare const useNow: (timezone: PickersTimezone) => PickerValidDate;
+export interface UseLocalizationContextReturnValue extends Omit<MuiPickersAdapterContextValue, 'localeText'> {
+  localeText: PickersLocaleText;
+}

package/esm/internals/hooks/useUtils.js

@@ -0,0 +1,27 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { MuiPickersAdapterContext } from "../../LocalizationProvider/LocalizationProvider.js";
+import { DEFAULT_LOCALE } from "../../locales/enUS.js";
+export const useLocalizationContext = () => {
+  const localization = React.useContext(MuiPickersAdapterContext);
+  if (localization === null) {
+    throw new Error(['MUI X: Can not find the date and time pickers localization context.', 'It looks like you forgot to wrap your component in LocalizationProvider.', 'This can also happen if you are bundling multiple versions of the `@mui/x-date-pickers` package'].join('\n'));
+  }
+  if (localization.utils === null) {
+    throw new Error(['MUI X: Can not find the date and time pickers adapter from its localization context.', 'It looks like you forgot to pass a `dateAdapter` to your LocalizationProvider.'].join('\n'));
+  }
+  const localeText = React.useMemo(() => _extends({}, DEFAULT_LOCALE, localization.localeText), [localization.localeText]);
+  return React.useMemo(() => _extends({}, localization, {
+    localeText
+  }), [localization, localeText]);
+};
+export const useUtils = () => useLocalizationContext().utils;
+export const useDefaultDates = () => useLocalizationContext().defaultDates;
+export const useNow = timezone => {
+  const utils = useUtils();
+  const now = React.useRef(undefined);
+  if (now.current === undefined) {
+    now.current = utils.date(undefined, timezone);
+  }
+  return now.current;
+};

package/esm/internals/hooks/useValueWithTimezone.d.ts

@@ -0,0 +1,53 @@
+import type { PickerValueManager } from './usePicker';
+import { PickersTimezone, PickerValidDate } from "../../models/index.js";
+import { PickerValidValue } from "../models/index.js";
+/**
+ * Hooks making sure that:
+ * - The value returned by `onChange` always have the timezone of `props.value` or `props.defaultValue` if defined
+ * - The value rendered is always the one from `props.timezone` if defined
+ */
+export declare const useValueWithTimezone: <TValue extends PickerValidValue, TChange extends (...params: any[]) => void>({
+  timezone: timezoneProp,
+  value: valueProp,
+  defaultValue,
+  referenceDate,
+  onChange,
+  valueManager
+}: UseValueWithTimezoneParameters<TValue, TChange>) => {
+  value: TValue;
+  handleValueChange: TChange;
+  timezone: string;
+};
+/**
+ * Wrapper around `useControlled` and `useValueWithTimezone`
+ */
+export declare const useControlledValueWithTimezone: <TValue extends PickerValidValue, TChange extends (...params: any[]) => void>({
+  name,
+  timezone: timezoneProp,
+  value: valueProp,
+  defaultValue,
+  referenceDate,
+  onChange: onChangeProp,
+  valueManager
+}: UseControlledValueWithTimezoneParameters<TValue, TChange>) => {
+  value: TValue;
+  handleValueChange: TChange;
+  timezone: string;
+};
+interface UseValueWithTimezoneParameters<TValue extends PickerValidValue, TChange extends (...params: any[]) => void> {
+  timezone: PickersTimezone | undefined;
+  value: TValue | undefined;
+  defaultValue: TValue | undefined;
+  /**
+   * The reference date as passed to `props.referenceDate`.
+   * It does not need to have its default value.
+   * This is only used to determine the timezone to use when `props.value` and `props.defaultValue` are not defined.
+   */
+  referenceDate: PickerValidDate | undefined;
+  onChange: TChange | undefined;
+  valueManager: PickerValueManager<TValue, any>;
+}
+interface UseControlledValueWithTimezoneParameters<TValue extends PickerValidValue, TChange extends (...params: any[]) => void> extends UseValueWithTimezoneParameters<TValue, TChange> {
+  name: string;
+}
+export {};

package/esm/internals/hooks/useValueWithTimezone.js

@@ -0,0 +1,80 @@
+import * as React from 'react';
+import useEventCallback from '@mui/utils/useEventCallback';
+import useControlled from '@mui/utils/useControlled';
+import { useUtils } from "./useUtils.js";
+/**
+ * Hooks making sure that:
+ * - The value returned by `onChange` always have the timezone of `props.value` or `props.defaultValue` if defined
+ * - The value rendered is always the one from `props.timezone` if defined
+ */
+export const useValueWithTimezone = ({
+  timezone: timezoneProp,
+  value: valueProp,
+  defaultValue,
+  referenceDate,
+  onChange,
+  valueManager
+}) => {
+  const utils = useUtils();
+  const firstDefaultValue = React.useRef(defaultValue);
+  const inputValue = valueProp ?? firstDefaultValue.current ?? valueManager.emptyValue;
+  const inputTimezone = React.useMemo(() => valueManager.getTimezone(utils, inputValue), [utils, valueManager, inputValue]);
+  const setInputTimezone = useEventCallback(newValue => {
+    if (inputTimezone == null) {
+      return newValue;
+    }
+    return valueManager.setTimezone(utils, inputTimezone, newValue);
+  });
+  let timezoneToRender;
+  if (timezoneProp) {
+    timezoneToRender = timezoneProp;
+  } else if (inputTimezone) {
+    timezoneToRender = inputTimezone;
+  } else if (referenceDate) {
+    timezoneToRender = utils.getTimezone(referenceDate);
+  } else {
+    timezoneToRender = 'default';
+  }
+  const valueWithTimezoneToRender = React.useMemo(() => valueManager.setTimezone(utils, timezoneToRender, inputValue), [valueManager, utils, timezoneToRender, inputValue]);
+  const handleValueChange = useEventCallback((newValue, ...otherParams) => {
+    const newValueWithInputTimezone = setInputTimezone(newValue);
+    onChange?.(newValueWithInputTimezone, ...otherParams);
+  });
+  return {
+    value: valueWithTimezoneToRender,
+    handleValueChange,
+    timezone: timezoneToRender
+  };
+};
+
+/**
+ * Wrapper around `useControlled` and `useValueWithTimezone`
+ */
+export const useControlledValueWithTimezone = ({
+  name,
+  timezone: timezoneProp,
+  value: valueProp,
+  defaultValue,
+  referenceDate,
+  onChange: onChangeProp,
+  valueManager
+}) => {
+  const [valueWithInputTimezone, setValue] = useControlled({
+    name,
+    state: 'value',
+    controlled: valueProp,
+    default: defaultValue ?? valueManager.emptyValue
+  });
+  const onChange = useEventCallback((newValue, ...otherParams) => {
+    setValue(newValue);
+    onChangeProp?.(newValue, ...otherParams);
+  });
+  return useValueWithTimezone({
+    timezone: timezoneProp,
+    value: valueWithInputTimezone,
+    defaultValue: undefined,
+    referenceDate,
+    onChange,
+    valueManager
+  });
+};

package/esm/internals/hooks/useViews.d.ts

@@ -0,0 +1,79 @@
+import { MakeOptional } from '@mui/x-internals/types';
+import type { PickerSelectionState } from './usePicker';
+import { DateOrTimeViewWithMeridiem, PickerValidValue } from "../models/index.js";
+import { PickerValidDate } from "../../models/index.js";
+export type PickerOnChangeFn = (date: PickerValidDate | null, selectionState?: PickerSelectionState) => void;
+export interface UseViewsOptions<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem> {
+  /**
+   * Callback fired when the value changes.
+   * @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.
+   * @template TView The view type. Will be one of date or time views.
+   * @param {TValue} value The new value.
+   * @param {PickerSelectionState | undefined} selectionState Indicates if the date selection is complete.
+   * @param {TView | undefined} selectedView Indicates the view in which the selection has been made.
+   */
+  onChange: (value: TValue, selectionState?: PickerSelectionState, selectedView?: TView) => void;
+  /**
+   * Callback fired on view change.
+   * @template TView
+   * @param {TView} view The new view.
+   */
+  onViewChange?: (view: TView) => void;
+  /**
+   * The default visible view.
+   * Used when the component view is not controlled.
+   * Must be a valid option from `views` list.
+   */
+  openTo?: TView;
+  /**
+   * The visible view.
+   * Used when the component view is controlled.
+   * Must be a valid option from `views` list.
+   */
+  view?: TView;
+  /**
+   * Available views.
+   */
+  views: readonly TView[];
+  /**
+   * If `true`, the main element is focused during the first mount.
+   * This main element is:
+   * - the element chosen by the visible view if any (i.e: the selected day on the `day` view).
+   * - the `input` element if there is a field rendered.
+   */
+  autoFocus?: boolean;
+  /**
+   * Controlled focused view.
+   */
+  focusedView?: TView | null;
+  /**
+   * Callback fired on focused view change.
+   * @template TView
+   * @param {TView} view The new view to focus or not.
+   * @param {boolean} hasFocus `true` if the view should be focused.
+   */
+  onFocusedViewChange?: (view: TView, hasFocus: boolean) => void;
+}
+export interface ExportedUseViewsOptions<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem> extends MakeOptional<UseViewsOptions<TValue, TView>, 'onChange' | 'openTo' | 'views'> {}
+interface UseViewsResponse<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem> {
+  view: TView;
+  setView: (view: TView) => void;
+  focusedView: TView | null;
+  setFocusedView: (view: TView, hasFocus: boolean) => void;
+  nextView: TView | null;
+  previousView: TView | null;
+  defaultView: TView;
+  goToNextView: () => void;
+  setValueAndGoToNextView: (value: TValue, currentViewSelectionState?: PickerSelectionState, selectedView?: TView) => void;
+}
+export declare function useViews<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem>({
+  onChange,
+  onViewChange,
+  openTo,
+  view: inView,
+  views,
+  autoFocus,
+  focusedView: inFocusedView,
+  onFocusedViewChange
+}: UseViewsOptions<TValue, TView>): UseViewsResponse<TValue, TView>;
+export {};

package/esm/internals/hooks/useViews.js

@@ -0,0 +1,113 @@
+import * as React from 'react';
+import useEventCallback from '@mui/utils/useEventCallback';
+import useControlled from '@mui/utils/useControlled';
+let warnedOnceNotValidView = false;
+export function useViews({
+  onChange,
+  onViewChange,
+  openTo,
+  view: inView,
+  views,
+  autoFocus,
+  focusedView: inFocusedView,
+  onFocusedViewChange
+}) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (!warnedOnceNotValidView) {
+      if (inView != null && !views.includes(inView)) {
+        console.warn(`MUI X: \`view="${inView}"\` is not a valid prop.`, `It must be an element of \`views=["${views.join('", "')}"]\`.`);
+        warnedOnceNotValidView = true;
+      }
+      if (inView == null && openTo != null && !views.includes(openTo)) {
+        console.warn(`MUI X: \`openTo="${openTo}"\` is not a valid prop.`, `It must be an element of \`views=["${views.join('", "')}"]\`.`);
+        warnedOnceNotValidView = true;
+      }
+    }
+  }
+  const previousOpenTo = React.useRef(openTo);
+  const previousViews = React.useRef(views);
+  const defaultView = React.useRef(views.includes(openTo) ? openTo : views[0]);
+  const [view, setView] = useControlled({
+    name: 'useViews',
+    state: 'view',
+    controlled: inView,
+    default: defaultView.current
+  });
+  const defaultFocusedView = React.useRef(autoFocus ? view : null);
+  const [focusedView, setFocusedView] = useControlled({
+    name: 'useViews',
+    state: 'focusedView',
+    controlled: inFocusedView,
+    default: defaultFocusedView.current
+  });
+  React.useEffect(() => {
+    // Update the current view when `openTo` or `views` props change
+    if (previousOpenTo.current && previousOpenTo.current !== openTo || previousViews.current && previousViews.current.some(previousView => !views.includes(previousView))) {
+      setView(views.includes(openTo) ? openTo : views[0]);
+      previousViews.current = views;
+      previousOpenTo.current = openTo;
+    }
+  }, [openTo, setView, view, views]);
+  const viewIndex = views.indexOf(view);
+  const previousView = views[viewIndex - 1] ?? null;
+  const nextView = views[viewIndex + 1] ?? null;
+  const handleFocusedViewChange = useEventCallback((viewToFocus, hasFocus) => {
+    if (hasFocus) {
+      // Focus event
+      setFocusedView(viewToFocus);
+    } else {
+      // Blur event
+      setFocusedView(prevFocusedView => viewToFocus === prevFocusedView ? null : prevFocusedView // If false the blur is due to view switching
+      );
+    }
+    onFocusedViewChange?.(viewToFocus, hasFocus);
+  });
+  const handleChangeView = useEventCallback(newView => {
+    // always keep the focused view in sync
+    handleFocusedViewChange(newView, true);
+    if (newView === view) {
+      return;
+    }
+    setView(newView);
+    if (onViewChange) {
+      onViewChange(newView);
+    }
+  });
+  const goToNextView = useEventCallback(() => {
+    if (nextView) {
+      handleChangeView(nextView);
+    }
+  });
+  const setValueAndGoToNextView = useEventCallback((value, currentViewSelectionState, selectedView) => {
+    const isSelectionFinishedOnCurrentView = currentViewSelectionState === 'finish';
+    const hasMoreViews = selectedView ?
+    // handles case like `DateTimePicker`, where a view might return a `finish` selection state
+    // but when it's not the final view given all `views` -> overall selection state should be `partial`.
+    views.indexOf(selectedView) < views.length - 1 : Boolean(nextView);
+    const globalSelectionState = isSelectionFinishedOnCurrentView && hasMoreViews ? 'partial' : currentViewSelectionState;
+    onChange(value, globalSelectionState, selectedView);
+    // Detects if the selected view is not the active one.
+    // Can happen if multiple views are displayed, like in `DesktopDateTimePicker` or `MultiSectionDigitalClock`.
+    if (selectedView && selectedView !== view) {
+      const nextViewAfterSelected = views[views.indexOf(selectedView) + 1];
+      if (nextViewAfterSelected) {
+        // move to next view after the selected one
+        handleChangeView(nextViewAfterSelected);
+      }
+    } else if (isSelectionFinishedOnCurrentView) {
+      goToNextView();
+    }
+  });
+  return {
+    view,
+    setView: handleChangeView,
+    focusedView,
+    setFocusedView: handleFocusedViewChange,
+    nextView,
+    previousView,
+    // Always return up-to-date default view instead of the initial one (i.e. defaultView.current)
+    defaultView: views.includes(openTo) ? openTo : views[0],
+    goToNextView,
+    setValueAndGoToNextView
+  };
+}

package/esm/internals/index.d.ts

@@ -0,0 +1,72 @@
+export { PickersArrowSwitcher } from "./components/PickersArrowSwitcher/PickersArrowSwitcher.js";
+export type { ExportedPickersArrowSwitcherProps, PickersArrowSwitcherSlots, PickersArrowSwitcherSlotProps } from './components/PickersArrowSwitcher';
+export { PickerFieldUI, PickerFieldUIContextProvider, cleanFieldResponse, useFieldTextFieldProps, PickerFieldUIContext, mergeSlotProps } from "./components/PickerFieldUI.js";
+export type { ExportedPickerFieldUIProps, PickerFieldUISlots, PickerFieldUISlotProps, PickerFieldUISlotsFromContext, PickerFieldUISlotPropsFromContext } from './components/PickerFieldUI';
+export { PickerProvider } from "./components/PickerProvider.js";
+export type { PickerContextValue } from './components/PickerProvider';
+export { PickersModalDialog } from "./components/PickersModalDialog.js";
+export type { PickersModalDialogSlots, PickersModalDialogSlotProps } from './components/PickersModalDialog';
+export { PickerPopper } from "./components/PickerPopper/PickerPopper.js";
+export type { PickerPopperSlots, PickerPopperSlotProps } from './components/PickerPopper/PickerPopper';
+export { PickersToolbar } from "./components/PickersToolbar.js";
+export type { PickersToolbarProps } from './components/PickersToolbar';
+export { pickersToolbarClasses } from "./components/pickersToolbarClasses.js";
+export type { PickersToolbarClassKey, PickersToolbarClasses } from './components/pickersToolbarClasses';
+export type { PickersToolbarButtonProps } from './components/PickersToolbarButton';
+export { pickersToolbarButtonClasses } from "./components/pickersToolbarButtonClasses.js";
+export type { PickersToolbarButtonClassKey, PickersToolbarButtonClasses } from './components/pickersToolbarButtonClasses';
+export type { PickersToolbarTextProps, ExportedPickersToolbarTextProps } from './components/PickersToolbarText';
+export { pickersToolbarTextClasses } from "./components/pickersToolbarTextClasses.js";
+export type { PickersToolbarTextClassKey, PickersToolbarTextClasses } from './components/pickersToolbarTextClasses';
+export { pickersArrowSwitcherClasses } from "./components/PickersArrowSwitcher/pickersArrowSwitcherClasses.js";
+export type { PickersArrowSwitcherClassKey, PickersArrowSwitcherClasses } from './components/PickersArrowSwitcher/pickersArrowSwitcherClasses';
+export { PickersToolbarButton } from "./components/PickersToolbarButton.js";
+export { DAY_MARGIN, DIALOG_WIDTH, VIEW_HEIGHT } from "./constants/dimensions.js";
+export { useControlledValueWithTimezone } from "./hooks/useValueWithTimezone.js";
+export type { DesktopOnlyPickerProps } from './hooks/useDesktopPicker';
+export { useField, useFieldInternalPropsWithDefaults, createDateStrForV7HiddenInputFromSections, createDateStrForV6InputFromSections } from "./hooks/useField/index.js";
+export type { UseFieldInternalProps, UseFieldParams, UseFieldResponse, FieldValueManager, FieldChangeHandler, FieldChangeHandlerContext } from './hooks/useField';
+export { useFieldOwnerState } from "./hooks/useFieldOwnerState.js";
+export type { MobileOnlyPickerProps } from './hooks/useMobilePicker';
+export { useNullableFieldPrivateContext } from "./hooks/useNullableFieldPrivateContext.js";
+export { useNullablePickerContext } from "./hooks/useNullablePickerContext.js";
+export { usePicker } from "./hooks/usePicker/index.js";
+export type { UsePickerParams, UsePickerProps, UsePickerValueFieldResponse, PickerViewsRendererProps } from './hooks/usePicker';
+export type { UsePickerValueContextValue, UsePickerValueNonStaticProps, PickerValueManager, PickerSelectionState } from './hooks/usePicker/usePickerValue.types';
+export type { PickerViewRendererLookup, PickerRendererInterceptorProps, PickerViewRenderer, UsePickerViewsProps } from './hooks/usePicker/usePickerViews';
+export type { UsePickerProviderNonStaticProps } from './hooks/usePicker/usePickerProvider';
+export { usePickerPrivateContext } from "./hooks/usePickerPrivateContext.js";
+export { useStaticPicker } from "./hooks/useStaticPicker/index.js";
+export type { StaticOnlyPickerProps, UseStaticPickerSlots, UseStaticPickerSlotProps } from './hooks/useStaticPicker';
+export { useToolbarOwnerState } from "./hooks/useToolbarOwnerState.js";
+export type { PickerToolbarOwnerState } from './hooks/useToolbarOwnerState';
+export { useLocalizationContext, useDefaultDates, useUtils, useNow } from "./hooks/useUtils.js";
+export type { ExportedUseViewsOptions, UseViewsOptions } from './hooks/useViews';
+export { useViews } from "./hooks/useViews.js";
+export { usePreviousMonthDisabled, useNextMonthDisabled } from "./hooks/date-helpers-hooks.js";
+export type { PickerAnyManager, PickerManagerFieldInternalProps, PickerManagerEnableAccessibleFieldDOMStructure, PickerManagerError } from './models/manager';
+export type { RangePosition } from './models/pickers';
+export type { BaseSingleInputFieldProps, FieldRangeSection } from './models/fields';
+export type { BasePickerProps, BasePickerInputProps } from './models/props/basePickerProps';
+export type { BaseClockProps, DesktopOnlyTimePickerProps, AmPmProps } from './models/props/time';
+export type { ExportedBaseTabsProps } from './models/props/tabs';
+export type { BaseToolbarProps, ExportedBaseToolbarProps } from './models/props/toolbar';
+export type { FormProps } from './models/formProps';
+export type { PickerVariant, TimeViewWithMeridiem, DateOrTimeViewWithMeridiem } from './models/common';
+export type { BaseDateValidationProps, BaseTimeValidationProps, TimeValidationProps, MonthValidationProps, YearValidationProps, DayValidationProps, DateTimeValidationProps } from './models/validation';
+export type { PickerValue, PickerRangeValue, PickerNonNullableRangeValue, InferNonNullablePickerValue, PickerValidValue } from './models/value';
+export { applyDefaultDate, replaceInvalidDateByNull, areDatesEqual, getTodayDate, isDatePickerView, mergeDateAndTime, formatMeridiem } from "./utils/date-utils.js";
+export { resolveTimeViewsResponse, resolveDateTimeFormat } from "./utils/date-time-utils.js";
+export { getDefaultReferenceDate } from "./utils/getDefaultReferenceDate.js";
+export { executeInTheNextEventLoopTick, getActiveElement, onSpaceOrEnter, mergeSx, DEFAULT_DESKTOP_MODE_MEDIA_QUERY } from "./utils/utils.js";
+export { useReduceAnimations } from "./hooks/useReduceAnimations.js";
+export { applyDefaultViewProps } from "./utils/views.js";
+export { DayCalendar } from "../DateCalendar/DayCalendar.js";
+export type { DayCalendarProps, DayCalendarSlots, DayCalendarSlotProps, ExportedDayCalendarProps } from '../DateCalendar/DayCalendar';
+export type { ExportedDateCalendarProps } from '../DateCalendar/DateCalendar.types';
+export { useCalendarState } from "../DateCalendar/useCalendarState.js";
+export { isInternalTimeView, isTimeView } from "./utils/time-utils.js";
+export { DateTimePickerToolbarOverrideContext } from "../DateTimePicker/DateTimePickerToolbar.js";
+export { getDateFieldInternalPropsDefaults } from "../managers/useDateManager.js";
+export { getTimeFieldInternalPropsDefaults } from "../managers/useTimeManager.js";
+export { getDateTimeFieldInternalPropsDefaults } from "../managers/useDateTimeManager.js";