@elliemae/ds-controlled-form 2.3.0-alpha.8 → 2.3.0-alpha.9

package/dist/types/controlled-date-range-picker/tests/date-range-picker.manual-delete-values.test.d.ts

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

package/dist/types/controlled-date-range-picker/tests/date-range-picker.types-dom.test.d.ts

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

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

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

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

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

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

@@ -0,0 +1,55 @@
+export declare const ControlledDateTimePickerDatatestid: {
+    DATE_INPUTS: {
+        MONTH: string;
+        DAY: string;
+        YEAR: string;
+    };
+    TIME_INPUTS: {
+        HOUR: string;
+        MINUTE: string;
+        MERIDIEM: string;
+    };
+    PICKER_ICONS: {
+        CALENDAR: string;
+        TIMEWHEEL: string;
+        CALENDAR_TIMEWHEEL: string;
+    };
+    CALENDAR: {
+        PREV_YEAR: string;
+        PREV_MONTH: string;
+        DAY: string;
+        FOCUSED_DAY: string;
+        START_RANGE_DAY: string;
+        IN_RANGE_DAY: string;
+        END_RANGE_DAY: string;
+        SELECTED_DAY: string;
+        SELECTED_FOCUSED_DAY: string;
+        NEXT_MONTH: string;
+        NEXT_YEAR: string;
+    };
+    TIMEWHEEL: {
+        PREV_HOUR: string;
+        HOUR: string;
+        CURRENT_HOUR: string;
+        NEXT_HOUR: string;
+        PREV_MINUTE: string;
+        MINUTE: string;
+        CURRENT_MINUTE: string;
+        NEXT_MINUTE: string;
+        PREV_MERIDIEM: string;
+        MERIDIEM: string;
+        CURRENT_MERIDIEM: string;
+        NEXT_MERIDIEM: string;
+    };
+    CONTEXTUAL_MENU: {
+        CALENDAR: string;
+        TIMEWHEEL: string;
+        CALENDAR_TIMEWHEEL: string;
+    };
+    CONTROLLER_COMPONENT: {
+        CALENDAR: string;
+        TIMEWHEEL: string;
+        CALENDAR_TIMEWHEEL: string;
+    };
+    CLEAR_BUTTON: string;
+};

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

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

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

@@ -0,0 +1,2 @@
+import type { DateTimePickerPropsT, ControlledDateTimePickerContextT } from '../index.d';
+export declare const useControlledDateTimePicker: (props: Partial<DateTimePickerPropsT>) => ControlledDateTimePickerContextT;

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

@@ -0,0 +1,4 @@
+import type { useGetDestructuredDateValuesAT, useGetDestructuredDateValuesRT, useGetDestructuredTimeValuesAT, useGetDestructuredTimeValuesRT, useGetDestructuredValuesAT, useGetDestructuredValuesRT } from '../index.d';
+export declare const useGetDestructuredDateValues: ({ date, dateTime, isDateTimeSelector, }: useGetDestructuredDateValuesAT) => useGetDestructuredDateValuesRT;
+export declare const useGetDestructuredTimeValues: ({ time, dateTime, isDateTimeSelector, }: useGetDestructuredTimeValuesAT) => useGetDestructuredTimeValuesRT;
+export declare const useGetDestructuredValues: ({ date, time, dateTime, isDateTimeSelector, }: useGetDestructuredValuesAT) => useGetDestructuredValuesRT;

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

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

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

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

package/dist/types/controlled-date-time-picker/index.d.ts

@@ -0,0 +1,7 @@
+export { DSControlledDateTimePickerWithSchema, DSControlledDateTimePicker } from './ControlledDateTimePicker';
+export { ControlledDateTimePickerDatatestid } from './ControlledDateTimePickerDatatestid';
+export { CONTROLLED_DATE_TIME_PICKER_TYPES } from './ControlledDateTimePickerTypes';
+export { deconstructValuesFromDateString, prependStringWithPlaceHolders } from './utils/stringHelpers';
+export { getValidationDateTimeStringMetaInfo } from './utils/dateTimeHelpers';
+export { getValidationDateStringMetaInfo, getDateStringFromDay, getDayFromDateString, getDateValuesFromDate, } from './utils/dateHelpers';
+export { getValidationTimeStringMetaInfo } from './utils/timeHelpers';

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

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const ClearButton: () => JSX.Element;

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

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

package/dist/types/controlled-date-time-picker/parts/ControlledDateTimePickerContent.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const ControlledDateTimePickerContent: () => JSX.Element;

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

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

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

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const DateInputs: () => JSX.Element;

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

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { onChangeFuncT, onBlurFuncT, onFocusFuncT, onKeyDownT } from '../../index.d';
+interface MMInputsPropsT {
+    onChange: onChangeFuncT;
+    onBlur: onBlurFuncT;
+    onFocus: onFocusFuncT;
+    onKeyDown: onKeyDownT;
+    autoFocusMonthInput: boolean;
+    value: string;
+    disabled: boolean;
+    contextRef: React.RefObject<HTMLInputElement>;
+    placeholder: string;
+    ariaCurrentValueForInputs: string;
+}
+export declare const MMInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, contextRef, autoFocusMonthInput, ariaCurrentValueForInputs, }: MMInputsPropsT) => JSX.Element>;
+export {};

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

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { onChangeFuncT, onBlurFuncT, onFocusFuncT, onKeyDownT } from '../../index.d';
+interface YYYYInputsPropsT {
+    onChange: onChangeFuncT;
+    onBlur: onBlurFuncT;
+    onFocus: onFocusFuncT;
+    onKeyDown: onKeyDownT;
+    value: string;
+    disabled: boolean;
+    contextRef: React.RefObject<HTMLInputElement>;
+    placeholder: string;
+    ariaCurrentValueForInputs: string;
+}
+export declare const YYYYInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, contextRef, ariaCurrentValueForInputs, }: YYYYInputsPropsT) => JSX.Element>;
+export {};

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

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

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

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const WrapWithCalendarContext: (Component: React.ComponentType) => () => JSX.Element;
+export declare const Calendar: () => JSX.Element;

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

@@ -0,0 +1,6 @@
+import React from 'react';
+interface CalendarBodyPropsT {
+    weekRowsNum: number;
+}
+export declare const CalendarBody: React.MemoExoticComponent<({ weekRowsNum }: CalendarBodyPropsT) => JSX.Element>;
+export {};

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

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export declare const CalendarContent: ({ className }: {
+    className?: string | undefined;
+}) => JSX.Element;

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const CalendarHead: () => JSX.Element;

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

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const CalendarIconTrigger: () => JSX.Element;

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

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const CalendarMonthDays: () => JSX.Element;

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

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const CalendarWeekDays: React.MemoExoticComponent<() => JSX.Element>;

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

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const CalendarWrapper: () => JSX.Element;

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

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { metaMonthDayT } from '../../../index.d';
+interface CalendarDayPropsT {
+    metaDay: metaMonthDayT;
+    colIndex?: number;
+    isInvisible?: boolean;
+}
+export declare const Day: ({ metaDay, colIndex, isInvisible }: CalendarDayPropsT) => JSX.Element;
+export {};

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

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+export declare const StyledIconTriggerButton: import("styled-components").StyledComponent<{
+    (props: import("@elliemae/ds-button/dist/types/v2/propTypes").DSButtonPropsT): JSX.Element;
+    propTypes: import("react").WeakValidationMap<unknown>;
+}, import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledShadowWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    isControllerOnly: boolean;
+}, never>;
+export declare const StyledCalendarWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledHeader: import("styled-components").StyledComponent<"section", import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledHeaderButton: import("styled-components").StyledComponent<{
+    (props: import("@elliemae/ds-button/dist/types/v2/propTypes").DSButtonPropsT): JSX.Element;
+    propTypes: import("react").WeakValidationMap<unknown>;
+}, import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledBody: import("styled-components").StyledComponent<"section", import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledDayBtn: import("styled-components").StyledComponent<{
+    (props: import("@elliemae/ds-button/dist/types/v2/propTypes").DSButtonPropsT): JSX.Element;
+    propTypes: import("react").WeakValidationMap<unknown>;
+}, import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledWeekDaysListWrapper: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("@elliemae/ds-grid/dist/types/types").GridPropsT & import("react").RefAttributes<HTMLDivElement>>, import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledWeekDaysHeaderItem: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const CalendarFooterMessage: import("styled-components").StyledComponent<"footer", import("styled-components").DefaultTheme, {}, never>;

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

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

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

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

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

@@ -0,0 +1,8 @@
+import type { metaMonthDayT } from '../../../index.d';
+import type { FocusLogicT } from './CalendarContext';
+interface useFocusLogicArgsT {
+    daysArray: metaMonthDayT[];
+    showCalendar: boolean;
+}
+export declare const useFocusLogic: ({ daysArray, showCalendar }: useFocusLogicArgsT) => FocusLogicT;
+export {};

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

@@ -0,0 +1,13 @@
+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;
+}
+export declare const useKeyboardHandlers: ({ focusedDay, daysArray, handlePrevMonth, handleNextMonth, handleFocusMetaDay, handleFocusMetaDayByDay, tryToFocusCurrentlyDataIsFocusedDay, }: useKeyboardHandlersArgsT) => KeyboardHandlersT;
+export {};

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

@@ -0,0 +1,12 @@
+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/dist/types/controlled-date-time-picker/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheel.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const CalendarWithTimeWheel: () => JSX.Element;

package/dist/types/controlled-date-time-picker/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheelContent.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const CalendarWithTimeWheelContent: () => JSX.Element;

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

@@ -0,0 +1,21 @@
+/// <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;
+}
+export declare const defaultCalendarWithTimeWheelContext: CalendarWithTimeWheelContextT;
+/** Context for cross component communication */
+export declare const CalendarWithTimeWheelContext: import("react").Context<CalendarWithTimeWheelContextT>;
+export default CalendarWithTimeWheelContext;

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

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

package/dist/types/controlled-date-time-picker/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheelIconTrigger.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const CalendarWithTimeWheelIconTrigger: () => JSX.Element;

package/dist/types/controlled-date-time-picker/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheelWrapper.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const CalendarWithTimeWheelWrapper: () => JSX.Element;

package/dist/types/controlled-date-time-picker/parts/Pickers/CalendarWithTimeWheel/Styleds.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+export declare const StyledIconTriggerButton: import("styled-components").StyledComponent<{
+    (props: import("@elliemae/ds-button/dist/types/v2/propTypes").DSButtonPropsT): JSX.Element;
+    propTypes: import("react").WeakValidationMap<unknown>;
+}, import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledCalendarWithTimeWheelWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    isControllerOnly: boolean;
+}, never>;
+export declare const StyledCalendar: import("styled-components").StyledComponent<({ className }: {
+    className?: string | undefined;
+}) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
+export declare const CalendarWithTimeWheelFooterMessage: import("styled-components").StyledComponent<"footer", import("styled-components").DefaultTheme, {}, never>;

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

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

package/dist/types/controlled-date-time-picker/parts/Pickers/PickersIcons.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const PickersIcons: () => JSX.Element;

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

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const HoursList: () => JSX.Element;

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

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare const MeridiemList: () => JSX.Element;
+export default MeridiemList;

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

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare const MinutesList: () => JSX.Element;
+export default MinutesList;

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

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare const SecondsList: () => JSX.Element;
+export default SecondsList;

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

@@ -0,0 +1,28 @@
+/// <reference types="react" />
+export declare const StyledIconTriggerButton: import("styled-components").StyledComponent<{
+    (props: import("@elliemae/ds-button/dist/types/v2/propTypes").DSButtonPropsT): JSX.Element;
+    propTypes: import("react").WeakValidationMap<unknown>;
+}, import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledWheelList: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+interface StyledWheelListItemPropsT {
+    isCurrentListItem?: boolean;
+    selected?: boolean;
+}
+export declare const StyledTimePickerContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    showShadow?: boolean | undefined;
+    isControllerOnly: boolean;
+}, never>;
+export declare const StyledTimePickerHead: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("@elliemae/ds-grid/dist/types/types").GridPropsT & import("react").RefAttributes<HTMLDivElement>>, import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledTimePickerWheelsLegend: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledTimePickerWheelWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledTimeBtn: import("styled-components").StyledComponent<{
+    (props: import("@elliemae/ds-button/dist/types/v2/propTypes").DSButtonPropsT): JSX.Element;
+    propTypes: import("react").WeakValidationMap<unknown>;
+}, import("styled-components").DefaultTheme, {}, never>;
+export declare const StyledWheelListItem: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, StyledWheelListItemPropsT, never>;
+export declare const StyledWheelChangeTimeBtn: import("styled-components").StyledComponent<{
+    (props: import("@elliemae/ds-button/dist/types/v2/propTypes").DSButtonPropsT): JSX.Element;
+    propTypes: import("react").WeakValidationMap<unknown>;
+}, import("styled-components").DefaultTheme, {}, never>;
+export declare const TimeWheelFooterMessage: import("styled-components").StyledComponent<"footer", import("styled-components").DefaultTheme, {}, never>;
+export {};

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

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const WrapWithTimeWheelContext: (Component: React.ComponentType) => () => JSX.Element;
+export declare const TimeWheel: () => JSX.Element;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const TimeWheelContent: React.MemoExoticComponent<({ showShadow }: {
+    showShadow?: boolean | undefined;
+}) => JSX.Element>;