react-stately 3.45.0 → 3.47.0

package/dist/types/src/layout/WaterfallLayout.d.ts

@@ -0,0 +1,68 @@
+import { DropTarget, DropTargetDelegate, Key, LayoutDelegate, Node } from '@react-types/shared';
+import { InvalidationContext } from '../virtualizer/types';
+import { Layout } from '../virtualizer/Layout';
+import { LayoutInfo } from '../virtualizer/LayoutInfo';
+import { Rect } from '../virtualizer/Rect';
+import { Size } from '../virtualizer/Size';
+export interface WaterfallLayoutOptions {
+    /**
+     * The minimum item size.
+     *
+     * @default 200 x 200
+     */
+    minItemSize?: Size;
+    /**
+     * The maximum item size.
+     *
+     * @default Infinity
+     */
+    maxItemSize?: Size;
+    /**
+     * The minimum space required between items.
+     *
+     * @default 18 x 18
+     */
+    minSpace?: Size;
+    /**
+     * The maximum allowed horizontal space between items.
+     *
+     * @default Infinity
+     */
+    maxHorizontalSpace?: number;
+    /**
+     * The maximum number of columns.
+     *
+     * @default Infinity
+     */
+    maxColumns?: number;
+    /**
+     * The thickness of the drop indicator.
+     *
+     * @default 2
+     */
+    dropIndicatorThickness?: number;
+    /**
+     * The fixed height of a loader element in px. This loader is specifically for "load more"
+     * elements rendered when loading more rows at the root level or inside nested row/sections.
+     *
+     * @default 48
+     */
+    loaderHeight?: number;
+}
+export declare class WaterfallLayout<T extends object, O extends WaterfallLayoutOptions = WaterfallLayoutOptions> extends Layout<Node<T>, O> implements LayoutDelegate, DropTargetDelegate {
+    private contentSize;
+    private layoutInfos;
+    protected numColumns: number;
+    protected dropIndicatorThickness: number;
+    private margin;
+    shouldInvalidateLayoutOptions(newOptions: O, oldOptions: O): boolean;
+    update(invalidationContext: InvalidationContext<O>): void;
+    getLayoutInfo(key: Key): LayoutInfo;
+    getContentSize(): Size;
+    getVisibleLayoutInfos(rect: Rect): LayoutInfo[];
+    updateItemSize(key: Key, size: Size): boolean;
+    getKeyRightOf(key: Key): Key | null;
+    getKeyLeftOf(key: Key): Key | null;
+    getKeyRange(from: Key, to: Key): Key[];
+    getDropTargetFromPoint(x: number, y: number): DropTarget;
+}

package/dist/types/src/list/ListCollection.d.ts

@@ -0,0 +1,19 @@
+import { Collection, Key, Node } from '@react-types/shared';
+export declare class ListCollection<T> implements Collection<Node<T>> {
+    private keyMap;
+    private iterable;
+    private firstKey;
+    private lastKey;
+    private _size;
+    constructor(nodes: Iterable<Node<T>>);
+    [Symbol.iterator](): IterableIterator<Node<T>>;
+    get size(): number;
+    getKeys(): IterableIterator<Key>;
+    getKeyBefore(key: Key): Key | null;
+    getKeyAfter(key: Key): Key | null;
+    getFirstKey(): Key | null;
+    getLastKey(): Key | null;
+    getItem(key: Key): Node<T> | null;
+    at(idx: number): Node<T> | null;
+    getChildren(key: Key): Iterable<Node<T>>;
+}

package/dist/types/src/list/useListState.d.ts

@@ -0,0 +1,31 @@
+import { Collection, CollectionStateBase, Key, LayoutDelegate, Node } from '@react-types/shared';
+import { MultipleSelectionStateProps } from '../selection/useMultipleSelectionState';
+import { SelectionManager } from '../selection/SelectionManager';
+export interface ListProps<T> extends CollectionStateBase<T>, MultipleSelectionStateProps {
+    /** Filter function to generate a filtered list of nodes. */
+    filter?: (nodes: Iterable<Node<T>>) => Iterable<Node<T>>;
+    /** @private */
+    suppressTextValueWarning?: boolean;
+    /**
+     * A delegate object that provides layout information for items in the collection.
+     * This can be used to override the behavior of shift selection.
+     */
+    layoutDelegate?: LayoutDelegate;
+}
+export interface ListState<T> {
+    /** A collection of items in the list. */
+    collection: Collection<Node<T>>;
+    /** A set of items that are disabled. */
+    disabledKeys: Set<Key>;
+    /** A selection manager to read and update multiple selection state. */
+    selectionManager: SelectionManager;
+}
+/**
+ * Provides state management for list-like components. Handles building a collection
+ * of items from props, and manages multiple selection state.
+ */
+export declare function useListState<T>(props: ListProps<T>): ListState<T>;
+/**
+ * Filters a collection using the provided filter function and returns a new ListState.
+ */
+export declare function UNSTABLE_useFilteredListState<T>(state: ListState<T>, filterFn: ((nodeValue: string, node: Node<T>) => boolean) | null | undefined): ListState<T>;

package/dist/types/src/list/useSingleSelectListState.d.ts

@@ -0,0 +1,21 @@
+import { CollectionStateBase, Key, Node, SingleSelection } from '@react-types/shared';
+import { ListState } from './useListState';
+export interface SingleSelectListProps<T> extends CollectionStateBase<T>, Omit<SingleSelection, 'disallowEmptySelection'> {
+    /** Filter function to generate a filtered list of nodes. */
+    filter?: (nodes: Iterable<Node<T>>) => Iterable<Node<T>>;
+    /** @private */
+    suppressTextValueWarning?: boolean;
+}
+export interface SingleSelectListState<T> extends ListState<T> {
+    /** The key for the currently selected item. */
+    readonly selectedKey: Key | null;
+    /** Sets the selected key. */
+    setSelectedKey(key: Key | null): void;
+    /** The value of the currently selected item. */
+    readonly selectedItem: Node<T> | null;
+}
+/**
+ * Provides state management for list-like components with single selection.
+ * Handles building a collection of items from props, and manages selection state.
+ */
+export declare function useSingleSelectListState<T extends object>(props: SingleSelectListProps<T>): SingleSelectListState<T>;

package/dist/types/src/menu/useMenuTriggerState.d.ts

@@ -0,0 +1,38 @@
+import { FocusStrategy, Key } from '@react-types/shared';
+import { OverlayTriggerProps, OverlayTriggerState } from '../overlays/useOverlayTriggerState';
+export type MenuTriggerType = 'press' | 'longPress';
+export interface MenuTriggerProps extends OverlayTriggerProps {
+    /**
+     * How the menu is triggered.
+     *
+     * @default 'press'
+     */
+    trigger?: MenuTriggerType;
+}
+export interface MenuTriggerState extends OverlayTriggerState {
+    /** Controls which item will be auto focused when the menu opens. */
+    readonly focusStrategy: FocusStrategy | null;
+    /** Opens the menu. */
+    open(focusStrategy?: FocusStrategy | null): void;
+    /** Toggles the menu. */
+    toggle(focusStrategy?: FocusStrategy | null): void;
+}
+export interface RootMenuTriggerState extends MenuTriggerState {
+    /** Opens a specific submenu tied to a specific menu item at a specific level. */
+    openSubmenu: (triggerKey: Key, level: number) => void;
+    /** Closes a specific submenu tied to a specific menu item at a specific level. */
+    closeSubmenu: (triggerKey: Key, level: number) => void;
+    /**
+     * An array of open submenu trigger keys within the menu tree.
+     * The index of key within array matches the submenu level in the tree.
+     */
+    expandedKeysStack: Key[];
+    /** Closes the menu and all submenus in the menu tree. */
+    close: () => void;
+}
+/**
+ * Manages state for a menu trigger. Tracks whether the menu is currently open,
+ * and controls which item will receive focus when it opens. Also tracks the open submenus within
+ * the menu tree via their trigger keys.
+ */
+export declare function useMenuTriggerState(props: MenuTriggerProps): RootMenuTriggerState;

package/dist/types/src/menu/useSubmenuTriggerState.d.ts

@@ -0,0 +1,30 @@
+import { FocusStrategy, Key } from '@react-types/shared';
+import type { OverlayTriggerState } from '../overlays/useOverlayTriggerState';
+import { RootMenuTriggerState } from './useMenuTriggerState';
+export interface SubmenuTriggerProps {
+    /** Key of the trigger item. */
+    triggerKey: Key;
+}
+export interface SubmenuTriggerState extends OverlayTriggerState {
+    /** Whether the submenu is currently open. */
+    isOpen: boolean;
+    /** Controls which item will be auto focused when the submenu opens. */
+    focusStrategy: FocusStrategy | null;
+    /** Opens the submenu. */
+    open: (focusStrategy?: FocusStrategy | null) => void;
+    /** Closes the submenu. */
+    close: () => void;
+    /** Closes all menus and submenus in the menu tree. */
+    closeAll: () => void;
+    /** The level of the submenu. */
+    submenuLevel: number;
+    /** Toggles the submenu. */
+    toggle: (focusStrategy?: FocusStrategy | null) => void;
+    /** @private */
+    setOpen: () => void;
+}
+/**
+ * Manages state for a submenu trigger. Tracks whether the submenu is currently open, the level of
+ * the submenu, and controls which item will receive focus when it opens.
+ */
+export declare function useSubmenuTriggerState(props: SubmenuTriggerProps, state: RootMenuTriggerState): SubmenuTriggerState;

package/dist/types/src/numberfield/useNumberFieldState.d.ts

@@ -0,0 +1,80 @@
+import { FocusableProps, HelpTextProps, InputBase, LabelableProps, RangeInputBase, TextInputBase, Validation, ValueBase } from '@react-types/shared';
+import { FormValidationState } from '../form/useFormValidationState';
+export interface NumberFieldProps extends InputBase, Validation<number>, FocusableProps, TextInputBase, ValueBase<number>, RangeInputBase<number>, LabelableProps, HelpTextProps {
+    /**
+     * Formatting options for the value displayed in the number field.
+     * This also affects what characters are allowed to be typed by the user.
+     */
+    formatOptions?: Intl.NumberFormatOptions;
+    /**
+     * Controls the behavior of the number field when the user blurs the field after editing. 'snap'
+     * will clamp the value to the min/max values, and snap to the nearest step value. 'validate' will
+     * not clamp the value, and will validate that the value is within the min/max range and on a
+     * valid step.
+     *
+     * @default 'snap'
+     */
+    commitBehavior?: 'snap' | 'validate';
+}
+export interface NumberFieldState extends FormValidationState {
+    /**
+     * The current text value of the input. Updated as the user types,
+     * and formatted according to `formatOptions` on blur.
+     */
+    inputValue: string;
+    /**
+     * The currently parsed number value, or NaN if a valid number could not be parsed.
+     * Updated based on the `inputValue` as the user types.
+     */
+    numberValue: number;
+    /** The default value of the input. */
+    defaultNumberValue: number;
+    /** The minimum value of the number field. */
+    minValue?: number;
+    /** The maximum value of the number field. */
+    maxValue?: number;
+    /** Whether the current value can be incremented according to the maximum value and step. */
+    canIncrement: boolean;
+    /** Whether the current value can be decremented according to the minimum value and step. */
+    canDecrement: boolean;
+    /**
+     * Validates a user input string according to the current locale and format options. Values can be
+     * partially entered, and may be valid even if they cannot currently be parsed to a number. Can be
+     * used to implement validation as a user types.
+     */
+    validate(value: string): boolean;
+    /** Sets the current text value of the input. */
+    setInputValue(val: string): void;
+    /** Sets the number value. */
+    setNumberValue(val: number): void;
+    /**
+     * Commits the current input value. The value is parsed to a number, clamped according to the
+     * minimum and maximum values of the field, and snapped to the nearest step value. This will fire
+     * the `onChange` prop with the new value, and if uncontrolled, update the `numberValue`.
+     * Typically this is called when the field is blurred.
+     *
+     * @param value - The value to commit. If not provided, the current input value is used.
+     */
+    commit(value?: string): 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 `maxValue` if any, and fires `onChange`. */
+    incrementToMax(): void;
+    /** Sets the current value to the `minValue` if any, and fires `onChange`. */
+    decrementToMin(): void;
+}
+export interface NumberFieldStateOptions extends NumberFieldProps {
+    /**
+     * The locale that should be used for parsing.
+     *
+     * @default 'en-US'
+     */
+    locale: string;
+}
+/**
+ * Provides state management for a number field component. Number fields allow users to enter a
+ * number, and increment or decrement the value using stepper buttons.
+ */
+export declare function useNumberFieldState(props: NumberFieldStateOptions): NumberFieldState;

package/dist/types/src/overlays/useOverlayTriggerState.d.ts

@@ -0,0 +1,25 @@
+export interface OverlayTriggerProps {
+    /** Whether the overlay is open by default (controlled). */
+    isOpen?: boolean;
+    /** Whether the overlay is open by default (uncontrolled). */
+    defaultOpen?: boolean;
+    /** Handler that is called when the overlay's open state changes. */
+    onOpenChange?: (isOpen: boolean) => void;
+}
+export interface OverlayTriggerState {
+    /** Whether the overlay is currently open. */
+    readonly isOpen: boolean;
+    /** Sets whether the overlay is open. */
+    setOpen(isOpen: boolean): void;
+    /** Opens the overlay. */
+    open(): void;
+    /** Closes the overlay. */
+    close(): void;
+    /** Toggles the overlay's visibility. */
+    toggle(): void;
+}
+/**
+ * Manages state for an overlay trigger. Tracks whether the overlay is open, and provides
+ * methods to toggle this state.
+ */
+export declare function useOverlayTriggerState(props: OverlayTriggerProps): OverlayTriggerState;

package/dist/types/src/radio/useRadioGroupState.d.ts

@@ -0,0 +1,48 @@
+import { FocusEvents, HelpTextProps, InputBase, InputDOMProps, LabelableProps, Orientation, Validation, ValidationState, ValueBase } from '@react-types/shared';
+import { FormValidationState } from '../form/useFormValidationState';
+export interface RadioGroupProps extends ValueBase<string | null, string>, InputBase, Pick<InputDOMProps, 'name'>, Validation<string>, LabelableProps, HelpTextProps, FocusEvents {
+    /**
+     * The axis the Radio Button(s) should align with.
+     *
+     * @default 'vertical'
+     */
+    orientation?: Orientation;
+}
+export interface RadioGroupState extends FormValidationState {
+    /**
+     * The name for the group, used for native form submission.
+     *
+     * @private
+     * @deprecated
+     */
+    readonly name: string;
+    /** Whether the radio group is disabled. */
+    readonly isDisabled: boolean;
+    /** Whether the radio group is read only. */
+    readonly isReadOnly: boolean;
+    /** Whether the radio group is required. */
+    readonly isRequired: boolean;
+    /**
+     * Whether the radio group is valid or invalid.
+     *
+     * @deprecated Use `isInvalid` instead.
+     */
+    readonly validationState: ValidationState | null;
+    /** Whether the radio group is invalid. */
+    readonly isInvalid: boolean;
+    /** The currently selected value. */
+    readonly selectedValue: string | null;
+    /** The default selected value. */
+    readonly defaultSelectedValue: string | null;
+    /** Sets the selected value. */
+    setSelectedValue(value: string | null): void;
+    /** The value of the last focused radio. */
+    readonly lastFocusedValue: string | null;
+    /** Sets the last focused value. */
+    setLastFocusedValue(value: string | null): void;
+}
+/**
+ * Provides state management for a radio group component. Provides a name for the group,
+ * and manages selection and focus state.
+ */
+export declare function useRadioGroupState(props: RadioGroupProps): RadioGroupState;

package/dist/types/src/searchfield/useSearchFieldState.d.ts

@@ -0,0 +1,19 @@
+import { FocusableProps, HelpTextProps, InputBase, LabelableProps, TextInputBase, Validation, ValueBase } from '@react-types/shared';
+export interface TextFieldProps<T = HTMLInputElement> extends InputBase, Validation<string>, HelpTextProps, FocusableProps<T>, TextInputBase, ValueBase<string>, LabelableProps {
+}
+export interface SearchFieldProps extends TextFieldProps {
+    /** Handler that is called when the SearchField is submitted. */
+    onSubmit?: (value: string) => void;
+    /** Handler that is called when the clear button is pressed. */
+    onClear?: () => void;
+}
+export interface SearchFieldState {
+    /** The current value of the search field. */
+    readonly value: string;
+    /** Sets the value of the search field. */
+    setValue(value: string): void;
+}
+/**
+ * Provides state management for a search field.
+ */
+export declare function useSearchFieldState(props: SearchFieldProps): SearchFieldState;

package/dist/types/src/select/useSelectState.d.ts

@@ -0,0 +1,100 @@
+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 SelectionMode = 'single' | 'multiple';
+export type ValueType<M extends SelectionMode> = M extends 'single' ? Key | null : readonly Key[];
+export type ChangeValueType<M extends SelectionMode> = M extends 'single' ? Key | null : Key[];
+type ValidationType<M extends SelectionMode> = M extends 'single' ? Key : Key[];
+export interface SelectProps<T, M extends SelectionMode = 'single'> extends CollectionBase<T>, Omit<InputBase, 'isReadOnly'>, ValueBase<ValueType<M>, ChangeValueType<M>>, Validation<ValidationType<M>>, HelpTextProps, LabelableProps, TextInputBase, FocusableProps {
+    /**
+     * 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;
+    /** Sets the open state of the menu. */
+    isOpen?: boolean;
+    /** Sets the default open state of the menu. */
+    defaultOpen?: boolean;
+    /** Method that is called when the open state of the menu changes. */
+    onOpenChange?: (isOpen: boolean) => void;
+    /**
+     * Whether the Select should close when an item is selected. Defaults to true if selectionMode is
+     * single, false otherwise.
+     */
+    shouldCloseOnSelect?: boolean;
+    /** Whether the select should be allowed to be open when the collection is empty. */
+    allowsEmptyCollection?: boolean;
+}
+export interface SelectStateOptions<T, M extends SelectionMode = 'single'> extends Omit<SelectProps<T, M>, 'children'>, CollectionStateBase<T> {
+}
+export interface SelectState<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 select value. */
+    readonly value: ValueType<M>;
+    /** The default select value. */
+    readonly defaultValue: ValueType<M>;
+    /** Sets the select 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>[];
+    /** Whether the select is currently focused. */
+    readonly isFocused: boolean;
+    /** Sets whether the select is focused. */
+    setFocused(isFocused: boolean): void;
+    /** Controls which item will be auto focused when the menu opens. */
+    readonly focusStrategy: FocusStrategy | null;
+    /** Opens the menu. */
+    open(focusStrategy?: FocusStrategy | null): void;
+    /** Toggles the menu. */
+    toggle(focusStrategy?: FocusStrategy | null): void;
+}
+/**
+ * Provides state management for a select component. Handles building a collection
+ * of items from props, handles the open state for the popup menu, and manages
+ * multiple selection state.
+ */
+export declare function useSelectState<T, M extends SelectionMode = 'single'>(props: SelectStateOptions<T, M>): SelectState<T, M>;
+export {};

package/dist/types/src/selection/Selection.d.ts

@@ -0,0 +1,10 @@
+import { Key } from '@react-types/shared';
+/**
+ * A Selection is a special Set containing Keys, which also has an anchor
+ * and current selected key for use when range selecting.
+ */
+export declare class Selection extends Set<Key> {
+    anchorKey: Key | null;
+    currentKey: Key | null;
+    constructor(keys?: Iterable<Key> | Selection, anchorKey?: Key | null, currentKey?: Key | null);
+}

package/dist/types/src/selection/SelectionManager.d.ts

@@ -0,0 +1,122 @@
+import { Collection, DisabledBehavior, FocusStrategy, Selection as ISelection, Key, LayoutDelegate, LongPressEvent, Node, PressEvent, SelectionBehavior, SelectionMode } from '@react-types/shared';
+import { MultipleSelectionManager, MultipleSelectionState } from './types';
+interface SelectionManagerOptions {
+    allowsCellSelection?: boolean;
+    layoutDelegate?: LayoutDelegate;
+    fullCollection?: Collection<Node<unknown>>;
+}
+/**
+ * An interface for reading and updating multiple selection state.
+ */
+export declare class SelectionManager implements MultipleSelectionManager {
+    collection: Collection<Node<unknown>>;
+    private state;
+    private allowsCellSelection;
+    private _isSelectAll;
+    private layoutDelegate;
+    private fullCollection;
+    constructor(collection: Collection<Node<unknown>>, state: MultipleSelectionState, options?: SelectionManagerOptions);
+    /**
+     * The type of selection that is allowed in the collection.
+     */
+    get selectionMode(): SelectionMode;
+    /**
+     * Whether the collection allows empty selection.
+     */
+    get disallowEmptySelection(): boolean;
+    /**
+     * The selection behavior for the collection.
+     */
+    get selectionBehavior(): SelectionBehavior;
+    /**
+     * Sets the selection behavior for the collection.
+     */
+    setSelectionBehavior(selectionBehavior: SelectionBehavior): void;
+    /**
+     * Whether the collection is currently focused.
+     */
+    get isFocused(): boolean;
+    /**
+     * Sets whether the collection is focused.
+     */
+    setFocused(isFocused: boolean): void;
+    /**
+     * The current focused key in the collection.
+     */
+    get focusedKey(): Key | null;
+    /** Whether the first or last child of the focused key should receive focus. */
+    get childFocusStrategy(): FocusStrategy | null;
+    /**
+     * Sets the focused key.
+     */
+    setFocusedKey(key: Key | null, childFocusStrategy?: FocusStrategy): void;
+    /**
+     * The currently selected keys in the collection.
+     */
+    get selectedKeys(): Set<Key>;
+    /**
+     * The raw selection value for the collection.
+     * Either 'all' for select all, or a set of keys.
+     */
+    get rawSelection(): ISelection;
+    /**
+     * Returns whether a key is selected.
+     */
+    isSelected(key: Key): boolean;
+    /**
+     * Whether the selection is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Whether all items in the collection are selected.
+     */
+    get isSelectAll(): boolean;
+    get firstSelectedKey(): Key | null;
+    get lastSelectedKey(): Key | null;
+    get disabledKeys(): Set<Key>;
+    get disabledBehavior(): DisabledBehavior;
+    /**
+     * Extends the selection to the given key.
+     */
+    extendSelection(toKey: Key): void;
+    private getKeyRange;
+    private getKeyRangeInternal;
+    private getKey;
+    /**
+     * Toggles whether the given key is selected.
+     */
+    toggleSelection(key: Key): void;
+    /**
+     * Replaces the selection with only the given key.
+     */
+    replaceSelection(key: Key): void;
+    /**
+     * Replaces the selection with the given keys.
+     */
+    setSelectedKeys(keys: Iterable<Key>): void;
+    private getSelectAllKeys;
+    /**
+     * Selects all items in the collection.
+     */
+    selectAll(): void;
+    /**
+     * Removes all keys from the selection.
+     */
+    clearSelection(): void;
+    /**
+     * Toggles between select all and an empty selection.
+     */
+    toggleSelectAll(): void;
+    select(key: Key, e?: PressEvent | LongPressEvent | PointerEvent): void;
+    /**
+     * Returns whether the current selection is equal to the given selection.
+     */
+    isSelectionEqual(selection: Set<Key>): boolean;
+    canSelectItem(key: Key): boolean;
+    private canSelectItemIn;
+    isDisabled(key: Key): boolean;
+    isLink(key: Key): boolean;
+    getItemProps(key: Key): any;
+    withCollection(collection: Collection<Node<unknown>>): SelectionManager;
+}
+export {};