react-aria-components 1.16.0 → 1.17.0

package/dist/types.d.ts

@@ -1,3764 +0,0 @@
-import { AriaLabelingProps, RefObject, DOMProps as _DOMProps1, GlobalDOMAttributes, ValidationResult, HoverEvents as _HoverEvents1, InputDOMProps, FocusableElement, FocusEvents, KeyboardEvents, Node, ValueBase, CollectionBase, DropTargetDelegate, ItemDropTarget, Key, LayoutDelegate, DraggableCollectionProps, DroppableCollectionProps, LinkDOMProps, PressEvents, MultipleSelection, Orientation as _Orientation2, DisabledBehavior as _DisabledBehavior1, Expandable, SelectionMode as _SelectionMode3 } from "@react-types/shared";
-import React, { AnchorHTMLAttributes, Context, CSSProperties, DetailedHTMLProps, ForwardedRef, JSX, ReactElement, ReactNode, HTMLAttributes, LabelHTMLAttributes, InputHTMLAttributes, OutputHTMLAttributes, TextareaHTMLAttributes } from "react";
-import { FormProps as _FormProps1 } from "@react-types/form";
-import { AriaCheckboxGroupProps, AriaCheckboxProps, HoverEvents, AriaColorAreaProps, HoverProps, AriaColorFieldProps, AriaSliderProps, AriaSliderThumbProps, Orientation, AriaColorSliderProps, AriaColorWheelOptions, AriaLinkOptions, AriaBreadcrumbsProps, AriaProgressBarProps, AriaButtonProps, AriaCalendarProps, AriaRangeCalendarProps, DateValue, AriaColorSwatchProps, DropIndicatorProps as _DropIndicatorProps1, DraggableCollectionOptions, DraggableItemProps, DraggableItemResult, DragItem, DragPreview, DropIndicatorAria, DroppableCollectionOptions, DroppableCollectionResult, DroppableItemOptions, DroppableItemResult, DropTarget, DropTargetDelegate as _DropTargetDelegate1, ListDropTargetDelegate, SeparatorProps as _SeparatorProps1, AriaListBoxProps, PlacementAxis, AriaPopoverProps, PositionProps, AriaMenuProps, AriaDialogProps, AriaComboBoxProps, AriaDateFieldProps, AriaTimeFieldProps, TimeValue, AriaDatePickerProps, AriaDateRangePickerProps, AriaDisclosureProps, LabelAriaProps, DropOptions, AriaGridListProps, AriaMeterProps, AriaModalOverlayProps, AriaNumberFieldProps, AriaRadioGroupProps, AriaRadioProps, AriaSearchFieldProps, AriaSelectProps, AriaSwitchProps, AriaTabListProps, AriaTabPanelProps, AriaTagGroupProps, AriaTextFieldProps as _AriaTextFieldProps1, AriaToastProps, AriaToastRegionProps, AriaToggleButtonGroupProps, AriaToggleButtonProps, AriaPositionProps, Placement, AriaTreeItemOptions, AriaTreeProps } from "react-aria";
-import { CheckboxGroupState, Color, ColorAreaState, ColorChannel, ColorFieldState, ColorSpace, SliderState, ColorSliderState, ColorWheelState, Collection, Node as _Node1, SelectionBehavior, SelectionMode as _SelectionMode2, SectionProps as _SectionProps1, CalendarState, RangeCalendarState, DraggableCollectionState, DraggableCollectionStateOptions, DroppableCollectionState, DroppableCollectionStateOptions, ListState, Orientation as _Orientation1, ColorPickerState, ColorPickerProps as _ColorPickerProps1, OverlayTriggerProps, MenuTriggerProps as _MenuTriggerProps1, RootMenuTriggerState, TreeState, OverlayTriggerState, ComboBoxState, DateFieldState, DateSegmentType, DateSegment as _DateSegment1, TimeFieldState, DatePickerState, DatePickerStateOptions, DateRangePickerState, DateRangePickerStateOptions, DisclosureGroupState, DisclosureState, DisclosureGroupProps as _DisclosureGroupProps1, NumberFieldState, RadioGroupState, SearchFieldState, SelectState, ToggleState, DisabledBehavior, SortDirection, TableState, TabListState, QueuedToast, ToastQueue, ToastState, ToggleGroupState, TooltipTriggerProps, TooltipTriggerState } from "react-stately";
-import { AriaTextFieldProps } from "@react-aria/textfield";
-import { AriaAutocompleteProps } from "@react-aria/autocomplete";
-import { AutocompleteState } from "@react-stately/autocomplete";
-import { CalendarDate, CalendarIdentifier, DateDuration, Calendar as _Calendar1 } from "@internationalized/date";
-import { DateValue as _DateValue1 } from "@react-types/calendar";
-import { LoadMoreSentinelProps } from "@react-aria/utils";
-import { TableColumnResizeState } from "@react-stately/table";
-import { ColumnSize, ColumnStaticSize, TableProps as _TableProps1 } from "@react-types/table";
-import { Layout } from "@react-stately/virtualizer";
-import { TableLayout as _TableLayout1, TableLayoutProps } from "@react-stately/layout";
-import { AriaToolbarProps } from "@react-aria/toolbar";
-export const DEFAULT_SLOT: unique symbol;
-interface SlottedValue<T> {
-    slots?: Record<string | symbol, T>;
-}
-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> = [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>];
-interface ProviderProps<A, B, C, D, E, F, G, H, I, J, K, L> {
-    values: ProviderValues<A, B, C, D, E, F, G, H, I, J, K, L>;
-    children: ReactNode;
-}
-export function Provider<A, B, C, D, E, F, G, H, I, J, K, L>({ values, children }: ProviderProps<A, B, C, D, E, F, G, H, I, J, K, L>): JSX.Element;
-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;
-}
-interface DOMProps extends StyleProps, _DOMProps1 {
-    /** The children of the component. */
-    children?: ReactNode;
-}
-type ClassNameOrFunction<T> = string | ((values: T & {
-    defaultClassName: string | undefined;
-}) => string);
-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>;
-}
-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>, _DOMProps1, 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 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 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;
-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 function useSlottedContext<T>(context: Context<SlottedContextValue<T>>, slot?: string | null): T | null | undefined;
-export 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>];
-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';
-}
-type DOMRenderFunction<E extends keyof React.JSX.IntrinsicElements, T> = (props: React.JSX.IntrinsicElements[E], renderProps: T) => ReactElement;
-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'>;
-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;
-}
-export interface TextProps extends HTMLAttributes<HTMLElement>, DOMRenderProps<any, any> {
-    elementType?: string;
-}
-export const TextContext: React.Context<ContextValue<TextProps, HTMLElement>>;
-export const Text: React.ForwardRefExoticComponent<TextProps & React.RefAttributes<HTMLElement>>;
-export const FieldErrorContext: React.Context<ValidationResult | null>;
-export interface FieldErrorRenderProps extends ValidationResult {
-}
-export interface FieldErrorProps extends RenderProps<FieldErrorRenderProps>, _DOMProps1, 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-FieldError'
-     */
-    className?: ClassNameOrFunction<FieldErrorRenderProps>;
-}
-/**
- * A FieldError displays validation errors for a form field.
- */
-export const FieldError: React.ForwardRefExoticComponent<FieldErrorProps & React.RefAttributes<HTMLElement>>;
-export interface FormProps extends _FormProps1, DOMProps, DOMRenderProps<'form', undefined>, GlobalDOMAttributes<HTMLFormElement> {
-    /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element.
-     * @default 'react-aria-Form'
-     */
-    className?: string;
-    /**
-     * Whether to use native HTML form validation to prevent form submission
-     * when a field value is missing or invalid, or mark fields as required
-     * or invalid via ARIA.
-     * @default 'native'
-     */
-    validationBehavior?: 'aria' | 'native';
-}
-export const FormContext: React.Context<ContextValue<FormProps, HTMLFormElement>>;
-/**
- * A form is a group of inputs that allows users to submit data to a server,
- * with support for providing field validation errors.
- */
-export const Form: React.ForwardRefExoticComponent<FormProps & React.RefAttributes<HTMLFormElement>>;
-export interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement>, DOMRenderProps<'label', undefined> {
-    elementType?: string;
-}
-export const LabelContext: React.Context<ContextValue<LabelProps, HTMLLabelElement>>;
-export const Label: (props: LabelProps & React.RefAttributes<HTMLLabelElement>) => React.ReactElement | null;
-export interface CheckboxGroupProps extends Omit<AriaCheckboxGroupProps, 'children' | 'label' | 'description' | 'errorMessage' | 'validationState' | 'validationBehavior'>, RACValidation, RenderProps<CheckboxGroupRenderProps, 'div'>, 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-CheckboxGroup'
-     */
-    className?: ClassNameOrFunction<CheckboxGroupRenderProps>;
-}
-export interface CheckboxProps extends Omit<AriaCheckboxProps, 'children' | 'validationState' | 'validationBehavior'>, HoverEvents, RACValidation, RenderProps<CheckboxRenderProps, 'label'>, SlotProps, Omit<GlobalDOMAttributes<HTMLLabelElement>, '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-Checkbox'
-     */
-    className?: ClassNameOrFunction<CheckboxRenderProps>;
-    /**
-     * A ref for the HTML input element.
-     */
-    inputRef?: RefObject<HTMLInputElement | null>;
-}
-export interface CheckboxGroupRenderProps {
-    /**
-     * Whether the checkbox group is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the checkbox group is read only.
-     * @selector [data-readonly]
-     */
-    isReadOnly: boolean;
-    /**
-     * Whether the checkbox group is required.
-     * @selector [data-required]
-     */
-    isRequired: boolean;
-    /**
-     * Whether the checkbox group is invalid.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-    /**
-     * State of the checkbox group.
-     */
-    state: CheckboxGroupState;
-}
-export interface CheckboxRenderProps {
-    /**
-     * Whether the checkbox is selected.
-     * @selector [data-selected]
-     */
-    isSelected: boolean;
-    /**
-     * Whether the checkbox is indeterminate.
-     * @selector [data-indeterminate]
-     */
-    isIndeterminate: boolean;
-    /**
-     * Whether the checkbox is currently hovered with a mouse.
-     * @selector [data-hovered]
-     */
-    isHovered: boolean;
-    /**
-     * Whether the checkbox is currently in a pressed state.
-     * @selector [data-pressed]
-     */
-    isPressed: boolean;
-    /**
-     * Whether the checkbox is focused, either via a mouse or keyboard.
-     * @selector [data-focused]
-     */
-    isFocused: boolean;
-    /**
-     * Whether the checkbox is keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the checkbox is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the checkbox is read only.
-     * @selector [data-readonly]
-     */
-    isReadOnly: boolean;
-    /**
-     * Whether the checkbox invalid.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-    /**
-     * Whether the checkbox is required.
-     * @selector [data-required]
-     */
-    isRequired: boolean;
-}
-export const CheckboxGroupContext: React.Context<ContextValue<CheckboxGroupProps, HTMLDivElement>>;
-export const CheckboxGroupStateContext: React.Context<CheckboxGroupState | null>;
-/**
- * A checkbox group allows a user to select multiple items from a list of options.
- */
-export const CheckboxGroup: (props: CheckboxGroupProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-/**
- * A checkbox allows a user to select multiple items from a list of individual items, or
- * to mark one individual item as selected.
- */
-export const Checkbox: (props: CheckboxProps & React.RefAttributes<HTMLLabelElement>) => React.ReactElement | null;
-export interface ColorThumbRenderProps {
-    /**
-     * The selected color, excluding the alpha channel.
-     */
-    color: Color;
-    /**
-     * Whether this thumb is currently being dragged.
-     * @selector [data-dragging]
-     */
-    isDragging: boolean;
-    /**
-     * Whether the thumb is currently hovered with a mouse.
-     * @selector [data-hovered]
-     */
-    isHovered: boolean;
-    /**
-     * Whether the thumb is currently focused.
-     * @selector [data-focused]
-     */
-    isFocused: boolean;
-    /**
-     * Whether the thumb is keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the thumb is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-}
-export interface ColorThumbProps extends _HoverEvents1, RenderProps<ColorThumbRenderProps>, 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-ColorThumb'
-     */
-    className?: ClassNameOrFunction<ColorThumbRenderProps>;
-}
-/**
- * A color thumb appears within a ColorArea, ColorSlider, or ColorWheel and allows a user to drag to adjust the color value.
- */
-export const ColorThumb: React.ForwardRefExoticComponent<ColorThumbProps & React.RefAttributes<HTMLDivElement>>;
-export interface ColorAreaRenderProps {
-    /**
-     * Whether the color area is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * State of the color area.
-     */
-    state: ColorAreaState;
-}
-export interface ColorAreaProps extends AriaColorAreaProps, RenderProps<ColorAreaRenderProps>, 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-ColorArea'
-     */
-    className?: ClassNameOrFunction<ColorAreaRenderProps>;
-}
-export const ColorAreaStateContext: React.Context<ColorAreaState | null>;
-/**
- * A color area allows users to adjust two channels of an RGB, HSL or HSB color value against a two-dimensional gradient background.
- */
-export const ColorArea: React.ForwardRefExoticComponent<ColorAreaProps & React.RefAttributes<HTMLDivElement>>;
-export interface GroupRenderProps {
-    /**
-     * Whether the group is currently hovered with a mouse.
-     * @selector [data-hovered]
-     */
-    isHovered: boolean;
-    /**
-     * Whether an element within the group is focused, either via a mouse or keyboard.
-     * @selector [data-focus-within]
-     */
-    isFocusWithin: boolean;
-    /**
-     * Whether an element within the group is keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the group is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the group is invalid.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-}
-export interface GroupProps extends AriaLabelingProps, Omit<HTMLAttributes<HTMLElement>, 'children' | 'className' | 'style' | 'render' | 'role' | 'slot'>, _DOMProps1, HoverProps, RenderProps<GroupRenderProps>, SlotProps {
-    /**
-     * 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-Group'
-     */
-    className?: ClassNameOrFunction<GroupRenderProps>;
-    /** Whether the group is disabled. */
-    isDisabled?: boolean;
-    /** Whether the group is invalid. */
-    isInvalid?: boolean;
-    /** Whether the group is read only. */
-    isReadOnly?: boolean;
-    /**
-     * An accessibility role for the group. By default, this is set to `'group'`.
-     * Use `'region'` when the contents of the group is important enough to be
-     * included in the page table of contents. Use `'presentation'` if the group
-     * is visual only and does not represent a semantic grouping of controls.
-     * @default 'group'
-     */
-    role?: 'group' | 'region' | 'presentation';
-}
-export const GroupContext: React.Context<ContextValue<GroupProps, HTMLDivElement>>;
-/**
- * A group represents a set of related UI controls, and supports interactive states for styling.
- */
-export const Group: (props: GroupProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface InputRenderProps {
-    /**
-     * Whether the input is currently hovered with a mouse.
-     * @selector [data-hovered]
-     */
-    isHovered: boolean;
-    /**
-     * Whether the input is focused, either via a mouse or keyboard.
-     * @selector [data-focused]
-     */
-    isFocused: boolean;
-    /**
-     * Whether the input is keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the input is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the input is invalid.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-}
-export interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'className' | 'style'>, HoverEvents, StyleRenderProps<InputRenderProps, 'input'> {
-    /**
-     * 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-Input'
-     */
-    className?: ClassNameOrFunction<InputRenderProps>;
-    /**
-     * Temporary text that occupies the text input when it is empty.
-     * See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Attributes/placeholder).
-     */
-    placeholder?: string;
-}
-export const InputContext: React.Context<ContextValue<InputProps, HTMLInputElement>>;
-/**
- * An input allows a user to input text.
- */
-export const Input: (props: InputProps & React.RefAttributes<HTMLInputElement>) => React.ReactElement | null;
-export interface ColorFieldRenderProps {
-    /**
-     * Whether the color field is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the color field is invalid.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-    /**
-     * Whether the color field is read only.
-     * @selector [data-readonly]
-     */
-    isReadOnly: boolean;
-    /**
-     * Whether the color field is required.
-     * @selector [data-required]
-     */
-    isRequired: boolean;
-    /**
-     * The color channel that this field edits, or "hex" if no `channel` prop is set.
-     * @selector [data-channel="hex | hue | saturation | ..."]
-     */
-    channel: ColorChannel | 'hex';
-    /**
-     * State of the color field.
-     */
-    state: ColorFieldState;
-}
-export interface ColorFieldProps extends Omit<AriaColorFieldProps, 'label' | 'placeholder' | 'description' | 'errorMessage' | 'validationState' | 'validationBehavior'>, RACValidation, InputDOMProps, RenderProps<ColorFieldRenderProps>, 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-ColorField'
-     */
-    className?: ClassNameOrFunction<ColorFieldRenderProps>;
-    /**
-     * The color channel that this field edits. If not provided,
-     * the color is edited as a hex value.
-     */
-    channel?: ColorChannel;
-    /**
-     * The color space that the color field operates in if a `channel` prop is provided.
-     * If no `channel` is provided, the color field always displays the color as an RGB hex value.
-     */
-    colorSpace?: ColorSpace;
-}
-export const ColorFieldStateContext: React.Context<ColorFieldState | null>;
-/**
- * A color field allows users to edit a hex color or individual color channel value.
- */
-export const ColorField: React.ForwardRefExoticComponent<ColorFieldProps & React.RefAttributes<HTMLDivElement>>;
-export interface SliderProps<T = number | number[]> extends Omit<AriaSliderProps<T>, 'label'>, RenderProps<SliderRenderProps>, 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-Slider'
-     */
-    className?: ClassNameOrFunction<SliderRenderProps>;
-    /**
-     * The display format of the value label.
-     */
-    formatOptions?: Intl.NumberFormatOptions;
-}
-export const SliderContext: React.Context<ContextValue<SliderProps<number | number[]>, HTMLDivElement>>;
-export const SliderStateContext: React.Context<SliderState | null>;
-export const SliderTrackContext: React.Context<ContextValue<SliderTrackContextValue, HTMLDivElement>>;
-export const SliderOutputContext: React.Context<ContextValue<SliderOutputContextValue, HTMLOutputElement>>;
-export interface SliderRenderProps {
-    /**
-     * The orientation of the slider.
-     * @selector [data-orientation="horizontal | vertical"]
-     */
-    orientation: Orientation;
-    /**
-     * Whether the slider is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * State of the slider.
-     */
-    state: SliderState;
-}
-/**
- * A slider allows a user to select one or more values within a range.
- */
-export const Slider: <T extends number | number[]>(props: SliderProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface SliderOutputProps extends RenderProps<SliderRenderProps, 'output'>, GlobalDOMAttributes<HTMLOutputElement> {
-    /**
-     * 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-SliderOutput'
-     */
-    className?: ClassNameOrFunction<SliderRenderProps>;
-}
-interface SliderOutputContextValue extends Omit<OutputHTMLAttributes<HTMLOutputElement>, 'children' | 'className' | 'style'>, SliderOutputProps {
-}
-/**
- * A slider output displays the current value of a slider as text.
- */
-export const SliderOutput: (props: SliderOutputProps & React.RefAttributes<HTMLOutputElement>) => React.ReactElement | null;
-export interface SliderTrackRenderProps extends SliderRenderProps {
-    /**
-     * Whether the slider track is currently hovered with a mouse.
-     * @selector [data-hovered]
-     */
-    isHovered: boolean;
-}
-export interface SliderTrackProps extends HoverEvents, RenderProps<SliderTrackRenderProps>, 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-SliderTrack'
-     */
-    className?: ClassNameOrFunction<SliderTrackRenderProps>;
-}
-interface SliderTrackContextValue extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'className' | 'style'>, SliderTrackProps {
-}
-/**
- * A slider track is a container for one or more slider thumbs.
- */
-export const SliderTrack: (props: SliderTrackProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface SliderThumbRenderProps {
-    /**
-     * State of the slider.
-     */
-    state: SliderState;
-    /**
-     * Whether this thumb is currently being dragged.
-     * @selector [data-dragging]
-     */
-    isDragging: boolean;
-    /**
-     * Whether the thumb is currently hovered with a mouse.
-     * @selector [data-hovered]
-     */
-    isHovered: boolean;
-    /**
-     * Whether the thumb is currently focused.
-     * @selector [data-focused]
-     */
-    isFocused: boolean;
-    /**
-     * Whether the thumb is keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the thumb is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-}
-export interface SliderThumbProps extends Omit<AriaSliderThumbProps, 'label' | 'validationState'>, HoverEvents, RenderProps<SliderThumbRenderProps>, 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-SliderThumb'
-     */
-    className?: ClassNameOrFunction<SliderThumbRenderProps>;
-    /**
-     * A ref for the HTML input element.
-     */
-    inputRef?: RefObject<HTMLInputElement | null>;
-}
-/**
- * A slider thumb represents an individual value that the user can adjust within a slider track.
- */
-export const SliderThumb: (props: SliderThumbProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface ColorSliderRenderProps {
-    /**
-     * The orientation of the color slider.
-     * @selector [data-orientation="horizontal | vertical"]
-     */
-    orientation: Orientation;
-    /**
-     * Whether the color slider is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * State of the color slider.
-     */
-    state: ColorSliderState;
-}
-export interface ColorSliderProps extends Omit<AriaColorSliderProps, 'label'>, RenderProps<ColorSliderRenderProps>, 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-ColorSlider'
-     */
-    className?: ClassNameOrFunction<ColorSliderRenderProps>;
-}
-export const ColorSliderStateContext: React.Context<ColorSliderState | null>;
-/**
- * A color slider allows users to adjust an individual channel of a color value.
- */
-export const ColorSlider: React.ForwardRefExoticComponent<ColorSliderProps & React.RefAttributes<HTMLDivElement>>;
-export interface ColorWheelRenderProps {
-    /**
-     * Whether the color wheel is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * State of the color wheel.
-     */
-    state: ColorWheelState;
-}
-export interface ColorWheelProps extends AriaColorWheelOptions, RenderProps<ColorWheelRenderProps>, 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-ColorWheel'
-     */
-    className?: ClassNameOrFunction<ColorWheelRenderProps>;
-}
-export const ColorWheelStateContext: React.Context<ColorWheelState | null>;
-/**
- * A color wheel allows users to adjust the hue of an HSL or HSB color value on a circular track.
- */
-export const ColorWheel: React.ForwardRefExoticComponent<ColorWheelProps & React.RefAttributes<HTMLDivElement>>;
-export interface ColorWheelTrackRenderProps extends ColorWheelRenderProps {
-}
-export interface ColorWheelTrackProps extends StyleRenderProps<ColorWheelTrackRenderProps>, 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-ColorWheelTrack'
-     */
-    className?: ClassNameOrFunction<ColorWheelTrackRenderProps>;
-}
-interface ColorWheelTrackContextValue extends Omit<HTMLAttributes<HTMLElement>, 'children' | 'className' | 'style'>, StyleRenderProps<ColorWheelTrackRenderProps> {
-}
-export const ColorWheelTrackContext: React.Context<ContextValue<ColorWheelTrackContextValue, HTMLDivElement>>;
-/**
- * A color wheel track renders a circular gradient track.
- */
-export const ColorWheelTrack: React.ForwardRefExoticComponent<ColorWheelTrackProps & React.RefAttributes<HTMLDivElement>>;
-export interface HeadingProps extends HTMLAttributes<HTMLElement>, DOMRenderProps<'h1', undefined> {
-    level?: number;
-}
-export const Heading: React.ForwardRefExoticComponent<HeadingProps & React.RefAttributes<HTMLHeadingElement>>;
-export const CheckboxContext: Context<ContextValue<CheckboxProps, HTMLLabelElement>>;
-export const ColorAreaContext: Context<ContextValue<Partial<ColorAreaProps>, HTMLDivElement>>;
-export const ColorFieldContext: Context<ContextValue<ColorFieldProps, HTMLDivElement>>;
-export const ColorSliderContext: Context<ContextValue<Partial<ColorSliderProps>, HTMLDivElement>>;
-export const ColorWheelContext: Context<ContextValue<Partial<ColorWheelProps>, HTMLDivElement>>;
-export const HeadingContext: Context<ContextValue<HeadingProps, HTMLHeadingElement>>;
-export interface SelectableCollectionContextValue<T> extends _DOMProps1, AriaLabelingProps {
-    filter?: (nodeTextValue: string, node: Node<T>) => boolean;
-    /** Whether the collection items should use virtual focus instead of being focused directly. */
-    shouldUseVirtualFocus?: boolean;
-    /** Whether typeahead is disabled. */
-    disallowTypeAhead?: boolean;
-}
-interface FieldInputContextValue<T = FocusableElement> extends _DOMProps1, FocusEvents<T>, KeyboardEvents, Pick<ValueBase<string>, 'onChange' | 'value'>, Pick<AriaTextFieldProps, 'enterKeyHint' | 'aria-controls' | 'aria-autocomplete' | 'aria-activedescendant' | 'spellCheck' | 'autoCorrect' | 'autoComplete'> {
-}
-export const SelectableCollectionContext: Context<ContextValue<SelectableCollectionContextValue<any>, HTMLElement>>;
-export const FieldInputContext: Context<ContextValue<FieldInputContextValue<FocusableElement>, FocusableElement>>;
-export interface AutocompleteProps<T = object> extends AriaAutocompleteProps<T>, SlotProps {
-}
-export const AutocompleteContext: React.Context<SlottedContextValue<Partial<AutocompleteProps<any>>>>;
-export const AutocompleteStateContext: React.Context<AutocompleteState | null>;
-/**
- * An autocomplete allows users to search or filter a list of suggestions.
- */
-export function Autocomplete<T extends object>(props: AutocompleteProps<T>): JSX.Element;
-interface CollectionProps<T> extends Omit<CollectionBase<T>, 'children'> {
-    /** The contents of the collection. */
-    children?: ReactNode | ((item: T) => ReactNode);
-    /** Values that should invalidate the item cache when using dynamic collections. */
-    dependencies?: ReadonlyArray<any>;
-}
-interface ItemRenderProps {
-    /**
-     * Whether the item is currently hovered with a mouse.
-     * @selector [data-hovered]
-     */
-    isHovered: boolean;
-    /**
-     * Whether the item is currently in a pressed state.
-     * @selector [data-pressed]
-     */
-    isPressed: boolean;
-    /**
-     * Whether the item is currently selected.
-     * @selector [data-selected]
-     */
-    isSelected: boolean;
-    /**
-     * Whether the item is currently focused.
-     * @selector [data-focused]
-     */
-    isFocused: boolean;
-    /**
-     * Whether the item is currently keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the item 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 type of selection that is allowed in the collection.
-     * @selector [data-selection-mode="single | multiple"]
-     */
-    selectionMode: _SelectionMode2;
-    /** The selection behavior for the collection. */
-    selectionBehavior: SelectionBehavior;
-    /**
-     * Whether the item allows dragging.
-     * @note This property is only available in collection components that support drag and drop.
-     * @selector [data-allows-dragging]
-     */
-    allowsDragging?: boolean;
-    /**
-     * Whether the item is currently being dragged.
-     * @note This property is only available in collection components that support drag and drop.
-     * @selector [data-dragging]
-     */
-    isDragging?: boolean;
-    /**
-     * Whether the item is currently an active drop target.
-     * @note This property is only available in collection components that support drag and drop.
-     * @selector [data-drop-target]
-     */
-    isDropTarget?: boolean;
-}
-export interface SectionProps<T> extends Omit<_SectionProps1<T>, 'children' | 'title'>, StyleProps, GlobalDOMAttributes<HTMLElement> {
-    /** The unique id of the section. */
-    id?: Key;
-    /** The object value that this section represents. When using dynamic collections, this is set automatically. */
-    value?: T;
-    /** Static child items or a function to render children. */
-    children?: ReactNode | ((item: T) => ReactElement);
-    /** Values that should invalidate the item cache when using dynamic collections. */
-    dependencies?: ReadonlyArray<any>;
-}
-/** @deprecated */
-export const Section: <T extends object>(props: SectionProps<T> & React.RefAttributes<HTMLElement>) => ReactElement | null;
-interface CollectionBranchProps {
-    /** The collection of items to render. */
-    collection: Collection<_Node1<unknown>>;
-    /** The parent node of the items to render. */
-    parent: _Node1<unknown>;
-    /** A function that renders a drop indicator between items. */
-    renderDropIndicator?: (target: ItemDropTarget) => ReactNode;
-}
-interface CollectionRootProps extends HTMLAttributes<HTMLElement> {
-    /** The collection of items to render. */
-    collection: Collection<_Node1<unknown>>;
-    /** A set of keys for items that should always be persisted in the DOM. */
-    persistedKeys?: Set<Key> | null;
-    /** A ref to the scroll container for the collection. */
-    scrollRef?: RefObject<HTMLElement | null>;
-    /** A function that renders a drop indicator between items. */
-    renderDropIndicator?: (target: ItemDropTarget) => ReactNode;
-}
-export interface CollectionRenderer {
-    /** Whether this is a virtualized collection. */
-    isVirtualized?: boolean;
-    /** A delegate object that provides layout information for items in the collection. */
-    layoutDelegate?: LayoutDelegate;
-    /** A delegate object that provides drop targets for pointer coordinates within the collection. */
-    dropTargetDelegate?: DropTargetDelegate;
-    /** A component that renders the root collection items. */
-    CollectionRoot: React.ComponentType<CollectionRootProps>;
-    /** A component that renders the child collection items. */
-    CollectionBranch: React.ComponentType<CollectionBranchProps>;
-}
-export const DefaultCollectionRenderer: CollectionRenderer;
-export const CollectionRendererContext: React.Context<CollectionRenderer>;
-export interface LinkProps extends Omit<AriaLinkOptions, 'elementType'>, HoverEvents, Omit<RenderProps<LinkRenderProps>, 'render'>, PossibleLinkDOMRenderProps<'span', LinkRenderProps>, SlotProps, _DOMProps1, Omit<GlobalDOMAttributes<HTMLAnchorElement>, '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-Link'
-     */
-    className?: ClassNameOrFunction<LinkRenderProps>;
-}
-export interface LinkRenderProps {
-    /**
-     * Whether the link is the current item within a list.
-     * @selector [data-current]
-     */
-    isCurrent: boolean;
-    /**
-     * Whether the link is currently hovered with a mouse.
-     * @selector [data-hovered]
-     */
-    isHovered: boolean;
-    /**
-     * Whether the link is currently in a pressed state.
-     * @selector [data-pressed]
-     */
-    isPressed: boolean;
-    /**
-     * Whether the link is focused, either via a mouse or keyboard.
-     * @selector [data-focused]
-     */
-    isFocused: boolean;
-    /**
-     * Whether the link is keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the link is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-}
-export const LinkContext: React.Context<ContextValue<LinkProps, HTMLAnchorElement>>;
-/**
- * A link allows a user to navigate to another page or resource within a web page
- * or application.
- */
-export const Link: (props: LinkProps & React.RefAttributes<HTMLAnchorElement>) => React.ReactElement | null;
-export interface BreadcrumbsProps<T> extends Omit<CollectionProps<T>, 'disabledKeys'>, AriaBreadcrumbsProps, StyleProps, SlotProps, AriaLabelingProps, DOMRenderProps<'ol', undefined>, GlobalDOMAttributes<HTMLOListElement> {
-    /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element.
-     * @default 'react-aria-Breadcrumbs'
-     */
-    className?: string;
-    /** Whether the breadcrumbs are disabled. */
-    isDisabled?: boolean;
-    /** Handler that is called when a breadcrumb is clicked. */
-    onAction?: (key: Key) => void;
-}
-export const BreadcrumbsContext: React.Context<ContextValue<BreadcrumbsProps<any>, HTMLOListElement>>;
-/**
- * Breadcrumbs display a hierarchy of links to the current page or resource in an application.
- */
-export const Breadcrumbs: <T extends object>(props: BreadcrumbsProps<T> & React.RefAttributes<HTMLOListElement>) => React.ReactElement | null;
-export interface BreadcrumbRenderProps {
-    /**
-     * Whether the breadcrumb is for the current page.
-     * @selector [data-current]
-     */
-    isCurrent: boolean;
-    /**
-     * Whether the breadcrumb is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-}
-export interface BreadcrumbProps extends RenderProps<BreadcrumbRenderProps, 'li'>, AriaLabelingProps, GlobalDOMAttributes<HTMLLIElement> {
-    /**
-     * 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-Breadcrumb'
-     */
-    className?: ClassNameOrFunction<BreadcrumbRenderProps>;
-    /** A unique id for the breadcrumb, which will be passed to `onAction` when the breadcrumb is pressed. */
-    id?: Key;
-}
-/**
- * A Breadcrumb represents an individual item in a `<Breadcrumbs>` list.
- */
-export const Breadcrumb: (props: BreadcrumbProps & React.RefAttributes<HTMLLIElement>) => React.ReactElement | null;
-export interface ProgressBarProps extends Omit<AriaProgressBarProps, 'label'>, RenderProps<ProgressBarRenderProps>, 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-ProgressBar'
-     */
-    className?: ClassNameOrFunction<ProgressBarRenderProps>;
-}
-export interface ProgressBarRenderProps {
-    /**
-     * The value as a percentage between the minimum and maximum.
-     */
-    percentage: number | undefined;
-    /**
-     * A formatted version of the value.
-     * @selector [aria-valuetext]
-     */
-    valueText: string | undefined;
-    /**
-     * Whether the progress bar is indeterminate.
-     * @selector :not([aria-valuenow])
-     */
-    isIndeterminate: boolean;
-}
-export const ProgressBarContext: React.Context<ContextValue<ProgressBarProps, HTMLDivElement>>;
-/**
- * Progress bars show either determinate or indeterminate progress of an operation
- * over time.
- */
-export const ProgressBar: React.ForwardRefExoticComponent<ProgressBarProps & React.RefAttributes<HTMLDivElement>>;
-export interface ButtonRenderProps {
-    /**
-     * Whether the button is currently hovered with a mouse.
-     * @selector [data-hovered]
-     */
-    isHovered: boolean;
-    /**
-     * Whether the button is currently in a pressed state.
-     * @selector [data-pressed]
-     */
-    isPressed: boolean;
-    /**
-     * Whether the button is focused, either via a mouse or keyboard.
-     * @selector [data-focused]
-     */
-    isFocused: boolean;
-    /**
-     * Whether the button is keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the button is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the button is currently in a pending state.
-     * @selector [data-pending]
-     */
-    isPending: boolean;
-}
-export interface ButtonProps extends Omit<AriaButtonProps, 'children' | 'href' | 'target' | 'rel' | 'elementType'>, HoverEvents, SlotProps, RenderProps<ButtonRenderProps, 'button'>, Omit<GlobalDOMAttributes<HTMLButtonElement>, '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-Button'
-     */
-    className?: ClassNameOrFunction<ButtonRenderProps>;
-    /**
-     * Whether the button is in a pending state. This disables press and hover events
-     * while retaining focusability, and announces the pending state to screen readers.
-     */
-    isPending?: boolean;
-}
-interface ButtonContextValue extends ButtonProps {
-    isPressed?: boolean;
-}
-export const ButtonContext: React.Context<ContextValue<ButtonContextValue, HTMLButtonElement>>;
-/**
- * A button allows a user to perform an action, with mouse, touch, and keyboard interactions.
- */
-export const Button: (props: ButtonProps & React.RefAttributes<HTMLButtonElement>) => React.ReactElement | null;
-export interface CalendarRenderProps {
-    /**
-     * Whether the calendar is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * State of the calendar.
-     */
-    state: CalendarState;
-    /**
-     * Whether the calendar is invalid.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-}
-export interface RangeCalendarRenderProps extends Omit<CalendarRenderProps, 'state'> {
-    /**
-     * State of the range calendar.
-     */
-    state: RangeCalendarState;
-}
-export interface CalendarProps<T extends DateValue> extends Omit<AriaCalendarProps<T>, 'errorMessage' | 'validationState'>, RenderProps<CalendarRenderProps, 'div'>, 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-Calendar'
-     */
-    className?: ClassNameOrFunction<CalendarRenderProps>;
-    /**
-     * The amount of days that will be displayed at once. This affects how pagination works.
-     * @default {months: 1}
-     */
-    visibleDuration?: DateDuration;
-    /**
-     * A function to create a new [Calendar](https://react-spectrum.adobe.com/internationalized/date/Calendar.html)
-     * object for a given calendar identifier. If not provided, the `createCalendar` function
-     * from `@internationalized/date` will be used.
-     */
-    createCalendar?: (identifier: CalendarIdentifier) => _Calendar1;
-}
-export interface RangeCalendarProps<T extends DateValue> extends Omit<AriaRangeCalendarProps<T>, 'errorMessage' | 'validationState'>, RenderProps<RangeCalendarRenderProps, 'div'>, 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-RangeCalendar'
-     */
-    className?: ClassNameOrFunction<RangeCalendarRenderProps>;
-    /**
-     * The amount of days that will be displayed at once. This affects how pagination works.
-     * @default {months: 1}
-     */
-    visibleDuration?: DateDuration;
-    /**
-     * A function to create a new [Calendar](https://react-spectrum.adobe.com/internationalized/date/Calendar.html)
-     * object for a given calendar identifier. If not provided, the `createCalendar` function
-     * from `@internationalized/date` will be used.
-     */
-    createCalendar?: (identifier: CalendarIdentifier) => _Calendar1;
-}
-export const CalendarContext: React.Context<ContextValue<CalendarProps<any>, HTMLDivElement>>;
-export const RangeCalendarContext: React.Context<ContextValue<RangeCalendarProps<any>, HTMLDivElement>>;
-export const CalendarStateContext: React.Context<CalendarState | null>;
-export const RangeCalendarStateContext: React.Context<RangeCalendarState<_DateValue1> | null>;
-/**
- * A calendar displays one or more date grids and allows users to select a single date.
- */
-export const Calendar: <T extends DateValue>(props: CalendarProps<T> & React.RefAttributes<HTMLDivElement>) => ReactElement | null;
-/**
- * A range calendar displays one or more date grids and allows users to select a contiguous range of dates.
- */
-export const RangeCalendar: <T extends DateValue>(props: RangeCalendarProps<T> & React.RefAttributes<HTMLDivElement>) => ReactElement | null;
-export interface CalendarCellRenderProps {
-    /** The date that the cell represents. */
-    date: CalendarDate;
-    /** The day number formatted according to the current locale. */
-    formattedDate: string;
-    /**
-     * Whether the cell is currently hovered with a mouse.
-     * @selector [data-hovered]
-     */
-    isHovered: boolean;
-    /**
-     * Whether the cell is currently being pressed.
-     * @selector [data-pressed]
-     */
-    isPressed: boolean;
-    /**
-     * Whether the cell is selected.
-     * @selector [data-selected]
-     */
-    isSelected: boolean;
-    /**
-     * Whether the cell is the first date in a range selection.
-     * @selector [data-selection-start]
-     */
-    isSelectionStart: boolean;
-    /**
-     * Whether the cell is the last date in a range selection.
-     * @selector [data-selection-end]
-     */
-    isSelectionEnd: boolean;
-    /**
-     * Whether the cell is focused.
-     * @selector [data-focused]
-     */
-    isFocused: boolean;
-    /**
-     * Whether the cell is keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the cell is disabled, according to the calendar's `minValue`, `maxValue`, and `isDisabled` props.
-     * Disabled dates are not focusable, and cannot be selected by the user. They are typically
-     * displayed with a dimmed appearance.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the cell is outside the visible range of the calendar.
-     * For example, dates before the first day of a month in the same week.
-     * @selector [data-outside-visible-range]
-     */
-    isOutsideVisibleRange: boolean;
-    /**
-     * Whether the cell is outside the current month.
-     * @selector [data-outside-month]
-     */
-    isOutsideMonth: boolean;
-    /**
-     * Whether the cell is unavailable, according to the calendar's `isDateUnavailable` prop. Unavailable dates remain
-     * focusable, but cannot be selected by the user. They should be displayed with a visual affordance to indicate they
-     * are unavailable, such as a different color or a strikethrough.
-     *
-     * Note that because they are focusable, unavailable dates must meet a 4.5:1 color contrast ratio,
-     * [as defined by WCAG](https://www.w3.org/WAI/WCAG21/Understanding/contrast-minimum.html).
-     *
-     * @selector [data-unavailable]
-     */
-    isUnavailable: boolean;
-    /**
-     * Whether the cell is part of an invalid selection.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-    /**
-     * Whether the cell is today.
-     * @selector [data-today]
-     */
-    isToday: boolean;
-}
-export interface CalendarGridProps extends StyleProps, DOMRenderProps<'table', undefined>, GlobalDOMAttributes<HTMLTableElement> {
-    /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element.
-     * @default 'react-aria-CalendarGrid'
-     */
-    className?: string;
-    /**
-     * Either a function to render calendar cells for each date in the month,
-     * or children containing a `<CalendarGridHeader>`` and `<CalendarGridBody>`
-     * when additional customization is needed.
-     */
-    children?: ReactElement | ReactElement[] | ((date: CalendarDate) => ReactElement);
-    /**
-     * An offset from the beginning of the visible date range that this
-     * CalendarGrid should display. Useful when displaying more than one
-     * month at a time.
-     */
-    offset?: DateDuration;
-    /**
-     * The style of weekday names to display in the calendar grid header,
-     * e.g. single letter, abbreviation, or full day name.
-     * @default "narrow"
-     */
-    weekdayStyle?: 'narrow' | 'short' | 'long';
-}
-/**
- * A calendar grid displays a single grid of days within a calendar or range calendar which
- * can be keyboard navigated and selected by the user.
- */
-export const CalendarGrid: (props: CalendarGridProps & React.RefAttributes<HTMLTableElement>) => ReactElement | null;
-export interface CalendarGridHeaderProps extends StyleProps, DOMRenderProps<'thead', undefined>, GlobalDOMAttributes<HTMLTableSectionElement> {
-    /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element.
-     * @default 'react-aria-CalendarGridHeader'
-     */
-    className?: string;
-    /** A function to render a `<CalendarHeaderCell>` for a weekday name. */
-    children: (day: string) => ReactElement;
-}
-/**
- * A calendar grid header displays a row of week day names at the top of a month.
- */
-export const CalendarGridHeader: (props: CalendarGridHeaderProps & React.RefAttributes<HTMLTableSectionElement>) => ReactElement | null;
-export interface CalendarHeaderCellProps extends DOMProps, DOMRenderProps<'th', undefined>, GlobalDOMAttributes<HTMLTableHeaderCellElement> {
-    /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element.
-     * @default 'react-aria-CalendarHeaderCell'
-     */
-    className?: string;
-}
-/**
- * A calendar header cell displays a week day name at the top of a column within a calendar.
- */
-export const CalendarHeaderCell: React.ForwardRefExoticComponent<CalendarHeaderCellProps & React.RefAttributes<HTMLTableCellElement>>;
-export interface CalendarGridBodyProps extends StyleProps, DOMRenderProps<'tbody', undefined>, GlobalDOMAttributes<HTMLTableSectionElement> {
-    /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element.
-     * @default 'react-aria-CalendarGridBody'
-     */
-    className?: string;
-    /** A function to render a `<CalendarCell>` for a given date. */
-    children: (date: CalendarDate) => ReactElement;
-}
-/**
- * A calendar grid body displays a grid of calendar cells within a month.
- */
-export const CalendarGridBody: (props: CalendarGridBodyProps & React.RefAttributes<HTMLTableSectionElement>) => ReactElement | null;
-export interface CalendarCellProps extends RenderProps<CalendarCellRenderProps, 'div'>, _HoverEvents1, 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-CalendarCell'
-     */
-    className?: ClassNameOrFunction<CalendarCellRenderProps>;
-    /** The date to render in the cell. */
-    date: CalendarDate;
-}
-/**
- * A calendar cell displays a date cell within a calendar grid which can be selected by the user.
- */
-export const CalendarCell: (props: CalendarCellProps & React.RefAttributes<HTMLTableCellElement>) => ReactElement | null;
-export interface ColorSwatchRenderProps {
-    /** The color of the swatch. */
-    color: Color;
-}
-export interface ColorSwatchProps extends AriaColorSwatchProps, StyleRenderProps<ColorSwatchRenderProps>, 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-ColorSwatch'
-     */
-    className?: ClassNameOrFunction<ColorSwatchRenderProps>;
-}
-export const ColorSwatchContext: React.Context<ContextValue<ColorSwatchProps, HTMLDivElement>>;
-/**
- * A ColorSwatch displays a preview of a selected color.
- */
-export const ColorSwatch: React.ForwardRefExoticComponent<ColorSwatchProps & React.RefAttributes<HTMLDivElement>>;
-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: _DropIndicatorProps1, state: DroppableCollectionState, ref: RefObject<HTMLElement | null>) => DropIndicatorAria;
-    renderDropIndicator?: (target: DropTarget) => JSX.Element;
-    dropTargetDelegate?: _DropTargetDelegate1;
-    ListDropTargetDelegate: typeof ListDropTargetDelegate;
-}
-export type DragAndDropHooks<T = object> = DragHooks<T> & DropHooks;
-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?: _DropTargetDelegate1;
-    /** 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 function useDragAndDrop<T = object>(options: DragAndDropOptions<T>): DragAndDrop<T>;
-interface DragAndDropContextValue {
-    dragAndDropHooks?: DragAndDropHooks;
-    dragState?: DraggableCollectionState;
-    dropState?: DroppableCollectionState;
-}
-export const DragAndDropContext: React.Context<DragAndDropContextValue>;
-export const DropIndicatorContext: React.Context<DropIndicatorContextValue | null>;
-export interface DropIndicatorRenderProps {
-    /**
-     * Whether the drop indicator is currently the active drop target.
-     * @selector [data-drop-target]
-     */
-    isDropTarget: boolean;
-}
-export interface DropIndicatorProps extends Omit<_DropIndicatorProps1, 'activateButtonRef'>, RenderProps<DropIndicatorRenderProps> {
-    /**
-     * 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-DropIndicator'
-     */
-    className?: ClassNameOrFunction<DropIndicatorRenderProps>;
-}
-interface DropIndicatorContextValue {
-    render: (props: DropIndicatorProps, ref: ForwardedRef<HTMLElement>) => ReactNode;
-}
-/**
- * A DropIndicator is rendered between items in a collection to indicate where dropped data will be inserted.
- */
-export const DropIndicator: React.ForwardRefExoticComponent<DropIndicatorProps & React.RefAttributes<HTMLElement>>;
-export interface HeaderProps extends HTMLAttributes<HTMLElement>, DOMRenderProps<'header', undefined> {
-}
-export const HeaderContext: React.Context<ContextValue<HeaderProps, HTMLElement>>;
-export const Header: (props: HeaderProps & React.RefAttributes<HTMLElement>) => React.ReactElement | null;
-export interface SharedElementTransitionProps {
-    children: ReactNode;
-}
-/**
- * A scope for SharedElements, which animate between parents.
- */
-export function SharedElementTransition(props: SharedElementTransitionProps): React.JSX.Element;
-export interface SharedElementRenderProps {
-    /**
-     * Whether the element is currently entering.
-     * @selector [data-entering]
-     */
-    isEntering: boolean;
-    /**
-     * Whether the element is currently exiting.
-     * @selector [data-exiting]
-     */
-    isExiting: boolean;
-}
-interface SharedElementPropsBase extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'className' | 'style'>, RenderProps<SharedElementRenderProps> {
-}
-export interface SharedElementProps extends SharedElementPropsBase {
-    name: string;
-    isVisible?: boolean;
-}
-/**
- * An element that animates between its old and new position when moving between parents.
- */
-export const SharedElement: React.ForwardRefExoticComponent<SharedElementProps & React.RefAttributes<HTMLDivElement>>;
-export interface SelectionIndicatorProps extends SharedElementPropsBase {
-    /**
-     * 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-SelectionIndicator'
-     */
-    className?: ClassNameOrFunction<SharedElementRenderProps>;
-    /** Whether the SelectionIndicator is visible. This is usually set automatically by the parent component. */
-    isSelected?: boolean;
-}
-export const SelectionIndicatorContext: React.Context<ContextValue<SelectionIndicatorProps, HTMLDivElement>>;
-/**
- * An animated indicator of selection state within a group of items.
- */
-export const SelectionIndicator: React.ForwardRefExoticComponent<SelectionIndicatorProps & React.RefAttributes<HTMLDivElement>>;
-export interface SeparatorProps extends _SeparatorProps1, StyleProps, SlotProps, DOMRenderProps<'hr' | 'div', undefined>, GlobalDOMAttributes<HTMLElement> {
-    /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element.
-     * @default 'react-aria-Separator'
-     */
-    className?: string;
-}
-export const SeparatorContext: React.Context<ContextValue<SeparatorProps, HTMLElement>>;
-/**
- * A separator is a visual divider between two groups of content, e.g. groups of menu items or sections of a page.
- */
-export const Separator: (props: SeparatorProps & React.RefAttributes<HTMLElement>) => React.ReactElement | null;
-export interface ListBoxRenderProps {
-    /**
-     * Whether the listbox has no items and should display its empty state.
-     * @selector [data-empty]
-     */
-    isEmpty: boolean;
-    /**
-     * Whether the listbox is currently focused.
-     * @selector [data-focused]
-     */
-    isFocused: boolean;
-    /**
-     * Whether the listbox is currently keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the listbox is currently the active drop target.
-     * @selector [data-drop-target]
-     */
-    isDropTarget: boolean;
-    /**
-     * Whether the items are arranged in a stack or grid.
-     * @selector [data-layout="stack | grid"]
-     */
-    layout: 'stack' | 'grid';
-    /**
-     * State of the listbox.
-     */
-    state: ListState<unknown>;
-}
-export interface ListBoxProps<T> extends Omit<AriaListBoxProps<T>, 'children' | 'label'>, CollectionProps<T>, StyleRenderProps<ListBoxRenderProps>, 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-ListBox'
-     */
-    className?: ClassNameOrFunction<ListBoxRenderProps>;
-    /**
-     * How multiple selection should behave in the collection.
-     * @default "toggle"
-     */
-    selectionBehavior?: SelectionBehavior;
-    /** The drag and drop hooks returned by `useDragAndDrop` used to enable drag and drop behavior for the ListBox. */
-    dragAndDropHooks?: DragAndDropHooks<NoInfer<T>>;
-    /** Provides content to display when there are no items in the list. */
-    renderEmptyState?: (props: ListBoxRenderProps) => ReactNode;
-    /**
-     * Whether the items are arranged in a stack or grid.
-     * @default 'stack'
-     */
-    layout?: 'stack' | 'grid';
-    /**
-     * The primary orientation of the items. Usually this is the
-     * direction that the collection scrolls.
-     * @default 'vertical'
-     */
-    orientation?: _Orientation1;
-}
-export const ListBoxContext: React.Context<ContextValue<ListBoxProps<any>, HTMLDivElement>>;
-export const ListStateContext: React.Context<ListState<any> | null>;
-/**
- * A listbox displays a list of options and allows a user to select one or more of them.
- */
-export const ListBox: <T extends object>(props: ListBoxProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface ListBoxSectionProps<T> extends SectionProps<T>, DOMRenderProps<'section', undefined> {
-    /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element.
-     * @default 'react-aria-ListBoxSection'
-     */
-    className?: string;
-}
-/**
- * A ListBoxSection represents a section within a ListBox.
- */
-export const ListBoxSection: <T extends object>(props: ListBoxSectionProps<T> & React.RefAttributes<HTMLElement>) => React.ReactElement | null;
-export interface ListBoxItemRenderProps extends ItemRenderProps {
-}
-export interface ListBoxItemProps<T = object> extends Omit<RenderProps<ListBoxItemRenderProps>, 'render'>, PossibleLinkDOMRenderProps<'div', ListBoxItemRenderProps>, LinkDOMProps, _HoverEvents1, PressEvents, KeyboardEvents, FocusEvents<HTMLDivElement>, 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-ListBoxItem'
-     */
-    className?: ClassNameOrFunction<ListBoxItemRenderProps>;
-    /** The unique id of the item. */
-    id?: Key;
-    /** The object value that this item represents. When using dynamic collections, this is set automatically. */
-    value?: T;
-    /** A string representation of the item's contents, used for features like typeahead. */
-    textValue?: string;
-    /** An accessibility label for this item. */
-    'aria-label'?: string;
-    /** Whether the item 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 ListBoxItem represents an individual option in a ListBox.
- */
-export const ListBoxItem: <T extends object>(props: ListBoxItemProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface ListBoxLoadMoreItemProps extends Omit<LoadMoreSentinelProps, 'collection'>, 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-ListBoxLoadMoreItem'
-     */
-    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 const ListBoxLoadMoreItem: (props: ListBoxLoadMoreItemProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface ColorSwatchPickerRenderProps extends Omit<ListBoxRenderProps, 'isDropTarget'> {
-}
-export interface ColorSwatchPickerProps extends ValueBase<string | Color, Color>, AriaLabelingProps, StyleRenderProps<ColorSwatchPickerRenderProps>, 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-ColorSwatchPicker'
-     */
-    className?: ClassNameOrFunction<ColorSwatchPickerRenderProps>;
-    /** The children of the ColorSwatchPicker. */
-    children?: ReactNode;
-    /**
-     * Whether the items are arranged in a stack or grid.
-     * @default 'grid'
-     */
-    layout?: 'grid' | 'stack';
-}
-export const ColorSwatchPickerContext: React.Context<ContextValue<ColorSwatchPickerProps, HTMLDivElement>>;
-/**
- * A ColorSwatchPicker displays a list of color swatches and allows a user to select one of them.
- */
-export const ColorSwatchPicker: React.ForwardRefExoticComponent<ColorSwatchPickerProps & React.RefAttributes<HTMLDivElement>>;
-export interface ColorSwatchPickerItemRenderProps extends Omit<ListBoxItemRenderProps, 'selectionMode' | 'selectionBehavior'> {
-    /** The color of the swatch. */
-    color: Color;
-}
-export interface ColorSwatchPickerItemProps extends RenderProps<ColorSwatchPickerItemRenderProps>, _HoverEvents1, 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-ColorSwatchPickerItem'
-     */
-    className?: ClassNameOrFunction<ColorSwatchPickerItemRenderProps>;
-    /** The color of the swatch. */
-    color: string | Color;
-    /** Whether the color swatch is disabled. */
-    isDisabled?: boolean;
-}
-export const ColorSwatchPickerItem: React.ForwardRefExoticComponent<ColorSwatchPickerItemProps & React.RefAttributes<HTMLDivElement>>;
-export interface ColorPickerRenderProps {
-    /** The currently selected color. */
-    color: Color;
-}
-export interface ColorPickerProps extends _ColorPickerProps1, SlotProps {
-    /** The children of the component. A function may be provided to alter the children based on component state. */
-    children: ChildrenOrFunction<ColorPickerRenderProps>;
-}
-export const ColorPickerContext: React.Context<SlottedContextValue<ColorPickerProps>>;
-export const ColorPickerStateContext: React.Context<ColorPickerState | null>;
-/**
- * A ColorPicker synchronizes a color value between multiple React Aria color components.
- * It simplifies building color pickers with customizable layouts via composition.
- */
-export function ColorPicker(props: ColorPickerProps): JSX.Element;
-export interface OverlayArrowProps extends Omit<HTMLAttributes<HTMLDivElement>, 'className' | 'style' | 'render' | 'children'>, RenderProps<OverlayArrowRenderProps>, _DOMProps1 {
-    /**
-     * 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-OverlayArrow'
-     */
-    className?: ClassNameOrFunction<OverlayArrowRenderProps>;
-}
-export interface OverlayArrowRenderProps {
-    /**
-     * The placement of the overlay relative to the trigger.
-     * @selector [data-placement="left | right | top | bottom"]
-     */
-    placement: PlacementAxis | null;
-}
-/**
- * An OverlayArrow renders a custom arrow element relative to an overlay element
- * such as a popover or tooltip such that it aligns with a trigger element.
- */
-export const OverlayArrow: (props: OverlayArrowProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface PopoverProps extends Omit<PositionProps, 'isOpen'>, Omit<AriaPopoverProps, 'popoverRef' | 'triggerRef' | 'groupRef' | 'offset' | 'arrowSize'>, OverlayTriggerProps, RenderProps<PopoverRenderProps>, SlotProps, AriaLabelingProps, 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-Popover'
-     */
-    className?: ClassNameOrFunction<PopoverRenderProps>;
-    /**
-     * The name of the component that triggered the popover. This is reflected on the element
-     * as the `data-trigger` attribute, and can be used to provide specific
-     * styles for the popover depending on which element triggered it.
-     */
-    trigger?: string;
-    /**
-     * The ref for the element which the popover positions itself with respect to.
-     *
-     * When used within a trigger component such as DialogTrigger, MenuTrigger, Select, etc.,
-     * this is set automatically. It is only required when used standalone.
-     */
-    triggerRef?: RefObject<Element | null>;
-    /**
-     * Whether the popover is currently performing an entry animation.
-     */
-    isEntering?: boolean;
-    /**
-     * Whether the popover 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.
-     * @default document.body
-     * @deprecated - Use a parent UNSAFE_PortalProvider to set your portal container instead.
-     */
-    UNSTABLE_portalContainer?: Element;
-    /**
-     * The additional offset applied along the main axis between the element and its
-     * anchor element.
-     * @default 8
-     */
-    offset?: number;
-}
-export interface PopoverRenderProps {
-    /**
-     * The name of the component that triggered the popover, e.g. "DialogTrigger" or "ComboBox".
-     * @selector [data-trigger="..."]
-     */
-    trigger: string | null;
-    /**
-     * The placement of the popover relative to the trigger.
-     * @selector [data-placement="left | right | top | bottom"]
-     */
-    placement: PlacementAxis | null;
-    /**
-     * Whether the popover is currently entering. Use this to apply animations.
-     * @selector [data-entering]
-     */
-    isEntering: boolean;
-    /**
-     * Whether the popover is currently exiting. Use this to apply animations.
-     * @selector [data-exiting]
-     */
-    isExiting: boolean;
-}
-interface PopoverContextValue extends PopoverProps {
-    /** Contexts to clear. */
-    clearContexts?: Context<any>[];
-}
-export const PopoverContext: React.Context<ContextValue<PopoverContextValue, HTMLElement>>;
-/**
- * A popover is an overlay element positioned relative to a trigger.
- */
-export const Popover: (props: PopoverProps & React.RefAttributes<HTMLElement>) => React.ReactElement | null;
-interface KeyboardProps extends HTMLAttributes<HTMLElement>, DOMRenderProps<'kbd', undefined> {
-}
-export const KeyboardContext: React.Context<ContextValue<KeyboardProps, HTMLElement>>;
-export const Keyboard: React.ForwardRefExoticComponent<KeyboardProps & React.RefAttributes<HTMLElement>>;
-export const MenuContext: React.Context<ContextValue<MenuProps<any>, HTMLDivElement>>;
-export const MenuStateContext: React.Context<TreeState<any> | null>;
-export const RootMenuTriggerStateContext: React.Context<RootMenuTriggerState | null>;
-export interface MenuTriggerProps extends _MenuTriggerProps1 {
-    children: ReactNode;
-}
-export function MenuTrigger(props: MenuTriggerProps): JSX.Element;
-export interface SubmenuTriggerProps {
-    /**
-     * The contents of the SubmenuTrigger. The first child should be an Item (the trigger) and the second child should be the Popover (for the submenu).
-     */
-    children: ReactElement[];
-    /**
-     * The delay time in milliseconds for the submenu to appear after hovering over the trigger.
-     * @default 200
-     */
-    delay?: number;
-}
-/**
- * A submenu trigger is used to wrap a submenu's trigger item and the submenu itself.
- *
- * @version alpha
- */
-export const SubmenuTrigger: (props: SubmenuTriggerProps & React.RefAttributes<HTMLDivElement>) => ReactElement | null;
-interface MenuRenderProps {
-    /**
-     * Whether the menu has no items and should display its empty state.
-     * @selector [data-empty]
-     */
-    isEmpty: boolean;
-}
-export interface MenuProps<T> extends Omit<AriaMenuProps<T>, 'children'>, CollectionProps<T>, StyleRenderProps<MenuRenderProps>, 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-Menu'
-     */
-    className?: ClassNameOrFunction<MenuRenderProps>;
-    /** Provides content to display when there are no items in the list. */
-    renderEmptyState?: () => ReactNode;
-    /** Whether the menu should close when the menu item is selected. */
-    shouldCloseOnSelect?: boolean;
-}
-/**
- * A menu displays a list of actions or options that a user can choose.
- */
-export const Menu: <T extends object>(props: MenuProps<T> & React.RefAttributes<HTMLDivElement>) => ReactElement | null;
-export interface MenuSectionProps<T> extends SectionProps<T>, MultipleSelection, DOMRenderProps<'section', undefined> {
-    /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element.
-     * @default 'react-aria-MenuSection'
-     */
-    className?: string;
-    /** Whether the menu should close when the menu item is selected. */
-    shouldCloseOnSelect?: boolean;
-}
-/**
- * A MenuSection represents a section within a Menu.
- */
-export const MenuSection: <T extends object>(props: MenuSectionProps<T> & React.RefAttributes<HTMLElement>) => ReactElement | null;
-export interface MenuItemRenderProps extends ItemRenderProps {
-    /**
-     * Whether the item has a submenu.
-     *
-     * @selector [data-has-submenu]
-     */
-    hasSubmenu: boolean;
-    /**
-     * Whether the item's submenu is open.
-     *
-     * @selector [data-open]
-     */
-    isOpen: boolean;
-}
-export interface MenuItemProps<T = object> extends Omit<RenderProps<MenuItemRenderProps>, 'render'>, PossibleLinkDOMRenderProps<'div', MenuItemRenderProps>, LinkDOMProps, _HoverEvents1, 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-MenuItem'
-     */
-    className?: ClassNameOrFunction<MenuItemRenderProps>;
-    /** The unique id of the item. */
-    id?: Key;
-    /** The object value that this item represents. When using dynamic collections, this is set automatically. */
-    value?: T;
-    /** A string representation of the item's contents, used for features like typeahead. */
-    textValue?: string;
-    /** An accessibility label for this item. */
-    'aria-label'?: string;
-    /** Whether the item is disabled. */
-    isDisabled?: boolean;
-    /** Handler that is called when the item is selected. */
-    onAction?: () => void;
-    /** Whether the menu should close when the menu item is selected. */
-    shouldCloseOnSelect?: boolean;
-}
-/**
- * A MenuItem represents an individual action in a Menu.
- */
-export const MenuItem: <T extends object>(props: MenuItemProps<T> & React.RefAttributes<HTMLDivElement>) => ReactElement | null;
-export interface DialogTriggerProps extends OverlayTriggerProps {
-    children: ReactNode;
-}
-export interface DialogRenderProps {
-    close: () => void;
-}
-export interface DialogProps extends AriaDialogProps, StyleProps, SlotProps, DOMRenderProps<'section', undefined>, GlobalDOMAttributes<HTMLElement> {
-    /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element.
-     * @default 'react-aria-Dialog'
-     */
-    className?: string;
-    /** Children of the dialog. A function may be provided to access a function to close the dialog. */
-    children?: ReactNode | ((opts: DialogRenderProps) => ReactNode);
-}
-export const DialogContext: React.Context<ContextValue<DialogProps, HTMLElement>>;
-export const OverlayTriggerStateContext: React.Context<OverlayTriggerState | null>;
-/**
- * A DialogTrigger opens a dialog when a trigger element is pressed.
- */
-export function DialogTrigger(props: DialogTriggerProps): JSX.Element;
-/**
- * A dialog is an overlay shown above other content in an application.
- */
-export const Dialog: (props: DialogProps & React.RefAttributes<HTMLElement>) => React.ReactElement | null;
-type SelectionMode = 'single' | 'multiple';
-export interface ComboBoxRenderProps {
-    /**
-     * Whether the combobox is currently open.
-     * @selector [data-open]
-     */
-    isOpen: boolean;
-    /**
-     * Whether the combobox is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the combobox is invalid.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-    /**
-     * Whether the combobox is required.
-     * @selector [data-required]
-     */
-    isRequired: boolean;
-}
-export interface ComboBoxProps<T extends object, M extends SelectionMode = 'single'> extends Omit<AriaComboBoxProps<T, M>, 'children' | 'placeholder' | 'label' | 'description' | 'errorMessage' | 'validationState' | 'validationBehavior'>, RACValidation, RenderProps<ComboBoxRenderProps>, 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-ComboBox'
-     */
-    className?: ClassNameOrFunction<ComboBoxRenderProps>;
-    /** The filter function used to determine if a option should be included in the combo box list. */
-    defaultFilter?: (textValue: string, inputValue: string) => boolean;
-    /**
-     * Whether the text or key of the selected item is submitted as part of an HTML form.
-     * When `allowsCustomValue` is `true`, this option does not apply and the text is always submitted.
-     * @default 'key'
-     */
-    formValue?: 'text' | 'key';
-    /** Whether the combo box allows the menu to be open when the collection is empty. */
-    allowsEmptyCollection?: boolean;
-}
-export const ComboBoxContext: React.Context<ContextValue<ComboBoxProps<any, SelectionMode>, HTMLDivElement>>;
-export const ComboBoxStateContext: React.Context<ComboBoxState<any, SelectionMode> | null>;
-/**
- * A combo box combines a text input with a listbox, allowing users to filter a list of options to items matching a query.
- */
-export const ComboBox: <T extends object, M extends SelectionMode = "single">(props: ComboBoxProps<T, M> & React.RefAttributes<HTMLDivElement>) => ReactElement | null;
-export interface ComboBoxValueRenderProps<T> {
-    /**
-     * Whether the value is a placeholder.
-     * @selector [data-placeholder]
-     */
-    isPlaceholder: boolean;
-    /** The object values of the currently selected items. */
-    selectedItems: (T | null)[];
-    /** The textValue of the currently selected items. */
-    selectedText: string;
-    /** The state of the ComboBox. */
-    state: ComboBoxState<T, 'single' | 'multiple'>;
-}
-export interface ComboBoxValueProps<T extends object> extends Omit<HTMLAttributes<HTMLElement>, keyof RenderProps<unknown>>, RenderProps<ComboBoxValueRenderProps<T>, 'div'> {
-    /**
-     * 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-ComboBoxValue'
-     */
-    className?: ClassNameOrFunction<ComboBoxValueRenderProps<T>>;
-    /** A value to display when no items are selected. */
-    placeholder?: ReactNode;
-}
-export const ComboBoxValueContext: React.Context<ContextValue<ComboBoxValueProps<any>, HTMLDivElement>>;
-/**
- * ComboBoxValue renders the selected values of a ComboBox, or a placeholder if no value is selected.
- * By default, the items are rendered as a comma separated list. Use the render function to customize this.
- */
-export const ComboBoxValue: <T extends object>(props: ComboBoxValueProps<T> & React.RefAttributes<HTMLDivElement>) => ReactElement | null;
-export interface DateFieldRenderProps {
-    /**
-     * State of the date field.
-     */
-    state: DateFieldState;
-    /**
-     * Whether the date field is invalid.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-    /**
-     * Whether the date field is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the date field is read only.
-     * @selector [data-readonly]
-     */
-    isReadOnly: boolean;
-    /**
-     * Whether the date field is required.
-     * @selector [data-required]
-     */
-    isRequired: boolean;
-}
-export interface DateFieldProps<T extends DateValue> extends Omit<AriaDateFieldProps<T>, 'label' | 'description' | 'errorMessage' | 'validationState' | 'validationBehavior'>, RACValidation, RenderProps<DateFieldRenderProps>, 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-DateField'
-     */
-    className?: ClassNameOrFunction<DateFieldRenderProps>;
-}
-export interface TimeFieldProps<T extends TimeValue> extends Omit<AriaTimeFieldProps<T>, 'label' | 'description' | 'errorMessage' | 'validationState' | 'validationBehavior'>, RACValidation, RenderProps<DateFieldRenderProps>, 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-TimeField'
-     */
-    className?: ClassNameOrFunction<DateFieldRenderProps>;
-}
-export const DateFieldContext: React.Context<ContextValue<DateFieldProps<any>, HTMLDivElement>>;
-export const TimeFieldContext: React.Context<ContextValue<TimeFieldProps<any>, HTMLDivElement>>;
-export const DateFieldStateContext: React.Context<DateFieldState | null>;
-export const TimeFieldStateContext: React.Context<TimeFieldState | null>;
-/**
- * A date field allows users to enter and edit date and time values using a keyboard.
- * Each part of a date value is displayed in an individually editable segment.
- */
-export const DateField: <T extends DateValue>(props: DateFieldProps<T> & React.RefAttributes<HTMLDivElement>) => ReactElement | null;
-/**
- * A time field allows users to enter and edit time values using a keyboard.
- * Each part of a time value is displayed in an individually editable segment.
- */
-export const TimeField: <T extends TimeValue>(props: TimeFieldProps<T> & React.RefAttributes<HTMLDivElement>) => ReactElement | null;
-export interface DateInputRenderProps {
-    /**
-     * Whether the date input is currently hovered with a mouse.
-     * @selector [data-hovered]
-     */
-    isHovered: boolean;
-    /**
-     * Whether an element within the date input is focused, either via a mouse or keyboard.
-     * @selector [data-focus-within]
-     */
-    isFocusWithin: boolean;
-    /**
-     * Whether an element within the date input is keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the date input is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the date input is invalid.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-}
-export interface DateInputProps extends SlotProps, StyleRenderProps<DateInputRenderProps>, 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-DateInput'
-     */
-    className?: ClassNameOrFunction<DateInputRenderProps>;
-    children: (segment: _DateSegment1) => ReactElement;
-}
-/**
- * A date input groups the editable date segments within a date field.
- */
-export const DateInput: (props: DateInputProps & React.RefAttributes<HTMLDivElement>) => ReactElement | null;
-export interface DateSegmentRenderProps extends Omit<_DateSegment1, 'isEditable'> {
-    /**
-     * Whether the segment is currently hovered with a mouse.
-     * @selector [data-hovered]
-     */
-    isHovered: boolean;
-    /**
-     * Whether the segment is focused, either via a mouse or keyboard.
-     * @selector [data-focused]
-     */
-    isFocused: boolean;
-    /**
-     * Whether the segment is keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the value is a placeholder.
-     * @selector [data-placeholder]
-     */
-    isPlaceholder: boolean;
-    /**
-     * Whether the segment is read only.
-     * @selector [data-readonly]
-     */
-    isReadOnly: boolean;
-    /**
-     * Whether the date field is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the date field is in an invalid state.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-    /**
-     * The type of segment. Values include `literal`, `year`, `month`, `day`, etc.
-     * @selector [data-type="..."]
-     */
-    type: DateSegmentType;
-}
-export interface DateSegmentProps extends RenderProps<DateSegmentRenderProps, 'span'>, HoverEvents, GlobalDOMAttributes<HTMLSpanElement> {
-    /**
-     * 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-DateSegment'
-     */
-    className?: ClassNameOrFunction<DateSegmentRenderProps>;
-    segment: _DateSegment1;
-}
-/**
- * A date segment displays an individual unit of a date and time, and allows users to edit
- * the value by typing or using the arrow keys to increment and decrement.
- */
-export const DateSegment: (props: DateSegmentProps & React.RefAttributes<HTMLSpanElement>) => ReactElement | null;
-export interface DatePickerRenderProps {
-    /**
-     * Whether an element within the date picker is focused, either via a mouse or keyboard.
-     * @selector [data-focus-within]
-     */
-    isFocusWithin: boolean;
-    /**
-     * Whether an element within the date picker is keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the date picker is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the date picker is read only.
-     * @selector [data-readonly]
-     */
-    isReadOnly: boolean;
-    /**
-     * Whether the date picker is invalid.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-    /**
-     * Whether the date picker is required.
-     * @selector [data-required]
-     */
-    isRequired: boolean;
-    /**
-     * Whether the date picker's popover is currently open.
-     * @selector [data-open]
-     */
-    isOpen: boolean;
-    /**
-     * State of the date picker.
-     */
-    state: DatePickerState;
-}
-export interface DateRangePickerRenderProps extends Omit<DatePickerRenderProps, 'state'> {
-    /**
-     * State of the date range picker.
-     */
-    state: DateRangePickerState;
-}
-export interface DatePickerProps<T extends DateValue> extends Omit<AriaDatePickerProps<T>, 'label' | 'description' | 'errorMessage' | 'validationState' | 'validationBehavior'>, Pick<DatePickerStateOptions<T>, 'shouldCloseOnSelect'>, RACValidation, RenderProps<DatePickerRenderProps>, 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-DatePicker'
-     */
-    className?: ClassNameOrFunction<DatePickerRenderProps>;
-}
-export interface DateRangePickerProps<T extends DateValue> extends Omit<AriaDateRangePickerProps<T>, 'label' | 'description' | 'errorMessage' | 'validationState' | 'validationBehavior'>, Pick<DateRangePickerStateOptions<T>, 'shouldCloseOnSelect'>, RACValidation, RenderProps<DateRangePickerRenderProps>, 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-DateRangePicker'
-     */
-    className?: ClassNameOrFunction<DateRangePickerRenderProps>;
-}
-export const DatePickerContext: React.Context<ContextValue<DatePickerProps<any>, HTMLDivElement>>;
-export const DateRangePickerContext: React.Context<ContextValue<DateRangePickerProps<any>, HTMLDivElement>>;
-export const DatePickerStateContext: React.Context<DatePickerState | null>;
-export const DateRangePickerStateContext: React.Context<DateRangePickerState | null>;
-/**
- * A date picker combines a DateField and a Calendar popover to allow users to enter or select a date and time value.
- */
-export const DatePicker: <T extends DateValue>(props: DatePickerProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-/**
- * A date range picker combines two DateFields and a RangeCalendar popover to allow
- * users to enter or select a date and time range.
- */
-export const DateRangePicker: <T extends DateValue>(props: DateRangePickerProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface DisclosureGroupProps extends _DisclosureGroupProps1, RenderProps<DisclosureGroupRenderProps>, _DOMProps1, 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-DisclosureGroup'
-     */
-    className?: ClassNameOrFunction<DisclosureGroupRenderProps>;
-}
-export interface DisclosureGroupRenderProps {
-    /**
-     * Whether the disclosure group is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * State of the disclosure group.
-     */
-    state: DisclosureGroupState;
-}
-export const DisclosureGroupStateContext: React.Context<DisclosureGroupState | null>;
-/**
- * A DisclosureGroup is a grouping of related disclosures, sometimes called an accordion.
- * It supports both single and multiple expanded items.
- */
-export const DisclosureGroup: React.ForwardRefExoticComponent<DisclosureGroupProps & React.RefAttributes<HTMLDivElement>>;
-export interface DisclosureProps extends Omit<AriaDisclosureProps, 'children'>, RenderProps<DisclosureRenderProps>, 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-Disclosure'
-     */
-    className?: ClassNameOrFunction<DisclosureRenderProps>;
-    /** An id for the disclosure when used within a DisclosureGroup, matching the id used in `expandedKeys`. */
-    id?: Key;
-}
-export interface DisclosureRenderProps {
-    /**
-     * Whether the disclosure is expanded.
-     * @selector [data-expanded]
-     */
-    isExpanded: boolean;
-    /**
-     * Whether the disclosure has keyboard focus.
-     * @selector [data-focus-visible-within]
-     */
-    isFocusVisibleWithin: boolean;
-    /**
-     * Whether the disclosure is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * State of the disclosure.
-     */
-    state: DisclosureState;
-}
-export const DisclosureContext: React.Context<ContextValue<DisclosureProps, HTMLDivElement>>;
-export const DisclosureStateContext: React.Context<DisclosureState | null>;
-/**
- * A disclosure is a collapsible section of content. It is composed of a a header with a heading and trigger button, and a panel that contains the content.
- */
-export const Disclosure: (props: DisclosureProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface DisclosurePanelRenderProps {
-    /**
-     * Whether keyboard focus is within the disclosure panel.
-     * @selector [data-focus-visible-within]
-     */
-    isFocusVisibleWithin: boolean;
-}
-export interface DisclosurePanelProps extends RenderProps<DisclosurePanelRenderProps>, _DOMProps1, LabelAriaProps, 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-DisclosurePanel'
-     */
-    className?: ClassNameOrFunction<DisclosurePanelRenderProps>;
-    /**
-     * The accessibility role for the disclosure's panel.
-     * @default 'group'
-     */
-    role?: 'group' | 'region';
-    /**
-     * The children of the component.
-     */
-    children: ReactNode;
-}
-/**
- * A DisclosurePanel provides the content for a disclosure.
- */
-export const DisclosurePanel: (props: DisclosurePanelProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface DropZoneRenderProps {
-    /**
-     * Whether the dropzone is currently hovered with a mouse.
-     * @selector [data-hovered]
-     */
-    isHovered: boolean;
-    /**
-     * Whether the dropzone is focused, either via a mouse or keyboard.
-     * @selector [data-focused]
-     */
-    isFocused: boolean;
-    /**
-     * Whether the dropzone is keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the dropzone is the drop target.
-     * @selector [data-drop-target]
-     */
-    isDropTarget: boolean;
-    /**
-     * Whether the dropzone is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-}
-export interface DropZoneProps extends Omit<DropOptions, 'getDropOperationForPoint' | 'ref' | 'hasDropButton'>, _HoverEvents1, RenderProps<DropZoneRenderProps>, SlotProps, AriaLabelingProps, 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-DropZone'
-     */
-    className?: ClassNameOrFunction<DropZoneRenderProps>;
-}
-export const DropZoneContext: React.Context<ContextValue<DropZoneProps, HTMLDivElement>>;
-/**
- * A drop zone is an area into which one or multiple objects can be dragged and dropped.
- */
-export const DropZone: React.ForwardRefExoticComponent<DropZoneProps & React.RefAttributes<HTMLDivElement>>;
-export interface FileTriggerProps extends GlobalDOMAttributes<HTMLInputElement> {
-    /**
-     * Specifies what mime type of files are allowed.
-     */
-    acceptedFileTypes?: ReadonlyArray<string>;
-    /**
-     * Whether multiple files can be selected.
-     */
-    allowsMultiple?: boolean;
-    /**
-     * Specifies the use of a media capture mechanism to capture the media on the spot.
-     */
-    defaultCamera?: 'user' | 'environment';
-    /**
-     * Handler when a user selects a file.
-     */
-    onSelect?: (files: FileList | null) => void;
-    /**
-     * The children of the component.
-     */
-    children?: ReactNode;
-    /**
-     * Enables the selection of directories instead of individual files.
-     */
-    acceptDirectory?: boolean;
-}
-/**
- * A FileTrigger allows a user to access the file system with any pressable React Aria or React Spectrum component, or custom components built with usePress.
- */
-export const FileTrigger: React.ForwardRefExoticComponent<FileTriggerProps & React.RefAttributes<HTMLInputElement>>;
-export interface GridListRenderProps {
-    /**
-     * Whether the list has no items and should display its empty state.
-     * @selector [data-empty]
-     */
-    isEmpty: boolean;
-    /**
-     * Whether the grid list is currently focused.
-     * @selector [data-focused]
-     */
-    isFocused: boolean;
-    /**
-     * Whether the grid list is currently keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the grid list is currently the active drop target.
-     * @selector [data-drop-target]
-     */
-    isDropTarget: boolean;
-    /**
-     * Whether the items are arranged in a stack or grid.
-     * @selector [data-layout="stack | grid"]
-     */
-    layout: 'stack' | 'grid';
-    /**
-     * State of the grid list.
-     */
-    state: ListState<unknown>;
-}
-export interface GridListProps<T> extends Omit<AriaGridListProps<T>, 'children'>, CollectionProps<T>, StyleRenderProps<GridListRenderProps>, 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-GridList'
-     */
-    className?: ClassNameOrFunction<GridListRenderProps>;
-    /**
-     * Whether typeahead navigation is disabled.
-     * @default false
-     */
-    disallowTypeAhead?: boolean;
-    /**
-     * How multiple selection should behave in the collection.
-     * @default "toggle"
-     */
-    selectionBehavior?: SelectionBehavior;
-    /** The drag and drop hooks returned by `useDragAndDrop` used to enable drag and drop behavior for the GridList. */
-    dragAndDropHooks?: DragAndDropHooks<NoInfer<T>>;
-    /** Provides content to display when there are no items in the list. */
-    renderEmptyState?: (props: GridListRenderProps) => ReactNode;
-    /**
-     * Whether the items are arranged in a stack or grid.
-     * @default 'stack'
-     */
-    layout?: 'stack' | 'grid';
-}
-export const GridListContext: React.Context<ContextValue<GridListProps<any>, HTMLDivElement>>;
-/**
- * A grid list displays a list of interactive items, with support for keyboard navigation,
- * single or multiple selection, and row actions.
- */
-export const GridList: <T extends object>(props: GridListProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface GridListItemRenderProps extends ItemRenderProps {
-    /** The unique id of the item. */
-    id?: Key;
-    /**
-     * State of the grid list.
-     */
-    state: ListState<unknown>;
-}
-export interface GridListItemProps<T = object> extends RenderProps<GridListItemRenderProps>, LinkDOMProps, _HoverEvents1, 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-GridListItem'
-     */
-    className?: ClassNameOrFunction<GridListItemRenderProps>;
-    /** The unique id of the item. */
-    id?: Key;
-    /** The object value that this item represents. When using dynamic collections, this is set automatically. */
-    value?: T;
-    /** A string representation of the item's contents, used for features like typeahead. */
-    textValue?: string;
-    /** Whether the item 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 GridListItem represents an individual item in a GridList.
- */
-export const GridListItem: <T extends object>(props: GridListItemProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface GridListLoadMoreItemProps extends Omit<LoadMoreSentinelProps, 'collection'>, 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-GridListLoadMoreItem'
-     */
-    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 const GridListLoadMoreItem: (props: GridListLoadMoreItemProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface GridListSectionProps<T> extends SectionProps<T>, DOMRenderProps<'div', undefined> {
-    /**
-     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element.
-     * @default 'react-aria-GridListSection'
-     */
-    className?: string;
-}
-/**
- * A GridListSection represents a section within a GridList.
- */
-export const GridListSection: <T extends object>(props: GridListSectionProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-interface GridListHeaderProps extends DOMRenderProps<'div', undefined>, DOMProps, GlobalDOMAttributes<HTMLElement> {
-}
-export const GridListHeaderContext: React.Context<ContextValue<GridListHeaderProps, HTMLDivElement>>;
-export const GridListHeader: (props: GridListHeaderProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface MeterProps extends Omit<AriaMeterProps, 'label'>, RenderProps<MeterRenderProps>, 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-Meter'
-     */
-    className?: ClassNameOrFunction<MeterRenderProps>;
-}
-export interface MeterRenderProps {
-    /**
-     * The value as a percentage between the minimum and maximum.
-     */
-    percentage: number;
-    /**
-     * A formatted version of the value.
-     * @selector [aria-valuetext]
-     */
-    valueText: string | undefined;
-}
-export const MeterContext: React.Context<ContextValue<MeterProps, HTMLDivElement>>;
-/**
- * A meter represents a quantity within a known range, or a fractional value.
- */
-export const Meter: (props: MeterProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface ModalOverlayProps extends AriaModalOverlayProps, OverlayTriggerProps, RenderProps<ModalRenderProps>, 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-ModalOverlay'
-     */
-    className?: ClassNameOrFunction<ModalRenderProps>;
-    /**
-     * Whether the modal is currently performing an entry animation.
-     */
-    isEntering?: boolean;
-    /**
-     * Whether the modal 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.
-     * @default document.body
-     * @deprecated - Use a parent UNSAFE_PortalProvider to set your portal container instead.
-     */
-    UNSTABLE_portalContainer?: Element;
-}
-export const ModalContext: React.Context<ContextValue<ModalOverlayProps, HTMLDivElement>>;
-export interface ModalRenderProps {
-    /**
-     * Whether the modal is currently entering. Use this to apply animations.
-     * @selector [data-entering]
-     */
-    isEntering: boolean;
-    /**
-     * Whether the modal is currently exiting. Use this to apply animations.
-     * @selector [data-exiting]
-     */
-    isExiting: boolean;
-    /**
-     * State of the modal.
-     */
-    state: OverlayTriggerState;
-}
-/**
- * A modal is an overlay element which blocks interaction with elements outside it.
- */
-export const Modal: (props: ModalOverlayProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-/**
- * A ModalOverlay is a wrapper for a Modal which allows customizing the backdrop element.
- */
-export const ModalOverlay: (props: ModalOverlayProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface NumberFieldRenderProps {
-    /**
-     * Whether the number field is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the number field is invalid.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-    /**
-     * Whether the number field is required.
-     * @selector [data-required]
-     */
-    isRequired: boolean;
-    /**
-     * State of the number field.
-     */
-    state: NumberFieldState;
-}
-export interface NumberFieldProps extends Omit<AriaNumberFieldProps, 'label' | 'placeholder' | 'description' | 'errorMessage' | 'validationState' | 'validationBehavior'>, RACValidation, InputDOMProps, RenderProps<NumberFieldRenderProps>, 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-NumberField'
-     */
-    className?: ClassNameOrFunction<NumberFieldRenderProps>;
-}
-export const NumberFieldContext: React.Context<ContextValue<NumberFieldProps, HTMLDivElement>>;
-export const NumberFieldStateContext: React.Context<NumberFieldState | null>;
-/**
- * A number field allows a user to enter a number, and increment or decrement the value using stepper buttons.
- */
-export const NumberField: (props: NumberFieldProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface RadioGroupProps extends Omit<AriaRadioGroupProps, 'children' | 'label' | 'description' | 'errorMessage' | 'validationState' | 'validationBehavior'>, RACValidation, RenderProps<RadioGroupRenderProps>, 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-RadioGroup'
-     */
-    className?: ClassNameOrFunction<RadioGroupRenderProps>;
-}
-export interface RadioProps extends Omit<AriaRadioProps, 'children'>, HoverEvents, RenderProps<RadioRenderProps, 'label'>, SlotProps, Omit<GlobalDOMAttributes<HTMLLabelElement>, '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-Radio'
-     */
-    className?: ClassNameOrFunction<RadioRenderProps>;
-    /**
-     * A ref for the HTML input element.
-     */
-    inputRef?: RefObject<HTMLInputElement | null>;
-}
-export interface RadioGroupRenderProps {
-    /**
-     * The orientation of the radio group.
-     * @selector [data-orientation="horizontal | vertical"]
-     */
-    orientation: Orientation;
-    /**
-     * Whether the radio group is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the radio group is read only.
-     * @selector [data-readonly]
-     */
-    isReadOnly: boolean;
-    /**
-     * Whether the radio group is required.
-     * @selector [data-required]
-     */
-    isRequired: boolean;
-    /**
-     * Whether the radio group is invalid.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-    /**
-     * State of the radio group.
-     */
-    state: RadioGroupState;
-}
-export interface RadioRenderProps {
-    /**
-     * Whether the radio is selected.
-     * @selector [data-selected]
-     */
-    isSelected: boolean;
-    /**
-     * Whether the radio is currently hovered with a mouse.
-     * @selector [data-hovered]
-     */
-    isHovered: boolean;
-    /**
-     * Whether the radio is currently in a pressed state.
-     * @selector [data-pressed]
-     */
-    isPressed: boolean;
-    /**
-     * Whether the radio is focused, either via a mouse or keyboard.
-     * @selector [data-focused]
-     */
-    isFocused: boolean;
-    /**
-     * Whether the radio is keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the radio is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the radio is read only.
-     * @selector [data-readonly]
-     */
-    isReadOnly: boolean;
-    /**
-     * Whether the radio is invalid.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-    /**
-     * Whether the checkbox is required.
-     * @selector [data-required]
-     */
-    isRequired: boolean;
-}
-export const RadioGroupContext: React.Context<ContextValue<RadioGroupProps, HTMLDivElement>>;
-export const RadioContext: React.Context<ContextValue<Partial<RadioProps>, HTMLLabelElement>>;
-export const RadioGroupStateContext: React.Context<RadioGroupState | null>;
-/**
- * A radio group allows a user to select a single item from a list of mutually exclusive options.
- */
-export const RadioGroup: (props: RadioGroupProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-/**
- * A radio represents an individual option within a radio group.
- */
-export const Radio: (props: RadioProps & React.RefAttributes<HTMLLabelElement>) => React.ReactElement | null;
-export interface SearchFieldRenderProps {
-    /**
-     * Whether the search field is empty.
-     * @selector [data-empty]
-     */
-    isEmpty: boolean;
-    /**
-     * Whether the search field is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the search field is invalid.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-    /**
-     * Whether the search field is read only.
-     * @selector [data-readonly]
-     */
-    isReadOnly: boolean;
-    /**
-     * Whether the search field is required.
-     * @selector [data-required]
-     */
-    isRequired: boolean;
-    /**
-     * State of the search field.
-     */
-    state: SearchFieldState;
-}
-export interface SearchFieldProps extends Omit<AriaSearchFieldProps, 'label' | 'placeholder' | 'description' | 'errorMessage' | 'validationState' | 'validationBehavior'>, RACValidation, RenderProps<SearchFieldRenderProps>, 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-SearchField'
-     */
-    className?: ClassNameOrFunction<SearchFieldRenderProps>;
-}
-export const SearchFieldContext: React.Context<ContextValue<SearchFieldProps, HTMLDivElement>>;
-/**
- * A search field allows a user to enter and clear a search query.
- */
-export const SearchField: (props: SearchFieldProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-type _SelectionMode1 = 'single' | 'multiple';
-export interface SelectRenderProps {
-    /**
-     * Whether the select is focused, either via a mouse or keyboard.
-     * @selector [data-focused]
-     */
-    isFocused: boolean;
-    /**
-     * Whether the select is keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the select is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the select is currently open.
-     * @selector [data-open]
-     */
-    isOpen: boolean;
-    /**
-     * Whether the select is invalid.
-     * @selector [data-invalid]
-     */
-    isInvalid: boolean;
-    /**
-     * Whether the select is required.
-     * @selector [data-required]
-     */
-    isRequired: boolean;
-}
-export interface SelectProps<T extends object = {}, M extends _SelectionMode1 = 'single'> extends Omit<AriaSelectProps<T, M>, 'children' | 'label' | 'description' | 'errorMessage' | 'validationState' | 'validationBehavior' | 'items'>, RACValidation, RenderProps<SelectRenderProps>, 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-Select'
-     */
-    className?: ClassNameOrFunction<SelectRenderProps>;
-    /**
-     * Temporary text that occupies the select when it is empty.
-     * @default 'Select an item' (localized)
-     */
-    placeholder?: string;
-}
-export const SelectContext: React.Context<ContextValue<SelectProps<any, _SelectionMode1>, HTMLDivElement>>;
-export const SelectStateContext: React.Context<SelectState<unknown, _SelectionMode1> | null>;
-/**
- * A select displays a collapsible list of options and allows a user to select one of them.
- */
-export const Select: <T extends object = {}, M extends _SelectionMode1 = "single">(props: SelectProps<T, M> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export interface SelectValueRenderProps<T> {
-    /**
-     * Whether the value is a placeholder.
-     * @selector [data-placeholder]
-     */
-    isPlaceholder: boolean;
-    /**
-     * The object value of the first selected item.
-     * @deprecated
-     */
-    selectedItem: T | null;
-    /** The object values of the currently selected items. */
-    selectedItems: (T | null)[];
-    /** The textValue of the currently selected items. */
-    selectedText: string;
-    /** The state of the select. */
-    state: SelectState<T, 'single' | 'multiple'>;
-}
-export interface SelectValueProps<T extends object> extends Omit<HTMLAttributes<HTMLElement>, keyof RenderProps<unknown>>, RenderProps<SelectValueRenderProps<T>, 'span'> {
-    /**
-     * 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-SelectValue'
-     */
-    className?: ClassNameOrFunction<SelectValueRenderProps<T>>;
-}
-export const SelectValueContext: React.Context<ContextValue<SelectValueProps<any>, HTMLSpanElement>>;
-/**
- * SelectValue renders the current value of a Select, or a placeholder if no value is selected.
- * It is usually placed within the button element.
- */
-export const SelectValue: <T extends object>(props: SelectValueProps<T> & React.RefAttributes<HTMLSpanElement>) => React.ReactElement | null;
-export interface SwitchProps extends Omit<AriaSwitchProps, 'children'>, HoverEvents, RenderProps<SwitchRenderProps, 'label'>, SlotProps, Omit<GlobalDOMAttributes<HTMLLabelElement>, '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-Switch'
-     */
-    className?: ClassNameOrFunction<SwitchRenderProps>;
-    /**
-     * A ref for the HTML input element.
-     */
-    inputRef?: RefObject<HTMLInputElement | null>;
-}
-export interface SwitchRenderProps {
-    /**
-     * Whether the switch is selected.
-     * @selector [data-selected]
-     */
-    isSelected: boolean;
-    /**
-     * Whether the switch is currently hovered with a mouse.
-     * @selector [data-hovered]
-     */
-    isHovered: boolean;
-    /**
-     * Whether the switch is currently in a pressed state.
-     * @selector [data-pressed]
-     */
-    isPressed: boolean;
-    /**
-     * Whether the switch is focused, either via a mouse or keyboard.
-     * @selector [data-focused]
-     */
-    isFocused: boolean;
-    /**
-     * Whether the switch is keyboard focused.
-     * @selector [data-focus-visible]
-     */
-    isFocusVisible: boolean;
-    /**
-     * Whether the switch is disabled.
-     * @selector [data-disabled]
-     */
-    isDisabled: boolean;
-    /**
-     * Whether the switch is read only.
-     * @selector [data-readonly]
-     */
-    isReadOnly: boolean;
-    /**
-     * State of the switch.
-     */
-    state: ToggleState;
-}
-export const SwitchContext: React.Context<ContextValue<SwitchProps, HTMLLabelElement>>;
-/**
- * A switch allows a user to turn a setting on or off.
- */
-export const Switch: (props: SwitchProps & React.RefAttributes<HTMLLabelElement>) => React.ReactElement | null;
-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 const ResizableTableContainer: React.ForwardRefExoticComponent<ResizableTableContainerProps & React.RefAttributes<HTMLDivElement>>;
-export const TableContext: React.Context<ContextValue<TableProps, HTMLDivElement | HTMLTableElement>>;
-export const TableStateContext: React.Context<TableState<any> | null>;
-export 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<_TableProps1<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 const Table: React.ForwardRefExoticComponent<TableProps & React.RefAttributes<HTMLDivElement | HTMLTableElement>>;
-interface TableOptionsContextValue {
-    /** The type of selection that is allowed in the table. */
-    selectionMode: _SelectionMode2;
-    /** 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 function useTableOptions(): TableOptionsContextValue;
-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'>, _HoverEvents1, 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 const TableHeader: <T extends object>(props: TableHeaderProps<T> & React.RefAttributes<HTMLDivElement | HTMLTableSectionElement>) => ReactElement | 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 const Column: (props: ColumnProps & React.RefAttributes<HTMLDivElement | HTMLTableCellElement>) => ReactElement | 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 _HoverEvents1, 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 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 const TableBody: <T extends object>(props: TableBodyProps<T> & React.RefAttributes<HTMLDivElement | HTMLTableSectionElement>) => ReactElement | null;
-export interface RowRenderProps extends ItemRenderProps {
-    /** Whether the row's children have keyboard focus. */
-    isFocusVisibleWithin: boolean;
-    /** The unique id of the row. */
-    id?: Key;
-}
-export interface RowProps<T> extends StyleRenderProps<RowRenderProps, 'tr' | 'div'>, LinkDOMProps, _HoverEvents1, 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;
-}
-/**
- * A row within a `<Table>`.
- */
-export const Row: <T extends object>(props: RowProps<T> & React.RefAttributes<HTMLDivElement | HTMLTableRowElement>) => ReactElement | 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;
-    /**
-     * The unique id of the cell.
-     **/
-    id?: Key;
-    /**
-     * The index of the column that this cell belongs to. Respects col spanning.
-     */
-    columnIndex?: number | null;
-}
-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 const Cell: (props: CellProps & React.RefAttributes<HTMLDivElement | HTMLTableCellElement>) => ReactElement | 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 const TableLoadMoreItem: (props: TableLoadMoreItemProps & React.RefAttributes<HTMLTableRowElement>) => ReactElement | null;
-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;
-}
-/**
- * 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 function Virtualizer<O>(props: VirtualizerProps<O>): JSX.Element;
-export class TableLayout<T, O extends TableLayoutProps = TableLayoutProps> extends _TableLayout1<T, O> implements LayoutOptionsDelegate<TableLayoutProps> {
-    useLayoutOptions(): TableLayoutProps;
-}
-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, _HoverEvents1, 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 const TabsContext: React.Context<ContextValue<TabsProps, HTMLDivElement>>;
-export const TabListStateContext: React.Context<TabListState<object> | null>;
-/**
- * Tabs organize content into multiple sections and allow users to navigate between them.
- */
-export const Tabs: (props: TabsProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | 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 const TabList: <T extends object>(props: TabListProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-/**
- * A Tab provides a title for an individual item within a TabList.
- */
-export const Tab: (props: TabProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | 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 const TabPanels: <T extends object>(props: TabPanelsProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-/**
- * A TabPanel provides the content for a tab.
- */
-export const TabPanel: (props: TabPanelProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-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 const TagGroupContext: React.Context<ContextValue<TagGroupProps, HTMLDivElement>>;
-export 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 const TagGroup: (props: TagGroupProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-/**
- * A tag list is a container for tags within a TagGroup.
- */
-export const TagList: <T extends object>(props: TagListProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | 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, _HoverEvents1, 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;
-}
-/**
- * A Tag is an individual item within a TagList.
- */
-export const Tag: (props: TagProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-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 const TextAreaContext: React.Context<ContextValue<TextAreaProps, HTMLTextAreaElement>>;
-/**
- * A textarea allows a user to input mult-line text.
- */
-export const TextArea: React.ForwardRefExoticComponent<TextAreaProps & React.RefAttributes<HTMLTextAreaElement>>;
-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<_AriaTextFieldProps1, '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 const TextFieldContext: React.Context<ContextValue<TextFieldProps, HTMLDivElement>>;
-/**
- * A text field allows a user to enter a plain text value with a keyboard.
- */
-export const TextField: (props: TextFieldProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-export const UNSTABLE_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.
- */
-export const UNSTABLE_ToastRegion: <T>(props: ToastRegionProps<T> & React.RefAttributes<HTMLDivElement>) => ReactElement | 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;
-}
-export const UNSTABLE_ToastList: <T>(props: ToastListProps<T> & React.RefAttributes<HTMLOListElement>) => ReactElement | 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.
- */
-export const UNSTABLE_Toast: <T>(props: ToastProps<T> & React.RefAttributes<HTMLDivElement>) => ReactElement | null;
-interface ToastContentProps extends HTMLAttributes<HTMLElement>, DOMRenderProps<'div', undefined> {
-}
-/**
- * ToastContent wraps the main content of a toast notification.
- */
-export const UNSTABLE_ToastContent: React.ForwardRefExoticComponent<ToastContentProps & React.RefAttributes<HTMLDivElement>>;
-export interface ToggleButtonGroupRenderProps {
-    /**
-     * The orientation of the toggle button group.
-     * @selector [data-orientation="horizontal | vertical"]
-     */
-    orientation: _Orientation2;
-    /**
-     * 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 const ToggleButtonGroupContext: React.Context<ContextValue<ToggleButtonGroupProps, HTMLDivElement>>;
-export const ToggleGroupStateContext: React.Context<ToggleGroupState | null>;
-/**
- * A toggle button group allows a user to toggle multiple options, with single or multiple selection.
- */
-export const ToggleButtonGroup: (props: ToggleButtonGroupProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-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 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 const ToggleButton: (props: ToggleButtonProps & React.RefAttributes<HTMLButtonElement>) => React.ReactElement | null;
-export interface ToolbarRenderProps {
-    /**
-     * The current orientation of the toolbar.
-     * @selector [data-orientation]
-     */
-    orientation: _Orientation2;
-}
-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 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 const Toolbar: (props: ToolbarProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-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.
-     * @default document.body
-     * @deprecated - Use a parent UNSAFE_PortalProvider to set your portal container instead.
-     */
-    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 const TooltipTriggerStateContext: React.Context<TooltipTriggerState | null>;
-export 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 function TooltipTrigger(props: TooltipTriggerComponentProps): JSX.Element;
-/**
- * A tooltip displays a description of an element on hover or focus.
- */
-export const Tooltip: (props: TooltipProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-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: _SelectionMode3;
-    /**
-     * Whether the tree allows dragging.
-     * @selector [data-allows-dragging]
-     */
-    allowsDragging: boolean;
-    /**
-     * State of the tree.
-     */
-    state: TreeState<unknown>;
-}
-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?: _DisabledBehavior1;
-    /** The drag and drop hooks returned by `useDragAndDrop` used to enable drag and drop behavior for the Tree. */
-    dragAndDropHooks?: DragAndDropHooks<NoInfer<T>>;
-}
-export const TreeContext: React.Context<ContextValue<TreeProps<any>, HTMLDivElement>>;
-export 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 const Tree: <T extends object>(props: TreeProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | 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 const TreeItemContent: (props: TreeItemContentProps & React.RefAttributes<Element>) => React.ReactElement | null;
-export interface TreeItemProps<T = object> extends StyleRenderProps<TreeItemRenderProps>, LinkDOMProps, _HoverEvents1, 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.
-     * @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 const TreeItem: <T extends object>(props: TreeItemProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | 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.
-     * @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 const TreeLoadMoreItem: <T extends object>(props: TreeLoadMoreItemProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
-interface _GridListSectionProps1<T> extends SectionProps<T>, DOMRenderProps<'section', undefined> {
-}
-/**
- * A TreeSection represents a section within a Tree.
- */
-export const TreeSection: <T extends object>(props: _GridListSectionProps1<T> & React.RefAttributes<HTMLElement>) => React.ReactElement | null;
-export const TreeHeader: (props: GridListHeaderProps) => ReactNode;
-export { Collection, createLeafComponent, createBranchComponent, CollectionBuilder } from '@react-aria/collections';
-export { useDrag, useDrop } from '@react-aria/dnd';
-export { DIRECTORY_DRAG_TYPE, isDirectoryDropItem, isFileDropItem, isTextDropItem, SSRProvider, RouterProvider, I18nProvider, isRTL, useLocale, useFilter, Pressable, Focusable, VisuallyHidden } from 'react-aria';
-export { FormValidationContext, parseColor, getColorChannels, ToastQueue as UNSTABLE_ToastQueue, useListData, useTreeData, useAsyncList } from 'react-stately';
-export { ListLayout, GridLayout, WaterfallLayout } from '@react-stately/layout';
-export { Layout, LayoutInfo, Size, Rect, Point } from '@react-stately/virtualizer';
-export type { DragOptions, DragResult } from '@react-aria/dnd';
-export type { DateValue, DateRange, TimeValue } from 'react-aria';
-export type { DirectoryDropItem, DraggableCollectionEndEvent, DraggableCollectionMoveEvent, DraggableCollectionStartEvent, DragPreviewRenderer, DragTypes, DropItem, DropOperation, DroppableCollectionDropEvent, DroppableCollectionEnterEvent, DroppableCollectionExitEvent, DroppableCollectionInsertDropEvent, DroppableCollectionMoveEvent, DroppableCollectionOnItemDropEvent, DroppableCollectionReorderEvent, DroppableCollectionRootDropEvent, DropPosition, DropTarget, FileDropItem, ItemDropTarget, RootDropTarget, TextDropItem, PressEvent } from 'react-aria';
-export type { CalendarState, CheckboxGroupState, Color, ColorAreaState, ColorFieldState, ColorFormat, ColorPickerState, ColorSliderState, ColorSpace, ColorWheelState, ComboBoxState, DateFieldState, DatePickerState, DateRangePickerState, DisclosureState, DisclosureGroupState, Key, ListState, NumberFieldState, OverlayTriggerState, QueuedToast, RadioGroupState, RangeCalendarState, RootMenuTriggerState, SearchFieldState, Selection, SelectState, SliderState, SortDescriptor, SortDirection, SelectionMode, TableState, TabListState, TimeFieldState, ToastOptions, ToastState, ToggleGroupState, ToggleState, TooltipTriggerState, TreeState, ListData, TreeData, AsyncListData } from 'react-stately';
-export type { AutocompleteState } from '@react-stately/autocomplete';
-export type { ListLayoutOptions, GridLayoutOptions, WaterfallLayoutOptions } from '@react-stately/layout';
-export type { RangeValue, ValidationResult, RouterConfig } from '@react-types/shared';
-
-//# sourceMappingURL=types.d.ts.map