react-aria-components 1.16.0 → 1.18.0

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

@@ -0,0 +1,182 @@
+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<any> | 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>(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>(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,96 @@
+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>(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>>;

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

@@ -0,0 +1,18 @@
+import { ClassNameOrFunction, ContextValue, StyleRenderProps } from './utils';
+import { HoverEvents } from '@react-types/shared';
+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.
+     *
+     * @default 'react-aria-TextArea'
+     */
+    className?: ClassNameOrFunction<InputRenderProps>;
+}
+export declare const TextAreaContext: React.Context<ContextValue<TextAreaProps, HTMLTextAreaElement>>;
+/**
+ * A textarea allows a user to input mult-line text.
+ */
+export declare const TextArea: React.ForwardRefExoticComponent<TextAreaProps & React.RefAttributes<HTMLTextAreaElement>>;

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

@@ -0,0 +1,46 @@
+import { AriaTextFieldProps } from 'react-aria/useTextField';
+import { ClassNameOrFunction, ContextValue, DOMProps, RACValidation, RenderProps, SlotProps } from './utils';
+import { GlobalDOMAttributes } from '@react-types/shared';
+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.
+     *
+     * @default 'react-aria-TextField'
+     */
+    className?: ClassNameOrFunction<TextFieldRenderProps>;
+    /** Whether the value is invalid. */
+    isInvalid?: boolean;
+}
+export declare const TextFieldContext: React.Context<ContextValue<TextFieldProps, HTMLDivElement>>;
+/**
+ * A text field allows a user to enter a plain text value with a keyboard.
+ */
+export declare const TextField: (props: TextFieldProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;

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

@@ -0,0 +1,94 @@
+import { AriaToastProps, AriaToastRegionProps } from 'react-aria/useToast';
+import { ClassNameOrFunction, ContextValue, DOMRenderProps, RenderProps, StyleRenderProps } from './utils';
+import { GlobalDOMAttributes } from '@react-types/shared';
+import { QueuedToast, ToastQueue, ToastState } from 'react-stately/useToastState';
+import React, { HTMLAttributes, ReactElement, ReactNode } from 'react';
+declare const ToastStateContext: React.Context<ToastState<any> | null>;
+export interface ToastRegionRenderProps<T> {
+    /** A list of all currently visible toasts. */
+    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.
+     *
+     * @default 'react-aria-ToastRegion'
+     */
+    className?: ClassNameOrFunction<ToastRegionRenderProps<T>>;
+    /** The queue of toasts to display. */
+    queue: ToastQueue<T>;
+    /** A function to render each toast, or children containing a `<ToastList>`. */
+    children: ReactNode | ((renderProps: {
+        toast: QueuedToast<T>;
+    }) => ReactElement);
+}
+/**
+ * A ToastRegion displays one or more toast notifications.
+ */
+declare const ToastRegion: <T>(props: ToastRegionProps<T> & React.RefAttributes<HTMLDivElement>) => ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface ToastListProps<T> extends Omit<ToastRegionProps<T>, 'queue' | 'children' | 'render'>, DOMRenderProps<'ol', ToastRegionRenderProps<T>> {
+    /** A function to render each toast. */
+    children: (renderProps: {
+        toast: QueuedToast<T>;
+    }) => ReactElement;
+}
+declare const ToastList: <T>(props: ToastListProps<T> & React.RefAttributes<HTMLOListElement>) => ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface ToastRenderProps<T> {
+    /**
+     * The toast object to display.
+     */
+    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.
+     *
+     * @default 'react-aria-Toast'
+     */
+    className?: ClassNameOrFunction<ToastRenderProps<T>>;
+}
+/**
+ * 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> {
+}
+export declare const ToastContentContext: React.Context<ContextValue<HTMLAttributes<HTMLElement>, HTMLDivElement>>;
+/**
+ * ToastContent wraps the main content of a toast notification.
+ */
+export declare const ToastContent: React.ForwardRefExoticComponent<ToastContentProps & React.RefAttributes<HTMLDivElement>>;
+export { Toast as UNSTABLE_Toast, ToastList as UNSTABLE_ToastList, ToastRegion as UNSTABLE_ToastRegion, ToastContent as UNSTABLE_ToastContent, ToastStateContext as UNSTABLE_ToastStateContext };

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

@@ -0,0 +1,39 @@
+import { AriaToggleButtonProps } from 'react-aria/useToggleButton';
+import { ButtonRenderProps } from './Button';
+import { ClassNameOrFunction, ContextValue, RenderProps, SlotProps } from './utils';
+import { GlobalDOMAttributes, Key } from '@react-types/shared';
+import { HoverEvents } from '@react-types/shared';
+import React from 'react';
+import { ToggleState } from 'react-stately/useToggleState';
+export interface ToggleButtonRenderProps extends Omit<ButtonRenderProps, 'isPending'> {
+    /**
+     * Whether the button is currently selected.
+     *
+     * @selector [data-selected]
+     */
+    isSelected: boolean;
+    /**
+     * State of the toggle button.
+     */
+    state: ToggleState;
+}
+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.
+     *
+     * @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.
+     */
+    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.
+ */
+export declare const ToggleButton: (props: ToggleButtonProps & React.RefAttributes<HTMLButtonElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;

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

@@ -0,0 +1,39 @@
+import { AriaToggleButtonGroupProps } from 'react-aria/useToggleButtonGroup';
+import { ClassNameOrFunction, ContextValue, RenderProps, SlotProps } from './utils';
+import { GlobalDOMAttributes, Orientation } from '@react-types/shared';
+import React from 'react';
+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;
+    /**
+     * State of the toggle button group.
+     */
+    state: ToggleGroupState;
+}
+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.
+     *
+     * @default 'react-aria-ToggleButtonGroup'
+     */
+    className?: ClassNameOrFunction<ToggleButtonGroupRenderProps>;
+}
+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.
+ */
+export declare const ToggleButtonGroup: (props: ToggleButtonGroupProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;

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

@@ -0,0 +1,27 @@
+import { AriaToolbarProps } from 'react-aria/useToolbar';
+import { ClassNameOrFunction, ContextValue, RenderProps, SlotProps } from './utils';
+import { GlobalDOMAttributes, Orientation } from '@react-types/shared';
+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.
+     *
+     * @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.
+ */
+export declare const Toolbar: (props: ToolbarProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;

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

@@ -0,0 +1,83 @@
+import { AriaLabelingProps, GlobalDOMAttributes, RefObject } from '@react-types/shared';
+import { AriaPositionProps, Placement, PlacementAxis, PositionProps } from 'react-aria/useOverlayPosition';
+import { ClassNameOrFunction, ContextValue, RenderProps } from './utils';
+import { OverlayTriggerProps } from 'react-stately/useOverlayTriggerState';
+import React, { JSX, ReactNode } from 'react';
+import { TooltipTriggerProps, TooltipTriggerState } from 'react-stately/useTooltipTriggerState';
+export interface TooltipTriggerComponentProps extends TooltipTriggerProps {
+    children: ReactNode;
+}
+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.
+     *
+     * @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.
+     */
+    triggerRef?: RefObject<Element | null>;
+    /**
+     * Whether the tooltip is currently performing an entry animation.
+     */
+    isEntering?: boolean;
+    /**
+     * Whether the tooltip is currently performing an exit animation.
+     */
+    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.
+     *
+     * @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;
+}
+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;
+    /**
+     * State of the tooltip.
+     */
+    state: TooltipTriggerState;
+}
+export declare const TooltipTriggerStateContext: React.Context<TooltipTriggerState | null>;
+export declare const TooltipContext: React.Context<ContextValue<TooltipProps, HTMLDivElement>>;
+/**
+ * TooltipTrigger wraps around a trigger element and a Tooltip. It handles opening and closing
+ * the Tooltip when the user hovers over or focuses the trigger, and positioning the Tooltip
+ * relative to the trigger.
+ */
+export declare function TooltipTrigger(props: TooltipTriggerComponentProps): JSX.Element;
+/**
+ * A tooltip displays a description of an element on hover or focus.
+ */
+export declare const Tooltip: (props: TooltipProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;