@depup/react-aria-components 1.16.0-depup.0 → 1.20.0-depup.0

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;

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

@@ -0,0 +1,202 @@
+import { AriaTreeItemOptions } from 'react-aria/useTree';
+import { AriaTreeProps } from 'react-aria/useTree';
+import { ChildrenOrFunction, ClassNameOrFunction, ContextValue, DOMRenderProps, RenderProps, SlotProps, StyleRenderProps } from './utils';
+import { CollectionProps, ItemRenderProps, SectionProps } from './Collection';
+import { DisabledBehavior, Expandable, GlobalDOMAttributes, HoverEvents, Key, LinkDOMProps, MultipleSelection, PressEvents, SelectionMode } from '@react-types/shared';
+import { DragAndDropHooks } from './useDragAndDrop';
+import { GridListHeaderProps } from './GridList';
+import { LoadMoreSentinelProps } from 'react-aria/private/utils/useLoadMoreSentinel';
+import { SelectionBehavior } from '@react-types/shared';
+import React, { ReactNode } from 'react';
+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.
+     */
+    state: TreeState<unknown>;
+}
+export interface TreeEmptyStateRenderProps extends Omit<TreeRenderProps, 'isEmpty'> {
+}
+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.
+     *
+     * @default 'react-aria-Tree'
+     */
+    className?: ClassNameOrFunction<TreeRenderProps>;
+    /**
+     * How multiple selection should behave in the tree.
+     *
+     * @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.
+     */
+    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.
+ */
+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;
+    /** The state of the tree. */
+    state: TreeState<unknown>;
+    /** The unique id of the tree row. */
+    id: Key;
+}
+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.
+     */
+    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' | 'focusMode' | 'allowsArrowNavigation'>, 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-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.
+     */
+    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.
+     */
+    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.
+     */
+    onAction?: () => void;
+}
+/**
+ * A TreeItem represents an individual item in a Tree.
+ */
+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' | 'direction'>, 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.
+     *
+     * @default 'react-aria-TreeLoadMoreItem'
+     */
+    className?: ClassNameOrFunction<TreeLoadMoreItemRenderProps>;
+    /**
+     * The load more spinner to render when loading additional items.
+     */
+    children?: ChildrenOrFunction<TreeLoadMoreItemRenderProps>;
+    /**
+     * Whether or not the loading spinner should be rendered or not.
+     */
+    isLoading?: boolean;
+}
+export declare const TreeLoadMoreItem: <T>(props: TreeLoadMoreItemProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface TreeSectionProps<T> extends SectionProps<T>, DOMRenderProps<'div', undefined> {
+}
+/**
+ * A TreeSection represents a section within a Tree.
+ */
+export declare const TreeSection: <T extends unknown>(props: TreeSectionProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface TreeHeaderProps extends GridListHeaderProps {
+}
+export declare const TreeHeader: (props: TreeHeaderProps) => ReactNode;

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

@@ -0,0 +1,23 @@
+import { Direction, DropTarget, DropTargetDelegate, Key, Node } from '@react-types/shared';
+interface TreeCollection<T> extends Iterable<Node<T>> {
+    getItem(key: Key): Node<T> | null;
+    getChildren?(key: Key): Iterable<Node<T>>;
+    getKeyAfter(key: Key): Key | null;
+    getKeyBefore(key: Key): Key | null;
+}
+interface TreeState<T> {
+    collection: TreeCollection<T>;
+    expandedKeys: Set<Key>;
+}
+export declare class TreeDropTargetDelegate<T> {
+    private delegate;
+    private state;
+    private direction;
+    private pointerTracking;
+    setup(delegate: DropTargetDelegate, state: TreeState<T>, direction: Direction): void;
+    getDropTargetFromPoint(x: number, y: number, isValidDropTarget: (target: DropTarget) => boolean): DropTarget | null;
+    private resolveDropTarget;
+    private getPotentialTargets;
+    private selectTarget;
+}
+export {};

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

@@ -0,0 +1,30 @@
+import { DropTargetDelegate, Node } from '@react-types/shared';
+import { Layout } from 'react-stately/useVirtualizerState';
+import { JSX, ReactNode } from 'react';
+export interface LayoutOptionsDelegate<O> {
+    useLayoutOptions?(): O;
+}
+interface ILayout<O> extends Layout<Node<unknown>, O>, Partial<DropTargetDelegate>, LayoutOptionsDelegate<O> {
+}
+interface LayoutClass<O> {
+    new (): ILayout<O>;
+}
+export interface VirtualizerProps<O> {
+    /** The child collection to virtualize (e.g. ListBox, GridList, or Table). */
+    children: ReactNode;
+    /** The layout object that determines the position and size of the visible elements. */
+    layout: LayoutClass<O> | ILayout<O>;
+    /** Options for the layout. */
+    layoutOptions?: O;
+    /**
+     * Whether to observe each item's size with a ResizeObserver and re-measure when it changes.
+     */
+    shouldObserveItemSize?: boolean;
+}
+/**
+ * A Virtualizer renders a scrollable collection of data using customizable layouts.
+ * It supports very large collections by only rendering visible items to the DOM, reusing
+ * them as the user scrolls.
+ */
+export declare function Virtualizer<O>(props: VirtualizerProps<O>): JSX.Element;
+export {};

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

@@ -0,0 +1,74 @@
+import { DropIndicatorProps as AriaDropIndicatorProps, DropIndicatorAria, DroppableCollectionOptions, DroppableCollectionResult, DroppableItemOptions, DroppableItemResult } from 'react-aria/useDroppableCollection';
+import { DraggableCollectionOptions, DraggableItemProps, DraggableItemResult, DragPreview } from 'react-aria/useDraggableCollection';
+import { DraggableCollectionProps, DroppableCollectionProps, Key, RefObject } from '@react-types/shared';
+import { DraggableCollectionState, DraggableCollectionStateOptions } from 'react-stately/useDraggableCollectionState';
+import { DragItem, DropTarget, DropTargetDelegate } from '@react-types/shared';
+import { DroppableCollectionState, DroppableCollectionStateOptions } from 'react-stately/useDroppableCollectionState';
+import { JSX } from 'react';
+import { ListDropTargetDelegate } from 'react-aria/ListDropTargetDelegate';
+export { DropIndicator, DropIndicatorContext, DragAndDropContext } from './DragAndDrop';
+export type { DropIndicatorProps, DropIndicatorRenderProps } from './DragAndDrop';
+interface DraggableCollectionStateOpts<T = object> extends Omit<DraggableCollectionStateOptions<T>, 'getItems'> {
+}
+interface DragHooks<T = object> {
+    useDraggableCollectionState?: (props: DraggableCollectionStateOpts<T>) => DraggableCollectionState;
+    useDraggableCollection?: (props: DraggableCollectionOptions, state: DraggableCollectionState, ref: RefObject<HTMLElement | null>) => void;
+    useDraggableItem?: (props: DraggableItemProps, state: DraggableCollectionState) => DraggableItemResult;
+    DragPreview?: typeof DragPreview;
+    renderDragPreview?: (items: DragItem[]) => JSX.Element | {
+        element: JSX.Element;
+        x: number;
+        y: number;
+    };
+    isVirtualDragging?: () => boolean;
+}
+interface DropHooks {
+    useDroppableCollectionState?: (props: DroppableCollectionStateOptions) => DroppableCollectionState;
+    useDroppableCollection?: (props: DroppableCollectionOptions, state: DroppableCollectionState, ref: RefObject<HTMLElement | null>) => DroppableCollectionResult;
+    useDroppableItem?: (options: DroppableItemOptions, state: DroppableCollectionState, ref: RefObject<HTMLElement | null>) => DroppableItemResult;
+    useDropIndicator?: (props: AriaDropIndicatorProps, state: DroppableCollectionState, ref: RefObject<HTMLElement | null>) => DropIndicatorAria;
+    renderDropIndicator?: (target: DropTarget) => JSX.Element;
+    dropTargetDelegate?: DropTargetDelegate;
+    ListDropTargetDelegate: typeof ListDropTargetDelegate;
+}
+export type DragAndDropHooks<T = object> = DragHooks<T> & DropHooks;
+export interface DragAndDrop<T = object> {
+    /** 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.
+     *
+     * @default () => []
+     */
+    getItems?: (keys: Set<Key>, items: T[]) => DragItem[];
+    /**
+     * A function that renders a drag preview, which is shown under the user's cursor while dragging.
+     * By default, a copy of the dragged element is rendered.
+     */
+    renderDragPreview?: (items: DragItem[]) => JSX.Element | {
+        element: JSX.Element;
+        x: number;
+        y: number;
+    };
+    /**
+     * A function that renders a drop indicator element between two items in a collection.
+     * This should render a `<DropIndicator>` element. If this function is not provided, a
+     * default DropIndicator is provided.
+     */
+    renderDropIndicator?: (target: DropTarget) => JSX.Element;
+    /**
+     * 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.
+ */
+export declare function useDragAndDrop<T = object>(options: DragAndDropOptions<T>): DragAndDrop<T>;

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

@@ -0,0 +1,233 @@
+import { AriaLabelingProps, RefObject, DOMProps as SharedDOMProps } from '@react-types/shared';
+import React, { AnchorHTMLAttributes, Context, CSSProperties, DetailedHTMLProps, ForwardedRef, JSX, ReactElement, ReactNode, RefCallback } from 'react';
+export declare const DEFAULT_SLOT: unique symbol;
+interface SlottedValue<T> {
+    slots?: Record<string | symbol, T>;
+}
+export type SlottedContextValue<T> = SlottedValue<T> | T | null | undefined;
+export type ContextValue<T, E> = SlottedContextValue<WithRef<T, E>>;
+type ProviderValue<T> = [Context<T>, T];
+type ProviderValues<A, B, C, D, E, F, G, H, I, J, K, L, M> = [ProviderValue<A>] | [ProviderValue<A>, ProviderValue<B>] | [ProviderValue<A>, ProviderValue<B>, ProviderValue<C>] | [ProviderValue<A>, ProviderValue<B>, ProviderValue<C>, ProviderValue<D>] | [ProviderValue<A>, ProviderValue<B>, ProviderValue<C>, ProviderValue<D>, ProviderValue<E>] | [
+    ProviderValue<A>,
+    ProviderValue<B>,
+    ProviderValue<C>,
+    ProviderValue<D>,
+    ProviderValue<E>,
+    ProviderValue<F>
+] | [
+    ProviderValue<A>,
+    ProviderValue<B>,
+    ProviderValue<C>,
+    ProviderValue<D>,
+    ProviderValue<E>,
+    ProviderValue<F>,
+    ProviderValue<G>
+] | [
+    ProviderValue<A>,
+    ProviderValue<B>,
+    ProviderValue<C>,
+    ProviderValue<D>,
+    ProviderValue<E>,
+    ProviderValue<F>,
+    ProviderValue<G>,
+    ProviderValue<H>
+] | [
+    ProviderValue<A>,
+    ProviderValue<B>,
+    ProviderValue<C>,
+    ProviderValue<D>,
+    ProviderValue<E>,
+    ProviderValue<F>,
+    ProviderValue<G>,
+    ProviderValue<H>,
+    ProviderValue<I>
+] | [
+    ProviderValue<A>,
+    ProviderValue<B>,
+    ProviderValue<C>,
+    ProviderValue<D>,
+    ProviderValue<E>,
+    ProviderValue<F>,
+    ProviderValue<G>,
+    ProviderValue<H>,
+    ProviderValue<I>,
+    ProviderValue<J>
+] | [
+    ProviderValue<A>,
+    ProviderValue<B>,
+    ProviderValue<C>,
+    ProviderValue<D>,
+    ProviderValue<E>,
+    ProviderValue<F>,
+    ProviderValue<G>,
+    ProviderValue<H>,
+    ProviderValue<I>,
+    ProviderValue<J>,
+    ProviderValue<K>
+] | [
+    ProviderValue<A>,
+    ProviderValue<B>,
+    ProviderValue<C>,
+    ProviderValue<D>,
+    ProviderValue<E>,
+    ProviderValue<F>,
+    ProviderValue<G>,
+    ProviderValue<H>,
+    ProviderValue<I>,
+    ProviderValue<J>,
+    ProviderValue<K>,
+    ProviderValue<L>
+] | [
+    ProviderValue<A>,
+    ProviderValue<B>,
+    ProviderValue<C>,
+    ProviderValue<D>,
+    ProviderValue<E>,
+    ProviderValue<F>,
+    ProviderValue<G>,
+    ProviderValue<H>,
+    ProviderValue<I>,
+    ProviderValue<J>,
+    ProviderValue<K>,
+    ProviderValue<L>,
+    ProviderValue<M>
+];
+interface ProviderProps<A, B, C, D, E, F, G, H, I, J, K, L, M> {
+    values: ProviderValues<A, B, C, D, E, F, G, H, I, J, K, L, M>;
+    children: ReactNode;
+}
+export declare function Provider<A, B, C, D, E, F, G, H, I, J, K, L, M>({ values, children }: ProviderProps<A, B, C, D, E, F, G, H, I, J, K, L, M>): JSX.Element;
+export interface StyleProps {
+    /**
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
+     * element.
+     */
+    className?: string;
+    /**
+     * The inline [style](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/style) for the
+     * element.
+     */
+    style?: CSSProperties;
+}
+export interface DOMProps extends StyleProps, SharedDOMProps {
+    /** The children of the component. */
+    children?: ReactNode;
+}
+export type ClassNameOrFunction<T> = string | ((values: T & {
+    defaultClassName: string | undefined;
+}) => string);
+export type StyleOrFunction<T> = CSSProperties | ((values: T & {
+    defaultStyle: CSSProperties;
+}) => CSSProperties | undefined);
+export interface StyleRenderProps<T, E extends keyof React.JSX.IntrinsicElements = 'div'> extends DOMRenderProps<E, T> {
+    /**
+     * 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.
+     */
+    className?: ClassNameOrFunction<T>;
+    /**
+     * The inline [style](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/style) for the
+     * element. A function may be provided to compute the style based on component state.
+     */
+    style?: StyleOrFunction<T>;
+}
+export type ChildrenOrFunction<T> = ReactNode | ((values: T & {
+    defaultChildren: ReactNode | undefined;
+}) => ReactNode);
+export interface RenderProps<T, E extends keyof React.JSX.IntrinsicElements = 'div'> extends StyleRenderProps<T, E> {
+    /**
+     * The children of the component. A function may be provided to alter the children based on
+     * component state.
+     */
+    children?: ChildrenOrFunction<T>;
+}
+interface RenderPropsHookOptions<T, E extends keyof React.JSX.IntrinsicElements> extends RenderProps<T, E>, SharedDOMProps, AriaLabelingProps {
+    values: T;
+    defaultChildren?: ReactNode;
+    defaultClassName?: string;
+    defaultStyle?: CSSProperties;
+}
+interface RenderPropsHookRetVal<T, E extends keyof React.JSX.IntrinsicElements> {
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+    'data-rac': string;
+    render?: DOMRenderFunction<E, T>;
+}
+export declare function useRenderProps<T, E extends keyof React.JSX.IntrinsicElements>(props: RenderPropsHookOptions<T, E>): RenderPropsHookRetVal<T, E>;
+/**
+ * A helper function that accepts a user-provided render prop value (either a static value or a
+ * function), and combines it with another value to create a final result.
+ */
+export declare function composeRenderProps<T, U, V extends T>(value: T extends any ? T | ((renderProps: U) => V) : never, wrap: (prevValue: T, renderProps: U) => V): (renderProps: U) => V;
+export type WithRef<T, E> = T & {
+    ref?: ForwardedRef<E>;
+};
+export interface SlotProps {
+    /**
+     * A slot name for the component. Slots allow the component to receive props from a parent
+     * component. An explicit `null` value indicates that the local props completely override all
+     * props received from a parent.
+     */
+    slot?: string | null;
+}
+export declare function useSlottedContext<T>(context: Context<SlottedContextValue<T>>, slot?: string | null): T | null | undefined;
+export declare function useContextProps<T, U extends SlotProps, E extends Element>(props: T & SlotProps, ref: ForwardedRef<E> | undefined, context: Context<ContextValue<U, E>>): [T, RefObject<E | null>];
+export declare function useSlot(initialState?: boolean | (() => boolean)): [RefCallback<Element>, boolean];
+/**
+ * Filters out `data-*` attributes to keep them from being passed down and duplicated.
+ *
+ * @param props
+ */
+export declare function removeDataAttributes<T>(props: T): T;
+export interface RACValidation {
+    /**
+     * Whether to use native HTML form validation to prevent form submission
+     * when the value is missing or invalid, or mark the field as required
+     * or invalid via ARIA.
+     *
+     * @default 'native'
+     */
+    validationBehavior?: 'native' | 'aria';
+}
+export type DOMRenderFunction<E extends keyof React.JSX.IntrinsicElements, T> = (props: React.JSX.IntrinsicElements[E], renderProps: T) => ReactElement;
+export interface DOMRenderProps<E extends keyof React.JSX.IntrinsicElements, T> {
+    /**
+     * Overrides the default DOM element with a custom render function.
+     * This allows rendering existing components with built-in styles and behaviors
+     * such as router links, animation libraries, and pre-styled components.
+     *
+     * Requirements:
+     *
+     * - You must render the expected element type (e.g. if `<button>` is expected, you cannot render an
+     *   `<a>`).
+     * - Only a single root DOM element can be rendered (no fragments).
+     * - You must pass through props and ref to the underlying DOM element, merging with your own prop
+     *   as appropriate.
+     */
+    render?: DOMRenderFunction<E, T>;
+}
+type LinkWithRequiredHref = Required<Pick<AnchorHTMLAttributes<HTMLAnchorElement>, 'href'>> & Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'href'>;
+export interface PossibleLinkDOMRenderProps<Fallback extends keyof React.JSX.IntrinsicElements, T> {
+    /**
+     * Overrides the default DOM element with a custom render function.
+     * This allows rendering existing components with built-in styles and behaviors
+     * such as router links, animation libraries, and pre-styled components.
+     *
+     * Note: You can check if `'href' in props` in order to tell whether to render an `<a>` element.
+     *
+     * Requirements:
+     *
+     * - You must render the expected element type (e.g. if `<a>` is expected, you cannot render a
+     *   `<button>`).
+     * - Only a single root DOM element can be rendered (no fragments).
+     * - You must pass through props and ref to the underlying DOM element, merging with your own prop
+     *   as appropriate.
+     */
+    render?: (props: DetailedHTMLProps<LinkWithRequiredHref, HTMLAnchorElement> | React.JSX.IntrinsicElements[Fallback], renderProps: T) => ReactElement;
+}
+type DOMComponents = {
+    [E in keyof React.JSX.IntrinsicElements]: (props: DOMRenderProps<E, any> & React.JSX.IntrinsicElements[E]) => ReactElement;
+};
+export declare const dom: DOMComponents;
+export {};