@proyecto-viviana/solidaria 0.0.2 → 0.0.3

package/dist/index.d.ts

@@ -1,15 +1,1214 @@
-export { createButton, createToggleButton, type AriaButtonProps, type ButtonAria, type AriaToggleButtonProps, type ToggleButtonAria, } from './button';
-export { createCheckbox, createCheckboxGroup, createCheckboxGroupItem, createCheckboxGroupState, checkboxGroupData, type AriaCheckboxProps, type CheckboxAria, type AriaCheckboxGroupProps, type CheckboxGroupAria, type AriaCheckboxGroupItemProps, type CheckboxGroupProps, type CheckboxGroupState, } from './checkbox';
-export { createRadio, createRadioGroup, createRadioGroupState, radioGroupData, type AriaRadioProps, type RadioAria, type AriaRadioGroupProps, type RadioGroupAria, type RadioGroupProps, type RadioGroupState, } from './radio';
-export { createPress, createFocusable, createFocusRing, createHover, type CreatePressProps, type PressResult, type PressEvent, type CreateFocusableProps, type FocusableResult, type FocusRingProps, type FocusRingResult, type CreateHoverProps, type HoverResult, type HoverEvent, type HoverEvents, } from './interactions';
-export { createLabel, createField, createLabels, type LabelAriaProps, type LabelAria, type AriaLabelingProps, type LabelableProps, type DOMProps, type AriaFieldProps, type FieldAria, type HelpTextProps, type ValidationResult, type Validation, } from './label';
-export { createIsSSR, createId, canUseDOM } from './ssr';
-export { createToggle, createToggleState, type AriaToggleProps, type ToggleAria, type ToggleStateOptions, type ToggleState, } from './toggle';
-export { createSwitch, type AriaSwitchProps, type SwitchAria, } from './switch';
-export { createLink, type AriaLinkProps, type LinkAria, } from './link';
-export { createTextField, type AriaTextFieldProps, type TextFieldAria, } from './textfield';
-export { createProgressBar, type AriaProgressBarProps, type ProgressBarAria, } from './progress';
-export { createSeparator, type AriaSeparatorProps, type SeparatorAria, type Orientation, } from './separator';
-export { mergeProps, filterDOMProps, type FilterDOMPropsOptions } from './utils';
-export { access, isAccessor, type MaybeAccessor, type MaybeAccessorValue } from './utils';
-//# sourceMappingURL=index.d.ts.map
+import { Accessor, JSX } from 'solid-js';
+import { ToggleState, CheckboxGroupProps, CheckboxGroupState, RadioGroupState } from '@proyecto-viviana/solid-stately';
+export { CheckboxGroupProps, CheckboxGroupState, RadioGroupProps, RadioGroupState, ToggleState, ToggleStateOptions, createCheckboxGroupState, createRadioGroupState, createToggleState } from '@proyecto-viviana/solid-stately';
+
+/**
+ * PressEvent class that matches React-Aria's PressEvent interface.
+ * Wraps native events with press-specific data.
+ */
+type PointerType = 'mouse' | 'pen' | 'touch' | 'keyboard' | 'virtual';
+type PressEventType = 'pressstart' | 'pressend' | 'pressup' | 'press';
+interface IPressEvent {
+    /** The type of press event being fired. */
+    type: PressEventType;
+    /** 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 of the press relative to the target element. */
+    x: number;
+    /** Y position of the press relative to the target element. */
+    y: number;
+    /**
+     * By default, press events stop propagation to parent elements.
+     * Call continuePropagation() to allow the event to bubble up.
+     */
+    continuePropagation(): void;
+}
+/**
+ * PressEvent class that provides all press event data.
+ * Based on React-Aria's PressEvent implementation.
+ */
+declare class PressEvent implements IPressEvent {
+    #private;
+    type: PressEventType;
+    pointerType: PointerType;
+    target: Element;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+    x: number;
+    y: number;
+    constructor(type: PressEventType, pointerType: PointerType, originalEvent: Event | null, target: Element);
+    /**
+     * Call this to allow the press event to propagate to parent elements.
+     * By default, press events stop propagation.
+     */
+    continuePropagation(): void;
+    /**
+     * Whether the event should stop propagation.
+     * Used internally by the press handler.
+     */
+    get shouldStopPropagation(): boolean;
+}
+
+/**
+ * createPress - Handles press interactions across mouse, touch, keyboard, and virtual clicks.
+ *
+ * This is a 1-1 port of React-Aria's usePress hook adapted for SolidJS.
+ * All behaviors, edge cases, and platform-specific handling are preserved.
+ */
+
+interface CreatePressProps {
+    /** Whether the target is currently disabled. */
+    isDisabled?: Accessor<boolean> | boolean;
+    /** Handler called when the press is released over the target. */
+    onPress?: (e: PressEvent) => void;
+    /** Handler called when a press interaction starts. */
+    onPressStart?: (e: PressEvent) => void;
+    /**
+     * Handler called when a press interaction ends, either
+     * over the target or when the pointer leaves the target.
+     */
+    onPressEnd?: (e: PressEvent) => void;
+    /** Handler called when a press is released over the target, regardless of whether it started on the target. */
+    onPressUp?: (e: PressEvent) => void;
+    /** Handler called when the press state changes. */
+    onPressChange?: (isPressed: boolean) => void;
+    /** Whether the press should be visual only, not triggering onPress. */
+    isPressed?: Accessor<boolean> | boolean;
+    /** Whether to prevent focus when pressing. */
+    preventFocusOnPress?: boolean;
+    /** Whether long press should cancel when pointer moves out of target. */
+    shouldCancelOnPointerExit?: boolean;
+    /** Whether text selection should be allowed during press. */
+    allowTextSelectionOnPress?: boolean;
+}
+interface PressResult {
+    /** Whether the target is currently pressed. */
+    isPressed: Accessor<boolean>;
+    /** Props to spread on the target element. */
+    pressProps: JSX.HTMLAttributes<HTMLElement>;
+}
+/**
+ * Handles press interactions across mouse, touch, keyboard, and screen readers.
+ * Provides consistent press behavior regardless of input method.
+ *
+ * Based on react-aria's usePress but adapted for SolidJS.
+ */
+declare function createPress(props?: CreatePressProps): PressResult;
+
+/**
+ * createFocus - Handles focus events for the immediate target.
+ *
+ * This is a 1-1 port of React-Aria's useFocus hook adapted for SolidJS.
+ * Focus events on child elements will be ignored.
+ */
+
+interface FocusEvents {
+    /** Handler that is called when the element receives focus. */
+    onFocus?: (e: FocusEvent) => void;
+    /** Handler that is called when the element loses focus. */
+    onBlur?: (e: FocusEvent) => void;
+    /** Handler that is called when the element's focus status changes. */
+    onFocusChange?: (isFocused: boolean) => void;
+}
+
+/**
+ * createKeyboard - Handles keyboard interactions for a focusable element.
+ *
+ * This is a 1-1 port of React-Aria's useKeyboard hook adapted for SolidJS.
+ */
+
+/**
+ * Keyboard event with continuePropagation support.
+ * By default, keyboard events stop propagation.
+ */
+interface KeyboardEvent$1 extends globalThis.KeyboardEvent {
+    /** Call this to allow the event to propagate to parent elements. */
+    continuePropagation(): void;
+}
+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 FocusableDOMProps {
+    /** Whether to exclude the element from the sequential tab order. */
+    excludeFromTabOrder?: boolean;
+}
+interface FocusableProps extends FocusEvents, KeyboardEvents {
+    /** Whether the element should receive focus on mount. */
+    autoFocus?: boolean;
+}
+interface CreateFocusableProps extends FocusableProps, FocusableDOMProps {
+    /** Whether focus should be disabled. */
+    isDisabled?: Accessor<boolean> | boolean;
+}
+interface FocusableResult {
+    /** Props to spread on the focusable element. */
+    focusableProps: JSX.HTMLAttributes<HTMLElement>;
+}
+/**
+ * Makes an element focusable, handling disabled state and tab order.
+ * Provides focus state tracking and autoFocus support.
+ *
+ * Based on react-aria's useFocusable but adapted for SolidJS.
+ *
+ * @example
+ * ```tsx
+ * import { createFocusable } from 'solidaria';
+ *
+ * function FocusableInput(props) {
+ *   let ref;
+ *   const { focusableProps } = createFocusable({
+ *     autoFocus: props.autoFocus,
+ *     onFocusChange: (focused) => console.log('Focus:', focused),
+ *   });
+ *
+ *   return (
+ *     <input
+ *       {...focusableProps}
+ *       ref={(el) => { ref = el; focusableProps.ref?.(el); }}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function createFocusable(props?: CreateFocusableProps, ref?: (el: HTMLElement) => void): FocusableResult;
+
+/**
+ * createFocusRing hook for Solidaria
+ *
+ * Determines whether a focus ring should be visible for a given element.
+ * Focus rings are visible when the user navigates with keyboard, but hidden
+ * when using mouse/touch.
+ *
+ * Port of @react-aria/focus useFocusRing.
+ */
+
+interface FocusRingProps {
+    /** Whether the element is a text input. */
+    isTextInput?: boolean;
+    /** Whether the element will be auto focused. */
+    autoFocus?: boolean;
+    /** Whether focus should be tracked within the element. */
+    within?: boolean;
+}
+interface FocusRingResult {
+    /** Whether the element is currently focused. */
+    isFocused: Accessor<boolean>;
+    /** Whether the focus ring should be visible. */
+    isFocusVisible: Accessor<boolean>;
+    /** Props to spread on the element to track focus. */
+    focusProps: JSX.HTMLAttributes<HTMLElement>;
+}
+/**
+ * Determines whether a focus ring should be visible for a given element.
+ *
+ * Focus rings are visible when:
+ * - The element is focused AND
+ * - The user is navigating with keyboard (not mouse/touch)
+ *
+ * For text inputs, focus rings are always visible when focused.
+ */
+declare function createFocusRing(props?: FocusRingProps): FocusRingResult;
+
+/**
+ * Reactivity utilities for Solidaria
+ *
+ * Provides type-safe utilities for working with SolidJS reactivity patterns.
+ */
+
+/**
+ * A value that may be either a raw value or an accessor function.
+ * This is a common pattern in SolidJS for props that may be reactive.
+ */
+type MaybeAccessor<T> = T | Accessor<T>;
+/**
+ * Unwraps a MaybeAccessor to get the underlying value.
+ * If the input is a function, it calls it to get the value.
+ * Otherwise, it returns the value directly.
+ *
+ * @param value - The value or accessor to unwrap.
+ */
+declare function access<T>(value: MaybeAccessor<T>): T;
+/**
+ * A value that may be undefined or an accessor that returns the value or undefined.
+ */
+type MaybeAccessorValue<T> = T | undefined | Accessor<T | undefined>;
+/**
+ * Checks if a value is an accessor function.
+ */
+declare function isAccessor<T>(value: MaybeAccessor<T>): value is Accessor<T>;
+
+/**
+ * createHover hook for Solidaria
+ *
+ * Handles pointer hover interactions for an element. Normalizes behavior
+ * across browsers and platforms, and ignores emulated mouse events on touch devices.
+ *
+ * Port of @react-aria/interactions useHover.
+ */
+
+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: Element;
+}
+interface HoverEvents {
+    /** Handler called when the hover starts. */
+    onHoverStart?: (e: HoverEvent) => void;
+    /** Handler called when the hover ends. */
+    onHoverEnd?: (e: HoverEvent) => void;
+    /** Handler called when the hover state changes. */
+    onHoverChange?: (isHovering: boolean) => void;
+}
+interface CreateHoverProps extends HoverEvents {
+    /** Whether the hover events should be disabled. */
+    isDisabled?: boolean;
+}
+interface HoverResult {
+    /** Props to spread on the target element. */
+    hoverProps: JSX.HTMLAttributes<HTMLElement>;
+    /** Whether the element is currently hovered. */
+    isHovered: Accessor<boolean>;
+}
+/**
+ * Handles pointer hover interactions for an element.
+ */
+declare function createHover(props?: MaybeAccessor<CreateHoverProps>): HoverResult;
+
+interface AriaButtonProps {
+    /** Whether the button is disabled. */
+    isDisabled?: Accessor<boolean> | boolean;
+    /** Handler called when the press is released over the target. */
+    onPress?: (e: PressEvent) => void;
+    /** Handler called when a press interaction starts. */
+    onPressStart?: (e: PressEvent) => void;
+    /** Handler called when a press interaction ends. */
+    onPressEnd?: (e: PressEvent) => void;
+    /** Handler called when a press is released over the target. */
+    onPressUp?: (e: PressEvent) => void;
+    /** Handler called when the press state changes. */
+    onPressChange?: (isPressed: boolean) => void;
+    /** Whether the button should not receive focus on press. */
+    preventFocusOnPress?: boolean;
+    /** Whether the element should receive focus on render. */
+    autoFocus?: boolean;
+    /** The HTML element type to use for the button. */
+    elementType?: 'button' | 'a' | 'div' | 'input' | 'span';
+    /** The URL to link to (for anchor elements). */
+    href?: string;
+    /** The target for the link (for anchor elements). */
+    target?: string;
+    /** The rel attribute for the link (for anchor elements). */
+    rel?: string;
+    /** The type attribute for button elements. */
+    type?: 'button' | 'submit' | 'reset';
+    /** Whether the button is in a pressed state (controlled). */
+    'aria-pressed'?: boolean | 'true' | 'false' | 'mixed';
+    /** Whether the button has a popup. */
+    'aria-haspopup'?: boolean | 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog' | 'true' | 'false';
+    /** Whether the popup is expanded. */
+    'aria-expanded'?: boolean | 'true' | 'false';
+    /** The accessible label for the button. */
+    'aria-label'?: string;
+    /** The id of the element that labels the button. */
+    'aria-labelledby'?: string;
+    /** The id of the element that describes the button. */
+    'aria-describedby'?: string;
+    /** Identifies the element (or elements) whose contents or presence are controlled by the button. */
+    'aria-controls'?: string;
+    /** Indicates the current "pressed" state of toggle buttons. */
+    'aria-current'?: boolean | 'page' | 'step' | 'location' | 'date' | 'time' | 'true' | 'false';
+    /** Additional attributes for form buttons. */
+    form?: string;
+    formAction?: string;
+    formEncType?: string;
+    formMethod?: string;
+    formNoValidate?: boolean;
+    formTarget?: string;
+    /** The name attribute for form buttons. */
+    name?: string;
+    /** The value attribute for form buttons. */
+    value?: string;
+    /** Whether to exclude the button from the tab order. */
+    excludeFromTabOrder?: boolean;
+}
+interface ButtonAria {
+    /** Props to spread on the button element. */
+    buttonProps: Record<string, unknown>;
+    /** Whether the button is currently pressed. */
+    isPressed: Accessor<boolean>;
+}
+
+/**
+ * Provides the behavior and accessibility implementation for a button component.
+ * Handles press interactions across mouse, touch, keyboard and screen readers.
+ *
+ * Based on react-aria's useButton but adapted for SolidJS.
+ *
+ * @example
+ * ```tsx
+ * import { createButton } from 'solidaria';
+ *
+ * function Button(props) {
+ *   let ref;
+ *   const { buttonProps, isPressed } = createButton(props);
+ *
+ *   return (
+ *     <button
+ *       {...buttonProps}
+ *       ref={ref}
+ *       class={isPressed() ? 'pressed' : ''}
+ *     >
+ *       {props.children}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function createButton(props?: AriaButtonProps): ButtonAria;
+
+interface AriaToggleButtonProps extends Omit<AriaButtonProps, 'aria-pressed'> {
+    /** Whether the button is selected (controlled). */
+    isSelected?: Accessor<boolean> | boolean;
+    /** Handler called when the button's selection state changes. */
+    onChange?: (isSelected: boolean) => void;
+    /** The default selected state (uncontrolled). */
+    defaultSelected?: boolean;
+}
+interface ToggleButtonAria extends ButtonAria {
+    /** Whether the button is currently selected. */
+    isSelected: Accessor<boolean>;
+}
+/**
+ * Provides the behavior and accessibility implementation for a toggle button component.
+ * Toggle buttons allow users to toggle a selection on or off.
+ *
+ * Based on react-aria's useToggleButton but adapted for SolidJS.
+ *
+ * @example
+ * ```tsx
+ * import { createToggleButton } from 'solidaria';
+ *
+ * function ToggleButton(props) {
+ *   const { buttonProps, isPressed, isSelected } = createToggleButton(props);
+ *
+ *   return (
+ *     <button
+ *       {...buttonProps}
+ *       class={isSelected() ? 'selected' : ''}
+ *       style={{ opacity: isPressed() ? 0.8 : 1 }}
+ *     >
+ *       {props.children}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function createToggleButton(props?: AriaToggleButtonProps): ToggleButtonAria;
+
+/**
+ * Toggle hook for Solidaria
+ *
+ * Handles interactions for toggle elements, e.g. Checkboxes and Switches.
+ *
+ * This is a 1:1 port of @react-aria/toggle's useToggle hook.
+ */
+
+interface AriaToggleProps {
+    /** Whether the element should be selected (controlled). */
+    isSelected?: boolean;
+    /** Whether the element should be selected by default (uncontrolled). */
+    defaultSelected?: boolean;
+    /** Handler that is called when the element's selection state changes. */
+    onChange?: (isSelected: boolean) => void;
+    /** The value of the input element, used when submitting an HTML form. */
+    value?: string;
+    /** The name of the input element, used when submitting an HTML form. */
+    name?: string;
+    /** The form to associate the input with. */
+    form?: string;
+    /** Whether the element is disabled. */
+    isDisabled?: boolean;
+    /** Whether the element is read only. */
+    isReadOnly?: boolean;
+    /** Whether the element is required. */
+    isRequired?: boolean;
+    /** Whether the element is invalid. */
+    isInvalid?: boolean;
+    /** The element's children. */
+    children?: JSX.Element;
+    /** 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 an error message for the object. */
+    'aria-errormessage'?: string;
+    /** Identifies the element (or elements) whose contents or presence are controlled by the current element. */
+    'aria-controls'?: string;
+    /** The element's unique identifier. */
+    id?: string;
+    /** 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;
+    /** Handler that is called when the element is clicked. */
+    onClick?: (e: MouseEvent) => void;
+    /** Handler that is called when the element receives focus. */
+    onFocus?: (e: FocusEvent) => void;
+    /** Handler that is called when the element loses focus. */
+    onBlur?: (e: FocusEvent) => void;
+    /** Handler that is called when the element's focus status changes. */
+    onFocusChange?: (isFocused: boolean) => void;
+    /** 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;
+    /** Whether to exclude the element from the tab order. */
+    excludeFromTabOrder?: boolean;
+    /** Whether to autofocus the element. */
+    autoFocus?: boolean;
+}
+interface ToggleAria {
+    /** Props to be spread on the label element. */
+    labelProps: JSX.LabelHTMLAttributes<HTMLLabelElement>;
+    /** Props to be spread on the input element. */
+    inputProps: JSX.InputHTMLAttributes<HTMLInputElement>;
+    /** Whether the toggle is selected. */
+    isSelected: Accessor<boolean>;
+    /** Whether the toggle is in a pressed state. */
+    isPressed: Accessor<boolean>;
+    /** Whether the toggle is disabled. */
+    isDisabled: boolean;
+    /** Whether the toggle is read only. */
+    isReadOnly: boolean;
+    /** Whether the toggle is invalid. */
+    isInvalid: boolean;
+}
+/**
+ * Handles interactions for toggle elements, e.g. Checkboxes and Switches.
+ */
+declare function createToggle(props: MaybeAccessor<AriaToggleProps>, state: ToggleState, ref: () => HTMLInputElement | null): ToggleAria;
+
+/**
+ * Checkbox hook for Solidaria
+ *
+ * Provides the behavior and accessibility implementation for a checkbox component.
+ * Checkboxes allow users to select multiple items from a list of individual items,
+ * or to mark one individual item as selected.
+ *
+ * This is a 1:1 port of @react-aria/checkbox's useCheckbox hook.
+ */
+
+interface AriaCheckboxProps extends AriaToggleProps {
+    /**
+     * Indeterminism is presentational only.
+     * The indeterminate visual representation remains regardless of user interaction.
+     */
+    isIndeterminate?: boolean;
+    /**
+     * Whether the checkbox is required.
+     */
+    isRequired?: boolean;
+    /**
+     * The validation behavior for the checkbox.
+     * @default 'aria'
+     */
+    validationBehavior?: 'aria' | 'native';
+}
+interface CheckboxAria {
+    /** Props for the label wrapper element. */
+    labelProps: JSX.LabelHTMLAttributes<HTMLLabelElement>;
+    /** Props for the input element. */
+    inputProps: JSX.InputHTMLAttributes<HTMLInputElement>;
+    /** Whether the checkbox is selected. */
+    isSelected: Accessor<boolean>;
+    /** Whether the checkbox is in a pressed state. */
+    isPressed: Accessor<boolean>;
+    /** Whether the checkbox is disabled. */
+    isDisabled: boolean;
+    /** Whether the checkbox is read only. */
+    isReadOnly: boolean;
+    /** Whether the checkbox is invalid. */
+    isInvalid: boolean;
+}
+/**
+ * Provides the behavior and accessibility implementation for a checkbox component.
+ * Checkboxes allow users to select multiple items from a list of individual items,
+ * or to mark one individual item as selected.
+ *
+ * @param props - Props for the checkbox.
+ * @param state - State for the checkbox, as returned by `createToggleState`.
+ * @param inputRef - A ref accessor for the HTML input element.
+ */
+declare function createCheckbox(props: MaybeAccessor<AriaCheckboxProps>, state: ToggleState, inputRef: () => HTMLInputElement | null): CheckboxAria;
+
+/**
+ * Checkbox group hook for Solidaria
+ *
+ * Provides the behavior and accessibility implementation for a checkbox group component.
+ * Checkbox groups allow users to select multiple items from a list of options.
+ *
+ * This is a 1:1 port of @react-aria/checkbox's useCheckboxGroup hook.
+ */
+
+interface AriaCheckboxGroupProps extends CheckboxGroupProps {
+    /** 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;
+    /** A description for the field. Provides a hint such as specific requirements for what to choose. */
+    description?: JSX.Element;
+    /** An error message for the field. */
+    errorMessage?: JSX.Element;
+}
+interface CheckboxGroupAria {
+    /** Props for the checkbox group wrapper element. */
+    groupProps: JSX.HTMLAttributes<HTMLElement>;
+    /** Props for the checkbox group's visible label (if any). */
+    labelProps: JSX.HTMLAttributes<HTMLElement>;
+    /** Props for the checkbox group description element, if any. */
+    descriptionProps: JSX.HTMLAttributes<HTMLElement>;
+    /** Props for the checkbox group error message element, if any. */
+    errorMessageProps: JSX.HTMLAttributes<HTMLElement>;
+    /** Whether the checkbox group is invalid. */
+    isInvalid: boolean;
+}
+declare const checkboxGroupData: WeakMap<CheckboxGroupState, {
+    name?: string;
+    form?: string;
+    descriptionId?: string;
+    errorMessageId?: string;
+    validationBehavior: "aria" | "native";
+}>;
+/**
+ * Provides the behavior and accessibility implementation for a checkbox group component.
+ * Checkbox groups allow users to select multiple items from a list of options.
+ *
+ * @param props - Props for the checkbox group.
+ * @param state - State for the checkbox group, as returned by `createCheckboxGroupState`.
+ */
+declare function createCheckboxGroup(props: MaybeAccessor<AriaCheckboxGroupProps>, state: CheckboxGroupState): CheckboxGroupAria;
+
+/**
+ * Checkbox group item hook for Solidaria
+ *
+ * Provides the behavior and accessibility implementation for a checkbox component
+ * contained within a checkbox group.
+ *
+ * This is a 1:1 port of @react-aria/checkbox's useCheckboxGroupItem hook.
+ */
+
+interface AriaCheckboxGroupItemProps extends Omit<AriaCheckboxProps, 'isSelected' | 'defaultSelected'> {
+    /** The value of the checkbox. */
+    value: string;
+}
+/**
+ * Provides the behavior and accessibility implementation for a checkbox component
+ * contained within a checkbox group.
+ *
+ * @param props - Props for the checkbox.
+ * @param state - State for the checkbox group, as returned by `createCheckboxGroupState`.
+ * @param inputRef - A ref accessor for the HTML input element.
+ */
+declare function createCheckboxGroupItem(props: MaybeAccessor<AriaCheckboxGroupItemProps>, state: CheckboxGroupState, inputRef: () => HTMLInputElement | null): CheckboxAria;
+
+/**
+ * Radio group hook for Solidaria
+ *
+ * Provides the behavior and accessibility implementation for a radio group component.
+ * Radio groups allow users to select a single item from a list of mutually exclusive options.
+ *
+ * This is a 1:1 port of @react-aria/radio's useRadioGroup hook.
+ */
+
+interface AriaRadioGroupProps {
+    /** The content to display as the label. */
+    label?: JSX.Element;
+    /** A description for the radio group. Provides additional context. */
+    description?: JSX.Element;
+    /** An error message for the radio group. */
+    errorMessage?: JSX.Element | ((validation: {
+        isInvalid: boolean;
+        validationErrors: string[];
+    }) => JSX.Element);
+    /** Whether the radio group is disabled. */
+    isDisabled?: boolean;
+    /** Whether the radio group is read only. */
+    isReadOnly?: boolean;
+    /** Whether the radio group is required. */
+    isRequired?: boolean;
+    /** Whether the radio group is invalid. */
+    isInvalid?: boolean;
+    /** The axis the Radio Button(s) should align with. Defaults to 'vertical'. */
+    orientation?: 'horizontal' | 'vertical';
+    /** The name of the radio group, used when submitting an HTML form. */
+    name?: string;
+    /** The form to associate the radio group with. */
+    form?: string;
+    /** Validation behavior for the radio group. */
+    validationBehavior?: 'aria' | 'native';
+    /** Handler that is called when the radio group receives focus. */
+    onFocus?: (e: FocusEvent) => void;
+    /** Handler that is called when the radio group loses focus. */
+    onBlur?: (e: FocusEvent) => void;
+    /** Handler that is called when the radio group's focus status changes. */
+    onFocusChange?: (isFocused: boolean) => void;
+    /** 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 an error message for the object. */
+    'aria-errormessage'?: string;
+    /** The element's unique identifier. */
+    id?: string;
+}
+interface RadioGroupAria {
+    /** Props for the radio group wrapper element. */
+    radioGroupProps: JSX.HTMLAttributes<HTMLDivElement>;
+    /** Props for the radio group's visible label (if any). */
+    labelProps: JSX.HTMLAttributes<HTMLElement>;
+    /** Props for the radio group description element, if any. */
+    descriptionProps: JSX.HTMLAttributes<HTMLElement>;
+    /** Props for the radio group error message element, if any. */
+    errorMessageProps: JSX.HTMLAttributes<HTMLElement>;
+    /** Whether the radio group is invalid. */
+    isInvalid: boolean;
+    /** Validation errors, if any. */
+    validationErrors: string[];
+    /** Validation details, if any. */
+    validationDetails: Record<string, boolean>;
+}
+interface RadioGroupData {
+    name: string;
+    form: string | undefined;
+    descriptionId: string | undefined;
+    errorMessageId: string | undefined;
+    validationBehavior: 'aria' | 'native';
+}
+declare const radioGroupData: WeakMap<RadioGroupState, RadioGroupData>;
+/**
+ * Provides the behavior and accessibility implementation for a radio group component.
+ * Radio groups allow users to select a single item from a list of mutually exclusive options.
+ */
+declare function createRadioGroup(props: MaybeAccessor<AriaRadioGroupProps>, state: RadioGroupState): RadioGroupAria;
+
+/**
+ * Radio hook for Solidaria
+ *
+ * Provides the behavior and accessibility implementation for an individual
+ * radio button in a radio group.
+ *
+ * This is a 1:1 port of @react-aria/radio's useRadio hook.
+ */
+
+interface AriaRadioProps {
+    /** The value of the radio button, used when submitting an HTML form. */
+    value: string;
+    /** Whether the radio button is disabled. */
+    isDisabled?: boolean;
+    /** The label for the radio button. */
+    children?: JSX.Element;
+    /** 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;
+    /** 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;
+    /** Handler that is called when the element is clicked. */
+    onClick?: (e: MouseEvent) => void;
+    /** Handler that is called when the element receives focus. */
+    onFocus?: (e: FocusEvent) => void;
+    /** Handler that is called when the element loses focus. */
+    onBlur?: (e: FocusEvent) => void;
+    /** Handler that is called when the element's focus status changes. */
+    onFocusChange?: (isFocused: boolean) => void;
+    /** 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;
+    /** Whether to autofocus the element. */
+    autoFocus?: boolean;
+}
+interface RadioAria {
+    /** Props for the label wrapper element. */
+    labelProps: JSX.LabelHTMLAttributes<HTMLLabelElement>;
+    /** Props for the input element. */
+    inputProps: JSX.InputHTMLAttributes<HTMLInputElement>;
+    /** Whether the radio is disabled. */
+    isDisabled: boolean;
+    /** Whether the radio is currently selected. */
+    isSelected: Accessor<boolean>;
+    /** Whether the radio is in a pressed state. */
+    isPressed: Accessor<boolean>;
+}
+/**
+ * Provides the behavior and accessibility implementation for an individual
+ * radio button in a radio group.
+ */
+declare function createRadio(props: MaybeAccessor<AriaRadioProps>, state: RadioGroupState, ref: () => HTMLInputElement | null): RadioAria;
+
+/**
+ * Label hook for Solidaria
+ *
+ * Provides the accessibility implementation for labels and their associated elements.
+ * Labels provide context for user inputs.
+ *
+ * This is a 1:1 port of @react-aria/label's useLabel hook.
+ */
+
+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 LabelableProps {
+    /** The content to display as the label. */
+    label?: JSX.Element;
+}
+interface DOMProps {
+    /** The element's unique identifier. */
+    id?: string;
+}
+interface LabelAriaProps extends LabelableProps, DOMProps, AriaLabelingProps {
+    /**
+     * The HTML element used to render the label, e.g. 'label', or 'span'.
+     * @default 'label'
+     */
+    labelElementType?: 'label' | 'span' | 'div';
+}
+interface LabelAria {
+    /** Props to apply to the label container element. */
+    labelProps: JSX.LabelHTMLAttributes<HTMLLabelElement> | JSX.HTMLAttributes<HTMLSpanElement>;
+    /** Props to apply to the field container element being labeled. */
+    fieldProps: AriaLabelingProps & DOMProps;
+}
+/**
+ * Provides the accessibility implementation for labels and their associated elements.
+ * Labels provide context for user inputs.
+ *
+ * @param props - The props for labels and fields.
+ */
+declare function createLabel(props: MaybeAccessor<LabelAriaProps>): LabelAria;
+
+/**
+ * Field hook for Solidaria
+ *
+ * Provides the accessibility implementation for input fields.
+ * Fields accept user input, gain context from their label, and may display
+ * a description or error message.
+ *
+ * This is a 1:1 port of @react-aria/label's useField hook.
+ */
+
+interface HelpTextProps {
+    /** A description for the field. Provides a hint such as specific requirements for what to choose. */
+    description?: JSX.Element;
+    /** An error message for the field. */
+    errorMessage?: JSX.Element | ((validation: ValidationResult) => JSX.Element);
+}
+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 validity state for the input. */
+    validationDetails: ValidityState;
+}
+interface Validation<T> {
+    /** Whether the input value is invalid. */
+    isInvalid?: boolean;
+    /** Whether the input is required before form submission. */
+    isRequired?: boolean;
+    /** A function that returns an error message if a given value is invalid. */
+    validate?: (value: T) => string | string[] | true | null | undefined;
+}
+interface AriaFieldProps extends LabelAriaProps, HelpTextProps, Omit<Validation<any>, 'isRequired'> {
+}
+interface FieldAria extends LabelAria {
+    /** Props for the description element, if any. */
+    descriptionProps: JSX.HTMLAttributes<HTMLElement>;
+    /** Props for the error message element, if any. */
+    errorMessageProps: JSX.HTMLAttributes<HTMLElement>;
+}
+/**
+ * Provides the accessibility implementation for input fields.
+ * Fields accept user input, gain context from their label, and may display
+ * a description or error message.
+ *
+ * @param props - Props for the Field.
+ */
+declare function createField(props: MaybeAccessor<AriaFieldProps>): FieldAria;
+
+/**
+ * Labels utility for Solidaria
+ *
+ * Merges aria-label and aria-labelledby into aria-labelledby when both exist.
+ *
+ * This is a 1:1 port of @react-aria/utils's useLabels hook.
+ */
+
+/**
+ * Merges aria-label and aria-labelledby into aria-labelledby when both exist.
+ *
+ * @param props - Aria label props.
+ * @param defaultLabel - Default value for aria-label when not present.
+ */
+declare function createLabels(props: DOMProps & AriaLabelingProps, defaultLabel?: string): DOMProps & AriaLabelingProps;
+
+/**
+ * SSR utilities for Solidaria
+ *
+ * SolidJS has built-in SSR support with `isServer` and `createUniqueId()`.
+ * These utilities provide a consistent API matching React-Aria's patterns.
+ */
+/**
+ * Returns whether the component is currently being server side rendered.
+ * Can be used to delay browser-specific rendering until after hydration.
+ */
+declare function createIsSSR(): boolean;
+/**
+ * Generate a unique ID that is stable across server and client.
+ * Uses SolidJS's built-in createUniqueId which handles SSR correctly.
+ *
+ * @param defaultId - Optional default ID to use instead of generating one.
+ */
+declare function createId(defaultId?: string): string;
+/**
+ * Check if we can use DOM APIs.
+ * This is useful for code that needs to run only in the browser.
+ */
+declare const canUseDOM: boolean;
+
+/**
+ * Switch hook for Solidaria
+ *
+ * Provides the behavior and accessibility implementation for a switch component.
+ * A switch is similar to a checkbox, but represents on/off values as opposed to selection.
+ *
+ * This is a 1:1 port of @react-aria/switch's useSwitch hook.
+ */
+
+interface AriaSwitchProps extends AriaToggleProps {
+}
+interface SwitchAria {
+    /** Props for the label wrapper element. */
+    labelProps: JSX.LabelHTMLAttributes<HTMLLabelElement>;
+    /** Props for the input element. */
+    inputProps: JSX.InputHTMLAttributes<HTMLInputElement>;
+    /** Whether the switch is selected. */
+    isSelected: Accessor<boolean>;
+    /** Whether the switch is in a pressed state. */
+    isPressed: Accessor<boolean>;
+    /** Whether the switch is disabled. */
+    isDisabled: boolean;
+    /** Whether the switch is read only. */
+    isReadOnly: boolean;
+}
+/**
+ * Provides the behavior and accessibility implementation for a switch component.
+ * A switch is similar to a checkbox, but represents on/off values as opposed to selection.
+ */
+declare function createSwitch(props: MaybeAccessor<AriaSwitchProps>, state: ToggleState, ref: () => HTMLInputElement | null): SwitchAria;
+
+/**
+ * Link hook for Solidaria
+ *
+ * Provides the behavior and accessibility implementation for a link component.
+ * A link allows a user to navigate to another page or resource within a web page
+ * or application.
+ *
+ * This is a 1:1 port of @react-aria/link's useLink hook.
+ */
+
+interface AriaLinkProps {
+    /** Whether the link is disabled. */
+    isDisabled?: boolean;
+    /** The HTML element used to render the link, e.g. 'a', or 'span'. @default 'a' */
+    elementType?: string;
+    /** The URL to link to. */
+    href?: string;
+    /** The target window for the link. */
+    target?: string;
+    /** The relationship between the linked resource and the current page. */
+    rel?: string;
+    /** 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. */
+    onPressEnd?: (e: PressEvent) => void;
+    /** Handler that is called when the element is clicked. */
+    onClick?: (e: MouseEvent) => void;
+    /** Handler that is called when the element receives focus. */
+    onFocus?: (e: FocusEvent) => void;
+    /** Handler that is called when the element loses focus. */
+    onBlur?: (e: FocusEvent) => void;
+    /** Handler that is called when the element's focus status changes. */
+    onFocusChange?: (isFocused: boolean) => void;
+    /** 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;
+    /** Whether to autofocus the element. */
+    autoFocus?: boolean;
+    /** Indicates the current "page" or state within a set of related elements. */
+    'aria-current'?: 'page' | 'step' | 'location' | 'date' | 'time' | 'true' | 'false' | boolean;
+    /** 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;
+}
+interface LinkAria {
+    /** Props for the link element. */
+    linkProps: Record<string, unknown>;
+    /** Whether the link is currently pressed. */
+    isPressed: Accessor<boolean>;
+}
+/**
+ * Provides the behavior and accessibility implementation for a link component.
+ * A link allows a user to navigate to another page or resource within a web page
+ * or application.
+ */
+declare function createLink(props?: MaybeAccessor<AriaLinkProps>): LinkAria;
+
+/**
+ * TextField hook for Solidaria
+ *
+ * Provides the behavior and accessibility implementation for a text field.
+ *
+ * This is a 1:1 port of @react-aria/textfield's useTextField hook.
+ */
+
+interface AriaTextFieldProps extends AriaFieldProps, FocusableProps {
+    /** The current value (controlled). */
+    value?: string;
+    /** The default value (uncontrolled). */
+    defaultValue?: string;
+    /** Handler that is called when the value changes. */
+    onChange?: (value: string) => void;
+    /** Whether the input is disabled. */
+    isDisabled?: boolean;
+    /** Whether the input is read only. */
+    isReadOnly?: boolean;
+    /** Whether the input is required. */
+    isRequired?: boolean;
+    /** The type of input to render. */
+    type?: 'text' | 'search' | 'url' | 'tel' | 'email' | 'password' | string;
+    /** The input mode hint for virtual keyboards. */
+    inputMode?: 'none' | 'text' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search';
+    /** The name of the input element, used when submitting an HTML form. */
+    name?: string;
+    /** Regex pattern to validate the input value. */
+    pattern?: string;
+    /** The maximum number of characters supported by the input. */
+    maxLength?: number;
+    /** The minimum number of characters required by the input. */
+    minLength?: number;
+    /** Placeholder text for the input. */
+    placeholder?: string;
+    /** Whether to enable auto complete. */
+    autoComplete?: string;
+    /** Whether to enable auto correct. */
+    autoCorrect?: string;
+    /** Whether to enable spell check. */
+    spellCheck?: 'true' | 'false';
+    /** Controls whether and how text input is automatically capitalized. */
+    autoCapitalize?: 'off' | 'none' | 'on' | 'sentences' | 'words' | 'characters';
+    /** The element type to use for the input. Defaults to 'input'. */
+    inputElementType?: 'input' | 'textarea';
+    onCopy?: JSX.EventHandler<HTMLInputElement | HTMLTextAreaElement, ClipboardEvent>;
+    onCut?: JSX.EventHandler<HTMLInputElement | HTMLTextAreaElement, ClipboardEvent>;
+    onPaste?: JSX.EventHandler<HTMLInputElement | HTMLTextAreaElement, ClipboardEvent>;
+    onCompositionStart?: JSX.EventHandler<HTMLInputElement | HTMLTextAreaElement, CompositionEvent>;
+    onCompositionEnd?: JSX.EventHandler<HTMLInputElement | HTMLTextAreaElement, CompositionEvent>;
+    onCompositionUpdate?: JSX.EventHandler<HTMLInputElement | HTMLTextAreaElement, CompositionEvent>;
+    onSelect?: JSX.EventHandler<HTMLInputElement | HTMLTextAreaElement, Event>;
+    onBeforeInput?: JSX.EventHandler<HTMLInputElement | HTMLTextAreaElement, InputEvent>;
+    onInput?: JSX.EventHandler<HTMLInputElement | HTMLTextAreaElement, InputEvent>;
+}
+interface TextFieldAria<T extends HTMLInputElement | HTMLTextAreaElement = HTMLInputElement> extends Omit<FieldAria, 'fieldProps'> {
+    /** Props for the input element. */
+    inputProps: JSX.InputHTMLAttributes<T>;
+    /** Whether the text field is invalid. */
+    isInvalid: boolean;
+}
+/**
+ * Provides the behavior and accessibility implementation for a text field.
+ * Text fields allow users to input text with a keyboard.
+ *
+ * @param props - Props for the text field.
+ * @param ref - Optional ref callback for the input element.
+ */
+declare function createTextField<T extends HTMLInputElement | HTMLTextAreaElement = HTMLInputElement>(props: MaybeAccessor<AriaTextFieldProps>, ref?: (el: T) => void): TextFieldAria<T>;
+
+/**
+ * ProgressBar hook for Solidaria
+ *
+ * Provides the accessibility implementation for a progress bar component.
+ * Progress bars show either determinate or indeterminate progress of an operation
+ * over time.
+ *
+ * This is a 1:1 port of @react-aria/progress's useProgressBar hook.
+ */
+
+interface AriaProgressBarProps {
+    /** The current value (controlled). */
+    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 value's label (e.g. 1 of 4). */
+    valueLabel?: string;
+    /** Whether presentation is indeterminate when progress isn't known. */
+    isIndeterminate?: boolean;
+    /** The display format of the value label. */
+    formatOptions?: Intl.NumberFormatOptions;
+    /** The content to display as the label. */
+    label?: string;
+    /** An accessibility label for this item. */
+    '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 ProgressBarAria {
+    /** Props for the progress bar container element. */
+    progressBarProps: Record<string, unknown>;
+    /** Props for the progress bar's visual label element (if any). */
+    labelProps: Record<string, unknown>;
+}
+/**
+ * Provides the accessibility implementation for a progress bar component.
+ * Progress bars show either determinate or indeterminate progress of an operation
+ * over time.
+ */
+declare function createProgressBar(props?: MaybeAccessor<AriaProgressBarProps>): ProgressBarAria;
+
+/**
+ * Merges multiple props objects together, handling event handlers specially
+ * by chaining them rather than replacing.
+ *
+ * Based on react-aria's mergeProps but adapted for SolidJS.
+ */
+declare function mergeProps<T extends object>(...args: T[]): Record<string, unknown>;
+
+/**
+ * filterDOMProps for Solidaria
+ *
+ * Filters out all props that aren't valid DOM props.
+ * This is a 1:1 port of @react-aria/utils filterDOMProps.
+ */
+interface FilterDOMPropsOptions {
+    /**
+     * If labelling associated aria properties should be included in the filter.
+     */
+    labelable?: boolean;
+    /** Whether the element is a link and should include DOM props for <a> elements. */
+    isLink?: boolean;
+    /** Whether to include global DOM attributes. */
+    global?: boolean;
+    /** Whether to include DOM events. */
+    events?: boolean;
+    /**
+     * A Set of other property names that should be included in the filter.
+     */
+    propNames?: Set<string>;
+}
+/**
+ * Filters out all props that aren't valid DOM props or defined via override prop obj.
+ * @param props - The component props to be filtered.
+ * @param opts - Props to override.
+ */
+declare function filterDOMProps(props: Record<string, unknown>, opts?: FilterDOMPropsOptions): Record<string, unknown>;
+
+/**
+ * createSeparator - SolidJS implementation of React Aria's useSeparator
+ *
+ * A separator is a visual divider between two groups of content,
+ * e.g. groups of menu items or sections of a page.
+ */
+
+type Orientation = 'horizontal' | 'vertical';
+interface AriaSeparatorProps {
+    /**
+     * The orientation of the separator.
+     * @default 'horizontal'
+     */
+    orientation?: Orientation;
+    /**
+     * The HTML element type that will be used to render the separator.
+     * @default 'hr'
+     */
+    elementType?: string;
+    /** An accessibility label for the separator. */
+    'aria-label'?: string;
+    /** Identifies the element(s) that labels the separator. */
+    'aria-labelledby'?: string;
+    /** The element's unique identifier. */
+    id?: string;
+}
+interface SeparatorAria {
+    /** Props for the separator element. */
+    separatorProps: JSX.HTMLAttributes<HTMLElement>;
+}
+/**
+ * Provides the accessibility implementation for a separator.
+ * A separator is a visual divider between two groups of content,
+ * e.g. groups of menu items or sections of a page.
+ */
+declare function createSeparator(props?: MaybeAccessor<AriaSeparatorProps>): SeparatorAria;
+
+export { type AriaButtonProps, type AriaCheckboxGroupItemProps, type AriaCheckboxGroupProps, type AriaCheckboxProps, type AriaFieldProps, type AriaLabelingProps, type AriaLinkProps, type AriaProgressBarProps, type AriaRadioGroupProps, type AriaRadioProps, type AriaSeparatorProps, type AriaSwitchProps, type AriaTextFieldProps, type AriaToggleButtonProps, type AriaToggleProps, type ButtonAria, type CheckboxAria, type CheckboxGroupAria, type CreateFocusableProps, type CreateHoverProps, type CreatePressProps, type DOMProps, type FieldAria, type FilterDOMPropsOptions, type FocusRingProps, type FocusRingResult, type FocusableResult, type HelpTextProps, type HoverEvent, type HoverEvents, type HoverResult, type LabelAria, type LabelAriaProps, type LabelableProps, type LinkAria, type MaybeAccessor, type MaybeAccessorValue, type Orientation, PressEvent, type PressResult, type ProgressBarAria, type RadioAria, type RadioGroupAria, type SeparatorAria, type SwitchAria, type TextFieldAria, type ToggleAria, type ToggleButtonAria, type Validation, type ValidationResult, access, canUseDOM, checkboxGroupData, createButton, createCheckbox, createCheckboxGroup, createCheckboxGroupItem, createField, createFocusRing, createFocusable, createHover, createId, createIsSSR, createLabel, createLabels, createLink, createPress, createProgressBar, createRadio, createRadioGroup, createSeparator, createSwitch, createTextField, createToggle, createToggleButton, filterDOMProps, isAccessor, mergeProps, radioGroupData };