@elliemae/ds-controlled-form 2.4.2-rc.1 → 2.4.2-rc.13

package/types/checkbox/styles.d.ts

@@ -3,3 +3,4 @@ export declare const StyledCheckBox: any;
 export declare const StyledInput: any;
 export declare const StyledInputMixed: any;
 export declare const StyledLabel: any;
+export declare const StyledWrapLabel: any;

package/types/combobox/parts/menu-list/styled.d.ts

@@ -2,4 +2,5 @@ export declare const StyledListWrapper: any;
 export declare const StyledList: any;
 export declare const StyledVirtualListWrapper: any;
 export declare const StyledCreatableLabel: any;
+export declare const StyledCreatableValue: any;
 export declare const StyledNoResultsWrapper: any;

package/types/combobox/react-desc-prop-types.d.ts

@@ -31,11 +31,10 @@ export declare namespace DSComboboxT {
         menuMaxHeight?: number;
         placeholder?: string;
         autoFocus?: boolean;
-        filteredOptions: OptionTypes[];
+        isMenuOpen?: boolean;
+        onMenuChange?: (state: boolean, reason: string, e: Event) => void;
         onCreate?: (label: string) => void;
-        onFilter?: (newOptions: OptionTypes[], inputValue: string) => void;
-        onMenuOpen?: () => void;
-        onMenuClose?: () => void;
+        onFilter?: (newOptions: OptionTypes[], inputValue?: string) => void;
         onCancel?: () => void;
         onBlur?: () => void;
         onSelectAll?: (suggestedValue: OptionTypes[] | [], event: React.MouseEvent | React.KeyboardEvent) => null;
@@ -49,11 +48,13 @@ export declare namespace DSComboboxT {
     interface DefaultProps {
         startPlacementPreference: string;
         placementOrderPreference: string[];
+        filteredOptions: OptionTypes[];
         hasError: boolean;
         inline: boolean;
         withoutPortal: boolean;
         zIndex: number;
         disabled: boolean;
+        noOptionsMessage: string;
         innerRef: React.RefObject<HTMLInputElement>;
         useMask: DSMaskT.Hook | typeof noop;
     }
@@ -70,12 +71,13 @@ export declare const ComboboxPropTypes: {
     disabled: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
     autoFocus: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
     hasError: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+    noOptionsMessage: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+    closeMenuOnScroll: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
     onChange: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
     onFilter: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
     onCreate: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
     onCancel: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
-    onMenuOpen: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
-    onMenuClose: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
+    onMenuChange: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
     inputMinWidth: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
     menuMinWidth: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;
     menuMaxHeight: import("@elliemae/ds-props-helpers/types/propTypes/types").ReactDescT;

package/types/combobox/sharedTypes.d.ts

@@ -1,11 +1,11 @@
-/// <reference types="react" />
+import React from 'react';
 import { useVirtual } from 'react-virtual';
 import { DSComboboxT } from './react-desc-prop-types';
 export declare namespace DSComboboxInternalsT {
     interface ComboBoxContextT {
         props: DSComboboxT.InternalProps;
         virtualListHelpers?: ReturnType<typeof useVirtual>;
-        showPopover: boolean;
+        menuState: boolean;
         setShowPopover: React.Dispatch<React.SetStateAction<boolean>>;
         referenceElement: HTMLElement | null;
         setReferenceElement: React.Dispatch<React.SetStateAction<HTMLElement | null>>;
@@ -25,6 +25,7 @@ export declare namespace DSComboboxInternalsT {
         setFocusOptionIdx: React.Dispatch<React.SetStateAction<string>>;
         showSelectedOptions: boolean;
         setShowSelectedOptions: React.Dispatch<React.SetStateAction<boolean>>;
+        setMenuState: (newState: boolean, reason?: string, e?: React.KeyboardEvent | React.MouseEvent | React.ChangeEvent<HTMLInputElement>) => void;
     }
 }
 export declare const isSeparator: (el: DSComboboxT.OptionTypes | undefined) => el is DSComboboxT.ItemSeparatorOptions;

package/types/combobox/utils/listHelper.d.ts

@@ -11,3 +11,4 @@ export declare const getSuggestedValueOnChange: (selectedOption: DSComboboxT.Ite
 export declare const filterOptions: (inputValue: string, options: DSComboboxT.OptionTypes[]) => DSComboboxT.OptionTypes[];
 export declare const selectedValuesWithSections: (optionsToParse: DSComboboxT.OptionTypes[], multiSelectedValue: DSComboboxT.ItemOption[]) => DSComboboxT.OptionTypes[];
 export declare const getFilteredOptionsSelected: (filteredOption: DSComboboxT.OptionTypes[], selectedValues: DSComboboxT.ItemOption[]) => DSComboboxT.OptionTypes[];
+export declare const scrollIfNeeded: (elem: HTMLElement, options?: ScrollIntoViewOptions | undefined) => void;

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

@@ -2,6 +2,7 @@ import { useRelevantValueFromProps } from './useRelevantValueFromProps';
 import { useGetDestructuredValues } from './useGetDestructuredValues';
 import { useGetPropsBasedOnType } from './useGetPropsBasedOnType';
 import { useGetReferences } from './useGetReferences';
+import { useFocusTracker } from './useFocusTracker';
 import type { DSControlledDateTimePickerT } from '../propTypes';
 import type { DSControlledDateTimePickerInternalsT } from '../sharedTypes';
 interface Config {
@@ -9,8 +10,9 @@ interface Config {
     destructuredValues: ReturnType<typeof useGetDestructuredValues>;
     propsBasedOnType: ReturnType<typeof useGetPropsBasedOnType>;
     DOMRefs: ReturnType<typeof useGetReferences>;
+    focusTrackers: ReturnType<typeof useFocusTracker>;
 }
-export declare const useChangeHandlers: ({ relevantValues, destructuredValues, propsBasedOnType, DOMRefs }: Config) => {
+export declare const useChangeHandlers: ({ relevantValues, destructuredValues, propsBasedOnType, focusTrackers }: 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;

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

@@ -1,4 +1,4 @@
-import React from 'react';
+import { useFocusTracker } from './useFocusTracker';
 import { useGetFlags } from './useGetFlags';
 import { useGetReferences } from './useGetReferences';
 import { useRelevantValueFromProps } from './useRelevantValueFromProps';
@@ -7,12 +7,9 @@ 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> & {
+export declare type ControlledDateTimePickerContextT = ReturnType<typeof useGetFlags> & ReturnType<typeof useFocusTracker> & 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/useFocusTracker.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="react" />
+import { useGetReferences } from './useGetReferences';
+import { useGetFlags } from './useGetFlags';
+declare type LatestInteractionRegion = 'calendar-days' | 'calendar-head' | 'timewheel' | 'date-inputs' | 'time-inputs' | 'clear-btn' | 'picker-icon' | '';
+declare type CurrFocusDescriber = 'first-segment' | 'month-input' | 'day-input' | 'year-input' | 'hour-input' | 'minute-input' | 'meridiem-input' | 'last-segment' | 'clear-btn' | 'date-picker-icon' | 'time-picker-icon' | 'datetime-picker-icon' | 'calendar-prev-month' | 'calendar-next-month' | 'calendar-prev-year' | 'calendar-next-year' | 'calendar-metafocused-day' | 'timewheel-curr-hour' | 'timewheel-curr-minute' | 'timewheel-curr-meridiem' | '';
+interface Config {
+    DOMRefs: ReturnType<typeof useGetReferences>;
+    flags: ReturnType<typeof useGetFlags>;
+}
+export declare const useFocusTracker: ({ DOMRefs, flags }: Config) => {
+    latestInteractionRegion: LatestInteractionRegion;
+    setLatestInteractionRegion: import("react").Dispatch<import("react").SetStateAction<LatestInteractionRegion>>;
+    currFocusDescriber: CurrFocusDescriber;
+    setCurrFocusDescriber: import("react").Dispatch<import("react").SetStateAction<CurrFocusDescriber>>;
+    trackFocusResetter: () => void;
+    trackFocusMonthInput: () => void;
+    trackFocusDayInput: () => void;
+    trackFocusYearInput: () => void;
+    trackFocusHourInput: () => void;
+    trackFocusMinuteInput: () => void;
+    trackFocusMeridiemInput: () => void;
+    trackFocusClearBtn: () => void;
+    trackFocusDatePickerIcon: () => void;
+    trackFocusTimePickerIcon: () => void;
+    trackFocusDatetimePickerIcon: () => void;
+    trackFocusCalendarPrevMonth: () => void;
+    trackFocusCalendarNextMonth: () => void;
+    trackFocusCalendarPrevYear: () => void;
+    trackFocusCalendarNextYear: () => void;
+    trackFocusCalendarMetafocusedDay: () => void;
+    trackFocusTimewheelCurrHour: () => void;
+    trackFocusTimewheelCurrMinute: () => void;
+    trackFocusTimewheelCurrMeridiem: () => void;
+    trackFocusPicker: () => void;
+    trackFocusFirstSegment: () => void;
+    trackFocusLastSegment: () => void;
+};
+export {};

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

@@ -1,16 +1,16 @@
 import type { DSControlledDateTimePickerT } from '../propTypes';
 export declare const useGetPropsBasedOnType: (propsWithDefaults: DSControlledDateTimePickerT.InternalProps) => {
-    getIsDisabledDay: any;
-    getIsOutOfRangeDay: any;
-    getIsStartRangeDay: any;
-    getIsDayInRange: any;
-    getIsEndRangeDay: any;
+    getIsDisabledDay: BooleanGetter<string>;
+    getIsOutOfRangeDay: BooleanGetter<string>;
+    getIsStartRangeDay: BooleanGetter<string> | (() => void);
+    getIsDayInRange: BooleanGetter<string> | (() => void);
+    getIsEndRangeDay: BooleanGetter<string> | (() => void);
     appOnDateChange: DSControlledDateTimePickerT.OnDateChange;
     appOnMonthChange: DSControlledDateTimePickerT.OnInternalInputsChange;
     appOnDayChange: DSControlledDateTimePickerT.OnInternalInputsChange;
     appOnYearChange: DSControlledDateTimePickerT.OnInternalInputsChange;
     appDate: string;
-    getIsDisabledTime: any;
+    getIsDisabledTime: BooleanGetter<string>;
     appOnTimeChange: DSControlledDateTimePickerT.OnTimeChange;
     appOnHourChange: DSControlledDateTimePickerT.OnInternalInputsChange;
     appOnMinuteChange: DSControlledDateTimePickerT.OnInternalInputsChange;

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

@@ -1,39 +1,33 @@
 /// <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;
-    };
+declare type FirstSegment = 'month-input' | 'hour-input' | 'date-picker-icon' | 'time-picker-icon' | 'datetime-picker-icon' | '';
+declare type LastSegment = 'year-input' | 'meridiem-input' | 'clear-btn' | 'date-picker-icon' | 'time-picker-icon' | 'datetime-picker-icon' | '';
+export declare const useGetReferences: ({ isWithDateInputs, isWithTimeInputs, isDateSelector, isTimeSelector, isDateTimeSelector, withAnyPicker, withClearBtn, }: ReturnType<typeof useGetFlags>) => {
+    monthInputRef: import("react").MutableRefObject<HTMLInputElement>;
+    dayInputRef: import("react").MutableRefObject<HTMLInputElement>;
+    yearInputRef: import("react").MutableRefObject<HTMLInputElement>;
+    hourInputRef: import("react").MutableRefObject<HTMLInputElement>;
+    minutesInputRef: import("react").MutableRefObject<HTMLInputElement>;
+    meridiemInputRef: import("react").MutableRefObject<HTMLInputElement>;
+    clearButtonRef: import("react").MutableRefObject<HTMLButtonElement>;
+    pickerButtonRef: import("react").MutableRefObject<HTMLButtonElement>;
+    prevYearBtnRef: import("react").MutableRefObject<HTMLButtonElement>;
+    prevMonthBtnRef: import("react").MutableRefObject<HTMLButtonElement>;
+    nextMonthBtnRef: import("react").MutableRefObject<HTMLButtonElement>;
+    nextYearBtnRef: import("react").MutableRefObject<HTMLButtonElement>;
+    calendarDaysWrapperRef: import("react").MutableRefObject<HTMLDivElement>;
+    prevHourBtnRef: import("react").MutableRefObject<HTMLButtonElement>;
+    currHourBtnRef: import("react").MutableRefObject<HTMLButtonElement>;
+    nextHourBtnRef: import("react").MutableRefObject<HTMLButtonElement>;
+    prevMinutesBtnRef: import("react").MutableRefObject<HTMLButtonElement>;
+    currMinutesBtnRef: import("react").MutableRefObject<HTMLButtonElement>;
+    nextMinutesBtnRef: import("react").MutableRefObject<HTMLButtonElement>;
+    prevMeridiemBtnRef: import("react").MutableRefObject<HTMLButtonElement>;
+    currMeridiemBtnRef: import("react").MutableRefObject<HTMLButtonElement>;
+    nextMeridiemBtnRef: import("react").MutableRefObject<HTMLButtonElement>;
+    firstSegmentRef: import("react").MutableRefObject<HTMLInputElement | HTMLButtonElement>;
+    lastSegmentRef: import("react").MutableRefObject<HTMLInputElement | HTMLButtonElement>;
+    firstSegment: FirstSegment;
+    lastSegment: LastSegment;
 };
+export {};

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

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

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

@@ -10,6 +10,7 @@ interface DDInputsPropsT {
     placeholder: string;
     ariaCurrentValueForInputs: string;
     contextRef: React.MutableRefObject<HTMLInputElement | null>;
+    isFocused: boolean;
 }
-export declare const DDInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, contextRef, placeholder, ariaCurrentValueForInputs, }: DDInputsPropsT) => JSX.Element>;
+export declare const DDInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, contextRef, placeholder, ariaCurrentValueForInputs, isFocused, }: DDInputsPropsT) => JSX.Element>;
 export {};

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

@@ -11,6 +11,7 @@ interface MMInputsPropsT {
     contextRef: React.MutableRefObject<HTMLInputElement | null>;
     placeholder: string;
     ariaCurrentValueForInputs: string;
+    isFocused: boolean;
 }
-export declare const MMInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, contextRef, autoFocusMonthInput, ariaCurrentValueForInputs, }: MMInputsPropsT) => JSX.Element>;
+export declare const MMInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, contextRef, autoFocusMonthInput, ariaCurrentValueForInputs, isFocused, }: MMInputsPropsT) => JSX.Element>;
 export {};

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

@@ -10,6 +10,7 @@ interface YYYYInputsPropsT {
     contextRef: React.MutableRefObject<HTMLInputElement | null>;
     placeholder: string;
     ariaCurrentValueForInputs: string;
+    isFocused: boolean;
 }
-export declare const YYYYInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, contextRef, ariaCurrentValueForInputs, }: YYYYInputsPropsT) => JSX.Element>;
+export declare const YYYYInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, contextRef, ariaCurrentValueForInputs, isFocused, }: YYYYInputsPropsT) => JSX.Element>;
 export {};

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

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { useCurrentDisplayedMonthYearLogic } from './useCurrentDisplayedMonthYearLogic';
+import { useFocusLogic } from './useFocusLogic';
+import { usePopperTriggerLogic } from './usePopperTriggerLogic';
+import { useKeyboardHandlers } from './useKeyboardHandlers';
+export declare type CalendarContextT = ReturnType<typeof useCurrentDisplayedMonthYearLogic> & ReturnType<typeof useFocusLogic> & ReturnType<typeof usePopperTriggerLogic> & ReturnType<typeof useKeyboardHandlers> & {
+    showCalendar: boolean;
+    setShowCalendar: StateSetter<boolean>;
+    onPrevYearFocus: React.FocusEventHandler;
+    onPrevMonthFocus: React.FocusEventHandler;
+    onNextMonthFocus: React.FocusEventHandler;
+    onNextYearFocus: React.FocusEventHandler;
+};
+export declare const useConfigCalendarCTX: () => CalendarContextT;

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

@@ -6,10 +6,9 @@ interface UseFocusLogicArgsT {
 }
 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 declare const useFocusLogic: ({ currentDisplayedMonthLogic }: UseFocusLogicArgsT) => FocusLogicT;
 export {};

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

@@ -0,0 +1,19 @@
+import React from 'react';
+import { usePopper } from 'react-popper';
+import { useFocusLogic } from './useFocusLogic';
+interface UsePopperTriggerLogic {
+    focusLogic: ReturnType<typeof useFocusLogic>;
+    showCalendar: boolean;
+    setShowCalendar: StateSetter<boolean>;
+}
+interface PopperTriggerLogicT {
+    closeCalendar: () => void;
+    setPopperElement: StateSetter<HTMLDivElement | null>;
+    setArrowElement: StateSetter<HTMLDivElement | null>;
+    usePopperHelpers: ReturnType<typeof usePopper>;
+    handleToggleCalendar: () => void;
+    handleSetTriggerRef: (instance: HTMLButtonElement) => void;
+    handleMenuWrapperKeyDown: (e: React.KeyboardEvent<HTMLElement>) => void;
+}
+export declare const usePopperTriggerLogic: ({ focusLogic, showCalendar, setShowCalendar, }: UsePopperTriggerLogic) => PopperTriggerLogicT;
+export {};

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

@@ -4,15 +4,9 @@ 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;

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

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { usePopper } from 'react-popper';
+interface PopperTriggerLogicT {
+    showTimePicker: boolean;
+    setShowTimePicker: StateSetter<boolean>;
+    setPopperElement: StateSetter<HTMLDivElement>;
+    setArrowElement: StateSetter<HTMLDivElement>;
+    usePopperHelpers: ReturnType<typeof usePopper>;
+    handleToggleTimePicker: () => void;
+    handleSetTriggerRef: (instance: HTMLButtonElement) => void;
+    handleMenuWrapperKeyDown: (e: React.KeyboardEvent<HTMLElement>) => void;
+}
+export declare const usePopperTriggerLogic: () => PopperTriggerLogicT;
+export {};

package/types/date-time-picker/parts/TimeInputs/HHInput.d.ts

@@ -11,6 +11,7 @@ interface HHInputsPropsT {
     placeholder: string;
     ariaCurrentValueForInputs: string;
     autoFocusHourInput: boolean;
+    isFocused: boolean;
 }
-export declare const HHInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, ariaCurrentValueForInputs, contextRef, autoFocusHourInput, }: HHInputsPropsT) => JSX.Element>;
+export declare const HHInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, ariaCurrentValueForInputs, contextRef, autoFocusHourInput, isFocused, }: HHInputsPropsT) => JSX.Element>;
 export {};

package/types/date-time-picker/parts/TimeInputs/MeridiemInput.d.ts

@@ -10,6 +10,7 @@ interface MeridiemInputsPropsT {
     contextRef: React.MutableRefObject<HTMLInputElement | null>;
     placeholder: string;
     ariaCurrentValueForInputs: string;
+    isFocused: boolean;
 }
-export declare const MeridiemInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, ariaCurrentValueForInputs, contextRef, }: MeridiemInputsPropsT) => JSX.Element>;
+export declare const MeridiemInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, ariaCurrentValueForInputs, contextRef, isFocused, }: MeridiemInputsPropsT) => JSX.Element>;
 export {};

package/types/date-time-picker/parts/TimeInputs/MinutesInput.d.ts

@@ -10,6 +10,7 @@ interface MinutesInputsPropsT {
     contextRef: React.MutableRefObject<HTMLInputElement | null>;
     placeholder: string;
     ariaCurrentValueForInputs: string;
+    isFocused: boolean;
 }
-export declare const MinutesInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, ariaCurrentValueForInputs, contextRef, }: MinutesInputsPropsT) => JSX.Element>;
+export declare const MinutesInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, ariaCurrentValueForInputs, contextRef, isFocused, }: MinutesInputsPropsT) => JSX.Element>;
 export {};

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

@@ -0,0 +1,117 @@
+import React from 'react';
+export declare namespace DSControlledDateTimePickerT {
+    type OnInternalValuesChangeEvent = React.ChangeEvent<HTMLInputElement> | React.KeyboardEvent<HTMLInputElement> | React.KeyboardEvent<HTMLButtonElement> | React.KeyboardEvent | React.MouseEvent<HTMLInputElement> | React.MouseEvent<HTMLButtonElement>;
+    type ControlTypes = 'full-date-time' | 'date-time-inputs' | 'date-time-picker' | 'date-time-picker-controller-only' | 'full-date' | 'date-inputs' | 'date-picker' | 'date-picker-controller-only' | 'full-time' | 'time-inputs' | 'time-picker' | 'time-picker-controller-only';
+    interface InternalInputsChangeMetaInfo {
+        isAutomaticFillTrigger?: boolean;
+        isDayPresentInMonth?: boolean;
+        isOutOfRangeDay?: boolean;
+        isDisabledDay?: boolean;
+        isDisabledTime?: boolean;
+        suggestedErrorMsg?: string;
+        newDateTimeString?: string;
+        newDateString?: string;
+        newTimeString?: string;
+    }
+    type OnDateChange = (val: string, metaInfo: InternalInputsChangeMetaInfo) => void;
+    type OnTimeChange = (val: string, metaInfo: InternalInputsChangeMetaInfo) => void;
+    type OnDateTimeChange = (val: string, metaInfo: InternalInputsChangeMetaInfo) => void;
+    type OnInternalInputsChange = (val: string, e: OnInternalValuesChangeEvent, metaInfo?: InternalInputsChangeMetaInfo) => void;
+    interface DefaultDateProps {
+        onMonthChange: OnInternalInputsChange;
+        onDayChange: OnInternalInputsChange;
+        onYearChange: OnInternalInputsChange;
+        onPickerOpen: NoopishFunc;
+        onPickerClose: NoopishFunc;
+        getIsDisabledDay: BooleanGetter<string>;
+        getIsOutOfRangeDay: BooleanGetter<string>;
+        getIsStartRangeDay: BooleanGetter<string>;
+        getIsDayInRange: BooleanGetter<string>;
+        getIsEndRangeDay: BooleanGetter<string>;
+        isClearable: boolean;
+        disabled: boolean;
+        hasError: boolean;
+        autoFocus: boolean;
+        preventCloseOnSelection: boolean;
+    }
+    interface OptionalDatePickerProps {
+        emptyPickerStartingMonth?: string;
+        onCalendarOpenFocusedDay?: string;
+        pickerFooterMsg?: string;
+    }
+    interface RequiredDatePickerProps {
+        type: 'full-date' | 'date-inputs' | 'date-picker' | 'date-picker-controller-only';
+        date: string;
+        onDateChange: OnDateChange;
+    }
+    type DatePickerProps = OptionalDatePickerProps & Partial<DefaultDateProps> & RequiredDatePickerProps;
+    type InternalDatePickerProps = OptionalDatePickerProps & DefaultDateProps & RequiredDatePickerProps;
+    interface DefaultTimeProps {
+        onHourChange: OnInternalInputsChange;
+        onMinuteChange: OnInternalInputsChange;
+        onMeridiemChange: OnInternalInputsChange;
+        onPickerOpen: NoopishFunc;
+        onPickerClose: NoopishFunc;
+        getIsDisabledTime: BooleanGetter<string>;
+        minutesInterval: number;
+        isClearable: boolean;
+        disabled: boolean;
+        hasError: boolean;
+        autoFocus: boolean;
+        preventCloseOnSelection: boolean;
+    }
+    interface OptionalTimePickerProps {
+        pickerFooterMsg?: string;
+        onTimeWheelOpenStartingTime?: string;
+    }
+    interface RequiredTimePickerProps {
+        type: 'full-time' | 'time-inputs' | 'time-picker' | 'time-picker-controller-only';
+        time: string;
+        onTimeChange: OnTimeChange;
+    }
+    type TimePickerProps = OptionalTimePickerProps & Partial<DefaultTimeProps> & RequiredTimePickerProps;
+    type InternalTimePickerProps = OptionalTimePickerProps & DefaultTimeProps & RequiredTimePickerProps;
+    type DefaultDateTimeProps = DefaultTimeProps & DefaultDateProps & {
+        onDateChange: OnDateChange;
+        onTimeChange: OnTimeChange;
+    };
+    type OptionalDateTimeProps = OptionalTimePickerProps & OptionalDatePickerProps;
+    interface RequiredDateTimeProps {
+        type: 'full-date-time' | 'date-time-inputs' | 'date-time-picker' | 'date-time-picker-controller-only';
+        dateTime: string;
+        onDateTimeChange: OnDateTimeChange;
+    }
+    type DateTimePickerProps = Partial<DefaultDateTimeProps> & OptionalDateTimeProps & RequiredDateTimeProps;
+    type InternalDateTimePickerProps = DefaultDateTimeProps & OptionalDateTimeProps & RequiredDateTimeProps;
+    type DefaultProps = DefaultDateTimeProps & {
+        type: 'full-date-time';
+    };
+    type Props = DateTimePickerProps | DatePickerProps | TimePickerProps;
+    type InternalProps = InternalDateTimePickerProps | InternalDatePickerProps | InternalTimePickerProps;
+}
+export declare const defaultProps: DSControlledDateTimePickerT.DefaultProps;
+export declare const propTypes: {
+    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;
+};

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

@@ -10,7 +10,7 @@ export declare namespace DSControlledDateTimePickerInternalsT {
         isNextMonthDay: boolean;
         isCurrMonthDay: boolean;
         isHidden: boolean;
-        dayBtnRef: React.RefObject<HTMLButtonElement>;
+        dayBtnRef: React.MutableRefObject<HTMLButtonElement>;
     }
     type OnKeyDown<HTMLT = HTMLInputElement> = (e: React.KeyboardEvent<HTMLT>) => void;
     type OnChangeFunc = (e: React.ChangeEvent<HTMLInputElement>) => void;

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

@@ -33,12 +33,6 @@ export declare const announcableCardinalDays: {
     readonly 30: "thirtieth";
     readonly 31: "thirty first";
 };
-export declare const homeEndAllArrowKeys: string[];
-export declare const homeEndKeys: string[];
-export declare const homeEndArrowUpDownDashSlashesKeys: string[];
-export declare const homeEndArrowUpDownSpaceKeys: string[];
-export declare const homeEndArrowUpDownSemiKeys: string[];
-export declare const homeEndArrowUpDownKeys: string[];
 export declare const defaultMetaInfo: {
     isAutomaticFillTrigger: boolean;
 };

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

@@ -0,0 +1,6 @@
+export declare const InputGroupDataTestIds: {
+    CONTAINER: string;
+    LEFTADDON: string;
+    RIGHTADDON: string;
+    INPUTCONTAINER: string;
+};

package/types/input-group/exported-related/index.d.ts

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

package/types/input-group/exported-related/theming.d.ts

@@ -0,0 +1,6 @@
+export declare const DSInputGroupName = "ds-input-group";
+export declare const DSInputGroupSlots: {
+    CONTAINER: string;
+    LEFT_ADDON: string;
+    RIGHT_ADDON: string;
+};

package/types/input-group/styled.d.ts

@@ -1,7 +1,4 @@
-/// <reference types="react" />
-export declare const StyledContainer: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("@elliemae/ds-grid/types/react-desc-prop-types").DSGridT.Props & import("react").RefAttributes<HTMLDivElement>>, import("styled-components").DefaultTheme, {
-    cols: string[];
-}, never>;
-export declare const StyledLeftAddon: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
-export declare const StyledRightAddon: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
-export declare const StyledInput: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledContainer: any;
+export declare const StyledLeftAddon: any;
+export declare const StyledRightAddon: any;
+export declare const StyledInput: any;