export { A as ArrayMinLength1, D as DependencyListTyped, E as ErrorModel, a as ExtractHead, b as ExtractMiddle, c as ExtractTail, K as KeyboardEventCode, L as LanguageBCP47Tags, N as NestedKeyOf, O as Optional, P as PartialRecord, R as RecursivePartial, S as SelectivePartial, T as TypedArray } from './shared/react-tools.Ozx07lAu.mjs';
import { H as HTMLMediaState, a as HTMLMediaControls } from './shared/react-tools.iu1MdjPB.mjs';
export { C as CompareFn } from './shared/react-tools.iu1MdjPB.mjs';
export { X as AlertHandler, Y as BatteryStatus, Z as Bluetooth, _ as BluetoothCharacteristicProperties, $ as BluetoothCharacteristicUUID, a0 as BluetoothDescriptorUUID, a1 as BluetoothDevice, a2 as BluetoothDevicesOptions, a3 as BluetoothRemoteGATTCharacteristic, a4 as BluetoothRemoteGATTDescriptor, a5 as BluetoothRemoteGATTServer, a6 as BluetoothRemoteGATTService, a7 as BluetoothScanFilters, a8 as BluetoothServiceUUID, a9 as CaptureController, aa as ConfirmHandler, ab as DialogHandler, ac as DialogType, ad as DocumentPIPOptions, ae as DocumentPictureInPictureEvent, af as HTMLAttributes, ag as PromptHandler, ah as SpeechGrammar, ai as SpeechGrammarList, aj as SpeechRecognition, ak as SpeechRecognitionConfig, al as SpeechRecognitionControls, am as SpeechRecognitionErrorCode, an as SpeechRecognitionErrorEvent, ao as SpeechRecognitionEvent, ap as SpeechRecognitionState, aq as SpeechSynthesisSpeakParam, ar as TDisplayMediaStreamOptions, as as TPermissionName, at as TPermissionState, au as UseAnimationProps, av as UseAnimationResult, aw as UseBatteryProps, ax as UseBluetoothResult, ay as UseBluetoothState, az as UseBroadcastChannelProps, aA as UseBroadcastChannelResult, aB as UseDebounceFunction, aC as UseDebounceOpts, aD as UseDebounceResult, aE as UseDeviceMotionResult, aF as UseDeviceOrientationResult, aG as UseDisplayMediaResult, aH as UseDocumentPIPProps, aI as UseDocumentPIPResult, aJ as UseEventSourceProps, aK as UseEventSourceResult, aL as UseEyeDropperProps, aM as UseEyeDropperResult, aN as UseFPSProps, aO as UseFPSResult, aP as UseFetchOptions, aQ as UseFetchResult, aR as UseFullscreenProps, aS as UseFullscreenResult, aT as UseGeoLocationResult, aU as UseGeolocationProps, aV as UseIdleCallbackProps, aW as UseIdleCallbackResult, aX as UseIntervalProps, aY as UseIntervalResult, aZ as UseLockResult, a_ as UseMediaDevicesProps, a$ as UseMediaDevicesResult, b0 as UseMediaQueryProps, b1 as UseMediaQueryResult, b2 as UsePIPProps, b3 as UsePIPResult, b4 as UseParallelPromisesOptions, b5 as UseParallelPromisesProps, b6 as UseParallelPromisesResult, b7 as UsePermissionResult, b8 as UsePopoverProps, b9 as UsePopoverResult, ba as UsePublishSubscribeResult, bb as UseRafProps, bc as UseRafResult, bd as UseReducedMotionResult, be as UseRemotePlaybackProps, bf as UseRemotePlaybackResult, bg as UseScreenWakeLockInfo, bh as UseScreenWakeLockProps, bi as UseScreenWakeLockResult, bj as UseScript, bk as UseScriptProps, bl as UseScriptStatus, bm as UseShareResult, bn as UseSpeechRecognitionProps, bo as UseSpeechSynthesis, bp as UseSpeechSynthesisProps, bq as UseTextSelectionProps, br as UseTextSelectionResult, bs as UseThrottleOptions, bt as UseThrottleProps, bu as UseThrottleResult, bv as UseTimeoutProps, bw as UseTimeoutResult, bx as UseTitleProps, by as UseTitleResult, bz as UseVibrateResult, bA as UseWebSocketProps, bB as UseWebSocketResult, bC as UseWebWorkerFnProps, bD as UseWebWorkerFnResult, bE as UseWebWorkerProps, bF as UseWebWorkerResult, u as use, a as useActiveElement, b as useAnimation, c as useAudio, d as useBattery, e as useBluetooth, f as useBroadcastChannel, g as useClipboard, h as useColorScheme, i as useDebounce, j as useDeviceMotion, k as useDeviceOrientation, l as useDialogBox, m as useDisplayMedia, n as useDocumentPIP, o as useEventSource, p as useEyeDropper, q as useFPS, r as useFetch, s as useFullscreen, t as useGeolocation, v as useIdleCallback, w as useInterval, x as useLock, y as useMediaDevices, z as useMediaQuery, A as usePIP, B as useParallelPromises, C as usePermission, D as usePopover, E as usePromise, F as usePublishSubscribe, G as useRaf, H as useReducedMotion, I as useRemotePlayback, J as useScreenWakeLock, K as useScript, L as useShare, M as useSpeechRecognition, N as useSpeechSynthesis, O as useTextSelection, P as useThrottle, Q as useTimeout, R as useTitle, S as useVibrate, T as useVideo, U as useWebSocket, V as useWebWorker, W as useWebWorkerFn } from './shared/react-tools.DXi5tThc.mjs';
export { O as OrientationLockType, S as ScreenDetail, B as ScreenDetails, C as ScreenDetailsEvt, D as SwipeDirection, U as UseBeforeUnloadProps, E as UseBeforeUnloadResult, F as UseClickOutsideProps, G as UseContextMenuProps, H as UseDoubleClickProps, I as UseDoubleClickResult, J as UseEventDispatcherProps, K as UseEventDispatcherResult, L as UseEventsResult, M as UseHotKeysProps, N as UseHotKeysResult, P as UseHoverOptions, Q as UseHoverProps, R as UseInfiniteScrollProps, T as UseInfiniteScrollResult, V as UseIntersectionObserverProps, W as UseIntersectionObserverResult, X as UseLongPressResult, Y as UseMeasureResult, Z as UseMutationObserverProps, _ as UseMutationObserverResult, $ as UseNetworkProps, a0 as UseNetworkResult, a1 as UseNetworkSelectedProps, a2 as UseNetworkSelectedResult, a3 as UsePerformActionProps, a4 as UsePerformActionResult, a5 as UsePointerLockProps, a6 as UsePointerLockResult, a7 as UseResizeObserverProps, a8 as UseResizeObserverResult, a9 as UseResponsiveBreakpoints, aa as UseResponsiveKeys, ab as UseResponsiveResult, ac as UseScreenProps, ad as UseScreenResult, ae as UseScrollIntoViewProps, af as UseScrollIntoViewResult, ag as UseSwipeProps, ah as UseSwipeResult, ai as UseVisibleAttachOptions, aj as UseVisibleOptions, ak as UseVisibleResult, al as UseVisibleWithRatioResult, u as useBeforeUnload, a as useClickOutside, b as useContextMenu, c as useDocumentVisibility, d as useDoubleClick, e as useEventDispatcher, f as useEventListener, g as useEvents, h as useHotKeys, i as useHover, j as useInfiniteScroll, k as useIntersectionObserver, l as useIsOnline, m as useLongPress, am as useLongPressCallback, an as useLongPressOptions, n as useMeasure, o as useMouse, p as useMutationObserver, q as useNetwork, r as usePerformAction, s as usePinchZoom, t as usePointerLock, v as useResizeObserver, w as useResponsive, x as useScreen, y as useScrollIntoView, z as useSwipe, A as useVisible } from './shared/react-tools.Bvi2QJmc.mjs';
import { MediaHTMLAttributes, DetailedReactHTMLElement, HTMLAttributes, MutableRefObject, RefObject, DependencyList, DispatchWithoutAction, Dispatch, SetStateAction, Key, ReactNode } from 'react';
export { U as UseEffectAbortableProps, l as UseIsMountedResult, m as UseLoggerProps, u as useDeferredValue, a as useEffectAbortable, b as useEffectCompare, c as useEffectDeepCompare, d as useEffectOnce, e as useIsMounted, f as useLayoutEffectAbortable, g as useLayoutEffectCompare, h as useLayoutEffectDeepCompare, i as useLayoutEffectOnce, j as useLogger, k as useRerender } from './shared/react-tools.lsM-hhT4.mjs';
export { U as UseCallbackCompareProps, h as UseCallbackCompareResult, i as UseLazyRefProps, j as UseLazyRefResult, k as UseMemoCompareProps, l as UseMemoCompareResult, m as UseMemoizedFnProps, n as UseMemoizedFnResult, o as UseMergedRefProps, p as UseMergedRefResult, u as useCallbackCompare, a as useCallbackDeepCompare, b as useId, c as useLazyRef, d as useMemoCompare, e as useMemoDeepCompare, f as useMemoizedFn, g as useMergedRef } from './shared/react-tools.DFA5Lj7A.mjs';
export { C as CreatePubSubStoreProps, q as CreatePubSubStoreResult, P as PubSubMutators, r as PubSubMutatorsFn, R as ReducerHistoryControls, S as StateHistoryControls, s as StateValidator, t as StorageStateOptions, v as StorageStateReadResult, w as StorageStateReadWriteResult, x as StorageStateWriteResult, U as UseArrayProps, y as UseArrayResult, z as UseDerivedStateProps, A as UseDerivedStateResult, B as UseLocalStorageStateProps, D as UseMapProps, E as UseMapResult, F as UsePreviousProps, G as UsePreviousResult, H as UseProxyStateProps, I as UseProxyStateResult, J as UseReducerGetResetProps, K as UseReducerGetResetResult, L as UseReducerHistoryGetterResult, M as UseReducerHistoryProps, N as UseReducerHistoryResult, O as UseSessionStorageStateProps, Q as UseSetProps, T as UseSetResult, V as UseStateHistoryGetterResult, W as UseStateHistoryProps, X as UseStateHistoryResult, Y as UseStateValidatorProps, Z as UseStateValidatorResult, _ as UseSyncExternalStoreProps, $ as UseSyncExternalStoreResult, c as createPubSubStore, u as useArray, a as useDerivedState, b as useLocalStorageState, d as useMap, e as usePrevious, f as useProxyState, g as useReducerGetReset, h as useReducerHistory, i as useReducerHistoryGetter, j as useSessionStorageState, k as useSet, l as useStateGetReset, m as useStateHistory, n as useStateHistoryGetter, o as useStateValidator, p as useSyncExternalStore } from './shared/react-tools.rir_926J.mjs';
export { A as Activity, C as CaseProps, E as ErrorBoundary, a as ErrorBoundaryProps, b as ErrorBoundaryState, F as For, c as ForMemoized, L as LazyComponent, d as LazyComponentProps, M as MatchOption, e as MatchOptionMemoized, f as MatchProps, O as OptionProps, S as Show, g as ShowMemoized, h as ShowProps, i as Suspense, j as SuspenseProps, k as SuspenseState, l as SwitchCase, m as SwitchCaseMemoized, n as SwitchProps } from './shared/react-tools.D3bLze-F.mjs';
export { C as ChangeStringCaseProps, a as ClickElementOnKeydownEventProps, b as ClickElementOnKeydownEventResult, D as DefaultSerializerProps, c as DetectBrowserResult, G as GetBase64Props, d as GetKeyObjectFromValueProps, e as GetKeyObjectFromValueResult, f as GetObjectFromDottedStringProps, H as HotKeyHandlerProps, g as HotKeyHandlerResult, I as IIsMouseEvent, h as IIsTouchEvent, i as IsAsyncProps, j as IsDeepEqualProps, k as IsShallowEqualProps, L as LazyProps, l as LazyResult, M as MergeObjectsProps, R as RemovePropertiesFromArrayObjectsProps, m as RemovePropertiesFromArrayObjectsResult, T as ToDataURLOptions, U as UseBase64ObjectOptions, n as alphanumericCompare, o as changeStringCase, p as clickElementOnKeydownEvent, q as defaultSerializer, r as detectBrowser, s as getBase64, t as getKeyObjectFromValue, u as getObjectFromDottedString, v as hotKeyHandler, w as isAsync, x as isClient, y as isDeepEqual, z as isMouseEvent, A as isShallowEqual, B as isTouchEvent, E as lazy, F as mergeObjects, J as removePropertiesFromArrayObjects, K as uniqueElementsArray } from './shared/react-tools.DeGTonG3.mjs';
import 'react/jsx-runtime';

/**
 * Props accepted by [useAudio](https://react-tools.ndria.dev/hooks/api-dom/useAudio).
 *
 * These are the standard `HTMLAudioElement` attributes you would normally pass to a `<audio>` tag
 * (e.g. `src`, `autoPlay`, `loop`, `controls`, `muted`, etc.). All attributes are optional.
 *
 * The hook creates the audio element internally and binds these attributes to it, so you do not
 * need to render an `<audio>` tag yourself — use the returned `MediaElement` instead.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/audio
 */
type UseAudioProps = MediaHTMLAttributes<HTMLAudioElement>;
/**
 * Result object returned by [useAudio](https://react-tools.ndria.dev/hooks/api-dom/useAudio).
 */
interface UseAudioResult {
    /**
     * Reactive snapshot of the current audio element state.
     * Re-renders the component whenever a media event fires.
     * See {@link HTMLMediaState} for the full list of fields.
     */
    state: HTMLMediaState;
    /**
     * Imperative control functions for the audio element
     * (play, pause, mute, seek, volume, etc.).
     * All functions are stable references and safe to call in event handlers.
     * See {@link HTMLMediaControls} for the full API.
     */
    controls: HTMLMediaControls;
    /**
     * The React `<audio>` element to render in JSX.
     * Rendering this element is required for the hook to function — it binds the
     * internal ref and event listeners to the DOM node.
     *
     * @example
     * ```tsx
     * const { state, controls, MediaElement } = useAudio({ src: "/song.mp3" });
     * return <div>{MediaElement}</div>;
     * ```
     */
    MediaElement: DetailedReactHTMLElement<HTMLAttributes<HTMLAudioElement>, HTMLAudioElement>;
    /**
     * Direct ref to the underlying `HTMLAudioElement`.
     * Useful for advanced imperative access not covered by `controls`.
     * `null` before the element mounts.
     */
    ref: MutableRefObject<HTMLAudioElement | null>;
}

/**
 * Props accepted by [useVideo](https://react-tools.ndria.dev/hooks/api-dom/useVideo).
 *
 * These are the standard `HTMLVideoElement` attributes you would normally pass to a `<video>` tag
 * (e.g. `src`, `autoPlay`, `loop`, `controls`, `muted`, `playsInline`, `poster`, etc.).
 * All attributes are optional.
 *
 * The hook creates the video element internally and binds these attributes to it, so you do not
 * need to render a `<video>` tag yourself — use the returned `MediaElement` instead.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/video
 */
type UseVideoProps = MediaHTMLAttributes<HTMLVideoElement>;
/**
 * Result object returned by [useVideo](https://react-tools.ndria.dev/hooks/api-dom/useVideo).
 */
interface UseVideoResult {
    /**
     * Reactive snapshot of the current video element state.
     * Re-renders the component whenever a media event fires.
     * See {@link HTMLMediaState} for the full list of fields.
     */
    state: HTMLMediaState;
    /**
     * Imperative control functions for the video element
     * (play, pause, mute, seek, volume, playback rate, etc.).
     * All functions are stable references and safe to call in event handlers.
     * See {@link HTMLMediaControls} for the full API.
     */
    controls: HTMLMediaControls;
    /**
     * The React `<video>` element to render in JSX.
     * Rendering this element is required for the hook to function — it binds the
     * internal ref and event listeners to the DOM node.
     *
     * @example
     * ```tsx
     * const { state, controls, MediaElement } = useVideo({ src: "/movie.mp4", controls: true });
     * return <div>{MediaElement}</div>;
     * ```
     */
    MediaElement: DetailedReactHTMLElement<HTMLAttributes<HTMLVideoElement>, HTMLVideoElement>;
    /**
     * Direct ref to the underlying `HTMLVideoElement`.
     * Useful for advanced imperative access not covered by `controls`
     * (e.g. reading `videoWidth`, `videoHeight`, or calling `requestPictureInPicture`).
     * `null` before the element mounts.
     */
    ref: MutableRefObject<HTMLVideoElement | null>;
}

/**
 * @internal
 */
type PromiseStatus = {
    status: "pending";
    promise: Promise<void>;
} | {
    status: "fulfilled";
    value: unknown;
} | {
    status: "rejected";
    reason: unknown;
};

/**
 * Props accepted by [useClipboard](https://react-tools.ndria.dev/hooks/api-dom/useClipboard).
 */
interface UseClipboardProps {
    /** return a value with current clipboard value or not */
    useValue: boolean;
    /** target on which delimiter handling */
    dataType: "text" | "any";
    /** data type handling. Based on it, Hook will return the functions for writing or reading text only or any type of data. */
    target?: RefObject<HTMLElement> | HTMLElement;
}
/**
 * Result returned by [useClipboard](https://react-tools.ndria.dev/hooks/api-dom/useClipboard).
 * - `[0]` — curren value.
 * - `[1]` — function to write value to the clipboard asynchronously..
 * - `[2]` — function to read value from the clipboard asynchronously. Returns the current clipboard contents.
 *
 * OR
 * - `[0]` — function to write value to the clipboard asynchronously..
 * - `[1]` — function to read value from the clipboard asynchronously. Returns the current clipboard contents.
 */
type UseClipboardResult = [
    /** Current value */
    string,
    /**
     * Write value to the clipboard asynchronously.
     * @param value - The value to copy to the clipboard.
     */
    (value: string) => Promise<void>,
    /** Read value from the clipboard asynchronously. Returns the current clipboard contents. */
    () => Promise<string>
] | [string | Blob | (string | Blob)[], (blob: Blob | Blob[]) => Promise<void>, () => Promise<string | Blob | (string | Blob)[]>] | [(text: string) => Promise<void>, () => Promise<string>] | [(blob: Blob | Blob[]) => Promise<void>, () => Promise<string | Blob | (string | Blob)[]>];

/**
 * Props accepted by [useColorScheme](https://react-tools.ndria.dev/hooks/api-dom/useColorScheme).
 */
interface UseColorSchemeProps {
    /** initial value if _getter_ function isn't present or isn't return a valid value. */
    defaultValue: "dark" | "light" | "mediaQuery";
    /** an optional function used to initialize current value. For example, it can be useful for reading the value from an attribute of an html file or from localStorage */
    getter?: () => "dark" | "light" | null | undefined;
    /** an optional function, which should work in conjunction with the _getter_ function, to run when the color scheme changes to save the value for future runs. */
    setter?: (schema: "light" | "dark") => void;
    /** if true returns only a function to manually change the color scheme value. */
    returnValue: boolean;
}
/**
 * Result returned by [useColorScheme](https://react-tools.ndria.dev/hooks/api-dom/useColorScheme).
 * - `[0]` — curren color schema value.
 * - `[1]` — function to update value.
 *
 * OR
 * - `[0]` — function to update value.
 */
type UseColorSchemeResult = [
    /**curren color schema value */
    "light" | "dark",
    /**
     * function to update value
     * @param value - The value to update.
     */
    (schema: "light" | "dark") => void
] | ((schema: "light" | "dark") => void);

/**
 * Parameters accepted by [usePromise](https://react-tools.ndria.dev/hooks/api-dom/usePromise).
 *
 * @template T - The resolved value type of the promise returned by `promise`.
 */
type UsePromiseProps<T> = {
    /**
     * A zero-argument factory function that returns the `Promise` to resolve.
     * Invoked on the first render and again whenever `deps` changes or the cache
     * is invalidated. The component suspends while the promise is pending, and
     * re-renders with the resolved value once it fulfills.
     */
    promise: () => Promise<T>;
    /**
     * A React dependency array (same semantics as `useEffect`). When any dependency
     * changes, the cached result is considered stale and `promise` is re-invoked on
     * the next render.
     */
    deps: DependencyList;
    /**
     * Optional configuration that controls caching, error handling, and invalidation behaviour.
     */
    options?: UsePromiseOptions;
};
/**
 * Options accepted by {@link usePromise}.
 */
type UsePromiseOptions = {
    /**
     * Controls how long the resolved result is retained in the module-level cache:
     * - **`"unmount"`** — The cache entry is deleted when the component unmounts,
     *   forcing a fresh fetch on the next mount.
     * - **`number`** — A time-to-live in **seconds**. The entry expires that many
     *   seconds after the promise resolves and is re-fetched on the next render.
     * - **`undefined`** *(default)* — The entry persists indefinitely for the
     *   lifetime of the module.
     */
    cache?: "unmount" | number;
    /**
     * When `true`, a rejected promise automatically removes its cache entry after a
     * short delay (~20 ms), allowing the factory to be retried on the next render
     * instead of permanently surfacing the error to the nearest `<ErrorBoundary>`.
     * Defaults to `false`.
     */
    cleanOnError?: boolean;
    /**
     * An explicit string key used to identify this promise in the module-level cache.
     * - When provided, this value is used as the cache key instead of the serialised
     *   `promise.toString()` representation, which may be unreliable after minification.
     * - Providing a stable identifier is strongly recommended in production builds.
     */
    identifier?: string;
    /**
     * Controls whether the hook exposes a manual invalidation callback:
     * - **`true`** — The hook returns `[T, () => void]`: the resolved value paired with
     *   an `invalidate` function that clears the cache entry and triggers a re-render,
     *   causing the factory to be re-invoked.
     * - **`false` | `undefined`** *(default)* — The hook returns `T` directly, with no
     *   invalidation handle exposed.
     */
    invalidateManually?: boolean;
};
/**
 * Return value of [usePromise](https://react-tools.ndria.dev/hooks/api-dom/usePromise) when `invalidateManually` is `true`.
 *
 * @template T - The resolved value type of the promise.
 */
type UsePromiseResultWithInvalidate<T> = [
    /**
     * The resolved value of the promise. Only accessible after the promise fulfills;
     * the component suspends while pending and throws for `<ErrorBoundary>` on rejection.
     */
    T,
    /**
     * A stable callback that clears the cache entry for this promise and triggers a
     * re-render, causing the factory to be re-invoked on the next render cycle.
     * Useful for manual cache invalidation after a mutation or user action.
     */
    () => void
];

/**
 * Parameters accepted by all overloads of [useEventListener](https://react-tools.ndria.dev/hooks/events/useEventListener).
 *
 * @template T - The event type key (e.g. `"click"`, `"keydown"`). Must be a key of `DocumentEventMap`, `HTMLElementEventMap`, `WindowEventMap`, or an arbitrary string for custom events.
 * @template E - The element type the listener is attached to.
 */
type UseEventListenerProps<T extends string, E extends Element = Element> = {
    /**
     * The event type or array of event types to listen for (e.g. `"click"` or
     * `["mouseenter", "mouseleave"]`). All types in the array share the same
     * `listener` callback.
     */
    type: T | T[];
    /**
     * The event handler invoked whenever one of the specified event types fires.
     * May return a value or a `Promise` — the return value is ignored by the hook.
     */
    listener: (evt: Event) => unknown | Promise<unknown>;
    /**
     * The target on which the listener is registered. Accepts a React
     * `RefObject<E>`, a direct element reference, or `Window`.
     * Defaults to `window` when omitted.
     */
    element?: RefObject<E> | E | Window;
    /**
     * Options forwarded to `addEventListener` as the third argument. Accepts either
     * a boolean shorthand for `capture` or a full {@link AddEventListenerOptions}
     * object. When omitted, the listener is registered with the browser defaults.
     */
    listenerOpts?: boolean | AddEventListenerOptions;
    /**
     * Controls which React effect hook is used to register the event listener:
     * - **`"normal"`** *(default)* — Uses `useEffect`, which runs asynchronously
     *   after the browser has painted.
     * - **`"layout"`** — Uses `useLayoutEffect`, which runs synchronously after
     *   DOM mutations but before the browser paints. Prefer this when the listener
     *   needs to read or modify layout immediately.
     */
    effectType?: "normal" | "layout";
};
/**
 * Return value of [useEventListener](https://react-tools.ndria.dev/hooks/events/useEventListener).
 *
 * A stable cleanup function that manually removes all registered event listeners
 * from the target element. Calling it is optional — the hook cleans up
 * automatically on unmount — but useful to detach listeners earlier on demand.
 */
type UseEventListenerResult = () => void;

/**
 * Options for the [useMouse](https://react-tools.ndria.dev/hooks/events/useMouse).
 */
interface UseMouseOpts {
    /**
     * Coordinate space to report pointer positions in.
     * - `"client"` — relative to the viewport (default).
     * - `"page"` — relative to the full page (includes scroll offset).
     * - `"screen"` — relative to the physical screen.
     * @default "client"
     */
    type?: "client" | "page" | "screen";
    /**
     * When provided, `x` and `y` are returned relative to this element's bounding rect
     * rather than the selected coordinate space. The element's `DOMRect` is also returned
     * as `relativeElementDim`.
     */
    relativeElement?: RefObject<HTMLElement | null> | HTMLElement;
}
/**
 * Result object returned by [useMouse](https://react-tools.ndria.dev/hooks/events/useMouse).
 */
interface UseMouseResult {
    /** Current horizontal pointer coordinate. `null` before the first pointer event. */
    x: number | null;
    /** Current vertical pointer coordinate. `null` before the first pointer event. */
    y: number | null;
    /**
     * Bounding rect of the `relativeElement` at the time of the last pointer event.
     * Only present when `relativeElement` is provided to the hook.
     */
    relativeElementDim?: DOMRect;
}

/**
 * Return value of [useRerender](https://react-tools.ndria.dev/hooks/lifecycle/useRerender), which varies based on the `withValue` argument.
 *
 * | `withValue`           | Return type                   | Description                                                      |
 * | --------------------- | ----------------------------- | ---------------------------------------------------------------- |
 * | `false` / `undefined` | `DispatchWithoutAction`       | A bare dispatch function with no state value exposed.            |
 * | `true`                | `[T, DispatchWithoutAction]`  | A tuple of the render counter value and the dispatch function.   |
 *
 * @template T - The type of the internal counter value. Only relevant when `withValue` is `true` — ignored in the `DispatchWithoutAction` overload.
 */
type UseRerenderResult<T> = DispatchWithoutAction | [
    /**
     * The current render counter value. Incremented each time the dispatch
     * function is called, allowing consumers to track how many forced re-renders
     * have occurred or to use the value as a reactive dependency.
     */
    T,
    /**
     * A stable dispatch function that increments the internal counter and
     * triggers a re-render of the component when called.
     */
    DispatchWithoutAction
];

/**
 * Parameters accepted by [useStateGetReset](https://react-tools.ndria.dev/hooks/state/useStateGetReset).
 *
 * @template T - The type of the state value.
 */
type UseStateGetResetProps<T> = {
    /**
     * The initial state value. Accepts either a direct value or a lazy initializer
     * function invoked only on the first render, avoiding unnecessary re-creation
     * of the initial value on subsequent renders. When omitted, the state is
     * initialised as `undefined`.
     */
    initialState?: T | (() => T);
};
/**
 * Return value of [useStateGetReset](https://react-tools.ndria.dev/hooks/state/useStateGetReset).
 *
 * @template T - The type of the state value.
 */
type UseStateGetResetResult<T> = [
    /** The current state value, reactive — triggers a re-render when updated. */
    T | undefined,
    /**
     * A stable setter (same semantics as the setter returned by `useState`).
     * Accepts either a new value or an updater function receiving the current
     * state and returning the next.
     */
    Dispatch<SetStateAction<T | undefined>>,
    /**
     * A stable getter that returns the current state value synchronously without
     * causing a re-render. Useful for reading state inside callbacks without
     * adding it as a dependency.
     */
    () => T | undefined,
    /**
     * Resets the state back to `initialState`, triggering a re-render.
     */
    () => void
];

/**
 * Props accepted by the [For](https://react-tools.ndria.dev/components/For) component
 * @template T - The type of the elements in the source array `of`.
 * @template S - The mapped element type after applying `map`. Defaults to `T` when `map` is omitted.
 */
interface ForProps<T, S extends T = T> {
    /**
     * The source array to iterate over. Each element is passed to `children`
     * after optional `filter`, `sort`, and `map` transformations are applied.
     */
    of: Array<T>;
    /**
     * Determines the React `key` assigned to each rendered element:
     * - When `T` (or `S`) is an **object** — a key of that object or a function
     *   `(item) => Key` deriving a key from the item.
     * - When `T` (or `S`) is a **primitive** — a direct `Key` value or a
     *   function `(item) => Key`.
     * When omitted, the element's index is used as the key.
     */
    elementKey?: (T | S) extends object ? keyof (T | S) | ((item: T | S) => Key) : Key | ((item: T | S) => Key);
    /**
     * A render function called for each element in the (optionally transformed)
     * array. Receives the current item, its index, and the computed React key.
     */
    children: (item: T | S, index: number, key: Key) => ReactNode;
    /**
     * Content rendered when the source array `of` is empty (after any `filter`
     * has been applied). Accepts any valid React node.
     */
    fallback?: ReactNode;
    /**
     * An optional filter predicate applied to the source array before rendering,
     * following the same signature as `Array.prototype.filter`. Elements for
     * which the predicate returns `false` are excluded.
     */
    filter?: Parameters<Array<T>["filter"]>[0];
    /**
     * An optional sort configuration applied after filtering:
     * - **`true`** — Uses the default sort order.
     * - **comparator function** — A custom `(a, b) => number` comparator,
     *   following the same signature as `Array.prototype.sort`.
     */
    sort?: true | Parameters<Array<T>["sort"]>[0];
    /**
     * An optional mapping function applied after filtering and sorting,
     * transforming each element from `T` to `S` before passing it to `children`.
     * When omitted, elements are passed as-is (`S` equals `T`).
     */
    map?: (...args: Parameters<Parameters<Array<T>["map"]>[0]>) => S;
}

/**
 * Parameters accepted by all overloads of [alphanumericCompare](https://react-tools.ndria.dev/utils/alphanumericCompare).
 */
type AlphanumericCompareProps = {
    /**
     * The first string to compare.
     */
    string1: string;
    /**
     * The second string to compare.
     */
    string2: string;
    /**
     * Controls the return type and comparison mode:
     * - **`undefined`** *(default)* — Returns a numeric sort order value
     *   (`-1`, `0`, or `1`), following the same semantics as
     *   `Intl.Collator.prototype.compare`.
     * - **`"<"` | `">"` | `"="` | `">="` | `"<="`** — Returns a `boolean`
     *   indicating whether the comparison satisfies the given operator.
     */
    compareType?: "<" | ">" | "=" | ">=" | "<=";
    /**
     * A BCP 47 language tag or array of tags forwarded to `Intl.Collator`.
     * Determines locale-sensitive string ordering rules (e.g. `"en"`, `"de"`,
     * `"it"`). When omitted, the runtime default locale is used.
     */
    locales?: Intl.LocalesArgument;
    /**
     * Options forwarded to the `Intl.Collator` constructor, allowing fine-grained
     * control over sensitivity, case handling, numeric ordering, and more.
     * See {@link Intl.CollatorOptions}.
     */
    opts?: Intl.CollatorOptions;
};

/**
 * Parameters accepted by all overloads of [uniqueElementsArray](https://react-tools.ndria.dev/utils/uniqueElementsArray).
 *
 * @template T - The element type of the input arrays.
 */
type UniqueElementsArrayProps<T> = {
    /**
     * The property key (or array of keys) used to determine uniqueness when `T`
     * is an object. Pass `"none"` to compare elements by value (identity for
     * primitives, referential equality for objects).
     */
    property: keyof T | (keyof T)[] | "none";
    /**
     * One or more arrays whose elements are merged and deduplicated. Duplicates
     * are determined by the `property` strategy.
     */
    args: (T[])[];
};
/**
 * Return value of [uniqueElementsArray](https://react-tools.ndria.dev/utils/uniqueElementsArray).
 *
 * A new array containing only unique elements from all provided input arrays,
 * preserving the order of first occurrence.
 *
 * @template T - The element type.
 */
type UniqueElementsArrayResult<T> = T[];

/**
 * Parameters accepted by [useEffectEvent](https://react-tools.ndria.dev/hooks/lifecycle/useEffectEvent).
 *
 * @template T - The type of the event handler function. Must be callable with any arguments and return any value.
 */
type UseEffectEventProps<T extends (...args: any[]) => any> = {
    /**
     * The event handler function to wrap. The returned stable wrapper always
     * delegates to the latest version of `fn` captured at render time, so it
     * is safe to read props, state, or context without being listed as an
     * effect dependency.
     */
    fn: T;
};
/**
 * Return value of [useEffectEvent](https://react-tools.ndria.dev/hooks/lifecycle/useEffectEvent).
 *
 * A stable function with the same signature as `fn`. Its identity never
 * changes between renders, making it safe to pass as a non-reactive
 * dependency to effects. Internally it always delegates to the latest
 * version of `fn`, so the handler always reads fresh props and state
 * without triggering effect re-runs.
 *
 * @template T - The type of the original handler function.
 */
type UseEffectEventResult<T extends (...args: any[]) => any> = T;

export { HTMLMediaControls, HTMLMediaState };
export type { AlphanumericCompareProps, ForProps, PromiseStatus, UniqueElementsArrayProps, UniqueElementsArrayResult, UseAudioProps, UseAudioResult, UseClipboardProps, UseClipboardResult, UseColorSchemeProps, UseColorSchemeResult, UseEffectEventProps, UseEffectEventResult, UseEventListenerProps, UseEventListenerResult, UseMouseOpts, UseMouseResult, UsePromiseOptions, UsePromiseProps, UsePromiseResultWithInvalidate, UseRerenderResult, UseStateGetResetProps, UseStateGetResetResult, UseVideoProps, UseVideoResult };