@elliemae/ds-controlled-form 1.57.1-rc.0 → 2.0.0-alpha.11

package/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/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/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/types/controlled-date-time-picker/parts/Pickers/TimeWheel/Styleds.d.ts

@@ -0,0 +1,79 @@
+/// <reference types="react" />
+export declare const StyledIconTriggerButton: import("styled-components").StyledComponent<{
+    (props: any): JSX.Element;
+    propTypes: {
+        id: any;
+        buttonType: any;
+        size: any;
+        disabled: any;
+        onClick: any;
+        onKeyDown: any;
+        onBlur: any;
+        onFocus: any;
+        className: any;
+        tabIndex: any;
+        innerRef: any;
+        'aria-label': any;
+        'aria-pressed': any;
+        'data-testid': any;
+        role: any;
+        children: any;
+    };
+}, any, {}, never>;
+export declare const StyledWheelList: import("styled-components").StyledComponent<"div", any, {}, never>;
+interface StyledWheelListItemPropsT {
+    isCurrentListItem?: boolean;
+    selected?: boolean;
+}
+export declare const StyledTimePickerContainer: import("styled-components").StyledComponent<"div", any, {
+    showShadow?: boolean | undefined;
+    isControllerOnly: boolean;
+}, never>;
+export declare const StyledTimePickerHead: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("react").RefAttributes<unknown>>, any, {}, never>;
+export declare const StyledTimePickerWheelsLegend: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const StyledTimePickerWheelWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const StyledTimeBtn: import("styled-components").StyledComponent<{
+    (props: any): JSX.Element;
+    propTypes: {
+        id: any;
+        buttonType: any;
+        size: any;
+        disabled: any;
+        onClick: any;
+        onKeyDown: any;
+        onBlur: any;
+        onFocus: any;
+        className: any;
+        tabIndex: any;
+        innerRef: any;
+        'aria-label': any;
+        'aria-pressed': any;
+        'data-testid': any;
+        role: any;
+        children: any;
+    };
+}, any, {}, never>;
+export declare const StyledWheelListItem: import("styled-components").StyledComponent<"div", any, StyledWheelListItemPropsT, never>;
+export declare const StyledWheelChangeTimeBtn: import("styled-components").StyledComponent<{
+    (props: any): JSX.Element;
+    propTypes: {
+        id: any;
+        buttonType: any;
+        size: any;
+        disabled: any;
+        onClick: any;
+        onKeyDown: any;
+        onBlur: any;
+        onFocus: any;
+        className: any;
+        tabIndex: any;
+        innerRef: any;
+        'aria-label': any;
+        'aria-pressed': any;
+        'data-testid': any;
+        role: any;
+        children: any;
+    };
+}, any, {}, never>;
+export declare const TimeWheelFooterMessage: import("styled-components").StyledComponent<"footer", any, {}, never>;
+export {};

package/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/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>;

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

@@ -0,0 +1,64 @@
+import React from 'react';
+export interface WheelsButtonsRefsT {
+    prevHourBtnRef: React.RefObject<HTMLButtonElement>;
+    currHourBtnRef: React.RefObject<HTMLButtonElement>;
+    nextHourBtnRef: React.RefObject<HTMLButtonElement>;
+    prevMinutesBtnRef: React.RefObject<HTMLButtonElement>;
+    currMinutesBtnRef: React.RefObject<HTMLButtonElement>;
+    nextMinutesBtnRef: React.RefObject<HTMLButtonElement>;
+    prevMeridiemBtnRef: React.RefObject<HTMLButtonElement>;
+    currMeridiemBtnRef: React.RefObject<HTMLButtonElement>;
+    nextMeridiemBtnRef: React.RefObject<HTMLButtonElement>;
+}
+export interface KeyboardHandlersT {
+    handlePrevHourBtnOnKeyDown: (e: React.KeyboardEvent) => void;
+    handleCurrHourOnKeyDown: (e: React.KeyboardEvent) => void;
+    handleNextHourBtnOnKeyDown: (e: React.KeyboardEvent) => void;
+    handlePrevMinuteBtnOnKeyDown: (e: React.KeyboardEvent) => void;
+    handleCurrMinutesOnKeyDown: (e: React.KeyboardEvent) => void;
+    handleNextMinuteBtnOnKeyDown: (e: React.KeyboardEvent) => void;
+    handlePrevMeridiemBtnOnKeyDown: (e: React.KeyboardEvent) => void;
+    handleCurrMeridiemOnKeyDown: (e: React.KeyboardEvent) => void;
+    handleNextMeridiemBtnOnKeyDown: (e: React.KeyboardEvent) => void;
+    handlePickerIconKeyDown: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
+}
+export interface PopperTriggerLogicT {
+    showTimePicker: boolean;
+    setShowTimePicker: React.Dispatch<React.SetStateAction<boolean>>;
+    setPopperElement: React.Dispatch<React.SetStateAction<HTMLDivElement>>;
+    setArrowElement: React.Dispatch<React.SetStateAction<HTMLDivElement>>;
+    usePopperHelpers: {
+        attributes: Record<string, unknown>;
+        styles: Record<string, React.CSSProperties>;
+    };
+    handleToggleTimePicker: (e?: React.MouseEvent<HTMLButtonElement>) => void;
+    handleSetTriggerRef: (instance: HTMLButtonElement) => void;
+    handleMenuWrapperKeyDown: (e?: React.KeyboardEvent<HTMLElement>) => void;
+}
+export interface useCurrentDisplayedWheelsLogicT {
+    currHourNum: number;
+    hours: string;
+    visibleHours: string[];
+    handlePrevHour: (e: React.MouseEvent) => void;
+    handleNextHour: (e: React.MouseEvent) => void;
+    handleTimeWheelBtnChangeHours: (newVal: string, e: React.MouseEvent<HTMLButtonElement>) => void;
+    currMinuteNum: number;
+    minutes: string;
+    visibleMinutes: string[];
+    handlePrevMinute: (e: React.MouseEvent) => void;
+    handleNextMinute: (e: React.MouseEvent) => void;
+    handleTimeWheelBtnChangeMinutes: (newVal: string, e: React.MouseEvent<HTMLButtonElement>) => void;
+    meridiem: string;
+    handleTimeWheelBtnChangeMeridiem: (newMeridiem: string, e: React.MouseEvent) => void;
+}
+export interface TimeWheelContextT extends PopperTriggerLogicT, useCurrentDisplayedWheelsLogicT, KeyboardHandlersT, WheelsButtonsRefsT {
+    ariaCurrentValueForInputs: string;
+    tempTimeString: string;
+    isControllerOnly: boolean;
+    autoFocusHourTimeWheel: boolean;
+    getIsDisabledTime: (val: string) => boolean;
+}
+export declare const defaultTimePickerContext: TimeWheelContextT;
+/** Context for cross component communication */
+export declare const TimeWheelContext: React.Context<TimeWheelContextT>;
+export default TimeWheelContext;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+import type { useCurrentDisplayedWheelsLogicT } from './TimeWheelContext';
+declare type useCurrentDisplayedWheelsLogicArgsT = {
+    minutesInterval: number;
+};
+export declare const useCurrentDisplayedWheelsLogic: ({ minutesInterval, }: useCurrentDisplayedWheelsLogicArgsT) => useCurrentDisplayedWheelsLogicT;
+export {};

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

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import type { useCurrentDisplayedWheelsLogicT, KeyboardHandlersT, WheelsButtonsRefsT } from './TimeWheelContext';
+declare type useKeyboardHandlersArgsT = Partial<useCurrentDisplayedWheelsLogicT> & WheelsButtonsRefsT & {
+    hideDate: boolean;
+    hideTime: boolean;
+    monthInputRef: React.RefObject<HTMLInputElement>;
+    hourInputRef: React.RefObject<HTMLInputElement>;
+    prevMonthBtnRef: React.RefObject<HTMLButtonElement>;
+    isWithCalendarToo: boolean;
+    isControllerOnly: boolean;
+};
+export declare const useKeyboardHandlers: ({ handlePrevHour, handleNextHour, handlePrevMinute, handleNextMinute, handleTimeWheelBtnChangeMeridiem, prevMonthBtnRef, prevHourBtnRef, currHourBtnRef, nextHourBtnRef, prevMinutesBtnRef, currMinutesBtnRef, nextMinutesBtnRef, prevMeridiemBtnRef, currMeridiemBtnRef, nextMeridiemBtnRef, hideDate, hideTime, monthInputRef, hourInputRef, isWithCalendarToo, isControllerOnly, }: useKeyboardHandlersArgsT) => KeyboardHandlersT;
+export {};

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

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import type { PopperTriggerLogicT } from './TimeWheelContext';
+interface usePopperTriggerLogicT {
+    pickerButtonRef: React.MutableRefObject<HTMLButtonElement>;
+    currHourBtnRef: React.MutableRefObject<HTMLButtonElement>;
+    onPickerClose: () => void;
+    onPickerOpen: () => void;
+    isWithCalendarToo: boolean;
+}
+export declare const usePopperTriggerLogic: ({ pickerButtonRef, currHourBtnRef, onPickerClose, onPickerOpen, isWithCalendarToo, }: usePopperTriggerLogicT) => PopperTriggerLogicT;
+export {};

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

@@ -0,0 +1,33 @@
+/// <reference types="react" />
+export declare const StyledSeparator: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("react").RefAttributes<unknown>>, any, {}, never>;
+export declare const StyledColonSeparator: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("react").RefAttributes<unknown>>, any, {}, never>;
+export declare const Styled2DigitsInput: import("styled-components").StyledComponent<"input", any, {}, never>;
+export declare const StyledMin4DigitsInput: import("styled-components").StyledComponent<"input", any, {}, never>;
+export declare const StyledInputsWrapperGrid: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("react").RefAttributes<unknown>>, any, {}, never>;
+export declare const StyledDateInputsWrapperGrid: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const StyledTimeInputsWrapperGrid: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const StyledPickersIconsWrapperGrid: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("react").RefAttributes<unknown>>, any, {
+    isControllerOnly: boolean;
+}, never>;
+export declare const StyledFocusWithIn: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("react").RefAttributes<unknown>>, any, {}, never>;
+export declare const StyledClearButton: import("styled-components").StyledComponent<{
+    (props: any): JSX.Element;
+    propTypes: {
+        id: any;
+        buttonType: any;
+        size: any;
+        disabled: any;
+        onClick: any;
+        onKeyDown: any;
+        onBlur: any;
+        onFocus: any;
+        className: any;
+        tabIndex: any;
+        innerRef: any;
+        'aria-label': any;
+        'aria-pressed': any;
+        'data-testid': any;
+        role: any;
+        children: any;
+    };
+}, any, {}, never>;

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+export declare const fixedValues: {
+    smallInputWidth: string;
+    largeInputWidth: string;
+    separatorWidth: string;
+};

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

@@ -0,0 +1,22 @@
+export declare const propTypes: {
+    type: any;
+    isClearable: any;
+    dateTime: any;
+    date: any;
+    time: any;
+    onDateChange: any;
+    onTimeChange: any;
+    onDateTimeChange: any;
+    onMonthChange: any;
+    onDayChange: any;
+    onYearChange: any;
+    onHourChange: any;
+    onMinuteChange: any;
+    onMeridiemChange: any;
+    getIsDisabledDay: any;
+    getIsOutOfRangeDay: any;
+    getIsDisabledTime: any;
+    emptyPickerStartingMonth: any;
+    onCalendarOpenFocusedDay: any;
+    minutesInterval: any;
+};

package/types/controlled-date-time-picker/tests/date-time-picker.auto-advance.test.d.ts

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

package/types/controlled-date-time-picker/tests/date-time-picker.clear-button.test.d.ts

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

package/types/controlled-date-time-picker/tests/date-time-picker.keyboard-focus.test.d.ts

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

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

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

package/types/controlled-date-time-picker/tests/date-time-picker.onChange-meta-info.test.d.ts

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

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

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

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

@@ -0,0 +1,35 @@
+export declare const weekDays: string[];
+export declare const monthNames: string[];
+export declare const announcableCardinalDays: {
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+    5: string;
+    6: string;
+    7: string;
+    8: string;
+    9: string;
+    10: string;
+    11: string;
+    12: string;
+    13: string;
+    14: string;
+    15: string;
+    16: string;
+    17: string;
+    18: string;
+    19: string;
+    20: string;
+    21: string;
+    22: string;
+    23: string;
+    24: string;
+    25: string;
+    26: string;
+    27: string;
+    28: string;
+    29: string;
+    30: string;
+    31: string;
+};

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

@@ -0,0 +1,38 @@
+import type { DateMonth, metaMonthDayT, internalInputsChangeMetaInfo } from '../index.d';
+export declare const getLastDayOfMonth: (month: DateMonth, year: number) => Date;
+export declare const isValidDayForTheMonth: (month: DateMonth, year: number, day: number) => boolean;
+export declare const isValidDayForTheMonthDateString: (dateString: string) => boolean;
+export declare const getValidationDateStringMetaInfo: (dateString: string, getIsOutOfRangeDay?: (day: string) => boolean, getIsDisabledDay?: (day: string) => boolean) => Partial<internalInputsChangeMetaInfo>;
+export declare const isLeapYear: (year: number) => boolean;
+export declare const getHowManyDaysInMonth: (year: number, month: number) => number;
+export declare const dateIsLeapYear: (date: Date) => boolean;
+export declare const dateGetDaysInMonth: (date: Date) => number;
+export declare const dateAddMonths: (date: Date, value: number) => Date;
+export declare const dateAddYear: (date: Date, value: number) => Date;
+interface DateValuesT {
+    month: DateMonth;
+    year: number;
+    day?: number;
+}
+interface DateSumValuesT {
+    monthsToSum?: number;
+    yearsToSum?: number;
+    daysToSum?: number;
+}
+export declare const sumFromDateValues: ({ month, year, day }: DateValuesT, { monthsToSum, yearsToSum, daysToSum }: DateSumValuesT) => DateValuesT;
+export declare const sumValuesToDate: (day: Date, sumValues: DateSumValuesT) => Date;
+export declare const subtractYears: (date: Date, howManyMore?: number) => Date;
+export declare const subtractMonths: (date: Date, howManyMore?: number) => Date;
+export declare const sumMonths: (date: Date, howManyMore?: number) => Date;
+export declare const sumYears: (date: Date, howManyMore?: number) => Date;
+export declare const getDaysInMonth: (month: number, year: number) => Date[];
+export declare const getLastXDaysFromPreviousMonth: (month: number, year: number, howMany: number) => Date[];
+export declare const getFirstXDaysFromNextMonth: (month: number, year: number, howMany: number) => Date[];
+export declare const getFiveBySevenCurrentMonthDaysMatrix: (month: number, year: number) => metaMonthDayT[];
+export declare const getDateValuesFromDate: (day: Date) => DateValuesT;
+export declare const getDateStringFromDay: (day: Date) => string;
+export declare const getDayFromDateString: (dateString: string) => Date | null;
+export declare const getMonthNameByMonthNumber: (monthNumber: number) => string;
+export declare const isSameDateMoment: (dateA: Date, dateB: Date) => boolean;
+export declare const compareTwoDatesDayEquality: (dayA: Date, dayB: Date) => boolean;
+export {};

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

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

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

@@ -0,0 +1 @@
+export declare const useGetDayFromDateString: () => Date;

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

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

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

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

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

@@ -0,0 +1 @@
+export declare const useOnClickOutside: (ref: any, handler: any) => void;

package/types/controlled-date-time-picker/utils/numberHelpers.d.ts

@@ -0,0 +1 @@
+export declare const convertToPositiveNumberIfPossible: (numberString: string) => number;

package/types/controlled-date-time-picker/utils/stringHelpers.d.ts

@@ -0,0 +1,36 @@
+export declare const prependStringWithPlaceHolders: (val: string, finalLength: number, placeholder?: string) => string;
+export declare const fillStringWithPlaceHolders: (val: string, finalLength: number, placeholder?: string) => string;
+export declare const getFormattedDateString: ({ month, day, year }: {
+    month: string;
+    day: string;
+    year: string;
+}) => string;
+export declare const dateTimeToDate: (dateTime: string) => string;
+export declare const deconstructValuesFromDateString: (dateString: string) => {
+    month: string;
+    day: string;
+    year: string;
+};
+export declare const deconstructValuesFromTimeString: (timeString: string) => {
+    hours: string;
+    minutes: string;
+    meridiem: string;
+};
+export declare const isValidDateString: (testString: string) => boolean;
+export declare const getFormattedTimeString: ({ hours, minutes, meridiem, }: {
+    hours: string;
+    minutes: string;
+    meridiem: string;
+}) => string;
+export declare const dateTimeToTime: (dateTime: string) => string;
+export declare const deconstructTimeValues: (timeString: string) => {
+    hours: string;
+    minutes: string;
+    meridiem: string;
+};
+export declare const isValidTimeString: (testString: string) => boolean;
+export declare const isIncompleteString: (testString: string, placeholder?: string) => boolean;
+export declare const isEmptyDateStringMask: (testString: string) => boolean;
+export declare const isEmptyTimeStringMask: (testString: string) => boolean;
+export declare const isEmptyDateTimeStringMask: (testString: string) => boolean;
+export declare const getAriaDayFromDateString: (dateString: string) => string;

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

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

package/types/controlled-toggle/ControlledToggle.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="react" />
+import type { DSControlledTogglePropsT } from './index.d';
+declare const DSControlledToggle: {
+    ({ labelOn, labelOff, name, value, checked, onChange, size, readOnly, active, disabled, containerProps, id, }: DSControlledTogglePropsT): JSX.Element;
+    defaultProps: {
+        labelOn: string;
+        labelOff: string;
+        name: string;
+        value: string;
+        checked: boolean;
+        onClick: () => null;
+        size: string;
+        readonly: boolean;
+        active: boolean;
+        disabled: boolean;
+    };
+    propTypes: {
+        labelOn: any;
+        labelOff: any;
+        value: any;
+        name: any;
+        checked: any;
+        onchange: any;
+        size: any;
+        readOnly: any;
+        active: any;
+        disabled: any;
+        containerProps: any;
+        id: any;
+    };
+};
+declare const DSControlledToggleWithSchema: any;
+export { DSControlledToggle, DSControlledToggleWithSchema };

package/types/controlled-toggle/defaultProps.d.ts

@@ -0,0 +1,12 @@
+export declare const defaultProps: {
+    labelOn: string;
+    labelOff: string;
+    name: string;
+    value: string;
+    checked: boolean;
+    onClick: () => null;
+    size: string;
+    readonly: boolean;
+    active: boolean;
+    disabled: boolean;
+};

package/types/controlled-toggle/index.d.ts

@@ -0,0 +1 @@
+export * from './ControlledToggle';

package/types/controlled-toggle/propTypes.d.ts

@@ -0,0 +1,14 @@
+export declare const propTypes: {
+    labelOn: any;
+    labelOff: any;
+    value: any;
+    name: any;
+    checked: any;
+    onchange: any;
+    size: any;
+    readOnly: any;
+    active: any;
+    disabled: any;
+    containerProps: any;
+    id: any;
+};

package/types/controlled-toggle/styles.d.ts

@@ -0,0 +1,8 @@
+import type { StyledContainerT, StyledLabelT, StyledVisibleContentT, StyledCircleT, StyledTextT, SetLabelWidthT } from './index.d';
+export declare const StyledContainer: import("styled-components").StyledComponent<"div", any, StyledContainerT, never>;
+export declare const StyledLabel: import("styled-components").StyledComponent<"div", any, StyledLabelT, never>;
+export declare const StyledVisibleContent: import("styled-components").StyledComponent<"label", any, StyledVisibleContentT, never>;
+export declare const StyledCircle: import("styled-components").StyledComponent<"div", any, StyledCircleT, never>;
+export declare const StyledText: import("styled-components").StyledComponent<"div", any, StyledTextT, never>;
+export declare const StyledInput: import("styled-components").StyledComponent<"input", any, {}, never>;
+export declare const SetLabelWidth: import("styled-components").StyledComponent<"div", any, SetLabelWidthT, never>;

package/types/controlled-toggle/tests/DSControlledToggle.keyboard.test.d.ts

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

package/types/controlled-toggle/tests/DSControlledToggle.test.d.ts

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

package/types/controlled-toggle/utils/addTooltipOnReadOnly.d.ts

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