@baseline-ui/core 0.59.0 → 0.60.1

package/dist/react-aria.d.ts

@@ -0,0 +1,708 @@
+import { ReactNode, ClipboardEventHandler, CompositionEventHandler, ReactEventHandler, FormEventHandler, AriaAttributes, DOMAttributes as DOMAttributes$1, AriaRole, CSSProperties, MouseEvent, FocusEvent, SyntheticEvent, KeyboardEvent as KeyboardEvent$1, JSX, HTMLAttributes, RefObject, LabelHTMLAttributes, ElementType, JSXElementConstructor, ButtonHTMLAttributes, AnchorHTMLAttributes, InputHTMLAttributes } 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 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 {
+  /**
+   * 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 {
+  /**
+   * 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 {
+  // 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<HTMLInputElement>,
+
+   /**
+    * Handler that is called when the user cuts text. See [MDN](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/oncut).
+    */
+   onCut?: ClipboardEventHandler<HTMLInputElement>,
+
+   /**
+    * Handler that is called when the user pastes text. See [MDN](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/onpaste).
+    */
+   onPaste?: ClipboardEventHandler<HTMLInputElement>,
+
+   // 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<HTMLInputElement>,
+
+   /**
+    * 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<HTMLInputElement>,
+
+   /**
+    * 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<HTMLInputElement>,
+
+   // 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<HTMLInputElement>,
+
+   // 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<HTMLInputElement>,
+   /**
+    * 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<HTMLInputElement>
+}
+
+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 extends DOMProps, InputDOMProps, TextInputDOMEvents {
+  /**
+   * 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
+}
+
+/** Any focusable element, including both HTML and SVG elements. */
+interface FocusableElement extends Element, HTMLOrSVGElement {}
+
+/** All DOM attributes supported across both HTML and SVG elements. */
+interface DOMAttributes<T = FocusableElement> extends AriaAttributes, DOMAttributes$1<T> {
+  id?: string | undefined,
+  role?: AriaRole | undefined,
+  tabIndex?: number | undefined,
+  style?: CSSProperties | undefined,
+  className?: string | 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 DropOperation = 'copy' | 'link' | 'move' | 'cancel';
+
+type DropPosition = 'on' | 'before' | 'after';
+
+interface ItemDropTarget {
+  /** The drop target type. */
+  type: 'item',
+  /** The item key. */
+  key: Key,
+  /** The drop position relative to the item. */
+  dropPosition: DropPosition
+}
+
+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
+}
+
+/*
+ * 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 = BaseEvent<KeyboardEvent$1<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 KeyboardEvents {
+  /** Handler that is called when a key is pressed. */
+  onKeyDown?: (e: KeyboardEvent) => void,
+  /** Handler that is called when a key is released. */
+  onKeyUp?: (e: KeyboardEvent) => 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 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 LabelableProps {
+  /** The content to display as the label. */
+  label?: ReactNode
+}
+
+/*
+ * 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;
+
+/**
+ * A map of HTML element names and their interface types.
+ * For example `'a'` -> `HTMLAnchorElement`.
+ */
+type IntrinsicHTMLElements = {
+    [K in keyof IntrinsicHTMLAttributes]: IntrinsicHTMLAttributes[K] extends HTMLAttributes<infer T> ? T : never;
+};
+/**
+ * A map of HTML element names and their attribute interface types.
+ * For example `'a'` -> `AnchorHTMLAttributes<HTMLAnchorElement>`.
+ */
+type IntrinsicHTMLAttributes = JSX.IntrinsicElements;
+type DefaultElementType = 'input';
+/**
+ * The intrinsic HTML element names that `useTextField` supports; e.g. `input`,
+ * `textarea`.
+ */
+type TextFieldIntrinsicElements = keyof Pick<IntrinsicHTMLElements, 'input' | 'textarea'>;
+/**
+ * The HTML element interfaces that `useTextField` supports based on what is
+ * defined for `TextFieldIntrinsicElements`; e.g. `HTMLInputElement`,
+ * `HTMLTextAreaElement`.
+ */
+type TextFieldHTMLElementType = Pick<IntrinsicHTMLElements, TextFieldIntrinsicElements>;
+/**
+ * The HTML attributes interfaces that `useTextField` supports based on what
+ * is defined for `TextFieldIntrinsicElements`; e.g. `InputHTMLAttributes`,
+ * `TextareaHTMLAttributes`.
+ */
+type TextFieldHTMLAttributesType = Pick<IntrinsicHTMLAttributes, TextFieldIntrinsicElements>;
+/**
+ * The type of `inputProps` returned by `useTextField`; e.g. `InputHTMLAttributes`,
+ * `TextareaHTMLAttributes`.
+ */
+type TextFieldInputProps<T extends TextFieldIntrinsicElements> = TextFieldHTMLAttributesType[T];
+interface TextFieldProps<T = HTMLInputElement> extends InputBase, Validation<string>, HelpTextProps, FocusableProps<T>, TextInputBase, ValueBase<string>, LabelableProps {
+}
+interface AriaTextFieldProps<T = HTMLInputElement> extends TextFieldProps<T>, AriaLabelingProps, FocusableDOMProps, TextInputDOMProps, 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 AriaTextFieldOptions<T extends TextFieldIntrinsicElements> extends AriaTextFieldProps<TextFieldHTMLElementType[T]> {
+    /**
+     * The HTML element used to render the input, e.g. 'input', or 'textarea'.
+     * It determines whether certain HTML attributes will be included in `inputProps`.
+     * For example, [`type`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-type).
+     * @default 'input'
+     */
+    inputElementType?: T;
+    /**
+     * Controls whether inputted text is automatically capitalized and, if so, in what manner.
+     * See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/autocapitalize).
+     */
+    autoCapitalize?: 'off' | 'none' | 'on' | 'sentences' | 'words' | 'characters';
+    /**
+     * 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 `ref` object that can be passed to `useTextField` based on the given
+ * intrinsic HTML element name; e.g.`RefObject<HTMLInputElement>`,
+ * `RefObject<HTMLTextAreaElement>`.
+ */
+type TextFieldRefObject<T extends TextFieldIntrinsicElements> = RefObject<TextFieldHTMLElementType[T] | null>;
+interface TextFieldAria<T extends TextFieldIntrinsicElements = DefaultElementType> extends ValidationResult {
+    /** Props for the input element. */
+    inputProps: TextFieldInputProps<T>;
+    /** Props for the text field's visible label element, if any. */
+    labelProps: DOMAttributes | LabelHTMLAttributes<HTMLLabelElement>;
+    /** Props for the text field's description element, if any. */
+    descriptionProps: DOMAttributes;
+    /** Props for the text field's error message element, if any. */
+    errorMessageProps: DOMAttributes;
+}
+/**
+ * Provides the behavior and accessibility implementation for a text field.
+ * @param props - Props for the text field.
+ * @param ref - Ref to the HTML input or textarea element.
+ */
+declare function useTextField<T extends TextFieldIntrinsicElements = DefaultElementType>(props: AriaTextFieldOptions<T>, ref: TextFieldRefObject<T>): TextFieldAria<T>;
+
+interface ButtonProps 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, LinkButtonProps<T>, AriaBaseButtonProps {
+}
+interface AriaButtonOptions<E extends ElementType> extends Omit<AriaButtonProps<E>, 'children'> {
+}
+interface ButtonAria<T> {
+    /** Props for the button element. */
+    buttonProps: T;
+    /** Whether the button is currently pressed. */
+    isPressed: boolean;
+}
+declare function useButton(props: AriaButtonOptions<'button'>, ref: RefObject<HTMLButtonElement | null>): ButtonAria<ButtonHTMLAttributes<HTMLButtonElement>>;
+declare function useButton(props: AriaButtonOptions<'a'>, ref: RefObject<HTMLAnchorElement | null>): ButtonAria<AnchorHTMLAttributes<HTMLAnchorElement>>;
+declare function useButton(props: AriaButtonOptions<'div'>, ref: RefObject<HTMLDivElement | null>): ButtonAria<HTMLAttributes<HTMLDivElement>>;
+declare function useButton(props: AriaButtonOptions<'input'>, ref: RefObject<HTMLInputElement | null>): ButtonAria<InputHTMLAttributes<HTMLInputElement>>;
+declare function useButton(props: AriaButtonOptions<'span'>, ref: RefObject<HTMLSpanElement | null>): ButtonAria<HTMLAttributes<HTMLSpanElement>>;
+declare function useButton(props: AriaButtonOptions<ElementType>, ref: RefObject<Element | null>): ButtonAria<DOMAttributes>;
+
+interface FocusManagerOptions {
+    /** The element to start searching from. The currently focused element by default. */
+    from?: Element;
+    /** Whether to only include tabbable elements, or all focusable elements. */
+    tabbable?: boolean;
+    /** Whether focus should wrap around when it reaches the end of the scope. */
+    wrap?: boolean;
+    /** A callback that determines whether the given element is focused. */
+    accept?: (node: Element) => boolean;
+}
+interface FocusManager {
+    /** Moves focus to the next focusable or tabbable element in the focus scope. */
+    focusNext(opts?: FocusManagerOptions): FocusableElement | null;
+    /** Moves focus to the previous focusable or tabbable element in the focus scope. */
+    focusPrevious(opts?: FocusManagerOptions): FocusableElement | null;
+    /** Moves focus to the first focusable or tabbable element in the focus scope. */
+    focusFirst(opts?: FocusManagerOptions): FocusableElement | null;
+    /** Moves focus to the last focusable or tabbable element in the focus scope. */
+    focusLast(opts?: FocusManagerOptions): FocusableElement | null;
+}
+/**
+ * Returns a FocusManager interface for the parent FocusScope.
+ * A FocusManager can be used to programmatically move focus within
+ * a FocusScope, e.g. in response to user events like keyboard navigation.
+ */
+declare function useFocusManager(): FocusManager | 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 FocusWithinResult {
+    /** Props to spread onto the target element. */
+    focusWithinProps: DOMAttributes;
+}
+/**
+ * Handles focus events for the target and its descendants.
+ */
+declare function useFocusWithin(props: FocusWithinProps): FocusWithinResult;
+
+interface SelectableItemStates {
+    /** Whether the item is currently in a pressed state. */
+    isPressed: boolean;
+    /** Whether the item is currently selected. */
+    isSelected: boolean;
+    /** Whether the item is currently focused. */
+    isFocused: 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`.
+     */
+    isDisabled: boolean;
+    /**
+     * Whether the item may be selected, dependent on `selectionMode`, `disabledKeys`, and `disabledBehavior`.
+     */
+    allowsSelection: boolean;
+    /**
+     * Whether the item has an action, dependent on `onAction`, `disabledKeys`,
+     * and `disabledBehavior`. It may also change depending on the current selection state
+     * of the list (e.g. when selection is primary). This can be used to enable or disable hover
+     * styles or other visual indications of interactivity.
+     */
+    hasAction: boolean;
+}
+
+interface GridListItemAria extends SelectableItemStates {
+    /** Props for the list row element. */
+    rowProps: DOMAttributes;
+    /** Props for the grid cell element within the list row. */
+    gridCellProps: DOMAttributes;
+    /** Props for the list item description element, if any. */
+    descriptionProps: DOMAttributes;
+}
+
+export { useButton, useFocusManager, useFocusWithin, useTextField };
+export type { AriaButtonProps, AriaTextFieldOptions, DroppableCollectionReorderEvent, GridListItemAria };