react-stately 3.45.0 → 3.46.0

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

@@ -0,0 +1,18 @@
+import { Key } from '@react-types/shared';
+import { ReactElement, ReactNode } from 'react';
+export interface PartialNode<T> {
+    type?: string;
+    key?: Key | null;
+    value?: T;
+    element?: ReactElement | null;
+    wrapper?: (element: ReactElement) => ReactElement;
+    rendered?: ReactNode;
+    textValue?: string;
+    'aria-label'?: string;
+    index?: number;
+    renderer?: (item: T) => ReactElement | null;
+    hasChildNodes?: boolean;
+    childNodes?: () => IterableIterator<PartialNode<T>>;
+    props?: any;
+    shouldInvalidate?: (context: any) => boolean;
+}

package/dist/types/src/collections/useCollection.d.ts

@@ -0,0 +1,8 @@
+import { Collection, CollectionStateBase, Node } from '@react-types/shared';
+import { ReactElement } from 'react';
+interface CollectionOptions<T, C extends Collection<Node<T>>> extends Omit<CollectionStateBase<T, C>, 'children'> {
+    children?: ReactElement<any> | null | (ReactElement<any> | null)[] | ((item: T) => ReactElement<any> | null);
+}
+type CollectionFactory<T, C extends Collection<Node<T>>> = (node: Iterable<Node<T>>) => C;
+export declare function useCollection<T extends object, C extends Collection<Node<T>> = Collection<Node<T>>>(props: CollectionOptions<T, C>, factory: CollectionFactory<T, C>, context?: unknown): C;
+export {};

package/dist/types/src/color/Color.d.ts

@@ -0,0 +1,10 @@
+import { ColorChannel, ColorSpace, Color as IColor } from './types';
+/** Parses a color from a string value. Throws an error if the string could not be parsed. */
+export declare function parseColor(value: string): IColor;
+export declare function normalizeColor(v: string | IColor): IColor;
+/** Returns a list of color channels for a given color space. */
+export declare function getColorChannels(colorSpace: ColorSpace): [ColorChannel, ColorChannel, ColorChannel];
+/**
+ * Returns the hue value normalized to the range of 0 to 360.
+ */
+export declare function normalizeHue(hue: number): number;

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

@@ -0,0 +1,81 @@
+/** A list of supported color formats. */
+export type ColorFormat = 'hex' | 'hexa' | 'rgb' | 'rgba' | 'hsl' | 'hsla' | 'hsb' | 'hsba';
+export type ColorSpace = 'rgb' | 'hsl' | 'hsb';
+/** A list of color channels. */
+export type ColorChannel = 'hue' | 'saturation' | 'brightness' | 'lightness' | 'red' | 'green' | 'blue' | 'alpha';
+export type ColorAxes = {
+    xChannel: ColorChannel;
+    yChannel: ColorChannel;
+    zChannel: ColorChannel;
+};
+export interface ColorChannelRange {
+    /** The minimum value of the color channel. */
+    minValue: number;
+    /** The maximum value of the color channel. */
+    maxValue: number;
+    /** The step value of the color channel, used when incrementing and decrementing. */
+    step: number;
+    /** The page step value of the color channel, used when incrementing and decrementing. */
+    pageSize: number;
+}
+/** Represents a color value. */
+export interface Color {
+    /** Converts the color to the given color format, and returns a new Color object. */
+    toFormat(format: ColorFormat): Color;
+    /** Converts the color to a string in the given format. */
+    toString(format?: ColorFormat | 'css'): string;
+    /** Returns a duplicate of the color value. */
+    clone(): Color;
+    /** Converts the color to hex, and returns an integer representation. */
+    toHexInt(): number;
+    /**
+     * Returns the numeric value for a given channel.
+     * Throws an error if the channel is unsupported in the current color format.
+     */
+    getChannelValue(channel: ColorChannel): number;
+    /**
+     * Sets the numeric value for a given channel, and returns a new Color object.
+     * Throws an error if the channel is unsupported in the current color format.
+     */
+    withChannelValue(channel: ColorChannel, value: number): Color;
+    /**
+     * Returns the minimum, maximum, and step values for a given channel.
+     */
+    getChannelRange(channel: ColorChannel): ColorChannelRange;
+    /**
+     * Returns a localized color channel name for a given channel and locale,
+     * for use in visual or accessibility labels.
+     */
+    getChannelName(channel: ColorChannel, locale: string): string;
+    /**
+     * Returns the number formatting options for the given channel.
+     */
+    getChannelFormatOptions(channel: ColorChannel): Intl.NumberFormatOptions;
+    /**
+     * Formats the numeric value for a given channel for display according to the provided locale.
+     */
+    formatChannelValue(channel: ColorChannel, locale: string): string;
+    /**
+     * Returns the color space, 'rgb', 'hsb' or 'hsl', for the current color.
+     */
+    getColorSpace(): ColorSpace;
+    /**
+     * Returns the color space axes, xChannel, yChannel, zChannel.
+     */
+    getColorSpaceAxes(xyChannels: {
+        xChannel?: ColorChannel;
+        yChannel?: ColorChannel;
+    }): ColorAxes;
+    /**
+     * Returns an array of the color channels within the current color space space.
+     */
+    getColorChannels(): [ColorChannel, ColorChannel, ColorChannel];
+    /**
+     * Returns a localized name for the color, for use in visual or accessibility labels.
+     */
+    getColorName(locale: string): string;
+    /**
+     * Returns a localized name for the hue, for use in visual or accessibility labels.
+     */
+    getHueName(locale: string): string;
+}

package/dist/types/src/color/useColor.d.ts

@@ -0,0 +1,2 @@
+import { Color } from './types';
+export declare function useColor(value: string | Color | undefined | null): Color | null | undefined;

package/dist/types/src/color/useColorAreaState.d.ts

@@ -0,0 +1,75 @@
+import { Color, ColorChannel, ColorSpace } from './types';
+import { ValueBase } from '@react-types/shared';
+export interface ColorAreaProps extends Omit<ValueBase<string | Color>, 'onChange'> {
+    /**
+     * The color space that the color area operates in. The `xChannel` and `yChannel` must be in this color space.
+     * If not provided, this defaults to the color space of the `color` or `defaultColor` value.
+     */
+    colorSpace?: ColorSpace;
+    /** Color channel for the horizontal axis. */
+    xChannel?: ColorChannel;
+    /** Color channel for the vertical axis. */
+    yChannel?: ColorChannel;
+    /** Whether the ColorArea is disabled. */
+    isDisabled?: boolean;
+    /** Handler that is called when the value changes, as the user drags. */
+    onChange?: (value: Color) => void;
+    /** Handler that is called when the user stops dragging. */
+    onChangeEnd?: (value: Color) => void;
+}
+export interface ColorAreaState {
+    /** The current color value displayed by the color area. */
+    readonly value: Color;
+    /** The default value of the color area. */
+    readonly defaultValue: Color;
+    /** Sets the current color value. If a string is passed, it will be parsed to a Color. */
+    setValue(value: string | Color): void;
+    /** The current value of the horizontal axis channel displayed by the color area. */
+    xValue: number;
+    /** Sets the value for the horizontal axis channel displayed by the color area, and triggers `onChange`. */
+    setXValue(value: number): void;
+    /** The current value of the vertical axis channel displayed by the color area. */
+    yValue: number;
+    /** Sets the value for the vertical axis channel displayed by the color area, and triggers `onChange`. */
+    setYValue(value: number): void;
+    /** Sets the x and y channels of the current color value based on a percentage of the width and height of the color area, and triggers `onChange`. */
+    setColorFromPoint(x: number, y: number): void;
+    /** Returns the coordinates of the thumb relative to the upper left corner of the color area as a percentage. */
+    getThumbPosition(): {
+        x: number;
+        y: number;
+    };
+    /** Increments the value of the horizontal axis channel by the channel step or page amount. */
+    incrementX(stepSize?: number): void;
+    /** Decrements the value of the horizontal axis channel by the channel step or page amount. */
+    decrementX(stepSize?: number): void;
+    /** Increments the value of the vertical axis channel by the channel step or page amount. */
+    incrementY(stepSize?: number): void;
+    /** Decrements the value of the vertical axis channel by the channel step or page amount. */
+    decrementY(stepSize?: number): void;
+    /** Whether the color area is currently being dragged. */
+    readonly isDragging: boolean;
+    /** Sets whether the color area is being dragged. */
+    setDragging(value: boolean): void;
+    /** Returns the xChannel, yChannel and zChannel names based on the color value. */
+    channels: {
+        xChannel: ColorChannel;
+        yChannel: ColorChannel;
+        zChannel: ColorChannel;
+    };
+    /** The step value of the xChannel, used when incrementing and decrementing. */
+    xChannelStep: number;
+    /** The step value of the yChannel, used when incrementing and decrementing. */
+    yChannelStep: number;
+    /** The page step value of the xChannel, used when incrementing and decrementing. */
+    xChannelPageStep: number;
+    /** The page step value of the yChannel, used when incrementing and decrementing. */
+    yChannelPageStep: number;
+    /** Returns the color that should be displayed in the color area thumb instead of `value`. */
+    getDisplayColor(): Color;
+}
+/**
+ * Provides state management for a color area component.
+ * Color area allows users to adjust two channels of an HSL, HSB or RGB color value against a two-dimensional gradient background.
+ */
+export declare function useColorAreaState(props: ColorAreaProps): ColorAreaState;

package/dist/types/src/color/useColorChannelFieldState.d.ts

@@ -0,0 +1,23 @@
+import { Color, ColorChannel, ColorSpace } from './types';
+import { ColorFieldProps } from './useColorFieldState';
+import { NumberFieldState } from '../numberfield/useNumberFieldState';
+export interface ColorChannelFieldProps extends ColorFieldProps {
+    colorSpace?: ColorSpace;
+    channel: ColorChannel;
+}
+export interface ColorChannelFieldStateOptions extends ColorChannelFieldProps {
+    locale: string;
+}
+export interface ColorChannelFieldState extends NumberFieldState {
+    /** The current value of the field. */
+    colorValue: Color;
+    /** The default value of the field. */
+    defaultColorValue: Color | null;
+    /** Sets the color value of the field. */
+    setColorValue(value: Color | null): void;
+}
+/**
+ * Provides state management for a color channel field, allowing users to edit the
+ * value of an individual color channel.
+ */
+export declare function useColorChannelFieldState(props: ColorChannelFieldStateOptions): ColorChannelFieldState;

package/dist/types/src/color/useColorFieldState.d.ts

@@ -0,0 +1,49 @@
+import { Color } from './types';
+import { FocusableProps, HelpTextProps, InputBase, LabelableProps, TextInputBase, Validation, ValueBase } from '@react-types/shared';
+import { FormValidationState } from '../form/useFormValidationState';
+export interface ColorFieldProps extends Omit<ValueBase<string | Color | null>, 'onChange'>, InputBase, Validation<Color | null>, FocusableProps, TextInputBase, LabelableProps, HelpTextProps {
+    /** Handler that is called when the value changes. */
+    onChange?: (color: Color | null) => void;
+}
+export interface ColorFieldState extends FormValidationState {
+    /**
+     * The current text value of the input. Updated as the user types,
+     * and formatted according to `formatOptions` on blur.
+     */
+    readonly inputValue: string;
+    /**
+     * The currently parsed color value, or null if the field is empty.
+     * Updated based on the `inputValue` as the user types.
+     */
+    readonly colorValue: Color | null;
+    /** The default value of the color field. */
+    readonly defaultColorValue: Color | null;
+    /** Sets the color value of the field. */
+    setColorValue(value: Color | null): void;
+    /** Sets the current text value of the input. */
+    setInputValue(value: string): void;
+    /**
+     * Updates the input value based on the currently parsed color value.
+     * Typically this is called when the field is blurred.
+     */
+    commit(): void;
+    /** Increments the current input value to the next step boundary, and fires `onChange`. */
+    increment(): void;
+    /** Decrements the current input value to the next step boundary, and fires `onChange`. */
+    decrement(): void;
+    /** Sets the current value to the maximum color value, and fires `onChange`. */
+    incrementToMax(): void;
+    /** Sets the current value to the minimum color value, and fires `onChange`. */
+    decrementToMin(): void;
+    /**
+     * Validates a user input string.
+     * Values can be partially entered, and may be valid even if they cannot currently be parsed to a color.
+     * Can be used to implement validation as a user types.
+     */
+    validate(value: string): boolean;
+}
+/**
+ * Provides state management for a color field component. Color fields allow
+ * users to enter and adjust a hex color value.
+ */
+export declare function useColorFieldState(props: ColorFieldProps): ColorFieldState;

package/dist/types/src/color/useColorPickerState.d.ts

@@ -0,0 +1,11 @@
+import { Color } from './types';
+import { ValueBase } from '@react-types/shared';
+export interface ColorPickerProps extends ValueBase<string | Color, Color> {
+}
+export interface ColorPickerState {
+    /** The current color value of the color picker. */
+    color: Color;
+    /** Sets the current color value of the color picker. */
+    setColor(color: Color | null): void;
+}
+export declare function useColorPickerState(props: ColorPickerProps): ColorPickerState;

package/dist/types/src/color/useColorSliderState.d.ts

@@ -0,0 +1,34 @@
+import { Color, ColorChannel, ColorSpace } from './types';
+import { SliderProps, SliderState } from '../slider/useSliderState';
+export interface ColorSliderProps extends Omit<SliderProps<string | Color>, 'minValue' | 'maxValue' | 'step' | 'pageSize' | 'onChange' | 'onChangeEnd'> {
+    /**
+     * The color space that the slider operates in. The `channel` must be in this color space.
+     * If not provided, this defaults to the color space of the `color` or `defaultColor` value.
+     */
+    colorSpace?: ColorSpace;
+    /** The color channel that the slider manipulates. */
+    channel: ColorChannel;
+    /** Handler that is called when the value changes, as the user drags. */
+    onChange?: (value: Color) => void;
+    /** Handler that is called when the user stops dragging. */
+    onChangeEnd?: (value: Color) => void;
+}
+export interface ColorSliderState extends SliderState {
+    /** The current color value represented by the color slider. */
+    readonly value: Color;
+    /** Sets the current color value. If a string is passed, it will be parsed to a Color. */
+    setValue(value: string | Color): void;
+    /** Returns the color that should be displayed in the slider instead of `value` or the optional parameter. */
+    getDisplayColor(): Color;
+    /** Whether the color slider is currently being dragged. */
+    readonly isDragging: boolean;
+}
+export interface ColorSliderStateOptions extends ColorSliderProps {
+    /** The locale to use for formatting the color channel value. */
+    locale: string;
+}
+/**
+ * Provides state management for a color slider component.
+ * Color sliders allow users to adjust an individual channel of a color value.
+ */
+export declare function useColorSliderState(props: ColorSliderStateOptions): ColorSliderState;

package/dist/types/src/color/useColorWheelState.d.ts

@@ -0,0 +1,55 @@
+import { Color } from './types';
+import { ValueBase } from '@react-types/shared';
+export interface ColorWheelProps extends Omit<ValueBase<string | Color>, 'onChange'> {
+    /** Whether the ColorWheel is disabled. */
+    isDisabled?: boolean;
+    /** Handler that is called when the value changes, as the user drags. */
+    onChange?: (value: Color) => void;
+    /** Handler that is called when the user stops dragging. */
+    onChangeEnd?: (value: Color) => void;
+    /**
+     * The default value (uncontrolled).
+     * @default 'hsl(0, 100%, 50%)'
+     */
+    defaultValue?: string | Color;
+}
+export interface ColorWheelState {
+    /** The current color value represented by the color wheel. */
+    readonly value: Color;
+    /** The default color value. */
+    readonly defaultValue: Color;
+    /** Sets the color value represented by the color wheel, and triggers `onChange`. */
+    setValue(value: string | Color): void;
+    /** The current value of the hue channel displayed by the color wheel. */
+    readonly hue: number;
+    /** Sets the hue channel of the current color value and triggers `onChange`. */
+    setHue(value: number): void;
+    /** Sets the hue channel of the current color value based on the given coordinates and radius of the color wheel, and triggers `onChange`. */
+    setHueFromPoint(x: number, y: number, radius: number): void;
+    /** Returns the coordinates of the thumb relative to the center point of the color wheel. */
+    getThumbPosition(radius: number): {
+        x: number;
+        y: number;
+    };
+    /** Increments the hue by the given amount (defaults to 1). */
+    increment(stepSize?: number): void;
+    /** Decrements the hue by the given amount (defaults to 1). */
+    decrement(stepSize?: number): void;
+    /** Whether the color wheel is currently being dragged. */
+    readonly isDragging: boolean;
+    /** Sets whether the color wheel is being dragged. */
+    setDragging(value: boolean): void;
+    /** Returns the color that should be displayed in the color wheel instead of `value`. */
+    getDisplayColor(): Color;
+    /** The step value of the hue channel, used when incrementing and decrementing. */
+    step: number;
+    /** The page step value of the hue channel, used when incrementing and decrementing. */
+    pageStep: number;
+    /** Whether the color wheel is disabled. */
+    readonly isDisabled: boolean;
+}
+/**
+ * Provides state management for a color wheel component.
+ * Color wheels allow users to adjust the hue of an HSL or HSB color value on a circular track.
+ */
+export declare function useColorWheelState(props: ColorWheelProps): ColorWheelState;

package/dist/types/src/combobox/useComboBoxState.d.ts

@@ -0,0 +1,127 @@
+import { CollectionBase, CollectionStateBase, FocusableProps, FocusStrategy, HelpTextProps, InputBase, Key, LabelableProps, Node, TextInputBase, Validation, ValueBase } from '@react-types/shared';
+import { FormValidationState } from '../form/useFormValidationState';
+import { ListState } from '../list/useListState';
+import { OverlayTriggerState } from '../overlays/useOverlayTriggerState';
+export type MenuTriggerAction = 'focus' | 'input' | 'manual';
+export type SelectionMode = 'single' | 'multiple';
+export type ValueType<M extends SelectionMode> = M extends 'single' ? Key | null : Key[];
+export type ChangeValueType<M extends SelectionMode> = M extends 'single' ? Key | null : Key[];
+type ValidationType<M extends SelectionMode> = M extends 'single' ? Key | null : Key[];
+export interface ComboBoxValidationValue<M extends SelectionMode = 'single'> {
+    /**
+     * The selected key in the ComboBox.
+     * @deprecated
+     */
+    selectedKey: Key | null;
+    /** The keys of the currently selected items. */
+    value: ValidationType<M>;
+    /** The value of the ComboBox input. */
+    inputValue: string;
+}
+export interface ComboBoxProps<T, M extends SelectionMode = 'single'> extends CollectionBase<T>, InputBase, ValueBase<ValueType<M>, ChangeValueType<M>>, TextInputBase, Validation<ComboBoxValidationValue<M>>, FocusableProps<HTMLInputElement>, LabelableProps, HelpTextProps {
+    /** The list of ComboBox items (uncontrolled). */
+    defaultItems?: Iterable<T>;
+    /** The list of ComboBox items (controlled). */
+    items?: Iterable<T>;
+    /** Method that is called when the open state of the menu changes. Returns the new open state and the action that caused the opening of the menu. */
+    onOpenChange?: (isOpen: boolean, menuTrigger?: MenuTriggerAction) => void;
+    /**
+     * Whether single or multiple selection is enabled.
+     * @default 'single'
+     */
+    selectionMode?: M;
+    /**
+     * The currently selected key in the collection (controlled).
+     * @deprecated
+     */
+    selectedKey?: Key | null;
+    /**
+     * The initial selected key in the collection (uncontrolled).
+     * @deprecated
+     */
+    defaultSelectedKey?: Key | null;
+    /**
+     * Handler that is called when the selection changes.
+     * @deprecated
+     */
+    onSelectionChange?: (key: Key | null) => void;
+    /** The value of the ComboBox input (controlled). */
+    inputValue?: string;
+    /** The default value of the ComboBox input (uncontrolled). */
+    defaultInputValue?: string;
+    /** Handler that is called when the ComboBox input value changes. */
+    onInputChange?: (value: string) => void;
+    /** Whether the ComboBox allows a non-item matching input value to be set. */
+    allowsCustomValue?: boolean;
+    /**
+     * The interaction required to display the ComboBox menu.
+     * @default 'input'
+     */
+    menuTrigger?: MenuTriggerAction;
+}
+export interface ComboBoxState<T, M extends SelectionMode = 'single'> extends ListState<T>, OverlayTriggerState, FormValidationState {
+    /**
+     * The key for the first selected item.
+     * @deprecated
+     */
+    readonly selectedKey: Key | null;
+    /**
+     * The default selected key.
+     * @deprecated
+     */
+    readonly defaultSelectedKey: Key | null;
+    /**
+     * Sets the selected key.
+     * @deprecated
+     */
+    setSelectedKey(key: Key | null): void;
+    /** The current combobox value. */
+    readonly value: ValueType<M>;
+    /** The default combobox value. */
+    readonly defaultValue: ValueType<M>;
+    /** Sets the combobox value. */
+    setValue(value: Key | readonly Key[] | null): void;
+    /**
+     * The value of the first selected item.
+     * @deprecated
+     */
+    readonly selectedItem: Node<T> | null;
+    /** The value of the selected items. */
+    readonly selectedItems: Node<T>[];
+    /** The current value of the combo box input. */
+    inputValue: string;
+    /** The default value of the combo box input. */
+    defaultInputValue: string;
+    /** Sets the value of the combo box input. */
+    setInputValue(value: string): void;
+    /** Selects the currently focused item and updates the input value. */
+    commit(): void;
+    /** Controls which item will be auto focused when the menu opens. */
+    readonly focusStrategy: FocusStrategy | null;
+    /** Whether the select is currently focused. */
+    readonly isFocused: boolean;
+    /** Sets whether the select is focused. */
+    setFocused(isFocused: boolean): void;
+    /** Opens the menu. */
+    open(focusStrategy?: FocusStrategy | null, trigger?: MenuTriggerAction): void;
+    /** Toggles the menu. */
+    toggle(focusStrategy?: FocusStrategy | null, trigger?: MenuTriggerAction): void;
+    /** Resets the input value to the previously selected item's text if any and closes the menu.  */
+    revert(): void;
+}
+type FilterFn = (textValue: string, inputValue: string) => boolean;
+export interface ComboBoxStateOptions<T, M extends SelectionMode = 'single'> extends Omit<ComboBoxProps<T, M>, 'children'>, CollectionStateBase<T> {
+    /** The filter function used to determine if a option should be included in the combo box list. */
+    defaultFilter?: FilterFn;
+    /** Whether the combo box allows the menu to be open when the collection is empty. */
+    allowsEmptyCollection?: boolean;
+    /** Whether the combo box menu should close on blur. */
+    shouldCloseOnBlur?: boolean;
+}
+/**
+ * Provides state management for a combo box component. Handles building a collection
+ * of items from props and manages the option selection state of the combo box. In addition, it tracks the input value,
+ * focus state, and other properties of the combo box.
+ */
+export declare function useComboBoxState<T extends object, M extends SelectionMode = 'single'>(props: ComboBoxStateOptions<T, M>): ComboBoxState<T, M>;
+export {};

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

@@ -0,0 +1,71 @@
+import { ListData } from './useListData';
+import { Key, LoadingState, Selection, SortDescriptor } from '@react-types/shared';
+export interface AsyncListOptions<T, C> {
+    /** The keys for the initially selected items. */
+    initialSelectedKeys?: Iterable<Key>;
+    /** The initial sort descriptor. */
+    initialSortDescriptor?: SortDescriptor;
+    /** The initial filter text. */
+    initialFilterText?: string;
+    /** A function that returns a unique key for an item object. */
+    getKey?: (item: T) => Key;
+    /** A function that loads the data for the items in the list. */
+    load: AsyncListLoadFunction<T, C>;
+    /**
+     * An optional function that performs sorting. If not provided,
+     * then `sortDescriptor` is passed to the `load` function.
+     */
+    sort?: AsyncListLoadFunction<T, C, AsyncListLoadOptions<T, C> & {
+        sortDescriptor: SortDescriptor;
+    }>;
+}
+export type AsyncListLoadFunction<T, C, S extends AsyncListLoadOptions<T, C> = AsyncListLoadOptions<T, C>> = (state: S) => AsyncListStateUpdate<T, C> | Promise<AsyncListStateUpdate<T, C>>;
+export interface AsyncListLoadOptions<T, C> {
+    /** The items currently in the list. */
+    items: T[];
+    /** The keys of the currently selected items in the list. */
+    selectedKeys: Selection;
+    /** The current sort descriptor for the list. */
+    sortDescriptor?: SortDescriptor;
+    /** An abort signal used to notify the load function that the request has been aborted. */
+    signal: AbortSignal;
+    /** The pagination cursor returned from the last page load. */
+    cursor?: C;
+    /** The current filter text used to perform server side filtering. */
+    filterText?: string;
+    /** The current loading state of the list. */
+    loadingState?: LoadingState;
+}
+export interface AsyncListStateUpdate<T, C> {
+    /** The new items to append to the list. */
+    items: Iterable<T>;
+    /** The keys to add to the selection. */
+    selectedKeys?: Iterable<Key>;
+    /** The sort descriptor to set. */
+    sortDescriptor?: SortDescriptor;
+    /** The pagination cursor to be used for the next page load. */
+    cursor?: C;
+    /** The updated filter text for the list. */
+    filterText?: string;
+}
+export interface AsyncListData<T> extends ListData<T> {
+    /** Whether data is currently being loaded. */
+    isLoading: boolean;
+    /** If loading data failed, then this contains the error that occurred. */
+    error?: Error;
+    /** The current sort descriptor for the list. */
+    sortDescriptor?: SortDescriptor;
+    /** Reloads the data in the list. */
+    reload(): void;
+    /** Loads the next page of data in the list. */
+    loadMore(): void;
+    /** Triggers sorting for the list. */
+    sort(descriptor: SortDescriptor): void;
+    /** The current loading state for the list. */
+    loadingState: LoadingState;
+}
+/**
+ * Manages state for an immutable async loaded list data structure, and provides convenience methods to
+ * update the data over time. Manages loading and error states, pagination, and sorting.
+ */
+export declare function useAsyncList<T, C = string>(options: AsyncListOptions<T, C>): AsyncListData<T>;