@elliemae/ds-form-date-time-picker 3.17.0-next.9 → 3.17.0

package/dist/types/parts/DateInputs/YYYYInput.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes.js';
+interface YYYYInputsPropsT {
+    onChange: DSControlledDateTimePickerInternalsT.OnChangeFunc;
+    onBlur: DSControlledDateTimePickerInternalsT.OnBlurFunc;
+    onFocus: DSControlledDateTimePickerInternalsT.OnFocusFunc;
+    onKeyDown: DSControlledDateTimePickerInternalsT.OnKeyDown;
+    value: string;
+    disabled: boolean;
+    contextRef: React.MutableRefObject<HTMLInputElement | null>;
+    placeholder: string;
+    ariaCurrentValueForInputs: string;
+    isFocused: boolean;
+    ariaAndDataProps?: AriaAndDataProps;
+}
+export declare const YYYYInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, contextRef, ariaCurrentValueForInputs, isFocused, ariaAndDataProps, }: YYYYInputsPropsT) => JSX.Element>;
+export {};

package/dist/types/parts/DateInputs/useDateInputs.d.ts

@@ -0,0 +1,2 @@
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes.js';
+export declare const useDateInputs: () => DSControlledDateTimePickerInternalsT.UseDateInputsR;

package/dist/types/parts/Pickers/Calendar/Calendar.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare const WrappedCalendarContext: ({ children }: {
+    children: JSX.Element;
+}) => import("react/jsx-runtime.js").JSX.Element;
+export declare const Calendar: () => import("react/jsx-runtime.js").JSX.Element;

package/dist/types/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) => import("react/jsx-runtime.js").JSX.Element>;
+export {};

package/dist/types/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/parts/Pickers/Calendar/CalendarContext.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import type { CalendarContextT } from './useConfigCalendarCTX.js';
+export declare const defaultCalendarContext: CalendarContextT;
+/** Context for cross component communication */
+export declare const CalendarContext: import("react").Context<CalendarContextT>;
+export default CalendarContext;

package/dist/types/parts/Pickers/Calendar/CalendarDaysList.d.ts

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

package/dist/types/parts/Pickers/Calendar/CalendarFooter.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const CalendarFooter: React.ComponentType;

package/dist/types/parts/Pickers/Calendar/CalendarHead.d.ts

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

package/dist/types/parts/Pickers/Calendar/CalendarIconTrigger.d.ts

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

package/dist/types/parts/Pickers/Calendar/CalendarMonthDays.d.ts

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

package/dist/types/parts/Pickers/Calendar/CalendarWeekDays.d.ts

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

package/dist/types/parts/Pickers/Calendar/CalendarWrapper.d.ts

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

package/dist/types/parts/Pickers/Calendar/Day.d.ts

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

package/dist/types/parts/Pickers/Calendar/Styleds.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+export declare const StyledIconTriggerButton: import("styled-components").StyledComponent<import("react").ComponentType<import("@elliemae/ds-button").DSButtonT.Props>, import("@elliemae/ds-system").Theme, object, never>;
+export declare const StyledShadowWrapper: import("styled-components").StyledComponent<keyof JSX.IntrinsicElements, import("@elliemae/ds-system").Theme, Record<string, unknown> & object, never>;
+export declare const StyledCalendarWrapper: import("styled-components").StyledComponent<keyof JSX.IntrinsicElements, import("@elliemae/ds-system").Theme, Record<string, unknown> & object, never>;
+export declare const StyledHeader: import("styled-components").StyledComponent<keyof JSX.IntrinsicElements, import("@elliemae/ds-system").Theme, Record<string, unknown> & object, never>;
+export declare const StyledHeaderLabel: import("styled-components").StyledComponent<"h3", import("@elliemae/ds-system").Theme, object, never>;
+export declare const StyledHeaderButton: import("styled-components").StyledComponent<import("react").ComponentType<import("@elliemae/ds-button").DSButtonT.Props>, import("@elliemae/ds-system").Theme, object, never>;
+export declare const StyledBody: import("styled-components").StyledComponent<keyof JSX.IntrinsicElements, import("@elliemae/ds-system").Theme, Record<string, unknown> & object, never>;
+export declare const StyledDayBtn: import("styled-components").StyledComponent<import("react").ComponentType<import("@elliemae/ds-button").DSButtonT.Props>, import("@elliemae/ds-system").Theme, object, never>;
+export declare const StyledWeekDaysListWrapper: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("@elliemae/ds-grid/dist/types/react-desc-prop-types.js").DSGridT.Props & import("react").RefAttributes<HTMLDivElement>>, import("@elliemae/ds-system").Theme, {
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+} & {
+    theme?: import("@elliemae/ds-system").Theme | undefined;
+} & {
+    as?: string | import("react").ComponentType<any> | undefined;
+    forwardedAs?: string | import("react").ComponentType<any> | undefined;
+}, never>;
+export declare const StyledWeekDaysHeaderItem: import("styled-components").StyledComponent<keyof JSX.IntrinsicElements, import("@elliemae/ds-system").Theme, Record<string, unknown> & object, never>;
+export declare const CalendarFooterMessage: import("styled-components").StyledComponent<"footer", import("@elliemae/ds-system").Theme, object, never>;

package/dist/types/parts/Pickers/Calendar/useConfigCalendarCTX.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { useCurrentDisplayedMonthYearLogic } from './useCurrentDisplayedMonthYearLogic.js';
+import { useFocusLogic } from './useFocusLogic.js';
+import { usePopperTriggerLogic } from './usePopperTriggerLogic.js';
+import { useKeyboardHandlers } from './useKeyboardHandlers.js';
+export 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/dist/types/parts/Pickers/Calendar/useCurrentDisplayedMonthYearLogic.d.ts

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

package/dist/types/parts/Pickers/Calendar/useFocusLogic.d.ts

@@ -0,0 +1,14 @@
+import type { useCurrentDisplayedMonthYearLogic } from './useCurrentDisplayedMonthYearLogic.js';
+import type { DSControlledDateTimePickerInternalsT } from '../../../sharedTypes.js';
+interface UseFocusLogicArgsT {
+    currentDisplayedMonthLogic: ReturnType<typeof useCurrentDisplayedMonthYearLogic>;
+    showCalendar: boolean;
+}
+interface FocusLogicT {
+    focusedDay?: DSControlledDateTimePickerInternalsT.MetaMonthDay;
+    resetFocusedDayToStartDate: () => void;
+    handleFocusMetaDay: (metaDayToFocus: DSControlledDateTimePickerInternalsT.MetaMonthDay) => void;
+    handleFocusMetaDayByDay: (day: Date) => void;
+}
+export declare const useFocusLogic: ({ currentDisplayedMonthLogic }: UseFocusLogicArgsT) => FocusLogicT;
+export {};

package/dist/types/parts/Pickers/Calendar/useKeyboardHandlers.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import type { DSControlledDateTimePickerInternalsT } from '../../../sharedTypes.js';
+import type { useFocusLogic } from './useFocusLogic.js';
+import type { useCurrentDisplayedMonthYearLogic } from './useCurrentDisplayedMonthYearLogic.js';
+interface UseKeyboardHandlersArgsT {
+    currentDisplayedMonthLogic: ReturnType<typeof useCurrentDisplayedMonthYearLogic>;
+    focusLogic: ReturnType<typeof useFocusLogic>;
+}
+type HandleDayOnKeyDownT = (e: React.KeyboardEvent, day: DSControlledDateTimePickerInternalsT.MetaMonthDay) => void;
+interface KeyboardHandlersT {
+    handleDayOnKeyDown: HandleDayOnKeyDownT;
+    handlePrevYearKeyDown: (e: React.KeyboardEvent) => void;
+    handlePrevMonthKeyDown: (e: React.KeyboardEvent) => void;
+    handleNextMonthKeyDown: (e: React.KeyboardEvent) => void;
+    handleNextYearKeyDown: (e: React.KeyboardEvent) => void;
+    handlePickerIconKeyDown: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
+}
+export declare const useKeyboardHandlers: ({ currentDisplayedMonthLogic, focusLogic, }: UseKeyboardHandlersArgsT) => KeyboardHandlersT;
+export {};

package/dist/types/parts/Pickers/Calendar/usePopperTriggerLogic.d.ts

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

package/dist/types/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheel.d.ts

@@ -0,0 +1 @@
+export declare const CalendarWithTimeWheel: () => import("react/jsx-runtime.js").JSX.Element;

package/dist/types/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheelContent.d.ts

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

package/dist/types/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheelContext.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import type { CalendarWithTimeWheelContextT } from './useConfigCalendarWithTimeWheelCTX.js';
+export declare const defaultCalendarWithTimeWheelContext: CalendarWithTimeWheelContextT;
+/** Context for cross component communication */
+export declare const CalendarWithTimeWheelContext: import("react").Context<CalendarWithTimeWheelContextT>;
+export default CalendarWithTimeWheelContext;

package/dist/types/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheelFooter.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const CalendarWithTimeWheelFooter: React.ComponentType;

package/dist/types/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheelIconTrigger.d.ts

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

package/dist/types/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheelWrapper.d.ts

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

package/dist/types/parts/Pickers/CalendarWithTimeWheel/Styleds.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare const StyledIconTriggerButton: import("styled-components").StyledComponent<import("react").ComponentType<import("@elliemae/ds-button").DSButtonT.Props>, import("@elliemae/ds-system").Theme, object, never>;
+export declare const StyledCalendarWithTimeWheelWrapper: import("styled-components").StyledComponent<keyof JSX.IntrinsicElements, import("@elliemae/ds-system").Theme, Record<string, unknown> & object, never>;
+export declare const StyledCalendar: import("styled-components").StyledComponent<({ className }: {
+    className?: string | undefined;
+}) => JSX.Element, import("@elliemae/ds-system").Theme, object, never>;
+export declare const CalendarWithTimeWheelFooterMessage: import("styled-components").StyledComponent<"footer", import("@elliemae/ds-system").Theme, object, never>;

package/dist/types/parts/Pickers/CalendarWithTimeWheel/useConfigCalendarWithTimeWheelCTX.d.ts

@@ -0,0 +1,14 @@
+import type React from 'react';
+export interface CalendarWithTimeWheelContextT {
+    referenceElement: HTMLButtonElement | null;
+    ariaCurrentValueForInputs: string;
+    showCalendarWithTimeWheel: boolean;
+    closeCalendar: () => void;
+    handleToggleCalendarWithTimeWheel: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    handleSetTriggerRef: (instance: HTMLButtonElement) => void;
+    handleMenuWrapperKeyDown: (e: React.KeyboardEvent<HTMLElement>) => void;
+    handlePickerIconKeyDown: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
+    isControllerOnly: boolean;
+    disabled: boolean;
+}
+export declare const useConfigCalendarWithTimeWheelCTX: () => CalendarWithTimeWheelContextT;

package/dist/types/parts/Pickers/PickersIcons.d.ts

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

package/dist/types/parts/Pickers/TimeWheel/HoursList.d.ts

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

package/dist/types/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/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/parts/Pickers/TimeWheel/TimeWheel.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare const WrappedTimeWheelContext: ({ children }: {
+    children: JSX.Element;
+}) => import("react/jsx-runtime.js").JSX.Element;
+export declare const TimeWheel: () => JSX.Element;

package/dist/types/parts/Pickers/TimeWheel/TimeWheelContent.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const TimeWheelContent: React.MemoExoticComponent<() => import("react/jsx-runtime.js").JSX.Element>;

package/dist/types/parts/Pickers/TimeWheel/TimeWheelContext.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import type { TimeWheelContextT } from './useConfigTimePickerCTX.js';
+export declare const defaultTimePickerContext: TimeWheelContextT;
+/** Context for cross component communication */
+export declare const TimeWheelContext: import("react").Context<TimeWheelContextT>;
+export default TimeWheelContext;

package/dist/types/parts/Pickers/TimeWheel/TimeWheelFooter.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const TimeWheelFooter: React.ComponentType;

package/dist/types/parts/Pickers/TimeWheel/TimeWheelIconTrigger.d.ts

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

package/dist/types/parts/Pickers/TimeWheel/TimeWheelWrapper.d.ts

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

package/dist/types/parts/Pickers/TimeWheel/useConfigTimePickerCTX.d.ts

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

package/dist/types/parts/Pickers/TimeWheel/useCurrentDisplayedWheelsLogic.d.ts

@@ -0,0 +1,17 @@
+import type { DSControlledDateTimePickerT } from '../../../propTypes.js';
+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/dist/types/parts/Pickers/TimeWheel/useKeyboardHandlers.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import type { useCurrentDisplayedWheelsLogic } from './useCurrentDisplayedWheelsLogic.js';
+interface UseKeyboardHandlersArgs {
+    currentDisplayedTimeWheelLogic: ReturnType<typeof useCurrentDisplayedWheelsLogic>;
+}
+interface KeyboardHandlersT {
+    handleCurrHourOnKeyDown: (e: React.KeyboardEvent) => void;
+    handleCurrMinutesOnKeyDown: (e: React.KeyboardEvent) => void;
+    handleCurrMeridiemOnKeyDown: (e: React.KeyboardEvent) => void;
+    handlePickerIconKeyDown: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
+}
+export declare const useKeyboardHandlers: ({ currentDisplayedTimeWheelLogic }: UseKeyboardHandlersArgs) => KeyboardHandlersT;
+export {};

package/dist/types/parts/Pickers/TimeWheel/usePopperTriggerLogic.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+interface PopperTriggerLogicT {
+    referenceElement: HTMLButtonElement | null;
+    showTimePicker: boolean;
+    closeTimePicker: () => void;
+    setShowTimePicker: StateSetter<boolean>;
+    handleToggleTimePicker: () => void;
+    handleSetTriggerRef: (instance: HTMLButtonElement) => void;
+    handleMenuWrapperKeyDown: (e: React.KeyboardEvent<HTMLElement>) => void;
+}
+export declare const usePopperTriggerLogic: () => PopperTriggerLogicT;
+export {};

package/dist/types/parts/Styleds.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+export declare const StyledSeparator: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("@elliemae/ds-grid/dist/types/react-desc-prop-types.js").DSGridT.Props & import("react").RefAttributes<HTMLDivElement>>, import("@elliemae/ds-system").Theme, object, never>;
+export declare const StyledColonSeparator: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("@elliemae/ds-grid/dist/types/react-desc-prop-types.js").DSGridT.Props & import("react").RefAttributes<HTMLDivElement>>, import("@elliemae/ds-system").Theme, object, never>;
+export declare const Styled2DigitsInput: import("styled-components").StyledComponent<"input", import("@elliemae/ds-system").Theme, Record<string, unknown> & object, never>;
+export declare const StyledMin4DigitsInput: import("styled-components").StyledComponent<"input", import("@elliemae/ds-system").Theme, Record<string, unknown> & object, never>;
+export declare const StyledInputsWrapperGrid: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("@elliemae/ds-grid/dist/types/react-desc-prop-types.js").DSGridT.Props & import("react").RefAttributes<HTMLDivElement>>, import("@elliemae/ds-system").Theme, object, never>;
+export declare const StyledDateInputsWrapperGrid: import("styled-components").StyledComponent<keyof JSX.IntrinsicElements, import("@elliemae/ds-system").Theme, Record<string, unknown> & object, never>;
+export declare const StyledTimeInputsWrapperGrid: import("styled-components").StyledComponent<keyof JSX.IntrinsicElements, import("@elliemae/ds-system").Theme, Record<string, unknown> & object, never>;
+export declare const StyledPickersIconsWrapperGrid: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("@elliemae/ds-grid/dist/types/react-desc-prop-types.js").DSGridT.Props & import("react").RefAttributes<HTMLDivElement>>, import("@elliemae/ds-system").Theme, {
+    isControllerOnly: boolean;
+}, never>;
+export declare const StyledFocusWithIn: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("@elliemae/ds-grid/dist/types/react-desc-prop-types.js").DSGridT.Props & import("react").RefAttributes<HTMLDivElement>>, import("@elliemae/ds-system").Theme, object, never>;
+export declare const StyledClearButton: import("styled-components").StyledComponent<import("react").ComponentType<import("@elliemae/ds-button").DSButtonT.Props>, import("@elliemae/ds-system").Theme, object, never>;

package/dist/types/parts/TimeInputs/HHInput.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes.js';
+interface HHInputsPropsT {
+    onChange: DSControlledDateTimePickerInternalsT.OnChangeFunc;
+    onBlur: DSControlledDateTimePickerInternalsT.OnBlurFunc;
+    onFocus: DSControlledDateTimePickerInternalsT.OnFocusFunc;
+    onKeyDown: DSControlledDateTimePickerInternalsT.OnKeyDown;
+    value: string;
+    disabled: boolean;
+    contextRef: React.MutableRefObject<HTMLInputElement | null>;
+    placeholder: string;
+    ariaCurrentValueForInputs: string;
+    autoFocusHourInput: boolean;
+    isFocused: boolean;
+    ariaAndDataProps?: AriaAndDataProps;
+}
+export declare const HHInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, ariaCurrentValueForInputs, contextRef, autoFocusHourInput, isFocused, ariaAndDataProps, }: HHInputsPropsT) => JSX.Element>;
+export {};

package/dist/types/parts/TimeInputs/MeridiemInput.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes.js';
+interface MeridiemInputsPropsT {
+    onChange: DSControlledDateTimePickerInternalsT.OnChangeFunc;
+    onBlur: DSControlledDateTimePickerInternalsT.OnBlurFunc;
+    onFocus: DSControlledDateTimePickerInternalsT.OnFocusFunc;
+    onKeyDown: DSControlledDateTimePickerInternalsT.OnKeyDown;
+    value: string;
+    disabled: boolean;
+    contextRef: React.MutableRefObject<HTMLInputElement | null>;
+    placeholder: string;
+    ariaCurrentValueForInputs: string;
+    isFocused: boolean;
+    ariaAndDataProps?: AriaAndDataProps;
+}
+export declare const MeridiemInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, ariaCurrentValueForInputs, contextRef, isFocused, ariaAndDataProps, }: MeridiemInputsPropsT) => JSX.Element>;
+export {};

package/dist/types/parts/TimeInputs/MinutesInput.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes.js';
+interface MinutesInputsPropsT {
+    onChange: DSControlledDateTimePickerInternalsT.OnChangeFunc;
+    onBlur: DSControlledDateTimePickerInternalsT.OnBlurFunc;
+    onFocus: DSControlledDateTimePickerInternalsT.OnFocusFunc;
+    onKeyDown: DSControlledDateTimePickerInternalsT.OnKeyDown;
+    value: string;
+    disabled: boolean;
+    contextRef: React.MutableRefObject<HTMLInputElement | null>;
+    placeholder: string;
+    ariaCurrentValueForInputs: string;
+    isFocused: boolean;
+    ariaAndDataProps?: AriaAndDataProps;
+}
+export declare const MinutesInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, placeholder, ariaCurrentValueForInputs, contextRef, isFocused, ariaAndDataProps, }: MinutesInputsPropsT) => JSX.Element>;
+export {};

package/dist/types/parts/TimeInputs/TimeInputs.d.ts

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

package/dist/types/parts/TimeInputs/useTimeInputs.d.ts

@@ -0,0 +1,22 @@
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes.js';
+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/dist/types/parts/config.d.ts

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

package/dist/types/propTypes.d.ts

@@ -0,0 +1,105 @@
+import type { WeakValidationMap } from 'react';
+import type React from 'react';
+import { ControlledDateTimePickerDatatestid } from './ControlledDateTimePickerDatatestid.js';
+export declare namespace DSControlledDateTimePickerT {
+    type DataTestIdType = typeof ControlledDateTimePickerDatatestid;
+    type FlatDataTestIdValues = {
+        [K in keyof DataTestIdType]: DataTestIdType[K] extends Record<string, unknown> ? DataTestIdType[K][keyof DataTestIdType[K]] : DataTestIdType[K];
+    }[keyof DataTestIdType];
+    type AriaAndDataPropsPerDataTestId = {
+        [key in FlatDataTestIdValues]?: AriaAndDataPropsOrPropsGetter;
+    };
+    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;
+    type AppOnInputChange = (val: string, e: OnInternalValuesChangeEvent, metaInfo: InternalInputsChangeMetaInfo) => void;
+    interface DefaultDateProps {
+        onMonthChange: AppOnInputChange;
+        onDayChange: AppOnInputChange;
+        onYearChange: AppOnInputChange;
+        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 extends AriaAndDataPropsPerDataTestId {
+        emptyPickerStartingMonth?: string;
+        onCalendarOpenFocusedDay?: string;
+        pickerFooterMsg?: string;
+        innerRef?: React.MutableRefObject<HTMLInputElement | HTMLButtonElement | null> | ((ref: HTMLInputElement | HTMLButtonElement | null) => void);
+    }
+    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: AppOnInputChange;
+        onMinuteChange: AppOnInputChange;
+        onMeridiemChange: AppOnInputChange;
+        onPickerOpen: NoopishFunc;
+        onPickerClose: NoopishFunc;
+        getIsDisabledTime: BooleanGetter<string>;
+        minutesInterval: number;
+        isClearable: boolean;
+        disabled: boolean;
+        hasError: boolean;
+        autoFocus: boolean;
+        preventCloseOnSelection: boolean;
+    }
+    interface OptionalTimePickerProps extends AriaAndDataPropsPerDataTestId {
+        pickerFooterMsg?: string;
+        onTimeWheelOpenStartingTime?: string;
+        innerRef?: React.MutableRefObject<HTMLInputElement | HTMLButtonElement | null> | ((ref: HTMLInputElement | HTMLButtonElement | null) => void);
+    }
+    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 = AriaAndDataPropsPerDataTestId & 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: WeakValidationMap<unknown>;