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

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

@@ -1,66 +1,6 @@
-import React from 'react';
-import type { DateMonth, metaMonthDayT, onFocusFuncT } from '../../../index.d';
-export declare type handleDayOnKeyDownT = (e: React.KeyboardEvent, day: metaMonthDayT) => void;
-export interface KeyboardHandlersT {
-    handleDayOnKeyDown: handleDayOnKeyDownT;
-    handlePrevYearKeyDown: (e: React.KeyboardEvent) => void;
-    handlePrevMonthKeyDown: (e: React.KeyboardEvent) => void;
-    handleNextMonthKeyDown: (e: React.KeyboardEvent) => void;
-    handleNextYearKeyDown: (e: React.KeyboardEvent) => void;
-    handlePickerIconKeyDown: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
-}
-export interface FocusLogicT {
-    focusedDay?: metaMonthDayT;
-    tryToFocusCurrentlyDataIsFocusedDay: () => void;
-    resetFocusedDayToStartDate: () => void;
-    handleFocusMetaDay: (metaDayToFocus: metaMonthDayT) => void;
-    handleFocusMetaDayByDay: (day: Date) => void;
-}
-export interface HeaderButtonsRefsT {
-    prevYearBtnRef: React.RefObject<HTMLButtonElement>;
-    prevMonthBtnRef: React.RefObject<HTMLButtonElement>;
-    nextMonthBtnRef: React.RefObject<HTMLButtonElement>;
-    nextYearBtnRef: React.RefObject<HTMLButtonElement>;
-    calendarDaysWrapperRef: React.RefObject<HTMLDivElement>;
-}
-export interface PopperTriggerLogicT {
-    closeCalendar: () => void;
-    setPopperElement: React.Dispatch<React.SetStateAction<HTMLDivElement>>;
-    setArrowElement: React.Dispatch<React.SetStateAction<HTMLDivElement>>;
-    usePopperHelpers?: {
-        attributes: Record<string, unknown>;
-        styles: Record<string, React.CSSProperties>;
-    };
-    handleToggleCalendar: (e?: React.MouseEvent<HTMLButtonElement>) => void;
-    handleSetTriggerRef: (instance: HTMLButtonElement) => void;
-    handleMenuWrapperKeyDown: (e?: React.KeyboardEvent<HTMLElement>) => void;
-}
-export interface useCurrentDisplayedMonthYearLogicT {
-    currentMonth?: DateMonth;
-    currentYear?: number;
-    daysArray: metaMonthDayT[];
-    invisibleFirstDay?: metaMonthDayT;
-    daysMatrixByWeekday?: metaMonthDayT[][];
-    invisibleLastDay?: metaMonthDayT;
-    handlePrevMonth: () => void;
-    handlePrevYear: () => void;
-    handleNextMonth: () => void;
-    handleNextYear: () => void;
-}
-export interface CalendarContextT extends KeyboardHandlersT, HeaderButtonsRefsT, FocusLogicT, PopperTriggerLogicT, useCurrentDisplayedMonthYearLogicT {
-    ariaCurrentValueForInputs: string;
-    showCalendar: boolean;
-    setShowCalendar: React.Dispatch<React.SetStateAction<boolean>>;
-    isControllerOnly: boolean;
-    isWithTimeWheelToo: boolean;
-    autoFocusPrevMonthArrow: boolean;
-    disabled: boolean;
-    onPrevYearFocus: onFocusFuncT;
-    onPrevMonthFocus: onFocusFuncT;
-    onNextMonthFocus: onFocusFuncT;
-    onNextYearFocus: onFocusFuncT;
-}
+/// <reference types="react" />
+import type { CalendarContextT } from './useConfigCalendarCTX';
 export declare const defaultCalendarContext: CalendarContextT;
 /** Context for cross component communication */
-export declare const CalendarContext: React.Context<CalendarContextT>;
+export declare const CalendarContext: import("react").Context<CalendarContextT>;
 export default CalendarContext;

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

@@ -1,9 +1,9 @@
 import React from 'react';
-import type { metaMonthDayT } from '../../../index.d';
+import type { DSControlledDateTimePickerInternalsT } from '../../../sharedTypes';
 export declare const CalendarDaysList: React.MemoExoticComponent<({ invisibleFirstDay, daysMatrixByWeekday, invisibleLastDay, innerRef }: CalendarDaysListPropsT) => JSX.Element>;
 export interface CalendarDaysListPropsT {
-    invisibleFirstDay: metaMonthDayT;
-    daysMatrixByWeekday: metaMonthDayT[][];
-    invisibleLastDay: metaMonthDayT;
+    invisibleFirstDay?: DSControlledDateTimePickerInternalsT.MetaMonthDay;
+    daysMatrixByWeekday: DSControlledDateTimePickerInternalsT.MetaMonthDay[][];
+    invisibleLastDay?: DSControlledDateTimePickerInternalsT.MetaMonthDay;
     innerRef: React.RefObject<HTMLDivElement>;
 }

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

@@ -1,2 +1,2 @@
-/// <reference types="react" />
-export declare const CalendarFooter: () => JSX.Element;
+import React from 'react';
+export declare const CalendarFooter: React.ComponentType;

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

@@ -1,7 +1,7 @@
 /// <reference types="react" />
-import type { metaMonthDayT } from '../../../index.d';
+import type { DSControlledDateTimePickerInternalsT } from '../../../sharedTypes';
 interface CalendarDayPropsT {
-    metaDay: metaMonthDayT;
+    metaDay: DSControlledDateTimePickerInternalsT.MetaMonthDay;
     colIndex?: number;
     isInvisible?: boolean;
 }

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

@@ -1,2 +1,15 @@
-import type { useCurrentDisplayedMonthYearLogicT } from './CalendarContext';
-export declare const useCurrentDisplayedMonthYearLogic: () => useCurrentDisplayedMonthYearLogicT;
+import type { DSControlledDateTimePickerInternalsT } from '../../../sharedTypes';
+interface UseCurrentDisplayedMonthYearLogicT {
+    currentMonth: DSControlledDateTimePickerInternalsT.DateMonth;
+    currentYear: number;
+    daysArray: DSControlledDateTimePickerInternalsT.MetaMonthDay[];
+    invisibleFirstDay?: DSControlledDateTimePickerInternalsT.MetaMonthDay;
+    daysMatrixByWeekday: DSControlledDateTimePickerInternalsT.MetaMonthDay[][];
+    invisibleLastDay?: DSControlledDateTimePickerInternalsT.MetaMonthDay;
+    handlePrevMonth: () => void;
+    handlePrevYear: () => void;
+    handleNextMonth: () => void;
+    handleNextYear: () => void;
+}
+export declare const useCurrentDisplayedMonthYearLogic: () => UseCurrentDisplayedMonthYearLogicT;
+export {};

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

@@ -1,8 +1,15 @@
-import type { metaMonthDayT } from '../../../index.d';
-import type { FocusLogicT } from './CalendarContext';
-interface useFocusLogicArgsT {
-    daysArray: metaMonthDayT[];
+import { useCurrentDisplayedMonthYearLogic } from './useCurrentDisplayedMonthYearLogic';
+import type { DSControlledDateTimePickerInternalsT } from '../../../sharedTypes';
+interface UseFocusLogicArgsT {
+    currentDisplayedMonthLogic: ReturnType<typeof useCurrentDisplayedMonthYearLogic>;
     showCalendar: boolean;
 }
-export declare const useFocusLogic: ({ daysArray, showCalendar }: useFocusLogicArgsT) => FocusLogicT;
+interface FocusLogicT {
+    focusedDay?: DSControlledDateTimePickerInternalsT.MetaMonthDay;
+    tryToFocusCurrentlyDataIsFocusedDay: () => void;
+    resetFocusedDayToStartDate: () => void;
+    handleFocusMetaDay: (metaDayToFocus: DSControlledDateTimePickerInternalsT.MetaMonthDay) => void;
+    handleFocusMetaDayByDay: (day: Date) => void;
+}
+export declare const useFocusLogic: ({ currentDisplayedMonthLogic, showCalendar }: UseFocusLogicArgsT) => FocusLogicT;
 export {};

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

@@ -1,13 +1,19 @@
-import type { metaMonthDayT } from '../../../index.d';
-import type { KeyboardHandlersT, HeaderButtonsRefsT } from './CalendarContext';
-interface useKeyboardHandlersArgsT extends Partial<HeaderButtonsRefsT> {
-    focusedDay: metaMonthDayT;
-    daysArray: metaMonthDayT[];
-    handlePrevMonth: () => void;
-    handleNextMonth: () => void;
-    handleFocusMetaDay: (metaDayToFocus: metaMonthDayT) => void;
-    handleFocusMetaDayByDay: (dayToFocus: Date) => void;
-    tryToFocusCurrentlyDataIsFocusedDay: () => void;
+/// <reference types="react" />
+import type { DSControlledDateTimePickerInternalsT } from '../../../sharedTypes';
+import { useFocusLogic } from './useFocusLogic';
+import { useCurrentDisplayedMonthYearLogic } from './useCurrentDisplayedMonthYearLogic';
+interface UseKeyboardHandlersArgsT {
+    currentDisplayedMonthLogic: ReturnType<typeof useCurrentDisplayedMonthYearLogic>;
+    focusLogic: ReturnType<typeof useFocusLogic>;
 }
-export declare const useKeyboardHandlers: ({ focusedDay, daysArray, handlePrevMonth, handleNextMonth, handleFocusMetaDay, handleFocusMetaDayByDay, tryToFocusCurrentlyDataIsFocusedDay, }: useKeyboardHandlersArgsT) => KeyboardHandlersT;
+declare type HandleDayOnKeyDownT = (e: React.KeyboardEvent, day: DSControlledDateTimePickerInternalsT.MetaMonthDay) => void;
+interface KeyboardHandlersT {
+    handleDayOnKeyDown: HandleDayOnKeyDownT;
+    handlePrevYearKeyDown: (e: React.KeyboardEvent) => void;
+    handlePrevMonthKeyDown: (e: React.KeyboardEvent) => void;
+    handleNextMonthKeyDown: (e: React.KeyboardEvent) => void;
+    handleNextYearKeyDown: (e: React.KeyboardEvent) => void;
+    handlePickerIconKeyDown: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
+}
+export declare const useKeyboardHandlers: ({ currentDisplayedMonthLogic, focusLogic, }: UseKeyboardHandlersArgsT) => KeyboardHandlersT;
 export {};

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

@@ -1,20 +1,5 @@
 /// <reference types="react" />
-export interface CalendarWithTimeWheelContextT {
-    ariaCurrentValueForInputs: string;
-    showCalendarWithTimeWheel: boolean;
-    setPopperElement: (instance: HTMLDivElement) => void;
-    setArrowElement: (instance: HTMLDivElement) => void;
-    usePopperHelpers: {
-        attributes: Record<string, unknown>;
-        styles: Record<string, React.CSSProperties>;
-    };
-    handleToggleCalendarWithTimeWheel: (e: React.MouseEvent<HTMLButtonElement>) => void;
-    handleSetTriggerRef: (instance: HTMLButtonElement) => void;
-    handleMenuWrapperKeyDown: (e?: React.KeyboardEvent<HTMLElement>) => void;
-    handlePickerIconKeyDown: (e?: React.KeyboardEvent<HTMLButtonElement>) => void;
-    isControllerOnly: boolean;
-    disabled: boolean;
-}
+import type { CalendarWithTimeWheelContextT } from './useConfigCalendarWithTimeWheelCTX';
 export declare const defaultCalendarWithTimeWheelContext: CalendarWithTimeWheelContextT;
 /** Context for cross component communication */
 export declare const CalendarWithTimeWheelContext: import("react").Context<CalendarWithTimeWheelContextT>;

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

@@ -1,2 +1,2 @@
-/// <reference types="react" />
-export declare const CalendarWithTimeWheelFooter: () => JSX.Element;
+import React from 'react';
+export declare const CalendarWithTimeWheelFooter: React.ComponentType;

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

@@ -1,2 +1,16 @@
-import type { CalendarWithTimeWheelContextT } from './CalendarWithTimeWheelContext';
+import React from 'react';
+import { usePopper } from 'react-popper';
+export interface CalendarWithTimeWheelContextT {
+    ariaCurrentValueForInputs: string;
+    showCalendarWithTimeWheel: boolean;
+    setPopperElement: (instance: HTMLDivElement) => void;
+    setArrowElement: (instance: HTMLDivElement) => void;
+    usePopperHelpers: ReturnType<typeof usePopper>;
+    handleToggleCalendarWithTimeWheel: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    handleSetTriggerRef: (instance: HTMLButtonElement) => void;
+    handleMenuWrapperKeyDown: (e: React.KeyboardEvent<HTMLElement>) => void;
+    handlePickerIconKeyDown: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
+    isControllerOnly: boolean;
+    disabled: boolean;
+}
 export declare const useConfigCalendarWithTimeWheelCTX: () => CalendarWithTimeWheelContextT;

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

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

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

@@ -1,65 +1,6 @@
-import React from 'react';
-export interface WheelsButtonsRefsT {
-    prevHourBtnRef: React.RefObject<HTMLButtonElement>;
-    currHourBtnRef: React.RefObject<HTMLButtonElement>;
-    nextHourBtnRef: React.RefObject<HTMLButtonElement>;
-    prevMinutesBtnRef: React.RefObject<HTMLButtonElement>;
-    currMinutesBtnRef: React.RefObject<HTMLButtonElement>;
-    nextMinutesBtnRef: React.RefObject<HTMLButtonElement>;
-    prevMeridiemBtnRef: React.RefObject<HTMLButtonElement>;
-    currMeridiemBtnRef: React.RefObject<HTMLButtonElement>;
-    nextMeridiemBtnRef: React.RefObject<HTMLButtonElement>;
-}
-export interface KeyboardHandlersT {
-    handlePrevHourBtnOnKeyDown: (e: React.KeyboardEvent) => void;
-    handleCurrHourOnKeyDown: (e: React.KeyboardEvent) => void;
-    handleNextHourBtnOnKeyDown: (e: React.KeyboardEvent) => void;
-    handlePrevMinuteBtnOnKeyDown: (e: React.KeyboardEvent) => void;
-    handleCurrMinutesOnKeyDown: (e: React.KeyboardEvent) => void;
-    handleNextMinuteBtnOnKeyDown: (e: React.KeyboardEvent) => void;
-    handlePrevMeridiemBtnOnKeyDown: (e: React.KeyboardEvent) => void;
-    handleCurrMeridiemOnKeyDown: (e: React.KeyboardEvent) => void;
-    handleNextMeridiemBtnOnKeyDown: (e: React.KeyboardEvent) => void;
-    handlePickerIconKeyDown: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
-}
-export interface PopperTriggerLogicT {
-    showTimePicker: boolean;
-    setShowTimePicker: React.Dispatch<React.SetStateAction<boolean>>;
-    setPopperElement: React.Dispatch<React.SetStateAction<HTMLDivElement>>;
-    setArrowElement: React.Dispatch<React.SetStateAction<HTMLDivElement>>;
-    usePopperHelpers: {
-        attributes: Record<string, unknown>;
-        styles: Record<string, React.CSSProperties>;
-    };
-    handleToggleTimePicker: (e?: React.MouseEvent<HTMLButtonElement>) => void;
-    handleSetTriggerRef: (instance: HTMLButtonElement) => void;
-    handleMenuWrapperKeyDown: (e?: React.KeyboardEvent<HTMLElement>) => void;
-}
-export interface useCurrentDisplayedWheelsLogicT {
-    currHourNum: number;
-    hours: string;
-    visibleHours: string[];
-    handlePrevHour: (e: React.MouseEvent) => void;
-    handleNextHour: (e: React.MouseEvent) => void;
-    handleTimeWheelBtnChangeHours: (newVal: string, e: React.MouseEvent<HTMLButtonElement>) => void;
-    currMinuteNum: number;
-    minutes: string;
-    visibleMinutes: string[];
-    handlePrevMinute: (e: React.MouseEvent) => void;
-    handleNextMinute: (e: React.MouseEvent) => void;
-    handleTimeWheelBtnChangeMinutes: (newVal: string, e: React.MouseEvent<HTMLButtonElement>) => void;
-    meridiem: string;
-    handleTimeWheelBtnChangeMeridiem: (newMeridiem: string, e: React.MouseEvent) => void;
-}
-export interface TimeWheelContextT extends PopperTriggerLogicT, useCurrentDisplayedWheelsLogicT, KeyboardHandlersT, WheelsButtonsRefsT {
-    ariaCurrentValueForInputs: string;
-    tempTimeString: string;
-    isControllerOnly: boolean;
-    autoFocusHourTimeWheel: boolean;
-    disabled: boolean;
-    getIsDisabledTime: (val: string) => boolean;
-}
+/// <reference types="react" />
+import type { TimeWheelContextT } from './useConfigTimePickerCTX';
 export declare const defaultTimePickerContext: TimeWheelContextT;
 /** Context for cross component communication */
-export declare const TimeWheelContext: React.Context<TimeWheelContextT>;
+export declare const TimeWheelContext: import("react").Context<TimeWheelContextT>;
 export default TimeWheelContext;

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

@@ -1,2 +1,2 @@
-/// <reference types="react" />
-export declare const TimeWheelFooter: () => JSX.Element;
+import React from 'react';
+export declare const TimeWheelFooter: React.ComponentType;

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

@@ -1,2 +1,5 @@
-import { TimeWheelContextT } from './TimeWheelContext';
+import { usePopperTriggerLogic } from './usePopperTriggerLogic';
+import { useCurrentDisplayedWheelsLogic } from './useCurrentDisplayedWheelsLogic';
+import { useKeyboardHandlers } from './useKeyboardHandlers';
+export declare type TimeWheelContextT = ReturnType<typeof useCurrentDisplayedWheelsLogic> & ReturnType<typeof usePopperTriggerLogic> & ReturnType<typeof useKeyboardHandlers>;
 export declare const useConfigTimePickerCTX: () => TimeWheelContextT;

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

@@ -1,6 +1,17 @@
-import type { useCurrentDisplayedWheelsLogicT } from './TimeWheelContext';
-declare type useCurrentDisplayedWheelsLogicArgsT = {
-    minutesInterval: number;
-};
-export declare const useCurrentDisplayedWheelsLogic: ({ minutesInterval, }: useCurrentDisplayedWheelsLogicArgsT) => useCurrentDisplayedWheelsLogicT;
+import type { DSControlledDateTimePickerT } from '../../../propTypes';
+interface UseCurrentDisplayedWheelsLogic {
+    currHourNum: number;
+    visibleHours: (string | null)[];
+    handlePrevHour: (e: DSControlledDateTimePickerT.OnInternalValuesChangeEvent) => void;
+    handleNextHour: (e: DSControlledDateTimePickerT.OnInternalValuesChangeEvent) => void;
+    handleTimeWheelBtnChangeHours: (newVal: string, e: DSControlledDateTimePickerT.OnInternalValuesChangeEvent) => void;
+    currMinuteNum: number;
+    visibleMinutes: (string | null)[];
+    handlePrevMinute: (e: DSControlledDateTimePickerT.OnInternalValuesChangeEvent) => void;
+    handleNextMinute: (e: DSControlledDateTimePickerT.OnInternalValuesChangeEvent) => void;
+    handleTimeWheelBtnChangeMinutes: (newVal: string, e: DSControlledDateTimePickerT.OnInternalValuesChangeEvent) => void;
+    handleTimeWheelBtnChangeMeridiem: (newMeridiem: string, e: DSControlledDateTimePickerT.OnInternalValuesChangeEvent) => void;
+    currMeridiem: string;
+}
+export declare const useCurrentDisplayedWheelsLogic: () => UseCurrentDisplayedWheelsLogic;
 export {};

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

@@ -1,4 +1,19 @@
-import type { useCurrentDisplayedWheelsLogicT, KeyboardHandlersT } from './TimeWheelContext';
-declare type useKeyboardHandlersArgsT = Partial<useCurrentDisplayedWheelsLogicT>;
-export declare const useKeyboardHandlers: ({ handlePrevHour, handleNextHour, handlePrevMinute, handleNextMinute, handleTimeWheelBtnChangeMeridiem, }: useKeyboardHandlersArgsT) => KeyboardHandlersT;
+/// <reference types="react" />
+import { useCurrentDisplayedWheelsLogic } from './useCurrentDisplayedWheelsLogic';
+interface UseKeyboardHandlersArgs {
+    currentDisplayedTimeWheelLogic: ReturnType<typeof useCurrentDisplayedWheelsLogic>;
+}
+interface KeyboardHandlersT {
+    handlePrevHourBtnOnKeyDown: (e: React.KeyboardEvent) => void;
+    handleCurrHourOnKeyDown: (e: React.KeyboardEvent) => void;
+    handleNextHourBtnOnKeyDown: (e: React.KeyboardEvent) => void;
+    handlePrevMinuteBtnOnKeyDown: (e: React.KeyboardEvent) => void;
+    handleCurrMinutesOnKeyDown: (e: React.KeyboardEvent) => void;
+    handleNextMinuteBtnOnKeyDown: (e: React.KeyboardEvent) => void;
+    handlePrevMeridiemBtnOnKeyDown: (e: React.KeyboardEvent) => void;
+    handleCurrMeridiemOnKeyDown: (e: React.KeyboardEvent) => void;
+    handleNextMeridiemBtnOnKeyDown: (e: React.KeyboardEvent) => void;
+    handlePickerIconKeyDown: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
+}
+export declare const useKeyboardHandlers: ({ currentDisplayedTimeWheelLogic }: UseKeyboardHandlersArgs) => KeyboardHandlersT;
 export {};

package/types/date-time-picker/parts/TimeInputs/HHInput.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 HHInputsPropsT {
-    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;
     autoFocusHourInput: boolean;

package/types/date-time-picker/parts/TimeInputs/MeridiemInput.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 MeridiemInputsPropsT {
-    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/TimeInputs/MinutesInput.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 MinutesInputsPropsT {
-    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/TimeInputs/useTimeInputs.d.ts

@@ -1,2 +1,22 @@
-import type { useTimeInputsRT } from '../../index.d';
-export declare const useTimeInputs: () => useTimeInputsRT;
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes';
+interface UseTimeInputsR {
+    autoFocusHourInput: boolean;
+    disabled: boolean;
+    handleChangeHours: DSControlledDateTimePickerInternalsT.HandleOnChangeFunc;
+    onHoursChange: DSControlledDateTimePickerInternalsT.OnChangeFunc;
+    handleChangeMinutes: DSControlledDateTimePickerInternalsT.HandleOnChangeFunc;
+    onMinutesChange: DSControlledDateTimePickerInternalsT.OnChangeFunc;
+    handleChangeMeridiem: DSControlledDateTimePickerInternalsT.HandleOnChangeFunc;
+    onMeridiemChange: DSControlledDateTimePickerInternalsT.OnChangeFunc;
+    onHoursFocus: DSControlledDateTimePickerInternalsT.OnFocusFunc;
+    onMinutesFocus: DSControlledDateTimePickerInternalsT.OnFocusFunc;
+    onMeridiemFocus: DSControlledDateTimePickerInternalsT.OnFocusFunc;
+    onHoursBlur: DSControlledDateTimePickerInternalsT.OnBlurFunc;
+    onMinutesBlur: DSControlledDateTimePickerInternalsT.OnBlurFunc;
+    onMeridiemBlur: DSControlledDateTimePickerInternalsT.OnBlurFunc;
+    onHoursKeyDown: DSControlledDateTimePickerInternalsT.OnKeyDown;
+    onMinutesKeyDown: DSControlledDateTimePickerInternalsT.OnKeyDown;
+    onMeridiemKeyDown: DSControlledDateTimePickerInternalsT.OnKeyDown;
+}
+export declare const useTimeInputs: () => UseTimeInputsR;
+export {};

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

@@ -1,5 +1,5 @@
 export declare const fixedValues: {
-    smallInputWidth: string;
-    largeInputWidth: string;
-    separatorWidth: string;
+    readonly smallInputWidth: "28px";
+    readonly largeInputWidth: "40px";
+    readonly separatorWidth: "7px";
 };

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

@@ -0,0 +1,94 @@
+import React from 'react';
+import type { DSControlledDateTimePickerT } from './propTypes';
+export declare namespace DSControlledDateTimePickerInternalsT {
+    type DateDay = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31;
+    type DateMonth = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+    interface MetaMonthDay {
+        day: Date;
+        dayAsString: string;
+        isPrevMonthDay: boolean;
+        isNextMonthDay: boolean;
+        isCurrMonthDay: boolean;
+        isHidden: boolean;
+        dayBtnRef: React.RefObject<HTMLButtonElement>;
+    }
+    type OnKeyDown<HTMLT = HTMLInputElement> = (e: React.KeyboardEvent<HTMLT>) => void;
+    type OnChangeFunc = (e: React.ChangeEvent<HTMLInputElement>) => void;
+    type OnDSBtnClick = (e: React.MouseEvent<HTMLButtonElement> | React.KeyboardEvent<HTMLButtonElement> | React.KeyboardEvent) => void;
+    type HandleOnChangeFunc = (newVal: string, e: DSControlledDateTimePickerT.OnInternalValuesChangeEvent, metaInfo?: DSControlledDateTimePickerT.InternalInputsChangeMetaInfo) => void;
+    type OnBlurFunc = (e: React.FocusEvent<HTMLInputElement>) => void;
+    type OnFocusFunc = (e: React.FocusEvent<HTMLInputElement>) => void;
+    interface UseDateInputsR {
+        month: string;
+        day: string;
+        year: string;
+        autoFocusMonthInput: boolean;
+        disabled: boolean;
+        onMonthChange: OnChangeFunc;
+        onDayChange: OnChangeFunc;
+        onYearChange: OnChangeFunc;
+        onMonthFocus: OnFocusFunc;
+        onDayFocus: OnFocusFunc;
+        onYearFocus: OnFocusFunc;
+        onMonthBlur: OnBlurFunc;
+        onDayBlur: OnBlurFunc;
+        onYearBlur: OnBlurFunc;
+        onMonthKeyDown: OnKeyDown;
+        onDayKeyDown: OnKeyDown;
+        onYearKeyDown: OnKeyDown;
+    }
+    interface InputsReferences {
+        monthInputRef: React.RefObject<HTMLInputElement>;
+        dayInputRef: React.RefObject<HTMLInputElement>;
+        yearInputRef: React.RefObject<HTMLInputElement>;
+        hourInputRef: React.RefObject<HTMLInputElement>;
+        minutesInputRef: React.RefObject<HTMLInputElement>;
+        meridiemInputRef: React.RefObject<HTMLInputElement>;
+        clearButtonRef: React.MutableRefObject<HTMLButtonElement>;
+        pickerButtonRef: React.MutableRefObject<HTMLButtonElement>;
+    }
+    interface CalendarReferences {
+        prevYearBtnRef: React.MutableRefObject<HTMLButtonElement>;
+        prevMonthBtnRef: React.MutableRefObject<HTMLButtonElement>;
+        nextMonthBtnRef: React.MutableRefObject<HTMLButtonElement>;
+        nextYearBtnRef: React.MutableRefObject<HTMLButtonElement>;
+        calendarDaysWrapperRef: React.MutableRefObject<HTMLDivElement>;
+    }
+    interface TimewheelReferences {
+        prevHourBtnRef: React.MutableRefObject<HTMLButtonElement>;
+        currHourBtnRef: React.MutableRefObject<HTMLButtonElement>;
+        nextHourBtnRef: React.MutableRefObject<HTMLButtonElement>;
+        prevMinutesBtnRef: React.MutableRefObject<HTMLButtonElement>;
+        currMinutesBtnRef: React.MutableRefObject<HTMLButtonElement>;
+        nextMinutesBtnRef: React.MutableRefObject<HTMLButtonElement>;
+        prevMeridiemBtnRef: React.MutableRefObject<HTMLButtonElement>;
+        currMeridiemBtnRef: React.MutableRefObject<HTMLButtonElement>;
+        nextMeridiemBtnRef: React.MutableRefObject<HTMLButtonElement>;
+    }
+    interface InternalPrecalculatedFlags {
+        isControllerOnly: boolean;
+        shouldPreserveClearableSpace: boolean;
+        isWithTimeWheelToo: boolean;
+        isWithCalendarToo: boolean;
+        isWithDateInputs: boolean;
+        isWithDateInputsOnly: boolean;
+        isWithTimeInputs: boolean;
+        isWithTimeInputsOnly: boolean;
+        autoFocusMonthInput: boolean;
+        autoFocusHourInput: boolean;
+        autoFocusPrevMonthArrow: boolean;
+        autoFocusHourTimeWheel: boolean;
+        hideDate: boolean;
+        hideTime: boolean;
+        hideDateTimePicker: boolean;
+        hideDatePicker: boolean;
+        hideTimePicker: boolean;
+        withAnyInputs: boolean;
+        withAnyPicker: boolean;
+        withClearBtn: boolean;
+        withAnyRightController: boolean;
+        isDateSelector: boolean;
+        isTimeSelector: boolean;
+        isDateTimeSelector: boolean;
+    }
+}

package/types/date-time-picker/utils/constants.d.ts

@@ -1,37 +1,37 @@
-export declare const weekDays: string[];
-export declare const monthNames: string[];
+export declare const weekDays: readonly ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+export declare const monthNames: readonly ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
 export declare const announcableCardinalDays: {
-    1: string;
-    2: string;
-    3: string;
-    4: string;
-    5: string;
-    6: string;
-    7: string;
-    8: string;
-    9: string;
-    10: string;
-    11: string;
-    12: string;
-    13: string;
-    14: string;
-    15: string;
-    16: string;
-    17: string;
-    18: string;
-    19: string;
-    20: string;
-    21: string;
-    22: string;
-    23: string;
-    24: string;
-    25: string;
-    26: string;
-    27: string;
-    28: string;
-    29: string;
-    30: string;
-    31: string;
+    readonly 1: "first";
+    readonly 2: "second";
+    readonly 3: "third";
+    readonly 4: "fourth";
+    readonly 5: "fifth";
+    readonly 6: "sixth";
+    readonly 7: "seventh";
+    readonly 8: "eighth";
+    readonly 9: "ninth";
+    readonly 10: "tenth";
+    readonly 11: "eleventh";
+    readonly 12: "twelfth";
+    readonly 13: "thirteenth";
+    readonly 14: "fourteenth";
+    readonly 15: "fifteenth";
+    readonly 16: "sixteenth";
+    readonly 17: "seventeenth";
+    readonly 18: "eighteenth";
+    readonly 19: "ninteenth";
+    readonly 20: "twentieth";
+    readonly 21: "twentie first";
+    readonly 22: "twentie second";
+    readonly 23: "twentie third";
+    readonly 24: "twentie fourth";
+    readonly 25: "twentie fifth";
+    readonly 26: "twentie sixth";
+    readonly 27: "twentie seventh";
+    readonly 28: "twentie eighth";
+    readonly 29: "twentie ninth";
+    readonly 30: "thirtieth";
+    readonly 31: "thirty first";
 };
 export declare const homeEndAllArrowKeys: string[];
 export declare const homeEndKeys: string[];