react-stately 3.45.0 → 3.46.0

package/dist/types/src/data/useListData.d.ts

@@ -0,0 +1,111 @@
+import { Key, Selection } from '@react-types/shared';
+export interface ListOptions<T> {
+    /** Initial items in the list. */
+    initialItems?: T[];
+    /** The keys for the initially selected items. */
+    initialSelectedKeys?: 'all' | Iterable<Key>;
+    /** The initial text to filter the list by. */
+    initialFilterText?: string;
+    /** A function that returns a unique key for an item object. */
+    getKey?: (item: T) => Key;
+    /** A function that returns whether a item matches the current filter text. */
+    filter?: (item: T, filterText: string) => boolean;
+}
+export interface ListData<T> {
+    /** The items in the list. */
+    items: T[];
+    /** The keys of the currently selected items in the list. */
+    selectedKeys: Selection;
+    /** Sets the selected keys. */
+    setSelectedKeys(keys: Selection): void;
+    /** Adds the given keys to the current selected keys. */
+    addKeysToSelection(keys: Selection): void;
+    /** Removes the given keys from the current selected keys. */
+    removeKeysFromSelection(keys: Selection): void;
+    /** The current filter text. */
+    filterText: string;
+    /** Sets the filter text. */
+    setFilterText(filterText: string): void;
+    /**
+     * Gets an item from the list by key.
+     * @param key - The key of the item to retrieve.
+     */
+    getItem(key: Key): T | undefined;
+    /**
+     * Inserts items into the list at the given index.
+     * @param index - The index to insert into.
+     * @param values - The values to insert.
+     */
+    insert(index: number, ...values: T[]): void;
+    /**
+     * Inserts items into the list before the item at the given key.
+     * @param key - The key of the item to insert before.
+     * @param values - The values to insert.
+     */
+    insertBefore(key: Key, ...values: T[]): void;
+    /**
+     * Inserts items into the list after the item at the given key.
+     * @param key - The key of the item to insert after.
+     * @param values - The values to insert.
+     */
+    insertAfter(key: Key, ...values: T[]): void;
+    /**
+     * Appends items to the list.
+     * @param values - The values to insert.
+     */
+    append(...values: T[]): void;
+    /**
+     * Prepends items to the list.
+     * @param value - The value to insert.
+     */
+    prepend(...values: T[]): void;
+    /**
+     * Removes items from the list by their keys.
+     * @param keys - The keys of the item to remove.
+     */
+    remove(...keys: Key[]): void;
+    /**
+     * Removes all items from the list that are currently
+     * in the set of selected items.
+     */
+    removeSelectedItems(): void;
+    /**
+     * Moves an item within the list.
+     * @param key - The key of the item to move.
+     * @param toIndex - The index to move the item to.
+     */
+    move(key: Key, toIndex: number): void;
+    /**
+     * Moves one or more items before a given key.
+     * @param key - The key of the item to move the items before.
+     * @param keys - The keys of the items to move.
+     */
+    moveBefore(key: Key, keys: Iterable<Key>): void;
+    /**
+     * Moves one or more items after a given key.
+     * @param key - The key of the item to move the items after.
+     * @param keys - The keys of the items to move.
+     */
+    moveAfter(key: Key, keys: Iterable<Key>): void;
+    /**
+     * Updates an item in the list.
+     * @param key - The key of the item to update.
+     * @param newValue - The new value for the item, or a function that returns the new value based on the previous value.
+     */
+    update(key: Key, newValue: T | ((prev: T) => T)): void;
+}
+export interface ListState<T> {
+    items: T[];
+    selectedKeys: Selection;
+    filterText: string;
+}
+interface CreateListOptions<T, C> extends ListOptions<T> {
+    cursor?: C;
+}
+/**
+ * Manages state for an immutable list data structure, and provides convenience methods to
+ * update the data over time.
+ */
+export declare function useListData<T>(options: ListOptions<T>): ListData<T>;
+export declare function createListActions<T, C>(opts: CreateListOptions<T, C>, dispatch: (updater: (state: ListState<T>) => ListState<T>) => void): Omit<ListData<T>, 'items' | 'selectedKeys' | 'getItem' | 'filterText'>;
+export {};

package/dist/types/src/data/useTreeData.d.ts

@@ -0,0 +1,106 @@
+import { Key } from '@react-types/shared';
+export interface TreeOptions<T extends object> {
+    /** Initial root items in the tree. */
+    initialItems?: T[];
+    /** The keys for the initially selected items. */
+    initialSelectedKeys?: Iterable<Key>;
+    /** A function that returns a unique key for an item object. */
+    getKey?: (item: T) => Key;
+    /** A function that returns the children for an item object. */
+    getChildren?: (item: T) => T[];
+}
+interface TreeNode<T extends object> {
+    /** A unique key for the tree node. */
+    key: Key;
+    /** The key of the parent node. */
+    parentKey?: Key | null;
+    /** The value object for the tree node. */
+    value: T;
+    /** Children of the tree node. */
+    children: TreeNode<T>[] | null;
+}
+export interface TreeData<T extends object> {
+    /** The root nodes in the tree. */
+    items: TreeNode<T>[];
+    /** The keys of the currently selected items in the tree. */
+    selectedKeys: Set<Key>;
+    /** Sets the selected keys. */
+    setSelectedKeys(keys: Set<Key>): void;
+    /**
+     * Gets a node from the tree by key.
+     * @param key - The key of the item to retrieve.
+     */
+    getItem(key: Key): TreeNode<T> | undefined;
+    /**
+     * Inserts an item into a parent node as a child.
+     * @param parentKey - The key of the parent item to insert into. `null` for the root.
+     * @param index - The index within the parent to insert into.
+     * @param value - The value to insert.
+     */
+    insert(parentKey: Key | null, index: number, ...values: T[]): void;
+    /**
+     * Inserts items into the list before the item at the given key.
+     * @param key - The key of the item to insert before.
+     * @param values - The values to insert.
+     */
+    insertBefore(key: Key, ...values: T[]): void;
+    /**
+     * Inserts items into the list after the item at the given key.
+     * @param key - The key of the item to insert after.
+     * @param values - The values to insert.
+     */
+    insertAfter(key: Key, ...values: T[]): void;
+    /**
+     * Appends an item into a parent node as a child.
+     * @param parentKey - The key of the parent item to insert into. `null` for the root.
+     * @param value - The value to insert.
+     */
+    append(parentKey: Key | null, ...values: T[]): void;
+    /**
+     * Prepends an item into a parent node as a child.
+     * @param parentKey - The key of the parent item to insert into. `null` for the root.
+     * @param value - The value to insert.
+     */
+    prepend(parentKey: Key | null, ...value: T[]): void;
+    /**
+     * Removes an item from the tree by its key.
+     * @param key - The key of the item to remove.
+     */
+    remove(...keys: Key[]): void;
+    /**
+     * Removes all items from the tree that are currently
+     * in the set of selected items.
+     */
+    removeSelectedItems(): void;
+    /**
+     * Moves an item within the tree.
+     * @param key - The key of the item to move.
+     * @param toParentKey - The key of the new parent to insert into. `null` for the root.
+     * @param index - The index within the new parent to insert at.
+     */
+    move(key: Key, toParentKey: Key | null, index: number): void;
+    /**
+     * Moves one or more items before a given key.
+     * @param key - The key of the item to move the items before.
+     * @param keys - The keys of the items to move.
+     */
+    moveBefore(key: Key, keys: Iterable<Key>): void;
+    /**
+     * Moves one or more items after a given key.
+     * @param key - The key of the item to move the items after.
+     * @param keys - The keys of the items to move.
+     */
+    moveAfter(key: Key, keys: Iterable<Key>): void;
+    /**
+     * Updates an item in the tree.
+     * @param key - The key of the item to update.
+     * @param newValue - The new value for the item.
+     */
+    update(key: Key, newValue: T): void;
+}
+/**
+ * Manages state for an immutable tree data structure, and provides convenience methods to
+ * update the data over time.
+ */
+export declare function useTreeData<T extends object>(options: TreeOptions<T>): TreeData<T>;
+export {};

package/dist/types/src/datepicker/IncompleteDate.d.ts

@@ -0,0 +1,46 @@
+import { AnyDateTime, Calendar } from '@internationalized/date';
+import { DateSegmentType } from './useDateFieldState';
+import { DateValue } from './types';
+type HourCycle = 'h12' | 'h11' | 'h23' | 'h24';
+/**
+ * This class represents a date that is incomplete or otherwise invalid as a result of user editing.
+ * For example, it can represent temporary dates such as February 31st if the user edits the day before the month.
+ * Times are represented according to an hour cycle rather than always in 24 hour time. This enables the user to adjust
+ * the day period (e.g. am/pm) independently from the hour.
+ */
+export declare class IncompleteDate {
+    calendar: Calendar;
+    era: string | null;
+    year: number | null;
+    month: number | null;
+    day: number | null;
+    hour: number | null;
+    hourCycle: HourCycle;
+    dayPeriod: number | null;
+    minute: number | null;
+    second: number | null;
+    millisecond: number | null;
+    offset: number | null;
+    constructor(calendar: Calendar, hourCycle: HourCycle, dateValue?: Partial<Omit<AnyDateTime, 'copy'>> | null);
+    copy(): IncompleteDate;
+    /** Checks whether all the specified segments have a value. */
+    isComplete(segments: DateSegmentType[]): boolean;
+    /** Checks whether the given date value matches this value for the specified segments. */
+    validate(dt: DateValue, segments: DateSegmentType[]): boolean;
+    /** Checks if the date is empty (i.e. all specified segments are null). */
+    isCleared(segments: DateSegmentType[]): boolean;
+    /** Sets the given field. */
+    set(field: DateSegmentType, value: number | string, placeholder: DateValue): IncompleteDate;
+    /** Sets the given field to null. */
+    clear(field: DateSegmentType): IncompleteDate;
+    /** Increments or decrements the given field. If it is null, then it is set to the placeholder value. */
+    cycle(field: DateSegmentType, amount: number, placeholder: DateValue, displaySegments: DateSegmentType[]): IncompleteDate;
+    /** Converts the incomplete date to a full date value, using the provided value for any unset fields. */
+    toValue(value: DateValue): DateValue;
+    getSegmentLimits(type: string): {
+        value: number | null;
+        minValue: number;
+        maxValue: number;
+    } | undefined;
+}
+export {};

package/dist/types/src/datepicker/placeholders.d.ts

@@ -0,0 +1 @@
+export declare function getPlaceholder(field: string, value: string, locale: string): string;

package/dist/types/src/datepicker/types.d.ts

@@ -0,0 +1,90 @@
+import { CalendarDate, CalendarDateTime, Time, ZonedDateTime } from '@internationalized/date';
+import { FocusableProps, HelpTextProps, InputBase, LabelableProps, RangeValue, Validation, ValueBase } from '@react-types/shared';
+import { OverlayTriggerProps } from '../overlays/useOverlayTriggerState';
+import { PageBehavior } from '../calendar/types';
+export type DateValue = CalendarDate | CalendarDateTime | ZonedDateTime;
+export type DateRange = RangeValue<DateValue>;
+export type MappedDateValue<T> = T extends ZonedDateTime ? ZonedDateTime : T extends CalendarDateTime ? CalendarDateTime : T extends CalendarDate ? CalendarDate : never;
+export type TimeValue = Time | CalendarDateTime | ZonedDateTime;
+export type MappedTimeValue<T> = T extends ZonedDateTime ? ZonedDateTime : T extends CalendarDateTime ? CalendarDateTime : T extends Time ? Time : never;
+export type Granularity = 'day' | 'hour' | 'minute' | 'second';
+interface DateFieldBase<T extends DateValue> extends InputBase, Validation<MappedDateValue<T>>, FocusableProps, LabelableProps, HelpTextProps {
+    /** The minimum allowed date that a user may select. */
+    minValue?: DateValue | null;
+    /** The maximum allowed date that a user may select. */
+    maxValue?: DateValue | null;
+    /** Callback that is called for each date of the calendar. If it returns true, then the date is unavailable. */
+    isDateUnavailable?: (date: DateValue) => boolean;
+    /** A placeholder date that influences the format of the placeholder shown when no value is selected. Defaults to today's date at midnight. */
+    placeholderValue?: T | null;
+    /** Whether to display the time in 12 or 24 hour format. By default, this is determined by the user's locale. */
+    hourCycle?: 12 | 24;
+    /** Determines the smallest unit that is displayed in the date picker. By default, this is `"day"` for dates, and `"minute"` for times. */
+    granularity?: Granularity;
+    /**
+     * Whether to hide the time zone abbreviation.
+     * @default false
+     */
+    hideTimeZone?: boolean;
+    /**
+     * Whether to always show leading zeros in the month, day, and hour fields.
+     * By default, this is determined by the user's locale.
+     */
+    shouldForceLeadingZeros?: boolean;
+}
+export interface DateFieldProps<T extends DateValue> extends DateFieldBase<T>, ValueBase<T | null, MappedDateValue<T> | null> {
+}
+interface DatePickerBase<T extends DateValue> extends DateFieldBase<T>, OverlayTriggerProps {
+    /**
+     * Controls the behavior of paging. Pagination either works by advancing the visible page by visibleDuration (default) or one unit of visibleDuration.
+     * @default visible
+     */
+    pageBehavior?: PageBehavior;
+    /**
+     * The day that starts the week.
+     */
+    firstDayOfWeek?: 'sun' | 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat';
+}
+export interface DatePickerProps<T extends DateValue> extends DatePickerBase<T>, ValueBase<T | null, MappedDateValue<T> | null> {
+}
+export interface DateRangePickerProps<T extends DateValue> extends Omit<DatePickerBase<T>, 'validate'>, Validation<RangeValue<MappedDateValue<T>>>, ValueBase<RangeValue<T> | null, RangeValue<MappedDateValue<T>> | null> {
+    /**
+     * When combined with `isDateUnavailable`, determines whether non-contiguous ranges,
+     * i.e. ranges containing unavailable dates, may be selected.
+     */
+    allowsNonContiguousRanges?: boolean;
+    /**
+     * The name of the start date input element, used when submitting an HTML form. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefname).
+     */
+    startName?: string;
+    /**
+     * The name of the end date input element, used when submitting an HTML form. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefname).
+     */
+    endName?: string;
+}
+export interface TimePickerProps<T extends TimeValue> extends InputBase, Validation<MappedTimeValue<T>>, FocusableProps, LabelableProps, HelpTextProps, ValueBase<T | null, MappedTimeValue<T> | null> {
+    /** Whether to display the time in 12 or 24 hour format. By default, this is determined by the user's locale. */
+    hourCycle?: 12 | 24;
+    /**
+     * Determines the smallest unit that is displayed in the time picker.
+     * @default 'minute'
+     */
+    granularity?: 'hour' | 'minute' | 'second';
+    /** Whether to hide the time zone abbreviation. */
+    hideTimeZone?: boolean;
+    /**
+     * Whether to always show leading zeros in the hour field.
+     * By default, this is determined by the user's locale.
+     */
+    shouldForceLeadingZeros?: boolean;
+    /**
+     * A placeholder time that influences the format of the placeholder shown when no value is selected.
+     * Defaults to 12:00 AM or 00:00 depending on the hour cycle.
+     */
+    placeholderValue?: T;
+    /** The minimum allowed time that a user may select. */
+    minValue?: TimeValue | null;
+    /** The maximum allowed time that a user may select. */
+    maxValue?: TimeValue | null;
+}
+export {};

package/dist/types/src/datepicker/useDateFieldState.d.ts

@@ -0,0 +1,110 @@
+import { Calendar, CalendarIdentifier, DateFormatter } from '@internationalized/date';
+import { FieldOptions, FormatterOptions } from './utils';
+import { DatePickerProps, DateValue, Granularity } from './types';
+import { FormValidationState } from '../form/useFormValidationState';
+import { ValidationState } from '@react-types/shared';
+export type DateSegmentType = 'era' | 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'dayPeriod' | 'literal' | 'timeZoneName';
+export interface DateSegment {
+    /** The type of segment. */
+    type: DateSegmentType;
+    /** The formatted text for the segment. */
+    text: string;
+    /** The numeric value for the segment, if applicable. */
+    value?: number | null;
+    /** The minimum numeric value for the segment, if applicable. */
+    minValue?: number;
+    /** The maximum numeric value for the segment, if applicable. */
+    maxValue?: number;
+    /** Whether the value is a placeholder. */
+    isPlaceholder: boolean;
+    /** A placeholder string for the segment. */
+    placeholder: string;
+    /** Whether the segment is editable. */
+    isEditable: boolean;
+}
+export interface DateFieldState extends FormValidationState {
+    /** The current field value. */
+    value: DateValue | null;
+    /** The default field value. */
+    defaultValue: DateValue | null;
+    /** The current value, converted to a native JavaScript `Date` object.  */
+    dateValue: Date;
+    /** The calendar system currently in use. */
+    calendar: Calendar;
+    /** Sets the field's value. */
+    setValue(value: DateValue | null): void;
+    /** A list of segments for the current value. */
+    segments: DateSegment[];
+    /** A date formatter configured for the current locale and format. */
+    dateFormatter: DateFormatter;
+    /**
+     * The current validation state of the date field, based on the `validationState`, `minValue`, and `maxValue` props.
+     * @deprecated Use `isInvalid` instead.
+     */
+    validationState: ValidationState | null;
+    /** Whether the date field is invalid, based on the `isInvalid`, `minValue`, and `maxValue` props. */
+    isInvalid: boolean;
+    /** The granularity for the field, based on the `granularity` prop and current value. */
+    granularity: Granularity;
+    /** The maximum date or time unit that is displayed in the field. */
+    maxGranularity: 'year' | 'month' | Granularity;
+    /** Whether the field is disabled. */
+    isDisabled: boolean;
+    /** Whether the field is read only. */
+    isReadOnly: boolean;
+    /** Whether the field is required. */
+    isRequired: boolean;
+    /** Increments the given segment. Upon reaching the minimum or maximum value, the value wraps around to the opposite limit. */
+    increment(type: DateSegmentType): void;
+    /** Decrements the given segment. Upon reaching the minimum or maximum value, the value wraps around to the opposite limit. */
+    decrement(type: DateSegmentType): void;
+    /**
+     * Increments the given segment by a larger amount, rounding it to the nearest increment.
+     * The amount to increment by depends on the field, for example 15 minutes, 7 days, and 5 years.
+     * Upon reaching the minimum or maximum value, the value wraps around to the opposite limit.
+     */
+    incrementPage(type: DateSegmentType): void;
+    /**
+     * Decrements the given segment by a larger amount, rounding it to the nearest increment.
+     * The amount to decrement by depends on the field, for example 15 minutes, 7 days, and 5 years.
+     * Upon reaching the minimum or maximum value, the value wraps around to the opposite limit.
+     */
+    decrementPage(type: DateSegmentType): void;
+    /** Increments the given segment to its maxiumum value. */
+    incrementToMax(type: DateSegmentType): void;
+    /** Decrements the given segment to its minimum value. */
+    decrementToMin(type: DateSegmentType): void;
+    /** Sets the value of the given segment. */
+    setSegment(type: 'era', value: string): void;
+    setSegment(type: DateSegmentType, value: number): void;
+    /** Updates the remaining unfilled segments with the placeholder value. */
+    confirmPlaceholder(): void;
+    /** Clears the value of the given segment, reverting it to the placeholder. */
+    clearSegment(type: DateSegmentType): void;
+    /** Formats the current date value using the given options. */
+    formatValue(fieldOptions: FieldOptions): string;
+    /** Gets a formatter based on state's props. */
+    getDateFormatter(locale: string, formatOptions: FormatterOptions): DateFormatter;
+}
+export interface DateFieldStateOptions<T extends DateValue = DateValue> extends DatePickerProps<T> {
+    /**
+     * The maximum unit to display in the date field.
+     * @default 'year'
+     */
+    maxGranularity?: 'year' | 'month' | Granularity;
+    /** The locale to display and edit the value according to. */
+    locale: string;
+    /**
+     * A function that creates a [Calendar](../internationalized/date/Calendar.html)
+     * object for a given calendar identifier. Such a function may be imported from the
+     * `@internationalized/date` package, or manually implemented to include support for
+     * only certain calendars.
+     */
+    createCalendar: (name: CalendarIdentifier) => Calendar;
+}
+/**
+ * Provides state management for a date field component.
+ * A date field allows users to enter and edit date and time values using a keyboard.
+ * Each part of a date value is displayed in an individually editable segment.
+ */
+export declare function useDateFieldState<T extends DateValue = DateValue>(props: DateFieldStateOptions<T>): DateFieldState;

package/dist/types/src/datepicker/useDatePickerState.d.ts

@@ -0,0 +1,59 @@
+import { DateFormatter } from '@internationalized/date';
+import { DatePickerProps, DateValue, Granularity, TimeValue } from './types';
+import { FieldOptions, FormatterOptions } from './utils';
+import { FormValidationState } from '../form/useFormValidationState';
+import { OverlayTriggerState } from '../overlays/useOverlayTriggerState';
+import { ValidationState } from '@react-types/shared';
+export interface DatePickerStateOptions<T extends DateValue> extends DatePickerProps<T> {
+    /**
+     * Determines whether the date picker popover should close automatically when a date is selected.
+     * @default true
+     */
+    shouldCloseOnSelect?: boolean | (() => boolean);
+}
+export interface DatePickerState extends OverlayTriggerState, FormValidationState {
+    /** The currently selected date. */
+    value: DateValue | null;
+    /** The default date. */
+    defaultValue: DateValue | null;
+    /** Sets the selected date. */
+    setValue(value: DateValue | null): void;
+    /**
+     * The date portion of the value. This may be set prior to `value` if the user has
+     * selected a date but has not yet selected a time.
+     */
+    dateValue: DateValue | null;
+    /** Sets the date portion of the value. */
+    setDateValue(value: DateValue): void;
+    /**
+     * The time portion of the value. This may be set prior to `value` if the user has
+     * selected a time but has not yet selected a date.
+     */
+    timeValue: TimeValue | null;
+    /** Sets the time portion of the value. */
+    setTimeValue(value: TimeValue): void;
+    /** The granularity for the field, based on the `granularity` prop and current value. */
+    granularity: Granularity;
+    /** Whether the date picker supports selecting a time, according to the `granularity` prop and current value. */
+    hasTime: boolean;
+    /** Whether the calendar popover is currently open. */
+    isOpen: boolean;
+    /** Sets whether the calendar popover is open. */
+    setOpen(isOpen: boolean): void;
+    /**
+     * The current validation state of the date picker, based on the `validationState`, `minValue`, and `maxValue` props.
+     * @deprecated Use `isInvalid` instead.
+     */
+    validationState: ValidationState | null;
+    /** Whether the date picker is invalid, based on the `isInvalid`, `minValue`, and `maxValue` props. */
+    isInvalid: boolean;
+    /** Formats the selected value using the given options. */
+    formatValue(locale: string, fieldOptions: FieldOptions): string;
+    /** Gets a formatter based on state's props. */
+    getDateFormatter(locale: string, formatOptions: FormatterOptions): DateFormatter;
+}
+/**
+ * Provides state management for a date picker component.
+ * A date picker combines a DateField and a Calendar popover to allow users to enter or select a date and time value.
+ */
+export declare function useDatePickerState<T extends DateValue = DateValue>(props: DatePickerStateOptions<T>): DatePickerState;

package/dist/types/src/datepicker/useDateRangePickerState.d.ts

@@ -0,0 +1,71 @@
+import { DateFormatter } from '@internationalized/date';
+import { DateRange, DateRangePickerProps, DateValue, Granularity, TimeValue } from './types';
+import { FieldOptions, FormatterOptions } from './utils';
+import { FormValidationState } from '../form/useFormValidationState';
+import { OverlayTriggerState } from '../overlays/useOverlayTriggerState';
+import { RangeValue, ValidationState } from '@react-types/shared';
+export interface DateRangePickerStateOptions<T extends DateValue = DateValue> extends DateRangePickerProps<T> {
+    /**
+     * Determines whether the date picker popover should close automatically when a date is selected.
+     * @default true
+     */
+    shouldCloseOnSelect?: boolean | (() => boolean);
+}
+type TimeRange = RangeValue<TimeValue>;
+export interface DateRangePickerState extends OverlayTriggerState, FormValidationState {
+    /** The currently selected date range. */
+    value: RangeValue<DateValue | null>;
+    /** The default selected date range. */
+    defaultValue: DateRange | null;
+    /** Sets the selected date range. */
+    setValue(value: DateRange | null): void;
+    /**
+     * The date portion of the selected range. This may be set prior to `value` if the user has
+     * selected a date range but has not yet selected a time range.
+     */
+    dateRange: RangeValue<DateValue | null> | null;
+    /** Sets the date portion of the selected range. */
+    setDateRange(value: DateRange): void;
+    /**
+     * The time portion of the selected range. This may be set prior to `value` if the user has
+     * selected a time range but has not yet selected a date range.
+     */
+    timeRange: RangeValue<TimeValue | null> | null;
+    /** Sets the time portion of the selected range. */
+    setTimeRange(value: TimeRange): void;
+    /** Sets the date portion of either the start or end of the selected range. */
+    setDate(part: 'start' | 'end', value: DateValue | null): void;
+    /** Sets the time portion of either the start or end of the selected range. */
+    setTime(part: 'start' | 'end', value: TimeValue | null): void;
+    /** Sets the date and time of either the start or end of the selected range. */
+    setDateTime(part: 'start' | 'end', value: DateValue | null): void;
+    /** The granularity for the field, based on the `granularity` prop and current value. */
+    granularity: Granularity;
+    /** Whether the date range picker supports selecting times, according to the `granularity` prop and current value. */
+    hasTime: boolean;
+    /** Whether the calendar popover is currently open. */
+    isOpen: boolean;
+    /** Sets whether the calendar popover is open. */
+    setOpen(isOpen: boolean): void;
+    /**
+     * The current validation state of the date range picker, based on the `validationState`, `minValue`, and `maxValue` props.
+     * @deprecated Use `isInvalid` instead.
+     */
+    validationState: ValidationState | null;
+    /** Whether the date range picker is invalid, based on the `isInvalid`, `minValue`, and `maxValue` props. */
+    isInvalid: boolean;
+    /** Formats the selected range using the given options. */
+    formatValue(locale: string, fieldOptions: FieldOptions): {
+        start: string;
+        end: string;
+    } | null;
+    /** Gets a formatter based on state's props. */
+    getDateFormatter(locale: string, formatOptions: FormatterOptions): DateFormatter;
+}
+/**
+ * Provides state management for a date range picker component.
+ * A date range picker combines two DateFields and a RangeCalendar popover to allow
+ * users to enter or select a date and time range.
+ */
+export declare function useDateRangePickerState<T extends DateValue = DateValue>(props: DateRangePickerStateOptions<T>): DateRangePickerState;
+export {};

package/dist/types/src/datepicker/useTimeFieldState.d.ts

@@ -0,0 +1,17 @@
+import { DateFieldState } from './useDateFieldState';
+import { TimePickerProps, TimeValue } from './types';
+import { Time } from '@internationalized/date';
+export interface TimeFieldStateOptions<T extends TimeValue = TimeValue> extends TimePickerProps<T> {
+    /** The locale to display and edit the value according to. */
+    locale: string;
+}
+export interface TimeFieldState extends DateFieldState {
+    /** The current time value. */
+    timeValue: Time;
+}
+/**
+ * Provides state management for a time field component.
+ * A time field allows users to enter and edit time values using a keyboard.
+ * Each part of a time value is displayed in an individually editable segment.
+ */
+export declare function useTimeFieldState<T extends TimeValue = TimeValue>(props: TimeFieldStateOptions<T>): TimeFieldState;

package/dist/types/src/datepicker/utils.d.ts

@@ -0,0 +1,20 @@
+import { Calendar } from '@internationalized/date';
+import { DatePickerProps, DateValue, Granularity, TimeValue } from './types';
+import { RangeValue, ValidationResult } from '@react-types/shared';
+export declare function getValidationResult(value: DateValue | null, minValue: DateValue | null | undefined, maxValue: DateValue | null | undefined, isDateUnavailable: ((v: DateValue) => boolean) | undefined, options: FormatterOptions): ValidationResult;
+export declare function getRangeValidationResult(value: RangeValue<DateValue | null> | null, minValue: DateValue | null | undefined, maxValue: DateValue | null | undefined, isDateUnavailable: ((v: DateValue) => boolean) | undefined, options: FormatterOptions): ValidationResult;
+export type FieldOptions = Pick<Intl.DateTimeFormatOptions, 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second'>;
+export interface FormatterOptions {
+    timeZone?: string;
+    hideTimeZone?: boolean;
+    granularity?: DatePickerProps<any>['granularity'];
+    maxGranularity?: 'year' | 'month' | DatePickerProps<any>['granularity'];
+    hourCycle?: 12 | 24;
+    showEra?: boolean;
+    shouldForceLeadingZeros?: boolean;
+}
+export declare function getFormatOptions(fieldOptions: FieldOptions, options: FormatterOptions): Intl.DateTimeFormatOptions;
+export declare function getPlaceholderTime(placeholderValue: DateValue | null | undefined): TimeValue;
+export declare function convertValue(value: DateValue | null | undefined, calendar: Calendar): DateValue | null | undefined;
+export declare function createPlaceholderDate(placeholderValue: DateValue | null | undefined, granularity: string, calendar: Calendar, timeZone: string | undefined): DateValue;
+export declare function useDefaultProps(v: DateValue | null, granularity: Granularity | undefined): [Granularity, string | undefined];