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