@baseline-ui/core 1.0.0 → 1.2.0

package/dist/react-aria.d.ts

@@ -20,62 +20,63 @@ type ValidationError = string | string[];
 
 interface Validation<T = unknown> {
   /** Whether user input is required on the input before form submission. */
-  isRequired?: boolean,
+  isRequired?: boolean;
   /** Whether the input value is invalid. */
-  isInvalid?: boolean,
+  isInvalid?: boolean;
   /** @deprecated Use `isInvalid` instead. */
-  validationState?: ValidationState,
+  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',
+  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
+  validate?: (value: T) => ValidationError | true | null | undefined;
 }
 
 interface ValidationResult {
   /** Whether the input value is invalid. */
-  isInvalid: boolean,
+  isInvalid: boolean;
   /** The current error messages for the input if it is invalid, otherwise an empty array. */
-  validationErrors: string[],
+  validationErrors: string[];
   /** The native validation details for the input. */
-  validationDetails: ValidityState
+  validationDetails: ValidityState;
 }
 
 interface InputBase {
   /** Whether the input is disabled. */
-  isDisabled?: boolean,
+  isDisabled?: boolean;
   /** Whether the input can be selected but not changed by the user. */
-  isReadOnly?: boolean
+  isReadOnly?: boolean;
 }
 
 interface ValueBase<T, C = T> {
   /** The current value (controlled). */
-  value?: T,
+  value?: T;
   /** The default value (uncontrolled). */
-  defaultValue?: T,
+  defaultValue?: T;
   /** Handler that is called when the value changes. */
-  onChange?: (value: C) => void
+  onChange?: (value: C) => void;
 }
 
 interface TextInputBase {
   /** Temporary text that occupies the text input when it is empty. */
-  placeholder?: string
+  placeholder?: string;
 }
 
 interface HelpTextProps {
   /** A description for the field. Provides a hint such as specific requirements for what to choose. */
-  description?: ReactNode,
+  description?: ReactNode;
   /** An error message for the field. */
-  errorMessage?: ReactNode | ((v: ValidationResult) => ReactNode)
+  errorMessage?: ReactNode | ((v: ValidationResult) => ReactNode);
 }
 
 /*
@@ -96,22 +97,23 @@ interface AriaLabelingProps {
   /**
    * Defines a string value that labels the current element.
    */
-  'aria-label'?: string,
+  'aria-label'?: string;
 
   /**
    * Identifies the element (or elements) that labels the current element.
    */
-  'aria-labelledby'?: string,
+  'aria-labelledby'?: string;
 
   /**
    * Identifies the element (or elements) that describes the object.
    */
-  'aria-describedby'?: string,
+  'aria-describedby'?: string;
 
   /**
-   * Identifies the element (or elements) that provide a detailed, extended description for the object.
+   * Identifies the element (or elements) that provide a detailed, extended description for the
+   * object.
    */
-  'aria-details'?: string
+  'aria-details'?: string;
 }
 
 interface AriaValidationProps {
@@ -119,16 +121,17 @@ interface AriaValidationProps {
   /**
    * Identifies the element that provides an error message for the object.
    */
-  'aria-errormessage'?: string
+  '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).
+   * The element's unique identifier. See
+   * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id).
    */
-  id?: string
+  id?: string;
 }
 
 interface FocusableDOMProps extends DOMProps {
@@ -138,121 +141,145 @@ interface FocusableDOMProps extends DOMProps {
    * be avoided except in rare scenarios where an alternative means of accessing
    * the element or its functionality via the keyboard is available.
    */
-  excludeFromTabOrder?: boolean
+  excludeFromTabOrder?: boolean;
 }
 
-
-interface TextInputDOMEvents {
+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<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>
+   * 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).
+   * 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,
+  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
+  form?: string;
 }
 
 // DOM props that apply to all text inputs
 // Ensure this is synced with useTextField
-interface TextInputDOMProps extends DOMProps, InputDOMProps, TextInputDOMEvents {
+interface TextInputDOMProps<T = HTMLInputElement>
+  extends DOMProps, 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).
+   * 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,
+  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).
+   * 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,
+  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).
+   * 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,
+  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).
+   * 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,
+  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).
+   * 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,
+  placeholder?: string;
 
   /**
-   * The type of input to render. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdeftype).
+   * 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 & {}),
+  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).
+   * 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',
+  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).
+   * 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,
+  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).
+   * 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
+  spellCheck?: string;
 }
 
 /** Any focusable element, including both HTML and SVG elements. */
@@ -260,11 +287,11 @@ 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
+  id?: string | undefined;
+  role?: AriaRole | undefined;
+  tabIndex?: number | undefined;
+  style?: CSSProperties | undefined;
+  className?: string | undefined;
 }
 
 /*
@@ -287,20 +314,20 @@ type DropPosition = 'on' | 'before' | 'after';
 
 interface ItemDropTarget {
   /** The drop target type. */
-  type: 'item',
+  type: 'item';
   /** The item key. */
-  key: Key,
+  key: Key;
   /** The drop position relative to the item. */
-  dropPosition: DropPosition
+  dropPosition: DropPosition;
 }
 
 interface DroppableCollectionReorderEvent {
   /** The keys of the items that were reordered. */
-  keys: Set<Key>,
+  keys: Set<Key>;
   /** The drop operation that should occur. */
-  dropOperation: DropOperation,
+  dropOperation: DropOperation;
   /** The drop target. */
-  target: ItemDropTarget
+  target: ItemDropTarget;
 }
 
 /*
@@ -322,10 +349,12 @@ interface DroppableCollectionReorderEvent {
 type BaseEvent<T extends SyntheticEvent> = T & {
   /**
    * Use continuePropagation.
-   * @deprecated */
-  stopPropagation(): void,
-  continuePropagation(): void
-}
+   *
+   * @deprecated
+   */
+  stopPropagation(): void;
+  continuePropagation(): void;
+};
 
 type KeyboardEvent = BaseEvent<KeyboardEvent$1<any>>;
 
@@ -333,80 +362,80 @@ type PointerType = 'mouse' | 'pen' | 'touch' | 'keyboard' | 'virtual';
 
 interface PressEvent {
   /** The type of press event being fired. */
-  type: 'pressstart' | 'pressend' | 'pressup' | 'press',
+  type: 'pressstart' | 'pressend' | 'pressup' | 'press';
   /** The pointer type that triggered the press event. */
-  pointerType: PointerType,
+  pointerType: PointerType;
   /** The target element of the press event. */
-  target: Element,
+  target: Element;
   /** Whether the shift keyboard modifier was held during the press event. */
-  shiftKey: boolean,
+  shiftKey: boolean;
   /** Whether the ctrl keyboard modifier was held during the press event. */
-  ctrlKey: boolean,
+  ctrlKey: boolean;
   /** Whether the meta keyboard modifier was held during the press event. */
-  metaKey: boolean,
+  metaKey: boolean;
   /** Whether the alt keyboard modifier was held during the press event. */
-  altKey: boolean,
+  altKey: boolean;
   /** X position relative to the target. */
-  x: number,
+  x: number;
   /** Y position relative to the target. */
-  y: number,
+  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,
+  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
+  continuePropagation(): void;
 }
 
 interface KeyboardEvents {
   /** Handler that is called when a key is pressed. */
-  onKeyDown?: (e: KeyboardEvent) => void,
+  onKeyDown?: (e: KeyboardEvent) => void;
   /** Handler that is called when a key is released. */
-  onKeyUp?: (e: KeyboardEvent) => void
+  onKeyUp?: (e: KeyboardEvent) => void;
 }
 
 interface FocusEvents<Target = Element> {
   /** Handler that is called when the element receives focus. */
-  onFocus?: (e: FocusEvent<Target>) => void,
+  onFocus?: (e: FocusEvent<Target>) => void;
   /** Handler that is called when the element loses focus. */
-  onBlur?: (e: FocusEvent<Target>) => void,
+  onBlur?: (e: FocusEvent<Target>) => void;
   /** Handler that is called when the element's focus status changes. */
-  onFocusChange?: (isFocused: boolean) => void
+  onFocusChange?: (isFocused: boolean) => void;
 }
 
 interface PressEvents {
   /** Handler that is called when the press is released over the target. */
-  onPress?: (e: PressEvent) => void,
+  onPress?: (e: PressEvent) => void;
   /** Handler that is called when a press interaction starts. */
-  onPressStart?: (e: PressEvent) => void,
+  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,
+  onPressEnd?: (e: PressEvent) => void;
   /** Handler that is called when the press state changes. */
-  onPressChange?: (isPressed: boolean) => void,
+  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,
+  onPressUp?: (e: PressEvent) => void;
   /**
    * **Not recommended – use `onPress` instead.** `onClick` is an alias for `onPress`
-   * provided for compatibility with other libraries. `onPress` provides 
+   * provided for compatibility with other libraries. `onPress` provides
    * additional event details for non-mouse interactions.
    */
-  onClick?: (e: MouseEvent<FocusableElement>) => void
+  onClick?: (e: MouseEvent<FocusableElement>) => void;
 }
 
 interface FocusableProps<Target = Element> extends FocusEvents<Target>, KeyboardEvents {
   /** Whether the element should receive focus on render. */
-  autoFocus?: boolean
+  autoFocus?: boolean;
 }
 
 /*
@@ -425,7 +454,7 @@ interface FocusableProps<Target = Element> extends FocusEvents<Target>, Keyboard
 
 interface LabelableProps {
   /** The content to display as the label. */
-  label?: ReactNode
+  label?: ReactNode;
 }
 
 /*
@@ -479,28 +508,40 @@ type TextFieldHTMLAttributesType = Pick<IntrinsicHTMLAttributes, TextFieldIntrin
 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. */
+interface AriaTextFieldProps<T = HTMLInputElement> extends TextFieldProps<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.
+     * 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. */
+    /**
+     * 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. */
+    /**
+     * 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).
+     * 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).
+     * 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;
@@ -510,7 +551,9 @@ interface AriaTextFieldOptions<T extends TextFieldIntrinsicElements> extends Ari
      */
     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).
+     * 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';
 }
@@ -532,6 +575,7 @@ interface TextFieldAria<T extends TextFieldIntrinsicElements = DefaultElementTyp
 }
 /**
  * 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.
  */
@@ -546,26 +590,40 @@ interface ButtonProps extends PressEvents, FocusableProps {
 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. */
+    /**
+     * 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. */
+    /**
+     * 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. */
+    /**
+     * 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. */
+    /**
+     * 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.
+     * 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;
     /**
@@ -595,6 +653,7 @@ interface AriaBaseButtonProps extends FocusableDOMProps, AriaLabelingProps {
 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>;
@@ -604,7 +663,10 @@ interface LinkButtonProps<T extends ElementType = 'button'> extends AriaButtonEl
     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). */
+    /**
+     * 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 {
@@ -678,12 +740,13 @@ interface SelectableItemStates {
     /** 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`.
+     * 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`.
+     * Whether the item may be selected, dependent on `selectionMode`, `disabledKeys`, and
+     * `disabledBehavior`.
      */
     allowsSelection: boolean;
     /**