@necto-react/hooks 2.6.0 → 2.10.0

package/dist/index.d.cts

@@ -0,0 +1,1000 @@
+import { ForwardedRef, Context, HTMLAttributes, RefObject, FocusEvent, ReactNode, CSSProperties } from 'react';
+import { DisabledFlags, FocusEvents, DOMAttributes, FocusableDOMProps, HoverEvent, KeyboardEvents, RenderProps } from '@necto-react/types';
+import { FocusableElement, PressEvent } from '@necto/types';
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Props for the useContextProps hook.
+ */
+interface UseContextPropsProps<T, E extends Element> {
+    /**
+     * Component props, must include optional slot property and optional ref.
+     */
+    props: T & {
+        /**
+         * The slot name to retrieve from the context. If null, context is not used.
+         */
+        slot?: string | null;
+        /**
+         * Optional forwarded ref for the component.
+         */
+        ref?: ForwardedRef<E>;
+    };
+    /**
+     * Forwarded ref for the component (from React.forwardRef).
+     */
+    ref: ForwardedRef<E>;
+    /**
+     * React context to retrieve slot values from.
+     * The context value can be:
+     *   - an object with `slots` (mapping slot names to values)
+     *   - a value of the same type as props (with optional ref)
+     *   - null or undefined
+     */
+    context: Context<{
+        slots?: Record<string | symbol, T & {
+            slot?: string | null;
+            ref?: ForwardedRef<E>;
+        }>;
+    } | (T & {
+        slot?: string | null;
+        ref?: ForwardedRef<E>;
+    }) | null | undefined>;
+}
+/**
+ * Return type for the useContextProps hook.
+ */
+type UseContextPropsReturn<T, E extends Element> = [
+    T,
+    (value: E | null) => void
+];
+
+/**
+ * React hook that merges props and refs from both component and context, including styles.
+ *
+ * @template T The props type.
+ * @template E The element type.
+ * @param {UseContextPropsProps<T, E>} params - Component props, ref, and context.
+ * @returns {UseContextPropsReturn<T, E>} A tuple of merged props and merged ref.
+ */
+declare function useContextProps<T, E extends Element>({ props, ref, context }: UseContextPropsProps<T, E>): UseContextPropsReturn<T, E>;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Props for the useDisabled hook.
+ */
+interface UseDisabledProps {
+    /** The key of the disabled flag to check. Defaults to 'general'. */
+    type?: keyof DisabledFlags;
+    /** The fallback value if the flag is not set. Defaults to false. */
+    defaultFallback?: boolean;
+}
+/**
+ * Return type for the useDisabled hook.
+ */
+type UseDisabledPropsReturn = boolean;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * React hook to determine if a specific feature or component type is disabled.
+ *
+ * @param {keyof DisabledFlags} type - The key of the disabled flag to check. Defaults to 'general'.
+ * @param {boolean} defaultFallback - The fallback value if the flag is not set. Defaults to false.
+ * @returns {boolean} True if the specified type is disabled, otherwise the fallback value.
+ */
+declare function useDisabled(props?: UseDisabledProps): UseDisabledPropsReturn;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Props for the useDisabledProps hook.
+ */
+interface UseDisabledPropsProps {
+    /** The key of the disabled flag to check. Defaults to 'general'. */
+    type?: keyof DisabledFlags;
+    /** Additional props to merge with the disabled attributes. */
+    extraProps?: HTMLAttributes<HTMLElement>;
+}
+/**
+ * Return type for the useDisabledProps hook.
+ */
+type UseDisabledPropsPropsReturn = HTMLAttributes<HTMLElement>;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Returns HTML props with appropriate disabled attributes based on the disabled state.
+ *
+ * @param {UseDisabledPropsOptions} options - Options for the hook.
+ * @returns {HTMLAttributes<HTMLElement>} The merged props including disabled and aria-disabled if applicable.
+ */
+declare function useDisabledProps(props?: UseDisabledPropsProps): UseDisabledPropsPropsReturn;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+/**
+ * Indicates whether partial visibility is allowed, or specifies the edge(s) to check for partial visibility.
+ */
+type PartialVisibility = boolean | 'top' | 'right' | 'bottom' | 'left';
+/**
+ * Props for the useElementVisibility hook.
+ */
+interface UseElementVisibilityProps {
+    /** Whether partial visibility is allowed, or which edge to check. */
+    partialVisibility?: PartialVisibility;
+    /** The threshold(s) at which to trigger the observer callback. */
+    threshold?: number | number[];
+    /** Margin around the root element. Can shrink or grow each side of the root element's bounding box. */
+    rootMargin?: string;
+    /** The element that is used as the viewport for checking visibility. */
+    root?: Element | Document | null;
+    /** Whether the visibility check is active. */
+    active?: boolean;
+    /** Whether the visibility state should persist once element becomes visible. */
+    once?: boolean;
+    /** Callback fired when the visibility state changes. */
+    onChange?: (isVisible: boolean) => void;
+}
+/** Intersection details provided by IntersectionObserver. */
+interface IntersectionDetails {
+    /** Whether the element is intersecting with the root. */
+    isIntersecting: boolean;
+    /** The ratio of the intersection area to the bounding box of the target. */
+    intersectionRatio: number;
+    /** The rectangle describing the intersection between the target and root. */
+    intersectionRect: DOMRectReadOnly;
+    /** The bounding rectangle of the target element. */
+    boundingClientRect: DOMRectReadOnly;
+    /** The bounding rectangle of the root element. */
+    rootBounds: DOMRectReadOnly | null;
+    /** The time at which the intersection was recorded. */
+    time: number;
+}
+/**
+ * Return type for the useElementVisibility hook.
+ */
+type UseElementVisibilityReturn<T extends Element = Element> = [
+    (node: T | null) => void,
+    boolean,
+    IntersectionDetails | null
+];
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * React hook that observes the visibility of a DOM element using the Intersection Observer API.
+ *
+ * @template T The type of the element being observed.
+ * @param {UseElementVisibilityProps} [props] - Options to control visibility observation and callbacks.
+ * @returns {UseElementVisibilityReturn<T>} A tuple containing the ref to the element, the visibility state, and intersection details.
+ */
+declare function useElementVisibility<T extends Element = Element>(props?: UseElementVisibilityProps): UseElementVisibilityReturn<T>;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Props for the useFocus hook.
+ */
+interface UseFocusProps<T = FocusableElement> extends FocusEvents<T> {
+    /** Whether focus events are disabled. */
+    isDisabled?: boolean;
+}
+/**
+ * Return type for the useFocus hook.
+ */
+interface UseFocusReturn<T = FocusableElement> {
+    /** Props that can be spread onto a focusable DOM element. */
+    focusProps?: DOMAttributes<T>;
+}
+
+/**
+ * Portions of this file are based on code from the React Aria Spectrum library by Adobe,
+ * licensed under the Apache License, Version 2.0.
+ * Copyright (c) Adobe. All rights reserved.
+ * See: https://github.com/adobe/react-spectrum
+ *
+ * Modifications copyright (c) Corinvo, LLC. and affiliates. All rights reserved.
+ *
+ * This file contains code licensed under:
+ * - The MIT License (see LICENSE in the root directory) for Corinvo modifications.
+ * - The Apache License, Version 2.0 for portions from Adobe.
+ *
+ * Modifications have been made to adapt the code for use in this project.
+ */
+
+/**
+ * React hook that manages focus and blur event handling for a focusable element.
+ *
+ * @template T The type of the focusable element.
+ * @param {UseFocusProps<T>} [props] - Options and event handlers for focus management.
+ * @returns {UseFocusReturn<T>} An object containing props to spread on the target element for focus management.
+ */
+declare function useFocus<T extends FocusableElement = FocusableElement>(props?: UseFocusProps<T>): UseFocusReturn<T>;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+interface UseFocusableProps extends FocusableDOMProps, FocusEvents {
+    isDisabled?: boolean;
+    autoFocus?: boolean;
+}
+type UseFocusableReturn = {};
+
+/**
+ * Portions of this file are based on code from the React Aria Spectrum library by Adobe,
+ * licensed under the Apache License, Version 2.0.
+ * Copyright (c) Adobe. All rights reserved.
+ * See: https://github.com/adobe/react-spectrum
+ *
+ * Modifications copyright (c) Corinvo, LLC. and affiliates. All rights reserved.
+ *
+ * This file contains code licensed under:
+ * - The MIT License (see LICENSE in the root directory) for Corinvo modifications.
+ * - The Apache License, Version 2.0 for portions from Adobe.
+ *
+ * Modifications have been made to adapt the code for use in this project.
+ */
+
+/**
+ * React hook that provides focus management and keyboard accessibility for a focusable element.
+ * Handles autofocus, disabled state, tab order, and merges focus and keyboard props.
+ *
+ * @param {UseFocusableProps} props - Props controlling focus behavior and accessibility.
+ * @param {RefObject<FocusableElement | null>} domRef - Ref to the DOM element to manage focus for.
+ * @returns {UseFocusableReturn} Object containing merged props for focusable behavior.
+ */
+declare function useFocusable(props: UseFocusableProps, domRef: RefObject<FocusableElement | null>): UseFocusableReturn;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Props for the useFocusRing hook.
+ */
+interface UseFocusRingProps {
+    /** Whether to track focus visibility within a subtree instead of just the element. */
+    within?: boolean;
+    /** Whether the target element is a text input. */
+    isTextInput?: boolean;
+    /** Whether the element should automatically receive focus when mounted. */
+    autoFocus?: boolean;
+}
+/**
+ * Return value for the useFocusRing hook.
+ */
+interface UseFocusRingReturn {
+    /** Whether the element is currently focused. */
+    isFocused: boolean;
+    /** Whether the focus is visible (e.g., due to keyboard navigation). */
+    isFocusVisible: boolean;
+    /** Props to spread onto the target element to enable focus ring behavior. */
+    focusProps: DOMAttributes;
+}
+
+/**
+ * Portions of this file are based on code from the React Aria Spectrum library by Adobe,
+ * licensed under the Apache License, Version 2.0.
+ * Copyright (c) Adobe. All rights reserved.
+ * See: https://github.com/adobe/react-spectrum
+ *
+ * Modifications copyright (c) Corinvo, LLC. and affiliates. All rights reserved.
+ *
+ * This file contains code licensed under:
+ * - The MIT License (see LICENSE in the root directory) for Corinvo modifications.
+ * - The Apache License, Version 2.0 for portions from Adobe.
+ *
+ * Modifications have been made to adapt the code for use in this project.
+ */
+
+/**
+ * React hook that manages focus state and focus ring visibility for an element.
+ *
+ * @param {UseFocusRingProps} [props] - Options to control focus ring behavior.
+ * @returns {UseFocusRingReturn} An object containing focus state, focus visibility, and props to spread on the target element.
+ */
+declare function useFocusRing(props?: UseFocusRingProps): UseFocusRingReturn;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+/**
+ * Props for the useFocusVisible hook.
+ */
+interface UseFocusVisibleProps {
+    /** Whether the target element is a text input. */
+    isTextInput?: boolean;
+    /** Whether the element should automatically receive focus when mounted. */
+    autoFocus?: boolean;
+}
+/**
+ * Return value for the useFocusVisible hook.
+ */
+interface UseFocusVisibleReturn {
+    /** Whether focus is currently visible (e.g., due to keyboard navigation). */
+    isFocusVisible: boolean;
+}
+
+/**
+ * Portions of this file are based on code from the React Aria Spectrum library by Adobe,
+ * licensed under the Apache License, Version 2.0.
+ * Copyright (c) Adobe. All rights reserved.
+ * See: https://github.com/adobe/react-spectrum
+ *
+ * Modifications copyright (c) Corinvo, LLC. and affiliates. All rights reserved.
+ *
+ * This file contains code licensed under:
+ * - The MIT License (see LICENSE in the root directory) for Corinvo modifications.
+ * - The Apache License, Version 2.0 for portions from Adobe.
+ *
+ * Modifications have been made to adapt the code for use in this project.
+ */
+
+/**
+ * React hook that provides focus visibility tracking.
+ *
+ * @param {UseFocusVisibleProps} [props] - Options for focus visibility behavior.
+ * @returns {UseFocusVisibleReturn} An object containing the focus visibility state.
+ */
+declare function useFocusVisible(props?: UseFocusVisibleProps): UseFocusVisibleReturn;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+/**
+ * Represents the type of user interaction modality that triggered focus.
+ *
+ * - 'keyboard': Focus was triggered via keyboard input (e.g., Tab key).
+ * - 'pointer': Focus was triggered via pointer input (e.g., mouse, touch).
+ * - 'virtual': Focus was triggered programmatically or by assistive technology.
+ */
+type Modality = 'keyboard' | 'pointer' | 'virtual';
+/**
+ * Props for the useFocusVisibleListener hook.
+ */
+interface UseFocusVisibleListenerProps {
+    /** Function called when focus visibility changes. */
+    fn: (isFocusVisible: boolean) => void;
+    /** Dependency array that determines when to rebind the listener. */
+    deps: ReadonlyArray<any>;
+    /** Additional options for focus visibility tracking. */
+    opts?: {
+        isTextInput?: boolean;
+    };
+}
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Returns the current interaction modality.
+ *
+ * @returns {Modality | null} The current interaction modality (keyboard, pointer, or virtual) or null if unknown.
+ */
+declare function getInteractionModality(): Modality | null;
+
+/**
+ * React hook that listens for focus visibility changes based on interaction modality.
+ *
+ * @param {UseFocusVisibleListenerProps} props - The props for the focus visible listener.
+ * @returns {void}
+ */
+declare function useFocusVisibleListener(props: UseFocusVisibleListenerProps): void;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Props for the useFocusWithin hook.
+ */
+interface UseFocusWithinProps {
+    /** Whether the focus events should be disabled. */
+    isDisabled?: boolean;
+    /** Handler that is called when focus enters the element or its descendants. */
+    onFocusWithin?: (e: FocusEvent) => void;
+    /** Handler that is called when focus leaves the element or its descendants. */
+    onBlurWithin?: (e: FocusEvent) => void;
+    /** Handler that is called when the focus state within the element changes. */
+    onFocusWithinChange?: (isFocusWithin: boolean) => void;
+}
+/**
+ * The result returned by the useFocusWithin hook.
+ */
+interface FocusWithinReturn {
+    /** Props to spread onto the target element to enable focus within tracking. */
+    focusWithinProps: DOMAttributes;
+}
+
+/**
+ * Portions of this file are based on code from the React Aria Spectrum library by Adobe,
+ * licensed under the Apache License, Version 2.0.
+ * Copyright (c) Adobe. All rights reserved.
+ * See: https://github.com/adobe/react-spectrum
+ *
+ * Modifications copyright (c) Corinvo, LLC. and affiliates. All rights reserved.
+ *
+ * This file contains code licensed under:
+ * - The MIT License (see LICENSE in the root directory) for Corinvo modifications.
+ * - The Apache License, Version 2.0 for portions from Adobe.
+ *
+ * Modifications have been made to adapt the code for use in this project.
+ */
+
+declare function useFocusWithin(props: UseFocusWithinProps): FocusWithinReturn;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+/**
+ * Interface for managing global event listeners with enhanced type safety.
+ */
+interface UseGlobalListenersReturn {
+    /**
+     * Adds a global event listener to the specified element.
+     *
+     * @param el The target element.
+     * @param type The event type.
+     * @param listener The event listener function.
+     * @param options Optional options.
+     */
+    addGlobalListener<K extends keyof WindowEventMap | keyof DocumentEventMap>(el: Window | EventTarget, type: K, listener: (this: Document, ev: K extends keyof WindowEventMap ? WindowEventMap[K] : K extends keyof DocumentEventMap ? DocumentEventMap[K] : never) => void, options?: boolean | AddEventListenerOptions): void;
+    /**
+     * Adds a global event listener to the specified element.
+     *
+     * @param el The target element.
+     * @param type The event type.
+     * @param listener The event listener function or object.
+     * @param options Optional options.
+     */
+    addGlobalListener(el: EventTarget, type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    /**
+     * Removes a global event listener from the specified element.
+     *
+     * @param el The target element.
+     * @param type The event type.
+     * @param listener The event listener function.
+     * @param options Optional options.
+     */
+    removeGlobalListener<K extends keyof WindowEventMap & keyof DocumentEventMap>(el: Window | EventTarget, type: K, listener: (this: Document, ev: K extends keyof WindowEventMap ? WindowEventMap[K] : DocumentEventMap[K]) => void, options?: boolean | EventListenerOptions): void;
+    /**
+     * Removes a global event listener from the specified element.
+     *
+     * @param el The target element.
+     * @param type The event type.
+     * @param listener The event listener function or object.
+     * @param options Optional options.
+     */
+    removeGlobalListener(el: EventTarget, type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    /**
+     * Removes all global event listeners.
+     */
+    removeAllGlobalListeners(): void;
+}
+
+/**
+ * Portions of this file are based on code from the React Aria Spectrum library by Adobe,
+ * licensed under the Apache License, Version 2.0.
+ * Copyright (c) Adobe. All rights reserved.
+ * See: https://github.com/adobe/react-spectrum
+ *
+ * Modifications copyright (c) Corinvo, LLC. and affiliates. All rights reserved.
+ *
+ * This file contains code licensed under:
+ * - The MIT License (see LICENSE in the root directory) for Corinvo modifications.
+ * - The Apache License, Version 2.0 for portions from Adobe.
+ *
+ * Modifications have been made to adapt the code for use in this project.
+ */
+
+declare function useGlobalListeners(): UseGlobalListenersReturn;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Props for the useHover hook.
+ */
+interface UseHoverProps extends HoverEvent {
+    /** Whether hover events are disabled. */
+    isDisabled?: boolean;
+    /** Called when a hover interaction starts. */
+    onHoverStart?: (event: HoverEvent) => void;
+    /** Called when a hover interaction ends. */
+    onHoverEnd?: (event: HoverEvent) => void;
+    /** Called when the hover state changes. */
+    onHoverChange?: (isHovered: boolean) => void;
+}
+/**
+ * Return type for the useHover hook.
+ */
+interface UseHoverReturn {
+    /** Props that can be passed on to render in the DOM. */
+    hoverProps: DOMAttributes;
+    /** Wether the current context is hovered or not. */
+    isHovered: boolean;
+}
+
+/**
+ * React hook that manages hover state and hover event handlers for an element.
+ *
+ * @param {UseHoverProps} [props] - Options to control hover behavior and event handlers.
+ * @returns {UseHoverReturn} An object containing hover state and props to spread on the target element.
+ */
+declare function useHover(props?: UseHoverProps): UseHoverReturn;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+/**
+ * Props for the useId hook.
+ */
+interface UseIdProps {
+    /** Optional custom prefix for the generated ID. */
+    prefix?: string;
+    /** Optional default ID to use instead of generating one. */
+    defaultId?: string;
+}
+
+/**
+ * Generates a unique, stable ID for React components, optionally with a custom prefix.
+ *
+ * @param {UseIdProps} [props] - Optional props object. You can provide a custom prefix and/or a defaultId.
+ * @returns {UseIdReturns} The generated or provided unique ID.
+ */
+declare function useId(props?: UseIdProps): string;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Props for the useKeyboard hook.
+ */
+interface UseKeyboardProps extends KeyboardEvents {
+    /**
+     * Whether the keyboard interaction is disabled.
+     * Defaults to false.
+     */
+    isDisabled?: boolean;
+}
+/**
+ * Return value of the useKeyboard hook.
+ */
+interface UseKeyboardReturn {
+    /**
+     * Props to be spread onto the target element to enable keyboard interactions.
+     */
+    keyboardProps: DOMAttributes;
+}
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * React hook that provides keyboard event handlers based on the disabled state.
+ *
+ * @param {UseKeyboardProps} props - Props controlling keyboard interaction.
+ * @returns {UseKeyboardReturn} Object containing keyboard event handler props.
+ */
+declare function useKeyboard(props: UseKeyboardProps): UseKeyboardReturn;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Specifies how the mounted state should be accessed.
+ */
+type MountedAccessType = 'function' | 'ref' | 'boolean';
+/**
+ * Props for the useMounted hook.
+ */
+interface UseMountedProps {
+    /** The type of access to the mounted state. */
+    type?: MountedAccessType;
+}
+/**
+ * Return type for the useMounted hook, varies based on the access type.
+ *
+ * - 'ref': Returns a RefObject containing the mounted state
+ * - 'boolean': Returns a boolean value directly
+ * - 'function': Returns a function that returns the current mounted state
+ */
+type UseMountedReturn<T extends MountedAccessType> = T extends 'ref' ? RefObject<boolean> : T extends 'boolean' ? boolean : () => boolean;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * React hook that tracks whether a component is mounted.
+ *
+ * @template T The type of access to the mounted state (function, ref, or boolean).
+ * @param {UseMountedProps & { type: T }} [props] - Options to configure the hook behavior.
+ * @returns {UseMountedReturn<T>} The mounted state in the requested format.
+ */
+declare function useMounted<T extends MountedAccessType = 'function'>(props?: UseMountedProps & {
+    type: T;
+}): UseMountedReturn<T>;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Props for the usePress hook.
+ */
+interface UsePressProps {
+    /** Whether the press interaction is disabled. */
+    isDisabled?: boolean;
+    /** Prevents the element from receiving focus when pressed. */
+    preventFocusOnPress?: boolean;
+    /** Allows text selection during press interactions. */
+    allowTextSelectionOnPress?: boolean;
+    /** Ref to the target DOM element. */
+    ref?: RefObject<HTMLElement>;
+    /** Handler called when a press interaction is successfully completed. */
+    onPress?: (e: PressEvent) => void;
+    /** Handler called when a press interaction starts (e.g., mouse down, touch start, key down). */
+    onPressStart?: (e: PressEvent) => void;
+    /** Handler called when a press interaction ends (e.g., mouse up, touch end, key up). */
+    onPressEnd?: (e: PressEvent) => void;
+    /** Handler called when the pressed state changes. */
+    onPressChange?: (isPressed: boolean) => void;
+    /** Handler called when a press is released over the target. */
+    onPressUp?: (e: PressEvent) => void;
+    /** Handler called on click events for compatibility. */
+    onClick?: (e: MouseEvent) => void;
+}
+/**
+ * Return type for the usePress hook.
+ */
+interface UsePressReturn {
+    /** Props to spread onto the target element to enable press interactions. */
+    pressProps: {
+        onMouseDown?: (e: MouseEvent) => void;
+        onMouseUp?: (e: MouseEvent) => void;
+        onMouseLeave?: (e: MouseEvent) => void;
+        onMouseEnter?: (e: MouseEvent) => void;
+        onTouchStart?: (e: TouchEvent) => void;
+        onTouchEnd?: (e: TouchEvent) => void;
+        onKeyDown?: (e: KeyboardEvent) => void;
+        onKeyUp?: (e: KeyboardEvent) => void;
+        onClick?: (e: MouseEvent) => void;
+    };
+    /** Whether the element is currently pressed. */
+    isPressed: boolean;
+}
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Provides press (mouse, touch, keyboard) interaction logic for UI components.
+ * Handles accessibility, text selection, and emulated event quirks for consistent press behavior.
+ *
+ * @param {UsePressProps} props - Configuration options and event handlers for the press interaction.
+ * @returns {UsePressReturn} An object containing press event props to spread onto your element and the current pressed state.
+ */
+declare function usePress(props?: UsePressProps): UsePressReturn;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Props for the useRendererHook
+ */
+interface UseRendererProps<T> extends RenderProps<T> {
+    id?: string;
+    values: T;
+    defaultChildren?: ReactNode;
+    defaultClassName?: string;
+    defaultStyle?: CSSProperties;
+    [dataAttr: `data-${string}`]: string | undefined;
+}
+/**
+ * Return type for the useRenderer hook.
+ */
+interface UseRendererReturn {
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+}
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+declare function useRenderer<T>(props: UseRendererProps<T>): UseRendererReturn;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Props for the useSlottedContext hook.
+ */
+interface UseSlottedContextProps<T> {
+    /**
+     * The React context to consume, which may be a slotted context value or a direct value.
+     */
+    context: Context<{
+        slots?: Record<string | symbol, T>;
+    } | T | null | undefined>;
+    /**
+     * The slot name to retrieve from the context. If null, context is not used.
+     */
+    slot?: string | null;
+}
+/**
+ * Return type for the useSlottedContext hook.
+ */
+type UseSlottedContextReturn<T> = T | null | undefined;
+
+/**
+ * Portions of this file are based on code from the React Aria Spectrum library by Adobe,
+ * licensed under the Apache License, Version 2.0.
+ * Copyright (c) Adobe. All rights reserved.
+ * See: https://github.com/adobe/react-spectrum
+ *
+ * Modifications copyright (c) Corinvo, LLC. and affiliates. All rights reserved.
+ *
+ * This file contains code licensed under:
+ * - The MIT License (see LICENSE in the root directory) for Corinvo modifications.
+ * - The Apache License, Version 2.0 for portions from Adobe.
+ *
+ * Modifications have been made to adapt the code for use in this project.
+ */
+
+/**
+ * Retrieves a value from a React context, optionally using a named slot.
+ * Returns the slot value if available, the direct context value, or null/undefined.
+ * Throws an error if a specified slot does not exist in the context.
+ *
+ * @param {UseSlottedContextProps<T>} props - The context and optional slot name.
+ * @returns {UseSlottedContextReturn<T>} The value for the given slot, the direct context value, or null/undefined.
+ */
+declare function useSlottedContext<T>(props: UseSlottedContextProps<T>): UseSlottedContextReturn<T>;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Props for synchronizing a context ref with a local ref.
+ *
+ * @template T The type of the element or value referenced.
+ */
+interface UseSyncContextRefProps<T> {
+    /**
+     * Optional context object containing a ref to synchronize.
+     */
+    context?: {
+        ref?: RefObject<T | null>;
+    };
+    /**
+     * Optional local ref to synchronize with the context ref.
+     */
+    ref?: RefObject<T | null>;
+}
+
+/**
+ * Portions of this file are based on code from the React Aria Spectrum library by Adobe,
+ * licensed under the Apache License, Version 2.0.
+ * Copyright (c) Adobe. All rights reserved.
+ * See: https://github.com/adobe/react-spectrum
+ *
+ * Modifications copyright (c) Corinvo, LLC. and affiliates. All rights reserved.
+ *
+ * This file contains code licensed under:
+ * - The MIT License (see LICENSE in the root directory) for Corinvo modifications.
+ * - The Apache License, Version 2.0 for portions from Adobe.
+ *
+ * Modifications have been made to adapt the code for use in this project.
+ */
+
+declare function useSyncContextRef<T>(props?: UseSyncContextRefProps<T>): void;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Props for the useSyntheticBlurEvent hook.
+ */
+interface UseSyntheticBlurEventProps<T extends Element = Element> {
+    /**
+     * Handler called when the blur event is triggered on the target element.
+     * Receives a React FocusEvent for the target element.
+     */
+    onBlur: (event: FocusEvent<T>) => void;
+}
+/**
+ * Return type for the useSyntheticBlurEvent hook.
+ */
+type UseSyntheticBlurEventReturn<T> = (event: FocusEvent<T>) => void;
+
+/**
+ * Portions of this file are based on code from the React Aria Spectrum library by Adobe,
+ * licensed under the Apache License, Version 2.0.
+ * Copyright (c) Adobe. All rights reserved.
+ * See: https://github.com/adobe/react-spectrum
+ *
+ * Modifications copyright (c) Corinvo, LLC. and affiliates. All rights reserved.
+ *
+ * This file contains code licensed under:
+ * - The MIT License (see LICENSE in the root directory) for Corinvo modifications.
+ * - The Apache License, Version 2.0 for portions from Adobe.
+ *
+ * Modifications have been made to adapt the code for use in this project.
+ */
+
+/**
+ * React hook to handle synthetic blur events, particularly for disabled elements.
+ *
+ * @param onBlur - Callback to handle the blur event.
+ * @returns A callback to attach to the element's blur event.
+ */
+declare function useSyntheticBlurEvent<T extends Element = Element>(props: UseSyntheticBlurEventProps<T>): UseSyntheticBlurEventReturn<T>;
+
+/**
+ * Returns a stable event callback that always invokes the latest version of the provided function.
+ *
+ * @param {T} fn - The event handler function to stabilize.
+ * @returns {T} A memoized callback that always calls the latest version of `fn`.
+ */
+declare function useEffectEvent<T extends (...args: any[]) => any>(fn: T): T;
+
+/**
+ * Copyright (c) Corinvo, LLC. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+/**
+ * React hook that determines if a browser feature is supported.
+ *
+ * @param {() => unknown} fn - Function that tests for feature support.
+ * @returns {boolean} Whether the feature is supported in the current environment.
+ */
+declare function useSupported(fn: () => unknown): boolean;
+
+export { type FocusWithinReturn, type UseContextPropsProps, type UseContextPropsReturn, type UseDisabledProps, type UseDisabledPropsProps, type UseDisabledPropsPropsReturn, type UseDisabledPropsReturn, type UseElementVisibilityProps, type UseElementVisibilityReturn, type UseFocusProps, type UseFocusReturn, type UseFocusRingProps, type UseFocusRingReturn, type UseFocusVisibleListenerProps, type UseFocusVisibleProps, type UseFocusVisibleReturn, type UseFocusWithinProps, type UseFocusableProps, type UseFocusableReturn, type UseGlobalListenersReturn, type UseHoverProps, type UseHoverReturn, type UseIdProps, type UseMountedProps, type UseMountedReturn, type UsePressProps, type UsePressReturn, type UseRendererProps, type UseRendererReturn, type UseSlottedContextProps, type UseSlottedContextReturn, type UseSyncContextRefProps, type UseSyntheticBlurEventProps, type UseSyntheticBlurEventReturn, getInteractionModality, useContextProps, useDisabled, useDisabledProps, useEffectEvent, useElementVisibility, useFocus, useFocusRing, useFocusVisible, useFocusVisibleListener, useFocusWithin, useFocusable, useGlobalListeners, useHover, useId, useKeyboard, useMounted, usePress, useRenderer, useSlottedContext, useSupported, useSyncContextRef, useSyntheticBlurEvent };