import React, { ReactNode, MouseEventHandler, TouchEventHandler, PointerEventHandler, UIEventHandler, WheelEventHandler, AnimationEventHandler, TransitionEventHandler, ClipboardEventHandler, CompositionEventHandler, ReactEventHandler, FormEventHandler, HTMLAttributeAnchorTarget, HTMLAttributeReferrerPolicy, ReactElement, MouseEvent, FocusEvent, SyntheticEvent, KeyboardEvent as KeyboardEvent$2, CSSProperties, DetailedHTMLProps, AnchorHTMLAttributes, ElementType, JSXElementConstructor, ButtonHTMLAttributes, HTMLAttributes, Ref, JSX, InputHTMLAttributes, LabelHTMLAttributes } from 'react';

/*
 * Copyright 2020 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */



type ValidationState = 'valid' | 'invalid';

type ValidationError = string | string[];

interface Validation<T = unknown> {
  /** Whether user input is required on the input before form submission. */
  isRequired?: boolean;
  /** Whether the input value is invalid. */
  isInvalid?: boolean;
  /** @deprecated Use `isInvalid` instead. */
  validationState?: ValidationState;
  /**
   * 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 'aria'
   */
  validationBehavior?: 'aria' | 'native';
  /**
   * A function that returns an error message if a given value is invalid.
   * Validation errors are displayed to the user when the form is submitted
   * if `validationBehavior="native"`. For realtime validation, use the `isInvalid`
   * prop instead.
   */
  validate?: (value: T) => ValidationError | true | null | undefined;
}

interface ValidationResult {
  /** Whether the input value is invalid. */
  isInvalid: boolean;
  /** The current error messages for the input if it is invalid, otherwise an empty array. */
  validationErrors: string[];
  /** The native validation details for the input. */
  validationDetails: ValidityState;
}

interface InputBase {
  /** Whether the input is disabled. */
  isDisabled?: boolean;
  /** Whether the input can be selected but not changed by the user. */
  isReadOnly?: boolean;
}

interface ValueBase<T, C = T> {
  /** The current value (controlled). */
  value?: T;
  /** The default value (uncontrolled). */
  defaultValue?: T;
  /** Handler that is called when the value changes. */
  onChange?: (value: C) => void;
}

interface TextInputBase {
  /** Temporary text that occupies the text input when it is empty. */
  placeholder?: string;
}

interface RangeValue<T> {
  /** The start value of the range. */
  start: T;
  /** The end value of the range. */
  end: T;
}

interface RangeInputBase<T> {
  /** The smallest value allowed for the input. */
  minValue?: T;
  /** The largest value allowed for the input. */
  maxValue?: T;
  /** The amount that the input value changes with each increment or decrement "tick". */
  step?: T; // ??
}

interface HelpTextProps {
  /** A description for the field. Provides a hint such as specific requirements for what to choose. */
  description?: ReactNode;
  /** An error message for the field. */
  errorMessage?: ReactNode | ((v: ValidationResult) => ReactNode);
}

/*
 * Copyright 2020 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */



interface AriaLabelingProps {
  /**
   * Defines a string value that labels the current element.
   */
  'aria-label'?: string;

  /**
   * Identifies the element (or elements) that labels the current element.
   */
  'aria-labelledby'?: string;

  /**
   * Identifies the element (or elements) that describes the object.
   */
  'aria-describedby'?: string;

  /**
   * Identifies the element (or elements) that provide a detailed, extended description for the
   * object.
   */
  'aria-details'?: string;
}

interface AriaValidationProps {
  // https://www.w3.org/TR/wai-aria-1.2/#aria-errormessage
  /**
   * Identifies the element that provides an error message for the object.
   */
  'aria-errormessage'?: string;
}

// A set of common DOM props that are allowed on any component
// Ensure this is synced with DOMPropNames in filterDOMProps
interface DOMProps$1 {
  /**
   * The element's unique identifier. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id).
   */
  id?: string;
}

interface FocusableDOMProps extends DOMProps$1 {
  /**
   * Whether to exclude the element from the sequential tab order. If true,
   * the element will not be focusable via the keyboard by tabbing. This should
   * be avoided except in rare scenarios where an alternative means of accessing
   * the element or its functionality via the keyboard is available.
   */
  excludeFromTabOrder?: boolean;
}

interface TextInputDOMEvents<T = HTMLInputElement> {
  // Clipboard events
  /**
   * Handler that is called when the user copies text. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/oncopy).
   */
  onCopy?: ClipboardEventHandler<T>;

  /**
   * Handler that is called when the user cuts text. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/oncut).
   */
  onCut?: ClipboardEventHandler<T>;

  /**
   * Handler that is called when the user pastes text. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/onpaste).
   */
  onPaste?: ClipboardEventHandler<T>;

  // Composition events
  /**
   * Handler that is called when a text composition system starts a new text composition session.
   * See [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Element/compositionstart_event).
   */
  onCompositionStart?: CompositionEventHandler<T>;

  /**
   * Handler that is called when a text composition system completes or cancels the current text
   * composition session. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Element/compositionend_event).
   */
  onCompositionEnd?: CompositionEventHandler<T>;

  /**
   * Handler that is called when a new character is received in the current text composition
   * session. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Element/compositionupdate_event).
   */
  onCompositionUpdate?: CompositionEventHandler<T>;

  // Selection events
  /**
   * Handler that is called when text in the input is selected. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Element/select_event).
   */
  onSelect?: ReactEventHandler<T>;

  // Input events
  /**
   * Handler that is called when the input value is about to be modified. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/beforeinput_event).
   */
  onBeforeInput?: FormEventHandler<T>;
  /**
   * Handler that is called when the input value is modified. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/input_event).
   */
  onInput?: FormEventHandler<T>;
}

interface InputDOMProps {
  /**
   * The name of the input element, used when submitting an HTML form. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefname).
   */
  name?: string;
  /**
   * The `<form>` element to associate the input with.
   * The value of this attribute must be the id of a `<form>` in the same document.
   * See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#form).
   */
  form?: string;
}

// DOM props that apply to all text inputs
// Ensure this is synced with useTextField
interface TextInputDOMProps<T = HTMLInputElement>
  extends DOMProps$1, InputDOMProps, TextInputDOMEvents<T> {
  /**
   * Describes the type of autocomplete functionality the input should provide if any. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefautocomplete).
   */
  autoComplete?: string;

  /**
   * The maximum number of characters supported by the input. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefmaxlength).
   */
  maxLength?: number;

  /**
   * The minimum number of characters required by the input. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefminlength).
   */
  minLength?: number;

  /**
   * Regex pattern that the value of the input must match to be valid. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefpattern).
   */
  pattern?: string;

  /**
   * Content that appears in the input when it is empty. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefplaceholder).
   */
  placeholder?: string;

  /**
   * The type of input to render. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdeftype).
   *
   * @default 'text'
   */
  type?: 'text' | 'search' | 'url' | 'tel' | 'email' | 'password' | (string & {});

  /**
   * Hints at the type of data that might be entered by the user while editing the element or its
   * contents. See
   * [MDN](https://html.spec.whatwg.org/multipage/interaction.html#input-modalities:-the-inputmode-attribute).
   */
  inputMode?: 'none' | 'text' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search';

  /**
   * An attribute that takes as its value a space-separated string that describes what, if any, type
   * of autocomplete functionality the input should provide. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#autocomplete).
   */
  autoCorrect?: string;

  /**
   * An enumerated attribute that defines whether the element may be checked for spelling errors.
   * See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/spellcheck).
   */
  spellCheck?: string;
}

/**
 * This type allows configuring link props with router options and type-safe URLs via TS module
 * augmentation. By default, this is an empty type. Extend with `href` and `routerOptions`
 * properties to configure your router.
 */
interface RouterConfig {}

type Href = RouterConfig extends {href: infer H} ? H : string;
type RouterOptions = RouterConfig extends {routerOptions: infer O} ? O : never;

// Make sure to update filterDOMProps.ts when updating this.
interface LinkDOMProps {
  /** A URL to link to. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#href). */
  href?: Href;
  /**
   * Hints at the human language of the linked URL.
   * See[MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#hreflang).
   */
  hrefLang?: string;
  /**
   * The target window for the link. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#target).
   */
  target?: HTMLAttributeAnchorTarget;
  /**
   * The relationship between the linked resource and the current page. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel).
   */
  rel?: string;
  /**
   * Causes the browser to download the linked URL. A string may be provided to suggest a file name.
   * See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#download).
   */
  download?: boolean | string;
  /**
   * A space-separated list of URLs to ping when the link is followed. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#ping).
   */
  ping?: string;
  /**
   * How much of the referrer to send when following the link. See
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#referrerpolicy).
   */
  referrerPolicy?: HTMLAttributeReferrerPolicy;
  /** Options for the configured client side router. */
  routerOptions?: RouterOptions;
}

/** Any focusable element, including both HTML and SVG elements. */
interface FocusableElement extends Element, HTMLOrSVGElement {}

/**
 * Global attributes that can be applied to any DOM element.
 *
 * @private
 */
// NOTE: id is handled elsewhere (DOMProps).
interface GlobalDOMAttributes<T = Element> extends GlobalDOMEvents<T> {
  dir?: string | undefined;
  lang?: string | undefined;
  hidden?: boolean | undefined;
  inert?: boolean | undefined;
  translate?: 'yes' | 'no' | undefined;
}

/**
 * Global DOM events that are supported on all DOM elements.
 *
 * @private
 */
// NOTES:
//   - Drag and drop events are omitted for now.
//   - Keyboard and focus events are supported directly on focusable elements (FocusableProps).
//   - Text input events (e.g. onInput, onCompositionStart, onCopy) are
//     supported only directly on input elements (TextInputDOMProps).
//     We don't support contentEditable on our components.
//   - Media events should be handled directly on the <video>/<audio><img> element.
interface GlobalDOMEvents<T = Element> {
  // MouseEvents
  onClick?: MouseEventHandler<T> | undefined;
  onClickCapture?: MouseEventHandler<T> | undefined;
  onAuxClick?: MouseEventHandler<T> | undefined;
  onAuxClickCapture?: MouseEventHandler<T> | undefined;
  onContextMenu?: MouseEventHandler<T> | undefined;
  onContextMenuCapture?: MouseEventHandler<T> | undefined;
  onDoubleClick?: MouseEventHandler<T> | undefined;
  onDoubleClickCapture?: MouseEventHandler<T> | undefined;
  onMouseDown?: MouseEventHandler<T> | undefined;
  onMouseDownCapture?: MouseEventHandler<T> | undefined;
  onMouseEnter?: MouseEventHandler<T> | undefined;
  onMouseLeave?: MouseEventHandler<T> | undefined;
  onMouseMove?: MouseEventHandler<T> | undefined;
  onMouseMoveCapture?: MouseEventHandler<T> | undefined;
  onMouseOut?: MouseEventHandler<T> | undefined;
  onMouseOutCapture?: MouseEventHandler<T> | undefined;
  onMouseOver?: MouseEventHandler<T> | undefined;
  onMouseOverCapture?: MouseEventHandler<T> | undefined;
  onMouseUp?: MouseEventHandler<T> | undefined;
  onMouseUpCapture?: MouseEventHandler<T> | undefined;

  // Touch Events
  onTouchCancel?: TouchEventHandler<T> | undefined;
  onTouchCancelCapture?: TouchEventHandler<T> | undefined;
  onTouchEnd?: TouchEventHandler<T> | undefined;
  onTouchEndCapture?: TouchEventHandler<T> | undefined;
  onTouchMove?: TouchEventHandler<T> | undefined;
  onTouchMoveCapture?: TouchEventHandler<T> | undefined;
  onTouchStart?: TouchEventHandler<T> | undefined;
  onTouchStartCapture?: TouchEventHandler<T> | undefined;

  // Pointer Events
  onPointerDown?: PointerEventHandler<T> | undefined;
  onPointerDownCapture?: PointerEventHandler<T> | undefined;
  onPointerMove?: PointerEventHandler<T> | undefined;
  onPointerMoveCapture?: PointerEventHandler<T> | undefined;
  onPointerUp?: PointerEventHandler<T> | undefined;
  onPointerUpCapture?: PointerEventHandler<T> | undefined;
  onPointerCancel?: PointerEventHandler<T> | undefined;
  onPointerCancelCapture?: PointerEventHandler<T> | undefined;
  onPointerEnter?: PointerEventHandler<T> | undefined;
  onPointerLeave?: PointerEventHandler<T> | undefined;
  onPointerOver?: PointerEventHandler<T> | undefined;
  onPointerOverCapture?: PointerEventHandler<T> | undefined;
  onPointerOut?: PointerEventHandler<T> | undefined;
  onPointerOutCapture?: PointerEventHandler<T> | undefined;
  onGotPointerCapture?: PointerEventHandler<T> | undefined;
  onGotPointerCaptureCapture?: PointerEventHandler<T> | undefined;
  onLostPointerCapture?: PointerEventHandler<T> | undefined;
  onLostPointerCaptureCapture?: PointerEventHandler<T> | undefined;

  // UI Events
  onScroll?: UIEventHandler<T> | undefined;
  onScrollCapture?: UIEventHandler<T> | undefined;

  // Wheel Events
  onWheel?: WheelEventHandler<T> | undefined;
  onWheelCapture?: WheelEventHandler<T> | undefined;

  // Animation Events
  onAnimationStart?: AnimationEventHandler<T> | undefined;
  onAnimationStartCapture?: AnimationEventHandler<T> | undefined;
  onAnimationEnd?: AnimationEventHandler<T> | undefined;
  onAnimationEndCapture?: AnimationEventHandler<T> | undefined;
  onAnimationIteration?: AnimationEventHandler<T> | undefined;
  onAnimationIterationCapture?: AnimationEventHandler<T> | undefined;

  // Transition Events
  onTransitionCancel?: TransitionEventHandler<T> | undefined;
  onTransitionCancelCapture?: TransitionEventHandler<T> | undefined;
  onTransitionEnd?: TransitionEventHandler<T> | undefined;
  onTransitionEndCapture?: TransitionEventHandler<T> | undefined;
  onTransitionRun?: TransitionEventHandler<T> | undefined;
  onTransitionRunCapture?: TransitionEventHandler<T> | undefined;
  onTransitionStart?: TransitionEventHandler<T> | undefined;
  onTransitionStartCapture?: TransitionEventHandler<T> | undefined;
}

/*
 * Copyright 2020 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */



type SelectionMode$4 = 'none' | 'single' | 'multiple';
type SelectionBehavior = 'toggle' | 'replace';
type Selection = 'all' | Set<Key>;
interface MultipleSelection {
  /** The type of selection that is allowed in the collection. */
  selectionMode?: SelectionMode$4;
  /** Whether the collection allows empty selection. */
  disallowEmptySelection?: boolean;
  /** The currently selected keys in the collection (controlled). */
  selectedKeys?: 'all' | Iterable<Key>;
  /** The initial selected keys in the collection (uncontrolled). */
  defaultSelectedKeys?: 'all' | Iterable<Key>;
  /** Handler that is called when the selection changes. */
  onSelectionChange?: (keys: Selection) => void;
  /** The currently disabled keys in the collection (controlled). */
  disabledKeys?: Iterable<Key>;
}

type FocusStrategy = 'first' | 'last';
type DisabledBehavior = 'selection' | 'all';

/*
 * Copyright 2020 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */



interface DragDropEvent {
  /** The x coordinate of the event, relative to the target element. */
  x: number;
  /** The y coordinate of the event, relative to the target element. */
  y: number;
}

type DropOperation = 'copy' | 'link' | 'move' | 'cancel';

interface DragItem {
  [type: string]: string;
}

interface DragStartEvent extends DragDropEvent {
  /** The event type. */
  type: 'dragstart';
}

interface DragMoveEvent extends DragDropEvent {
  /** The event type. */
  type: 'dragmove';
}

interface DragEndEvent extends DragDropEvent {
  /** The event type. */
  type: 'dragend';
  /** The drop operation that occurred. */
  dropOperation: DropOperation;
}

interface DropEnterEvent extends DragDropEvent {
  /** The event type. */
  type: 'dropenter';
}

interface DropMoveEvent extends DragDropEvent {
  /** The event type. */
  type: 'dropmove';
}

interface DropActivateEvent extends DragDropEvent {
  /** The event type. */
  type: 'dropactivate';
}

interface DropExitEvent extends DragDropEvent {
  /** The event type. */
  type: 'dropexit';
}

interface TextDropItem {
  /** The item kind. */
  kind: 'text';
  /**
   * The drag types available for this item.
   * These are often mime types, but may be custom app-specific types.
   */
  types: Set<string>;
  /** Returns the data for the given type as a string. */
  getText(type: string): Promise<string>;
}

interface FileDropItem {
  /** The item kind. */
  kind: 'file';
  /** The file type (usually a mime type). */
  type: string;
  /** The file name. */
  name: string;
  /** Returns the contents of the file as a blob. */
  getFile(): Promise<File>;
  /** Returns the contents of the file as a string. */
  getText(): Promise<string>;
}

interface DirectoryDropItem {
  /** The item kind. */
  kind: 'directory';
  /** The directory name. */
  name: string;
  /** Returns the entries contained within the directory. */
  getEntries(): AsyncIterable<FileDropItem | DirectoryDropItem>;
}

type DropItem = TextDropItem | FileDropItem | DirectoryDropItem;

interface DropEvent extends DragDropEvent {
  /** The event type. */
  type: 'drop';
  /** The drop operation that should occur. */
  dropOperation: DropOperation;
  /** The dropped items. */
  items: DropItem[];
}

type DropPosition = 'on' | 'before' | 'after';
interface RootDropTarget {
  /** The event type. */
  type: 'root';
}

interface ItemDropTarget {
  /** The drop target type. */
  type: 'item';
  /** The item key. */
  key: Key;
  /** The drop position relative to the item. */
  dropPosition: DropPosition;
}

type DropTarget = RootDropTarget | ItemDropTarget;

interface DroppableCollectionEnterEvent extends DropEnterEvent {
  /** The drop target. */
  target: DropTarget;
}

interface DroppableCollectionActivateEvent extends DropActivateEvent {
  /** The drop target. */
  target: DropTarget;
}

interface DroppableCollectionExitEvent extends DropExitEvent {
  /** The drop target. */
  target: DropTarget;
}

interface DroppableCollectionDropEvent extends DropEvent {
  /** The drop target. */
  target: DropTarget;
}

interface DroppableCollectionInsertDropEvent {
  /** The dropped items. */
  items: DropItem[];
  /** The drop operation that should occur. */
  dropOperation: DropOperation;
  /** The drop target. */
  target: ItemDropTarget;
}

interface DroppableCollectionRootDropEvent {
  /** The dropped items. */
  items: DropItem[];
  /** The drop operation that should occur. */
  dropOperation: DropOperation;
}

interface DroppableCollectionOnItemDropEvent {
  /** The dropped items. */
  items: DropItem[];
  /** The drop operation that should occur. */
  dropOperation: DropOperation;
  /** Whether the drag originated within the same collection as the drop. */
  isInternal: boolean;
  /** The drop target. */
  target: ItemDropTarget;
}

interface DroppableCollectionReorderEvent {
  /** The keys of the items that were reordered. */
  keys: Set<Key>;
  /** The drop operation that should occur. */
  dropOperation: DropOperation;
  /** The drop target. */
  target: ItemDropTarget;
}

type DragType = string | symbol;
interface DragTypes {
  /** Returns whether the drag contains data of the given type. */
  has(type: DragType | DragType[]): boolean;
}

interface DropTargetDelegate {
  /**
   * Returns a drop target within a collection for the given x and y coordinates. The point is
   * provided relative to the top left corner of the collection container. A drop target can be
   * checked to see if it is valid using the provided `isValidDropTarget` function.
   */
  getDropTargetFromPoint(
    x: number,
    y: number,
    isValidDropTarget: (target: DropTarget) => boolean
  ): DropTarget | null;
}

interface DroppableCollectionUtilityOptions {
  /**
   * The drag types that the droppable collection accepts. If the collection accepts directories,
   * include `DIRECTORY_DRAG_TYPE` in your array of allowed types.
   *
   * @default 'all'
   */
  acceptedDragTypes?: 'all' | Array<string | symbol>;
  /**
   * Handler that is called when external items are dropped "between" items.
   */
  onInsert?: (e: DroppableCollectionInsertDropEvent) => void;
  /**
   * Handler that is called when external items are dropped on the droppable collection's root.
   */
  onRootDrop?: (e: DroppableCollectionRootDropEvent) => void;
  /**
   * Handler that is called when items are dropped "on" an item.
   */
  onItemDrop?: (e: DroppableCollectionOnItemDropEvent) => void;
  /**
   * Handler that is called when items are reordered within the collection.
   * This handler only allows dropping between items, not on items.
   * It does not allow moving items to a different parent item within a tree.
   */
  onReorder?: (e: DroppableCollectionReorderEvent) => void;
  /**
   * Handler that is called when items are moved within the source collection.
   * This handler allows dropping both on or between items, and items may be
   * moved to a different parent item within a tree.
   */
  onMove?: (e: DroppableCollectionReorderEvent) => void;
  /**
   * A function returning whether a given target in the droppable collection is a valid "on" drop
   * target for the current drag types.
   */
  shouldAcceptItemDrop?: (target: ItemDropTarget, types: DragTypes) => boolean;
}

interface DroppableCollectionBaseProps {
  /** Handler that is called when a valid drag enters a drop target. */
  onDropEnter?: (e: DroppableCollectionEnterEvent) => void;
  /**
   * Handler that is called after a valid drag is held over a drop target for a period of time.
   */
  onDropActivate?: (e: DroppableCollectionActivateEvent) => void;
  /** Handler that is called when a valid drag exits a drop target. */
  onDropExit?: (e: DroppableCollectionExitEvent) => void;
  /**
   * Handler that is called when a valid drag is dropped on a drop target. When defined, this
   * overrides other drop handlers such as `onInsert`, and `onItemDrop`.
   */
  onDrop?: (e: DroppableCollectionDropEvent) => void;
  /**
   * A function returning the drop operation to be performed when items matching the given types are
   * dropped on the drop target.
   */
  getDropOperation?: (
    target: DropTarget,
    types: DragTypes,
    allowedOperations: DropOperation[]
  ) => DropOperation;
}

interface DroppableCollectionProps
  extends DroppableCollectionUtilityOptions, DroppableCollectionBaseProps {}

interface DraggableCollectionStartEvent extends DragStartEvent {
  /** The keys of the items that were dragged. */
  keys: Set<Key>;
}

interface DraggableCollectionMoveEvent extends DragMoveEvent {
  /** The keys of the items that were dragged. */
  keys: Set<Key>;
}

interface DraggableCollectionEndEvent extends DragEndEvent {
  /** The keys of the items that were dragged. */
  keys: Set<Key>;
  /** Whether the drop ended within the same collection as it originated. */
  isInternal: boolean;
}

type DragPreviewRenderer = (
  items: DragItem[],
  callback: (node: HTMLElement | null, x?: number, y?: number) => void
) => void;

interface DraggableCollectionProps<T = object> {
  /** Handler that is called when a drag operation is started. */
  onDragStart?: (e: DraggableCollectionStartEvent) => void;
  /** Handler that is called when the drag is moved. */
  onDragMove?: (e: DraggableCollectionMoveEvent) => void;
  /**
   * Handler that is called when the drag operation is ended, either as a result of a drop or a
   * cancellation.
   */
  onDragEnd?: (e: DraggableCollectionEndEvent) => void;
  /** A function that returns the items being dragged. */
  getItems: (keys: Set<Key>, items: T[]) => DragItem[];
  /** The ref of the element that will be rendered as the drag preview while dragging. */
  preview?: RefObject<DragPreviewRenderer | null>;
  /**
   * Function that returns the drop operations that are allowed for the dragged items. If not
   * provided, all drop operations are allowed.
   */
  getAllowedDropOperations?: () => DropOperation[];
}

/*
 * Copyright 2020 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */



interface ItemProps<T> extends LinkDOMProps {
  /** Rendered contents of the item or child items. */
  children: ReactNode;
  /** Rendered contents of the item if `children` contains child items. */
  title?: ReactNode; // label?? contents?
  /** A string representation of the item's contents, used for features like typeahead. */
  textValue?: string;
  /** An accessibility label for this item. */
  'aria-label'?: string;
  /** A list of child item objects. Used for dynamic collections. */
  childItems?: Iterable<T>;
  /** Whether this item has children, even if not loaded yet. */
  hasChildItems?: boolean;
}

type ItemElement<T> = ReactElement<ItemProps<T>> | null;
type ItemRenderer<T> = (item: T) => ItemElement<T>;

interface SectionProps<T> {
  /** Rendered contents of the section, e.g. a header. */
  title?: ReactNode;
  /** An accessibility label for the section. */
  'aria-label'?: string;
  /** Static child items or a function to render children. */
  children: ItemElement<T> | ItemElement<T>[] | ItemRenderer<T>;
  /** Item objects in the section. */
  items?: Iterable<T>;
}

type SectionElement<T> = ReactElement<SectionProps<T>> | null;

type CollectionElement<T> = SectionElement<T> | ItemElement<T>;
type CollectionChildren<T> =
  | CollectionElement<T>
  | CollectionElement<T>[]
  | ((item: T) => CollectionElement<T>);
interface CollectionBase<T> {
  /** The contents of the collection. */
  children: CollectionChildren<T>;
  /** Item objects in the collection. */
  items?: Iterable<T>;
  /**
   * The item keys that are disabled. These items cannot be selected, focused, or otherwise
   * interacted with.
   */
  disabledKeys?: Iterable<Key>;
}

interface KeyboardDelegate {
  /** Returns the key visually below the given one, or `null` for none. */
  getKeyBelow?(key: Key, options?: {includeDisabled?: boolean}): Key | null;

  /** Returns the key visually above the given one, or `null` for none. */
  getKeyAbove?(key: Key, options?: {includeDisabled?: boolean}): Key | null;

  /** Returns the key visually to the left of the given one, or `null` for none. */
  getKeyLeftOf?(key: Key, options?: {includeDisabled?: boolean}): Key | null;

  /** Returns the key visually to the right of the given one, or `null` for none. */
  getKeyRightOf?(key: Key, options?: {includeDisabled?: boolean}): Key | null;

  /** Returns the key visually one page below the given one, or `null` for none. */
  getKeyPageBelow?(key: Key): Key | null;

  /** Returns the key visually one page above the given one, or `null` for none. */
  getKeyPageAbove?(key: Key): Key | null;

  /** Returns the first key, or `null` for none. */
  getFirstKey?(key?: Key | null, global?: boolean): Key | null;

  /** Returns the last key, or `null` for none. */
  getLastKey?(key?: Key | null, global?: boolean): Key | null;

  /** Returns the next key after `fromKey` that matches the given search string, or `null` for none. */
  getKeyForSearch?(search: string, fromKey?: Key | null): Key | null;
}

interface Rect {
  x: number;
  y: number;
  width: number;
  height: number;
}

interface Size {
  width: number;
  height: number;
}

/** A LayoutDelegate provides layout information for collection items. */
interface LayoutDelegate {
  /** Returns a rectangle for the item with the given key. */
  getItemRect(key: Key): Rect | null;
  /** Returns the visible rectangle of the collection. */
  getVisibleRect(): Rect;
  /** Returns the size of the scrollable content in the collection. */
  getContentSize(): Size;
  /** Returns a list of keys between `from` and `to`. */
  getKeyRange?(from: Key, to: Key): Key[];
}

/**
 * A generic interface to access a readonly sequential
 * collection of unique keyed items.
 */
interface Collection<T> extends Iterable<T> {
  /** The number of items in the collection. */
  readonly size: number;

  /** Iterate over all keys in the collection. */
  getKeys(): Iterable<Key>;

  /** Get an item by its key. */
  getItem(key: Key): T | null;

  /** Get an item by the index of its key. */
  at(idx: number): T | null;

  /** Get the key that comes before the given key in the collection. */
  getKeyBefore(key: Key): Key | null;

  /** Get the key that comes after the given key in the collection. */
  getKeyAfter(key: Key): Key | null;

  /** Get the first key in the collection. */
  getFirstKey(): Key | null;

  /** Get the last key in the collection. */
  getLastKey(): Key | null;

  /** Iterate over the child items of the given key. */
  getChildren?(key: Key): Iterable<T>;

  /** Returns a string representation of the item's contents. */
  getTextValue?(key: Key): string;

  /** Filters the collection using the given function. */
  filter?(filterFn: (nodeValue: string, node: T) => boolean): Collection<T>;
}

interface Node<T> {
  /** The type of item this node represents. */
  type: string;
  /** A unique key for the node. */
  key: Key;
  /** The object value the node was created from. */
  value: T | null;
  /** The level of depth this node is at in the hierarchy. */
  level: number;
  /** Whether this item has children, even if not loaded yet. */
  hasChildNodes: boolean;
  /**
   * The loaded children of this node.
   *
   * @deprecated Use `collection.getChildren(node.key)` instead.
   */
  childNodes: Iterable<Node<T>>;
  /** The rendered contents of this node (e.g. JSX). */
  rendered: ReactNode;
  /** A string value for this node, used for features like typeahead. */
  textValue: string;
  /** An accessibility label for this node. */
  'aria-label'?: string;
  /** The index of this node within its parent. */
  index: number;
  /** A function that should be called to wrap the rendered node. */
  wrapper?: (element: ReactElement) => ReactElement;
  /** The key of the parent node. */
  parentKey?: Key | null;
  /** The key of the node before this node. */
  prevKey?: Key | null;
  /** The key of the node after this node. */
  nextKey?: Key | null;
  /** The first child key of this node. */
  firstChildKey?: Key | null;
  /** The last child key of this node. */
  lastChildKey?: Key | null;
  /** Additional properties specific to a particular node type. */
  props?: any;
  /** @private */
  shouldInvalidate?: (context: any) => boolean;
  /** A function that renders this node to a React Element in the DOM. */
  render?: (node: Node<any>) => ReactElement;
}

/*
 * Copyright 2020 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */



// Event bubbling can be problematic in real-world applications, so the default for React Spectrum components
// is not to propagate. This can be overridden by calling continuePropagation() on the event.
type BaseEvent<T extends SyntheticEvent> = T & {
  /**
   * Use continuePropagation.
   *
   * @deprecated
   */
  stopPropagation(): void;
  continuePropagation(): void;
};

type KeyboardEvent$1 = BaseEvent<KeyboardEvent$2<any>>;

type PointerType = 'mouse' | 'pen' | 'touch' | 'keyboard' | 'virtual';

interface PressEvent {
  /** The type of press event being fired. */
  type: 'pressstart' | 'pressend' | 'pressup' | 'press';
  /** The pointer type that triggered the press event. */
  pointerType: PointerType;
  /** The target element of the press event. */
  target: Element;
  /** Whether the shift keyboard modifier was held during the press event. */
  shiftKey: boolean;
  /** Whether the ctrl keyboard modifier was held during the press event. */
  ctrlKey: boolean;
  /** Whether the meta keyboard modifier was held during the press event. */
  metaKey: boolean;
  /** Whether the alt keyboard modifier was held during the press event. */
  altKey: boolean;
  /** X position relative to the target. */
  x: number;
  /** Y position relative to the target. */
  y: number;
  /**
   * The key that triggered the press event, if it was triggered by a keyboard interaction.
   * This is useful for differentiating between Space and Enter key presses.
   */
  key?: string;
  /**
   * By default, press events stop propagation to parent elements.
   * In cases where a handler decides not to handle a specific event,
   * it can call `continuePropagation()` to allow a parent to handle it.
   */
  continuePropagation(): void;
}

interface LongPressEvent extends Omit<PressEvent, 'type' | 'continuePropagation'> {
  /** The type of long press event being fired. */
  type: 'longpressstart' | 'longpressend' | 'longpress';
}

interface HoverEvent {
  /** The type of hover event being fired. */
  type: 'hoverstart' | 'hoverend';
  /** The pointer type that triggered the hover event. */
  pointerType: 'mouse' | 'pen';
  /** The target element of the hover event. */
  target: HTMLElement;
}

interface KeyboardEvents {
  /** Handler that is called when a key is pressed. */
  onKeyDown?: (e: KeyboardEvent$1) => void;
  /** Handler that is called when a key is released. */
  onKeyUp?: (e: KeyboardEvent$1) => void;
}

interface FocusEvents<Target = Element> {
  /** Handler that is called when the element receives focus. */
  onFocus?: (e: FocusEvent<Target>) => void;
  /** Handler that is called when the element loses focus. */
  onBlur?: (e: FocusEvent<Target>) => void;
  /** Handler that is called when the element's focus status changes. */
  onFocusChange?: (isFocused: boolean) => void;
}

interface HoverEvents {
  /** Handler that is called when a hover interaction starts. */
  onHoverStart?: (e: HoverEvent) => void;
  /** Handler that is called when a hover interaction ends. */
  onHoverEnd?: (e: HoverEvent) => void;
  /** Handler that is called when the hover state changes. */
  onHoverChange?: (isHovering: boolean) => void;
}

interface PressEvents {
  /** Handler that is called when the press is released over the target. */
  onPress?: (e: PressEvent) => void;
  /** Handler that is called when a press interaction starts. */
  onPressStart?: (e: PressEvent) => void;
  /**
   * Handler that is called when a press interaction ends, either
   * over the target or when the pointer leaves the target.
   */
  onPressEnd?: (e: PressEvent) => void;
  /** Handler that is called when the press state changes. */
  onPressChange?: (isPressed: boolean) => void;
  /**
   * Handler that is called when a press is released over the target, regardless of
   * whether it started on the target or not.
   */
  onPressUp?: (e: PressEvent) => void;
  /**
   * **Not recommended – use `onPress` instead.** `onClick` is an alias for `onPress`
   * provided for compatibility with other libraries. `onPress` provides
   * additional event details for non-mouse interactions.
   */
  onClick?: (e: MouseEvent<FocusableElement>) => void;
}

interface FocusableProps<Target = Element> extends FocusEvents<Target>, KeyboardEvents {
  /** Whether the element should receive focus on render. */
  autoFocus?: boolean;
}

/*
 * Copyright 2020 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */



interface RefObject<T> {
  current: T;
}

/*
 * Copyright 2020 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */



interface LabelableProps {
  /** The content to display as the label. */
  label?: ReactNode;
}

/*
 * Copyright 2020 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */

type Orientation = 'horizontal' | 'vertical';

/*
 * Copyright 2020 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */

type Direction = 'ltr' | 'rtl';

/*
 * Copyright 2023 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */

type Key = string | number;

interface TextFieldProps$1<T = HTMLInputElement> extends InputBase, Validation<string>, HelpTextProps, FocusableProps<T>, TextInputBase, ValueBase<string>, LabelableProps {
}
interface AriaTextFieldProps<T = HTMLInputElement> extends TextFieldProps$1<T>, AriaLabelingProps, FocusableDOMProps, TextInputDOMProps<T>, AriaValidationProps {
    /**
     * Identifies the currently active element when DOM focus is on a composite widget, textbox,
     * group, or application.
     */
    'aria-activedescendant'?: string;
    /**
     * Indicates whether inputting text could trigger display of one or more predictions of the user's
     * intended value for an input and specifies how predictions would be presented if they are made.
     */
    'aria-autocomplete'?: 'none' | 'inline' | 'list' | 'both';
    /**
     * Indicates the availability and type of interactive popup element, such as menu or dialog, that
     * can be triggered by an element.
     */
    'aria-haspopup'?: boolean | 'false' | 'true' | 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog';
    /**
     * Identifies the element (or elements) whose contents or presence are controlled by the current
     * element.
     */
    'aria-controls'?: string;
    /**
     * An enumerated attribute that defines what action label or icon to preset for the enter key on
     * virtual keyboards. See
     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/enterkeyhint).
     */
    enterKeyHint?: 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
}

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, DOMProps$1 {
    /** 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);
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);
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>;
}
/**
 * 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.
 */
declare function composeRenderProps<T, U, V extends T>(value: T extends any ? T | ((renderProps: U) => V) : never, wrap: (prevValue: T, renderProps: U) => V): (renderProps: U) => V;
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;
}
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;
}

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: SelectionMode$4;
    /** 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;
}

interface ButtonProps$1 extends PressEvents, FocusableProps {
    /** Whether the button is disabled. */
    isDisabled?: boolean;
    /** The content to display in the button. */
    children?: ReactNode;
}
interface AriaBaseButtonProps extends FocusableDOMProps, AriaLabelingProps {
    /** Indicates whether the element is disabled to users of assistive technology. */
    'aria-disabled'?: boolean | 'true' | 'false';
    /**
     * Indicates whether the element, or another grouping element it controls, is currently expanded
     * or collapsed.
     */
    'aria-expanded'?: boolean | 'true' | 'false';
    /**
     * Indicates the availability and type of interactive popup element, such as menu or dialog, that
     * can be triggered by an element.
     */
    'aria-haspopup'?: boolean | 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog' | 'true' | 'false';
    /**
     * Identifies the element (or elements) whose contents or presence are controlled by the current
     * element.
     */
    'aria-controls'?: string;
    /** Indicates the current "pressed" state of toggle buttons. */
    'aria-pressed'?: boolean | 'true' | 'false' | 'mixed';
    /**
     * Indicates whether this element represents the current item within a container or set of related
     * elements.
     */
    'aria-current'?: boolean | 'true' | 'false' | 'page' | 'step' | 'location' | 'date' | 'time';
    /**
     * The behavior of the button when used in an HTML form.
     *
     * @default 'button'
     */
    type?: 'button' | 'submit' | 'reset';
    /**
     * Whether to prevent focus from moving to the button when pressing it.
     *
     * Caution, this can make the button inaccessible and should only be used when alternative
     * keyboard interaction is provided, such as ComboBox's MenuTrigger or a NumberField's
     * increment/decrement control.
     */
    preventFocusOnPress?: boolean;
    /**
     * The `<form>` element to associate the button with.
     * The value of this attribute must be the id of a `<form>` in the same document.
     * See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/button#form).
     */
    form?: string;
    /**
     * The URL that processes the information submitted by the button.
     * Overrides the action attribute of the button's form owner.
     */
    formAction?: ButtonHTMLAttributes<HTMLButtonElement>['formAction'];
    /** Indicates how to encode the form data that is submitted. */
    formEncType?: string;
    /** Indicates the HTTP method used to submit the form. */
    formMethod?: string;
    /** Indicates that the form is not to be validated when it is submitted. */
    formNoValidate?: boolean;
    /** Overrides the target attribute of the button's form owner. */
    formTarget?: string;
    /** Submitted as a pair with the button's value as part of the form data. */
    name?: string;
    /** The value associated with the button's name when it's submitted with the form data. */
    value?: string;
}
interface AriaButtonElementTypeProps<T extends ElementType = 'button'> {
    /**
     * The HTML element or React element used to render the button, e.g. 'div', 'a', or `RouterLink`.
     *
     * @default 'button'
     */
    elementType?: T | JSXElementConstructor<any>;
}
interface LinkButtonProps<T extends ElementType = 'button'> extends AriaButtonElementTypeProps<T> {
    /** A URL to link to if elementType="a". */
    href?: string;
    /** The target window for the link. */
    target?: string;
    /**
     * The relationship between the linked resource and the current page. See
     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel).
     */
    rel?: string;
}
interface AriaButtonProps<T extends ElementType = 'button'> extends ButtonProps$1, LinkButtonProps<T>, AriaBaseButtonProps {
}

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;
}
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;
}
/**
 * A button allows a user to perform an action, with mouse, touch, and keyboard interactions.
 */
declare const Button: (props: ButtonProps & React.RefAttributes<HTMLButtonElement>) => React.ReactElement | null;

/** A CalendarDate represents a date without any time components in a specific calendar system. */
declare class CalendarDate {
    #private;
    /** The calendar system associated with this date, e.g. Gregorian. */
    readonly calendar: Calendar$1;
    /** The calendar era for this date, e.g. "BC" or "AD". */
    readonly era: string;
    /** The year of this date within the era. */
    readonly year: number;
    /**
     * The month number within the year. Note that some calendar systems such as Hebrew
     * may have a variable number of months per year. Therefore, month numbers may not
     * always correspond to the same month names in different years.
     */
    readonly month: number;
    /** The day number within the month. */
    readonly day: number;
    constructor(year: number, month: number, day: number);
    constructor(era: string, year: number, month: number, day: number);
    constructor(calendar: Calendar$1, year: number, month: number, day: number);
    constructor(calendar: Calendar$1, era: string, year: number, month: number, day: number);
    /** Returns a copy of this date. */
    copy(): CalendarDate;
    /** Returns a new `CalendarDate` with the given duration added to it. */
    add(duration: DateDuration): CalendarDate;
    /** Returns a new `CalendarDate` with the given duration subtracted from it. */
    subtract(duration: DateDuration): CalendarDate;
    /**
     * Returns a new `CalendarDate` with the given fields set to the provided values. Other fields
     * will be constrained accordingly.
     */
    set(fields: DateFields): CalendarDate;
    /**
     * Returns a new `CalendarDate` with the given field adjusted by a specified amount.
     * When the resulting value reaches the limits of the field, it wraps around.
     */
    cycle(field: DateField$1, amount: number, options?: CycleOptions): CalendarDate;
    /**
     * Converts the date to a native JavaScript Date object, with the time set to midnight in the
     * given time zone.
     */
    toDate(timeZone: string): Date;
    /** Converts the date to an ISO 8601 formatted string. */
    toString(): string;
    /**
     * Compares this date with another. A negative result indicates that this date is before the given
     * one, and a positive date indicates that it is after.
     */
    compare(b: AnyCalendarDate): number;
}
/** A Time represents a clock time without any date components. */
declare class Time {
    #private;
    /** The hour, numbered from 0 to 23. */
    readonly hour: number;
    /** The minute in the hour. */
    readonly minute: number;
    /** The second in the minute. */
    readonly second: number;
    /** The millisecond in the second. */
    readonly millisecond: number;
    constructor(hour?: number, minute?: number, second?: number, millisecond?: number);
    /** Returns a copy of this time. */
    copy(): Time;
    /** Returns a new `Time` with the given duration added to it. */
    add(duration: TimeDuration): Time;
    /** Returns a new `Time` with the given duration subtracted from it. */
    subtract(duration: TimeDuration): Time;
    /**
     * Returns a new `Time` with the given fields set to the provided values. Other fields will be
     * constrained accordingly.
     */
    set(fields: TimeFields): Time;
    /**
     * Returns a new `Time` with the given field adjusted by a specified amount.
     * When the resulting value reaches the limits of the field, it wraps around.
     */
    cycle(field: TimeField$1, amount: number, options?: CycleTimeOptions): Time;
    /** Converts the time to an ISO 8601 formatted string. */
    toString(): string;
    /**
     * Compares this time with another. A negative result indicates that this time is before the given
     * one, and a positive time indicates that it is after.
     */
    compare(b: AnyTime): number;
}
/** A CalendarDateTime represents a date and time without a time zone, in a specific calendar system. */
declare class CalendarDateTime {
    #private;
    /** The calendar system associated with this date, e.g. Gregorian. */
    readonly calendar: Calendar$1;
    /** The calendar era for this date, e.g. "BC" or "AD". */
    readonly era: string;
    /** The year of this date within the era. */
    readonly year: number;
    /**
     * The month number within the year. Note that some calendar systems such as Hebrew
     * may have a variable number of months per year. Therefore, month numbers may not
     * always correspond to the same month names in different years.
     */
    readonly month: number;
    /** The day number within the month. */
    readonly day: number;
    /** The hour in the day, numbered from 0 to 23. */
    readonly hour: number;
    /** The minute in the hour. */
    readonly minute: number;
    /** The second in the minute. */
    readonly second: number;
    /** The millisecond in the second. */
    readonly millisecond: number;
    constructor(year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
    constructor(era: string, year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
    constructor(calendar: Calendar$1, year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
    constructor(calendar: Calendar$1, era: string, year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
    /** Returns a copy of this date. */
    copy(): CalendarDateTime;
    /** Returns a new `CalendarDateTime` with the given duration added to it. */
    add(duration: DateTimeDuration): CalendarDateTime;
    /** Returns a new `CalendarDateTime` with the given duration subtracted from it. */
    subtract(duration: DateTimeDuration): CalendarDateTime;
    /**
     * Returns a new `CalendarDateTime` with the given fields set to the provided values. Other fields
     * will be constrained accordingly.
     */
    set(fields: DateFields & TimeFields): CalendarDateTime;
    /**
     * Returns a new `CalendarDateTime` with the given field adjusted by a specified amount.
     * When the resulting value reaches the limits of the field, it wraps around.
     */
    cycle(field: DateField$1 | TimeField$1, amount: number, options?: CycleTimeOptions): CalendarDateTime;
    /** Converts the date to a native JavaScript Date object in the given time zone. */
    toDate(timeZone: string, disambiguation?: Disambiguation): Date;
    /** Converts the date to an ISO 8601 formatted string. */
    toString(): string;
    /**
     * Compares this date with another. A negative result indicates that this date is before the given
     * one, and a positive date indicates that it is after.
     */
    compare(b: CalendarDate | CalendarDateTime | ZonedDateTime): number;
}
/** A ZonedDateTime represents a date and time in a specific time zone and calendar system. */
declare class ZonedDateTime {
    #private;
    /** The calendar system associated with this date, e.g. Gregorian. */
    readonly calendar: Calendar$1;
    /** The calendar era for this date, e.g. "BC" or "AD". */
    readonly era: string;
    /** The year of this date within the era. */
    readonly year: number;
    /**
     * The month number within the year. Note that some calendar systems such as Hebrew
     * may have a variable number of months per year. Therefore, month numbers may not
     * always correspond to the same month names in different years.
     */
    readonly month: number;
    /** The day number within the month. */
    readonly day: number;
    /** The hour in the day, numbered from 0 to 23. */
    readonly hour: number;
    /** The minute in the hour. */
    readonly minute: number;
    /** The second in the minute. */
    readonly second: number;
    /** The millisecond in the second. */
    readonly millisecond: number;
    /** The IANA time zone identifier that this date and time is represented in. */
    readonly timeZone: string;
    /** The UTC offset for this time, in milliseconds. */
    readonly offset: number;
    constructor(year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
    constructor(era: string, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
    constructor(calendar: Calendar$1, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
    constructor(calendar: Calendar$1, era: string, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
    /** Returns a copy of this date. */
    copy(): ZonedDateTime;
    /** Returns a new `ZonedDateTime` with the given duration added to it. */
    add(duration: DateTimeDuration): ZonedDateTime;
    /** Returns a new `ZonedDateTime` with the given duration subtracted from it. */
    subtract(duration: DateTimeDuration): ZonedDateTime;
    /**
     * Returns a new `ZonedDateTime` with the given fields set to the provided values. Other fields
     * will be constrained accordingly.
     */
    set(fields: DateFields & TimeFields, disambiguation?: Disambiguation): ZonedDateTime;
    /**
     * Returns a new `ZonedDateTime` with the given field adjusted by a specified amount.
     * When the resulting value reaches the limits of the field, it wraps around.
     */
    cycle(field: DateField$1 | TimeField$1, amount: number, options?: CycleTimeOptions): ZonedDateTime;
    /** Converts the date to a native JavaScript Date object. */
    toDate(): Date;
    /**
     * Converts the date to an ISO 8601 formatted string, including the UTC offset and time zone
     * identifier.
     */
    toString(): string;
    /** Converts the date to an ISO 8601 formatted string in UTC. */
    toAbsoluteString(): string;
    /**
     * Compares this date with another. A negative result indicates that this date is before the given
     * one, and a positive date indicates that it is after.
     */
    compare(b: CalendarDate | CalendarDateTime | ZonedDateTime): number;
}

/** An interface that is compatible with any object with date fields. */
interface AnyCalendarDate {
    readonly calendar: Calendar$1;
    readonly era: string;
    readonly year: number;
    readonly month: number;
    readonly day: number;
    copy(): this;
}
/** An interface that is compatible with any object with time fields. */
interface AnyTime {
    readonly hour: number;
    readonly minute: number;
    readonly second: number;
    readonly millisecond: number;
    copy(): this;
}
type CalendarIdentifier = 'gregory' | 'buddhist' | 'chinese' | 'coptic' | 'dangi' | 'ethioaa' | 'ethiopic' | 'hebrew' | 'indian' | 'islamic' | 'islamic-umalqura' | 'islamic-tbla' | 'islamic-civil' | 'islamic-rgsa' | 'iso8601' | 'japanese' | 'persian' | 'roc';
/**
 * The Calendar interface represents a calendar system, including information
 * about how days, months, years, and eras are organized, and methods to perform
 * arithmetic on dates.
 */
interface Calendar$1 {
    /**
     * A string identifier for the calendar, as defined by Unicode CLDR. See
     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/supportedValuesOf#supported_calendar_types).
     */
    identifier: CalendarIdentifier;
    /** Creates a CalendarDate in this calendar from the given Julian day number. */
    fromJulianDay(jd: number): CalendarDate;
    /** Converts a date in this calendar to a Julian day number. */
    toJulianDay(date: AnyCalendarDate): number;
    /** Returns the number of days in the month of the given date. */
    getDaysInMonth(date: AnyCalendarDate): number;
    /** Returns the number of months in the year of the given date. */
    getMonthsInYear(date: AnyCalendarDate): number;
    /** Returns the number of years in the era of the given date. */
    getYearsInEra(date: AnyCalendarDate): number;
    /** Returns a list of era identifiers for the calendar. */
    getEras(): string[];
    /**
     * Returns the minimum month number of the given date's year.
     * Normally, this is 1, but in some calendars such as the Japanese,
     * eras may begin in the middle of a year.
     */
    getMinimumMonthInYear?(date: AnyCalendarDate): number;
    /**
     * Returns the minimum day number of the given date's month.
     * Normally, this is 1, but in some calendars such as the Japanese,
     * eras may begin in the middle of a month.
     */
    getMinimumDayInMonth?(date: AnyCalendarDate): number;
    /** Returns the maximum months across all years. */
    getMaximumMonthsInYear(): number;
    /** Returns the maximum days across all months. */
    getMaximumDaysInMonth(): number;
    /**
     * Returns a date that is the first day of the month for the given date.
     * This is used to determine the month that the given date falls in, if
     * the calendar has months that do not align with the standard calendar months
     * (e.g. fiscal calendars).
     */
    getFormattableMonth?(date: AnyCalendarDate): CalendarDate;
    /** Returns whether the given calendar is the same as this calendar. */
    isEqual?(calendar: Calendar$1): boolean;
    /** @private */
    balanceDate?(date: AnyCalendarDate): void;
    /** @private */
    balanceYearMonth?(date: AnyCalendarDate, previousDate: AnyCalendarDate): void;
    /** @private */
    constrainDate?(date: AnyCalendarDate): void;
    /** @private */
    isInverseEra?(date: AnyCalendarDate): boolean;
}
/** Represents an amount of time in calendar-specific units, for use when performing arithmetic. */
interface DateDuration {
    /** The number of years to add or subtract. */
    years?: number;
    /** The number of months to add or subtract. */
    months?: number;
    /** The number of weeks to add or subtract. */
    weeks?: number;
    /** The number of days to add or subtract. */
    days?: number;
}
/** Represents an amount of time, for use whe performing arithmetic. */
interface TimeDuration {
    /** The number of hours to add or subtract. */
    hours?: number;
    /** The number of minutes to add or subtract. */
    minutes?: number;
    /** The number of seconds to add or subtract. */
    seconds?: number;
    /** The number of milliseconds to add or subtract. */
    milliseconds?: number;
}
/**
 * Represents an amount of time with both date and time components, for use when performing
 * arithmetic.
 */
interface DateTimeDuration extends DateDuration, TimeDuration {
}
interface DateFields {
    era?: string;
    year?: number;
    month?: number;
    day?: number;
}
interface TimeFields {
    hour?: number;
    minute?: number;
    second?: number;
    millisecond?: number;
}
type DateField$1 = keyof DateFields;
type TimeField$1 = keyof TimeFields;
type Disambiguation = 'compatible' | 'earlier' | 'later' | 'reject';
interface CycleOptions {
    /** Whether to round the field value to the nearest interval of the amount. */
    round?: boolean;
}
interface CycleTimeOptions extends CycleOptions {
    /**
     * Whether to use 12 or 24 hour time. If 12 hour time is chosen, the resulting value
     * will remain in the same day period as the original value (e.g. if the value is AM,
     * the resulting value also be AM).
     *
     * @default 24
     */
    hourCycle?: 12 | 24;
}

/** Returns today's date in the given time zone. */
declare function today(timeZone: string): CalendarDate;
/** Returns the time zone identifier for the current user. */
declare function getLocalTimeZone(): string;

/** Parses an ISO 8601 date string, with no time components. */
declare function parseDate(value: string): CalendarDate;
/** Parses an ISO 8601 date and time string, with no time zone. */
declare function parseDateTime(value: string): CalendarDateTime;
/**
 * Parses an ISO 8601 date and time string with a time zone extension and optional UTC offset (e.g.
 * "2021-11-07T00:45[America/Los_Angeles]" or "2021-11-07T00:45-07:00[America/Los_Angeles]").
 * Ambiguous times due to daylight saving time transitions are resolved according to the
 * `disambiguation` parameter.
 */
declare function parseZonedDateTime(value: string, disambiguation?: Disambiguation): ZonedDateTime;

interface DateRangeFormatPart extends Intl.DateTimeFormatPart {
    source: 'startRange' | 'endRange' | 'shared';
}
/** A wrapper around Intl.DateTimeFormat that fixes various browser bugs, and polyfills new features. */
declare class DateFormatter implements Intl.DateTimeFormat {
    private formatter;
    private options;
    private resolvedHourCycle;
    constructor(locale: string, options?: Intl.DateTimeFormatOptions);
    /**
     * Formats a date as a string according to the locale and format options passed to the
     * constructor.
     */
    format(value: Date): string;
    /** Formats a date to an array of parts such as separators, numbers, punctuation, and more. */
    formatToParts(value: Date): Intl.DateTimeFormatPart[];
    /** Formats a date range as a string. */
    formatRange(start: Date, end: Date): string;
    /** Formats a date range as an array of parts. */
    formatRangeToParts(start: Date, end: Date): DateRangeFormatPart[];
    /** Returns the resolved formatting options based on the values passed to the constructor. */
    resolvedOptions(): Intl.ResolvedDateTimeFormatOptions;
}

type DateValue$1 = CalendarDate | CalendarDateTime | ZonedDateTime;
type MappedDateValue$1<T> = T extends ZonedDateTime ? ZonedDateTime : T extends CalendarDateTime ? CalendarDateTime : T extends CalendarDate ? CalendarDate : never;
type PageBehavior = 'single' | 'visible';
interface CalendarPropsBase {
    /** The minimum allowed date that a user may select. */
    minValue?: DateValue$1 | null;
    /** The maximum allowed date that a user may select. */
    maxValue?: DateValue$1 | null;
    /**
     * Whether the calendar is disabled.
     *
     * @default false
     */
    isDisabled?: boolean;
    /**
     * Whether the calendar value is immutable.
     *
     * @default false
     */
    isReadOnly?: boolean;
    /**
     * Whether to automatically focus the calendar when it mounts.
     *
     * @default false
     */
    autoFocus?: boolean;
    /** Controls the currently focused date within the calendar. */
    focusedValue?: DateValue$1 | null;
    /** The date that is focused when the calendar first mounts (uncontrolled). */
    defaultFocusedValue?: DateValue$1 | null;
    /** Handler that is called when the focused date changes. */
    onFocusChange?: (date: CalendarDate) => void;
    /**
     * Whether the current selection is valid or invalid according to application logic.
     *
     * @deprecated Use `isInvalid` instead.
     */
    validationState?: ValidationState;
    /** Whether the current selection is invalid according to application logic. */
    isInvalid?: boolean;
    /** An error message to display when the selected value is invalid. */
    errorMessage?: ReactNode;
    /**
     * Controls the behavior of paging. Pagination either works by advancing the visible page by
     * visibleDuration (default) or one unit of visibleDuration.
     *
     * @default visible
     */
    pageBehavior?: PageBehavior;
    /**
     * The day that starts the week.
     */
    firstDayOfWeek?: 'sun' | 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat';
    /**
     * Determines the alignment of the visible months on initial render based on the current selection
     * or current date if there is no selection.
     *
     * @default 'center'
     */
    selectionAlignment?: 'start' | 'center' | 'end';
    /**
     * The number of weeks in a month. This overrides the default set by the locale.
     */
    weeksInMonth?: number;
}
interface CalendarStateBase {
    /** Whether the calendar is disabled. */
    readonly isDisabled: boolean;
    /** Whether the calendar is in a read only state. */
    readonly isReadOnly: boolean;
    /** The visible duration in the calendar. */
    readonly visibleDuration: DateDuration;
    /** The date range that is currently visible in the calendar. */
    readonly visibleRange: RangeValue<CalendarDate>;
    /** The minimum allowed date that a user may select. */
    readonly minValue?: DateValue$1 | null;
    /** The maximum allowed date that a user may select. */
    readonly maxValue?: DateValue$1 | null;
    /** The time zone of the dates currently being displayed. */
    readonly timeZone: string;
    /**
     * The current validation state of the selected value.
     *
     * @deprecated Use `isValueInvalid` instead.
     */
    readonly validationState: ValidationState | null;
    /** Whether the calendar is invalid. */
    readonly isValueInvalid: boolean;
    /** The currently focused date. */
    readonly focusedDate: CalendarDate;
    /** Sets the focused date. */
    setFocusedDate(value: CalendarDate): void;
    /** Moves focus to the next calendar date. */
    focusNextDay(): void;
    /** Moves focus to the previous calendar date. */
    focusPreviousDay(): void;
    /** Moves focus to the next row of dates, e.g. the next week. */
    focusNextRow(): void;
    /** Moves focus to the previous row of dates, e.g. the previous work. */
    focusPreviousRow(): void;
    /** Moves focus to the next page of dates, e.g. the next month if one month is visible. */
    focusNextPage(): void;
    /** Moves focus to the previous page of dates, e.g. the previous month if one month is visible. */
    focusPreviousPage(): void;
    /** Moves focus to the start of the current section of dates, e.g. the start of the current month. */
    focusSectionStart(): void;
    /**
     * Moves focus to the end of the current section of dates, e.g. the end of the current month
     * month.
     */
    focusSectionEnd(): void;
    /**
     * Moves focus to the next section of dates based on what is currently displayed.
     * By default, focus is moved by one of the currently displayed unit. For example, if
     * one or more months are displayed, then focus is moved forward by one month.
     * If the `larger` option is `true`, the focus is moved by the next larger unit than
     * the one displayed. For example, if months are displayed, then focus moves to the next year.
     */
    focusNextSection(larger?: boolean): void;
    /**
     * Moves focus to the previous section of dates based on what is currently displayed.
     * By default, focus is moved by one of the currently displayed unit. For example, if
     * one or more months are displayed, then focus is moved backward by one month.
     * If the `larger` option is `true`, the focus is moved by the next larger unit than
     * the one displayed. For example, if months are displayed, then focus moves to the previous year.
     */
    focusPreviousSection(larger?: boolean): void;
    /** Selects the currently focused date. */
    selectFocusedDate(): void;
    /** Selects the given date. */
    selectDate(date: CalendarDate): void;
    /** Whether focus is currently within the calendar. */
    readonly isFocused: boolean;
    /** Sets whether focus is currently within the calendar. */
    setFocused(value: boolean): void;
    /** Returns whether the given date is invalid according to the `minValue` and `maxValue` props. */
    isInvalid(date: CalendarDate): boolean;
    /** Returns whether the given date is currently selected. */
    isSelected(date: CalendarDate): boolean;
    /** Returns whether the given date is currently focused. */
    isCellFocused(date: CalendarDate): boolean;
    /**
     * Returns whether the given date is disabled according to the `minValue, `maxValue`, and
     * `isDisabled` props.
     */
    isCellDisabled(date: CalendarDate): boolean;
    /** Returns whether the given date is unavailable according to the `isDateUnavailable` prop. */
    isCellUnavailable(date: CalendarDate): boolean;
    /**
     * Returns whether the previous visible date range is allowed to be selected according to the
     * `minValue` prop.
     */
    isPreviousVisibleRangeInvalid(): boolean;
    /**
     * Returns whether the next visible date range is allowed to be selected according to the
     * `maxValue` prop.
     */
    isNextVisibleRangeInvalid(): boolean;
    /**
     * Returns an array of dates in the week index counted from the provided start date, or the first
     * visible date if not given. The returned array always has 7 elements, but may include null if
     * the date does not exist according to the calendar system.
     */
    getDatesInWeek(weekIndex: number, startDate?: CalendarDate): Array<CalendarDate | null>;
    /** Returns the number of weeks in a month. */
    getWeeksInMonth(startDate?: CalendarDate): number;
}
type CalendarSelectionMode = 'single' | 'multiple';
type CalendarValueType<T, M extends CalendarSelectionMode> = M extends 'single' ? T : readonly T[];
interface CalendarState<M extends CalendarSelectionMode = 'single'> extends CalendarStateBase {
    /** Whether single or multiple selection is enabled. */
    readonly selectionMode: M;
    /** The currently selected date. */
    readonly value: CalendarValueType<CalendarDate | null, M>;
    /** Sets the currently selected date. */
    setValue(value: CalendarValueType<CalendarDate | null, M>): void;
}
interface RangeCalendarState<T extends DateValue$1 = DateValue$1> extends CalendarStateBase {
    /** The currently selected date range. */
    readonly value: RangeValue<T> | null;
    /** Sets the currently selected date range. */
    setValue(value: RangeValue<T> | null): void;
    /** Highlights the given date during selection, e.g. by hovering or dragging. */
    highlightDate(date: CalendarDate): void;
    /** The current anchor date that the user clicked on to begin range selection. */
    readonly anchorDate: CalendarDate | null;
    /** Sets the anchor date that the user clicked on to begin range selection. */
    setAnchorDate(date: CalendarDate | null): void;
    /** The currently highlighted date range. */
    readonly highlightedRange: RangeValue<CalendarDate> | null;
    /** Whether the user is currently dragging over the calendar. */
    readonly isDragging: boolean;
    /** Sets whether the user is dragging over the calendar. */
    setDragging(isDragging: boolean): void;
    /** Clears the current selection. */
    clearSelection(): void;
    /** Commits the current selection. */
    commitSelection(): void;
    /** Focuses the next available day before or after the anchor date. */
    focusNearestAvailableDate(anchorDate: CalendarDate): void;
}

interface CalendarProps$1<T extends DateValue$1, M extends CalendarSelectionMode = 'single'> extends CalendarPropsBase, ValueBase<CalendarValueType<T | null, M>, CalendarValueType<MappedDateValue$1<T>, M>> {
    /**
     * Whether single or multiple selection is enabled.
     *
     * @default 'single'
     */
    selectionMode?: M;
    /**
     * Callback that is called for each date of the calendar. If it returns true, then the date is
     * unavailable.
     */
    isDateUnavailable?: (date: DateValue$1) => boolean;
}

interface RangeCalendarProps$1<T extends DateValue$1> extends CalendarPropsBase, ValueBase<RangeValue<T> | null, RangeValue<MappedDateValue$1<T>>> {
    /**
     * When combined with `isDateUnavailable`, determines whether non-contiguous ranges,
     * i.e. ranges containing unavailable dates, may be selected.
     */
    allowsNonContiguousRanges?: boolean;
    /**
     * Callback that is called for each date of the calendar. If it returns true, then the date is
     * unavailable. The second argument provides the current selection anchor date, if any. This can
     * be used to adjust the available dates based on the user's first selected date.
     */
    isDateUnavailable?: (date: DateValue$1, anchorDate: CalendarDate | null) => boolean;
}

interface AriaCalendarProps<T extends DateValue$1, M extends CalendarSelectionMode = 'single'> extends CalendarProps$1<T, M>, DOMProps$1, AriaLabelingProps {
}

interface AriaRangeCalendarProps<T extends DateValue$1> extends RangeCalendarProps$1<T>, DOMProps$1, AriaLabelingProps {
    /**
     * Controls the behavior when a pointer is released outside the calendar or a blur occurs mid
     * selection:
     *
     * - `clear`: clear the currently selected range of dates.
     * - `reset`: reset the selection to the previously selected range of dates.
     * - `select`: select the currently hovered range of dates.
     *
     * @default 'select'
     */
    commitBehavior?: 'clear' | 'reset' | 'select';
}

interface HeadingProps extends HTMLAttributes<HTMLElement>, DOMRenderProps<'h1', undefined> {
    /**
     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
     * element.
     *
     * @default 'react-aria-Heading'
     */
    className?: string;
    /**
     * The heading level.
     *
     * @default 3
     */
    level?: number;
}
declare const Heading: React.ForwardRefExoticComponent<HeadingProps & React.RefAttributes<HTMLHeadingElement>>;

interface CalendarRenderProps<M extends CalendarSelectionMode = 'single'> {
    /**
     * Whether the calendar is disabled.
     *
     * @selector [data-disabled]
     */
    isDisabled: boolean;
    /**
     * State of the calendar.
     */
    state: CalendarState<M>;
    /**
     * Whether the calendar is invalid.
     *
     * @selector [data-invalid]
     */
    isInvalid: boolean;
}
interface RangeCalendarRenderProps extends Omit<CalendarRenderProps, 'state'> {
    /**
     * State of the range calendar.
     */
    state: RangeCalendarState;
}
interface CalendarProps<T extends DateValue$1, M extends CalendarSelectionMode = 'single'> extends Omit<AriaCalendarProps<T, M>, 'errorMessage' | 'validationState'>, RenderProps<CalendarRenderProps<M>, '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<M>>;
    /**
     * 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) => Calendar$1;
}
interface RangeCalendarProps<T extends DateValue$1> 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) => Calendar$1;
}
/**
 * A calendar displays one or more date grids and allows users to select a single date.
 */
declare const Calendar: <T extends DateValue$1, M extends CalendarSelectionMode = "single">(props: CalendarProps<T, M> & React.RefAttributes<HTMLDivElement>) => ReactElement | null;
/**
 * A range calendar displays one or more date grids and allows users to select a contiguous range of
 * dates.
 */
declare const RangeCalendar: <T extends DateValue$1>(props: RangeCalendarProps<T> & React.RefAttributes<HTMLDivElement>) => ReactElement | null;
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;
}
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.
 */
declare const CalendarGrid: (props: CalendarGridProps & React.RefAttributes<HTMLTableElement>) => ReactElement | null;
interface CalendarCellProps extends RenderProps<CalendarCellRenderProps, 'div'>, HoverEvents, 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.
 */
declare const CalendarCell: (props: CalendarCellProps & React.RefAttributes<HTMLTableCellElement>) => ReactElement | null;

interface FormValidationState {
    /** Realtime validation results, updated as the user edits the value. */
    realtimeValidation: ValidationResult;
    /** Currently displayed validation results, updated when the user commits their changes. */
    displayValidation: ValidationResult;
    /**
     * Updates the current validation result. Not displayed to the user until `commitValidation` is
     * called.
     */
    updateValidation(result: ValidationResult): void;
    /** Resets the displayed validation state to valid when the user resets the form. */
    resetValidation(): void;
    /** Commits the realtime validation so it is displayed to the user. */
    commitValidation(): void;
}

interface CheckboxGroupProps$1 extends ValueBase<string[]>, Pick<InputDOMProps, 'name'>, InputBase, LabelableProps, HelpTextProps, Validation<string[]> {
}
interface CheckboxGroupState extends FormValidationState {
    /** Current selected values. */
    readonly value: readonly string[];
    /** Default selected values. */
    readonly defaultValue: readonly string[];
    /** Whether the checkbox group is disabled. */
    readonly isDisabled: boolean;
    /** Whether the checkbox group is read only. */
    readonly isReadOnly: boolean;
    /**
     * The current validation state of the checkbox group.
     *
     * @deprecated Use `isInvalid` instead.
     */
    readonly validationState: ValidationState | null;
    /** Whether the checkbox group is invalid. */
    readonly isInvalid: boolean;
    /**
     * Whether the checkboxes in the group are required.
     * This changes to false once at least one item is selected.
     */
    readonly isRequired: boolean;
    /** Returns whether the given value is selected. */
    isSelected(value: string): boolean;
    /** Sets the selected values. */
    setValue(value: string[]): void;
    /** Adds a value to the set of selected values. */
    addValue(value: string): void;
    /** Removes a value from the set of selected values. */
    removeValue(value: string): void;
    /** Toggles a value in the set of selected values. */
    toggleValue(value: string): void;
    /** Sets whether one of the checkboxes is invalid. */
    setInvalid(value: string, validation: ValidationResult): void;
}

interface AriaCheckboxGroupProps extends CheckboxGroupProps$1, InputDOMProps, DOMProps$1, AriaLabelingProps, AriaValidationProps, FocusEvents {
}

interface ToggleStateOptions extends InputBase {
    /**
     * Whether the element should be selected (uncontrolled).
     */
    defaultSelected?: boolean;
    /**
     * Whether the element should be selected (controlled).
     */
    isSelected?: boolean;
    /**
     * Handler that is called when the element's selection state changes.
     */
    onChange?: (isSelected: boolean) => void;
}
interface ToggleProps extends ToggleStateOptions, Validation<boolean>, FocusableProps {
    /**
     * The label for the element.
     */
    children?: ReactNode;
    /**
     * The value of the input element, used when submitting an HTML form. See
     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefvalue).
     */
    value?: string;
}

interface AriaToggleProps extends ToggleProps, FocusableDOMProps, AriaLabelingProps, AriaValidationProps, InputDOMProps, PressEvents {
    /**
     * Identifies the element (or elements) whose contents or presence are controlled by the current
     * element.
     */
    'aria-controls'?: string;
}

interface CheckboxProps$1 extends ToggleProps {
    /**
     * Indeterminism is presentational only.
     * The indeterminate visual representation remains regardless of user interaction.
     */
    isIndeterminate?: boolean;
}
interface AriaCheckboxProps extends CheckboxProps$1, InputDOMProps, AriaToggleProps {
}

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>;
}
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?: Ref<HTMLInputElement | null>;
}
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;
}
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;
}
/**
 * A checkbox group allows a user to select multiple items from a list of options.
 */
declare 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.
 *
 * @deprecated Use CheckboxField + CheckboxButton instead.
 */
declare const Checkbox: (props: CheckboxProps & React.RefAttributes<HTMLLabelElement>) => React.ReactElement | null;

/** A list of supported color formats. */
type ColorFormat = 'hex' | 'hexa' | 'rgb' | 'rgba' | 'hsl' | 'hsla' | 'hsb' | 'hsba';
type ColorSpace = 'rgb' | 'hsl' | 'hsb';
/** A list of color channels. */
type ColorChannel = 'hue' | 'saturation' | 'brightness' | 'lightness' | 'red' | 'green' | 'blue' | 'alpha';
type ColorAxes = {
    xChannel: ColorChannel;
    yChannel: ColorChannel;
    zChannel: ColorChannel;
};
interface ColorChannelRange {
    /** The minimum value of the color channel. */
    minValue: number;
    /** The maximum value of the color channel. */
    maxValue: number;
    /** The step value of the color channel, used when incrementing and decrementing. */
    step: number;
    /** The page step value of the color channel, used when incrementing and decrementing. */
    pageSize: number;
}
/** Represents a color value. */
interface Color {
    /** Converts the color to the given color format, and returns a new Color object. */
    toFormat(format: ColorFormat): Color;
    /** Converts the color to a string in the given format. */
    toString(format?: ColorFormat | 'css'): string;
    /** Returns a duplicate of the color value. */
    clone(): Color;
    /** Converts the color to hex, and returns an integer representation. */
    toHexInt(): number;
    /**
     * Returns the numeric value for a given channel.
     * Throws an error if the channel is unsupported in the current color format.
     */
    getChannelValue(channel: ColorChannel): number;
    /**
     * Sets the numeric value for a given channel, and returns a new Color object.
     * Throws an error if the channel is unsupported in the current color format.
     */
    withChannelValue(channel: ColorChannel, value: number): Color;
    /**
     * Returns the minimum, maximum, and step values for a given channel.
     */
    getChannelRange(channel: ColorChannel): ColorChannelRange;
    /**
     * Returns a localized color channel name for a given channel and locale,
     * for use in visual or accessibility labels.
     */
    getChannelName(channel: ColorChannel, locale: string): string;
    /**
     * Returns the number formatting options for the given channel.
     */
    getChannelFormatOptions(channel: ColorChannel): Intl.NumberFormatOptions;
    /**
     * Formats the numeric value for a given channel for display according to the provided locale.
     */
    formatChannelValue(channel: ColorChannel, locale: string): string;
    /**
     * Returns the color space, 'rgb', 'hsb' or 'hsl', for the current color.
     */
    getColorSpace(): ColorSpace;
    /**
     * Returns the color space axes, xChannel, yChannel, zChannel.
     */
    getColorSpaceAxes(xyChannels: {
        xChannel?: ColorChannel;
        yChannel?: ColorChannel;
    }): ColorAxes;
    /**
     * Returns an array of the color channels within the current color space space.
     */
    getColorChannels(): [ColorChannel, ColorChannel, ColorChannel];
    /**
     * Returns a localized name for the color, for use in visual or accessibility labels.
     */
    getColorName(locale: string): string;
    /**
     * Returns a localized name for the hue, for use in visual or accessibility labels.
     */
    getHueName(locale: string): string;
}

interface ColorAreaProps$1 extends Omit<ValueBase<string | Color>, 'onChange'> {
    /**
     * The color space that the color area operates in. The `xChannel` and `yChannel` must be in this
     * color space. If not provided, this defaults to the color space of the `color` or `defaultColor`
     * value.
     */
    colorSpace?: ColorSpace;
    /** Color channel for the horizontal axis. */
    xChannel?: ColorChannel;
    /** Color channel for the vertical axis. */
    yChannel?: ColorChannel;
    /** Whether the ColorArea is disabled. */
    isDisabled?: boolean;
    /** Handler that is called when the value changes, as the user drags. */
    onChange?: (value: Color) => void;
    /** Handler that is called when the user stops dragging. */
    onChangeEnd?: (value: Color) => void;
}
interface ColorAreaState {
    /** The current color value displayed by the color area. */
    readonly value: Color;
    /** The default value of the color area. */
    readonly defaultValue: Color;
    /** Sets the current color value. If a string is passed, it will be parsed to a Color. */
    setValue(value: string | Color): void;
    /** The current value of the horizontal axis channel displayed by the color area. */
    xValue: number;
    /**
     * Sets the value for the horizontal axis channel displayed by the color area, and triggers
     * `onChange`.
     */
    setXValue(value: number): void;
    /** The current value of the vertical axis channel displayed by the color area. */
    yValue: number;
    /**
     * Sets the value for the vertical axis channel displayed by the color area, and triggers
     * `onChange`.
     */
    setYValue(value: number): void;
    /**
     * Sets the x and y channels of the current color value based on a percentage of the width and
     * height of the color area, and triggers `onChange`.
     */
    setColorFromPoint(x: number, y: number): void;
    /**
     * Returns the coordinates of the thumb relative to the upper left corner of the color area as a
     * percentage.
     */
    getThumbPosition(): {
        x: number;
        y: number;
    };
    /** Increments the value of the horizontal axis channel by the channel step or page amount. */
    incrementX(stepSize?: number): void;
    /** Decrements the value of the horizontal axis channel by the channel step or page amount. */
    decrementX(stepSize?: number): void;
    /** Increments the value of the vertical axis channel by the channel step or page amount. */
    incrementY(stepSize?: number): void;
    /** Decrements the value of the vertical axis channel by the channel step or page amount. */
    decrementY(stepSize?: number): void;
    /** Whether the color area is currently being dragged. */
    readonly isDragging: boolean;
    /** Sets whether the color area is being dragged. */
    setDragging(value: boolean): void;
    /** Returns the xChannel, yChannel and zChannel names based on the color value. */
    channels: {
        xChannel: ColorChannel;
        yChannel: ColorChannel;
        zChannel: ColorChannel;
    };
    /** The step value of the xChannel, used when incrementing and decrementing. */
    xChannelStep: number;
    /** The step value of the yChannel, used when incrementing and decrementing. */
    yChannelStep: number;
    /** The page step value of the xChannel, used when incrementing and decrementing. */
    xChannelPageStep: number;
    /** The page step value of the yChannel, used when incrementing and decrementing. */
    yChannelPageStep: number;
    /** Returns the color that should be displayed in the color area thumb instead of `value`. */
    getDisplayColor(): Color;
}

interface AriaColorAreaProps extends ColorAreaProps$1, DOMProps$1, AriaLabelingProps {
    /**
     * The name of the x channel input element, used when submitting an HTML form. See
     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefname).
     */
    xName?: string;
    /**
     * The name of the y channel input element, used when submitting an HTML form. See
     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefname).
     */
    yName?: string;
    /**
     * The `<form>` element to associate the ColorArea with.
     * The value of this attribute must be the id of a `<form>` in the same document.
     * See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#form).
     */
    form?: string;
}

interface ColorAreaRenderProps {
    /**
     * Whether the color area is disabled.
     *
     * @selector [data-disabled]
     */
    isDisabled: boolean;
    /**
     * State of the color area.
     */
    state: ColorAreaState;
}
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>;
}
/**
 * A color area allows users to adjust two channels of an RGB, HSL or HSB color value against a
 * two-dimensional gradient background.
 */
declare const ColorArea: React.ForwardRefExoticComponent<ColorAreaProps & React.RefAttributes<HTMLDivElement>>;

interface ColorFieldProps$1 extends Omit<ValueBase<string | Color | null>, 'onChange'>, InputBase, Validation<Color | null>, FocusableProps, TextInputBase, LabelableProps, HelpTextProps {
    /** Handler that is called when the value changes. */
    onChange?: (color: Color | null) => void;
}
interface ColorFieldState extends FormValidationState {
    /**
     * The current text value of the input. Updated as the user types,
     * and formatted according to `formatOptions` on blur.
     */
    readonly inputValue: string;
    /**
     * The currently parsed color value, or null if the field is empty.
     * Updated based on the `inputValue` as the user types.
     */
    readonly colorValue: Color | null;
    /** The default value of the color field. */
    readonly defaultColorValue: Color | null;
    /** Sets the color value of the field. */
    setColorValue(value: Color | null): void;
    /** Sets the current text value of the input. */
    setInputValue(value: string): void;
    /**
     * Updates the input value based on the currently parsed color value.
     * Typically this is called when the field is blurred.
     */
    commit(): void;
    /** Increments the current input value to the next step boundary, and fires `onChange`. */
    increment(): void;
    /** Decrements the current input value to the next step boundary, and fires `onChange`. */
    decrement(): void;
    /** Sets the current value to the maximum color value, and fires `onChange`. */
    incrementToMax(): void;
    /** Sets the current value to the minimum color value, and fires `onChange`. */
    decrementToMin(): void;
    /**
     * Validates a user input string. Values can be partially entered, and may be valid even if they
     * cannot currently be parsed to a color. Can be used to implement validation as a user types.
     */
    validate(value: string): boolean;
}

interface NumberFieldProps$1 extends InputBase, Validation<number>, FocusableProps, TextInputBase, ValueBase<number>, RangeInputBase<number>, LabelableProps, HelpTextProps {
    /**
     * Formatting options for the value displayed in the number field.
     * This also affects what characters are allowed to be typed by the user.
     */
    formatOptions?: Intl.NumberFormatOptions;
    /**
     * Controls the behavior of the number field when the user blurs the field after editing. 'snap'
     * will clamp the value to the min/max values, and snap to the nearest step value. 'validate' will
     * not clamp the value, and will validate that the value is within the min/max range and on a
     * valid step.
     *
     * @default 'snap'
     */
    commitBehavior?: 'snap' | 'validate';
}
interface NumberFieldState extends FormValidationState {
    /**
     * The current text value of the input. Updated as the user types,
     * and formatted according to `formatOptions` on blur.
     */
    inputValue: string;
    /**
     * The currently parsed number value, or NaN if a valid number could not be parsed.
     * Updated based on the `inputValue` as the user types.
     */
    numberValue: number;
    /** The default value of the input. */
    defaultNumberValue: number;
    /** The minimum value of the number field. */
    minValue?: number;
    /** The maximum value of the number field. */
    maxValue?: number;
    /** Whether the current value can be incremented according to the maximum value and step. */
    canIncrement: boolean;
    /** Whether the current value can be decremented according to the minimum value and step. */
    canDecrement: boolean;
    /**
     * Validates a user input string according to the current locale and format options. Values can be
     * partially entered, and may be valid even if they cannot currently be parsed to a number. Can be
     * used to implement validation as a user types.
     */
    validate(value: string): boolean;
    /** Sets the current text value of the input. */
    setInputValue(val: string): void;
    /** Sets the number value. */
    setNumberValue(val: number): void;
    /**
     * Commits the current input value. The value is parsed to a number, clamped according to the
     * minimum and maximum values of the field, and snapped to the nearest step value. This will fire
     * the `onChange` prop with the new value, and if uncontrolled, update the `numberValue`.
     * Typically this is called when the field is blurred.
     *
     * @param value - The value to commit. If not provided, the current input value is used.
     */
    commit(value?: string): void;
    /** Increments the current input value to the next step boundary, and fires `onChange`. */
    increment(): void;
    /** Decrements the current input value to the next step boundary, and fires `onChange`. */
    decrement(): void;
    /** Sets the current value to the `maxValue` if any, and fires `onChange`. */
    incrementToMax(): void;
    /** Sets the current value to the `minValue` if any, and fires `onChange`. */
    decrementToMin(): void;
}

interface AriaColorFieldProps extends ColorFieldProps$1, AriaLabelingProps, FocusableDOMProps, Omit<TextInputDOMProps, 'minLength' | 'maxLength' | 'pattern' | 'type' | 'inputMode' | 'autoComplete' | 'autoCorrect' | 'spellCheck'>, AriaValidationProps {
    /** Enables or disables changing the value with scroll. */
    isWheelDisabled?: boolean;
}

interface AriaNumberFieldProps extends NumberFieldProps$1, DOMProps$1, AriaLabelingProps, TextInputDOMEvents {
    /**
     * A custom aria-label for the decrement button. If not provided, the localized string "Decrement"
     * is used.
     */
    decrementAriaLabel?: string;
    /**
     * A custom aria-label for the increment button. If not provided, the localized string "Increment"
     * is used.
     */
    incrementAriaLabel?: string;
    /**
     * Enables or disables changing the value with scroll.
     */
    isWheelDisabled?: boolean;
}

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;
}
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;
}
/**
 * A color field allows users to edit a hex color or individual color channel value.
 */
declare const ColorField: React.ForwardRefExoticComponent<ColorFieldProps & React.RefAttributes<HTMLDivElement>>;

interface SliderProps<T = number | number[]> extends RangeInputBase<number>, ValueBase<T>, LabelableProps {
    /**
     * The orientation of the Slider.
     *
     * @default 'horizontal'
     */
    orientation?: Orientation;
    /** Whether the whole Slider is disabled. */
    isDisabled?: boolean;
    /** Fired when the slider stops moving, due to being let go. */
    onChangeEnd?: (value: T) => void;
    /**
     * The slider's minimum value.
     *
     * @default 0
     */
    minValue?: number;
    /**
     * The slider's maximum value.
     *
     * @default 100
     */
    maxValue?: number;
    /**
     * The slider's step value.
     *
     * @default 1
     */
    step?: number;
}
interface SliderState {
    /**
     * Values managed by the slider by thumb index.
     */
    readonly values: number[];
    /**
     * The default values for each thumb.
     */
    readonly defaultValues: number[];
    /**
     * Get the value for the specified thumb.
     *
     * @param index
     */
    getThumbValue(index: number): number;
    /**
     * Sets the value for the specified thumb.
     * The actual value set will be clamped and rounded according to min/max/step.
     *
     * @param index
     * @param value
     */
    setThumbValue(index: number, value: number): void;
    /**
     * Sets value for the specified thumb by percent offset (between 0 and 1).
     *
     * @param index
     * @param percent
     */
    setThumbPercent(index: number, percent: number): void;
    /**
     * Whether the specific thumb is being dragged.
     *
     * @param index
     */
    isThumbDragging(index: number): boolean;
    /**
     * Set is dragging on the specified thumb.
     *
     * @param index
     * @param dragging
     */
    setThumbDragging(index: number, dragging: boolean): void;
    /**
     * Currently-focused thumb index.
     */
    readonly focusedThumb: number | undefined;
    /**
     * Set focused true on specified thumb. This will remove focus from
     * any thumb that had it before.
     *
     * @param index
     */
    setFocusedThumb(index: number | undefined): void;
    /**
     * Returns the specified thumb's value as a percentage from 0 to 1.
     *
     * @param index
     */
    getThumbPercent(index: number): number;
    /**
     * Returns the value as a percent between the min and max of the slider.
     *
     * @param index
     */
    getValuePercent(value: number): number;
    /**
     * Returns the string label for the specified thumb's value, per props.formatOptions.
     *
     * @param index
     */
    getThumbValueLabel(index: number): string;
    /**
     * Returns the string label for the value, per props.formatOptions.
     *
     * @param value
     */
    getFormattedValue(value?: number | number[]): string;
    /**
     * Returns the min allowed value for the specified thumb.
     *
     * @param index
     */
    getThumbMinValue(index: number): number;
    /**
     * Returns the max allowed value for the specified thumb.
     *
     * @param index
     */
    getThumbMaxValue(index: number): number;
    /**
     * Converts a percent along track (between 0 and 1) to the corresponding value.
     *
     * @param percent
     */
    getPercentValue(percent: number): number;
    /**
     * Returns if the specified thumb is editable.
     *
     * @param index
     */
    isThumbEditable(index: number): boolean;
    /**
     * Set the specified thumb's editable state.
     *
     * @param index
     * @param editable
     */
    setThumbEditable(index: number, editable: boolean): void;
    /**
     * Increments the value of the thumb by the step or page amount.
     */
    incrementThumb(index: number, stepSize?: number): void;
    /**
     * Decrements the value of the thumb by the step or page amount.
     */
    decrementThumb(index: number, stepSize?: number): void;
    /**
     * The step amount for the slider.
     */
    readonly step: number;
    /**
     * The page size for the slider, used to do a bigger step.
     */
    readonly pageSize: number;
    /** The orientation of the slider. */
    readonly orientation: Orientation;
    /** Whether the slider is disabled. */
    readonly isDisabled: boolean;
}

interface ColorSliderProps$1 extends Omit<SliderProps<string | Color>, 'minValue' | 'maxValue' | 'step' | 'pageSize' | 'onChange' | 'onChangeEnd'> {
    /**
     * The color space that the slider operates in. The `channel` must be in this color space.
     * If not provided, this defaults to the color space of the `color` or `defaultColor` value.
     */
    colorSpace?: ColorSpace;
    /** The color channel that the slider manipulates. */
    channel: ColorChannel;
    /** Handler that is called when the value changes, as the user drags. */
    onChange?: (value: Color) => void;
    /** Handler that is called when the user stops dragging. */
    onChangeEnd?: (value: Color) => void;
}
interface ColorSliderState extends SliderState {
    /** The current color value represented by the color slider. */
    readonly value: Color;
    /** Sets the current color value. If a string is passed, it will be parsed to a Color. */
    setValue(value: string | Color): void;
    /**
     * Returns the color that should be displayed in the slider instead of `value` or the optional
     * parameter.
     */
    getDisplayColor(): Color;
    /** Whether the color slider is currently being dragged. */
    readonly isDragging: boolean;
}

interface AriaColorSliderProps extends ColorSliderProps$1, InputDOMProps, DOMProps$1, AriaLabelingProps {
}

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;
}
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>;
}
/**
 * A color slider allows users to adjust an individual channel of a color value.
 */
declare const ColorSlider: React.ForwardRefExoticComponent<ColorSliderProps & React.RefAttributes<HTMLDivElement>>;

interface AriaColorSwatchProps extends AriaLabelingProps, DOMProps$1 {
    /** The color value to display in the swatch. */
    color?: string | Color;
    /**
     * A localized accessible name for the color.
     * By default, a description is generated from the color value,
     * but this can be overridden if you have a more specific color
     * name (e.g. Pantone colors).
     */
    colorName?: string;
}

interface ColorSwatchRenderProps {
    /** The color of the swatch. */
    color: Color;
}
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>;
}
/**
 * A ColorSwatch displays a preview of a selected color.
 */
declare const ColorSwatch: React.ForwardRefExoticComponent<ColorSwatchProps & React.RefAttributes<HTMLDivElement>>;

interface FocusState {
    /** Whether the collection is currently focused. */
    readonly isFocused: boolean;
    /** Sets whether the collection is focused. */
    setFocused(isFocused: boolean): void;
    /** The current focused key in the collection. */
    readonly focusedKey: Key | null;
    /** Whether the first or last child of the focused key should receive focus. */
    readonly childFocusStrategy: FocusStrategy | null;
    /**
     * Sets the focused key, and optionally, whether the first or last child of that key should
     * receive focus.
     */
    setFocusedKey(key: Key | null, child?: FocusStrategy): void;
}
interface MultipleSelectionState extends FocusState {
    /** The type of selection that is allowed in the collection. */
    readonly selectionMode: SelectionMode$4;
    /** The selection behavior for the collection. */
    readonly selectionBehavior: SelectionBehavior;
    /** Sets the selection behavior for the collection. */
    setSelectionBehavior(selectionBehavior: SelectionBehavior): void;
    /** Whether the collection allows empty selection. */
    readonly disallowEmptySelection: boolean;
    /** The currently selected keys in the collection. */
    readonly selectedKeys: Selection;
    /** Sets the selected keys in the collection. */
    setSelectedKeys(keys: Selection): void;
    /** The currently disabled keys in the collection. */
    readonly disabledKeys: Set<Key>;
    /** Whether `disabledKeys` applies to selection, actions, or both. */
    readonly disabledBehavior: DisabledBehavior;
}
interface MultipleSelectionManager extends FocusState {
    /** The type of selection that is allowed in the collection. */
    readonly selectionMode: SelectionMode$4;
    /** The selection behavior for the collection. */
    readonly selectionBehavior: SelectionBehavior;
    /** Whether the collection allows empty selection. */
    readonly disallowEmptySelection?: boolean;
    /** The currently selected keys in the collection. */
    readonly selectedKeys: Set<Key>;
    /** Whether the selection is empty. */
    readonly isEmpty: boolean;
    /** Whether all items in the collection are selected. */
    readonly isSelectAll: boolean;
    /** The first selected key in the collection. */
    readonly firstSelectedKey: Key | null;
    /** The last selected key in the collection. */
    readonly lastSelectedKey: Key | null;
    /** The currently disabled keys in the collection. */
    readonly disabledKeys: Set<Key>;
    /** Whether `disabledKeys` applies to selection, actions, or both. */
    readonly disabledBehavior: DisabledBehavior;
    /** Returns whether a key is selected. */
    isSelected(key: Key): boolean;
    /** Returns whether the current selection is equal to the given selection. */
    isSelectionEqual(selection: Set<Key>): boolean;
    /** Extends the selection to the given key. */
    extendSelection(toKey: Key): void;
    /** Toggles whether the given key is selected. */
    toggleSelection(key: Key): void;
    /** Replaces the selection with only the given key. */
    replaceSelection(key: Key): void;
    /** Replaces the selection with the given keys. */
    setSelectedKeys(keys: Iterable<Key>): void;
    /** Selects all items in the collection. */
    selectAll(): void;
    /** Removes all keys from the selection. */
    clearSelection(): void;
    /** Toggles between select all and an empty selection. */
    toggleSelectAll(): void;
    /**
     * Toggles, replaces, or extends selection to the given key depending
     * on the pointer event and collection's selection mode.
     */
    select(key: Key, e?: PressEvent | LongPressEvent | PointerEvent): void;
    /** Returns whether the given key can be selected. */
    canSelectItem(key: Key): boolean;
    /** Returns whether the given key is non-interactive, i.e. both selection and actions are disabled. */
    isDisabled(key: Key): boolean;
    /** Sets the selection behavior for the collection. */
    setSelectionBehavior(selectionBehavior: SelectionBehavior): void;
    /** Returns whether the given key is a hyperlink. */
    isLink(key: Key): boolean;
    /** Returns the props for the given item. */
    getItemProps(key: Key): any;
    /** The collection of nodes that the selection manager handles. */
    collection: Collection<Node<unknown>>;
}

interface SelectionManagerOptions {
    allowsCellSelection?: boolean;
    layoutDelegate?: LayoutDelegate;
    fullCollection?: Collection<Node<unknown>>;
}
/**
 * An interface for reading and updating multiple selection state.
 */
declare class SelectionManager implements MultipleSelectionManager {
    collection: Collection<Node<unknown>>;
    private state;
    private allowsCellSelection;
    private _isSelectAll;
    private layoutDelegate;
    private fullCollection;
    constructor(collection: Collection<Node<unknown>>, state: MultipleSelectionState, options?: SelectionManagerOptions);
    /**
     * The type of selection that is allowed in the collection.
     */
    get selectionMode(): SelectionMode$4;
    /**
     * Whether the collection allows empty selection.
     */
    get disallowEmptySelection(): boolean;
    /**
     * The selection behavior for the collection.
     */
    get selectionBehavior(): SelectionBehavior;
    /**
     * Sets the selection behavior for the collection.
     */
    setSelectionBehavior(selectionBehavior: SelectionBehavior): void;
    /**
     * Whether the collection is currently focused.
     */
    get isFocused(): boolean;
    /**
     * Sets whether the collection is focused.
     */
    setFocused(isFocused: boolean): void;
    /**
     * The current focused key in the collection.
     */
    get focusedKey(): Key | null;
    /** Whether the first or last child of the focused key should receive focus. */
    get childFocusStrategy(): FocusStrategy | null;
    /**
     * Sets the focused key.
     */
    setFocusedKey(key: Key | null, childFocusStrategy?: FocusStrategy): void;
    /**
     * The currently selected keys in the collection.
     */
    get selectedKeys(): Set<Key>;
    /**
     * The raw selection value for the collection.
     * Either 'all' for select all, or a set of keys.
     */
    get rawSelection(): Selection;
    /**
     * Returns whether a key is selected.
     */
    isSelected(key: Key): boolean;
    /**
     * Whether the selection is empty.
     */
    get isEmpty(): boolean;
    /**
     * Whether all items in the collection are selected.
     */
    get isSelectAll(): boolean;
    get firstSelectedKey(): Key | null;
    get lastSelectedKey(): Key | null;
    get disabledKeys(): Set<Key>;
    get disabledBehavior(): DisabledBehavior;
    /**
     * Extends the selection to the given key.
     */
    extendSelection(toKey: Key): void;
    private getKeyRange;
    private getKeyRangeInternal;
    private getKey;
    /**
     * Toggles whether the given key is selected.
     */
    toggleSelection(key: Key): void;
    /**
     * Replaces the selection with only the given key.
     */
    replaceSelection(key: Key): void;
    /**
     * Replaces the selection with the given keys.
     */
    setSelectedKeys(keys: Iterable<Key>): void;
    private getSelectAllKeys;
    /**
     * Selects all items in the collection.
     */
    selectAll(): void;
    /**
     * Removes all keys from the selection.
     */
    clearSelection(): void;
    /**
     * Toggles between select all and an empty selection.
     */
    toggleSelectAll(): void;
    select(key: Key, e?: PressEvent | LongPressEvent | PointerEvent): void;
    /**
     * Returns whether the current selection is equal to the given selection.
     */
    isSelectionEqual(selection: Set<Key>): boolean;
    canSelectItem(key: Key): boolean;
    private canSelectItemIn;
    isDisabled(key: Key): boolean;
    isLink(key: Key): boolean;
    getItemProps(key: Key): any;
    withCollection(collection: Collection<Node<unknown>>): SelectionManager;
}

interface ListState<T> {
    /** A collection of items in the list. */
    collection: Collection<Node<T>>;
    /** A set of items that are disabled. */
    disabledKeys: Set<Key>;
    /** A selection manager to read and update multiple selection state. */
    selectionManager: SelectionManager;
}

interface ListBoxProps$1<T> extends CollectionBase<T>, MultipleSelection, FocusEvents {
    /** Whether to auto focus the listbox or an option. */
    autoFocus?: boolean | FocusStrategy;
    /** Whether focus should wrap around when the end/start is reached. */
    shouldFocusWrap?: boolean;
}
interface AriaListBoxPropsBase<T> extends ListBoxProps$1<T>, DOMProps$1, AriaLabelingProps {
    /**
     * Whether pressing the escape key should clear selection in the listbox or not.
     *
     * Most experiences should not modify this option as it eliminates a keyboard user's ability to
     * easily clear selection. Only use if the escape key is being handled externally or should not
     * trigger selection clearing contextually.
     *
     * @default 'clearSelection'
     */
    escapeKeyBehavior?: 'clearSelection' | 'none';
}
interface AriaListBoxProps<T> extends AriaListBoxPropsBase<T> {
    /**
     * An optional visual label for the listbox.
     */
    label?: ReactNode;
    /** How multiple selection should behave in the collection. */
    selectionBehavior?: SelectionBehavior;
    /** Whether selection should occur on press up instead of press down. */
    shouldSelectOnPressUp?: boolean;
    /** Whether options should be focused when the user hovers over them. */
    shouldFocusOnHover?: boolean;
    /**
     * Handler that is called when a user performs an action on an item. The exact user event depends
     * on the collection's `selectionBehavior` prop and the interaction modality.
     */
    onAction?: (key: Key) => void;
}

interface DropOperationEvent {
    target: DropTarget;
    types: DragTypes;
    allowedOperations: DropOperation[];
    isInternal: boolean;
    draggingKeys: Set<Key>;
}
interface DroppableCollectionStateOptions extends Omit<DroppableCollectionProps, 'onDropMove' | 'onDropActivate'> {
    /** A collection of items. */
    collection: Collection<Node<unknown>>;
    /** An interface for reading and updating multiple selection state. */
    selectionManager: MultipleSelectionManager;
    /** Whether the drop events should be disabled. */
    isDisabled?: boolean;
}
interface DroppableCollectionState {
    /** A collection of items. */
    collection: Collection<Node<unknown>>;
    /** An interface for reading and updating multiple selection state. */
    selectionManager: MultipleSelectionManager;
    /** The current drop target. */
    target: DropTarget | null;
    /** Whether drop events are disabled. */
    isDisabled?: boolean;
    /** Sets the current drop target. */
    setTarget(target: DropTarget | null): void;
    /** Returns whether the given target is equivalent to the current drop target. */
    isDropTarget(target: DropTarget | null): boolean;
    /** Returns the drop operation for the given parameters. */
    getDropOperation(e: DropOperationEvent): DropOperation;
}

interface DroppableCollectionOptions extends DroppableCollectionProps {
    /** A delegate object that implements behavior for keyboard focus movement. */
    keyboardDelegate: KeyboardDelegate;
    /** A delegate object that provides drop targets for pointer coordinates within the collection. */
    dropTargetDelegate: DropTargetDelegate;
    /** A custom keyboard event handler for drop targets. */
    onKeyDown?: (e: KeyboardEvent) => void;
}
interface DroppableCollectionResult {
    /** Props for the collection element. */
    collectionProps: HTMLAttributes<HTMLElement>;
}

interface DroppableItemOptions {
    /** The drop target represented by the item. */
    target: DropTarget;
    /** The ref to the activate button. */
    activateButtonRef?: RefObject<FocusableElement | null>;
}
interface DroppableItemResult {
    /** Props for the droppable element. */
    dropProps: HTMLAttributes<HTMLElement>;
    /** Whether the item is currently the active drop target. */
    isDropTarget: boolean;
}

interface DropIndicatorProps {
    /** The drop target that the drop indicator represents. */
    target: DropTarget;
    /** The ref to the activate button. */
    activateButtonRef?: RefObject<FocusableElement | null>;
}
interface DropIndicatorAria {
    /** Props for the drop indicator element. */
    dropIndicatorProps: HTMLAttributes<HTMLElement>;
    /** Whether the drop indicator is currently the active drop target. */
    isDropTarget: boolean;
    /**
     * Whether the drop indicator is hidden, both visually and from assistive technology.
     * Use this to determine whether to omit the element from the DOM entirely.
     */
    isHidden: boolean;
}

interface DraggableCollectionStateOptions<T = object> extends DraggableCollectionProps<T> {
    /** A collection of items. */
    collection: Collection<Node<unknown>>;
    /** An interface for reading and updating multiple selection state. */
    selectionManager: MultipleSelectionManager;
    /** Whether the drag events should be disabled. */
    isDisabled?: boolean;
}
interface DraggableCollectionState {
    /** A collection of items. */
    collection: Collection<Node<unknown>>;
    /** An interface for reading and updating multiple selection state. */
    selectionManager: MultipleSelectionManager;
    /** The key of the item that initiated a drag. */
    draggedKey: Key | null;
    /** The keys of the items that are currently being dragged. */
    draggingKeys: Set<Key>;
    /** Whether drag events are disabled. */
    isDisabled?: boolean;
    /** Returns whether the given key is currently being dragged. */
    isDragging(key: Key): boolean;
    /** Returns the keys of the items that will be dragged with the given key (e.g. selected items). */
    getKeysForDrag(key: Key): Set<Key>;
    /** Returns the items to drag for the given key. */
    getItems(key: Key): DragItem[];
    /** The ref of the element that will be rendered as the drag preview while dragging. */
    preview?: RefObject<DragPreviewRenderer | null>;
    /**
     * Function that returns the drop operations that are allowed for the dragged items. If not
     * provided, all drop operations are allowed.
     */
    getAllowedDropOperations?: () => DropOperation[];
    /** Begins a drag for the given key. This triggers the onDragStart event. */
    startDrag(key: Key, event: DragStartEvent): void;
    /** Triggers an onDragMove event. */
    moveDrag(event: DragMoveEvent): void;
    /** Ends the current drag, and emits an onDragEnd event. */
    endDrag(event: DraggableCollectionEndEvent): void;
}

interface DraggableItemProps {
    /** The key of the draggable item within the collection. */
    key: Key;
    /**
     * Whether the item has an explicit focusable drag affordance to initiate accessible drag and drop
     * mode. If true, the dragProps will omit these event handlers, and they will be applied to
     * dragButtonProps instead.
     */
    hasDragButton?: boolean;
    /**
     * Whether the item has a primary action (e.g. Enter key or long press) that would conflict with
     * initiating accessible drag and drop. If true, the Alt key must be held to start dragging with a
     * keyboard, and long press is disabled until selection mode is entered. This should be passed
     * from the associated collection item hook (e.g. useOption, useGridListItem, etc.).
     */
    hasAction?: boolean;
}
interface DraggableItemResult {
    /** Props for the draggable item. */
    dragProps: HTMLAttributes<HTMLElement>;
    /** Props for the explicit drag button affordance, if any. */
    dragButtonProps: AriaButtonProps;
}

interface DraggableCollectionOptions {
}

interface DragPreviewProps {
    /**
     * A render function which returns a preview element, or an object containing the element
     * and a custom offset. If an object is returned, the provided `x` and `y` values will be
     * used as the drag preview offset instead of the default calculation.
     */
    children: (items: DragItem[]) => JSX.Element | {
        element: JSX.Element;
        x: number;
        y: number;
    } | null;
}
declare const DragPreview: React.ForwardRefExoticComponent<DragPreviewProps & React.RefAttributes<DragPreviewRenderer | null>>;

interface ListDropTargetDelegateOptions {
    /**
     * 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?: Orientation;
    /**
     * The horizontal layout direction.
     *
     * @default 'ltr'
     */
    direction?: Direction;
}
declare class ListDropTargetDelegate implements DropTargetDelegate {
    private collection;
    private ref;
    private layout;
    private orientation;
    protected direction: Direction;
    constructor(collection: Iterable<Node<unknown>>, ref: RefObject<HTMLElement | null>, options?: ListDropTargetDelegateOptions);
    private getPrimaryStart;
    private getPrimaryEnd;
    private getSecondaryStart;
    private getSecondaryEnd;
    private getFlowStart;
    private getFlowEnd;
    private getFlowSize;
    getDropTargetFromPoint(x: number, y: number, isValidDropTarget: (target: DropTarget) => boolean): DropTarget;
}

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: DropIndicatorProps, state: DroppableCollectionState, ref: RefObject<HTMLElement | null>) => DropIndicatorAria;
    renderDropIndicator?: (target: DropTarget) => JSX.Element;
    dropTargetDelegate?: DropTargetDelegate;
    ListDropTargetDelegate: typeof ListDropTargetDelegate;
}
type DragAndDropHooks<T = object> = DragHooks<T> & DropHooks;

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';
    /**
     * The primary orientation of the items.
     *
     * @selector [data-orientation="vertical | horizontal"]
     */
    orientation: Orientation;
    /**
     * State of the listbox.
     */
    state: ListState<unknown>;
}
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?: Orientation;
}
/**
 * A listbox displays a list of options and allows a user to select one or more of them.
 */
declare const ListBox: <T>(props: ListBoxProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
interface ListBoxItemRenderProps extends ItemRenderProps {
}
interface ListBoxItemProps<T = object> extends Omit<RenderProps<ListBoxItemRenderProps>, 'render'>, PossibleLinkDOMRenderProps<'div', ListBoxItemRenderProps>, LinkDOMProps, HoverEvents, 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.
 */
declare const ListBoxItem: <T>(props: ListBoxItemProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;

interface ColorSwatchPickerRenderProps extends Omit<ListBoxRenderProps, 'isDropTarget'> {
}
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';
}
/**
 * A ColorSwatchPicker displays a list of color swatches and allows a user to select one of them.
 */
declare const ColorSwatchPicker: React.ForwardRefExoticComponent<ColorSwatchPickerProps & React.RefAttributes<HTMLDivElement>>;
interface ColorSwatchPickerItemRenderProps extends Omit<ListBoxItemRenderProps, 'selectionMode' | 'selectionBehavior'> {
    /** The color of the swatch. */
    color: Color;
}
interface ColorSwatchPickerItemProps extends RenderProps<ColorSwatchPickerItemRenderProps>, HoverEvents, 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;
}
declare const ColorSwatchPickerItem: React.ForwardRefExoticComponent<ColorSwatchPickerItemProps & React.RefAttributes<HTMLDivElement>>;

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;
}
interface ColorThumbProps extends HoverEvents, 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.
 */
declare const ColorThumb: React.ForwardRefExoticComponent<ColorThumbProps & React.RefAttributes<HTMLDivElement>>;

interface ColorWheelProps$1 extends Omit<ValueBase<string | Color>, 'onChange'> {
    /** Whether the ColorWheel is disabled. */
    isDisabled?: boolean;
    /** Handler that is called when the value changes, as the user drags. */
    onChange?: (value: Color) => void;
    /** Handler that is called when the user stops dragging. */
    onChangeEnd?: (value: Color) => void;
    /**
     * The default value (uncontrolled).
     *
     * @default 'hsl(0, 100%, 50%)'
     */
    defaultValue?: string | Color;
}
interface ColorWheelState {
    /** The current color value represented by the color wheel. */
    readonly value: Color;
    /** The default color value. */
    readonly defaultValue: Color;
    /** Sets the color value represented by the color wheel, and triggers `onChange`. */
    setValue(value: string | Color): void;
    /** The current value of the hue channel displayed by the color wheel. */
    readonly hue: number;
    /** Sets the hue channel of the current color value and triggers `onChange`. */
    setHue(value: number): void;
    /**
     * Sets the hue channel of the current color value based on the given coordinates and radius of
     * the color wheel, and triggers `onChange`.
     */
    setHueFromPoint(x: number, y: number, radius: number): void;
    /** Returns the coordinates of the thumb relative to the center point of the color wheel. */
    getThumbPosition(radius: number): {
        x: number;
        y: number;
    };
    /** Increments the hue by the given amount (defaults to 1). */
    increment(stepSize?: number): void;
    /** Decrements the hue by the given amount (defaults to 1). */
    decrement(stepSize?: number): void;
    /** Whether the color wheel is currently being dragged. */
    readonly isDragging: boolean;
    /** Sets whether the color wheel is being dragged. */
    setDragging(value: boolean): void;
    /** Returns the color that should be displayed in the color wheel instead of `value`. */
    getDisplayColor(): Color;
    /** The step value of the hue channel, used when incrementing and decrementing. */
    step: number;
    /** The page step value of the hue channel, used when incrementing and decrementing. */
    pageStep: number;
    /** Whether the color wheel is disabled. */
    readonly isDisabled: boolean;
}

interface AriaColorWheelProps extends ColorWheelProps$1, InputDOMProps, DOMProps$1, AriaLabelingProps {
}
interface AriaColorWheelOptions extends AriaColorWheelProps {
    /** The outer radius of the color wheel. */
    outerRadius: number;
    /** The inner radius of the color wheel. */
    innerRadius: number;
}

interface ColorWheelRenderProps {
    /**
     * Whether the color wheel is disabled.
     *
     * @selector [data-disabled]
     */
    isDisabled: boolean;
    /**
     * State of the color wheel.
     */
    state: ColorWheelState;
}
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>;
}
/**
 * A color wheel allows users to adjust the hue of an HSL or HSB color value on a circular track.
 */
declare const ColorWheel: React.ForwardRefExoticComponent<ColorWheelProps & React.RefAttributes<HTMLDivElement>>;
interface ColorWheelTrackRenderProps extends ColorWheelRenderProps {
}
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>;
}
/**
 * A color wheel track renders a circular gradient track.
 */
declare const ColorWheelTrack: React.ForwardRefExoticComponent<ColorWheelTrackProps & React.RefAttributes<HTMLDivElement>>;

interface OverlayTriggerProps {
    /** Whether the overlay is open by default (controlled). */
    isOpen?: boolean;
    /** Whether the overlay is open by default (uncontrolled). */
    defaultOpen?: boolean;
    /** Handler that is called when the overlay's open state changes. */
    onOpenChange?: (isOpen: boolean) => void;
}
interface Point {
    x: number;
    y: number;
}
interface OverlayTriggerState {
    /** Whether the overlay is currently open. */
    readonly isOpen: boolean;
    /** Sets whether the overlay is open. */
    setOpen(isOpen: boolean): void;
    /** Opens the overlay. */
    open(): void;
    /** Closes the overlay. */
    close(): void;
    /** Toggles the overlay's visibility. */
    toggle(): void;
    /** The cursor position when the overlay was triggered, relative to the window viewport. */
    readonly point: Point | null;
    /** Sets the cursor position relative to the window viewport. */
    setPoint(point: Point): void;
}

type MenuTriggerAction = 'focus' | 'input' | 'manual';
type SelectionMode$3 = 'single' | 'multiple';
type ValueType$1<M extends SelectionMode$3> = M extends 'single' ? Key | null : readonly Key[];
type ChangeValueType$1<M extends SelectionMode$3> = M extends 'single' ? Key | null : Key[];
type ValidationType$1<M extends SelectionMode$3> = M extends 'single' ? Key | null : Key[];
interface ComboBoxValidationValue<M extends SelectionMode$3 = 'single'> {
    /**
     * The selected key in the ComboBox.
     *
     * @deprecated
     */
    selectedKey: Key | null;
    /** The keys of the currently selected items. */
    value: ValidationType$1<M>;
    /** The value of the ComboBox input. */
    inputValue: string;
}
interface ComboBoxProps$1<T, M extends SelectionMode$3 = 'single'> extends CollectionBase<T>, InputBase, ValueBase<ValueType$1<M>, ChangeValueType$1<M>>, TextInputBase, Validation<ComboBoxValidationValue<M>>, FocusableProps<HTMLInputElement>, LabelableProps, HelpTextProps {
    /** The list of ComboBox items (uncontrolled). */
    defaultItems?: Iterable<T>;
    /** The list of ComboBox items (controlled). */
    items?: Iterable<T>;
    /**
     * Method that is called when the open state of the menu changes. Returns the new open state and
     * the action that caused the opening of the menu.
     */
    onOpenChange?: (isOpen: boolean, menuTrigger?: MenuTriggerAction) => void;
    /**
     * Whether single or multiple selection is enabled.
     *
     * @default 'single'
     */
    selectionMode?: M;
    /**
     * The currently selected key in the collection (controlled).
     *
     * @deprecated
     */
    selectedKey?: Key | null;
    /**
     * The initial selected key in the collection (uncontrolled).
     *
     * @deprecated
     */
    defaultSelectedKey?: Key | null;
    /**
     * Handler that is called when the selection changes.
     *
     * @deprecated
     */
    onSelectionChange?: (key: Key | null) => void;
    /** The value of the ComboBox input (controlled). */
    inputValue?: string;
    /** The default value of the ComboBox input (uncontrolled). */
    defaultInputValue?: string;
    /** Handler that is called when the ComboBox input value changes. */
    onInputChange?: (value: string) => void;
    /** Whether the ComboBox allows a non-item matching input value to be set. */
    allowsCustomValue?: boolean;
    /**
     * The interaction required to display the ComboBox menu.
     *
     * @default 'input'
     */
    menuTrigger?: MenuTriggerAction;
}

interface AriaComboBoxProps<T, M extends SelectionMode$3 = 'single'> extends ComboBoxProps$1<T, M>, DOMProps$1, InputDOMProps, AriaLabelingProps {
    /** Whether keyboard navigation is circular. */
    shouldFocusWrap?: boolean;
}

type SelectionMode$2 = 'single' | 'multiple';
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;
    /**
     * Whether the combobox is read only.
     *
     * @selector [data-readonly]
     */
    isReadOnly: boolean;
}
interface ComboBoxProps<T, M extends SelectionMode$2 = '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 an option should be included in the combo box list.
     * By default, a language-sensitive "contains" filter from `useFilter` is used.
     */
    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;
}
/**
 * A combo box combines a text input with a listbox, allowing users to filter a list of options to
 * items matching a query.
 */
declare const ComboBox: <T, M extends SelectionMode$2 = "single">(props: ComboBoxProps<T, M> & React.RefAttributes<HTMLDivElement>) => ReactElement | null;

type DateValue = CalendarDate | CalendarDateTime | ZonedDateTime;
type DateRange = RangeValue<DateValue>;
type MappedDateValue<T> = T extends ZonedDateTime ? ZonedDateTime : T extends CalendarDateTime ? CalendarDateTime : T extends CalendarDate ? CalendarDate : never;
type TimeValue = Time | CalendarDateTime | ZonedDateTime;
type MappedTimeValue<T> = T extends ZonedDateTime ? ZonedDateTime : T extends CalendarDateTime ? CalendarDateTime : T extends Time ? Time : never;
type Granularity = 'day' | 'hour' | 'minute' | 'second';
interface DateFieldBase<T extends DateValue> extends InputBase, Validation<MappedDateValue<T>>, FocusableProps, LabelableProps, HelpTextProps {
    /** The minimum allowed date that a user may select. */
    minValue?: DateValue | null;
    /** The maximum allowed date that a user may select. */
    maxValue?: DateValue | null;
    /**
     * Callback that is called for each date of the calendar. If it returns true, then the date is
     * unavailable.
     */
    isDateUnavailable?: (date: DateValue) => boolean;
    /**
     * A placeholder date that influences the format of the placeholder shown when no value is
     * selected. Defaults to today's date at midnight.
     */
    placeholderValue?: T | null;
    /**
     * Whether to display the time in 12 or 24 hour format. By default, this is determined by the
     * user's locale.
     */
    hourCycle?: 12 | 24;
    /**
     * Determines the smallest unit that is displayed in the date picker. By default, this is `"day"`
     * for dates, and `"minute"` for times.
     */
    granularity?: Granularity;
    /**
     * Whether to hide the time zone abbreviation.
     *
     * @default false
     */
    hideTimeZone?: boolean;
    /**
     * Whether to always show leading zeros in the month, day, and hour fields.
     * By default, this is determined by the user's locale.
     */
    shouldForceLeadingZeros?: boolean;
}
interface DateFieldProps$1<T extends DateValue> extends DateFieldBase<T>, ValueBase<T | null, MappedDateValue<T> | null> {
}
interface DatePickerBase<T extends DateValue> extends DateFieldBase<T>, OverlayTriggerProps {
    /**
     * Controls the behavior of paging. Pagination either works by advancing the visible page by
     * visibleDuration (default) or one unit of visibleDuration.
     *
     * @default visible
     */
    pageBehavior?: PageBehavior;
    /**
     * The day that starts the week.
     */
    firstDayOfWeek?: 'sun' | 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat';
}
interface DatePickerProps$1<T extends DateValue> extends DatePickerBase<T>, ValueBase<T | null, MappedDateValue<T> | null> {
}
interface DateRangePickerProps$1<T extends DateValue> extends Omit<DatePickerBase<T>, 'validate' | 'isDateUnavailable'>, Validation<RangeValue<MappedDateValue<T>>>, ValueBase<RangeValue<T> | null, RangeValue<MappedDateValue<T>> | null> {
    /**
     * When combined with `isDateUnavailable`, determines whether non-contiguous ranges,
     * i.e. ranges containing unavailable dates, may be selected.
     */
    allowsNonContiguousRanges?: boolean;
    /**
     * Callback that is called for each date of the calendar. If it returns true, then the date is
     * unavailable.
     */
    isDateUnavailable?: (date: DateValue, anchorDate: CalendarDate | null) => boolean;
    /**
     * The name of the start date input element, used when submitting an HTML form. See
     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefname).
     */
    startName?: string;
    /**
     * The name of the end date input element, used when submitting an HTML form. See
     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefname).
     */
    endName?: string;
}
interface TimePickerProps<T extends TimeValue> extends InputBase, Validation<MappedTimeValue<T>>, FocusableProps, LabelableProps, HelpTextProps, ValueBase<T | null, MappedTimeValue<T> | null> {
    /**
     * Whether to display the time in 12 or 24 hour format. By default, this is determined by the
     * user's locale.
     */
    hourCycle?: 12 | 24;
    /**
     * Determines the smallest unit that is displayed in the time picker.
     *
     * @default 'minute'
     */
    granularity?: 'hour' | 'minute' | 'second';
    /** Whether to hide the time zone abbreviation. */
    hideTimeZone?: boolean;
    /**
     * Whether to always show leading zeros in the hour field.
     * By default, this is determined by the user's locale.
     */
    shouldForceLeadingZeros?: boolean;
    /**
     * A placeholder time that influences the format of the placeholder shown when no value is
     * selected. Defaults to 12:00 AM or 00:00 depending on the hour cycle.
     */
    placeholderValue?: T;
    /** The minimum allowed time that a user may select. */
    minValue?: TimeValue | null;
    /** The maximum allowed time that a user may select. */
    maxValue?: TimeValue | null;
}

type FieldOptions = Pick<Intl.DateTimeFormatOptions, 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second'>;
interface FormatterOptions {
    timeZone?: string;
    hideTimeZone?: boolean;
    granularity?: DatePickerProps$1<any>['granularity'];
    maxGranularity?: 'year' | 'month' | DatePickerProps$1<any>['granularity'];
    hourCycle?: 12 | 24;
    showEra?: boolean;
    shouldForceLeadingZeros?: boolean;
}

type DateSegmentType = 'era' | 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'dayPeriod' | 'literal' | 'timeZoneName';
interface DateSegment$1 {
    /** The type of segment. */
    type: DateSegmentType;
    /** The formatted text for the segment. */
    text: string;
    /** The numeric value for the segment, if applicable. */
    value?: number | null;
    /** The minimum numeric value for the segment, if applicable. */
    minValue?: number;
    /** The maximum numeric value for the segment, if applicable. */
    maxValue?: number;
    /** Whether the value is a placeholder. */
    isPlaceholder: boolean;
    /** A placeholder string for the segment. */
    placeholder: string;
    /** Whether the segment is editable. */
    isEditable: boolean;
}
interface DateFieldState extends FormValidationState {
    /** The current field value. */
    value: DateValue | null;
    /** The default field value. */
    defaultValue: DateValue | null;
    /** The current value, converted to a native JavaScript `Date` object. */
    dateValue: Date;
    /** The calendar system currently in use. */
    calendar: Calendar$1;
    /** Sets the field's value. */
    setValue(value: DateValue | null): void;
    /** A list of segments for the current value. */
    segments: DateSegment$1[];
    /** A date formatter configured for the current locale and format. */
    dateFormatter: DateFormatter;
    /**
     * The current validation state of the date field, based on the `validationState`, `minValue`, and
     * `maxValue` props.
     *
     * @deprecated Use `isInvalid` instead.
     */
    validationState: ValidationState | null;
    /** Whether the date field is invalid, based on the `isInvalid`, `minValue`, and `maxValue` props. */
    isInvalid: boolean;
    /** The granularity for the field, based on the `granularity` prop and current value. */
    granularity: Granularity;
    /** The maximum date or time unit that is displayed in the field. */
    maxGranularity: 'year' | 'month' | Granularity;
    /** Whether the field is disabled. */
    isDisabled: boolean;
    /** Whether the field is read only. */
    isReadOnly: boolean;
    /** Whether the field is required. */
    isRequired: boolean;
    /**
     * Increments the given segment. Upon reaching the minimum or maximum value, the value wraps
     * around to the opposite limit.
     */
    increment(type: DateSegmentType): void;
    /**
     * Decrements the given segment. Upon reaching the minimum or maximum value, the value wraps
     * around to the opposite limit.
     */
    decrement(type: DateSegmentType): void;
    /**
     * Increments the given segment by a larger amount, rounding it to the nearest increment.
     * The amount to increment by depends on the field, for example 15 minutes, 7 days, and 5 years.
     * Upon reaching the minimum or maximum value, the value wraps around to the opposite limit.
     */
    incrementPage(type: DateSegmentType): void;
    /**
     * Decrements the given segment by a larger amount, rounding it to the nearest increment.
     * The amount to decrement by depends on the field, for example 15 minutes, 7 days, and 5 years.
     * Upon reaching the minimum or maximum value, the value wraps around to the opposite limit.
     */
    decrementPage(type: DateSegmentType): void;
    /** Increments the given segment to its maxiumum value. */
    incrementToMax(type: DateSegmentType): void;
    /** Decrements the given segment to its minimum value. */
    decrementToMin(type: DateSegmentType): void;
    /** Sets the value of the given segment. */
    setSegment(type: 'era', value: string): void;
    setSegment(type: DateSegmentType, value: number): void;
    /** Updates the remaining unfilled segments with the placeholder value. */
    confirmPlaceholder(): void;
    /** Clears the value of the given segment, reverting it to the placeholder. */
    clearSegment(type: DateSegmentType): void;
    /** Formats the current date value using the given options. */
    formatValue(fieldOptions: FieldOptions): string;
    /** Gets a formatter based on state's props. */
    getDateFormatter(locale: string, formatOptions: FormatterOptions): DateFormatter;
}

interface AriaDateFieldProps<T extends DateValue> extends DateFieldProps$1<T>, AriaLabelingProps, DOMProps$1, InputDOMProps {
    /**
     * Describes the type of autocomplete functionality the input should provide if any. See
     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefautocomplete).
     */
    autoComplete?: string;
}
interface AriaTimeFieldProps<T extends TimeValue> extends TimePickerProps<T>, AriaLabelingProps, DOMProps$1, InputDOMProps {
}

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;
}
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>;
}
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>;
}
/**
 * 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.
 */
declare 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.
 */
declare const TimeField: <T extends TimeValue>(props: TimeFieldProps<T> & React.RefAttributes<HTMLDivElement>) => ReactElement | null;
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;
}
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: DateSegment$1) => ReactElement;
}
/**
 * A date input groups the editable date segments within a date field.
 */
declare const DateInput: (props: DateInputProps & React.RefAttributes<HTMLDivElement>) => ReactElement | null;
interface DateSegmentRenderProps extends Omit<DateSegment$1, '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;
}
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: DateSegment$1;
}
/**
 * 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.
 */
declare const DateSegment: (props: DateSegmentProps & React.RefAttributes<HTMLSpanElement>) => ReactElement | null;

interface AriaDialogProps extends DOMProps$1, AriaLabelingProps {
    /**
     * The accessibility role for the dialog.
     *
     * @default 'dialog'
     */
    role?: 'dialog' | 'alertdialog';
}

interface DatePickerStateOptions<T extends DateValue> extends DatePickerProps$1<T> {
    /**
     * Determines whether the date picker popover should close automatically when a date is selected.
     *
     * @default true
     */
    shouldCloseOnSelect?: boolean | (() => boolean);
}
interface DatePickerState extends OverlayTriggerState, FormValidationState {
    /** The currently selected date. */
    value: DateValue | null;
    /** The default date. */
    defaultValue: DateValue | null;
    /** Sets the selected date. */
    setValue(value: DateValue | null): void;
    /**
     * The date portion of the value. This may be set prior to `value` if the user has
     * selected a date but has not yet selected a time.
     */
    dateValue: DateValue | null;
    /** Sets the date portion of the value. */
    setDateValue(value: DateValue): void;
    /**
     * The time portion of the value. This may be set prior to `value` if the user has
     * selected a time but has not yet selected a date.
     */
    timeValue: TimeValue | null;
    /** Sets the time portion of the value. */
    setTimeValue(value: TimeValue): void;
    /** The granularity for the field, based on the `granularity` prop and current value. */
    granularity: Granularity;
    /**
     * Whether the date picker supports selecting a time, according to the `granularity` prop and
     * current value.
     */
    hasTime: boolean;
    /** Whether the calendar popover is currently open. */
    isOpen: boolean;
    /** Sets whether the calendar popover is open. */
    setOpen(isOpen: boolean): void;
    /**
     * The current validation state of the date picker, based on the `validationState`, `minValue`,
     * and `maxValue` props.
     *
     * @deprecated Use `isInvalid` instead.
     */
    validationState: ValidationState | null;
    /** Whether the date picker is invalid, based on the `isInvalid`, `minValue`, and `maxValue` props. */
    isInvalid: boolean;
    /** Formats the selected value using the given options. */
    formatValue(locale: string, fieldOptions: FieldOptions): string;
    /** Gets a formatter based on state's props. */
    getDateFormatter(locale: string, formatOptions: FormatterOptions): DateFormatter;
}

interface AriaDatePickerProps<T extends DateValue> extends DatePickerProps$1<T>, AriaLabelingProps, InputDOMProps, DOMProps$1, InputDOMProps {
    /**
     * Describes the type of autocomplete functionality the input should provide if any. See
     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefautocomplete).
     */
    autoComplete?: string;
}

interface DateRangePickerStateOptions<T extends DateValue = DateValue> extends DateRangePickerProps$1<T> {
    /**
     * Determines whether the date picker popover should close automatically when a date is selected.
     *
     * @default true
     */
    shouldCloseOnSelect?: boolean | (() => boolean);
}
type TimeRange = RangeValue<TimeValue>;
interface DateRangePickerState extends OverlayTriggerState, FormValidationState {
    /** The currently selected date range. */
    value: RangeValue<DateValue | null>;
    /** The default selected date range. */
    defaultValue: DateRange | null;
    /** Sets the selected date range. */
    setValue(value: DateRange | null): void;
    /**
     * The date portion of the selected range. This may be set prior to `value` if the user has
     * selected a date range but has not yet selected a time range.
     */
    dateRange: RangeValue<DateValue | null> | null;
    /** Sets the date portion of the selected range. */
    setDateRange(value: DateRange): void;
    /**
     * The time portion of the selected range. This may be set prior to `value` if the user has
     * selected a time range but has not yet selected a date range.
     */
    timeRange: RangeValue<TimeValue | null> | null;
    /** Sets the time portion of the selected range. */
    setTimeRange(value: TimeRange): void;
    /** Sets the date portion of either the start or end of the selected range. */
    setDate(part: 'start' | 'end', value: DateValue | null): void;
    /** Sets the time portion of either the start or end of the selected range. */
    setTime(part: 'start' | 'end', value: TimeValue | null): void;
    /** Sets the date and time of either the start or end of the selected range. */
    setDateTime(part: 'start' | 'end', value: DateValue | null): void;
    /** The granularity for the field, based on the `granularity` prop and current value. */
    granularity: Granularity;
    /**
     * Whether the date range picker supports selecting times, according to the `granularity` prop and
     * current value.
     */
    hasTime: boolean;
    /** Whether the calendar popover is currently open. */
    isOpen: boolean;
    /** Sets whether the calendar popover is open. */
    setOpen(isOpen: boolean): void;
    /**
     * The current validation state of the date range picker, based on the `validationState`,
     * `minValue`, and `maxValue` props.
     *
     * @deprecated Use `isInvalid` instead.
     */
    validationState: ValidationState | null;
    /**
     * Whether the date range picker is invalid, based on the `isInvalid`, `minValue`, and `maxValue`
     * props.
     */
    isInvalid: boolean;
    /** Formats the selected range using the given options. */
    formatValue(locale: string, fieldOptions: FieldOptions): {
        start: string;
        end: string;
    } | null;
    /** Gets a formatter based on state's props. */
    getDateFormatter(locale: string, formatOptions: FormatterOptions): DateFormatter;
}

interface AriaDateRangePickerProps<T extends DateValue> extends DateRangePickerProps$1<T>, AriaLabelingProps, Omit<InputDOMProps, 'name'>, DOMProps$1 {
}

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;
}
interface DateRangePickerRenderProps extends Omit<DatePickerRenderProps, 'state'> {
    /**
     * State of the date range picker.
     */
    state: DateRangePickerState;
}
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>;
}
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>;
}
/**
 * A date picker combines a DateField and a Calendar popover to allow users to enter or select a
 * date and time value.
 */
declare 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.
 */
declare const DateRangePicker: <T extends DateValue>(props: DateRangePickerProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;

interface DialogRenderProps {
    close: () => void;
}
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);
}
/**
 * A dialog is an overlay shown above other content in an application.
 */
declare const Dialog: (props: DialogProps & React.RefAttributes<HTMLElement>) => React.ReactElement | null;

interface DropOptions {
    /** A ref for the droppable element. */
    ref: RefObject<FocusableElement | null>;
    /**
     * A function returning the drop operation to be performed when items matching the given types are
     * dropped on the drop target.
     */
    getDropOperation?: (types: DragTypes, allowedOperations: DropOperation[]) => DropOperation;
    /** A function that returns the drop operation for a specific point within the target. */
    getDropOperationForPoint?: (types: DragTypes, allowedOperations: DropOperation[], x: number, y: number) => DropOperation;
    /** Handler that is called when a valid drag enters the drop target. */
    onDropEnter?: (e: DropEnterEvent) => void;
    /** Handler that is called when a valid drag is moved within the drop target. */
    onDropMove?: (e: DropMoveEvent) => void;
    /**
     * Handler that is called after a valid drag is held over the drop target for a period of time.
     * This typically opens the item so that the user can drop within it.
     */
    onDropActivate?: (e: DropActivateEvent) => void;
    /** Handler that is called when a valid drag exits the drop target. */
    onDropExit?: (e: DropExitEvent) => void;
    /** Handler that is called when a valid drag is dropped on the drop target. */
    onDrop?: (e: DropEvent) => void;
    /**
     * Whether the item has an explicit focusable drop affordance to initiate accessible drag and drop
     * mode. If true, the dropProps will omit these event handlers, and they will be applied to
     * dropButtonProps instead.
     */
    hasDropButton?: boolean;
    /**
     * Whether the drop target is disabled. If true, the drop target will not accept any drops.
     */
    isDisabled?: boolean;
}

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;
}
interface DropZoneProps extends Omit<DropOptions, 'getDropOperationForPoint' | 'ref' | 'hasDropButton'>, HoverEvents, 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>;
}
/**
 * A drop zone is an area into which one or multiple objects can be dragged and dropped.
 */
declare const DropZone: React.ForwardRefExoticComponent<DropZoneProps & React.RefAttributes<HTMLDivElement>>;

interface FieldErrorRenderProps extends ValidationResult {
}
interface FieldErrorProps extends RenderProps<FieldErrorRenderProps>, DOMProps$1, 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>;
    /**
     * The HTML element type to render. Defaults to `'span'`.
     * Set to `'div'` when using block-level children (e.g. `<ul>`) to avoid invalid HTML.
     *
     * @default 'span'
     */
    elementType?: string;
}
/**
 * A FieldError displays validation errors for a form field.
 */
declare const FieldError: React.ForwardRefExoticComponent<FieldErrorProps & React.RefAttributes<HTMLElement>>;

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.
 */
declare const FileTrigger: React.ForwardRefExoticComponent<FileTriggerProps & React.RefAttributes<HTMLInputElement>>;

interface GridListProps<T> extends CollectionBase<T>, MultipleSelection {
    /** Whether to auto focus the gridlist or an option. */
    autoFocus?: boolean | FocusStrategy;
    /**
     * Handler that is called when a user performs an action on an item. The exact user event depends
     * on the collection's `selectionBehavior` prop and the interaction modality.
     */
    onAction?: (key: Key) => void;
    /**
     * Whether `disabledKeys` applies to all interactions, or only selection.
     *
     * @default 'all'
     */
    disabledBehavior?: DisabledBehavior;
    /** Whether selection should occur on press up instead of press down. */
    shouldSelectOnPressUp?: boolean;
}
interface AriaGridListProps<T> extends GridListProps<T>, DOMProps$1, AriaLabelingProps {
    /**
     * Whether keyboard navigation to focusable elements within grid list items is
     * via the left/right arrow keys or the tab key.
     *
     * @default 'arrow'
     */
    keyboardNavigationBehavior?: 'arrow' | 'tab';
    /**
     * Whether pressing the escape key should clear selection in the grid list or not.
     *
     * Most experiences should not modify this option as it eliminates a keyboard user's ability to
     * easily clear selection. Only use if the escape key is being handled externally or should not
     * trigger selection clearing contextually.
     *
     * @default 'clearSelection'
     */
    escapeKeyBehavior?: 'clearSelection' | 'none';
}

interface HoverProps extends HoverEvents {
    /** Whether the hover events should be disabled. */
    isDisabled?: boolean;
}

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;
}
interface GroupProps extends AriaLabelingProps, Omit<HTMLAttributes<HTMLElement>, 'children' | 'className' | 'style' | 'render' | 'role' | 'slot'>, DOMProps$1, 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';
}
/**
 * A group represents a set of related UI controls, and supports interactive states for styling.
 */
declare const Group: (props: GroupProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;

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;
}
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;
}
/**
 * An input allows a user to input text.
 */
declare const Input: (props: InputProps & React.RefAttributes<HTMLInputElement>) => React.ReactElement | null;

interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement>, DOMRenderProps<'label', undefined> {
    elementType?: string;
}
declare const Label: (props: LabelProps & React.RefAttributes<HTMLLabelElement>) => React.ReactElement | null;

type Placement = 'bottom' | 'bottom left' | 'bottom right' | 'bottom start' | 'bottom end' | 'top' | 'top left' | 'top right' | 'top start' | 'top end' | 'left' | 'left top' | 'left bottom' | 'start' | 'start top' | 'start bottom' | 'right' | 'right top' | 'right bottom' | 'end' | 'end top' | 'end bottom';
type Axis = 'top' | 'bottom' | 'left' | 'right';
type PlacementAxis = Axis | 'center';
interface PositionProps {
    /**
     * The placement of the element with respect to its anchor element.
     *
     * @default 'bottom'
     */
    placement?: Placement;
    /**
     * The placement padding that should be applied between the element and its
     * surrounding container.
     *
     * @default 12
     */
    containerPadding?: number;
    /**
     * The additional offset applied along the main axis between the element and its
     * anchor element.
     *
     * @default 0
     */
    offset?: number;
    /**
     * The additional offset applied along the cross axis between the element and its
     * anchor element.
     *
     * @default 0
     */
    crossOffset?: number;
    /**
     * Whether the element should flip its orientation (e.g. top to bottom or left to right) when
     * there is insufficient room for it to render completely.
     *
     * @default true
     */
    shouldFlip?: boolean;
    /** Whether the element is rendered. */
    isOpen?: boolean;
}
interface AriaPositionProps extends PositionProps {
    /**
     * Cross size of the overlay arrow in pixels.
     *
     * @default 0
     */
    arrowSize?: number;
    /**
     * Element that that serves as the positioning boundary.
     *
     * @default document.body
     */
    boundaryElement?: Element;
    /**
     * The ref for the element which the overlay positions itself with respect to.
     */
    targetRef: RefObject<Element | null>;
    /**
     * The ref for the overlay element.
     */
    overlayRef: RefObject<Element | null>;
    /**
     * The ref for the arrow element.
     */
    arrowRef?: RefObject<Element | null>;
    /**
     * A ref for the scrollable region within the overlay.
     *
     * @default overlayRef
     */
    scrollRef?: RefObject<Element | null>;
    /**
     * Whether the overlay should update its position automatically.
     *
     * @default true
     */
    shouldUpdatePosition?: boolean;
    /** Handler that is called when the overlay should close. */
    onClose?: (() => void) | null;
    /**
     * The maxHeight specified for the overlay element.
     * By default, it will take all space up to the current viewport height.
     */
    maxHeight?: number;
    /**
     * The minimum distance the arrow's edge should be from the edge of the overlay element.
     *
     * @default 0
     */
    arrowBoundaryOffset?: number;
    /**
     * Overrides the target element's bounding rectangle. Useful for positioning relative to
     * a specific point such as the mouse cursor (e.g. context menus) or text selection.
     *
     * @default target.getBoundingClientRect()
     * @param target - The target element.
     */
    getTargetRect?: (target: Element) => DOMRect | null | undefined;
}

interface FocusWithinProps {
    /** Whether the focus within events should be disabled. */
    isDisabled?: boolean;
    /** Handler that is called when the target element or a descendant receives focus. */
    onFocusWithin?: (e: FocusEvent) => void;
    /** Handler that is called when the target element and all descendants lose focus. */
    onBlurWithin?: (e: FocusEvent) => void;
    /** Handler that is called when the the focus within state changes. */
    onFocusWithinChange?: (isFocusWithin: boolean) => void;
}

interface AriaPopoverProps extends Omit<AriaPositionProps, 'isOpen' | 'onClose' | 'targetRef' | 'overlayRef'>, Omit<FocusWithinProps, 'isDisabled'> {
    /**
     * The ref for the element which the popover positions itself with respect to.
     */
    triggerRef: RefObject<Element | null>;
    /**
     * The ref for the popover element.
     */
    popoverRef: RefObject<Element | null>;
    /** A ref for the popover arrow element. */
    arrowRef?: RefObject<Element | null>;
    /**
     * An optional ref for a group of popovers, e.g. submenus.
     * When provided, this element is used to detect outside interactions
     * and hiding elements from assistive technologies instead of the popoverRef.
     */
    groupRef?: RefObject<Element | null>;
    /**
     * Whether the popover is non-modal, i.e. elements outside the popover may be
     * interacted with by assistive technologies.
     *
     * Most popovers should not use this option as it may negatively impact the screen
     * reader experience. Only use with components such as combobox, which are designed
     * to handle this situation carefully.
     */
    isNonModal?: boolean;
    /**
     * Whether pressing the escape key to close the popover should be disabled.
     *
     * Most popovers should not use this option. When set to true, an alternative
     * way to close the popover with a keyboard must be provided.
     *
     * @default false
     */
    isKeyboardDismissDisabled?: boolean;
    /**
     * When user interacts with the argument element outside of the popover ref,
     * return true if onClose should be called. This gives you a chance to filter
     * out interaction with elements that should not dismiss the popover.
     * By default, onClose will always be called on interaction outside the popover ref.
     */
    shouldCloseOnInteractOutside?: (element: Element) => boolean;
}

interface ProgressBarBaseProps {
    /**
     * The current value (controlled).
     *
     * @default 0
     */
    value?: number;
    /**
     * The smallest value allowed for the input.
     *
     * @default 0
     */
    minValue?: number;
    /**
     * The largest value allowed for the input.
     *
     * @default 100
     */
    maxValue?: number;
    /** The content to display as the label. */
    label?: ReactNode;
    /**
     * The display format of the value label.
     *
     * @default { style: 'percent' }
     */
    formatOptions?: Intl.NumberFormatOptions;
    /** The content to display as the value's label (e.g. 1 of 4). */
    valueLabel?: ReactNode;
}
interface AriaProgressBarBaseProps extends ProgressBarBaseProps, DOMProps$1, AriaLabelingProps {
}

interface AriaMeterProps extends AriaProgressBarBaseProps {
}

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>;
}
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;
}
/**
 * A meter represents a quantity within a known range, or a fractional value.
 */
declare const Meter: (props: MeterProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;

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 read only.
     *
     * @selector [data-readonly]
     */
    isReadOnly: boolean;
    /**
     * Whether the number field is required.
     *
     * @selector [data-required]
     */
    isRequired: boolean;
    /**
     * State of the number field.
     */
    state: NumberFieldState;
}
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>;
}
/**
 * A number field allows a user to enter a number, and increment or decrement the value using
 * stepper buttons.
 */
declare const NumberField: (props: NumberFieldProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;

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;
    /**
     * Whether the popover should appear and disappear without an entry or exit animation. This is
     * used by components such as PreviewTrigger to skip animations when quickly swapping between
     * overlays.
     */
    shouldSkipAnimation?: boolean;
    /**
     * The container element in which the overlay portal will be placed. This may have unknown
     * behavior depending on where it is portalled to.
     *
     * @deprecated - Use a parent UNSAFE_PortalProvider to set your portal container instead.
     * @default document.body
     */
    UNSTABLE_portalContainer?: Element;
    /**
     * The additional offset applied along the main axis between the element and its
     * anchor element.
     *
     * @default 8
     */
    offset?: number;
}
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;
}
/**
 * A popover is an overlay element positioned relative to a trigger.
 */
declare const Popover: (props: PopoverProps & React.RefAttributes<HTMLElement>) => React.ReactElement | null;

interface TextFieldProps<T = HTMLInputElement> extends InputBase, Validation<string>, HelpTextProps, FocusableProps<T>, TextInputBase, ValueBase<string>, LabelableProps {
}
interface SearchFieldProps$1 extends TextFieldProps {
    /** Handler that is called when the SearchField is submitted. */
    onSubmit?: (value: string) => void;
    /** Handler that is called when the clear button is pressed. */
    onClear?: () => void;
}
interface SearchFieldState {
    /** The current value of the search field. */
    readonly value: string;
    /** Sets the value of the search field. */
    setValue(value: string): void;
}

interface AriaSearchFieldProps extends SearchFieldProps$1, Omit<AriaTextFieldProps, 'type'> {
    /**
     * An enumerated attribute that defines what action label or icon to preset for the enter key on
     * virtual keyboards. See
     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/enterkeyhint).
     */
    enterKeyHint?: 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
    /**
     * The type of input to render. See
     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdeftype).
     *
     * @default 'search'
     */
    type?: 'text' | 'search' | 'url' | 'tel' | 'email' | 'password' | (string & {});
}

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;
}
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>;
}
/**
 * A search field allows a user to enter and clear a search query.
 */
declare const SearchField: (props: SearchFieldProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;

type SelectionMode$1 = 'single' | 'multiple';
type ValueType<M extends SelectionMode$1> = M extends 'single' ? Key | null : readonly Key[];
type ChangeValueType<M extends SelectionMode$1> = M extends 'single' ? Key | null : Key[];
type ValidationType<M extends SelectionMode$1> = M extends 'single' ? Key : Key[];
interface SelectProps$1<T, M extends SelectionMode$1 = 'single'> extends CollectionBase<T>, Omit<InputBase, 'isReadOnly'>, ValueBase<ValueType<M>, ChangeValueType<M>>, Validation<ValidationType<M>>, HelpTextProps, LabelableProps, TextInputBase, FocusableProps {
    /**
     * Whether single or multiple selection is enabled.
     *
     * @default 'single'
     */
    selectionMode?: M;
    /**
     * The currently selected key in the collection (controlled).
     *
     * @deprecated
     */
    selectedKey?: Key | null;
    /**
     * The initial selected key in the collection (uncontrolled).
     *
     * @deprecated
     */
    defaultSelectedKey?: Key | null;
    /**
     * Handler that is called when the selection changes.
     *
     * @deprecated
     */
    onSelectionChange?: (key: Key | null) => void;
    /** Sets the open state of the menu. */
    isOpen?: boolean;
    /** Sets the default open state of the menu. */
    defaultOpen?: boolean;
    /** Method that is called when the open state of the menu changes. */
    onOpenChange?: (isOpen: boolean) => void;
    /**
     * Whether the Select should close when an item is selected. Defaults to true if selectionMode is
     * single, false otherwise.
     */
    shouldCloseOnSelect?: boolean;
    /** Whether the select should be allowed to be open when the collection is empty. */
    allowsEmptyCollection?: boolean;
}
interface SelectState<T, M extends SelectionMode$1 = 'single'> extends ListState<T>, OverlayTriggerState, FormValidationState {
    /**
     * The key for the first selected item.
     *
     * @deprecated
     */
    readonly selectedKey: Key | null;
    /**
     * The default selected key.
     *
     * @deprecated
     */
    readonly defaultSelectedKey: Key | null;
    /**
     * Sets the selected key.
     *
     * @deprecated
     */
    setSelectedKey(key: Key | null): void;
    /** The current select value. */
    readonly value: ValueType<M>;
    /** The default select value. */
    readonly defaultValue: ValueType<M>;
    /** Sets the select value. */
    setValue(value: Key | readonly Key[] | null): void;
    /**
     * The value of the first selected item.
     *
     * @deprecated
     */
    readonly selectedItem: Node<T> | null;
    /** The value of the selected items. */
    readonly selectedItems: Node<T>[];
    /** Whether the select is currently focused. */
    readonly isFocused: boolean;
    /** Sets whether the select is focused. */
    setFocused(isFocused: boolean): void;
    /** Controls which item will be auto focused when the menu opens. */
    readonly focusStrategy: FocusStrategy | null;
    /** Opens the menu. */
    open(focusStrategy?: FocusStrategy | null): void;
    /** Toggles the menu. */
    toggle(focusStrategy?: FocusStrategy | null): void;
}

interface AriaSelectProps<T, M extends SelectionMode$1 = 'single'> extends SelectProps$1<T, M>, DOMProps$1, AriaLabelingProps, FocusableDOMProps {
    /**
     * Describes the type of autocomplete functionality the input should provide if any. See
     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefautocomplete).
     */
    autoComplete?: string;
    /**
     * The name of the input, used when submitting an HTML form.
     */
    name?: string;
    /**
     * The `<form>` element to associate the input with.
     * The value of this attribute must be the id of a `<form>` in the same document.
     * See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#form).
     */
    form?: string;
}

type SelectionMode = 'single' | 'multiple';
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;
}
interface SelectProps<T = {}, M extends SelectionMode = '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;
}
/**
 * A select displays a collapsible list of options and allows a user to select one of them.
 */
declare const Select: <T, M extends SelectionMode = "single">(props: SelectProps<T, M> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
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'>;
}
interface SelectValueProps<T> 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>>;
}
/**
 * SelectValue renders the current value of a Select, or a placeholder if no value is selected.
 * It is usually placed within the button element.
 */
declare const SelectValue: <T>(props: SelectValueProps<T> & React.RefAttributes<HTMLSpanElement>) => React.ReactElement | null;

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;
}
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>;
}
/**
 * A slider output displays the current value of a slider as text.
 */
declare const SliderOutput: (props: SliderOutputProps & React.RefAttributes<HTMLOutputElement>) => React.ReactElement | null;
interface SliderTrackRenderProps extends SliderRenderProps {
    /**
     * Whether the slider track is currently hovered with a mouse.
     *
     * @selector [data-hovered]
     */
    isHovered: boolean;
}
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>;
}
/**
 * A slider track is a container for one or more slider thumbs.
 */
declare const SliderTrack: (props: SliderTrackProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;

interface AriaTagGroupProps<T> extends CollectionBase<T>, MultipleSelection, Pick<AriaGridListProps<T>, 'escapeKeyBehavior' | 'onAction'>, DOMProps$1, LabelableProps, AriaLabelingProps, Omit<HelpTextProps, 'errorMessage'> {
    /**
     * How multiple selection should behave in the collection.
     *
     * @default 'toggle'
     */
    selectionBehavior?: SelectionBehavior;
    /** Whether selection should occur on press up instead of press down. */
    shouldSelectOnPressUp?: boolean;
    /** Handler that is called when a user deletes a tag. */
    onRemove?: (keys: Set<Key>) => void;
    /** An error message for the field. */
    errorMessage?: ReactNode;
    /**
     * Whether pressing the escape key should clear selection in the TagGroup or not.
     *
     * Most experiences should not modify this option as it eliminates a keyboard user's ability to
     * easily clear selection. Only use if the escape key is being handled externally or should not
     * trigger selection clearing contextually.
     *
     * @default 'clearSelection'
     */
    escapeKeyBehavior?: 'clearSelection' | 'none';
}

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;
}
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>;
}
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;
}
/**
 * A tag group is a focusable list of labels, categories, keywords, filters, or other items, with
 * support for keyboard navigation, selection, and removal.
 */
declare const TagGroup: (props: TagGroupProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
/**
 * A tag list is a container for tags within a TagGroup.
 */
declare const TagList: <T>(props: TagListProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
interface TagRenderProps extends Omit<ItemRenderProps, 'allowsDragging' | 'isDragging' | 'isDropTarget'> {
    /**
     * Whether the tag group allows items to be removed.
     *
     * @selector [data-allows-removing]
     */
    allowsRemoving: boolean;
}
interface TagProps extends RenderProps<TagRenderProps, 'div'>, LinkDOMProps, HoverEvents, FocusEvents, PressEvents, Omit<GlobalDOMAttributes<HTMLDivElement>, 'onClick'> {
    /**
     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
     * element. A function may be provided to compute the class based on component state.
     *
     * @default 'react-aria-Tag'
     */
    className?: ClassNameOrFunction<TagRenderProps>;
    /** A unique id for the tag. */
    id?: Key;
    /**
     * A string representation of the tags's contents, used for accessibility.
     * Required if children is not a plain text string.
     */
    textValue?: string;
    /** Whether the tag is disabled. */
    isDisabled?: boolean;
    /**
     * Handler that is called when a user performs an action on the item. The exact user event depends
     * on the collection's `selectionBehavior` prop and the interaction modality.
     */
    onAction?: () => void;
}
/**
 * A Tag is an individual item within a TagList.
 */
declare const Tag: (props: TagProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;

interface TextProps extends HTMLAttributes<HTMLElement>, DOMRenderProps<any, any> {
    elementType?: string;
}
declare const Text: (props: TextProps & React.RefAttributes<HTMLElement>) => React.ReactElement | null;

interface I18nProviderProps {
    /** Contents that should have the locale applied. */
    children: ReactNode;
    /** The locale to apply to the children. */
    locale?: string;
}
/**
 * Provides the locale for the application to all child components.
 */
declare function I18nProvider(props: I18nProviderProps): JSX.Element;

export { Button, Calendar, CalendarCell, CalendarDate, CalendarDateTime, CalendarGrid, Checkbox, CheckboxGroup, ColorArea, ColorField, ColorSlider, ColorSwatch, ColorSwatchPicker, ColorSwatchPickerItem, ColorThumb, ColorWheel, ColorWheelTrack, ComboBox, DateField, DateInput, DatePicker, DateRangePicker, DateSegment, Dialog, DropZone, FieldError, FileTrigger, Group, Heading, I18nProvider, Input, Label, ListBox, ListBoxItem, Meter, NumberField, Popover, RangeCalendar, SearchField, Select, SelectValue, SliderOutput, SliderTrack, Tag, TagGroup, TagList, Text, Time, TimeField, composeRenderProps, getLocalTimeZone, parseDate, parseDateTime, parseZonedDateTime, today };
export type { CalendarProps, CheckboxGroupProps, CheckboxProps, ColorAreaProps, ColorFieldProps, ColorSliderProps, ColorSwatchPickerItemProps, ColorSwatchPickerProps, ColorWheelProps, ComboBoxProps, DateFieldProps, DatePickerProps, DateRangePickerProps, DateValue, DropZoneProps, FileTriggerProps, ListBoxItemProps, ListBoxProps, MeterProps, NumberFieldProps, RangeCalendarProps, SearchFieldProps, SelectProps, TagGroupProps, TagListProps, TagProps, TimeFieldProps, TimeValue, ValidationResult };