@elliemae/ds-controlled-form 2.4.1-rc.5 → 2.4.1-rc.9

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/mask-hook/hooks/index.d.ts

@@ -1,4 +1,5 @@
 export * from './usePhoneMask';
 export * from './useNumberMask';
 export * from './useSSNMask';
+export * from './useRegExpMask';
 export * from './useZipCodeMask';

package/types/mask-hook/hooks/useRegExpMask.d.ts

@@ -0,0 +1,4 @@
+import { DSMaskT } from '../react-desc-prop-types';
+export declare const isRegExp: (item: RegExp | string) => item is RegExp;
+export declare const useRegExpMask: DSMaskT.Hook;
+export declare const UseRegExpMaskWithSchema: import("@elliemae/ds-props-helpers/types/propTypes/types").DocumentedReactComponent<DSMaskT.HookArgs>;

package/types/mask-hook/react-desc-prop-types.d.ts

@@ -22,13 +22,18 @@ export declare namespace DSMaskT {
     interface PhoneHookArgs extends HookArgs {
         isInternational: boolean;
     }
+    interface RegExpHookArgs extends HookArgs {
+        filledMask: boolean;
+    }
     type Hook = (args: HookArgs) => HookReturn;
     type PhoneHook = (args: PhoneHookArgs) => HookReturn;
     type NumberHook = (args: NumberHookArgs) => HookReturn;
 }
-export declare const DSMaskHookDefaultProps: Partial<DSMaskT.PhoneHookArgs>;
+export declare const DSMaskHookDefaultProps: Partial<DSMaskT.HookReturn>;
 export declare const DSMaskPhoneHookDefaultProps: Partial<DSMaskT.PhoneHookArgs>;
+export declare const DSMaskRegExpHookDefaultProps: Partial<DSMaskT.RegExpHookArgs>;
 export declare const DSMaskNumberHookDefaultProps: Partial<DSMaskT.NumberHookArgs>;
 export declare const DSMaskHookPropsTypes: React.WeakValidationMap<unknown>;
+export declare const DSMaskRegExpHookPropsTypes: React.WeakValidationMap<unknown>;
 export declare const DSMaskPhoneHookPropsTypes: React.WeakValidationMap<unknown>;
 export declare const DSMaskNumberHookPropsTypes: React.WeakValidationMap<unknown>;

package/types/mask-hook/tests/useRegExpMask.test.d.ts

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

package/types/mask-hook/utils/flatStringArray.d.ts

@@ -0,0 +1 @@
+export declare const flatStringArray: (stringArray: string[]) => string[];

package/types/mask-hook/utils/index.d.ts

@@ -2,3 +2,4 @@ export * from './addSpecialCharacters';
 export * from './getPartialMaskedPos';
 export * from './setCursorPosition';
 export * from './sharedFilters';
+export * from './flatStringArray';

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

@@ -1,2 +0,0 @@
-import { CalendarContextT } from './CalendarContext';
-export declare const useConfigCalendarCTX: () => CalendarContextT;

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

@@ -1,12 +0,0 @@
-import React from 'react';
-import type { metaMonthDayT } from '../../../index.d';
-import type { PopperTriggerLogicT } from './CalendarContext';
-interface usePopperTriggerLogicT {
-    tryToFocusCurrentlyDataIsFocusedDay: () => void;
-    resetFocusedDayToStartDate: () => void;
-    focusedDay: metaMonthDayT;
-    showCalendar: boolean;
-    setShowCalendar: React.Dispatch<React.SetStateAction<boolean>>;
-}
-export declare const usePopperTriggerLogic: ({ focusedDay, resetFocusedDayToStartDate, showCalendar, setShowCalendar, tryToFocusCurrentlyDataIsFocusedDay, }: usePopperTriggerLogicT) => PopperTriggerLogicT;
-export {};

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

@@ -1,2 +0,0 @@
-import type { PopperTriggerLogicT } from './TimeWheelContext';
-export declare const usePopperTriggerLogic: () => PopperTriggerLogicT;

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

@@ -1,81 +0,0 @@
-/// <reference path="../../../../../shared/typings/react-desc.d.ts" />
-export declare const 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;
-    };
-};