@elliemae/ds-controlled-form 2.4.1-rc.7 → 2.4.2-rc.0

package/types/date-time-picker/ControlledDateTimePicker.d.ts

@@ -1,87 +1,32 @@
 /// <reference path="../../../../../shared/typings/react-desc.d.ts" />
 /// <reference types="react" />
-import type { DateTimePickerPropsT } from './index.d';
+import type { DSControlledDateTimePickerT } from './propTypes';
 declare const DSControlledDateTimePicker: {
-    (props: DateTimePickerPropsT): JSX.Element;
+    (props: DSControlledDateTimePickerT.Props): JSX.Element;
     propTypes: {
-        type: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        disabled: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        isClearable: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        dateTime: {
-            defaultValue(arg: import("react-desc").ReactDescPossibleDefaultValues): {
-                deprecated: import("react-desc").PropTypesDescValidator;
-            };
-            isRequired: import("react-desc").PropTypesDescValue;
-        };
-        date: {
-            defaultValue(arg: import("react-desc").ReactDescPossibleDefaultValues): {
-                deprecated: import("react-desc").PropTypesDescValidator;
-            };
-            isRequired: import("react-desc").PropTypesDescValue;
-        };
-        time: {
-            defaultValue(arg: import("react-desc").ReactDescPossibleDefaultValues): {
-                deprecated: import("react-desc").PropTypesDescValidator;
-            };
-            isRequired: import("react-desc").PropTypesDescValue;
-        };
-        onDateChange: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        onTimeChange: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        onDateTimeChange: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        onMonthChange: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        onDayChange: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        onYearChange: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        onHourChange: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        onMinuteChange: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        onMeridiemChange: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        getIsDisabledDay: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        getIsOutOfRangeDay: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        getIsDisabledTime: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        emptyPickerStartingMonth: {
-            defaultValue(arg: import("react-desc").ReactDescPossibleDefaultValues): {
-                deprecated: import("react-desc").PropTypesDescValidator;
-            };
-            isRequired: import("react-desc").PropTypesDescValue;
-        };
-        onCalendarOpenFocusedDay: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        minutesInterval: {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        'data-testid': {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
+        type: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        disabled: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        isClearable: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        dateTime: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        date: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        time: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        onDateChange: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        onTimeChange: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        onDateTimeChange: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        onMonthChange: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        onDayChange: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        onYearChange: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        onHourChange: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        onMinuteChange: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        onMeridiemChange: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        getIsDisabledDay: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        getIsOutOfRangeDay: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        getIsDisabledTime: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        emptyPickerStartingMonth: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        onCalendarOpenFocusedDay: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        onTimeWheelOpenStartingTime: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        minutesInterval: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+        'data-testid': import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
     };
 };
 declare const DSControlledDateTimePickerWithSchema: {

package/types/date-time-picker/ControlledDateTimePickerCTX.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="react" />
-import type { ControlledDateTimePickerContextT, PropsWithDefaultsT } from './index.d';
-export declare const defaultProps: PropsWithDefaultsT;
+import type { ControlledDateTimePickerContextT } from './config/useControlledDateTimePicker';
 /** Context for cross component communication */
 export declare const ControlledDateTimePickerContext: import("react").Context<ControlledDateTimePickerContextT>;
 export default ControlledDateTimePickerContext;

package/types/date-time-picker/ControlledDateTimePickerDatatestid.d.ts

@@ -1,55 +1,55 @@
 export declare const ControlledDateTimePickerDatatestid: {
-    DATE_INPUTS: {
-        MONTH: string;
-        DAY: string;
-        YEAR: string;
+    readonly DATE_INPUTS: {
+        readonly MONTH: "ds-controlled-date-time-picker-month-input";
+        readonly DAY: "ds-controlled-date-time-picker-day-input";
+        readonly YEAR: "ds-controlled-date-time-picker-year-input";
     };
-    TIME_INPUTS: {
-        HOUR: string;
-        MINUTE: string;
-        MERIDIEM: string;
+    readonly TIME_INPUTS: {
+        readonly HOUR: "ds-controlled-date-time-picker-hour-input";
+        readonly MINUTE: "ds-controlled-date-time-picker-minute-input";
+        readonly MERIDIEM: "ds-controlled-date-time-picker-meridiem-input";
     };
-    PICKER_ICONS: {
-        CALENDAR: string;
-        TIMEWHEEL: string;
-        CALENDAR_TIMEWHEEL: string;
+    readonly PICKER_ICONS: {
+        readonly CALENDAR: "ds-controlled-date-time-picker-calendar-trigger-icon";
+        readonly TIMEWHEEL: "ds-controlled-date-time-picker-timewheel-trigger-icon";
+        readonly CALENDAR_TIMEWHEEL: "ds-controlled-date-time-picker-calendar-timewheel-trigger-icon";
     };
-    CALENDAR: {
-        PREV_YEAR: string;
-        PREV_MONTH: string;
-        DAY: string;
-        FOCUSED_DAY: string;
-        START_RANGE_DAY: string;
-        IN_RANGE_DAY: string;
-        END_RANGE_DAY: string;
-        SELECTED_DAY: string;
-        SELECTED_FOCUSED_DAY: string;
-        NEXT_MONTH: string;
-        NEXT_YEAR: string;
+    readonly CALENDAR: {
+        readonly PREV_YEAR: "ds-controlled-date-time-picker-calendar-prev-year";
+        readonly PREV_MONTH: "ds-controlled-date-time-picker-calendar-prev-month";
+        readonly DAY: "ds-controlled-date-time-picker-calendar-day";
+        readonly FOCUSED_DAY: "ds-controlled-date-time-picker-calendar-focused-day";
+        readonly START_RANGE_DAY: "ds-controlled-date-time-picker-calendar-start-range-day";
+        readonly IN_RANGE_DAY: "ds-controlled-date-time-picker-calendar-in-range-day";
+        readonly END_RANGE_DAY: "ds-controlled-date-time-picker-calendar-end-range-day";
+        readonly SELECTED_DAY: "ds-controlled-date-time-picker-calendar-selected-day";
+        readonly SELECTED_FOCUSED_DAY: "ds-controlled-date-time-picker-calendar-selected-focused-day";
+        readonly NEXT_MONTH: "ds-controlled-date-time-picker-calendar-next-month";
+        readonly NEXT_YEAR: "ds-controlled-date-time-picker-calendar-next-year";
     };
-    TIMEWHEEL: {
-        PREV_HOUR: string;
-        HOUR: string;
-        CURRENT_HOUR: string;
-        NEXT_HOUR: string;
-        PREV_MINUTE: string;
-        MINUTE: string;
-        CURRENT_MINUTE: string;
-        NEXT_MINUTE: string;
-        PREV_MERIDIEM: string;
-        MERIDIEM: string;
-        CURRENT_MERIDIEM: string;
-        NEXT_MERIDIEM: string;
+    readonly TIMEWHEEL: {
+        readonly PREV_HOUR: "ds-controlled-date-time-picker-timewheel-prev-hour";
+        readonly HOUR: "ds-controlled-date-time-picker-timewheel-hour";
+        readonly CURRENT_HOUR: "ds-controlled-date-time-picker-timewheel-current-hour";
+        readonly NEXT_HOUR: "ds-controlled-date-time-picker-timewheel-next-hour";
+        readonly PREV_MINUTE: "ds-controlled-date-time-picker-timewheel-prev-minute";
+        readonly MINUTE: "ds-controlled-date-time-picker-timewheel-minute";
+        readonly CURRENT_MINUTE: "ds-controlled-date-time-picker-timewheel-current-minute";
+        readonly NEXT_MINUTE: "ds-controlled-date-time-picker-timewheel-next-minute";
+        readonly PREV_MERIDIEM: "ds-controlled-date-time-picker-timewheel-prev-meridiem";
+        readonly MERIDIEM: "ds-controlled-date-time-picker-timewheel-meridiem";
+        readonly CURRENT_MERIDIEM: "ds-controlled-date-time-picker-timewheel-current-meridiem";
+        readonly NEXT_MERIDIEM: "ds-controlled-date-time-picker-timewheel-next-meridiem";
     };
-    CONTEXTUAL_MENU: {
-        CALENDAR: string;
-        TIMEWHEEL: string;
-        CALENDAR_TIMEWHEEL: string;
+    readonly CONTEXTUAL_MENU: {
+        readonly CALENDAR: "ds-controlled-date-time-picker-calendar-context-content-wrapper";
+        readonly TIMEWHEEL: "ds-controlled-date-time-picker-timewheel-context-content-wrapper";
+        readonly CALENDAR_TIMEWHEEL: "ds-controlled-date-time-picker-calendar-timewheel-context-content-wrapper";
     };
-    CONTROLLER_COMPONENT: {
-        CALENDAR: string;
-        TIMEWHEEL: string;
-        CALENDAR_TIMEWHEEL: string;
+    readonly CONTROLLER_COMPONENT: {
+        readonly CALENDAR: "ds-controlled-date-time-picker-calendar-controller-wrapper";
+        readonly TIMEWHEEL: "ds-controlled-date-time-picker-timewheel-controller-wrapper";
+        readonly CALENDAR_TIMEWHEEL: "ds-controlled-date-time-picker-calendar-timewheel-controller-wrapper";
     };
-    CLEAR_BUTTON: string;
+    readonly CLEAR_BUTTON: "ds-controlled-date-time-picker-clear-btn";
 };

package/types/date-time-picker/ControlledDateTimePickerTypes.d.ts

@@ -1,20 +1,20 @@
 export declare const CONTROLLED_DATE_TIME_PICKER_TYPES: {
-    DATE_TIME: {
-        FULL: "full-date-time";
-        CONTROLLER_ONLY: "date-time-picker-controller-only";
-        PICKER: "date-time-picker";
-        INPUTS: "date-time-inputs";
+    readonly DATE_TIME: {
+        readonly FULL: "full-date-time";
+        readonly CONTROLLER_ONLY: "date-time-picker-controller-only";
+        readonly PICKER: "date-time-picker";
+        readonly INPUTS: "date-time-inputs";
     };
-    DATE: {
-        FULL: "full-date";
-        CONTROLLER_ONLY: "date-picker-controller-only";
-        PICKER: "date-picker";
-        INPUTS: "date-inputs";
+    readonly DATE: {
+        readonly FULL: "full-date";
+        readonly CONTROLLER_ONLY: "date-picker-controller-only";
+        readonly PICKER: "date-picker";
+        readonly INPUTS: "date-inputs";
     };
-    TIME: {
-        FULL: "full-time";
-        CONTROLLER_ONLY: "time-picker-controller-only";
-        PICKER: "time-picker";
-        INPUTS: "time-inputs";
+    readonly TIME: {
+        readonly FULL: "full-time";
+        readonly CONTROLLER_ONLY: "time-picker-controller-only";
+        readonly PICKER: "time-picker";
+        readonly INPUTS: "time-inputs";
     };
 };

package/types/date-time-picker/config/useChangeHandlers.d.ts

@@ -0,0 +1,25 @@
+import { useRelevantValueFromProps } from './useRelevantValueFromProps';
+import { useGetDestructuredValues } from './useGetDestructuredValues';
+import { useGetPropsBasedOnType } from './useGetPropsBasedOnType';
+import { useGetReferences } from './useGetReferences';
+import type { DSControlledDateTimePickerT } from '../propTypes';
+import type { DSControlledDateTimePickerInternalsT } from '../sharedTypes';
+interface Config {
+    relevantValues: ReturnType<typeof useRelevantValueFromProps>;
+    destructuredValues: ReturnType<typeof useGetDestructuredValues>;
+    propsBasedOnType: ReturnType<typeof useGetPropsBasedOnType>;
+    DOMRefs: ReturnType<typeof useGetReferences>;
+}
+export declare const useChangeHandlers: ({ relevantValues, destructuredValues, propsBasedOnType, DOMRefs }: Config) => {
+    handleChangeComposedDateTimeString: (newDateString: string, newTimeString: string, metaInfo: DSControlledDateTimePickerT.InternalInputsChangeMetaInfo) => void;
+    handleChangeComposedDateString: (newDateString: string, metaInfo: Partial<DSControlledDateTimePickerT.InternalInputsChangeMetaInfo>) => void;
+    handleChangeComposedTimeString: (newTimeString: string, metaInfo: Partial<DSControlledDateTimePickerT.InternalInputsChangeMetaInfo>) => void;
+    handleChangeMonth: DSControlledDateTimePickerT.OnInternalInputsChange;
+    handleChangeDay: DSControlledDateTimePickerT.OnInternalInputsChange;
+    handleChangeYear: DSControlledDateTimePickerT.OnInternalInputsChange;
+    handleChangeHours: DSControlledDateTimePickerT.OnInternalInputsChange;
+    handleChangeMinutes: DSControlledDateTimePickerT.OnInternalInputsChange;
+    handleChangeMeridiem: DSControlledDateTimePickerT.OnInternalInputsChange;
+    handleClearAll: DSControlledDateTimePickerInternalsT.OnDSBtnClick;
+};
+export {};

package/types/date-time-picker/config/useControlledDateTimePicker.d.ts

@@ -1,2 +1,18 @@
-import type { DateTimePickerPropsT, ControlledDateTimePickerContextT } from '../index.d';
-export declare const useControlledDateTimePicker: (props: Partial<DateTimePickerPropsT>) => ControlledDateTimePickerContextT;
+import React from 'react';
+import { useGetFlags } from './useGetFlags';
+import { useGetReferences } from './useGetReferences';
+import { useRelevantValueFromProps } from './useRelevantValueFromProps';
+import { useGetPropsBasedOnType } from './useGetPropsBasedOnType';
+import { useGetDestructuredValues } from './useGetDestructuredValues';
+import { useChangeHandlers } from './useChangeHandlers';
+import { useGlobalKeyHandlers } from './useGlobalKeyHandlers';
+import type { DSControlledDateTimePickerT } from '../propTypes';
+export declare type LatestInteractionRegion = 'calendar-days' | 'calendar-head' | 'timewheel' | 'date-inputs' | 'time-inputs' | 'clear-btn' | '';
+export declare type ControlledDateTimePickerContextT = ReturnType<typeof useGetFlags> & ReturnType<typeof useGetReferences> & ReturnType<typeof useGetPropsBasedOnType> & ReturnType<typeof useRelevantValueFromProps> & ReturnType<typeof useGetDestructuredValues> & ReturnType<typeof useChangeHandlers> & ReturnType<typeof useGlobalKeyHandlers> & {
+    props: DSControlledDateTimePickerT.InternalProps;
+    ariaCurrentValueForInputs: string;
+    dataAttrs: Record<string, string>;
+    latestInteractionRegion: LatestInteractionRegion;
+    setLatestInteractionRegion: React.Dispatch<React.SetStateAction<LatestInteractionRegion>>;
+};
+export declare const useControlledDateTimePicker: (props: DSControlledDateTimePickerT.Props) => ControlledDateTimePickerContextT;

package/types/date-time-picker/config/useGetDestructuredValues.d.ts

@@ -1,4 +1,30 @@
-import type { useGetDestructuredDateValuesAT, useGetDestructuredDateValuesRT, useGetDestructuredTimeValuesAT, useGetDestructuredTimeValuesRT, useGetDestructuredValuesAT, useGetDestructuredValuesRT } from '../index.d';
-export declare const useGetDestructuredDateValues: ({ date, dateTime, isDateTimeSelector, }: useGetDestructuredDateValuesAT) => useGetDestructuredDateValuesRT;
-export declare const useGetDestructuredTimeValues: ({ time, dateTime, isDateTimeSelector, }: useGetDestructuredTimeValuesAT) => useGetDestructuredTimeValuesRT;
-export declare const useGetDestructuredValues: ({ date, time, dateTime, isDateTimeSelector, }: useGetDestructuredValuesAT) => useGetDestructuredValuesRT;
+import { useGetFlags } from './useGetFlags';
+import { useGetPropsBasedOnType } from './useGetPropsBasedOnType';
+declare type UseGetDestructuredDateValues = (config: ReturnType<typeof useGetPropsBasedOnType> & ReturnType<typeof useGetFlags>) => {
+    month: string;
+    day: string;
+    year: string;
+    monthNum: number;
+    dayNum: number;
+    yearNum: number;
+    announcedMonth: string;
+    announcedDay: string;
+    announcedYear: string;
+    announcedDateValues: string;
+};
+export declare const useGetDestructuredDateValues: UseGetDestructuredDateValues;
+declare type UseGetDestructuredTimeValues = (config: ReturnType<typeof useGetPropsBasedOnType> & ReturnType<typeof useGetFlags>) => {
+    hours: string;
+    minutes: string;
+    meridiem: string;
+    hoursNum: number;
+    minutesNum: number;
+    announcedHours: string;
+    announcedMinutes: string;
+    announcedMeridiem: string;
+    announcedTimeValues: string;
+};
+export declare const useGetDestructuredTimeValues: UseGetDestructuredTimeValues;
+declare type UseGetDestructuredValues = (config: ReturnType<typeof useGetPropsBasedOnType> & ReturnType<typeof useGetFlags>) => ReturnType<typeof useGetDestructuredDateValues> & ReturnType<typeof useGetDestructuredTimeValues>;
+export declare const useGetDestructuredValues: UseGetDestructuredValues;
+export {};

package/types/date-time-picker/config/useGetFlags.d.ts

@@ -0,0 +1,27 @@
+import type { DSControlledDateTimePickerT } from '../propTypes';
+export declare const useGetFlags: (props: DSControlledDateTimePickerT.InternalProps) => {
+    hideDatePicker: boolean;
+    hideTimePicker: boolean;
+    isDateSelector: boolean;
+    isTimeSelector: boolean;
+    isDateTimeSelector: boolean;
+    isWithDateInputsOnly: boolean;
+    isWithTimeInputsOnly: boolean;
+    autoFocusHourInput: boolean;
+    autoFocusHourTimeWheel: boolean;
+    hideDate: boolean;
+    hideTime: boolean;
+    hideDateTimePicker: boolean;
+    isControllerOnly: boolean;
+    isWithTimeWheelToo: boolean;
+    isWithCalendarToo: boolean;
+    withAnyInputs: boolean;
+    withAnyPicker: boolean;
+    withClearBtn: boolean;
+    isWithDateInputs: boolean;
+    isWithTimeInputs: boolean;
+    autoFocusMonthInput: boolean;
+    autoFocusPrevMonthArrow: boolean;
+    shouldPreserveClearableSpace: boolean;
+    withAnyRightController: boolean;
+};

package/types/date-time-picker/config/useGetPropsBasedOnType.d.ts

@@ -0,0 +1,28 @@
+import type { DSControlledDateTimePickerT } from '../propTypes';
+export declare const useGetPropsBasedOnType: (propsWithDefaults: DSControlledDateTimePickerT.InternalProps) => {
+    getIsDisabledDay: any;
+    getIsOutOfRangeDay: any;
+    getIsStartRangeDay: any;
+    getIsDayInRange: any;
+    getIsEndRangeDay: any;
+    appOnDateChange: DSControlledDateTimePickerT.OnDateChange;
+    appOnMonthChange: DSControlledDateTimePickerT.OnInternalInputsChange;
+    appOnDayChange: DSControlledDateTimePickerT.OnInternalInputsChange;
+    appOnYearChange: DSControlledDateTimePickerT.OnInternalInputsChange;
+    appDate: string;
+    getIsDisabledTime: any;
+    appOnTimeChange: DSControlledDateTimePickerT.OnTimeChange;
+    appOnHourChange: DSControlledDateTimePickerT.OnInternalInputsChange;
+    appOnMinuteChange: DSControlledDateTimePickerT.OnInternalInputsChange;
+    appOnMeridiemChange: DSControlledDateTimePickerT.OnInternalInputsChange;
+    appTime: string;
+    appDateTime: string;
+    appOnDateTimeChange: DSControlledDateTimePickerT.OnDateTimeChange;
+    emptyPickerStartingMonth: string;
+    onCalendarOpenFocusedDay: string | undefined;
+    minutesInterval: number;
+    onTimeWheelOpenStartingTime: string;
+    isDate: boolean;
+    isTime: boolean;
+    isDateTime: boolean;
+};

package/types/date-time-picker/config/useGetPropsWithDefault.d.ts

@@ -1,2 +1,2 @@
-import { PropsWithDefaultsT } from '../index.d';
-export declare const useGetDatePickerWithDefaultsProps: (props: Partial<PropsWithDefaultsT>) => PropsWithDefaultsT;
+import { DSControlledDateTimePickerT } from '../propTypes';
+export declare const useGetDatePickerWithDefaultsProps: (props: DSControlledDateTimePickerT.Props) => DSControlledDateTimePickerT.InternalProps;

package/types/date-time-picker/config/useGetReferences.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="react" />
+import { useGetFlags } from './useGetFlags';
+export declare const useGetReferences: ({ isWithDateInputs, isWithTimeInputs, withAnyPicker, withClearBtn, }: ReturnType<typeof useGetFlags>) => {
+    monthInputRef: import("react").RefObject<HTMLInputElement>;
+    dayInputRef: import("react").RefObject<HTMLInputElement>;
+    yearInputRef: import("react").RefObject<HTMLInputElement>;
+    hourInputRef: import("react").RefObject<HTMLInputElement>;
+    minutesInputRef: import("react").RefObject<HTMLInputElement>;
+    meridiemInputRef: import("react").RefObject<HTMLInputElement>;
+    clearButtonRef: import("react").RefObject<HTMLButtonElement>;
+    pickerButtonRef: import("react").RefObject<HTMLButtonElement>;
+    prevYearBtnRef: import("react").RefObject<HTMLButtonElement>;
+    prevMonthBtnRef: import("react").RefObject<HTMLButtonElement>;
+    nextMonthBtnRef: import("react").RefObject<HTMLButtonElement>;
+    nextYearBtnRef: import("react").RefObject<HTMLButtonElement>;
+    calendarDaysWrapperRef: import("react").RefObject<HTMLDivElement>;
+    prevHourBtnRef: import("react").RefObject<HTMLButtonElement>;
+    currHourBtnRef: import("react").RefObject<HTMLButtonElement>;
+    nextHourBtnRef: import("react").RefObject<HTMLButtonElement>;
+    prevMinutesBtnRef: import("react").RefObject<HTMLButtonElement>;
+    currMinutesBtnRef: import("react").RefObject<HTMLButtonElement>;
+    nextMinutesBtnRef: import("react").RefObject<HTMLButtonElement>;
+    prevMeridiemBtnRef: import("react").RefObject<HTMLButtonElement>;
+    currMeridiemBtnRef: import("react").RefObject<HTMLButtonElement>;
+    nextMeridiemBtnRef: import("react").RefObject<HTMLButtonElement>;
+    firstSegmentRef: import("react").RefObject<HTMLInputElement | HTMLButtonElement>;
+    lastSegmentRef: import("react").RefObject<HTMLInputElement | HTMLButtonElement>;
+    firstFragmentRefUpdateDeps: {
+        isWithDateInputs: boolean;
+        isWithTimeInputs: boolean;
+        withAnyPicker: boolean;
+    };
+    lastFragmentRefUpdateDeps: {
+        withAnyPicker: boolean;
+        withClearBtn: boolean;
+        isWithTimeInputs: boolean;
+        isWithDateInputs: boolean;
+    };
+};

package/types/date-time-picker/config/useGlobalKeyHandlers.d.ts

@@ -0,0 +1,16 @@
+import { useChangeHandlers } from './useChangeHandlers';
+import { useGetPropsBasedOnType } from './useGetPropsBasedOnType';
+import { useGetReferences } from './useGetReferences';
+import { useGetFlags } from './useGetFlags';
+import type { DSControlledDateTimePickerT } from '../propTypes';
+interface Config {
+    propsBasedOnType: ReturnType<typeof useGetPropsBasedOnType>;
+    changeHandlers: ReturnType<typeof useChangeHandlers>;
+    DOMRefs: ReturnType<typeof useGetReferences>;
+    flags: ReturnType<typeof useGetFlags>;
+}
+export declare const useGlobalKeyHandlers: ({ propsBasedOnType, changeHandlers, DOMRefs, flags }: Config) => {
+    onFillWithCurrentDateKeys: (e: React.KeyboardEvent<HTMLInputElement | HTMLButtonElement>, metaInfo?: Partial<DSControlledDateTimePickerT.InternalInputsChangeMetaInfo>) => void;
+    onGlobalKeyDown: (e: React.KeyboardEvent<HTMLInputElement | HTMLButtonElement>) => void;
+};
+export {};

package/types/date-time-picker/config/useRelevantValueFromProps.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import type { DSControlledDateTimePickerT } from '../propTypes';
+export declare const useRelevantValueFromProps: (props: DSControlledDateTimePickerT.InternalProps) => {
+    dateStringFromProps: string;
+    timeStringFromProps: string;
+    tempDateString: string;
+    setTempDateString: import("react").Dispatch<import("react").SetStateAction<string>>;
+    tempTimeString: string;
+    setTimeString: import("react").Dispatch<import("react").SetStateAction<string>>;
+};

package/types/date-time-picker/config/useValidateProps.d.ts

@@ -1,2 +1,2 @@
-import { PropsWithDefaultsT } from '../index.d';
-export declare const useValidateProps: (props: Partial<PropsWithDefaultsT>) => void;
+import { DSControlledDateTimePickerT } from '../propTypes';
+export declare const useValidateProps: (props: DSControlledDateTimePickerT.Props) => void;

package/types/date-time-picker/parts/ClearButton/useClearButton.d.ts

@@ -1,11 +1,11 @@
 /// <reference types="react" />
-import type { onClearClickT, onKeyDownT } from '../../index.d';
-interface useOnClearClickRT {
-    onClearClick: onClearClickT;
-    onClearButtonKeyDown: onKeyDownT<HTMLButtonElement>;
-    clearButtonRef: React.MutableRefObject<HTMLButtonElement>;
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes';
+interface UseOnClearClickR {
+    onClearClick: DSControlledDateTimePickerInternalsT.OnDSBtnClick;
+    onClearButtonKeyDown: DSControlledDateTimePickerInternalsT.OnKeyDown<HTMLButtonElement>;
+    clearButtonRef: React.MutableRefObject<HTMLButtonElement | null>;
     withAnyPicker: boolean;
     withClearBtn: boolean;
 }
-export declare const useClearButton: () => useOnClearClickRT;
+export declare const useClearButton: () => UseOnClearClickR;
 export {};

package/types/date-time-picker/parts/DateInputs/DDInput.d.ts

@@ -1,15 +1,15 @@
 import React from 'react';
-import type { onChangeFuncT, onBlurFuncT, onFocusFuncT, onKeyDownT } from '../../index.d';
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes';
 interface DDInputsPropsT {
-    onChange: onChangeFuncT;
-    onBlur: onBlurFuncT;
-    onFocus: onFocusFuncT;
-    onKeyDown: onKeyDownT;
+    onChange: DSControlledDateTimePickerInternalsT.OnChangeFunc;
+    onBlur: DSControlledDateTimePickerInternalsT.OnBlurFunc;
+    onFocus: DSControlledDateTimePickerInternalsT.OnFocusFunc;
+    onKeyDown: DSControlledDateTimePickerInternalsT.OnKeyDown;
     value: string;
     disabled: boolean;
     placeholder: string;
     ariaCurrentValueForInputs: string;
-    contextRef: React.RefObject<HTMLInputElement>;
+    contextRef: React.MutableRefObject<HTMLInputElement | null>;
 }
 export declare const DDInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, contextRef, placeholder, ariaCurrentValueForInputs, }: DDInputsPropsT) => JSX.Element>;
 export {};

package/types/date-time-picker/parts/DateInputs/MMInput.d.ts

@@ -1,14 +1,14 @@
 import React from 'react';
-import type { onChangeFuncT, onBlurFuncT, onFocusFuncT, onKeyDownT } from '../../index.d';
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes';
 interface MMInputsPropsT {
-    onChange: onChangeFuncT;
-    onBlur: onBlurFuncT;
-    onFocus: onFocusFuncT;
-    onKeyDown: onKeyDownT;
+    onChange: DSControlledDateTimePickerInternalsT.OnChangeFunc;
+    onBlur: DSControlledDateTimePickerInternalsT.OnBlurFunc;
+    onFocus: DSControlledDateTimePickerInternalsT.OnFocusFunc;
+    onKeyDown: DSControlledDateTimePickerInternalsT.OnKeyDown;
     autoFocusMonthInput: boolean;
     value: string;
     disabled: boolean;
-    contextRef: React.RefObject<HTMLInputElement>;
+    contextRef: React.MutableRefObject<HTMLInputElement | null>;
     placeholder: string;
     ariaCurrentValueForInputs: string;
 }

package/types/date-time-picker/parts/DateInputs/YYYYInput.d.ts

@@ -1,13 +1,13 @@
 import React from 'react';
-import type { onChangeFuncT, onBlurFuncT, onFocusFuncT, onKeyDownT } from '../../index.d';
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes';
 interface YYYYInputsPropsT {
-    onChange: onChangeFuncT;
-    onBlur: onBlurFuncT;
-    onFocus: onFocusFuncT;
-    onKeyDown: onKeyDownT;
+    onChange: DSControlledDateTimePickerInternalsT.OnChangeFunc;
+    onBlur: DSControlledDateTimePickerInternalsT.OnBlurFunc;
+    onFocus: DSControlledDateTimePickerInternalsT.OnFocusFunc;
+    onKeyDown: DSControlledDateTimePickerInternalsT.OnKeyDown;
     value: string;
     disabled: boolean;
-    contextRef: React.RefObject<HTMLInputElement>;
+    contextRef: React.MutableRefObject<HTMLInputElement | null>;
     placeholder: string;
     ariaCurrentValueForInputs: string;
 }

package/types/date-time-picker/parts/DateInputs/useDateInputs.d.ts

@@ -1,2 +1,2 @@
-import type { useDateInputsRT } from '../../index.d';
-export declare const useDateInputs: () => useDateInputsRT;
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes';
+export declare const useDateInputs: () => DSControlledDateTimePickerInternalsT.UseDateInputsR;

package/types/date-time-picker/parts/Pickers/Calendar/Calendar.d.ts

@@ -1,3 +1,5 @@
-import React from 'react';
-export declare const WrapWithCalendarContext: (Component: React.ComponentType) => () => JSX.Element;
+/// <reference types="react" />
+export declare const WrappedCalendarContext: ({ children }: {
+    children: JSX.Element;
+}) => JSX.Element;
 export declare const Calendar: () => JSX.Element;