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

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[];

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

@@ -1,8 +1,16 @@
-import type { DateMonth, metaMonthDayT, internalInputsChangeMetaInfo } from '../index.d';
-export declare const getLastDayOfMonth: (month: DateMonth, year: number) => Date;
-export declare const isValidDayForTheMonth: (month: DateMonth, year: number, day: number) => boolean;
+import type { DSControlledDateTimePickerT } from '../propTypes';
+import type { DSControlledDateTimePickerInternalsT } from '../sharedTypes';
+export declare const getDateValuesFromDate: (day: Date) => DateValuesT;
+export declare const getDateStringFromDay: (day: Date) => string;
+export declare const getTimeStringFromDay: (day: Date) => string;
+export declare const getMonthNameByMonthNumber: (monthNumber: number) => string;
+export declare const isSameDateMoment: (dateA: Date, dateB: Date) => boolean;
+export declare const compareTwoDatesDayEquality: (dayA: Date, dayB: Date) => boolean;
+export declare const getLastDayOfMonth: (month: DSControlledDateTimePickerInternalsT.DateMonth, year: number) => Date;
+export declare const isValidDayForTheMonth: (month: DSControlledDateTimePickerInternalsT.DateMonth, year: number, day: DSControlledDateTimePickerInternalsT.DateDay) => boolean;
+export declare const getDayFromDateString: (dateString: string) => Date | null;
 export declare const isValidDayForTheMonthDateString: (dateString: string) => boolean;
-export declare const getValidationDateStringMetaInfo: (dateString: string, getIsOutOfRangeDay?: (day: string) => boolean, getIsDisabledDay?: (day: string) => boolean) => Partial<internalInputsChangeMetaInfo>;
+export declare const getValidationDateStringMetaInfo: (dateString: string, getIsOutOfRangeDay?: (day: string) => boolean, getIsDisabledDay?: (day: string) => boolean) => Partial<DSControlledDateTimePickerT.InternalInputsChangeMetaInfo>;
 export declare const isLeapYear: (year: number) => boolean;
 export declare const getHowManyDaysInMonth: (year: number, month: number) => number;
 export declare const dateIsLeapYear: (date: Date) => boolean;
@@ -10,9 +18,9 @@ export declare const dateGetDaysInMonth: (date: Date) => number;
 export declare const dateAddMonths: (date: Date, value: number) => Date;
 export declare const dateAddYear: (date: Date, value: number) => Date;
 interface DateValuesT {
-    month: DateMonth;
+    month: DSControlledDateTimePickerInternalsT.DateMonth;
     year: number;
-    day?: number;
+    day?: DSControlledDateTimePickerInternalsT.DateDay;
 }
 interface DateSumValuesT {
     monthsToSum?: number;
@@ -28,12 +36,5 @@ export declare const sumYears: (date: Date, howManyMore?: number) => Date;
 export declare const getDaysInMonth: (month: number, year: number) => Date[];
 export declare const getLastXDaysFromPreviousMonth: (month: number, year: number, howMany: number) => Date[];
 export declare const getFirstXDaysFromNextMonth: (month: number, year: number, howMany: number) => Date[];
-export declare const getFiveBySevenCurrentMonthDaysMatrix: (month: number, year: number) => metaMonthDayT[];
-export declare const getDateValuesFromDate: (day: Date) => DateValuesT;
-export declare const getDateStringFromDay: (day: Date) => string;
-export declare const getTimeStringFromDay: (day: Date) => string;
-export declare const getDayFromDateString: (dateString: string) => Date | null;
-export declare const getMonthNameByMonthNumber: (monthNumber: number) => string;
-export declare const isSameDateMoment: (dateA: Date, dateB: Date) => boolean;
-export declare const compareTwoDatesDayEquality: (dayA: Date, dayB: Date) => boolean;
+export declare const getFiveBySevenCurrentMonthDaysMatrix: (month: number, year: number) => DSControlledDateTimePickerInternalsT.MetaMonthDay[];
 export {};

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

@@ -1,8 +1,8 @@
-import type { internalInputsChangeMetaInfo } from '../index.d';
-interface validatorsT {
+import type { DSControlledDateTimePickerT } from '../propTypes';
+interface Validators {
     getIsOutOfRangeDay: (day: string) => boolean;
     getIsDisabledDay: (day: string) => boolean;
     getIsDisabledTime: (val: string) => boolean;
 }
-export declare const getValidationDateTimeStringMetaInfo: (dateString: string, timeString: string, validators: validatorsT) => Partial<internalInputsChangeMetaInfo>;
+export declare const getValidationDateTimeStringMetaInfo: (dateString: string, timeString: string, validators: Validators) => Partial<DSControlledDateTimePickerT.InternalInputsChangeMetaInfo>;
 export {};

package/types/date-time-picker/utils/hooks/useGetDayFromDateString.d.ts

@@ -1 +1 @@
-export declare const useGetDayFromDateString: () => Date;
+export declare const useGetDayFromDateString: () => Date | null;

package/types/date-time-picker/utils/hooks/useGetMonthYearFromDateStringOrEmptyStartingMonth.d.ts

@@ -1,5 +1,5 @@
-import type { DateMonth } from '../../index.d';
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes';
 export declare const useGetMonthYearFromDateStringOrEmptyStartingMonth: () => {
     year: number;
-    month: DateMonth;
+    month: DSControlledDateTimePickerInternalsT.DateMonth;
 };

package/types/date-time-picker/utils/hooks/useGetStartingFocusedDay.d.ts

@@ -1,8 +1,8 @@
-interface useGetStartingFocusedDayRT {
-    startFocusedYear: number;
-    startFocusedDay: number;
-    startFocusedMonth: number;
-    startFocusedDate: Date;
+interface StartingFocusedDayT {
+    startFocusedYear: number | null;
+    startFocusedDay: number | null;
+    startFocusedMonth: number | null;
+    startFocusedDate: Date | null;
 }
-export declare const useGetStartingFocusedDay: () => useGetStartingFocusedDayRT;
+export declare const useGetStartingFocusedDay: () => StartingFocusedDayT;
 export {};

package/types/date-time-picker/utils/hooks/useOnClickOutside.d.ts

@@ -1 +1 @@
-export declare const useOnClickOutside: (ref: any, handler: any) => void;
+export declare const useOnClickOutside: (ref: HTMLElement | null, handler: NoopishFunc<MouseEvent | TouchEvent>) => void;

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

@@ -1,2 +1,2 @@
-import type { internalInputsChangeMetaInfo } from '../index.d';
-export declare const getValidationTimeStringMetaInfo: (timeString: string, getIsDisabledTime?: (timeS: string) => boolean) => Partial<internalInputsChangeMetaInfo>;
+import type { DSControlledDateTimePickerT } from '../propTypes';
+export declare const getValidationTimeStringMetaInfo: (timeString: string, getIsDisabledTime?: (timeS: string) => boolean) => Partial<DSControlledDateTimePickerT.InternalInputsChangeMetaInfo>;

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

@@ -0,0 +1,4 @@
+import { DSControlledDateTimePickerT } from '../propTypes';
+export declare const getIsDateTime: (props: DSControlledDateTimePickerT.Props | DSControlledDateTimePickerT.InternalProps) => props is DSControlledDateTimePickerT.DateTimePickerProps | DSControlledDateTimePickerT.InternalDateTimePickerProps;
+export declare const getIsDate: (props: DSControlledDateTimePickerT.Props | DSControlledDateTimePickerT.InternalProps) => props is DSControlledDateTimePickerT.DatePickerProps | DSControlledDateTimePickerT.InternalDatePickerProps;
+export declare const getIsTime: (props: DSControlledDateTimePickerT.Props | DSControlledDateTimePickerT.InternalProps) => props is DSControlledDateTimePickerT.TimePickerProps | DSControlledDateTimePickerT.InternalTimePickerProps;

package/types/index.d.ts

@@ -6,3 +6,4 @@ export * from './date-time-picker';
 export * from './mask-hook';
 export * from './text-input';
 export * from './toggle';
+export * from './large-text-input';

package/types/large-text-input/DSControlledLargeTextInput.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import type { DSControlledLargeTextInputT } from './react-desc-prop-types';
+declare const DSControlledLargeTextInput: (props: DSControlledLargeTextInputT.Props) => JSX.Element;
+declare const DSControlledLargeTextInputWithSchema: import("@elliemae/ds-props-helpers/types/propTypes/types").DocumentedReactComponent<DSControlledLargeTextInputT.Props>;
+export { DSControlledLargeTextInput, DSControlledLargeTextInputWithSchema };

package/types/large-text-input/exported-related/data-test-ids.d.ts

@@ -0,0 +1,5 @@
+export declare const DSControlledLargetTextInputDatatestids: {
+    CONTAINER: string;
+    CHAR_COUNTER: string;
+    INPUT: string;
+};

package/types/large-text-input/exported-related/index.d.ts

@@ -0,0 +1,2 @@
+export * from './data-test-ids';
+export * from './theming';

package/types/large-text-input/exported-related/theming.d.ts

@@ -0,0 +1,6 @@
+export declare const DSControlledLargeTextInputName = "ds-controlled-large-text-input";
+export declare const DSControlledLargeTextInputSlots: {
+    CONTAINER: string;
+    INPUT: string;
+    CHAR_COUNTER: string;
+};