@salt-ds/lab 1.0.0-alpha.54 → 1.0.0-alpha.56

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

@@ -1,67 +1,63 @@
-import { type DateValue } from "@internationalized/date";
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
 import { type SyntheticEvent } from "react";
 import { type UseCalendarSelectionMultiSelectProps, type UseCalendarSelectionOffsetProps, type UseCalendarSelectionRangeProps, type UseCalendarSelectionSingleProps } from "./useCalendarSelection";
 /**
  * Interface representing the base properties UseCalendar hook.
  */
-interface UseCalendarBaseProps {
+interface UseCalendarBaseProps<TDate> {
     /**
      * The default visible month.
      */
-    defaultVisibleMonth?: DateValue;
+    defaultVisibleMonth?: TDate;
     /**
      * Callback fired when the visible month changes.
      * @param event - The synthetic event.
      * @param visibleMonth - The new visible month.
      */
-    onVisibleMonthChange?: (event: SyntheticEvent, visibleMonth: DateValue) => void;
+    onVisibleMonthChange?: (event: SyntheticEvent, visibleMonth: TDate) => 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;
+    isDayUnselectable?: (date: TDate) => 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;
+    isDayHighlighted?: (date: TDate) => string | false | undefined;
     /**
      * 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;
+    isDayDisabled?: (date: TDate) => string | false | undefined;
     /**
      * The currently visible month.
      */
-    visibleMonth?: DateValue;
+    visibleMonth?: TDate;
     /**
      * If `true`, hides dates that are out of the selectable range.
      */
     hideOutOfRangeDates?: boolean;
     /**
-     * The minimum selectable date.
-     */
-    minDate?: DateValue;
-    /**
-     * The maximum selectable date.
+     * Locale for date formatting
      */
-    maxDate?: DateValue;
+    locale?: any;
     /**
-     * The time zone used for date calculations.
+     * The minimum selectable date.
      */
-    timeZone?: string;
+    minDate?: TDate;
     /**
-     * The locale used for date formatting.
+     * The maximum selectable date.
      */
-    locale?: string;
+    maxDate?: TDate;
 }
 /**
  * UseCalendar hook props for a single date selection Calendar.
  */
-export interface UseCalendarSingleProps extends UseCalendarSelectionSingleProps, UseCalendarBaseProps {
+export interface UseCalendarSingleProps<TDate extends DateFrameworkType> extends UseCalendarSelectionSingleProps<TDate>, UseCalendarBaseProps<TDate> {
     /**
      * The selection variant, set to "single".
      */
@@ -70,7 +66,7 @@ export interface UseCalendarSingleProps extends UseCalendarSelectionSingleProps,
 /**
  * UseCalendar hook props for a date range selection Calendar.
  */
-export interface UseCalendarRangeProps extends UseCalendarSelectionRangeProps, UseCalendarBaseProps {
+export interface UseCalendarRangeProps<TDate extends DateFrameworkType> extends UseCalendarSelectionRangeProps<TDate>, UseCalendarBaseProps<TDate> {
     /**
      * The selection variant, set to "range".
      */
@@ -79,7 +75,7 @@ export interface UseCalendarRangeProps extends UseCalendarSelectionRangeProps, U
 /**
  * UseCalendar hook props for a multi-select Calendar.
  */
-export interface UseCalendarMultiSelectProps extends UseCalendarSelectionMultiSelectProps, UseCalendarBaseProps {
+export interface UseCalendarMultiSelectProps<TDate extends DateFrameworkType> extends UseCalendarSelectionMultiSelectProps<TDate>, UseCalendarBaseProps<TDate> {
     /**
      * The selection variant, set to "multiselect".
      */
@@ -88,7 +84,7 @@ export interface UseCalendarMultiSelectProps extends UseCalendarSelectionMultiSe
 /**
  * UseCalendar hook props for an offset date selection Calendar.
  */
-export interface UseCalendarOffsetProps extends UseCalendarSelectionOffsetProps, UseCalendarBaseProps {
+export interface UseCalendarOffsetProps<TDate extends DateFrameworkType> extends UseCalendarSelectionOffsetProps<TDate>, UseCalendarBaseProps<TDate> {
     /**
      * The selection variant, set to "offset".
      */
@@ -97,42 +93,198 @@ export interface UseCalendarOffsetProps extends UseCalendarSelectionOffsetProps,
 /**
  * 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): {
+export declare type UseCalendarProps<TDate extends DateFrameworkType> = UseCalendarSingleProps<TDate> | UseCalendarRangeProps<TDate> | UseCalendarMultiSelectProps<TDate> | UseCalendarOffsetProps<TDate>;
+/**
+ * Represents the return type of the useCalendar hook.
+ *
+ * @template TDate - The type of the date object used in the calendar.
+ */
+export interface UseCalendarReturn<TDate extends DateFrameworkType> {
+    /**
+     * The state of the calendar.
+     */
     state: {
-        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 | null;
-        minDate: DateValue | undefined;
-        maxDate: DateValue | undefined;
-        selectionVariant: "offset" | "range" | "single" | "multiselect";
-        hideOutOfRangeDates: boolean | undefined;
+        /**
+         * The currently visible month in the calendar.
+         */
+        visibleMonth: TDate;
+        /**
+         * The currently focused date in the calendar, or null if no date is focused.
+         */
+        focusedDate: TDate | null;
+        /**
+         * The locale used for date formatting.
+         */
+        locale: any;
+        /**
+         * The minimum selectable date in the calendar.
+         */
+        minDate: TDate;
+        /**
+         * The maximum selectable date in the calendar.
+         */
+        maxDate: TDate;
+        /**
+         * The selection variant of the calendar, indicating the type of selection allowed.
+         */
+        selectionVariant: "single" | "range" | "multiselect" | "offset";
+        /**
+         * Whether to hide dates that are out of the selectable range.
+         */
+        hideOutOfRangeDates?: boolean;
+        /**
+         * Whether the calendar is currently focused.
+         */
         calendarFocused: boolean;
-        timeZone: string;
-        locale: string;
+        /**
+         * Additional state properties from selectionManager.state.
+         */
+        [key: string]: any;
     };
+    /**
+     * Helper functions for interacting with the calendar.
+     */
     helpers: {
-        setSelectedDate: (event: SyntheticEvent<HTMLButtonElement, Event>, newSelectedDate: DateValue) => void;
-        isSelected: (date: DateValue) => boolean;
-        setHoveredDate: (event: SyntheticEvent<Element, Event>, 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;
-        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) => string | false | undefined;
-        isDayVisible: (date: DateValue) => boolean;
-        isOutsideAllowedDates: (date: DateValue) => boolean | undefined;
-        isOutsideAllowedMonths: (date: DateValue) => boolean | undefined;
-        isOutsideAllowedYears: (date: DateValue) => boolean | undefined;
+        /**
+         * Sets the visible month in the calendar.
+         *
+         * @param event - The synthetic event triggering the change.
+         * @param newVisibleMonth - The new visible month to set.
+         */
+        setVisibleMonth: (event: SyntheticEvent, newVisibleMonth: TDate) => void;
+        /**
+         * Sets the focused date in the calendar.
+         *
+         * @param event - The synthetic event triggering the change.
+         * @param date - The new date to focus.
+         */
+        setFocusedDate: (event: SyntheticEvent, date: TDate) => void;
+        /**
+         * Sets whether the calendar is focused.
+         *
+         * @param focused - Whether the calendar should be focused.
+         */
+        setCalendarFocused: (focused: boolean) => void;
+        /**
+         * Determines 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: TDate) => string | false | undefined;
+        /**
+         * Determines 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: TDate) => string | false | undefined;
+        /**
+         * Determines 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: TDate) => string | false | undefined;
+        /**
+         * Determines if a day is visible in the calendar.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the day is visible, otherwise `false`.
+         */
+        isDayVisible: (date: TDate) => boolean;
+        /**
+         * Determines if a date is outside the allowed date range.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is outside the allowed range, otherwise `false`.
+         */
+        isOutsideAllowedDates: (date: TDate) => boolean;
+        /**
+         * Determines if a month is outside the allowed range.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the month is outside the allowed range, otherwise `false`.
+         */
+        isOutsideAllowedMonths: (date: TDate) => boolean;
+        /**
+         * Determines if a year is outside the allowed range.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the year is outside the allowed range, otherwise `false`.
+         */
+        isOutsideAllowedYears: (date: TDate) => boolean;
+        /**
+         * Sets the selected date in the calendar.
+         *
+         * @param event - The event triggering the change.
+         * @param newSelectedDate - The new date to select.
+         */
+        setSelectedDate: (event: React.KeyboardEvent<HTMLButtonElement> | React.MouseEvent<HTMLButtonElement, MouseEvent>, newSelectedDate: TDate) => void;
+        /**
+         * Determines if a date is selected.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is selected, otherwise `false`.
+         */
+        isSelected: (date: TDate) => boolean;
+        /**
+         * Sets the hovered date in the calendar.
+         *
+         * @param event - The event triggering the change.
+         * @param newHoveredDate - The new date to hover.
+         */
+        setHoveredDate: (event: SyntheticEvent, newHoveredDate: TDate | null) => void;
+        /**
+         * Determines if a date is part of a selected span.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is part of a selected span, otherwise `false`.
+         */
+        isSelectedSpan: (date: TDate) => boolean;
+        /**
+         * Determines if a date is part of a hovered span.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is part of a hovered span, otherwise `false`.
+         */
+        isHoveredSpan: (date: TDate) => boolean;
+        /**
+         * Determines if a date is the start of a selected range.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is the start of a selected range, otherwise `false`.
+         */
+        isSelectedStart: (date: TDate) => boolean;
+        /**
+         * Determines if a date is the end of a selected range.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is the end of a selected range, otherwise `false`.
+         */
+        isSelectedEnd: (date: TDate) => boolean;
+        /**
+         * Determines if a date is hovered.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is hovered, otherwise `false`.
+         */
+        isHovered: (date: TDate) => boolean;
+        /**
+         * Determines if a date is part of a hovered offset.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the date is part of a hovered offset, otherwise `false`.
+         */
+        isHoveredOffset: (date: TDate) => boolean;
+        /**
+         * Determines if a day is selectable.
+         *
+         * @param date - The date to check.
+         * @returns `true` if the day is selectable, otherwise `false`.
+         */
+        isDaySelectable: (date: TDate) => boolean;
     };
-};
+}
+export declare function useCalendar<TDate extends DateFrameworkType>(props: UseCalendarProps<TDate>): UseCalendarReturn<TDate>;
 export {};

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

@@ -1,4 +1,4 @@
-import { type DateValue } from "@internationalized/date";
+import type { DateFrameworkType } from "@salt-ds/date-adapters";
 import { type RefObject } from "react";
 /**
  * Interface representing the status of a day in the Calendar.
@@ -40,21 +40,19 @@ export interface DayStatus {
 /**
  * UseCalendar hook props to return a calendar day's status
  */
-export interface useCalendarDayProps {
+export interface useCalendarDayProps<TDate> {
     /**
      * The date of the calendar day.
      */
-    date: DateValue;
+    date: TDate;
     /**
      * The month of the calendar day.
      */
-    month: DateValue;
+    month: TDate;
 }
-export declare function useCalendarDay({ date, month }: useCalendarDayProps, ref: RefObject<HTMLElement>): {
+export declare function useCalendarDay<TDate extends DateFrameworkType>(props: useCalendarDayProps<TDate>, ref: RefObject<HTMLElement>): {
     status: DayStatus;
     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

@@ -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/contact-details/internal/StarIcon.d.ts

@@ -1,7 +1,6 @@
-import React from "react";
 export interface StarIconProps {
     className?: string;
     selected?: boolean;
     highlighted?: boolean;
 }
-export declare const StarIcon: React.ForwardRefExoticComponent<StarIconProps & React.RefAttributes<SVGSVGElement>>;
+export declare const StarIcon: import("react").ForwardRefExoticComponent<StarIconProps & import("react").RefAttributes<SVGSVGElement>>;

package/dist-types/contact-details/internal/StarIconContainer.d.ts

@@ -1,4 +1,4 @@
-import React, { type HTMLAttributes } from "react";
+import { type HTMLAttributes } from "react";
 export interface StarIconContainerProps extends HTMLAttributes<HTMLSpanElement> {
     className?: string;
     isFocusVisible?: boolean;
@@ -6,4 +6,4 @@ export interface StarIconContainerProps extends HTMLAttributes<HTMLSpanElement>
     isHighlighted?: boolean;
     isSelected?: boolean;
 }
-export declare const StarIconContainer: React.ForwardRefExoticComponent<StarIconContainerProps & React.RefAttributes<HTMLSpanElement>>;
+export declare const StarIconContainer: import("react").ForwardRefExoticComponent<StarIconContainerProps & import("react").RefAttributes<HTMLSpanElement>>;