@salt-ds/lab 1.0.0-alpha.50 → 1.0.0-alpha.52

package/dist-types/calendar/useCalendar.d.ts

@@ -1,33 +1,116 @@
 import { type DateValue } from "@internationalized/date";
 import { type SyntheticEvent } from "react";
-import { type UseMultiSelectionCalendarProps, type UseOffsetSelectionCalendarProps, type UseRangeSelectionCalendarProps, type UseSingleSelectionCalendarProps } from "./useSelection";
-interface BaseUseCalendarProps {
+import { type UseCalendarSelectionMultiSelectProps, type UseCalendarSelectionOffsetProps, type UseCalendarSelectionRangeProps, type UseCalendarSelectionSingleProps } from "./useCalendarSelection";
+/**
+ * Interface representing the base properties UseCalendar hook.
+ */
+interface UseCalendarBaseProps {
+    /**
+     * The default visible month.
+     */
     defaultVisibleMonth?: DateValue;
+    /**
+     * Callback fired when the visible month changes.
+     * @param event - The synthetic event.
+     * @param visibleMonth - The new visible month.
+     */
     onVisibleMonthChange?: (event: SyntheticEvent, visibleMonth: DateValue) => void;
+    /**
+     * Function to determine if a day is unselectable.
+     * @param date - The date to check.
+     * @returns A string reason if the day is unselectable, otherwise `false` or `undefined`.
+     */
     isDayUnselectable?: (date: DateValue) => string | false | undefined;
+    /**
+     * Function to determine if a day is highlighted.
+     * @param date - The date to check.
+     * @returns A string reason if the day is highlighted, otherwise `false` or `undefined`.
+     */
     isDayHighlighted?: (date: DateValue) => string | false | undefined;
-    isDayDisabled?: (date: DateValue) => boolean;
+    /**
+     * Function to determine if a day is disabled.
+     * @param date - The date to check.
+     * @returns A string reason if the day is disabled, otherwise `false` or `undefined`.
+     */
+    isDayDisabled?: (date: DateValue) => string | false | undefined;
+    /**
+     * The currently visible month.
+     */
     visibleMonth?: DateValue;
+    /**
+     * If `true`, hides dates that are out of the selectable range.
+     */
     hideOutOfRangeDates?: boolean;
-    hideYearDropdown?: boolean;
+    /**
+     * The minimum selectable date.
+     */
     minDate?: DateValue;
+    /**
+     * The maximum selectable date.
+     */
     maxDate?: DateValue;
+    /**
+     * The time zone used for date calculations.
+     */
+    timeZone?: string;
+    /**
+     * The locale used for date formatting.
+     */
+    locale?: string;
 }
-export declare type useCalendarProps = (Omit<UseSingleSelectionCalendarProps, "isDaySelectable"> | Omit<UseMultiSelectionCalendarProps, "isDaySelectable"> | Omit<UseRangeSelectionCalendarProps, "isDaySelectable"> | Omit<UseOffsetSelectionCalendarProps, "isDaySelectable">) & BaseUseCalendarProps;
-export declare function useCalendar(props: useCalendarProps): {
+/**
+ * UseCalendar hook props for a single date selection Calendar.
+ */
+export interface UseCalendarSingleProps extends UseCalendarSelectionSingleProps, UseCalendarBaseProps {
+    /**
+     * The selection variant, set to "single".
+     */
+    selectionVariant: "single";
+}
+/**
+ * UseCalendar hook props for a date range selection Calendar.
+ */
+export interface UseCalendarRangeProps extends UseCalendarSelectionRangeProps, UseCalendarBaseProps {
+    /**
+     * The selection variant, set to "range".
+     */
+    selectionVariant: "range";
+}
+/**
+ * UseCalendar hook props for a multi-select Calendar.
+ */
+export interface UseCalendarMultiSelectProps extends UseCalendarSelectionMultiSelectProps, UseCalendarBaseProps {
+    /**
+     * The selection variant, set to "multiselect".
+     */
+    selectionVariant: "multiselect";
+}
+/**
+ * UseCalendar hook props for an offset date selection Calendar.
+ */
+export interface UseCalendarOffsetProps extends UseCalendarSelectionOffsetProps, UseCalendarBaseProps {
+    /**
+     * The selection variant, set to "offset".
+     */
+    selectionVariant: "offset";
+}
+/**
+ * UseCalendar hook props, wth the selection variant determining the return type of the date selection
+ */
+export declare type UseCalendarProps = UseCalendarSingleProps | UseCalendarRangeProps | UseCalendarMultiSelectProps | UseCalendarOffsetProps;
+export declare function useCalendar(props: UseCalendarProps): {
     state: {
-        selectedDate: import("@internationalized/date").CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime | import("./useSelection").RangeSelectionValueType | {
-            startDate?: DateValue | undefined;
-            endDate?: DateValue | undefined;
-        } | DateValue[] | null | undefined;
+        selectedDate: import("@internationalized/date").CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime | import("./useCalendarSelection").DateRangeSelection | import("./useCalendarSelection").MultipleDateSelection | null | undefined;
         hoveredDate: import("@internationalized/date").CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime | null | undefined;
         visibleMonth: DateValue;
-        focusedDate: DateValue;
+        focusedDate: DateValue | null;
         minDate: DateValue | undefined;
         maxDate: DateValue | undefined;
-        selectionVariant: "offset" | "range" | "default" | "multiselect";
+        selectionVariant: "offset" | "range" | "single" | "multiselect";
         hideOutOfRangeDates: boolean | undefined;
         calendarFocused: boolean;
+        timeZone: string;
+        locale: string;
     };
     helpers: {
         setSelectedDate: (event: SyntheticEvent<HTMLButtonElement, Event>, newSelectedDate: DateValue) => void;
@@ -39,16 +122,17 @@ export declare function useCalendar(props: useCalendarProps): {
         isSelectedStart: (date: DateValue) => boolean;
         isSelectedEnd: (date: DateValue) => boolean;
         isHoveredOffset: (date: DateValue) => boolean;
+        isDaySelectable: ((date: DateValue) => boolean) | undefined;
         setVisibleMonth: (event: SyntheticEvent, newVisibleMonth: DateValue) => void;
         setFocusedDate: (event: SyntheticEvent, date: DateValue) => void;
         setCalendarFocused: import("react").Dispatch<import("react").SetStateAction<boolean>>;
         isDayUnselectable: (date: DateValue) => string | false | undefined;
         isDayHighlighted: (date: DateValue) => string | false | undefined;
-        isDayDisabled: (date: DateValue) => boolean;
+        isDayDisabled: (date: DateValue) => string | false | undefined;
         isDayVisible: (date: DateValue) => boolean;
-        isOutsideAllowedDates: (date: DateValue) => boolean;
-        isOutsideAllowedMonths: (date: DateValue) => boolean;
-        isOutsideAllowedYears: (date: DateValue) => boolean;
+        isOutsideAllowedDates: (date: DateValue) => boolean | undefined;
+        isOutsideAllowedMonths: (date: DateValue) => boolean | undefined;
+        isOutsideAllowedYears: (date: DateValue) => boolean | undefined;
     };
 };
 export {};

package/dist-types/calendar/useCalendarDay.d.ts

@@ -1,17 +1,53 @@
 import { type DateValue } from "@internationalized/date";
 import { type RefObject } from "react";
+/**
+ * Interface representing the status of a day in the Calendar.
+ */
 export interface DayStatus {
+    /**
+     * If `true`, the day is out of the selectable range.
+     */
     outOfRange?: boolean;
+    /**
+     * If `true`, the day is selected.
+     */
     selected?: boolean;
+    /**
+     * If `true`, the day is today.
+     */
     today?: boolean;
+    /**
+     * If set, the day is unselectable with a reason.
+     */
     unselectable?: string | false;
+    /**
+     * If set, the day is highlighted with a reason.
+     */
     highlighted?: string | false;
+    /**
+     * If `true`, the day is focused.
+     */
     focused?: boolean;
+    /**
+     * If `true`, the day is disabled.
+     */
     disabled?: boolean;
+    /**
+     * If `true`, the day is hidden.
+     */
     hidden?: boolean;
 }
+/**
+ * UseCalendar hook props to return a calendar day's status
+ */
 export interface useCalendarDayProps {
+    /**
+     * The date of the calendar day.
+     */
     date: DateValue;
+    /**
+     * The month of the calendar day.
+     */
     month: DateValue;
 }
 export declare function useCalendarDay({ date, month }: useCalendarDayProps, ref: RefObject<HTMLElement>): {
@@ -19,4 +55,6 @@ export declare function useCalendarDay({ date, month }: useCalendarDayProps, ref
     dayProps: Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">;
     unselectableReason: string | false | undefined;
     highlightedReason: string | false | undefined;
+    locale: string;
+    timeZone: string;
 };

package/dist-types/calendar/useCalendarSelection.d.ts

@@ -0,0 +1,189 @@
+import { CalendarDate, CalendarDateTime, type DateValue, ZonedDateTime } from "@internationalized/date";
+import type { KeyboardEventHandler, MouseEventHandler, SyntheticEvent } from "react";
+/**
+ * Type representing a single date selection.
+ */
+export declare type SingleDateSelection = DateValue;
+/**
+ * Type representing multiple date selections.
+ */
+export declare type MultipleDateSelection = DateValue[];
+/**
+ * Type representing a date range selection.
+ */
+export declare type DateRangeSelection = {
+    /**
+     * The start date of the range.
+     */
+    startDate?: DateValue | null;
+    /**
+     * The end date of the range.
+     */
+    endDate?: DateValue | null;
+};
+/**
+ * Type representing all possible selection value types.
+ */
+export declare type AllSelectionValueType = SingleDateSelection | MultipleDateSelection | DateRangeSelection | null;
+/**
+ * The default minimum year used by the calendar.
+ */
+export declare const CALENDAR_MIN_YEAR = 1900;
+/**
+ * The default maximum year used by the calendar.
+ */
+export declare const CALENDAR_MAX_YEAR = 2100;
+/**
+ * Checks if a value is a single date selection.
+ * @param value - The value to check.
+ * @returns `true` if the value is a single date selection, otherwise `false`.
+ */
+export declare function isSingleSelectionValueType(value: any): value is DateValue;
+/**
+ * Checks if a value is a date range selection.
+ * @param value - The value to check.
+ * @returns `true` if the value is a date range selection, otherwise `false`.
+ */
+export declare function isDateRangeSelection(value: any): value is DateRangeSelection;
+/**
+ * Checks if a value is a multiple date selection.
+ * @param value - The value to check.
+ * @returns `true` if the value is a multiple date selection, otherwise `false`.
+ */
+export declare function isMultipleDateSelection(value: any): value is MultipleDateSelection;
+/**
+ * Base properties for calendar UseCalendarSelection hook.
+ * @template SelectionVariantType - The type of the selection variant.
+ */
+interface UseCalendarSelectionBaseProps<SelectionVariantType> {
+    /**
+     * The currently hovered date.
+     */
+    hoveredDate?: DateValue | null;
+    /**
+     * The currently selected date.
+     */
+    selectedDate?: SelectionVariantType | null;
+    /**
+     * The default selected date.
+     */
+    defaultSelectedDate?: SelectionVariantType;
+    /**
+     * Callback fired when the selected date changes.
+     * @param event - The synthetic event.
+     * @param selectedDate - The new selected date.
+     */
+    onSelectedDateChange?: (event: SyntheticEvent, selectedDate: SelectionVariantType | null) => void;
+    /**
+     * Function to determine if a day is selectable.
+     * @param date - The date to check.
+     * @returns `true` if the day is selectable, otherwise `false`.
+     */
+    isDaySelectable?: (date: DateValue) => boolean;
+    /**
+     * Callback fired when the hovered date changes.
+     * @param event - The synthetic event.
+     * @param hoveredDate - The new hovered date.
+     */
+    onHoveredDateChange?: (event: SyntheticEvent, hoveredDate: DateValue | null) => void;
+    /**
+     * Function to select a new date.
+     * @param currentSelectedDate - The current selected date.
+     * @param newSelectedDate - The new date to select.
+     * @returns The updated selection variant type.
+     */
+    select?: (currentSelectedDate: SelectionVariantType, newSelectedDate: DateValue) => SelectionVariantType;
+}
+/**
+ * UseCalendar hook props to return a calendar day's status
+ */
+export interface UseCalendarSelectionOffsetProps extends Omit<UseCalendarSelectionBaseProps<DateRangeSelection>, "startDateOffset" | "endDateOffset"> {
+    /**
+     * The selection variant, set to "offset".
+     */
+    selectionVariant: "offset";
+    /**
+     * Function to calculate the start date offset.
+     * @param date - The date to offset.
+     * @returns The offset start date.
+     */
+    startDateOffset?: (date: DateValue) => DateValue;
+    /**
+     * Function to calculate the end date offset.
+     * @param date - The date to offset.
+     * @returns The offset end date.
+     */
+    endDateOffset?: (date: DateValue) => DateValue;
+}
+/**
+ * Properties for the range date selection hook.
+ */
+export interface UseCalendarSelectionRangeProps extends UseCalendarSelectionBaseProps<DateRangeSelection> {
+    /**
+     * The selection variant, set to "range".
+     */
+    selectionVariant: "range";
+}
+/**
+ * Properties for the multi-select date selection hook.
+ */
+export interface UseCalendarSelectionMultiSelectProps extends UseCalendarSelectionBaseProps<MultipleDateSelection> {
+    /**
+     * The selection variant, set to "multiselect".
+     */
+    selectionVariant: "multiselect";
+}
+/**
+ * Properties for the single date selection hook.
+ */
+export interface UseCalendarSelectionSingleProps extends UseCalendarSelectionBaseProps<SingleDateSelection> {
+    /**
+     * The selection variant, set to "single".
+     */
+    selectionVariant: "single";
+}
+/**
+ * UseCalendarSelection hook props, wth the selection variant determining the return type of the date selection
+ */
+export declare type UseCalendarSelectionProps = UseCalendarSelectionSingleProps | UseCalendarSelectionMultiSelectProps | UseCalendarSelectionRangeProps | UseCalendarSelectionOffsetProps;
+export declare function useCalendarSelection(props: UseCalendarSelectionProps): {
+    state: {
+        selectedDate: CalendarDate | CalendarDateTime | ZonedDateTime | DateRangeSelection | MultipleDateSelection | null | undefined;
+        hoveredDate: CalendarDate | CalendarDateTime | ZonedDateTime | null | undefined;
+    };
+    helpers: {
+        setSelectedDate: (event: SyntheticEvent<HTMLButtonElement>, newSelectedDate: DateValue) => void;
+        isSelected: (date: DateValue) => boolean;
+        setHoveredDate: (event: SyntheticEvent, date: DateValue | null) => void;
+        isHovered: (date: DateValue) => boolean;
+        isSelectedSpan: (date: DateValue) => boolean;
+        isHoveredSpan: (date: DateValue) => boolean;
+        isSelectedStart: (date: DateValue) => boolean;
+        isSelectedEnd: (date: DateValue) => boolean;
+        isHoveredOffset: (date: DateValue) => boolean;
+        isDaySelectable: ((date: DateValue) => boolean) | undefined;
+    };
+};
+export declare function useCalendarSelectionDay({ date }: {
+    date: DateValue;
+}): {
+    handleClick: MouseEventHandler<HTMLButtonElement>;
+    handleKeyDown: KeyboardEventHandler<HTMLButtonElement>;
+    handleMouseOver: MouseEventHandler<HTMLButtonElement>;
+    handleMouseLeave: MouseEventHandler<HTMLButtonElement>;
+    status: {
+        selected: boolean;
+        selectedSpan: boolean;
+        hoveredSpan: boolean;
+        selectedStart: boolean;
+        selectedEnd: boolean;
+        hovered: boolean;
+        hoveredOffset: boolean;
+    };
+    dayProps: {
+        className: string;
+        "aria-pressed": string | undefined;
+        "aria-disabled": string | undefined;
+    };
+};
+export {};

package/dist-types/date-input/DateInputRange.d.ts

@@ -0,0 +1,150 @@
+import { type DateValue } from "@internationalized/date";
+import { type InputProps } from "@salt-ds/core";
+import { type ChangeEvent, type ComponentPropsWithoutRef, type InputHTMLAttributes, type ReactNode, type Ref, type SyntheticEvent } from "react";
+import { type DateRangeSelection } from "../calendar";
+import type { DateInputSingleParserError } from "./DateInputSingle";
+/**
+ * Date error produced by DateInputRange parser.
+ */
+export declare type DateInputRangeParserError = string | false;
+/**
+ * DateInputRange raw value or null if no date is defined.
+ */
+export declare type DateInputRangeValue = {
+    startDate?: string | null;
+    endDate?: string | null;
+};
+/**
+ * Return value of DateInputRange parser.
+ * @template T
+ */
+export interface DateInputRangeParserResult<T = DateValue | null> {
+    /**
+     * The parsed date value.
+     */
+    date: T;
+    /**
+     * The error encountered during parsing, if any.
+     */
+    error: DateInputRangeParserError;
+}
+/**
+ * Date Range error returned with selected date to indicate invalid dates.
+ */
+export declare type DateInputRangeError = {
+    /**
+     * The error for the start date.
+     */
+    startDate: DateInputSingleParserError;
+    /**
+     * The error for the end date.
+     */
+    endDate: DateInputSingleParserError;
+};
+/**
+ * Props for the DateInputRange component.
+ * @template T
+ */
+export interface DateInputRangeProps<T = DateRangeSelection> extends Omit<ComponentPropsWithoutRef<"div">, "defaultValue" | "onChange">, Omit<InputProps, "defaultValue" | "inputRef" | "value" | "onChange"> {
+    /**
+     * The aria-label for accessibility.
+     */
+    ariaLabel?: string;
+    /**
+     * Styling variant with full border. Defaults to false.
+     */
+    bordered?: boolean;
+    /**
+     * The marker to use in an empty read-only DateInput.
+     * Use `''` to disable this feature. Defaults to '—'.
+     */
+    emptyReadOnlyMarker?: string;
+    /**
+     * End adornment component.
+     */
+    endAdornment?: ReactNode;
+    /**
+     * Attributes applied to the start `input` element.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dateInput#Attributes
+     */
+    startInputProps?: InputHTMLAttributes<HTMLInputElement>;
+    /**
+     * Attributes applied to the end `input` element.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dateInput#Attributes
+     */
+    endInputProps?: InputHTMLAttributes<HTMLInputElement>;
+    /**
+     * If `true`, the component is read-only.
+     */
+    readOnly?: boolean;
+    /**
+     * Validation status.
+     */
+    validationStatus?: "error" | "warning" | "success";
+    /**
+     * Styling variant. Defaults to "primary".
+     */
+    variant?: "primary" | "secondary";
+    /**
+     * Function to format the input value.
+     */
+    format?: (date: DateValue | null) => string;
+    /**
+     * Optional ref for the start input component.
+     */
+    startInputRef?: Ref<HTMLInputElement>;
+    /**
+     * Optional ref for the end input component.
+     */
+    endInputRef?: Ref<HTMLInputElement>;
+    /**
+     * Input value. Use when the input value is controlled.
+     */
+    value?: DateInputRangeValue;
+    /**
+     * The initial input value. Use when the component is uncontrolled.
+     */
+    defaultValue?: DateInputRangeValue;
+    /**
+     * The date value. Use when the component is controlled.
+     */
+    date?: T | null;
+    /**
+     * The initial selected date value. Use when the component is uncontrolled.
+     */
+    defaultDate?: T | null;
+    /**
+     * Callback fired when the input value changes.
+     * @param event - The change event.
+     * @param date - The new date input range value.
+     */
+    onChange?: (event: ChangeEvent<HTMLInputElement>, date: DateInputRangeValue) => void;
+    /**
+     * Callback fired when the selected date changes.
+     * @param event - The synthetic event.
+     * @param date - The new date value.
+     * @param error - The date input range error.
+     */
+    onDateChange?: (event: SyntheticEvent, date: T | null, error: DateInputRangeError) => void;
+    /**
+     * Called when input values change, either due to user interaction or programmatic formatting of valid dates.
+     * @param newValue - The new date input range value.
+     * @param isFormatted - Whether the value is formatted.
+     */
+    onDateValueChange?: (newValue: DateInputRangeValue, isFormatted: boolean) => void;
+    /**
+     * Function to parse date string to valid `DateValue` or null, if invalid.
+     * @param inputDate - The input date string.
+     * @returns The result of the date input range parser.
+     */
+    parse?: (inputDate: string) => DateInputRangeParserResult;
+    /**
+     * Locale of the entered date.
+     */
+    locale?: string;
+    /**
+     * Timezone of the entered date.
+     */
+    timeZone?: string;
+}
+export declare const DateInputRange: import("react").ForwardRefExoticComponent<DateInputRangeProps<DateRangeSelection> & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/date-input/DateInputSingle.d.ts

@@ -0,0 +1,117 @@
+import { type DateValue } from "@internationalized/date";
+import { type ComponentPropsWithoutRef, type InputHTMLAttributes, type ReactNode, type RefObject, type SyntheticEvent } from "react";
+import { type SingleDateSelection } from "../calendar";
+/**
+ * Date error produced by DateInputSingle parser.
+ */
+export declare type DateInputSingleParserError = string | false;
+/**
+ * Date error produced by DateInputSingle parser.
+ */
+export declare type DateInputSingleError = DateInputSingleParserError;
+/**
+ * Return value of DateInputSingle parser.
+ * @template T
+ */
+export interface DateInputSingleParserResult<T = DateValue | null> {
+    /**
+     * The parsed date value.
+     */
+    date: T;
+    /**
+     * The error encountered during parsing, if any.
+     */
+    error: DateInputSingleParserError;
+}
+/**
+ * Props for the DateInputSingle component.
+ * @template T
+ */
+export interface DateInputSingleProps<T = SingleDateSelection> extends Omit<ComponentPropsWithoutRef<"div">, "defaultValue">, Pick<ComponentPropsWithoutRef<"input">, "disabled" | "value" | "defaultValue" | "placeholder"> {
+    /**
+     * The aria-label for accessibility.
+     */
+    ariaLabel?: string;
+    /**
+     * Styling variant with full border. Defaults to false.
+     */
+    bordered?: boolean;
+    /**
+     * The marker to use in an empty read-only DateInput.
+     * Use `''` to disable this feature. Defaults to '—'.
+     */
+    emptyReadOnlyMarker?: string;
+    /**
+     * End adornment component.
+     */
+    endAdornment?: ReactNode;
+    /**
+     * Attributes applied to the `input` element.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dateInput#Attributes
+     */
+    inputProps?: InputHTMLAttributes<HTMLInputElement>;
+    /**
+     * If `true`, the component is read-only.
+     */
+    readOnly?: boolean;
+    /**
+     * Validation status.
+     */
+    validationStatus?: "error" | "warning" | "success";
+    /**
+     * Styling variant. Defaults to "primary".
+     */
+    variant?: "primary" | "secondary";
+    /**
+     * Function to format the input value.
+     */
+    format?: (date: DateValue | null) => string;
+    /**
+     * Reference for the input.
+     */
+    inputRef?: RefObject<HTMLInputElement>;
+    /**
+     * Input value. Use when the input value is controlled.
+     */
+    value?: string;
+    /**
+     * The initial input value. Use when the component is uncontrolled.
+     */
+    defaultValue?: string;
+    /**
+     * The date value. Use when the component is controlled.
+     */
+    date?: T | null;
+    /**
+     * The initial selected date value. Use when the component is uncontrolled.
+     */
+    defaultDate?: T | null;
+    /**
+     * Callback fired when the selected date changes.
+     * @param event - The synthetic event.
+     * @param date - The new date value.
+     * @param error - The date input single error.
+     */
+    onDateChange?: (event: SyntheticEvent, date: T | null, error: DateInputSingleError) => void;
+    /**
+     * Function to parse date string to valid `DateValue` or null, if invalid or empty.
+     * @param inputDate - The input date string.
+     * @returns The result of the date input single parser.
+     */
+    parse?: (inputDate: string) => DateInputSingleParserResult;
+    /**
+     * Called when input value changes, either due to user interaction or programmatic formatting of valid dates.
+     * @param newValue - The new date input value.
+     * @param isFormatted - Whether the value is formatted.
+     */
+    onDateValueChange?: (newValue: string, isFormatted: boolean) => void;
+    /**
+     * Locale of the entered date.
+     */
+    locale?: string;
+    /**
+     * Timezone of the entered date.
+     */
+    timeZone?: string;
+}
+export declare const DateInputSingle: import("react").ForwardRefExoticComponent<DateInputSingleProps<DateValue> & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/date-input/index.d.ts

@@ -1 +1,3 @@
-export * from "./DateInput";
+export * from "./DateInputSingle";
+export * from "./DateInputRange";
+export * from "./utils";