@salt-ds/date-components 0.0.0-snapshot-20260330155807

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

@@ -0,0 +1,131 @@
+import { type InputProps } from "@salt-ds/core";
+import type { DateDetail, ParserResult, Timezone } 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";
+/**
+ * DateInputRange raw value or null if no date is defined.
+ */
+export type DateInputRangeValue = {
+    startDate?: string | null;
+    endDate?: string | null;
+};
+/**
+ * Details of parsing the date range
+ */
+export 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;
+};
+/**
+ * Enum to identify the field being parsed
+ */
+export declare enum DateParserField {
+    START = "start",
+    END = "end"
+}
+/**
+ * Props for the DateInputRange component.
+ */
+export interface DateInputRangeProps extends Omit<ComponentPropsWithoutRef<"div">, "defaultValue" | "onChange">, Omit<InputProps, "defaultValue" | "inputRef" | "value" | "onChange"> {
+    /**
+     * 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" | "tertiary";
+    /**
+     * Format string for date.
+     */
+    format?: string;
+    /**
+     * Optional ref for the start input component.
+     */
+    startInputRef?: Ref<HTMLInputElement>;
+    /**
+     * Optional ref for the end input component.
+     */
+    endInputRef?: Ref<HTMLInputElement>;
+    /**
+     * 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
+     */
+    parse?: (value: string, field: DateParserField, format: string) => ParserResult;
+    /**
+     * 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?: DateRangeSelection | null;
+    /**
+     * The initial selected date value. Use when the component is uncontrolled.
+     */
+    defaultDate?: DateRangeSelection | 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>) => void;
+    /**
+     * Callback fired when the selected date changes.
+     * @param event - The synthetic event.
+     * @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: DateRangeSelection | 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.
+     */
+    onDateValueChange?: (event: SyntheticEvent | null, newValue: DateInputRangeValue) => void;
+    /**
+     * Specifies the timezone behavior:
+     * - If undefined, the timezone will be derived from the passed date, or from `defaultSelectedDate`/`selectedDate`.
+     * - If set to "default", the default timezone of the date library will be used.
+     * - If set to "system", the local system's timezone will be applied.
+     * - If set to "UTC", the time will be returned in UTC.
+     * - If set to a valid IANA timezone identifier, the time will be returned for that specific timezone.
+     */
+    timezone?: Timezone;
+}
+export declare const DateInputRange: import("react").ForwardRefExoticComponent<DateInputRangeProps & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,99 @@
+import type { DateDetail, DateFrameworkType, ParserResult, Timezone } from "@salt-ds/date-adapters";
+import { type ComponentPropsWithoutRef, type InputHTMLAttributes, type ReactNode, type Ref, type SyntheticEvent } from "react";
+import type { SingleDateSelection } from "../calendar";
+/**
+ * Details of parsing the date
+ */
+export type DateInputSingleDetails = DateDetail;
+/**
+ * Props for the DateInputSingle component.
+ */
+export interface DateInputSingleProps extends Omit<ComponentPropsWithoutRef<"div">, "defaultValue">, Pick<ComponentPropsWithoutRef<"input">, "disabled" | "value" | "defaultValue" | "placeholder"> {
+    /**
+     * 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;
+    /**
+     * Start adornment component
+     */
+    startAdornment?: ReactNode;
+    /**
+     * Validation status.
+     */
+    validationStatus?: "error" | "warning" | "success";
+    /**
+     * Styling variant. Defaults to "primary".
+     */
+    variant?: "primary" | "secondary" | "tertiary";
+    /**
+     * Format string for date.
+     */
+    format?: string;
+    /**
+     * Reference for the input.
+     */
+    inputRef?: Ref<HTMLInputElement>;
+    /**
+     * Parser callback, if not using the adapter's parser
+     * @param value - date string to parse
+     * @param format - format required
+     */
+    parse?: (value: string, format: string) => ParserResult;
+    /**
+     * 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?: DateFrameworkType | null;
+    /**
+     * The initial selected date value. Use when the component is uncontrolled.
+     */
+    defaultDate?: DateFrameworkType | null;
+    /**
+     * Callback fired when the selected date changes.
+     * @param event - The synthetic event.
+     * @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: SingleDateSelection | 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.
+     */
+    onDateValueChange?: (event: SyntheticEvent | null, newValue: string) => void;
+    /**
+     * Specifies the timezone behavior:
+     * - If undefined, the timezone will be derived from the passed date, or from `defaultSelectedDate`/`selectedDate`.
+     * - If set to "default", the default timezone of the date library will be used.
+     * - If set to "system", the local system's timezone will be applied.
+     * - If set to "UTC", the time will be returned in UTC.
+     * - If set to a valid IANA timezone identifier, the time will be returned for that specific timezone.
+     */
+    timezone?: Timezone;
+}
+export declare const DateInputSingle: import("react").ForwardRefExoticComponent<DateInputSingleProps & import("react").RefAttributes<HTMLDivElement>>;

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

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

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

@@ -0,0 +1,52 @@
+import type { Timezone } from "@salt-ds/date-adapters";
+import { type ReactNode } from "react";
+import { type DatePickerOpenChangeReason } from "./DatePickerOverlayProvider";
+import { type UseDatePickerRangeProps, type UseDatePickerSingleProps } from "./useDatePicker";
+/**
+ * Base props for DatePicker.
+ */
+export interface DatePickerBaseProps {
+    className?: string;
+    children?: ReactNode;
+    /** the open/close state of the overlay. The open/close state will be controlled when this prop is provided. */
+    open?: boolean;
+    /** When `open` is uncontrolled, set this to `true` to open on click */
+    openOnClick?: boolean;
+    /**
+     * Handler for when open state changes
+     * @param newOpen - true when opened
+     * @param reason - reason for the the state change
+     */
+    onOpenChange?: (newOpen: boolean, reason?: DatePickerOpenChangeReason) => void;
+    /**
+     * the initial open/close state of the overlay, when the open/close state is un-controlled.
+     */
+    defaultOpen?: DatePickerBaseProps["open"];
+    /**
+     * Specifies the timezone behavior:
+     * - If undefined, the timezone will be derived from the passed date, or from `defaultSelectedDate`/`selectedDate`.
+     * - If set to "default", the default timezone of the date library will be used.
+     * - If set to "system", the local system's timezone will be applied.
+     * - If set to "UTC", the time will be returned in UTC.
+     * - If set to a valid IANA timezone identifier, the time will be returned for that specific timezone.
+     */
+    timezone?: Timezone;
+}
+/**
+ * Props for the DatePicker component, when `selectionVariant` is `single`.
+ */
+export interface DatePickerSingleProps extends DatePickerBaseProps, UseDatePickerSingleProps {
+    selectionVariant: "single";
+}
+/**
+ * Props for the DatePicker component, when `selectionVariant` is `range`.
+ */
+export interface DatePickerRangeProps extends DatePickerBaseProps, UseDatePickerRangeProps {
+    selectionVariant: "range";
+}
+/**
+ * Props for the DatePicker component.
+ */
+export 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>>;

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

@@ -0,0 +1,79 @@
+import { type ButtonProps } from "@salt-ds/core";
+import { type ComponentPropsWithoutRef, type Ref, type SyntheticEvent } from "react";
+import type { DateRangeSelection, SingleDateSelection } from "../calendar";
+/**
+ * Base props for DatePicker actions component.
+ */
+export interface DatePickerActionsBaseProps extends ComponentPropsWithoutRef<"div"> {
+    /**
+     * Callback fired when the cancel action is triggered.
+     * @param _event - The synthetic event.
+     */
+    onCancel?: (_event: SyntheticEvent) => void;
+    /**
+     * Ref to apply button
+     */
+    applyButtonRef?: Ref<HTMLButtonElement>;
+    /**
+     * Props for the apply button.
+     */
+    ApplyButtonProps?: ButtonProps;
+    /**
+     * Props for the cancel button.
+     */
+    CancelButtonProps?: ButtonProps;
+    /**
+     * Ref to cancel button
+     */
+    cancelButtonRef?: Ref<HTMLButtonElement>;
+}
+/**
+ * Props for the DatePicker actions component.
+ * @template SelectionVariant - The selection variant, either "single" or "range".
+ */
+export type DatePickerActionsProps<SelectionVariant extends "single" | "range"> = SelectionVariant extends "single" ? DatePickerActionsBaseProps & {
+    /**
+     * The selection variant, set to "single".
+     */
+    selectionVariant: "single";
+    /**
+     * Callback fired when the apply action is triggered.
+     * @param _event - The synthetic event.
+     * @param date - The selected single date or null.
+     */
+    onApply?: (_event: SyntheticEvent, date: SingleDateSelection | null) => void;
+} : DatePickerActionsBaseProps & {
+    /**
+     * The selection variant, set to "range".
+     */
+    selectionVariant: "range";
+    /**
+     * Callback fired when the apply action is triggered.
+     * @param _event - The synthetic event.
+     * @param date - The selected date range or null.
+     */
+    onApply?: (_event: SyntheticEvent, date: DateRangeSelection | null) => void;
+};
+export declare const DatePickerActions: import("react").ForwardRefExoticComponent<((DatePickerActionsBaseProps & {
+    /**
+     * The selection variant, set to "single".
+     */
+    selectionVariant: "single";
+    /**
+     * Callback fired when the apply action is triggered.
+     * @param _event - The synthetic event.
+     * @param date - The selected single date or null.
+     */
+    onApply?: (_event: SyntheticEvent, date: SingleDateSelection | null) => void;
+}) | (DatePickerActionsBaseProps & {
+    /**
+     * The selection variant, set to "range".
+     */
+    selectionVariant: "range";
+    /**
+     * Callback fired when the apply action is triggered.
+     * @param _event - The synthetic event.
+     * @param date - The selected date range or null.
+     */
+    onApply?: (_event: SyntheticEvent, date: DateRangeSelection | null) => void;
+})) & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,172 @@
+import type { DateFrameworkType, Timezone } from "@salt-ds/date-adapters";
+import { type Context, type Ref, type SyntheticEvent } from "react";
+import type { DateRangeSelection, SingleDateSelection } from "../calendar";
+import type { DateInputRangeDetails, DateInputSingleDetails } from "../date-input";
+/**
+ * Interface representing the base state for a DatePicker.
+ */
+interface DatePickerBaseState {
+    /**
+     * The state properties of the DatePicker.
+     */
+    state: {
+        /**
+         * If `true`, the DatePicker is disabled.
+         */
+        disabled?: boolean;
+        /**
+         * If `true`, the DatePicker is read-only.
+         */
+        readOnly?: boolean;
+        /**
+         * If `true`, the DatePicker has been cancelled.
+         */
+        cancelled?: boolean;
+        /**
+         * If `true`, the apply action is enabled.
+         */
+        enableApply?: boolean;
+        /**
+         * The minimum selectable date.
+         */
+        minDate?: DateFrameworkType;
+        /**
+         * The maximum selectable date.
+         */
+        maxDate?: DateFrameworkType;
+        /**
+         * Reference to the container element.
+         */
+        containerRef: Ref<HTMLDivElement>;
+        /**
+         * Specifies the timezone behavior:
+         * - If undefined, the timezone will be derived from the passed date, or from `defaultSelectedDate`/`selectedDate`.
+         * - If set to "default", the default timezone of the date library will be used.
+         * - If set to "system", the local system's timezone will be applied.
+         * - If set to "UTC", the time will be returned in UTC.
+         * - If set to a valid IANA timezone identifier, the time will be returned for that specific timezone.
+         */
+        timezone?: Timezone;
+    };
+    /**
+     * Helper functions for managing the DatePicker state.
+     */
+    helpers: {
+        /**
+         * Cancels the DatePicker action.
+         * @param event - event that triggered the state change
+         */
+        cancel: (event?: Event) => void;
+        /**
+         * 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: DateFrameworkType) => string | false | undefined;
+        /**
+         * 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: DateFrameworkType) => string | false | undefined;
+        /**
+         * Sets the enableApply state.
+         * @param newEnableApply - The new value for enableApply.
+         */
+        setEnableApply: (newEnableApply: boolean) => void;
+    };
+}
+/**
+ * Interface representing the state for a single date picker.
+ */
+export interface SingleDatePickerState extends DatePickerBaseState {
+    /**
+     * The state properties of the single date picker.
+     */
+    state: DatePickerBaseState["state"] & {
+        /**
+         * The selected date.
+         */
+        selectedDate: SingleDateSelection<DateFrameworkType> | null;
+        /**
+         * The default selected date.
+         */
+        defaultSelectedDate?: SingleDateSelection<DateFrameworkType>;
+    };
+    /**
+     * Helper functions for managing the single date picker state.
+     */
+    helpers: DatePickerBaseState["helpers"] & {
+        /**
+         * Apply the selected single date.
+         * @param event - The synthetic event.
+         * @param date - The new applied date.
+         */
+        apply: (event: SyntheticEvent, date: SingleDateSelection<DateFrameworkType> | null) => void;
+        /**
+         * Select a single date.
+         * @param event - The synthetic event.
+         * @param date - The selected date or null.
+         * @param details - Details of selection, such as errors and original value.
+         */
+        select: (event: SyntheticEvent, date: SingleDateSelection<DateFrameworkType> | null, details?: DateInputSingleDetails) => void;
+    };
+}
+/**
+ * Interface representing the state for a range date picker.
+ */
+export interface RangeDatePickerState extends DatePickerBaseState {
+    /**
+     * The state properties of the range date picker.
+     */
+    state: DatePickerBaseState["state"] & {
+        /**
+         * The selected date range.
+         */
+        selectedDate: DateRangeSelection<DateFrameworkType> | null;
+        /**
+         * The default selected date range.
+         */
+        defaultSelectedDate?: DateRangeSelection<DateFrameworkType>;
+    };
+    /**
+     * Helper functions for managing the range date picker state.
+     */
+    helpers: DatePickerBaseState["helpers"] & {
+        /**
+         * Apply the selected date range.
+         * @param event - The synthetic event.
+         * @param date - The new applied date range
+         */
+        apply: (event: SyntheticEvent, date: DateRangeSelection<DateFrameworkType> | null) => void;
+        /**
+         * Select a date range.
+         * @param event - The synthetic event.
+         * @param date - The selected date.
+         * @param details - Details of selection, such as errors and original value.     */
+        select: (event: SyntheticEvent, date: DateRangeSelection<DateFrameworkType> | null, details?: DateInputRangeDetails) => void;
+    };
+}
+/**
+ * Type representing the state of a date picker, either single or range.
+ */
+export type DatePickerState = SingleDatePickerState | RangeDatePickerState;
+/**
+ * Context for single date selection.
+ */
+export declare const SingleDateSelectionContext: Context<SingleDatePickerState | undefined>;
+/**
+ * Context for date range selection.
+ */
+export declare const DateRangeSelectionContext: Context<RangeDatePickerState | undefined>;
+/**
+ * Props for using the date picker context.
+ */
+export interface UseDatePickerContextProps {
+    /**
+     * The selection variant, either "single" or "range".
+     */
+    selectionVariant: "single" | "range";
+}
+export declare function useDatePickerContext({ selectionVariant, }: UseDatePickerContextProps): DatePickerState;
+export {};

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

@@ -0,0 +1,4 @@
+import { type FormFieldHelperTextProps } from "@salt-ds/core";
+export interface DatePickerHelperTextProps extends FormFieldHelperTextProps {
+}
+export declare const DatePickerHelperText: import("react").ForwardRefExoticComponent<Omit<DatePickerHelperTextProps, "ref"> & import("react").RefAttributes<HTMLLabelElement>>;

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

@@ -0,0 +1,11 @@
+import { type ComponentPropsWithoutRef, type ReactNode } from "react";
+/**
+ * Props for the DatePickerOverlay component.
+ */
+export interface DatePickerOverlayProps extends ComponentPropsWithoutRef<"div"> {
+    /**
+     * The content to be rendered inside the overlay.
+     */
+    children: ReactNode;
+}
+export declare const DatePickerOverlay: import("react").ForwardRefExoticComponent<DatePickerOverlayProps & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,106 @@
+import { type ElementProps, type FloatingContext, type OpenChangeReason as FloatingUIOpenChangeReason, useInteractions } from "@floating-ui/react";
+import { useFloatingUI } from "@salt-ds/core";
+import { type ReactNode } from "react";
+/** Reason for overlay state change, can be a custom reason */
+export type DatePickerOpenChangeReason = FloatingUIOpenChangeReason | "apply" | "cancel" | string;
+/**
+ * Interface representing the state for a DatePicker overlay.
+ */
+interface DatePickerOverlayState {
+    /**
+     * If `true`, the overlay is open.
+     */
+    open: boolean;
+    /**
+     * If `true`, the overlay contains the active element
+     */
+    focused: boolean;
+    /**
+     * The result of the floating UI calculations.
+     */
+    floatingUIResult: ReturnType<typeof useFloatingUI>;
+    /**
+     * Ref to attach to the initially focused element, when the overlay is opened.
+     */
+    initialFocusRef?: React.MutableRefObject<HTMLElement | null>;
+}
+/**
+ * Interface representing the helper functions for a DatePicker overlay.
+ */
+interface DatePickerOverlayHelpers {
+    /**
+     * Function to get the props for the floating element.
+     */
+    getFloatingProps: ReturnType<typeof useInteractions>["getFloatingProps"];
+    /**
+     * Function to get the props for the reference element.
+     */
+    getReferenceProps: ReturnType<typeof useInteractions>["getReferenceProps"];
+    /**
+     * Sets the open state of the overlay.
+     * @param newOpen - The new value for the open state.
+     * @param event - event that triggered the state change
+     * @param reason - reason for the the state change
+     */
+    setOpen: (newOpen: boolean, event?: Event, reason?: DatePickerOpenChangeReason) => void;
+    /**~
+     * Register a callback for when onDismiss is called
+     * @param onDismissCallback
+     */
+    setOnDismiss: (onDismissCallback: (event?: Event) => void) => void;
+}
+/**
+ * Interface representing the context type for a DatePicker overlay.
+ */
+interface DatePickerOverlayContextType {
+    /**
+     * The state of the DatePicker overlay.
+     */
+    state: DatePickerOverlayState;
+    /**
+     * The helper functions for the DatePicker overlay.
+     */
+    helpers: DatePickerOverlayHelpers;
+}
+/**
+ * Props for the DatePickerOverlayProvider component.
+ */
+interface DatePickerOverlayProviderProps {
+    /**
+     * If `true`, the overlay is disabled.
+     */
+    disabled?: boolean;
+    /**
+     * If `true`, the overlay is open.
+     */
+    open?: boolean;
+    /**
+     * When `open` is uncontrolled, set this to `true` to open on click
+     */
+    openOnClick?: boolean;
+    /**
+     * Handler for when open state changes
+     * @param newOpen - true when opened
+     * @param reason - reason for the the state change
+     */
+    onOpenChange?: (newOpen: boolean, reason?: DatePickerOpenChangeReason) => void;
+    /**
+     * The default open state of the overlay.
+     */
+    defaultOpen?: boolean;
+    /**
+     * The content to be rendered inside the overlay provider.
+     */
+    children: ReactNode;
+    /**
+     * A factory method to create a set of interaction, if provided overrides the default interactions
+     */
+    interactions?: (context: FloatingContext) => Array<ElementProps>;
+    /**
+     * When true, shouldn't open the overlay.
+     */
+    readOnly?: boolean;
+}
+export declare const DatePickerOverlayProvider: React.FC<DatePickerOverlayProviderProps>;
+export declare const useDatePickerOverlay: () => DatePickerOverlayContextType;
+export {};

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

@@ -0,0 +1,14 @@
+import { type SyntheticEvent } from "react";
+import { type CalendarRangeProps, type DateRangeSelection } from "../calendar";
+import type { DatePickerPanelBaseProps } from "./DatePickerSingleGridPanel";
+/**
+ * Props for the DatePickerRangeGridPanel component.
+ */
+export type DatePickerRangeGridPanelProps = DatePickerPanelBaseProps & DateRangeSelection & {
+    onSelectionChange?: (event: SyntheticEvent, selectedDate?: DateRangeSelection | null) => void;
+    CalendarProps?: Partial<Omit<CalendarRangeProps, "selectionVariant" | "selectedDate" | "defaultSelectedDate" | "multiselect" | "onHoveredDateChange" | "onSelectionChange" | "onVisibleMonthChange">>;
+};
+export declare const DatePickerRangeGridPanel: import("react").ForwardRefExoticComponent<DatePickerPanelBaseProps & DateRangeSelection & {
+    onSelectionChange?: (event: SyntheticEvent, selectedDate?: DateRangeSelection | null) => void;
+    CalendarProps?: Partial<Omit<CalendarRangeProps, "selectionVariant" | "selectedDate" | "defaultSelectedDate" | "multiselect" | "onHoveredDateChange" | "onSelectionChange" | "onVisibleMonthChange">>;
+} & import("react").RefAttributes<HTMLDivElement>>;