react-aria-components 1.15.1 → 1.17.0

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

@@ -0,0 +1,405 @@
+import { AriaLabelingProps, GlobalDOMAttributes, HoverEvents, Key, LinkDOMProps, PressEvents } from '@react-types/shared';
+import { ClassNameOrFunction, ContextValue, DOMProps, DOMRenderProps, RenderProps, SlotProps, StyleProps, StyleRenderProps } from './utils';
+import { CollectionProps, ItemRenderProps } from './Collection';
+import { ColumnSize, ColumnStaticSize } from 'react-stately/useTableState';
+import { DisabledBehavior, SelectionBehavior, SelectionMode, SortDirection } from '@react-types/shared';
+import { DragAndDropHooks } from './useDragAndDrop';
+import { LoadMoreSentinelProps } from 'react-aria/private/utils/useLoadMoreSentinel';
+import React, { ReactElement, ReactNode } from 'react';
+import { TableProps as SharedTableProps, TableState } from 'react-stately/useTableState';
+import { TableColumnResizeState } from 'react-stately/useTableState';
+export { TableLayout } from './TableLayout';
+export interface ResizableTableContainerProps extends DOMProps, DOMRenderProps<'div', undefined>, GlobalDOMAttributes<HTMLDivElement> {
+    /**
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element.
+     * @default 'react-aria-ResizableTableContainer'
+     */
+    className?: string;
+    /**
+     * Handler that is called when a user starts a column resize.
+     */
+    onResizeStart?: (widths: Map<Key, ColumnSize>) => void;
+    /**
+     * Handler that is called when a user performs a column resize.
+     * Can be used with the width property on columns to put the column widths into
+     * a controlled state.
+     */
+    onResize?: (widths: Map<Key, ColumnSize>) => void;
+    /**
+     * Handler that is called after a user performs a column resize.
+     * Can be used to store the widths of columns for another future session.
+     */
+    onResizeEnd?: (widths: Map<Key, ColumnSize>) => void;
+}
+export declare const ResizableTableContainer: React.ForwardRefExoticComponent<ResizableTableContainerProps & React.RefAttributes<HTMLDivElement>>;
+export declare const TableContext: React.Context<ContextValue<TableProps, HTMLDivElement | HTMLTableElement>>;
+export declare const TableStateContext: React.Context<TableState<any> | null>;
+export declare const TableColumnResizeStateContext: React.Context<TableColumnResizeState<unknown> | null>;
+export interface TableRenderProps {
+    /**
+     * Whether the table is currently focused.
+     * @selector [data-focused]
+     */
+    isFocused: boolean;
+    /**
+     * Whether the table is currently keyboard focused.
+     * @selector [data-focus-visible]
+     */
+    isFocusVisible: boolean;
+    /**
+     * Whether the table is currently the active drop target.
+     * @selector [data-drop-target]
+     */
+    isDropTarget: boolean;
+    /**
+     * State of the table.
+     */
+    state: TableState<unknown>;
+}
+export interface TableProps extends Omit<SharedTableProps<any>, 'children'>, StyleRenderProps<TableRenderProps, 'table' | 'div'>, SlotProps, AriaLabelingProps, GlobalDOMAttributes<HTMLTableElement> {
+    /**
+     * 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-Table'
+     */
+    className?: ClassNameOrFunction<TableRenderProps>;
+    /** The elements that make up the table. Includes the TableHeader, TableBody, Columns, and Rows. */
+    children?: ReactNode;
+    /**
+     * How multiple selection should behave in the collection.
+     * @default "toggle"
+     */
+    selectionBehavior?: SelectionBehavior;
+    /**
+     * Whether `disabledKeys` applies to all interactions, or only selection.
+     * @default "all"
+     */
+    disabledBehavior?: DisabledBehavior;
+    /** Handler that is called when a user performs an action on the row. */
+    onRowAction?: (key: Key) => void;
+    /** The drag and drop hooks returned by `useDragAndDrop` used to enable drag and drop behavior for the Table. */
+    dragAndDropHooks?: DragAndDropHooks;
+}
+/**
+ * A table displays data in rows and columns and enables a user to navigate its contents via directional navigation keys,
+ * and optionally supports row selection and sorting.
+ */
+export declare const Table: React.ForwardRefExoticComponent<TableProps & React.RefAttributes<HTMLDivElement | HTMLTableElement>>;
+export interface TableOptionsContextValue {
+    /** The type of selection that is allowed in the table. */
+    selectionMode: SelectionMode;
+    /** The selection behavior for the table. If selectionMode is `"none"`, this will be `null`. */
+    selectionBehavior: SelectionBehavior | null;
+    /** Whether the table allows empty selection. */
+    disallowEmptySelection: boolean;
+    /** Whether the table allows rows to be dragged. */
+    allowsDragging: boolean;
+}
+/**
+ * Returns options from the parent `<Table>` component.
+ */
+export declare function useTableOptions(): TableOptionsContextValue;
+export interface TableHeaderRenderProps {
+    /**
+     * Whether the table header is currently hovered with a mouse.
+     * @selector [data-hovered]
+     */
+    isHovered: boolean;
+}
+export interface TableHeaderProps<T> extends StyleRenderProps<TableHeaderRenderProps, 'thead' | 'div'>, HoverEvents, GlobalDOMAttributes<HTMLTableSectionElement> {
+    /**
+     * 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-TableHeader'
+     */
+    className?: ClassNameOrFunction<TableHeaderRenderProps>;
+    /** A list of table columns. */
+    columns?: Iterable<T>;
+    /** A list of `Column(s)` or a function. If the latter, a list of columns must be provided using the `columns` prop. */
+    children?: ReactNode | ((item: T) => ReactElement);
+    /** Values that should invalidate the column cache when using dynamic collections. */
+    dependencies?: ReadonlyArray<any>;
+}
+/**
+ * A header within a `<Table>`, containing the table columns.
+ */
+export declare const TableHeader: <T extends object>(props: TableHeaderProps<T> & React.RefAttributes<HTMLDivElement | HTMLTableSectionElement>) => ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface ColumnRenderProps {
+    /**
+     * Whether the column is currently hovered with a mouse.
+     * @selector [data-hovered]
+     */
+    isHovered: boolean;
+    /**
+     * Whether the column is currently in a pressed state.
+     * @selector [data-pressed]
+     */
+    isPressed: boolean;
+    /**
+     * Whether the column is currently focused.
+     * @selector [data-focused]
+     */
+    isFocused: boolean;
+    /**
+     * Whether the column is currently keyboard focused.
+     * @selector [data-focus-visible]
+     */
+    isFocusVisible: boolean;
+    /**
+     * Whether the column allows sorting.
+     * @selector [data-allows-sorting]
+     */
+    allowsSorting: boolean;
+    /**
+     * The current sort direction.
+     * @selector [data-sort-direction="ascending | descending"]
+     */
+    sortDirection: SortDirection | undefined;
+    /**
+     * Whether the column is currently being resized.
+     * @selector [data-resizing]
+     */
+    isResizing: boolean;
+    /**
+     * Triggers sorting for this column in the given direction.
+     */
+    sort(direction: SortDirection): void;
+    /**
+     * Starts column resizing if the table is contained in a `<ResizableTableContainer>` element.
+     */
+    startResize(): void;
+}
+export interface ColumnProps extends RenderProps<ColumnRenderProps, 'th' | 'div'>, GlobalDOMAttributes<HTMLTableHeaderCellElement> {
+    /**
+     * 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-Column'
+     */
+    className?: ClassNameOrFunction<ColumnRenderProps>;
+    /** The unique id of the column. */
+    id?: Key;
+    /** Whether the column allows sorting. */
+    allowsSorting?: boolean;
+    /** Whether a column is a [row header](https://www.w3.org/TR/wai-aria-1.1/#rowheader) and should be announced by assistive technology during row navigation. */
+    isRowHeader?: boolean;
+    /** A string representation of the column's contents, used for accessibility announcements. */
+    textValue?: string;
+    /** The width of the column. This prop only applies when the `<Table>` is wrapped in a `<ResizableTableContainer>`. */
+    width?: ColumnSize | null;
+    /** The default width of the column. This prop only applies when the `<Table>` is wrapped in a `<ResizableTableContainer>`. */
+    defaultWidth?: ColumnSize | null;
+    /** The minimum width of the column. This prop only applies when the `<Table>` is wrapped in a `<ResizableTableContainer>`. */
+    minWidth?: ColumnStaticSize | null;
+    /** The maximum width of the column. This prop only applies when the `<Table>` is wrapped in a `<ResizableTableContainer>`. */
+    maxWidth?: ColumnStaticSize | null;
+}
+/**
+ * A column within a `<Table>`.
+ */
+export declare const Column: (props: ColumnProps & React.RefAttributes<HTMLDivElement | HTMLTableCellElement>) => ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface ColumnResizerRenderProps {
+    /**
+     * Whether the resizer is currently hovered with a mouse.
+     * @selector [data-hovered]
+     */
+    isHovered: boolean;
+    /**
+     * Whether the resizer is currently focused.
+     * @selector [data-focused]
+     */
+    isFocused: boolean;
+    /**
+     * Whether the resizer is currently keyboard focused.
+     * @selector [data-focus-visible]
+     */
+    isFocusVisible: boolean;
+    /**
+     * Whether the resizer is currently being resized.
+     * @selector [data-resizing]
+     */
+    isResizing: boolean;
+    /**
+     * The direction that the column is currently resizable.
+     * @selector [data-resizable-direction="right | left | both"]
+     */
+    resizableDirection: 'right' | 'left' | 'both';
+}
+export interface ColumnResizerProps extends HoverEvents, RenderProps<ColumnResizerRenderProps>, 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.
+     * @default 'react-aria-ColumnResizer'
+     */
+    className?: ClassNameOrFunction<ColumnResizerRenderProps>;
+    /** A custom accessibility label for the resizer. */
+    'aria-label'?: string;
+}
+export declare const ColumnResizer: React.ForwardRefExoticComponent<ColumnResizerProps & React.RefAttributes<HTMLDivElement>>;
+export interface TableBodyRenderProps {
+    /**
+     * Whether the table body has no rows and should display its empty state.
+     * @selector [data-empty]
+     */
+    isEmpty: boolean;
+    /**
+     * Whether the Table is currently the active drop target.
+     * @selector [data-drop-target]
+     */
+    isDropTarget: boolean;
+}
+export interface TableBodyProps<T> extends Omit<CollectionProps<T>, 'disabledKeys'>, StyleRenderProps<TableBodyRenderProps, 'tbody' | 'div'>, GlobalDOMAttributes<HTMLTableSectionElement> {
+    /**
+     * 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-TableBody'
+     */
+    className?: ClassNameOrFunction<TableBodyRenderProps>;
+    /** Provides content to display when there are no rows in the table. */
+    renderEmptyState?: (props: TableBodyRenderProps) => ReactNode;
+}
+/**
+ * The body of a `<Table>`, containing the table rows.
+ */
+export declare const TableBody: <T extends object>(props: TableBodyProps<T> & React.RefAttributes<HTMLDivElement | HTMLTableSectionElement>) => ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface RowRenderProps extends ItemRenderProps {
+    /** Whether the row's children have keyboard focus. */
+    isFocusVisibleWithin: boolean;
+    /** The unique id of the row. */
+    id?: Key;
+    /**
+     * Whether the row is expanded.
+     * @selector [data-expanded]
+     */
+    isExpanded: boolean;
+    /**
+     * Whether the row has child rows.
+     * @selector [data-has-child-items]
+     */
+    hasChildItems: boolean;
+    /**
+     * What level the row has within the table.
+     * @selector [data-level]
+     */
+    level: number;
+}
+export interface RowProps<T> extends StyleRenderProps<RowRenderProps, 'tr' | 'div'>, LinkDOMProps, HoverEvents, PressEvents, Omit<GlobalDOMAttributes<HTMLTableRowElement>, '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.
+     * @default 'react-aria-Row'
+     */
+    className?: ClassNameOrFunction<RowRenderProps>;
+    /** A list of columns used when dynamically rendering cells. */
+    columns?: Iterable<T>;
+    /** The cells within the row. Supports static items or a function for dynamic rendering. */
+    children?: ReactNode | ((item: T) => ReactElement);
+    /** The object value that this row represents. When using dynamic collections, this is set automatically. */
+    value?: T;
+    /** Values that should invalidate the cell cache when using dynamic collections. */
+    dependencies?: ReadonlyArray<any>;
+    /** A string representation of the row's contents, used for features like typeahead. */
+    textValue?: string;
+    /** Whether the row is disabled. */
+    isDisabled?: boolean;
+    /**
+     * Handler that is called when a user performs an action on the row. The exact user event depends on
+     * the collection's `selectionBehavior` prop and the interaction modality.
+     */
+    onAction?: () => void;
+    /** The unique id of the row. */
+    id?: Key;
+    /** Whether this row has children, even if not loaded yet. */
+    hasChildItems?: boolean;
+}
+/**
+ * A row within a `<Table>`.
+ */
+export declare const Row: <T extends object>(props: RowProps<T> & React.RefAttributes<HTMLDivElement | HTMLTableRowElement>) => ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface CellRenderProps {
+    /**
+     * Whether the cell is currently in a pressed state.
+     * @selector [data-pressed]
+     */
+    isPressed: boolean;
+    /**
+     * Whether the cell is currently focused.
+     * @selector [data-focused]
+     */
+    isFocused: boolean;
+    /**
+     * Whether the cell is currently keyboard focused.
+     * @selector [data-focus-visible]
+     */
+    isFocusVisible: boolean;
+    /**
+     * Whether the cell is currently hovered with a mouse.
+     * @selector [data-hovered]
+     */
+    isHovered: boolean;
+    /**
+     * Whether the parent row is currently selected.
+     * @selector [data-selected]
+     */
+    isSelected: boolean;
+    /**
+     * Whether the parent row is non-interactive, i.e. both selection and actions are disabled and the item may
+     * not be focused. Dependent on `disabledKeys` and `disabledBehavior`.
+     * @selector [data-disabled]
+     */
+    isDisabled: boolean;
+    /**
+     * The unique id of the cell.
+     **/
+    id?: Key;
+    /**
+     * The index of the column that this cell belongs to. Respects col spanning.
+     */
+    columnIndex?: number | null;
+    /**
+     * Whether the column displays hierarchical data.
+     * @selector [data-tree-column]
+     */
+    isTreeColumn: boolean;
+    /**
+     * Whether the parent row is expanded.
+     * @selector [data-expanded]
+     */
+    isExpanded: boolean;
+    /**
+     * Whether the parent row has child rows.
+     * @selector [data-has-child-items]
+     */
+    hasChildItems: boolean;
+    /**
+     * What level the parent row has within the table.
+     * @selector [data-level]
+     */
+    level: number;
+}
+export interface CellProps extends RenderProps<CellRenderProps, 'td' | 'div'>, GlobalDOMAttributes<HTMLTableCellElement> {
+    /**
+     * 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-Cell'
+     */
+    className?: ClassNameOrFunction<CellRenderProps>;
+    /** The unique id of the cell. */
+    id?: Key;
+    /** A string representation of the cell's contents, used for features like typeahead. */
+    textValue?: string;
+    /** Indicates how many columns the data cell spans. */
+    colSpan?: number;
+}
+/**
+ * A cell within a table row.
+ */
+export declare const Cell: (props: CellProps & React.RefAttributes<HTMLDivElement | HTMLTableCellElement>) => ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface TableLoadMoreItemProps extends Omit<LoadMoreSentinelProps, 'collection'>, StyleProps, DOMRenderProps<'tr' | 'div', undefined>, GlobalDOMAttributes<HTMLTableRowElement> {
+    /**
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element.
+     * @default 'react-aria-TableLoadMoreItem'
+     */
+    className?: string;
+    /**
+     * The load more spinner to render when loading additional items.
+     */
+    children?: ReactNode;
+    /**
+     * Whether or not the loading spinner should be rendered or not.
+     */
+    isLoading?: boolean;
+}
+export declare const TableLoadMoreItem: (props: TableLoadMoreItemProps & React.RefAttributes<HTMLTableRowElement>) => ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;

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

@@ -0,0 +1,5 @@
+import { TableLayout as BaseTableLayout, TableLayoutProps } from 'react-stately/useVirtualizerState';
+import { LayoutOptionsDelegate } from './Virtualizer';
+export declare class TableLayout<T, O extends TableLayoutProps = TableLayoutProps> extends BaseTableLayout<T, O> implements LayoutOptionsDelegate<TableLayoutProps> {
+    useLayoutOptions(): TableLayoutProps;
+}

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

@@ -0,0 +1,157 @@
+import { AriaLabelingProps, FocusEvents, GlobalDOMAttributes, HoverEvents, Key, LinkDOMProps, PressEvents } from '@react-types/shared';
+import { AriaTabListProps, AriaTabPanelProps } from 'react-aria/useTabList';
+import { ClassNameOrFunction, ContextValue, DOMRenderProps, PossibleLinkDOMRenderProps, RenderProps, SlotProps, StyleProps, StyleRenderProps } from './utils';
+import { CollectionProps } from './Collection';
+import { Orientation } from '@react-types/shared';
+import React from 'react';
+import { TabListState } from 'react-stately/useTabListState';
+export interface TabsProps extends Omit<AriaTabListProps<any>, 'items' | 'children'>, RenderProps<TabsRenderProps>, 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.
+     * @default 'react-aria-Tabs'
+     */
+    className?: ClassNameOrFunction<TabsRenderProps>;
+}
+export interface TabsRenderProps {
+    /**
+     * The orientation of the tabs.
+     * @selector [data-orientation="horizontal | vertical"]
+     */
+    orientation: Orientation;
+}
+export interface TabListProps<T> extends StyleRenderProps<TabListRenderProps>, AriaLabelingProps, Omit<CollectionProps<T>, 'disabledKeys'>, 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.
+     * @default 'react-aria-TabList'
+     */
+    className?: ClassNameOrFunction<TabListRenderProps>;
+}
+export interface TabListRenderProps {
+    /**
+     * The orientation of the tab list.
+     * @selector [data-orientation="horizontal | vertical"]
+     */
+    orientation: Orientation;
+    /**
+     * State of the tab list.
+     */
+    state: TabListState<unknown>;
+}
+export interface TabProps extends Omit<RenderProps<TabRenderProps>, 'render'>, PossibleLinkDOMRenderProps<'div', TabRenderProps>, AriaLabelingProps, 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.
+     * @default 'react-aria-Tab'
+     */
+    className?: ClassNameOrFunction<TabRenderProps>;
+    /** The unique id of the tab. */
+    id?: Key;
+    /** Whether the tab is disabled. */
+    isDisabled?: boolean;
+}
+export interface TabRenderProps {
+    /**
+     * Whether the tab is currently hovered with a mouse.
+     * @selector [data-hovered]
+     */
+    isHovered: boolean;
+    /**
+     * Whether the tab is currently in a pressed state.
+     * @selector [data-pressed]
+     */
+    isPressed: boolean;
+    /**
+     * Whether the tab is currently selected.
+     * @selector [data-selected]
+     */
+    isSelected: boolean;
+    /**
+     * Whether the tab is currently focused.
+     * @selector [data-focused]
+     */
+    isFocused: boolean;
+    /**
+     * Whether the tab is currently keyboard focused.
+     * @selector [data-focus-visible]
+     */
+    isFocusVisible: boolean;
+    /**
+     * Whether the tab is disabled.
+     * @selector [data-disabled]
+     */
+    isDisabled: boolean;
+}
+export interface TabPanelProps extends AriaTabPanelProps, RenderProps<TabPanelRenderProps>, 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.
+     * @default 'react-aria-TabPanel'
+     */
+    className?: ClassNameOrFunction<TabPanelRenderProps>;
+    /**
+     * Whether to mount the tab panel in the DOM even when it is not currently selected.
+     * Inactive tab panels are inert and cannot be interacted with. They must be styled appropriately so this is clear to the user visually.
+     * @default false
+     */
+    shouldForceMount?: boolean;
+}
+export interface TabPanelRenderProps {
+    /**
+     * Whether the tab panel is currently focused.
+     * @selector [data-focused]
+     */
+    isFocused: boolean;
+    /**
+     * Whether the tab panel is currently keyboard focused.
+     * @selector [data-focus-visible]
+     */
+    isFocusVisible: boolean;
+    /**
+     * Whether the tab panel is currently non-interactive. This occurs when the
+     * `shouldForceMount` prop is true, and the corresponding tab is not selected.
+     * @selector [data-inert]
+     */
+    isInert: boolean;
+    /**
+     * Whether the tab panel is currently entering. Use this to apply animations.
+     * @selector [data-entering]
+     */
+    isEntering: boolean;
+    /**
+     * Whether the tab panel is currently exiting. Use this to apply animations.
+     * @selector [data-exiting]
+     */
+    isExiting: boolean;
+    /**
+     * State of the tab list.
+     */
+    state: TabListState<unknown>;
+}
+export declare const TabsContext: React.Context<ContextValue<TabsProps, HTMLDivElement>>;
+export declare const TabListStateContext: React.Context<TabListState<object> | null>;
+/**
+ * Tabs organize content into multiple sections and allow users to navigate between them.
+ */
+export declare const Tabs: (props: TabsProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+/**
+ * A TabList is used within Tabs to group tabs that a user can switch between.
+ * The ids of the items within the <TabList> must match up with a corresponding item inside the <TabPanels>.
+ */
+export declare const TabList: <T extends object>(props: TabListProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+/**
+ * A Tab provides a title for an individual item within a TabList.
+ */
+export declare const Tab: (props: TabProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface TabPanelsProps<T> extends Omit<CollectionProps<T>, 'disabledKeys'>, StyleProps, DOMRenderProps<'div', undefined>, GlobalDOMAttributes<HTMLDivElement> {
+    /**
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element.
+     * @default 'react-aria-TabPanels'
+     */
+    className?: string;
+}
+/**
+ * Groups multiple `<TabPanel>` elements, and provides CSS variables for animated transitions.
+ */
+export declare const TabPanels: <T extends object>(props: TabPanelsProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+/**
+ * A TabPanel provides the content for a tab.
+ */
+export declare const TabPanel: (props: TabPanelProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;

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

@@ -0,0 +1,85 @@
+import { AriaTagGroupProps } from 'react-aria/useTagGroup';
+import { ClassNameOrFunction, ContextValue, DOMProps, DOMRenderProps, RenderProps, SlotProps, StyleRenderProps } from './utils';
+import { CollectionProps, ItemRenderProps } from './Collection';
+import { FocusEvents, GlobalDOMAttributes, HoverEvents, Key, LinkDOMProps, PressEvents } from '@react-types/shared';
+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.
+     * @default 'react-aria-TagGroup'
+     */
+    className?: string;
+}
+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;
+    /**
+     * State of the TagGroup.
+     */
+    state: ListState<unknown>;
+}
+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.
+     * @default 'react-aria-TagList'
+     */
+    className?: ClassNameOrFunction<TagListRenderProps>;
+    /** Provides content to display when there are no items in the tag list. */
+    renderEmptyState?: (props: TagListRenderProps) => ReactNode;
+}
+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.
+ */
+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 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.
+     * @default 'react-aria-Tag'
+     */
+    className?: ClassNameOrFunction<TagRenderProps>;
+    /** A unique id for the tag. */
+    id?: Key;
+    /**
+     * A string representation of the tags's contents, used for accessibility.
+     * Required if children is not a plain text string.
+     */
+    textValue?: string;
+    /** 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.
+     */
+    onAction?: () => void;
+}
+/**
+ * A Tag is an individual item within a TagList.
+ */
+export declare const Tag: (props: TagProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;

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

@@ -0,0 +1,7 @@
+import { ContextValue, DOMRenderProps } from './utils';
+import React, { HTMLAttributes } from 'react';
+export interface TextProps extends HTMLAttributes<HTMLElement>, DOMRenderProps<any, any> {
+    elementType?: string;
+}
+export declare const TextContext: React.Context<ContextValue<TextProps, HTMLElement>>;
+export declare const Text: React.ForwardRefExoticComponent<TextProps & React.RefAttributes<HTMLElement>>;