react-aria-components 1.17.0 → 1.18.0

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

@@ -6,7 +6,9 @@ import { ListState } from 'react-stately/useListState';
 import React, { ReactNode } from 'react';
 export interface TagGroupProps extends Omit<AriaTagGroupProps<unknown>, 'children' | 'items' | 'label' | 'description' | 'errorMessage' | 'keyboardDelegate'>, DOMProps, SlotProps, DOMRenderProps<'div', undefined>, GlobalDOMAttributes<HTMLDivElement> {
     /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element.
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
+     * element.
+     *
      * @default 'react-aria-TagGroup'
      */
     className?: string;
@@ -14,16 +16,19 @@ export interface TagGroupProps extends Omit<AriaTagGroupProps<unknown>, 'childre
 export interface TagListRenderProps {
     /**
      * Whether the tag list has no items and should display its empty state.
+     *
      * @selector [data-empty]
      */
     isEmpty: boolean;
     /**
      * Whether the tag list is currently focused.
+     *
      * @selector [data-focused]
      */
     isFocused: boolean;
     /**
      * Whether the tag list is currently keyboard focused.
+     *
      * @selector [data-focus-visible]
      */
     isFocusVisible: boolean;
@@ -34,7 +39,9 @@ export interface TagListRenderProps {
 }
 export interface TagListProps<T> extends Omit<CollectionProps<T>, 'disabledKeys'>, StyleRenderProps<TagListRenderProps, 'div'>, GlobalDOMAttributes<HTMLDivElement> {
     /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
+     * element. A function may be provided to compute the class based on component state.
+     *
      * @default 'react-aria-TagList'
      */
     className?: ClassNameOrFunction<TagListRenderProps>;
@@ -44,23 +51,27 @@ export interface TagListProps<T> extends Omit<CollectionProps<T>, 'disabledKeys'
 export declare const TagGroupContext: React.Context<ContextValue<TagGroupProps, HTMLDivElement>>;
 export declare const TagListContext: React.Context<ContextValue<TagListProps<any>, HTMLDivElement>>;
 /**
- * A tag group is a focusable list of labels, categories, keywords, filters, or other items, with support for keyboard navigation, selection, and removal.
+ * A tag group is a focusable list of labels, categories, keywords, filters, or other items, with
+ * support for keyboard navigation, selection, and removal.
  */
 export declare const TagGroup: (props: TagGroupProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
 /**
  * A tag list is a container for tags within a TagGroup.
  */
-export declare const TagList: <T extends object>(props: TagListProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export declare const TagList: <T>(props: TagListProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
 export interface TagRenderProps extends Omit<ItemRenderProps, 'allowsDragging' | 'isDragging' | 'isDropTarget'> {
     /**
      * Whether the tag group allows items to be removed.
+     *
      * @selector [data-allows-removing]
      */
     allowsRemoving: boolean;
 }
 export interface TagProps extends RenderProps<TagRenderProps, 'div'>, LinkDOMProps, HoverEvents, FocusEvents, PressEvents, Omit<GlobalDOMAttributes<HTMLDivElement>, 'onClick'> {
     /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
+     * element. A function may be provided to compute the class based on component state.
+     *
      * @default 'react-aria-Tag'
      */
     className?: ClassNameOrFunction<TagRenderProps>;
@@ -74,8 +85,8 @@ export interface TagProps extends RenderProps<TagRenderProps, 'div'>, LinkDOMPro
     /** Whether the tag is disabled. */
     isDisabled?: boolean;
     /**
-     * Handler that is called when a user performs an action on the item. The exact user event depends on
-     * the collection's `selectionBehavior` prop and the interaction modality.
+     * Handler that is called when a user performs an action on the item. The exact user event depends
+     * on the collection's `selectionBehavior` prop and the interaction modality.
      */
     onAction?: () => void;
 }

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

@@ -4,7 +4,9 @@ import { InputRenderProps } from './Input';
 import React, { TextareaHTMLAttributes } from 'react';
 export interface TextAreaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'className' | 'style'>, HoverEvents, StyleRenderProps<InputRenderProps, 'textarea'> {
     /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
+     * element. A function may be provided to compute the class based on component state.
+     *
      * @default 'react-aria-TextArea'
      */
     className?: ClassNameOrFunction<InputRenderProps>;

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

@@ -5,28 +5,34 @@ import React from 'react';
 export interface TextFieldRenderProps {
     /**
      * Whether the text field is disabled.
+     *
      * @selector [data-disabled]
      */
     isDisabled: boolean;
     /**
      * Whether the value is invalid.
+     *
      * @selector [data-invalid]
      */
     isInvalid: boolean;
     /**
      * Whether the text field is read only.
+     *
      * @selector [data-readonly]
      */
     isReadOnly: boolean;
     /**
      * Whether the text field is required.
+     *
      * @selector [data-required]
      */
     isRequired: boolean;
 }
 export interface TextFieldProps extends Omit<AriaTextFieldProps, 'label' | 'placeholder' | 'description' | 'errorMessage' | 'validationState' | 'validationBehavior'>, RACValidation, Omit<DOMProps, 'style' | 'className' | 'render' | 'children'>, SlotProps, RenderProps<TextFieldRenderProps>, GlobalDOMAttributes<HTMLDivElement> {
     /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
+     * element. A function may be provided to compute the class based on component state.
+     *
      * @default 'react-aria-TextField'
      */
     className?: ClassNameOrFunction<TextFieldRenderProps>;

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

@@ -9,23 +9,28 @@ export interface ToastRegionRenderProps<T> {
     visibleToasts: QueuedToast<T>[];
     /**
      * Whether the toast region is currently hovered with a mouse.
+     *
      * @selector [data-hovered]
      */
     isHovered: boolean;
     /**
      * Whether the toast region is currently focused.
+     *
      * @selector [data-focused]
      */
     isFocused: boolean;
     /**
      * Whether the toast region is keyboard focused.
+     *
      * @selector [data-focus-visible]
      */
     isFocusVisible: boolean;
 }
 export interface ToastRegionProps<T> extends AriaToastRegionProps, StyleRenderProps<ToastRegionRenderProps<T>>, GlobalDOMAttributes<HTMLDivElement> {
     /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
+     * element. A function may be provided to compute the class based on component state.
+     *
      * @default 'react-aria-ToastRegion'
      */
     className?: ClassNameOrFunction<ToastRegionRenderProps<T>>;
@@ -54,24 +59,29 @@ export interface ToastRenderProps<T> {
     toast: QueuedToast<T>;
     /**
      * Whether the toast is currently focused.
+     *
      * @selector [data-focused]
      */
     isFocused: boolean;
     /**
      * Whether the toast is keyboard focused.
+     *
      * @selector [data-focus-visible]
      */
     isFocusVisible: boolean;
 }
 export interface ToastProps<T> extends AriaToastProps<T>, RenderProps<ToastRenderProps<T>>, GlobalDOMAttributes<HTMLDivElement> {
     /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
+     * element. A function may be provided to compute the class based on component state.
+     *
      * @default 'react-aria-Toast'
      */
     className?: ClassNameOrFunction<ToastRenderProps<T>>;
 }
 /**
- * A Toast displays a brief, temporary notification of actions, errors, or other events in an application.
+ * A Toast displays a brief, temporary notification of actions, errors, or other events in an
+ * application.
  */
 declare const Toast: <T>(props: ToastProps<T> & React.RefAttributes<HTMLDivElement>) => ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
 export interface ToastContentProps extends HTMLAttributes<HTMLElement>, DOMRenderProps<'div', undefined> {

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

@@ -8,6 +8,7 @@ import { ToggleState } from 'react-stately/useToggleState';
 export interface ToggleButtonRenderProps extends Omit<ButtonRenderProps, 'isPending'> {
     /**
      * Whether the button is currently selected.
+     *
      * @selector [data-selected]
      */
     isSelected: boolean;
@@ -18,15 +19,21 @@ export interface ToggleButtonRenderProps extends Omit<ButtonRenderProps, 'isPend
 }
 export interface ToggleButtonProps extends Omit<AriaToggleButtonProps, 'children' | 'elementType' | 'id'>, HoverEvents, SlotProps, RenderProps<ToggleButtonRenderProps, 'button'>, Omit<GlobalDOMAttributes<HTMLDivElement>, 'onClick'> {
     /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
+     * element. A function may be provided to compute the class based on component state.
+     *
      * @default 'react-aria-ToggleButton'
      */
     className?: ClassNameOrFunction<ToggleButtonRenderProps>;
-    /** When used in a ToggleButtonGroup, an identifier for the item in `selectedKeys`. When used standalone, a DOM id. */
+    /**
+     * When used in a ToggleButtonGroup, an identifier for the item in `selectedKeys`. When used
+     * standalone, a DOM id.
+     */
     id?: Key;
 }
 export declare const ToggleButtonContext: React.Context<ContextValue<ToggleButtonProps, HTMLButtonElement>>;
 /**
- * A toggle button allows a user to toggle a selection on or off, for example switching between two states or modes.
+ * A toggle button allows a user to toggle a selection on or off, for example switching between two
+ * states or modes.
  */
 export declare const ToggleButton: (props: ToggleButtonProps & React.RefAttributes<HTMLButtonElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;

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

@@ -6,11 +6,13 @@ import { ToggleGroupState } from 'react-stately/useToggleGroupState';
 export interface ToggleButtonGroupRenderProps {
     /**
      * The orientation of the toggle button group.
+     *
      * @selector [data-orientation="horizontal | vertical"]
      */
     orientation: Orientation;
     /**
      * Whether the toggle button group is disabled.
+     *
      * @selector [data-disabled]
      */
     isDisabled: boolean;
@@ -21,7 +23,9 @@ export interface ToggleButtonGroupRenderProps {
 }
 export interface ToggleButtonGroupProps extends AriaToggleButtonGroupProps, RenderProps<ToggleButtonGroupRenderProps>, SlotProps, GlobalDOMAttributes<HTMLDivElement> {
     /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
+     * element. A function may be provided to compute the class based on component state.
+     *
      * @default 'react-aria-ToggleButtonGroup'
      */
     className?: ClassNameOrFunction<ToggleButtonGroupRenderProps>;
@@ -29,6 +33,7 @@ export interface ToggleButtonGroupProps extends AriaToggleButtonGroupProps, Rend
 export declare const ToggleButtonGroupContext: React.Context<ContextValue<ToggleButtonGroupProps, HTMLDivElement>>;
 export declare const ToggleGroupStateContext: React.Context<ToggleGroupState | null>;
 /**
- * A toggle button group allows a user to toggle multiple options, with single or multiple selection.
+ * A toggle button group allows a user to toggle multiple options, with single or multiple
+ * selection.
  */
 export declare const ToggleButtonGroup: (props: ToggleButtonGroupProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;

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

@@ -5,20 +5,23 @@ import React from 'react';
 export interface ToolbarRenderProps {
     /**
      * The current orientation of the toolbar.
+     *
      * @selector [data-orientation]
      */
     orientation: Orientation;
 }
 export interface ToolbarProps extends AriaToolbarProps, SlotProps, RenderProps<ToolbarRenderProps>, GlobalDOMAttributes<HTMLDivElement> {
     /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
+     * element. A function may be provided to compute the class based on component state.
+     *
      * @default 'react-aria-Toolbar'
      */
     className?: ClassNameOrFunction<ToolbarRenderProps>;
 }
 export declare const ToolbarContext: React.Context<ContextValue<ToolbarProps, HTMLDivElement>>;
 /**
- * A toolbar is a container for a set of interactive controls, such as buttons, dropdown menus, or checkboxes,
- * with arrow key navigation.
+ * A toolbar is a container for a set of interactive controls, such as buttons, dropdown menus, or
+ * checkboxes, with arrow key navigation.
  */
 export declare const Toolbar: (props: ToolbarProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;

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

@@ -9,14 +9,17 @@ export interface TooltipTriggerComponentProps extends TooltipTriggerProps {
 }
 export interface TooltipProps extends PositionProps, Pick<AriaPositionProps, 'arrowBoundaryOffset'>, OverlayTriggerProps, AriaLabelingProps, RenderProps<TooltipRenderProps>, GlobalDOMAttributes<HTMLDivElement> {
     /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
+     * element. A function may be provided to compute the class based on component state.
+     *
      * @default 'react-aria-Tooltip'
      */
     className?: ClassNameOrFunction<TooltipRenderProps>;
     /**
      * The ref for the element which the tooltip positions itself with respect to.
      *
-     * When used within a TooltipTrigger this is set automatically. It is only required when used standalone.
+     * When used within a TooltipTrigger this is set automatically. It is only required when used
+     * standalone.
      */
     triggerRef?: RefObject<Element | null>;
     /**
@@ -28,13 +31,16 @@ export interface TooltipProps extends PositionProps, Pick<AriaPositionProps, 'ar
      */
     isExiting?: boolean;
     /**
-     * The container element in which the overlay portal will be placed. This may have unknown behavior depending on where it is portalled to.
-     * @default document.body
+     * The container element in which the overlay portal will be placed. This may have unknown
+     * behavior depending on where it is portalled to.
+     *
      * @deprecated - Use a parent UNSAFE_PortalProvider to set your portal container instead.
+     * @default document.body
      */
     UNSTABLE_portalContainer?: Element;
     /**
      * The placement of the tooltip with respect to the trigger.
+     *
      * @default 'top'
      */
     placement?: Placement;
@@ -42,16 +48,19 @@ export interface TooltipProps extends PositionProps, Pick<AriaPositionProps, 'ar
 export interface TooltipRenderProps {
     /**
      * The placement of the tooltip relative to the trigger.
+     *
      * @selector [data-placement="left | right | top | bottom"]
      */
     placement: PlacementAxis | null;
     /**
      * Whether the tooltip is currently entering. Use this to apply animations.
+     *
      * @selector [data-entering]
      */
     isEntering: boolean;
     /**
      * Whether the tooltip is currently exiting. Use this to apply animations.
+     *
      * @selector [data-exiting]
      */
     isExiting: boolean;

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

@@ -12,29 +12,40 @@ import { TreeState } from 'react-stately/useTreeState';
 export interface TreeRenderProps {
     /**
      * Whether the tree has no items and should display its empty state.
+     *
      * @selector [data-empty]
      */
     isEmpty: boolean;
     /**
      * Whether the tree is currently focused.
+     *
      * @selector [data-focused]
      */
     isFocused: boolean;
     /**
      * Whether the tree is currently keyboard focused.
+     *
      * @selector [data-focus-visible]
      */
     isFocusVisible: boolean;
     /**
      * The type of selection that is allowed in the collection.
+     *
      * @selector [data-selection-mode="single | multiple"]
      */
     selectionMode: SelectionMode;
     /**
      * Whether the tree allows dragging.
+     *
      * @selector [data-allows-dragging]
      */
     allowsDragging: boolean;
+    /**
+     * Whether the tree is currently the active drop target.
+     *
+     * @selector [data-drop-target]
+     */
+    isDropTarget: boolean;
     /**
      * State of the tree.
      */
@@ -44,50 +55,61 @@ export interface TreeEmptyStateRenderProps extends Omit<TreeRenderProps, 'isEmpt
 }
 export interface TreeProps<T> extends Omit<AriaTreeProps<T>, 'children'>, MultipleSelection, CollectionProps<T>, StyleRenderProps<TreeRenderProps>, SlotProps, Expandable, GlobalDOMAttributes<HTMLDivElement> {
     /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
+     * element. A function may be provided to compute the class based on component state.
+     *
      * @default 'react-aria-Tree'
      */
     className?: ClassNameOrFunction<TreeRenderProps>;
     /**
      * How multiple selection should behave in the tree.
-     * @default "toggle"
+     *
+     * @default 'toggle'
      */
     selectionBehavior?: SelectionBehavior;
     /** Provides content to display when there are no items in the list. */
     renderEmptyState?: (props: TreeEmptyStateRenderProps) => ReactNode;
     /**
      * Whether `disabledKeys` applies to all interactions, or only selection.
+     *
      * @default 'all'
      */
     disabledBehavior?: DisabledBehavior;
-    /** The drag and drop hooks returned by `useDragAndDrop` used to enable drag and drop behavior for the Tree. */
+    /**
+     * The drag and drop hooks returned by `useDragAndDrop` used to enable drag and drop behavior for
+     * the Tree.
+     */
     dragAndDropHooks?: DragAndDropHooks<NoInfer<T>>;
 }
 export declare const TreeContext: React.Context<ContextValue<TreeProps<any>, HTMLDivElement>>;
 export declare const TreeStateContext: React.Context<TreeState<any> | null>;
 /**
- * A tree provides users with a way to navigate nested hierarchical information, with support for keyboard navigation
- * and selection.
+ * A tree provides users with a way to navigate nested hierarchical information, with support for
+ * keyboard navigation and selection.
  */
-export declare const Tree: <T extends object>(props: TreeProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export declare const Tree: <T>(props: TreeProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
 export interface TreeItemRenderProps extends ItemRenderProps {
     /**
      * Whether the tree item is expanded.
+     *
      * @selector [data-expanded]
      */
     isExpanded: boolean;
     /**
      * Whether the tree item has child tree items.
+     *
      * @selector [data-has-child-items]
      */
     hasChildItems: boolean;
     /**
      * What level the tree item has within the tree.
+     *
      * @selector [data-level="number"]
      */
     level: number;
     /**
      * Whether the tree item's children have keyboard focus.
+     *
      * @selector [data-focus-visible-within]
      */
     isFocusVisibleWithin: boolean;
@@ -99,49 +121,63 @@ export interface TreeItemRenderProps extends ItemRenderProps {
 export interface TreeItemContentRenderProps extends TreeItemRenderProps {
 }
 export interface TreeItemContentProps {
-    /** The children of the component. A function may be provided to alter the children based on component state. */
+    /**
+     * The children of the component. A function may be provided to alter the children based on
+     * component state.
+     */
     children: ChildrenOrFunction<TreeItemContentRenderProps>;
 }
 export declare const TreeItemContent: (props: TreeItemContentProps & React.RefAttributes<Element>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
 export declare const TreeItemContentContext: React.Context<TreeItemContentRenderProps | null>;
 export interface TreeItemProps<T = object> extends StyleRenderProps<TreeItemRenderProps>, LinkDOMProps, HoverEvents, PressEvents, Pick<AriaTreeItemOptions, 'hasChildItems'>, Omit<GlobalDOMAttributes<HTMLDivElement>, 'onClick'> {
     /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
+     * element. A function may be provided to compute the class based on component state.
+     *
      * @default 'react-aria-TreeItem'
      */
     className?: ClassNameOrFunction<TreeItemRenderProps>;
     /** The unique id of the tree row. */
     id?: Key;
-    /** The object value that this tree item represents. When using dynamic collections, this is set automatically. */
+    /**
+     * The object value that this tree item represents. When using dynamic collections, this is set
+     * automatically.
+     */
     value?: T;
     /** A string representation of the tree item's contents, used for features like typeahead. */
     textValue: string;
     /** An accessibility label for this tree item. */
     'aria-label'?: string;
-    /** The content of the tree item along with any nested children. Supports static nested tree items or use of a Collection to dynamically render nested tree items. */
+    /**
+     * The content of the tree item along with any nested children. Supports static nested tree items
+     * or use of a Collection to dynamically render nested tree items.
+     */
     children: ReactNode;
     /** Whether the item is disabled. */
     isDisabled?: boolean;
     /**
-     * Handler that is called when a user performs an action on this tree item. The exact user event depends on
-     * the collection's `selectionBehavior` prop and the interaction modality.
+     * Handler that is called when a user performs an action on this tree item. The exact user event
+     * depends on the collection's `selectionBehavior` prop and the interaction modality.
      */
     onAction?: () => void;
 }
 /**
  * A TreeItem represents an individual item in a Tree.
  */
-export declare const TreeItem: <T extends object>(props: TreeItemProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export declare const TreeItem: <T extends unknown>(props: TreeItemProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
 export interface TreeLoadMoreItemRenderProps {
     /**
      * What level the tree item has within the tree.
+     *
      * @selector [data-level]
      */
     level: number;
 }
 export interface TreeLoadMoreItemProps extends Omit<LoadMoreSentinelProps, 'collection'>, RenderProps<TreeLoadMoreItemRenderProps> {
     /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
+     * element. A function may be provided to compute the class based on component state.
+     *
      * @default 'react-aria-TreeLoadMoreItem'
      */
     className?: ClassNameOrFunction<TreeLoadMoreItemRenderProps>;
@@ -154,11 +190,11 @@ export interface TreeLoadMoreItemProps extends Omit<LoadMoreSentinelProps, 'coll
      */
     isLoading?: boolean;
 }
-export declare const TreeLoadMoreItem: <T extends object>(props: TreeLoadMoreItemProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export declare const TreeLoadMoreItem: <T>(props: TreeLoadMoreItemProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
 export interface GridListSectionProps<T> extends SectionProps<T>, DOMRenderProps<'div', undefined> {
 }
 /**
  * A TreeSection represents a section within a Tree.
  */
-export declare const TreeSection: <T extends object>(props: GridListSectionProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export declare const TreeSection: <T extends unknown>(props: GridListSectionProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
 export declare const TreeHeader: (props: GridListHeaderProps) => ReactNode;

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

@@ -33,12 +33,14 @@ interface DropHooks {
 }
 export type DragAndDropHooks<T = object> = DragHooks<T> & DropHooks;
 export interface DragAndDrop<T = object> {
-    /** Drag and drop hooks for the collection element.  */
+    /** Drag and drop hooks for the collection element. */
     dragAndDropHooks: DragAndDropHooks<T>;
 }
 export interface DragAndDropOptions<T = object> extends Omit<DraggableCollectionProps, 'preview' | 'getItems'>, DroppableCollectionProps {
     /**
-     * A function that returns the items being dragged. If not specified, we assume that the collection is not draggable.
+     * A function that returns the items being dragged. If not specified, we assume that the
+     * collection is not draggable.
+     *
      * @default () => []
      */
     getItems?: (keys: Set<Key>, items: T[]) => DragItem[];
@@ -57,12 +59,16 @@ export interface DragAndDropOptions<T = object> extends Omit<DraggableCollection
      * default DropIndicator is provided.
      */
     renderDropIndicator?: (target: DropTarget) => JSX.Element;
-    /** A custom delegate object that provides drop targets for pointer coordinates within the collection. */
+    /**
+     * A custom delegate object that provides drop targets for pointer coordinates within the
+     * collection.
+     */
     dropTargetDelegate?: DropTargetDelegate;
     /** Whether the drag and drop events should be disabled. */
     isDisabled?: boolean;
 }
 /**
- * Provides the hooks required to enable drag and drop behavior for a drag and drop compatible collection component.
+ * Provides the hooks required to enable drag and drop behavior for a drag and drop compatible
+ * collection component.
  */
 export declare function useDragAndDrop<T = object>(options: DragAndDropOptions<T>): DragAndDrop<T>;