@salt-ds/lab 1.0.0-alpha.55 → 1.0.0-alpha.57

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

@@ -1,164 +1,198 @@
-import { CalendarDate, CalendarDateTime, type DateValue, ZonedDateTime } from "@internationalized/date";
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
 import type { KeyboardEventHandler, MouseEventHandler, SyntheticEvent } from "react";
 /**
  * Type representing a single date selection.
  */
-export declare type SingleDateSelection = DateValue;
+export declare type SingleDateSelection<TDate extends DateFrameworkType> = TDate;
 /**
  * Type representing multiple date selections.
  */
-export declare type MultipleDateSelection = DateValue[];
+export declare type MultipleDateSelection<TDate extends DateFrameworkType> = TDate[];
 /**
  * Type representing a date range selection.
  */
-export declare type DateRangeSelection = {
+export declare type DateRangeSelection<TDate extends DateFrameworkType> = {
     /**
      * The start date of the range.
      */
-    startDate?: DateValue | null;
+    startDate?: TDate | null;
     /**
      * The end date of the range.
      */
-    endDate?: DateValue | null;
+    endDate?: TDate | 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;
+export declare type AllSelectionValueType<TDate extends DateFrameworkType> = SingleDateSelection<TDate> | MultipleDateSelection<TDate> | DateRangeSelection<TDate> | null;
 /**
  * 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;
+export declare function isSingleSelectionValueType<TDate extends DateFrameworkType>(value: any): value is TDate;
 /**
  * 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;
+export declare function isDateRangeSelection<TDate extends DateFrameworkType>(value: any): value is DateRangeSelection<TDate>;
 /**
  * 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;
+export declare function isMultipleDateSelection<TDate extends DateFrameworkType>(value: any): value is MultipleDateSelection<TDate>;
 /**
  * Base properties for calendar UseCalendarSelection hook.
  * @template SelectionVariantType - The type of the selection variant.
  */
-interface UseCalendarSelectionBaseProps<SelectionVariantType> {
+interface UseCalendarSelectionBaseProps<TDate extends DateFrameworkType> {
     /**
      * 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;
+    hoveredDate?: TDate | null;
     /**
      * 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;
+    isDaySelectable?: (date: TDate) => 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;
+    onHoveredDateChange?: (event: SyntheticEvent, hoveredDate: TDate | null) => void;
 }
 /**
  * UseCalendar hook props to return a calendar day's status
  */
-export interface UseCalendarSelectionOffsetProps extends Omit<UseCalendarSelectionBaseProps<DateRangeSelection>, "startDateOffset" | "endDateOffset"> {
+export interface UseCalendarSelectionOffsetProps<TDate extends DateFrameworkType> extends Omit<UseCalendarSelectionBaseProps<TDate>, "startDateOffset" | "endDateOffset"> {
     /**
      * The selection variant, set to "offset".
      */
     selectionVariant: "offset";
+    /**
+     * The currently selected date.
+     */
+    selectedDate?: DateRangeSelection<TDate>;
+    /**
+     * The default selected date.
+     */
+    defaultSelectedDate?: DateRangeSelection<TDate>;
+    /**
+     * Callback fired when the selected date changes.
+     * @param event - The synthetic event.
+     * @param selectedDate - The new selected date.
+     */
+    onSelectionChange?: (event: SyntheticEvent, selectedDate: DateRangeSelection<TDate>) => void;
     /**
      * Function to calculate the start date offset.
      * @param date - The date to offset.
      * @returns The offset start date.
      */
-    startDateOffset?: (date: DateValue) => DateValue;
+    startDateOffset?: (date: TDate) => TDate;
     /**
      * Function to calculate the end date offset.
      * @param date - The date to offset.
      * @returns The offset end date.
      */
-    endDateOffset?: (date: DateValue) => DateValue;
+    endDateOffset?: (date: TDate) => TDate;
 }
 /**
  * Properties for the range date selection hook.
  */
-export interface UseCalendarSelectionRangeProps extends UseCalendarSelectionBaseProps<DateRangeSelection> {
+export interface UseCalendarSelectionRangeProps<TDate extends DateFrameworkType> extends UseCalendarSelectionBaseProps<TDate> {
     /**
      * The selection variant, set to "range".
      */
     selectionVariant: "range";
+    /**
+     * The currently selected date.
+     */
+    selectedDate?: DateRangeSelection<TDate>;
+    /**
+     * The default selected date.
+     */
+    defaultSelectedDate?: DateRangeSelection<TDate>;
+    /**
+     * Callback fired when the selected date changes.
+     * @param event - The synthetic event.
+     * @param selectedDate - The new selected date.
+     */
+    onSelectionChange?: (event: SyntheticEvent, selectedDate: DateRangeSelection<TDate>) => void;
 }
 /**
  * Properties for the multi-select date selection hook.
  */
-export interface UseCalendarSelectionMultiSelectProps extends UseCalendarSelectionBaseProps<MultipleDateSelection> {
+export interface UseCalendarSelectionMultiSelectProps<TDate extends DateFrameworkType> extends UseCalendarSelectionBaseProps<TDate> {
     /**
      * The selection variant, set to "multiselect".
      */
     selectionVariant: "multiselect";
+    /**
+     * The currently selected date.
+     */
+    selectedDate?: MultipleDateSelection<TDate>;
+    /**
+     * The default selected date.
+     */
+    defaultSelectedDate?: MultipleDateSelection<TDate>;
+    /**
+     * Callback fired when the selected date changes.
+     * @param event - The synthetic event.
+     * @param selectedDate - The new selected date.
+     */
+    onSelectionChange?: (event: SyntheticEvent, selectedDate: MultipleDateSelection<TDate>) => void;
 }
 /**
  * Properties for the single date selection hook.
  */
-export interface UseCalendarSelectionSingleProps extends UseCalendarSelectionBaseProps<SingleDateSelection> {
+export interface UseCalendarSelectionSingleProps<TDate extends DateFrameworkType> extends UseCalendarSelectionBaseProps<TDate> {
     /**
      * The selection variant, set to "single".
      */
     selectionVariant: "single";
+    /**
+     * The currently selected date.
+     */
+    selectedDate?: SingleDateSelection<TDate> | null;
+    /**
+     * The default selected date.
+     */
+    defaultSelectedDate?: SingleDateSelection<TDate> | null;
+    /**
+     * Callback fired when the selected date changes.
+     * @param event - The synthetic event.
+     * @param selectedDate - The new selected date.
+     */
+    onSelectionChange?: (event: SyntheticEvent, selectedDate: SingleDateSelection<TDate> | null) => void;
 }
 /**
  * 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): {
+export declare type UseCalendarSelectionProps<TDate extends DateFrameworkType> = UseCalendarSelectionSingleProps<TDate> | UseCalendarSelectionMultiSelectProps<TDate> | UseCalendarSelectionRangeProps<TDate> | UseCalendarSelectionOffsetProps<TDate>;
+export declare function useCalendarSelection<TDate extends DateFrameworkType>(props: UseCalendarSelectionProps<TDate>): {
     state: {
-        selectedDate: CalendarDate | CalendarDateTime | ZonedDateTime | DateRangeSelection | MultipleDateSelection | null | undefined;
-        hoveredDate: CalendarDate | CalendarDateTime | ZonedDateTime | null | undefined;
+        selectedDate: TDate | MultipleDateSelection<TDate> | DateRangeSelection<TDate> | null | undefined;
+        hoveredDate: TDate | 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;
+        setSelectedDate: (event: SyntheticEvent<HTMLButtonElement>, newSelectedDate: TDate) => void;
+        isSelected: (date: TDate) => boolean;
+        setHoveredDate: (event: SyntheticEvent, date: TDate | null) => void;
+        isHovered: (date: TDate) => boolean;
+        isSelectedSpan: (date: TDate) => boolean;
+        isHoveredSpan: (date: TDate) => boolean;
+        isSelectedStart: (date: TDate) => boolean;
+        isSelectedEnd: (date: TDate) => boolean;
+        isHoveredOffset: (date: TDate) => boolean;
+        isDaySelectable: ((date: TDate) => boolean) | undefined;
     };
 };
-export declare function useCalendarSelectionDay({ date }: {
-    date: DateValue;
+export declare function useCalendarSelectionDay<TDate extends DateFrameworkType>({ date, }: {
+    date: TDate;
 }): {
     handleClick: MouseEventHandler<HTMLButtonElement>;
     handleKeyDown: KeyboardEventHandler<HTMLButtonElement>;

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

@@ -1,12 +1,7 @@
-import { type DateValue } from "@internationalized/date";
 import { type InputProps } from "@salt-ds/core";
+import type { DateDetail, DateFrameworkType, ParserResult } from "@salt-ds/date-adapters";
 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;
+import type { DateRangeSelection } from "../calendar";
 /**
  * DateInputRange raw value or null if no date is defined.
  */
@@ -15,37 +10,26 @@ export declare type DateInputRangeValue = {
     endDate?: string | null;
 };
 /**
- * Return value of DateInputRange parser.
- * @template T
+ * Details of parsing the date range
  */
-export interface DateInputRangeParserResult<T = DateValue | null> {
-    /**
-     * The parsed date value.
-     */
-    date: T;
-    /**
-     * The error encountered during parsing, if any.
-     */
-    error: DateInputRangeParserError;
-}
+export declare type DateInputRangeDetails = {
+    /** Details of parsing the start date and applying any validation */
+    startDate?: DateDetail;
+    /** Details of parsing the end date and applying any validation */
+    endDate?: DateDetail;
+};
 /**
- * Date Range error returned with selected date to indicate invalid dates.
+ * Enum to identify the field being parsed
  */
-export declare type DateInputRangeError = {
-    /**
-     * The error for the start date.
-     */
-    startDate: DateInputSingleParserError;
-    /**
-     * The error for the end date.
-     */
-    endDate: DateInputSingleParserError;
-};
+export declare enum DateParserField {
+    START = "start",
+    END = "end"
+}
 /**
  * Props for the DateInputRange component.
  * @template T
  */
-export interface DateInputRangeProps<T = DateRangeSelection> extends Omit<ComponentPropsWithoutRef<"div">, "defaultValue" | "onChange">, Omit<InputProps, "defaultValue" | "inputRef" | "value" | "onChange"> {
+export interface DateInputRangeProps<TDate extends DateFrameworkType> extends Omit<ComponentPropsWithoutRef<"div">, "defaultValue" | "onChange">, Omit<InputProps, "defaultValue" | "inputRef" | "value" | "onChange"> {
     /**
      * The aria-label for accessibility.
      */
@@ -86,9 +70,9 @@ export interface DateInputRangeProps<T = DateRangeSelection> extends Omit<Compon
      */
     variant?: "primary" | "secondary";
     /**
-     * Function to format the input value.
+     * Format string for date.
      */
-    format?: (date: DateValue | null) => string;
+    format?: string;
     /**
      * Optional ref for the start input component.
      */
@@ -97,6 +81,18 @@ export interface DateInputRangeProps<T = DateRangeSelection> extends Omit<Compon
      * Optional ref for the end input component.
      */
     endInputRef?: Ref<HTMLInputElement>;
+    /**
+     * Locale for date formatting and parsing
+     */
+    locale?: any;
+    /**
+     * Parser callback, if not using the adapter's parser
+     * @param value - date string to parse
+     * @param field: DateParserField to identify value,
+     * @param format - format required
+     * @param locale - locale required
+     */
+    parse?: (value: string, field: DateParserField, format: string, locale?: any) => ParserResult<TDate>;
     /**
      * Input value. Use when the input value is controlled.
      */
@@ -108,43 +104,29 @@ export interface DateInputRangeProps<T = DateRangeSelection> extends Omit<Compon
     /**
      * The date value. Use when the component is controlled.
      */
-    date?: T | null;
+    date?: DateRangeSelection<TDate> | null;
     /**
      * The initial selected date value. Use when the component is uncontrolled.
      */
-    defaultDate?: T | null;
+    defaultDate?: DateRangeSelection<TDate> | 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;
+    onChange?: (event: ChangeEvent<HTMLInputElement>) => 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.
+     * @param date - the selected date, invalid date if not a valid date or undefined (uncontrolled) or null (controlled) if not defined
+     * @param details - The details of date selection, either a valid date or error
      */
-    onDateChange?: (event: SyntheticEvent, date: T | null, error: DateInputRangeError) => void;
+    onDateChange?: (event: SyntheticEvent, date: DateRangeSelection<TDate> | null, details: DateInputRangeDetails) => void;
     /**
      * Called when input values change, either due to user interaction or programmatic formatting of valid dates.
+     * @param event - The synthetic event or null if a programmatic change.
      * @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;
+    onDateValueChange?: (event: SyntheticEvent | null, newValue: DateInputRangeValue) => void;
 }
-export declare const DateInputRange: import("react").ForwardRefExoticComponent<DateInputRangeProps<DateRangeSelection> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const DateInputRange: import("react").ForwardRefExoticComponent<DateInputRangeProps<any> & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -1,33 +1,15 @@
-import { type DateValue } from "@internationalized/date";
-import { type ComponentPropsWithoutRef, type InputHTMLAttributes, type ReactNode, type RefObject, type SyntheticEvent } from "react";
-import { type SingleDateSelection } from "../calendar";
+import type { DateDetail, DateFrameworkType, ParserResult } from "@salt-ds/date-adapters";
+import { type ComponentPropsWithoutRef, type InputHTMLAttributes, type ReactNode, type Ref, type SyntheticEvent } from "react";
+import type { SingleDateSelection } from "../calendar";
 /**
- * Date error produced by DateInputSingle parser.
+ * Details of parsing the date
  */
-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;
-}
+export declare type DateInputSingleDetails = DateDetail;
 /**
  * Props for the DateInputSingle component.
  * @template T
  */
-export interface DateInputSingleProps<T = SingleDateSelection> extends Omit<ComponentPropsWithoutRef<"div">, "defaultValue">, Pick<ComponentPropsWithoutRef<"input">, "disabled" | "value" | "defaultValue" | "placeholder"> {
+export interface DateInputSingleProps<TDate extends DateFrameworkType> extends Omit<ComponentPropsWithoutRef<"div">, "defaultValue">, Pick<ComponentPropsWithoutRef<"input">, "disabled" | "value" | "defaultValue" | "placeholder"> {
     /**
      * The aria-label for accessibility.
      */
@@ -54,6 +36,10 @@ export interface DateInputSingleProps<T = SingleDateSelection> extends Omit<Comp
      * If `true`, the component is read-only.
      */
     readOnly?: boolean;
+    /**
+     * Start adornment component
+     */
+    startAdornment?: ReactNode;
     /**
      * Validation status.
      */
@@ -63,13 +49,24 @@ export interface DateInputSingleProps<T = SingleDateSelection> extends Omit<Comp
      */
     variant?: "primary" | "secondary";
     /**
-     * Function to format the input value.
+     * Format string for date.
      */
-    format?: (date: DateValue | null) => string;
+    format?: string;
     /**
      * Reference for the input.
      */
-    inputRef?: RefObject<HTMLInputElement>;
+    inputRef?: Ref<HTMLInputElement>;
+    /**
+     * Locale for date formatting and parsing
+     */
+    locale?: any;
+    /**
+     * Parser callback, if not using the adapter's parser
+     * @param value - date string to parse
+     * @param format - format required
+     * @param locale - locale required
+     */
+    parse?: (value: string, format: string, locale?: any) => ParserResult<TDate>;
     /**
      * Input value. Use when the input value is controlled.
      */
@@ -81,37 +78,23 @@ export interface DateInputSingleProps<T = SingleDateSelection> extends Omit<Comp
     /**
      * The date value. Use when the component is controlled.
      */
-    date?: T | null;
+    date?: TDate | null;
     /**
      * The initial selected date value. Use when the component is uncontrolled.
      */
-    defaultDate?: T | null;
+    defaultDate?: TDate | 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.
+     * @param date - the selected date, invalid date if not a valid date or undefined (uncontrolled) or null (controlled) if not defined
+     * @param details - The details of date selection, either a valid date or 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;
+    onDateChange?: (event: SyntheticEvent, date: SingleDateSelection<TDate> | null | undefined, details: DateInputSingleDetails) => void;
     /**
      * Called when input value changes, either due to user interaction or programmatic formatting of valid dates.
+     * @param event - The synthetic event or null if a programmatic change.
      * @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;
+    onDateValueChange?: (event: SyntheticEvent | null, newValue: string) => void;
 }
-export declare const DateInputSingle: import("react").ForwardRefExoticComponent<DateInputSingleProps<DateValue> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const DateInputSingle: import("react").ForwardRefExoticComponent<DateInputSingleProps<any> & import("react").RefAttributes<HTMLDivElement>>;

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

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

package/dist-types/date-picker/DatePicker.d.ts

@@ -1,3 +1,4 @@
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
 import { type ReactNode } from "react";
 import { type UseDatePickerRangeProps, type UseDatePickerSingleProps } from "./useDatePicker";
 /**
@@ -8,17 +9,34 @@ export interface DatePickerBaseProps {
     children?: ReactNode;
     /** the open/close state of the overlay. The open/close state will be controlled when this prop is provided. */
     open?: boolean;
+    /**
+     * Handler for when open state changes
+     * @param newOpen - true when opened
+     */
+    onOpen?: (newOpen: boolean) => void;
     /**
      * the initial open/close state of the overlay, when the open/close state is un-controlled.
      */
     defaultOpen?: DatePickerBaseProps["open"];
 }
-export interface DatePickerSingleProps extends DatePickerBaseProps, UseDatePickerSingleProps {
+/**
+ * Props for the DatePicker component, when `selectionVariant` is `single`.
+ * @template T
+ */
+export interface DatePickerSingleProps<TDate extends DateFrameworkType> extends DatePickerBaseProps, UseDatePickerSingleProps<TDate> {
     selectionVariant: "single";
 }
-export interface DatePickerRangeProps extends DatePickerBaseProps, UseDatePickerRangeProps {
+/**
+ * Props for the DatePicker component, when `selectionVariant` is `range`.
+ * @template T
+ */
+export interface DatePickerRangeProps<TDate extends DateFrameworkType> extends DatePickerBaseProps, UseDatePickerRangeProps<TDate> {
     selectionVariant: "range";
 }
-export declare type DatePickerProps = DatePickerSingleProps | DatePickerRangeProps;
-export declare const DatePickerMain: import("react").ForwardRefExoticComponent<DatePickerProps & import("react").RefAttributes<HTMLDivElement>>;
-export declare const DatePicker: import("react").ForwardRefExoticComponent<DatePickerProps & import("react").RefAttributes<HTMLDivElement>>;
+/**
+ * Props for the DatePicker component.
+ * @template T
+ */
+export declare type DatePickerProps<TDate extends DateFrameworkType> = DatePickerSingleProps<TDate> | DatePickerRangeProps<TDate>;
+export declare const DatePickerMain: import("react").ForwardRefExoticComponent<DatePickerProps<any> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const DatePicker: import("react").ForwardRefExoticComponent<DatePickerProps<Date | import("dayjs").Dayjs | import("luxon").DateTime<boolean> | import("moment").Moment> & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/date-picker/DatePickerActions.d.ts

@@ -2,8 +2,9 @@ import { type ButtonProps } from "@salt-ds/core";
 import { type ComponentPropsWithoutRef, type Ref, type SyntheticEvent } from "react";
 import type { DateRangeSelection, SingleDateSelection } from "../calendar";
 import "./DatePickerActions.css";
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
 /**
- * Base props for DatePicker actions.
+ * Base props for DatePicker actions component.
  */
 export interface DatePickerActionsBaseProps extends ComponentPropsWithoutRef<"div"> {
     /**
@@ -32,7 +33,7 @@ export interface DatePickerActionsBaseProps extends ComponentPropsWithoutRef<"di
  * Props for the DatePicker actions component.
  * @template SelectionVariant - The selection variant, either "single" or "range".
  */
-export declare type DatePickerActionsProps<SelectionVariant extends "single" | "range"> = SelectionVariant extends "single" ? DatePickerActionsBaseProps & {
+export declare type DatePickerActionsProps<TDate extends DateFrameworkType, SelectionVariant extends "single" | "range"> = SelectionVariant extends "single" ? DatePickerActionsBaseProps & {
     /**
      * The selection variant, set to "single".
      */
@@ -42,7 +43,7 @@ export declare type DatePickerActionsProps<SelectionVariant extends "single" | "
      * @param _event - The synthetic event.
      * @param date - The selected single date or null.
      */
-    onApply?: (_event: SyntheticEvent, date: SingleDateSelection | null) => void;
+    onApply?: (_event: SyntheticEvent, date: SingleDateSelection<TDate> | null) => void;
 } : DatePickerActionsBaseProps & {
     /**
      * The selection variant, set to "range".
@@ -53,28 +54,28 @@ export declare type DatePickerActionsProps<SelectionVariant extends "single" | "
      * @param _event - The synthetic event.
      * @param date - The selected date range or null.
      */
-    onApply?: (_event: SyntheticEvent, date: DateRangeSelection | null) => void;
+    onApply?: (_event: SyntheticEvent, date: DateRangeSelection<TDate> | null) => void;
 };
 export declare const DatePickerActions: import("react").ForwardRefExoticComponent<((DatePickerActionsBaseProps & {
     /**
-     * The selection variant, set to "single".
+     * The selection variant, set to "range".
      */
-    selectionVariant: "single";
+    selectionVariant: "range";
     /**
      * Callback fired when the apply action is triggered.
      * @param _event - The synthetic event.
-     * @param date - The selected single date or null.
+     * @param date - The selected date range or null.
      */
-    onApply?: ((_event: SyntheticEvent, date: SingleDateSelection | null) => void) | undefined;
+    onApply?: ((_event: SyntheticEvent, date: DateRangeSelection<Date | import("dayjs").Dayjs | import("luxon").DateTime<boolean> | import("moment").Moment> | null) => void) | undefined;
 }) | (DatePickerActionsBaseProps & {
     /**
-     * The selection variant, set to "range".
+     * The selection variant, set to "single".
      */
-    selectionVariant: "range";
+    selectionVariant: "single";
     /**
      * Callback fired when the apply action is triggered.
      * @param _event - The synthetic event.
-     * @param date - The selected date range or null.
+     * @param date - The selected single date or null.
      */
-    onApply?: ((_event: SyntheticEvent, date: DateRangeSelection | null) => void) | undefined;
+    onApply?: ((_event: SyntheticEvent, date: Date | import("dayjs").Dayjs | import("luxon").DateTime<boolean> | import("moment").Moment | null) => void) | undefined;
 })) & import("react").RefAttributes<HTMLDivElement>>;