import * as react from 'react';
import { RefObject, PropsWithChildren, AriaAttributes, DOMAttributes, ComponentPropsWithRef, RefCallback, DependencyList } from 'react';
import { L as LanguageBCP47Tags, T as TypedArray } from './react-tools.Ozx07lAu.cjs';
import { H as HTMLMediaState } from './react-tools.C7sRw3h-.cjs';

/**
 * Props for the [useScript](https://react-tools.ndria.dev/hooks/api-dom/useScript).
 */
interface UseScriptProps {
    /** HTML `<script>` element attributes to set on the injected script tag. */
    attributes: {
        /** URL of the external script to load (`src` attribute). */
        src?: string;
        /**
         * When `true`, the script is downloaded in parallel and executed as soon as it is available,
         * without blocking HTML parsing.
         */
        async?: boolean;
        /** Cross-origin request mode for the script. */
        crossorigin?: "anonymous" | "use-credentials" | "";
        /**
         * When `true`, the script is executed after the document has been parsed but before
         * the `DOMContentLoaded` event fires.
         */
        defer?: boolean;
        /** Fetch priority hint for the resource. */
        fetchpriority?: "high" | "low" | "auto";
        /** Subresource Integrity (SRI) hash for validating the fetched script. */
        integrity?: string;
        /** When `true`, the script is not executed in browsers that support ES modules. */
        nomodule?: boolean;
        /** Cryptographic nonce for use with a Content Security Policy. */
        nonce?: string;
        /** Referrer policy to use when fetching the script. */
        referrerpolicy?: "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
        /** MIME type of the script. Use `"module"` for ES module scripts. */
        type?: string;
    };
    /** Behavioural options for the hook itself. */
    options: {
        /**
         * When `true`, the hook manages appending and removing the `<script>` element.
         * @default true
         */
        handleAppending?: boolean;
        /**
         * When `true`, the `<script>` element is removed from the DOM when the component unmounts.
         * @default false
         */
        removeOnUnmount?: boolean;
        /**
         * When provided, the script is injected into the document of this `<iframe>` instead of
         * the main document.
         */
        iframe?: HTMLIFrameElement;
    };
}
/**
 * Loading status of the script, returned as the first element of `useScript`'s result tuple.
 */
type UseScriptStatus = "idle" | "loading" | "error" | "ready";
/**
 * Function signature for the [useScript](https://react-tools.ndria.dev/hooks/api-dom/useScript).
 */
interface UseScript {
    (attributes: UseScriptProps["attributes"], options: UseScriptProps["options"]): [
        /** Current loading status of the script. */
        status: UseScriptStatus,
        /**
         * Reload the script with optional updated attributes.
         * @param attributes - New `<script>` attributes to apply before reloading.
         * @param iframe - Target iframe for reloading (overrides the constructor option).
         */
        (attributes?: UseScriptProps["attributes"], iframe?: HTMLIFrameElement) => void,
        /** Remove the `<script>` element from the DOM. */
        () => void
    ];
}

/**
 * Parameters accepted by [useTextSelection](https://react-tools.ndria.dev/hooks/api-dom/useTextSelection).
 */
type UseTextSelectionProps = {
    /**
     * The element within which text selection is tracked. Accepts either a React
     * `RefObject<HTMLElement>` or a direct `HTMLElement` reference.
     * When omitted, selection is tracked globally on `document.body`.
     */
    target?: RefObject<HTMLElement> | HTMLElement;
    /**
     * Called when the user begins a selection gesture inside the target element
     * (on `pointerdown`). Also fired when the pointer re-enters the target while
     * a selection is already in progress and no text is currently selected.
     */
    onStart?: (evt: Event) => void;
    /**
     * Called on every `selectionchange` event while a selection gesture is active
     * inside the target element. Registered on `document` for the duration of the
     * gesture and removed on `pointerup` or `pointerleave`.
     */
    onChange?: (evt: Event) => void;
    /**
     * Called when the selection gesture ends inside the target element (on `pointerup`
     * or `pointerleave`), after the final {@link TextSelection} value has been computed
     * and the reactive state has been updated.
     */
    onEnd?: (evt: Event) => void;
};
/**
 * Text selection state returned by [useTextSelection](https://react-tools.ndria.dev/hooks/api-dom/useTextSelection).
 * Updated whenever the user changes the text selection in the document.
 */
type UseTextSelectionResult = null | {
    /** The raw text content of the current selection (equivalent to `Selection.toString()`). */
    text: string;
    /**
     * Direction of the selection relative to the anchor point.
     * - `"forward"` — the user dragged from left to right / top to bottom.
     * - `"backward"` — the user dragged from right to left / bottom to top.
     */
    direction: "forward" | "backward";
    /**
     * Bounding rectangle that fully encloses the entire selection, even when it spans
     * multiple lines or nodes. Equivalent to the union of all `innerRectangles`.
     */
    outsideRectangle: DOMRect;
    /**
     * Array of `DOMRect` objects, one per text line or range fragment.
     * Use these for fine-grained positioning (e.g. rendering a floating toolbar aligned
     * to each line of a multi-line selection).
     */
    innerRectangles: DOMRect[];
};

/**
 * Reactive state snapshot of the device's battery, returned by `useBattery`.
 * All properties are updated automatically via Battery Status API events.
 */
interface BatteryStatus {
    /** `true` when the Battery Status API is available in the current browser/environment. */
    isSupported: boolean;
    /**
     * Current battery charge level as a value between `0.0` (empty) and `1.0` (full).
     * Multiply by 100 to get a percentage.
     */
    level: number;
    /** `true` when the battery is currently being charged. */
    charging: boolean;
    /**
     * Estimated seconds remaining until the battery is fully charged.
     * `Infinity` when the battery is not charging or the time cannot be determined.
     */
    chargingTime: number;
    /**
     * Estimated seconds of remaining battery life.
     * `Infinity` when the battery is charging or the time cannot be determined.
     */
    dischargingTime: number;
}
/**
 * Configuration object accepted by [useBattery](https://react-tools.ndria.dev/hooks/api-dom/useBattery).
 *
 * All callback properties mirror the Battery Status API events. They are optional — omit any
 * you don't need.
 *
 */
interface UseBatteryProps {
    /**
     * Called when the battery's `charging` state changes
     * (i.e. the charger is plugged in or unplugged).
     * @param evt - The native `chargingchange` event.
     */
    onCharging?: (evt: Event) => void;
    /**
     * Called when the estimated time until the battery is fully charged changes.
     * @param evt - The native `chargingtimechange` event.
     */
    onChargingTime?: (evt: Event) => void;
    /**
     * Called when the estimated remaining battery life changes.
     * @param evt - The native `dischargingtimechange` event.
     */
    onDischargingTime?: (evt: Event) => void;
    /**
     * Called when the battery level changes.
     * @param evt - The native `levelchange` event.
     */
    onLevel?: (evt: Event) => void;
}

/**
 * Props accepted by [useGeolocation](https://react-tools.ndria.dev/hooks/api-dom/useGeolocation).
 */
interface UseGeolocationProps {
    /**
     * it establishes how to obtain the geographic location:
     * - __current__: it gets the location when invoked.
     * - __observer__: it gets the current position every time it changes.
     * - __manual__: to obtain the location it need to invoke functions returned from hook.
     */
    mode: "observe" | "current" | "manual";
    /**
     * Called when the Geolocation API returns an error (permission denied, unavailable, timeout, etc.).
     * @param error - The `GeolocationPositionError` describing the failure.
     */
    onError?: (error: GeolocationPositionError) => void;
    /**
     * Options forwarded directly to `Geolocation.getCurrentPosition` /
     * `Geolocation.watchPosition`.
     * Common options: `{ enableHighAccuracy: true, timeout: 5000, maximumAge: 0 }`.
     */
    locationOptions?: PositionOptions;
}
/**
 * Result tuple returned by [useGeolocation](https://react-tools.ndria.dev/hooks/api-dom/useGeolocation).
 *
 */
type UseGeoLocationResult = [
    /** `location` - possible states of the Geolocation API: supported (with an optional position) or not supported. */
    ({
        /** `true` — the Geolocation API is supported in the current browser/environment. */
        isSupported: true;
        /**
         * The most recent `GeolocationPosition` object, containing `coords` (latitude, longitude,
         * accuracy, etc.) and a `timestamp`. `undefined` before the first position is obtained
         * or if the user denies permission.
         */
        position?: GeolocationPosition;
    }) | ({
        /** `false` — the Geolocation API is not supported; `position` is never set. */
        isSupported: false;
        position?: never;
    }),
    /** `currentPosition` — function to obtain manually current location. */
    () => Promise<void>,
    /** `observerPosition` — function to obtain location on every changes. */
    () => Promise<() => void>
];

/**
 * Reactive snapshot of the device motion sensor data, returned by [useDeviceMotion](https://react-tools.ndria.dev/hooks/api-dom/useDeviceMotion).
 * Values are updated whenever the browser fires `devicemotion` events.
 */
interface UseDeviceMotionResult {
    /** `true` when the `DeviceMotionEvent` API is supported and permission has been granted. */
    isSupported: boolean;
    /**
     * Acceleration of the device along `x`, `y`, and `z` axes in m/s², **excluding** the
     * effect of gravity. `null` when not available or not supported.
     */
    acceleration: DeviceMotionEventAcceleration | null;
    /**
     * Acceleration of the device along `x`, `y`, and `z` axes in m/s², **including** the
     * contribution of gravity (approximately `9.8 m/s²` on the z-axis at rest).
     * `null` when not available or not supported.
     */
    accelerationIncludingGravity: DeviceMotionEventAcceleration | null;
    /**
     * Rate of rotation around each axis in degrees per second (`alpha`, `beta`, `gamma`).
     * `null` when not available or not supported.
     */
    rotationRate: DeviceMotionEventRotationRate | null;
    /**
     * Interval in milliseconds at which data is obtained from the hardware sensor.
     * `null` when not available.
     */
    interval: number | null;
}

/**
 * Reactive snapshot of the device orientation sensor data, returned by [useDeviceOrientation](https://react-tools.ndria.dev/hooks/api-dom/useDeviceOrientation).
 * Values are updated whenever the browser fires `deviceorientation` events.
 */
interface UseDeviceOrientationResult {
    /** `true` when the `DeviceOrientationEvent` API is supported and permission has been granted. */
    isSupported: boolean;
    /**
     * `true` when the orientation data is provided relative to the Earth's coordinate frame
     * (absolute orientation). `false` when it is relative to some arbitrary frame.
     * `null` when the property is not available.
     */
    absolute: boolean | null;
    /**
     * Rotation around the Z axis (compass heading) in degrees in the range `[0, 360)`.
     * `null` when not available.
     */
    alpha: number | null;
    /**
     * Rotation around the X axis (front-to-back tilt) in degrees in the range `[-180, 180]`.
     * Positive values indicate the top of the device is tilted away from the user.
     * `null` when not available.
     */
    beta: number | null;
    /**
     * Rotation around the Y axis (left-to-right tilt) in degrees in the range `[-90, 90]`.
     * Positive values indicate the right side of the device is tilted down.
     * `null` when not available.
     */
    gamma: number | null;
}

/**
 * The `navigator.bluetooth` interface, extended with the `requestDevice` method.
 * Used internally by `useBluetooth`.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/API/Bluetooth
 */
interface Bluetooth extends EventTarget {
    /**
     * Prompts the user to select a Bluetooth device matching the provided options.
     * @param opts - Filter options (services, device name, etc.).
     * @returns A Promise resolving to the selected `BluetoothDevice`, or a `TypeError`/`DOMException` on failure.
     */
    requestDevice: (opts?: BluetoothDevicesOptions) => Promise<BluetoothDevice | TypeError | DOMException>;
}
/**
 * Options passed to `Bluetooth.requestDevice()`.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/API/Bluetooth/requestDevice
 */
interface BluetoothDevicesOptions {
    /**
     * Array of scan filters. The browser only shows devices that match at least one filter.
     * Each filter can specify `services`, `name`, and/or `namePrefix`.
     */
    filters?: BluetoothScanFilters[];
    /**
     * Array of additional GATT service UUIDs that the requesting script wants to access,
     * beyond those specified in `filters`.
     */
    optionalServices?: BluetoothServiceUUID[];
    /**
     * When `true`, the browser shows all discoverable Bluetooth devices regardless of filters.
     * Use with caution — requires user consent for every device.
     * @default false
     */
    acceptAllDevices?: boolean;
}
/** A UUID identifying a Bluetooth GATT service. Can be a 16-bit short UUID (number) or a full 128-bit UUID string. */
type BluetoothServiceUUID = number | string;
/** A UUID identifying a Bluetooth GATT characteristic. */
type BluetoothCharacteristicUUID = number | string;
/** A UUID identifying a Bluetooth GATT descriptor. */
type BluetoothDescriptorUUID = number | string;
/**
 * Represents a Bluetooth device inside the current script execution environment.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/API/BluetoothDevice
 */
interface BluetoothDevice {
    /** A unique string identifying the device across sessions in the same origin. */
    readonly id: string;
    /** Human-readable name provided by the device (e.g. `"My Headphones"`). */
    readonly name: string;
    /** Reference to the device's primary GATT server. Use this to discover services and characteristics. */
    readonly gatt: BluetoothRemoteGATTServer;
}
/**
 * Represents a GATT Server hosted on a remote Bluetooth device.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/API/BluetoothRemoteGATTServer
 */
interface BluetoothRemoteGATTServer {
    /**
     * `true` while this script execution environment is connected to the device.
     * Note: may be `false` even when the physical connection is still alive.
     */
    readonly connected: boolean;
    /** The `BluetoothDevice` this server belongs to. */
    readonly device: BluetoothDevice;
    /**
     * Establishes a GATT connection to the device.
     * @returns A Promise that resolves to this `BluetoothRemoteGATTServer` on success.
     */
    connect: () => Promise<BluetoothRemoteGATTServer>;
    /** Disconnects from the remote GATT server. */
    disconnect: () => void;
    /**
     * Returns a Promise to the primary GATT service with the given UUID.
     * @param uuid - The service UUID to look up.
     */
    getPrimaryService: (uuid: BluetoothServiceUUID) => Promise<BluetoothRemoteGATTService>;
    /**
     * Returns a Promise to all primary GATT services with the given UUID.
     * @param uuid - The service UUID to look up.
     */
    getPrimaryServices: (uuid: BluetoothServiceUUID) => Promise<BluetoothRemoteGATTService[]>;
}
/**
 * Represents a GATT service on a remote Bluetooth device.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/API/BluetoothRemoteGATTService
 */
interface BluetoothRemoteGATTService {
    /** The `BluetoothDevice` this service belongs to. */
    readonly device: BluetoothDevice;
    /** `true` if this is a primary service; `false` if it is secondary. */
    readonly isPrimary: boolean;
    /** UUID string identifying this service (e.g. `"0000180d-0000-1000-8000-00805f9b34fb"`). */
    readonly uuid: BluetoothServiceUUID;
    /**
     * Returns a Promise to the characteristic with the given UUID within this service.
     * @param uuid - The characteristic UUID.
     */
    getCharacteristic: (uuid: BluetoothCharacteristicUUID) => Promise<BluetoothRemoteGATTCharacteristic>;
    /**
     * Returns a Promise to all characteristics with the given UUID within this service.
     * @param uuid - The characteristic UUID.
     */
    getCharacteristics: (uuid: BluetoothCharacteristicUUID) => Promise<BluetoothRemoteGATTCharacteristic[]>;
}
/**
 * Represents a GATT Characteristic, the basic data element of a Bluetooth service.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/API/BluetoothRemoteGATTCharacteristic
 */
interface BluetoothRemoteGATTCharacteristic extends EventTarget {
    /** The `BluetoothRemoteGATTService` this characteristic belongs to. */
    readonly service: BluetoothRemoteGATTService;
    /** UUID string identifying this characteristic (e.g. `"00002a37-0000-1000-8000-00805f9b34fb"`). */
    readonly uuid: BluetoothCharacteristicUUID;
    /** Object describing which operations (read, write, notify, etc.) are permitted. */
    readonly properties: BluetoothCharacteristicProperties;
    /** The most recently cached value, updated on read or via notification/indication. */
    readonly value: ArrayBuffer;
    /** Event handler called when the characteristic value changes (notification/indication). */
    oncharacteristicvaluechanged: (evt: EventTarget) => void;
    /**
     * Returns the first GATT descriptor with the given UUID.
     * @param uuid - The descriptor UUID.
     */
    getDescriptor: (uuid: BluetoothDescriptorUUID) => Promise<BluetoothRemoteGATTDescriptor>;
    /**
     * Returns all GATT descriptors with the given UUID.
     * @param uuid - The descriptor UUID.
     */
    getDescriptors: (uuid: BluetoothDescriptorUUID) => Promise<BluetoothRemoteGATTDescriptor[]>;
    /** Reads and returns the current value of the characteristic. */
    readValue: () => Promise<DataView>;
    /**
     * Writes a value to the characteristic (response optional).
     * @deprecated Use `writeValueWithResponse` or `writeValueWithoutResponse` instead.
     */
    writeValue: (value: ArrayBuffer) => Promise<void>;
    /**
     * Writes a value and waits for confirmation from the device.
     * @param value - The binary data to write.
     */
    writeValueWithResponse: (value: ArrayBuffer) => Promise<void>;
    /**
     * Writes a value without requesting confirmation from the device.
     * @param value - The binary data to write.
     */
    writeValueWithoutResponse: (value: ArrayBuffer) => Promise<void>;
    /** Subscribes to value change notifications for this characteristic. */
    startNotifications: () => Promise<BluetoothRemoteGATTCharacteristic>;
    /** Unsubscribes from value change notifications for this characteristic. */
    stopNotifications: () => Promise<void>;
}
/**
 * Permission flags describing which operations are allowed on a GATT characteristic.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/API/BluetoothCharacteristicProperties
 */
interface BluetoothCharacteristicProperties {
    /** `true` if authenticated signed writes are permitted. */
    readonly authenticatedSignedWrites: boolean;
    /** `true` if broadcasting the value via the Server Characteristic Configuration Descriptor is permitted. */
    readonly broadcast: boolean;
    /** `true` if indications (acknowledged notifications) are permitted. */
    readonly indicate: boolean;
    /** `true` if notifications (unacknowledged) are permitted. */
    readonly notify: boolean;
    /** `true` if reading the characteristic value is permitted. */
    readonly read: boolean;
    /** `true` if reliable writes are permitted. */
    readonly reliableWrite: boolean;
    /** `true` if writing to the characteristic descriptor is permitted. */
    readonly writableAuxiliaries: boolean;
    /** `true` if writing with response is permitted. */
    readonly write: boolean;
    /** `true` if writing without response is permitted. */
    readonly writeWithoutResponse: boolean;
}
/**
 * Represents a GATT Descriptor, providing additional metadata about a characteristic's value.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/API/BluetoothRemoteGATTDescriptor
 */
interface BluetoothRemoteGATTDescriptor {
    /** The characteristic this descriptor is attached to. */
    characteristic: BluetoothRemoteGATTCharacteristic;
    /** UUID string of this descriptor (e.g. `"00002902-0000-1000-8000-00805f9b34fb"` for CCCD). */
    uuid: BluetoothDescriptorUUID;
    /** The most recently cached descriptor value. Updated on read. */
    value: ArrayBuffer;
    /** Reads and returns the current descriptor value. */
    readValue: () => Promise<ArrayBuffer>;
    /**
     * Writes a value to the descriptor.
     * @param value - The binary data to write.
     */
    writeValue: (value: ArrayBuffer) => Promise<void>;
}
/**
 * Scan filter for `Bluetooth.requestDevice()`.
 * A device matches if it satisfies at least one of the provided filters.
 *
 * Each variant requires at least one of: `name`, `namePrefix`, or `services`.
 */
type BluetoothScanFilters = {
    name: string;
    namePrefix: string;
    services: BluetoothServiceUUID[];
} | {
    name: string;
    namePrefix?: never;
    services?: never;
} | {
    name: string;
    namePrefix: string;
    services?: never;
} | {
    name: string;
    namePrefix?: never;
    services: BluetoothServiceUUID[];
} | {
    name?: never;
    namePrefix: string;
    services: BluetoothServiceUUID[];
} | {
    name?: never;
    namePrefix?: never;
    services: BluetoothServiceUUID[];
} | {
    name?: never;
    namePrefix: string;
    services?: never;
};
/**
 * Reactive state snapshot returned as the first element of [useBluetooth](https://react-tools.ndria.dev/hooks/api-dom/useBluetooth)'s tuple.
 *
 */
interface UseBluetoothState {
    /**
     * `true` when the Web Bluetooth API (`navigator.bluetooth`) is available in the current browser.
     * When `false`, `requestDevice` will not open a picker.
     */
    isSupported: boolean;
    /**
     * `true` when a GATT connection to a device is currently active.
     * Becomes `false` after `server.disconnect()` is called or the device goes out of range.
     */
    isConnected: boolean;
    /**
     * The selected `BluetoothDevice` returned by the browser's device picker.
     * `null` before the user selects a device or after disconnection.
     */
    device: BluetoothDevice | null;
    /**
     * The `BluetoothRemoteGATTServer` for the selected device.
     * Use this to discover services and characteristics.
     * `null` until a GATT connection is established.
     */
    server: BluetoothRemoteGATTServer | null;
}
/**
 * Result tuple returned by [useBluetooth](https://react-tools.ndria.dev/hooks/api-dom/useBluetooth).
 *
 * | Index | Type | Description |
 * |-------|------|-------------|
 * | `[0]` | `UseBluetoothState` | Reactive Bluetooth state (supported, connected, device, server). See {@link UseBluetoothState}. |
 * | `[1]` | `(opts?: BluetoothDevicesOptions) => Promise<void>` | `requestDevice` — opens the browser's Bluetooth device picker. Connect to the GATT server of the chosen device. |
 *
 */
type UseBluetoothResult = [UseBluetoothState, (opts?: BluetoothDevicesOptions) => Promise<void>];

/**
 * Imperative controls for the speech recognition instance, injected as the
 * second argument of every event callback in {@link UseSpeechRecognitionProps}.
 * Using these controls inside a callback is always safe — they delegate to the
 * latest internal implementation via stable refs, so no circular dependency or
 * stale closure issues arise.
 */
interface SpeechRecognitionControls {
    /**Starts a new recognition session, optionally overriding the _defaultConfig_ passed to the hook.*/
    start: (config?: SpeechRecognitionConfig) => void;
    /**Stops the current recognition session and attempts to return results for audio captured so far.*/
    stop: () => void;
    /**Aborts the current recognition session. Pass _true_ to also clear the last result from state.*/
    reset: (resultAlso?: boolean) => void;
}
/**
 * Configuration object accepted by [useSpeechRecognition](https://react-tools.ndria.dev/hooks/api-dom/useSpeechRecognition).
 *
 * All callback properties mirror the corresponding event handlers on the native
 * `SpeechRecognition` interface.
 */
interface UseSpeechRecognitionProps {
    /**
     * When `true`, recognition starts automatically on mount (equivalent to calling
     * `start()` immediately). Useful for "always listening" scenarios.
     * @default false
     */
    alreadyStarted?: boolean;
    /**
     * Default configuration applied to the `SpeechRecognition` instance.
     * See {@link SpeechRecognitionConfig} for the available options.
     */
    defaultConfig?: SpeechRecognitionConfig;
    /** Fired when the user agent has started capturing audio. */
    onAudioStart?: (this: SpeechRecognition, ev: Event, controls: SpeechRecognitionControls) => void;
    /** Fired when the user agent has finished capturing audio. */
    onAudioEnd?: (this: SpeechRecognition, ev: Event, controls: SpeechRecognitionControls) => void;
    /** Fired when the speech recognition service disconnects. */
    onEnd?: (this: SpeechRecognition, ev: Event, controls: SpeechRecognitionControls) => void;
    /** Fired when a speech recognition error occurs. */
    onError?: (this: SpeechRecognition, ev: SpeechRecognitionErrorEvent, controls: SpeechRecognitionControls) => void;
    /** Fired when no significant recognition was returned. */
    onNoMatch?: (this: SpeechRecognition, ev: SpeechRecognitionEvent, controls: SpeechRecognitionControls) => void;
    /** Fired when a word or phrase has been positively recognised. */
    onResult?: (this: SpeechRecognition, ev: SpeechRecognitionEvent, controls: SpeechRecognitionControls) => void;
    /** Fired when any sound (recognisable or not) has been detected. */
    onSoundStart?: (this: SpeechRecognition, ev: Event, controls: SpeechRecognitionControls) => void;
    /** Fired when any sound has stopped being detected. */
    onSoundEnd?: (this: SpeechRecognition, ev: Event, controls: SpeechRecognitionControls) => void;
    /** Fired when speech recognised by the service has been detected. */
    onSpeechStart?: (this: SpeechRecognition, ev: Event, controls: SpeechRecognitionControls) => void;
    /** Fired when speech recognised by the service has stopped being detected. */
    onSpeechEnd?: (this: SpeechRecognition, ev: Event, controls: SpeechRecognitionControls) => void;
    /** Fired when the speech recognition service has begun listening. */
    onStart?: (this: SpeechRecognition, ev: Event, controls: SpeechRecognitionControls) => void;
}
/**
 * Initial configuration options for the `SpeechRecognition` instance.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition
 */
interface SpeechRecognitionConfig {
    /**Returns and sets a collection of _SpeechGrammar_ objects that represent the grammars that will be understood by the current SpeechRecognition.*/
    grammars?: SpeechGrammarList;
    /**
     * BCP 47 language tag for recognition (e.g. `"en-US"`, `"it-IT"`).
     * Falls back to the `<html lang>` attribute or the user agent's language setting.
     */
    lang?: LanguageBCP47Tags;
    /**
     * When `true`, continuous results are returned for each recognition phrase.
     * When `false` (default), recognition stops after the first result.
     * @default false
     */
    continuous?: boolean;
    /**
     * When `true`, interim (non-final) results are also returned.
     * When `false`, only final results are delivered.
     * @default false
     */
    interimResults?: boolean;
    /**
     * Maximum number of `SpeechRecognitionAlternative` objects per result.
     * @default 1
     */
    maxAlternatives?: number;
}
type SpeechRecognitionErrorCode = 'aborted' | 'audio-capture' | 'bad-grammar' | 'language-not-supported' | 'network' | 'no-speech' | 'not-allowed' | 'service-not-allowed';
interface SpeechRecognitionErrorEvent extends Event {
    readonly error: SpeechRecognitionErrorCode;
    readonly message?: string;
}
interface SpeechRecognitionEvent extends Event {
    /**Returns the lowest index value result in the SpeechRecognitionResultList "array" that has actually changed.*/
    readonly resultIndex: number;
    /**Returns a SpeechRecognitionResultList object representing all the speech recognition results for the current session.*/
    results: SpeechRecognitionResultList;
}
/**The SpeechGrammar interface of the Web Speech API represents a set of words or patterns of words that we want the recognition service to recognize.*/
interface SpeechGrammar {
    /**Sets and returns a string containing the grammar from within in the SpeechGrammar object instance.*/
    src: string;
    /**Sets and returns the weight of the SpeechGrammar object.*/
    weight?: number;
}
/**The SpeechGrammarList interface of the Web Speech API represents a list of SpeechGrammar objects containing words or patterns of words that we want the recognition service to recognize.*/
interface SpeechGrammarList {
    /**Returns the number of SpeechGrammar objects contained in the SpeechGrammarList.*/
    readonly length: number;
    /**Standard getter — allows individual SpeechGrammar objects to be retrieved from the SpeechGrammarList using array syntax.*/
    item: (index: number) => SpeechGrammar;
    /**Takes a grammar present at a specific URI and adds it to the SpeechGrammarList as a new SpeechGrammar object.*/
    addFromURI: (
    /**A string representing the URI of the grammar to be added.*/
    src: string, 
    /**A float representing the weight of the grammar relative to other grammars present in the SpeechGrammarList. The weight means the importance of this grammar, or the likelihood that it will be recognized by the speech recognition service. The value can be between 0.0 and 1.0; If not specified, the default used is 1.0.*/
    weight?: number) => undefined;
    /**Adds a grammar in a string to the SpeechGrammarList as a new SpeechGrammar object.*/
    addFromString: (
    /**A string representing the URI of the grammar to be added.*/
    src: string, 
    /**A float representing the weight of the grammar relative to other grammars present in the SpeechGrammarList. The weight means the importance of this grammar, or the likelihood that it will be recognized by the speech recognition service. The value can be between 0.0 and 1.0; If not specified, the default used is 1.0.*/
    weight?: number) => undefined;
    [index: number]: SpeechGrammar;
}
/**
 * Reactive state snapshot returned by [useSpeechRecognition](https://react-tools.ndria.dev/hooks/api-dom/useSpeechRecognition).
 */
interface SpeechRecognitionState {
    /**
     * `true` when the Web Speech API (`SpeechRecognition` or `webkitSpeechRecognition`)
     * is available in the current browser.
     */
    isSupported: boolean;
    /**
     * `true` while the speech recognition service is actively listening for speech.
     * Becomes `false` after `stop()` is called or recognition ends automatically.
     */
    isListening: boolean;
    /**
     * The most recent recognition result.
     * - `results` — a `SpeechRecognitionResultList` containing all result alternatives.
     * - `resultIndex` — index of the most recent result in the list.
     * Both are `null` before the first result arrives.
     */
    result: {
        results: SpeechRecognitionEvent["results"] | null;
        resultIndex: SpeechRecognitionEvent["resultIndex"] | null;
    };
}
/**
 * The `SpeechRecognition` Web API interface.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition
 */
interface SpeechRecognition extends EventTarget {
    /** Grammar list used by this recognition instance. */
    grammars: SpeechGrammarList;
    /**
     * BCP 47 language tag. Falls back to the document's `lang` attribute
     * or the user agent's default language.
     */
    lang: LanguageBCP47Tags;
    /**
     * When `true`, recognition continues returning results until `stop()` is called.
     * @default false
     */
    continuous: boolean;
    /**
     * When `true`, interim (non-final) results are delivered via `onresult`.
     * @default false
     */
    interimResults: boolean;
    /**
     * Maximum number of recognition alternatives per result.
     * @default 1
     */
    maxAlternatives: number;
    /** Called when audio capture starts. */
    onaudiostart: ((this: SpeechRecognition, ev: Event) => void) | null;
    /** Called when audio capture ends. */
    onaudioend: ((this: SpeechRecognition, ev: Event) => void) | null;
    /** Called when the service disconnects. */
    onend: ((this: SpeechRecognition, ev: Event) => void) | null;
    /** Called when a recognition error occurs. */
    onerror: ((this: SpeechRecognition, ev: SpeechRecognitionErrorEvent) => void) | null;
    /** Called when no significant recognition was found. */
    onnomatch: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => void) | null;
    /** Called when a recognition result is returned. */
    onresult: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => void) | null;
    /** Called when any detectable sound starts. */
    onsoundstart: ((this: SpeechRecognition, ev: Event) => void) | null;
    /** Called when detectable sound stops. */
    onsoundend: ((this: SpeechRecognition, ev: Event) => void) | null;
    /** Called when recognised speech starts. */
    onspeechstart: ((this: SpeechRecognition, ev: Event) => void) | null;
    /** Called when recognised speech ends. */
    onspeechend: ((this: SpeechRecognition, ev: Event) => void) | null;
    /** Called when the recognition service starts listening. */
    onstart: ((this: SpeechRecognition, ev: Event) => void) | null;
    /** Starts listening for speech. */
    start: () => void;
    /** Stops listening; returns results for speech recognised so far. */
    stop: () => void;
    /** Stops listening without returning results. */
    abort: () => void;
}

type SpeechSynthesisonCancel = ((this: SpeechSynthesisUtterance, ev: {
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisEvent/charIndex).*/
    readonly charIndex: number;
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisEvent/charLength).*/
    readonly charLength: number;
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisEvent/elapsedTime).*/
    readonly elapsedTime: number;
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisEvent/name).*/
    readonly name: string;
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisEvent/utterance).*/
    readonly utterance: SpeechSynthesisUtterance;
}) => void) | null;
/**
 * Props accepted by [useSpeechSynthesis](https://react-tools.ndria.dev/hooks/api-dom/useSpeechSynthesis).
 *
 */
interface UseSpeechSynthesisProps {
    /**function that will be executed when __speak__ method of _SpeechSynthesis_ will be invoked.*/
    onSpeak?: () => void;
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/start_event).*/
    onStart?: SpeechSynthesisUtterance["onstart"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/pause_event).*/
    onPause?: SpeechSynthesisUtterance["onpause"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/resume_event).*/
    onResume?: SpeechSynthesisUtterance["onresume"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/boundary_event).*/
    onBoundary?: SpeechSynthesisUtterance["onboundary"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/mark_event).*/
    onMark?: SpeechSynthesisUtterance["onmark"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/error_event).*/
    onError?: SpeechSynthesisUtterance["onerror"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/end_event).*/
    onEnd?: SpeechSynthesisUtterance["onend"];
    onCancel?: SpeechSynthesisonCancel;
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/lang).*/
    lang?: LanguageBCP47Tags;
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/pitch).*/
    pitch?: SpeechSynthesisUtterance["pitch"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/rate).*/
    rate?: SpeechSynthesisUtterance["rate"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/voice).*/
    voice?: SpeechSynthesisUtterance["voice"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/volume).*/
    volume?: SpeechSynthesisUtterance["volume"];
}
type SpeechSynthesisSpeakParam = SpeechSynthesisUtterance["text"] | ({
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/text).*/
    text: SpeechSynthesisUtterance["text"];
    /**boolean that if true invokes __speak__ method of _SpeechSynthesis_ cancelling currenty speaking.*/
    startImmediatly?: boolean;
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/start_event).*/
    onStart?: SpeechSynthesisUtterance["onstart"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/pause_event).*/
    onPause?: SpeechSynthesisUtterance["onpause"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/resume_event).*/
    onResume?: SpeechSynthesisUtterance["onresume"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/boundary_event).*/
    onBoundary?: SpeechSynthesisUtterance["onboundary"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/mark_event).*/
    onMark?: SpeechSynthesisUtterance["onmark"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/error_event).*/
    onError?: SpeechSynthesisUtterance["onerror"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/end_event).*/
    onEnd?: SpeechSynthesisUtterance["onend"];
    onCancel?: SpeechSynthesisonCancel;
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/lang).*/
    lang?: LanguageBCP47Tags;
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/pitch).*/
    pitch?: SpeechSynthesisUtterance["pitch"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/rate).*/
    rate?: SpeechSynthesisUtterance["rate"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/voice).*/
    voice?: SpeechSynthesisUtterance["voice"];
    /**[MDN Reference](https://developer.mozilla.org/docs/Web/API/SpeechSynthesisUtterance/volume).*/
    volume?: SpeechSynthesisUtterance["volume"];
});
/**
 * Declaration of [useSpeechSynthesis](https://react-tools.ndria.dev/hooks/api-dom/useSpeechSynthesis).
 */
interface UseSpeechSynthesis {
    (props?: UseSpeechSynthesisProps): {
        state: {
            /**Returns a boolean value indicating SpeechSynthesis availability.*/
            isSupported: boolean;
            /**Returns the current status of SpeechSynthesis.*/
            status: "ready" | "speaking" | "paused" | "error" | "end" | "unavailable";
            /**Returns a boolean indicating the presence of texts to speech.*/
            hasPending: boolean;
            /**Returns the list of available voices.*/
            voices: SpeechSynthesisVoice[] | null;
        };
        /**Function to start speaking.*/
        speak: (param: SpeechSynthesisSpeakParam) => void;
        /**Function to keep in pause speaking.*/
        pause: () => void;
        /**Function to resume speaking.*/
        resume: () => void;
        /**Function to cancel speaking.*/
        cancel: () => void;
    };
}

/**
 * Props for the [useFPS](https://react-tools.ndria.dev/hooks/api-dom/useFPS).
 */
interface UseFPSProps {
    /**
     * Sampling interval in seconds. The hook records one FPS measurement per interval
     * and updates the result accordingly.
     */
    everySeconds: number;
    /**
     * Number of measurements to keep in the rolling window for average/max calculations.
     * Older measurements are dropped once the window is full.
     */
    windowSize: number;
}
/**
 * Result object returned by [useFPS](https://react-tools.ndria.dev/hooks/api-dom/useFPS).
 */
interface UseFPSResult {
    /**
     * Rolling array of recent FPS measurements (up to `windowSize` entries).
     * Each value is the frames-per-second recorded during the corresponding sampling interval.
     */
    fps: number[];
    /** Average FPS over all measurements currently in the rolling window. */
    avg: number;
    /** Highest FPS value recorded in the rolling window. */
    maxFps: number;
    /** Most recently recorded FPS value. */
    currentFps: number;
}

/**
 * Props for the [usePIP](https://react-tools.ndria.dev/hooks/api-dom/usePIP).
 */
interface UsePIPProps {
    /** The `<video>` element to enter Picture-in-Picture mode. Accepts a `RefObject` or a direct reference. */
    target: RefObject<HTMLVideoElement> | HTMLVideoElement;
    /** Called when the PIP window is requested (before it opens). */
    onOpen?: (evt: Event) => void;
    /**
     * Called when the PIP window has successfully opened.
     * @param pipWindow - The `PictureInPictureWindow` object, providing `width` and `height`.
     */
    onOpened?: (pipWindow: PictureInPictureWindow) => void;
    /** Called when the PIP window is closed (video returns to its original position). */
    onClose?: (evt: PictureInPictureEvent) => void;
    /** Called if the PIP request or close operation fails. */
    onError?: (err: unknown) => void;
}
/**
 * Result object returned by [usePIP](https://react-tools.ndria.dev/hooks/api-dom/usePIP).
 */
interface UsePIPResult {
    /** `true` when the Picture-in-Picture API is supported by the current browser. */
    isSupported: boolean;
    /** Request Picture-in-Picture mode for the target video element. */
    openPIP: () => Promise<void>;
    /** Exit Picture-in-Picture mode, returning the video to its original container. */
    closePIP: () => Promise<void>;
}

/**
 * Event fired when the Document Picture-in-Picture window is successfully opened.
 */
interface DocumentPictureInPictureEvent extends Event {
    window: Window;
}
/**
 * Configuration options for the Document Picture-in-Picture window.
 */
interface DocumentPIPOptions {
    /** Initial dimensions for the PiP window. */
    window?: {
        /** Width of the window in pixels. */
        width: number;
        /** Height of the window in pixels. */
        height: number;
    };
    /**
     * If true, clones the parent document's stylesheets into the PiP window.
     * Useful for maintaining consistent UI styling.
     */
    inheritCSS?: boolean;
}
/**
 * Props accepted by [useDocumentPIP](https://react-tools.ndria.dev/hooks/api-dom/useDocumentPIP).
 */
interface UseDocumentPIPProps {
    /** Default options to apply when opening the PiP window. */
    options?: DocumentPIPOptions;
    /** Callback triggered immediately when the opening process starts. */
    onOpen?: () => void;
    /** Callback triggered once the PiP window is open and the document is available. */
    onOpened?: (evt: DocumentPictureInPictureEvent) => void;
    /** Callback triggered when the PiP window is closed. */
    onClose?: (evt: PageTransitionEvent) => void;
    /** Callback triggered if the PiP request fails (e.g., user denial or unsupported environment). */
    onError?: (err: unknown) => void;
}
/**
 * Result returned by [useDocumentPIP](https://react-tools.ndria.dev/hooks/api-dom/useDocumentPIP).
 */
interface UseDocumentPIPResult {
    /** Indicates if the Document Picture-in-Picture API is supported by the current browser. */
    isSupported: boolean;
    /**
     * Opens the PiP window.
     * @param opts - Optional overrides for the default window options.
     * @returns A promise that resolves when the window is initialized.
     */
    openPIP: (opts?: DocumentPIPOptions) => Promise<void>;
    /** Manually closes the active PiP window. */
    closePIP: () => void;
    /** The current PiP window instance, or undefined if no window is active. */
    window?: Window;
    /**
     * A React component that renders its children inside the PiP window using a Portal.
     * Returns null if the PiP window is not currently open.
     */
    PipWindow: (props: PropsWithChildren) => JSX.Element | null;
}

/**
 * Extends the standard HTML attribute set with the `popover` attribute introduced by the
 * [Popover API](https://developer.mozilla.org/en-US/docs/Web/API/Popover_API).
 *
 * @template T - The HTML element type the attributes apply to.
 *
 */
interface HTMLAttributes<T> extends AriaAttributes, DOMAttributes<T> {
    /**
     * Sets the popover behaviour of the element:
     *  - **`"auto"`** — The popover can be dismissed by clicking outside it (light-dismiss)
     *    or by pressing `Escape`. Only one `auto` popover can be open at a time.
     *  - **`"manual"`** — The popover must be explicitly opened and closed via JavaScript.
     *    Multiple `manual` popovers can coexist, and light-dismiss is disabled.
     */
    popover?: "auto" | "manual";
}
/**
 * Parameters accepted by [usePopover](https://react-tools.ndria.dev/hooks/api-dom/usePopover).
 */
interface UsePopoverProps {
    /**
     * Controls the popover dismissal behaviour:
     *   - **`"auto"`** — Light-dismiss is enabled (clicking outside or pressing `Escape` closes
     *     the popover). Only one `auto` popover can be visible at a time.
     *   - **`"manual"`** — The popover must be closed explicitly via {@link UsePopoverResult.hidePopover}
     *     or {@link UsePopoverResult.togglePopover}. Multiple `manual` popovers can coexist.
    */
    mode: "auto" | "manual";
    /**
     * Optional callback invoked
     *   synchronously **before** the popover transitions between open and closed states.
     *   Receives a {@link ToggleEvent} whose `oldState` and `newState` properties indicate the
     *   direction of the transition (`"closed" → "open"` or `"open" → "closed"`).
     */
    onBeforeToggle?: (evt: ToggleEvent) => void;
    /**
     * Optional callback invoked
     *   **after** the popover has finished transitioning. Receives the same {@link ToggleEvent}
     *   as `onBeforeToggle`. Use this to react to the final open/closed state rather than
     *   intercepting the transition.
     */
    onToggle?: (evt: ToggleEvent) => void;
}
/**
 * Return value of [usePopover](https://react-tools.ndria.dev/hooks/api-dom/usePopover).
 */
interface UsePopoverResult {
    /**
     * `true` when the browser supports the Popover API
     *   (i.e. `showPopover` exists on `HTMLElement.prototype`). When `false`, the
     *   {@link UsePopoverResult.Popover} component renders nothing and all control functions
     *   are no-ops.
     */
    isSupported: boolean;
    /**
     * Reactive boolean reflecting the current visibility state of
     *   the popover. Updates synchronously after each {@link ToggleEvent} fires. Use this to
     *   conditionally style trigger elements or render additional UI.
     */
    isOpen: boolean;
    /**
     * Imperatively opens the popover by calling the native
     *   `HTMLElement.showPopover()` method on the underlying element. Has no effect if the
     *   popover is already open or if the API is not supported.
     */
    showPopover: () => void;
    /**
     * Imperatively closes the popover by calling the native
     *   `HTMLElement.hidePopover()` method on the underlying element. Has no effect if the
     *   popover is already closed or if the API is not supported.
     */
    hidePopover: () => void;
    /**
     * Imperatively toggles the popover open or closed by
     *   calling the native `HTMLElement.togglePopover()` method. Has no effect if the API is
     *   not supported.
     */
    togglePopover: () => void;
    /**
     *   A React component that renders the popover container as a `<div>` with the appropriate
     *   `id`, `popover`, and ref wired up internally. Accepts all standard `<div>` props
     *   (including `ref`) plus the {@link HTMLAttributes} `popover` extension.
     *   - Renders `false` (nothing) when the Popover API is not supported.
     *   - Must be rendered in the tree for {@link UsePopoverResult.showPopover},
     *     {@link UsePopoverResult.hidePopover}, and {@link UsePopoverResult.togglePopover} to work.
     *   - The `id` is managed internally and should not be overridden.
     */
    Popover: ({ children, ...rest }: ComponentPropsWithRef<"div"> & HTMLAttributes<"div">) => false | JSX.Element;
}

/**
 * Parameters accepted by [useRemotePlayback](https://react-tools.ndria.dev/hooks/api-dom/useRemotePlayback).
 */
interface UseRemotePlaybackProps {
    /**
     * Called when the remote playback device begins its connection attempt,
     * i.e. when the underlying {@link RemotePlayback} state transitions to `"connecting"`.
     */
    onConnecting?: (evt: Event) => void;
    /**
     * Called when the remote playback device successfully establishes a connection,
     * i.e. when the underlying {@link RemotePlayback} state transitions to `"connected"`.
     */
    onConnect?: (evt: Event) => void;
    /**
     * Called when the remote playback device disconnects, i.e. when the underlying
     * {@link RemotePlayback} state transitions back to `"disconnected"`.
     */
    onDisconnect?: (evt: Event) => void;
    /**
     * Called when an error occurs while attempting to watch availability or connect
     * to a remote playback device. Receives the thrown value, which may be a
     * `DOMException` or any other error type depending on the browser implementation.
     * When omitted, errors are re-thrown.
     */
    onError?: (err: unknown) => void;
}
/**
 * Return value of [useRemotePlayback](https://react-tools.ndria.dev/hooks/api-dom/useRemotePlayback).
 *
 * @template T - The `HTMLMediaElement` subtype (`HTMLVideoElement`, `HTMLAudioElement`, etc.) that the ref will be attached to.
 */
interface UseRemotePlaybackResult<T extends HTMLMediaElement> {
    /**
     * A React ref callback to attach to the target media element. Wiring this ref is
     * required for all other returned values and functions to work — it initialises the
     * underlying {@link RemotePlayback} object and registers the event handlers for
     * `connect`, `connecting`, and `disconnect`. Cleans up all listeners and cancels
     * availability watching when the element is unmounted.
     */
    ref: RefCallback<T>;
    /**
     * `true` when the browser supports the Remote Playback API
     * (i.e. `"RemotePlayback" in window`). When `false`, {@link UseRemotePlaybackResult.prompt}
     * resolves immediately without opening any picker and {@link UseRemotePlaybackResult.state}
     * remains `"disconnected"`.
     */
    isSupported: boolean;
    /**
     * Reactive string reflecting the current remote playback connection state:
     * - **`"disconnected"`** — No remote device is connected. This is the initial state.
     * - **`"connecting"`** — A connection attempt is in progress.
     * - **`"connected"`** — A remote device is actively receiving playback.
     * - **`"unavailable"`** — No compatible remote playback devices were detected in the
     *   vicinity (reported by the availability watcher).
     */
    state: "unavailable" | "connected" | "connecting" | "disconnected";
    /**
     * Opens the browser's native remote playback device picker, allowing the user to
     * select a device to stream media to (e.g. Chromecast, AirPlay). Resolves when the
     * picker is dismissed, regardless of whether a device was selected. Rejects if the
     * API is unavailable or the call is made before the {@link UseRemotePlaybackResult.ref}
     * has been attached to a media element.
     */
    prompt: () => Promise<void>;
}

/**
 * Configuration object accepted by [useAnimation](https://react-tools.ndria.dev/hooks/api-dom/useAnimation).
 *
 * Wraps the Web Animations API (`Element.animate()`) options with additional
 * React lifecycle hooks.
 */
interface UseAnimationProps {
    /**
     * Keyframes to animate. Accepts any format supported by `Element.animate()`:
     * - `Keyframe[]` — an array of keyframe objects (e.g. `[{ opacity: 0 }, { opacity: 1 }]`).
     * - `PropertyIndexedKeyframes` — an object mapping CSS properties to arrays of values.
     * - `null` — no keyframes (the animation is effectively disabled).
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/animate
     */
    keyFrames: Keyframe[] | PropertyIndexedKeyframes | null;
    /**
     * When `true`, the animation starts immediately when the element mounts
     * (before a manual call to `playAnimation()`).
     * @default false
     */
    immediate?: boolean;
    /**
     * Timing options forwarded to `Element.animate()`.
     * Accepts either:
     * - A `number` representing the total duration in milliseconds.
     * - A `KeyframeAnimationOptions` object (e.g. `{ duration: 500, easing: "ease-in-out" }`).
     */
    opts?: number | KeyframeAnimationOptions;
    /**
     * Called when the animation completes (the `finish` event fires).
     * @param this - The `Animation` instance that finished.
     * @param evt - The `AnimationPlaybackEvent` fired by the animation.
     */
    onFinish?: (this: Animation, evt: AnimationPlaybackEvent) => void;
    /**
     * Called when the animation is removed from its element's effect stack.
     * @param this - The `Animation` instance.
     * @param evt - The event fired on removal.
     */
    onRemove?: (this: Animation, evt: Event) => void;
    /**
     * Called when the animation is cancelled.
     * @param this - The `Animation` instance.
     * @param evt - The `AnimationPlaybackEvent` fired on cancellation.
     */
    onCancel?: (this: Animation, evt: AnimationPlaybackEvent) => void;
    /**
     * Called when the Web Animations API throws an unexpected error.
     * @param err - The caught error value.
     */
    onError?: (err: unknown) => void;
}
/**
 * Result object returned by [useAnimation](https://react-tools.ndria.dev/hooks/api-dom/useAnimation).
 *
 * @template T Type of the target DOM element (defaults to `Element`).
 */
interface UseAnimationResult<T extends Element> {
    /**
     * `true` when the Web Animations API (`element.animate`) is available in the current browser.
     * When `false`, all control functions are no-ops.
     */
    isSupported: boolean;
    /**
     * Callback ref to attach to the DOM element you want to animate.
     * The animation is created and bound to the element when this ref is set.
     */
    ref: RefCallback<T>;
    /** Resumes or starts the animation (calls `Animation.play()`). */
    playAnimation: () => void;
    /** Pauses the animation at its current position (calls `Animation.pause()`). */
    pauseAnimation: () => void;
    /** Immediately jumps the animation to its end state (calls `Animation.finish()`). */
    finishAnimation: () => void;
    /** Cancels the animation, removing all effects and resetting to the initial state (calls `Animation.cancel()`). */
    cancelAnimation: () => void;
    /**
     * Marks the animation as persistent so it is not automatically removed from the
     * element's effect stack (calls `Animation.persist()`).
     */
    persistAnimation: () => void;
    /** Plays the animation in reverse (calls `Animation.reverse()`). */
    reverseAnimation: () => void;
    /**
     * Applies the current computed animation styles directly to the element and then
     * cancels the animation (calls `Animation.commitStyles()`).
     * Useful for preserving the final animation state after removal.
     */
    commitStyles: () => void;
    /**
     * Changes the playback rate of the animation without adjusting its current time.
     * @param playbackRate - The new playback rate (e.g. `2` for double speed, `0.5` for half, `-1` for reverse).
     */
    updatePlaybackRate: (playbackRate: number) => void;
}

/**
 * Configuration object accepted by [useEventSource](https://react-tools.ndria.dev/hooks/api-dom/useEventSource).
 * @template T Expected type of the parsed message data.
 */
interface UseEventSourceProps {
    /**
     * URL of the SSE endpoint. Can be set here or passed to `open()` at connection time.
     * If omitted, `open()` must always be called with a URL.
     */
    url?: string | URL;
    /**
     * Options forwarded to the `EventSource` constructor.
     * The most useful option is `{ withCredentials: true }` for cross-origin SSE endpoints
     * that require cookies or HTTP auth.
     */
    opts?: EventSourceInit;
    /**
     * Array of named events to listen to on the `EventSource`.
     * Each entry registers a listener for the named event type alongside the default `"message"` listener.
     *
     * @example
     * ```ts
     * events: [
     *   { name: "update", handler: (evt) => console.log(evt.data) },
     *   { name: "ping" }, // no handler — just subscribes without a callback
     * ]
     * ```
     */
    events?: {
        name: string;
        handler?: (evt: MessageEvent) => void;
    }[];
    /**
     * When `true`, the `EventSource` connection is opened immediately on mount.
     * When `false` (default), call `open()` to connect.
     * @default false
     */
    immediateConnection?: boolean;
    /**
     * Called when the `EventSource` connection is established (`open` event).
     * @param evt - The `Event` fired when the connection opens.
     */
    onOpen?: (evt: Event) => void;
    /**
     * Called when an error occurs on the `EventSource` connection (`error` event).
     * This includes connection errors and server-side errors.
     * @param evt - The `Event` fired on error.
     */
    onError?: (evt: Event) => void;
    /**
     * Called for every unnamed `"message"` event received from the server.
     * @param evt - The `MessageEvent` containing the received data.
     * @template T - Expected type of `evt.data` after parsing.
     */
    onMessage?: <T>(evt: MessageEvent<T>) => void;
}
/**
 * Result object returned by [useEventSource](https://react-tools.ndria.dev/hooks/api-dom/useEventSource).
 *
 * @template T Expected type of the parsed message data.
 */
interface UseEventSourceResult<T> {
    /**
     * Current connection state of the `EventSource`:
     * - `"READY"` — not yet connected (initial state).
     * - `"CONNECTING"` — connection attempt in progress.
     * - `"OPENED"` — connection established, receiving events.
     * - `"CLOSED"` — connection closed (manually or by the server).
     */
    status: "READY" | "CONNECTING" | "OPENED" | "CLOSED";
    /**
     * The most recently received `"message"` event data.
     * `null` before the first message arrives.
     */
    data: T | null;
    /**
     * Opens the `EventSource` connection to the provided (or configured) URL.
     * @param url - Optional URL override for this specific connection.
     */
    open: (url?: string) => void;
    /** Closes the `EventSource` connection. The `status` transitions to `"CLOSED"`. */
    close: () => void;
}

/**
 * Props for the [useWebSocket](https://react-tools.ndria.dev/hooks/api-dom/useWebSocket).
 * @template T Type of the data exchanged on the socket.
 */
interface UseWebSocketProps<T = unknown> {
    /** WebSocket endpoint URL. Can be set here or passed to `open()` at connection time. */
    url?: string | URL;
    /** Sub-protocol string or array of strings forwarded to the `WebSocket` constructor. */
    protocols?: string | string[];
    /**
     * The binary data type used to receive binary messages.
     * @default "blob"
     */
    binaryType?: "blob" | "arraybuffer";
    /**
     * When `true`, the WebSocket connection is opened immediately on mount.
     * @default false
     */
    immediateConnection?: boolean;
    /** Called when the WebSocket connection opens. */
    onOpen?: (evt: Event) => void;
    /**
     * Called when a message is received.
     * @param data - The parsed message data (processed by `parser`).
     * @param evt - The raw `MessageEvent`.
     */
    onMessage?: (data: T, evt: MessageEvent<T>) => void;
    /** Called when a WebSocket error occurs. */
    onError?: (evt: Event, err?: Error) => void;
    /** Called when the WebSocket connection closes. */
    onClose?: (evt: CloseEvent) => void;
    /**
     * When `true`, messages sent while the connection is not yet open are buffered
     * and delivered once the connection is established.
     * @default false
     */
    bufferingData?: boolean;
    /**
     * Auto-reconnect configuration.
     * - `true` — reconnect indefinitely with the default delay.
     * - `{ retries, delay, onFailed? }` — reconnect up to `retries` times with `delay` ms between attempts.
     */
    reconnect?: boolean | {
        retries: number;
        delay: number;
        onFailed?: () => void;
    };
    /**
     * Message parser applied to incoming `MessageEvent.data` before calling `onMessage`.
     * - `"json"` — `JSON.parse`.
     * - `"text"` — identity (string passthrough).
     * - `"blob"` / `"arraybuffer"` — return the raw binary data.
     * - A function — custom parser receiving the raw data and returning the typed value.
     * @default "json"
     */
    parser?: "json" | "text" | "blob" | "arraybuffer" | ((data: string | ArrayBuffer | Blob) => unknown);
}
/**
 * Result object returned by [useWebSocket](https://react-tools.ndria.dev/hooks/api-dom/useWebSocket).
 * @template T Type of the data exchanged on the socket.
 */
interface UseWebSocketResult<T = unknown> {
    /**
     * Current connection state.
     * - `"READY"` — not yet connected.
     * - `"CONNECTING"` — connection in progress.
     * - `"CONNECTED"` — connection established.
     * - `"RECONNECTING"` — attempting to reconnect after a disconnect.
     * - `"DISCONNECTING"` — close handshake in progress.
     * - `"DISCONNECTED"` — connection fully closed.
     */
    status: "READY" | "CONNECTING" | "CONNECTED" | "RECONNECTING" | "DISCONNECTING" | "DISCONNECTED";
    /** Most recently received parsed message data. `null` before the first message. */
    data: T | null;
    /** The raw `MessageEvent` for the most recently received message. `null` before the first message. */
    lastMessage: MessageEvent | null;
    /**
     * Open the WebSocket connection.
     * @param url - Optional URL override. Falls back to `props.url`.
     */
    open: (url?: string | URL) => void;
    /**
     * Send raw data over the WebSocket.
     * @param data - String, binary data, or typed array to transmit.
     */
    send: (data: string | ArrayBuffer | Blob | TypedArray) => void;
    /**
     * Serialise a value as JSON and send it over the WebSocket.
     * @param data - Any JSON-serialisable value.
     */
    sendJSON: (data: unknown) => void;
    /**
     * Close the WebSocket connection.
     * @param code - Optional close status code (see RFC 6455).
     * @param reason - Optional human-readable close reason.
     */
    close: (code?: number, reason?: string) => void;
    /** Manually trigger a reconnection attempt. */
    reconnect: () => void;
    /** Direct reference to the underlying `WebSocket` instance. `null` when not connected. */
    socket: WebSocket | null;
}

/**
 * Prop accepted by [useMediaDevices](https://react-tools.ndria.dev/hooks/api-dom/useMediaDevices)
 *
 */
type UseMediaDevicesProps = "devicesList" | "supportedConstraintsList" | "DisplayCapture" | "mediaInputCapture";
/**
 * Represents the return type of [useMediaDevices](https://react-tools.ndria.dev/hooks/api-dom/useMediaDevices), which varies depending on the `action`
 * parameter passed to the hook. Each variant corresponds to a specific `MediaDevices` API method.
 *
 * @remarks
 * This is a union of four function signatures — one per supported action:
 *
 * - **`"devicesList"`** — Returns a function that calls `enumerateDevices()` and resolves with
 *   the list of available media input/output devices. Optionally registers a `devicechange`
 *   listener for the lifetime of the component.
 *
 * - **`"supportedConstraintsList"`** — Returns a function that calls `getSupportedConstraints()`
 *   and returns an object describing which media track constraints the browser supports.
 *   Optionally registers a `devicechange` listener.
 *
 * - **`"DisplayCapture"`** — Returns a function that calls `getDisplayMedia()` and resolves with
 *   a `MediaStream` capturing a screen, window, or tab. Accepts optional
 *   {@link DisplayMediaStreamOptions} and an optional `devicechange` listener.
 *
 * - **`"mediaInputCapture"`** — Returns a function that calls `getUserMedia()` and resolves with
 *   a `MediaStream` from a camera and/or microphone. Accepts optional
 *   {@link MediaStreamConstraints} and an optional `devicechange` listener.
 *
 * @param onDevicesChange - Optional callback invoked whenever the set of available media devices
 *   changes (i.e. on the `devicechange` event). Available on all four variants as the last
 *   parameter. Not supported in all browsers — the hook throws if `ondevicechange` is not
 *   available and this argument is provided.
 * @param options - (`"DisplayCapture"` variant only) Options forwarded to `getDisplayMedia()`.
 *   See {@link DisplayMediaStreamOptions}.
 * @param constraints - (`"mediaInputCapture"` variant only) Constraints forwarded to
 *   `getUserMedia()`. See {@link MediaStreamConstraints}.
 *
 */
type UseMediaDevicesResult = ((onDevicesChange?: ((evt: Event) => void | Promise<void>) | undefined) => Promise<MediaDeviceInfo[]>) | ((onDevicesChange?: ((evt: Event) => void | Promise<void>) | undefined) => MediaTrackSupportedConstraints) | ((options?: DisplayMediaStreamOptions, onDevicesChange?: ((evt: Event) => void | Promise<void>) | undefined) => Promise<MediaStream>) | ((constraints?: MediaStreamConstraints, onDevicesChange?: ((evt: Event) => void | Promise<void>) | undefined) => Promise<MediaStream>);
/**The CaptureController interface provides methods that can be used to further manipulate a capture session separate from its initiation via MediaDevices.getDisplayMedia().*/
interface CaptureController {
    /**controls whether the captured tab or window will be focused when an associated MediaDevices.getDisplayMedia() Promise fulfills, or whether the focus will remain with the tab containing the capturing app.*/
    setFocusBehavior: (
    /**An enumerated value that describes whether the user agent should transfer focus to the captured display surface, or keep the capturing app focused. Possible values are focus-captured-surface (transfer focus) and no-focus-change (keep focus on the capturing app).*/
    focusBehavior: "focus-captured-surface" | "no-focus-change") => void;
}
type TDisplayMediaStreamOptions = DisplayMediaStreamOptions & {
    controller?: CaptureController;
};

/**
 * Extended set of permission names beyond the standard `PermissionName` type.
 * Includes vendor-specific and draft API permissions supported by various browsers.
 */
type PermissionNamePolyfill = "midi" | "ambient-light-sensor" | "accessibility-events" | "clipboard-read" | "clipboard-write" | "payment-handler" | "idle-detection" | "periodic-background-sync" | "system-wake-lock" | "window-management" | "window-placement" | "local-fonts" | "top-level-storage-access" | "captured-surface-control" | "persistent-storage" | "storage-access" | "accelerometer" | "background-fetch" | "bluetooth" | "camera" | "display-capture" | "geolocation" | "gyroscope" | "magnetometer" | "microphone" | "nfc" | "notifications" | "push" | "screen-wake-lock" | "speaker-selection";
/**
 * Union of the standard `PermissionName` and the extended `PermissionNamePolyfill`.
 * Used by [usePermission](https://react-tools.ndria.dev/hooks/api-dom/usePermission).
 */
type TPermissionName = PermissionName | PermissionNamePolyfill;
/**
 * Possible permission states returned by `usePermission`.
 * Extends the standard `PermissionState` with:
 * - `"not supported"` — the Permissions API or the specific permission name is not available.
 * - `"asking"` — a permission request is currently in progress.
 */
type TPermissionState = PermissionState | "not supported" | "asking";
/**
 * Result tuple returned by [usePermission](https://react-tools.ndria.dev/hooks/api-dom/usePermission).
 */
type UsePermissionResult = [
    /** current permission state (`"granted"`, `"denied"`, `"prompt"`, `"not supported"`, `"asking"`). */
    TPermissionState,
    /** `requestPermission()` — triggers a permission request and returns the resulting state. */
    () => Promise<TPermissionState>
];

/**
 * Props for the [useWebWorker](https://react-tools.ndria.dev/hooks/api-dom/useWebWorker).
 */
interface UseWebWorkerProps {
    /**
     * URL of the worker script to load.
     * Must comply with the same-origin policy (or use a Blob URL for inline workers).
     */
    url: string | URL;
    /** Options forwarded to the `Worker` constructor (e.g. `{ type: "module" }`). */
    options?: WorkerOptions;
    /**
     * Called on the main thread when the worker posts a message via `postMessage`.
     * @param e - The `MessageEvent` containing the worker's response.
     */
    onMessage?: (e: MessageEvent) => void;
    /**
     * Called when the worker receives a message that cannot be deserialised.
     * @param e - The erroneous `MessageEvent`.
     */
    onMessageError?: (e: MessageEvent) => void;
    /**
     * Called when an uncaught error occurs inside the worker.
     * @param e - The `ErrorEvent` dispatched by the worker.
     */
    onError?: (e: Event) => void;
}
/**
 * Result object returned by [useWebWorker](https://react-tools.ndria.dev/hooks/api-dom/useWebWorker).
 */
interface UseWebWorkerResult {
    /**
     * Post a message to the worker thread.
     * @param message - The data to send (must be structured-cloneable or transferable).
     * @param transfer - Optional array of `Transferable` objects to transfer ownership of, or
     *   a `StructuredSerializeOptions` object.
     */
    send: <T>(message: T, transfer?: Transferable[] | StructuredSerializeOptions) => void;
    /**
     * Immediately terminate the worker, stopping its execution.
     * Any pending messages are discarded.
     */
    terminate: Worker["terminate"];
}

/**
 * Props accepted by [useWebWorkerFn](https://react-tools.ndria.dev/hooks/api-dom/useWebWorkerFn).
 *
 * @template T - The type of the function to execute inside the Web Worker. Must be a callable accepting any number of arguments and returning any value.
 */
interface UseWebWorkerFnProps<T extends (...args: unknown[]) => unknown> {
    /**
     * The function to run inside a Web Worker. It is serialised via
     * `.toString()` and reconstructed in an isolated worker context, so it
     * must be a **pure, self-contained function** — it cannot reference
     * variables, imports, or closures from the outer scope. Any dependencies
     * must either be passed as arguments or loaded via `deps`.
     */
    fn: T;
    /**
     * An optional array of external script URLs imported into the worker
     * context via `importScripts()` before `fn` is invoked. Use this to
     * provide third-party libraries, polyfills, or shared utilities that
     * `fn` depends on at runtime.
     */
    deps?: string[];
}
/**
 * Return value of [useWebWorkerFn](https://react-tools.ndria.dev/hooks/api-dom/useWebWorkerFn).
 *
 * An async wrapper function with the same parameter signature as `fn`. Calling
 * it serialises the arguments, transfers them to the Web Worker, executes `fn`
 * in the isolated worker context, and resolves the returned `Promise` with the
 * result once the worker replies. Rejects if the worker throws or is terminated
 * before completing.
 *
 * @template T - The type of the original function, used to preserve its
 *   parameter and return types.
 */
interface UseWebWorkerFnResult<T extends (...args: unknown[]) => unknown> {
    /**
     * @param args - The arguments forwarded to `fn` inside the worker. Must
     *   be serialisable via the [structured clone algorithm](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm).
     * @returns A `Promise` that resolves with the return value of `fn`, or
     *   rejects if the worker encounters an error.
     */
    (...args: Parameters<T>): Promise<ReturnType<T>>;
}

/**
 * Props accepted by [useBroadcastChannel](https://react-tools.ndria.dev/hooks/api-dom/useBroadcastChannel).
 *
 * @template T Type of the data exchanged on the channel.
 *
 */
interface UseBroadcastChannelProps<T> {
    /** broadcast channel name */
    name: string;
    /** function that will be execute when a message occurred */
    onMessage?: (evt: MessageEvent<T>) => void;
    /** function that will be execute when an error message occurred */
    onError?: (evt: MessageEvent) => void;
}
/**
 * Result tuple returned by [useBroadcastChannel](https://react-tools.ndria.dev/hooks/api-dom/useBroadcastChannel).
 *
 * @template T Type of the data exchanged on the channel.
 */
type UseBroadcastChannelResult<T> = [
    /** Last received message data. `undefined` before any message arrives. */
    T | undefined,
    /** `send` — broadcasts `data` to all other contexts subscribed to the same channel name. */
    (data: T) => void
];

/**
 * Options used by [useDebounce](https://react-tools.ndria.dev/hooks/api-dom/useDebounce).
 */
interface UseDebounceOpts {
    /** Delay in milliseconds before the debounced function is invoked. */
    delay: number;
    /**
     * When `true`, uses `requestAnimationFrame` as the timer mechanism instead of `setTimeout`.
     * Only fires when the browser window is focused. Useful for animation-related debouncing.
     * @default false
     */
    focusedWindow?: boolean;
}
/**
 * Function used by [useDebounce](https://react-tools.ndria.dev/hooks/api-dom/useDebounce).
 * @template T Type of the parameters function.
 */
interface UseDebounceFunction<T extends unknown[]> {
    (...args: T): void;
}
/**
 * Result tuple by [useDebounce](https://react-tools.ndria.dev/hooks/api-dom/useDebounce).
 *
 * @template T Type of the UseDebounceFunction parameters function.
 */
type UseDebounceResult<T extends unknown[]> = [
    /** the debounced version of the function; calling it resets the delay timer. */
    (...args: T) => void,
    /** cancel any pending invocation without calling the function. */
    () => void,
    /** flush: execute the function immediately, cancelling the pending debounced call. */
    (...args: T) => void
];

/**
 * The possible types for the native dialog box.
 */
type DialogType = "prompt" | "alert" | "confirm";
/**
 * Function that triggers a native `window.prompt`.
 * @param message - Text to display in the dialog.
 * @param _default - Default value for the input field.
 * @returns The string entered by the user or null if cancelled.
 */
type PromptHandler = (message?: string, _default?: string) => string | null;
/**
 * Function that triggers a native `window.alert`.
 * @param message - The message to display.
 */
type AlertHandler = (message?: any) => void;
/**
 * Function that triggers a native `window.confirm`.
 * @param message - The question to display.
 * @returns True if the user clicks OK, false otherwise.
 */
type ConfirmHandler = (message?: string) => boolean;
/**
 * Union of all possible handler functions returned by the hook.
 */
type DialogHandler = PromptHandler | AlertHandler | ConfirmHandler;

/**
 * Result tuple returned by [useDisplayMedia](https://react-tools.ndria.dev/hooks/api-dom/useDisplayMedia).
 *
 */
type UseDisplayMediaResult = [
    /** The active display capture stream. `undefined` before `start()` is called or after `stop()`. */
    MediaStream | undefined,
    /** `start` — opens the display-capture picker and starts the stream. */
    (options?: TDisplayMediaStreamOptions) => Promise<void>,
    /** `stop` — stops all tracks and releases the stream. */
    () => void
];

/**
 * Optional callbacks for [useEyeDropper](https://react-tools.ndria.dev/hooks/api-dom/useEyeDropper).
 *
 */
interface UseEyeDropperProps {
    /** Called immediately when `open()` is invoked, before the picker appears. */
    onStart?: () => void;
    /**
     * Called with the selected hex colour string once the user picks a colour.
     * @param result - The selected colour as a CSS hex string (e.g. `"#ff5733"`).
     */
    onFinish?: (result: `#${string}`) => void;
}
/**
 * Result object returned by [useEyeDropper](https://react-tools.ndria.dev/hooks/api-dom/useEyeDropper).
 */
interface UseEyeDropperResult {
    /** `true` when the EyeDropper API is available in the current browser. */
    isSupported: boolean;
    /**
     * Opens the colour picker UI.
     * Resolves with the selected hex colour string.
     * @param signal - Optional `AbortSignal` to cancel the picker programmatically.
     */
    open: (signal?: AbortSignal) => Promise<`#${string}`> | Promise<void>;
}

/**
 * Options used by [useFetch](https://react-tools.ndria.dev/hooks/api-dom/useFetch).
 */
interface UseFetchOptions extends RequestInit {
    /**
     * Called whenever the loading state toggles.
     * @param loading - `true` when a request begins; `false` when it completes or errors.
     */
    onLoading?: (loading: boolean) => void;
    /**
     * Called when the request throws an error (network failure, non-OK response, etc.).
     * @param error - The caught error value.
     */
    onError?: (error: unknown) => void;
    /**
     * When `true`, the hook participates in React's Suspense protocol.
     * The component suspends until the fetch resolves, integrating with `<Suspense>` and `<ErrorBoundary>`.
     * @default false
     */
    suspensable?: boolean;
}
/**
 * Result tuple returned by [useFetch](https://react-tools.ndria.dev/hooks/api-dom/useFetch).
 *
 * @template T The expected response body type.
 */
type UseFetchResult<T> = [
    /** Parsed response data. `undefined` before the first successful request and after an error. */
    T | undefined,
    /** `call` — executes the fetch request. Accepts optional per-call `RequestInit` overrides merged with the hook-level options. */
    (conf?: RequestInit) => Promise<void>,
    /** `true` while the request is in-flight. */
    boolean,
    /** `error` — the caught error value when the request fails; `undefined` otherwise. */
    unknown
];

/**
 * Props accepted by [useFullscreen](https://react-tools.ndria.dev/hooks/api-dom/useFullscreen).
 *
 */
interface UseFullscreenProps {
    /**
     * Callback function for entering fullscreen mode.
     * Can be synchronous or asynchronous.
     */
    onEnter?: () => void | Promise<void>;
    /**
     * Callback function triggered when the fullscreen state changes.
     * @param {Event} event - The native fullscreen change event.
     */
    onChange?: (evt: Event) => void;
    /**
     * Callback function for exiting fullscreen mode.
     * Can be synchronous or asynchronous.
     */
    onExit?: () => void | Promise<void>;
}
/**
 * Result tuple returned by [useFullscreen](https://react-tools.ndria.dev/hooks/api-dom/useFullscreen).
 *
 * @template T Type of the observed DOM element.
 */
type UseFullscreenResult<T extends Element> = [
    /** `true` when the element is currently in fullscreen mode. */
    boolean,
    /** Callback ref to attach to the target element. */
    RefCallback<T>,
    /**`enter` — requests fullscreen on the attached element, calling `onEnter` first if provided. */
    (opts?: FullscreenOptions) => Promise<void>,
    /** `exit` — exits fullscreen, calling `onExit` first if provided. */
    () => Promise<void>
];

/**
 * Props accepted by [useIdleCallback](https://react-tools.ndria.dev/hooks/api-dom/useIdleCallback)
 */
interface UseIdleCallbackProps {
    /** Callback passed to `requestIdleCallback`, invoked during browser idle periods. */
    cb: IdleRequestCallback;
    /** Options forwarded to `requestIdleCallback` (e.g. `{ timeout: 2000 }`). */
    opts?: IdleRequestOptions;
}
/**
 * Result tuple returned by [useIdleCallback](https://react-tools.ndria.dev/hooks/api-dom/useIdleCallback).
 *
 */
type UseIdleCallbackResult = [
    /** `location` - possible states of the Geolocation API: supported (with an optional position) or not supported. */
    boolean,
    /** `invoke` - function to invoke execution. */
    () => void,
    /** `cancel` - function to cancel execution. */
    () => void
];

/**
 * Props for the [useInterval](https://react-tools.ndria.dev/hooks/api-dom/useInterval).
 * @template T Type of callback function parameters.
 */
interface UseIntervalProps<T extends unknown[]> {
    /** Callback executed on each interval tick. */
    callback: (...args: T) => void;
    /**
     * Interval period in milliseconds.
     * The interval does not start automatically — call `start()` to begin.
     */
    delay: number;
}
/**
 * Result tuple returned by [useInterval](https://react-tools.ndria.dev/hooks/api-dom/useInterval).
 *
 * @template T Type of the callback function parameters.
 */
type UseIntervalResult<T extends unknown[]> = [
    /** `start` - function to start interval. */
    (...args: T) => void,
    /** `stop` - function to clear interval. */
    () => void,
    /** `promisify` - function to promisify and start interval. */
    (...args: T) => Promise<void>
];

/**
 * Result tuple returned by [useLock](https://react-tools.ndria.dev/hooks/api-dom/useLock).
 *
 * | Index | Type | Description |
 * |-------|------|-------------|
 * | `[0]` | `(currName?, currCb?, currOpts?) => Promise<T>` | `acquire` — requests the named lock and invokes the callback. Per-call arguments override the hook-level defaults. |
 * | `[1]` | `() => Promise<LockManagerSnapshot>` | `query` — returns the current state of all held and pending locks via `navigator.locks.query()`. |
 *
 * @template T Return type of the lock callback.
 */
type UseLockResult<T> = [
    /** `acquire` — requests the named lock and invokes the callback. Per-call arguments override the hook-level defaults. */
    (currName?: string, currCb?: LockGrantedCallback<T>, currOpts?: LockOptions) => Promise<T>,
    /** `query` — returns the current state of all held and pending locks via `navigator.locks.query()`. */
    () => Promise<LockManagerSnapshot>
];

/**
 * Props accepted by [useMediaQuery](https://react-tools.ndria.dev/hooks/api-dom/useMediaQuery).
 *
 */
interface UseMediaQueryProps {
    /** media query to test. */
    mediaQuery: string;
    /** MediaQueryListEvent change handler. */
    onChange?: (evt: MediaQueryListEvent) => void;
}
/**
 * Result object returned by [useMediaQuery](https://react-tools.ndria.dev/hooks/api-dom/useMediaQuery).
 */
interface UseMediaQueryResult {
    /**
     * `true` when the CSS media query currently matches; `false` otherwise.
     * Re-evaluated whenever the match state changes (component re-renders).
     */
    matches: boolean;
    /**
     * The serialised form of the evaluated media query string
     * (e.g. `"(max-width: 768px)"`), as reported by `MediaQueryList.media`.
     */
    media: string;
}

/**
 * Options accepted by [useParallelPromises](https://react-tools.ndria.dev/hooks/api-dom/useParallelPromises).
 */
type UseParallelPromisesOptions = {
    /**
     * Controls how long resolved results are 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 cache entry expires after the given
     *     number of seconds from the moment the promise resolves. Expired entries are deleted on
     *     the next render and the factory is re-invoked.
     *   - **`undefined`** *(default)* — The cache entry persists indefinitely across mounts and
     *     unmounts for the lifetime of the module.
     */
    cache?: "unmount" | number;
    /**
     * An optional array of explicit string keys used to
     *   identify each factory in the cache, positionally aligned with the `factories` array.
     *   - When provided, `identifiers[i]` is used as the cache key for `factories[i]`.
     *   - When omitted, the cache key is derived by serialising the factory function via
     *     `toString()`, which may be unreliable after minification. Providing stable explicit
     *     identifiers is strongly recommended in production builds.
     */
    identifiers?: string[];
};
/**
 * Parameters accepted by [useParallelPromises](https://react-tools.ndria.dev/hooks/api-dom/useParallelPromises).
 *
 * @template T - A readonly tuple of zero-argument async factory functions. Inferred automatically from the `factories` argument. The return types of each factory determine the corresponding entry in the result tuple.
 */
type UseParallelPromisesProps<T extends readonly (() => Promise<any>)[]> = {
    /**
     * A readonly tuple of factory functions, each returning a `Promise`.
     *   All factories are invoked in parallel on the first render (or after invalidation).
     *   Each factory must be a zero-argument function: `() => Promise<any>`.
     */
    factories: T;
    /**
     * A React dependency array (same semantics as `useEffect`).
     *   When any dependency changes, the cached result for the affected factory is considered
     *   stale and the promise is re-executed on the next render.
     */
    deps: DependencyList;
    /**
     * Optional configuration object.
     *   See {@link UseParallelPromisesOptions}.
     */
    options?: UseParallelPromisesOptions;
};
/**
 * Return value of [useParallelPromises](https://react-tools.ndria.dev/hooks/api-dom/useParallelPromises).
 *
 * @template T - The readonly tuple of factory functions passed to the hook. Used to infer
 *   the type of each entry in `result`.
 */
type UseParallelPromisesResult<T extends readonly (() => Promise<any>)[]> = {
    /**
     * A mutable
     *   tuple whose length and types mirror the `factories` input. `result[K]` is the awaited
     *   return type of `factories[K]`. This property is only accessible after all promises have
     *   fulfilled; if any promise is still pending the component suspends, and if any promise
     *   rejects the error is re-thrown for the nearest `<ErrorBoundary>` to catch.
     */
    result: {
        -readonly [K in keyof T]: Awaited<ReturnType<T[K]>>;
    };
    /**
     * A stable callback that clears **all** entries from
     *   the shared module-level cache and triggers a re-render, causing every factory to be
     *   re-invoked on the next render cycle. Useful for manual cache invalidation (e.g. after
     *   a mutation).
     */
    invalidate: () => void;
};

/**
 * Result tuple returned by [usePublishSubscribe](https://react-tools.ndria.dev/hooks/api-dom/usePublishSubscribe).
 *
 * @template T Type of the message payload exchanged on the topic.
 */
type UsePublishSubscribeResult<T> = [
    /** `subscribe` — registers a listener for the topic. Returns an `unsubscribe` function; unsubscribes automatically on component unmount. */
    (listener: (value?: T) => void | Promise<void>) => () => void,
    /** `publish` — broadcasts `value` to all current subscribers of the topic. */
    (value?: T) => Promise<void>
];

/**
 * Props for the [useRaf](https://react-tools.ndria.dev/hooks/api-dom/useRaf).
 * @template T Type of arguments passed to the requestAnimationFrame callback function.
 */
interface UseRafProps<T extends unknown[]> {
    /**
     * Callback invoked on each animation frame.
     * @param timeElapsed - Milliseconds elapsed since the RAF loop started.
     * @param repeat - function which, if invoked, re-executes the requestAnimationFrame with the callback itself.
     * @param args - various parameters can be added, passed with the invocation function returned by the hook.
     */
    cb: (timeElapsed: number, repeat: () => void, ...args: T) => void;
}
/**
 * Result object returned by [useRaf](https://react-tools.ndria.dev/hooks/api-dom/useRaf).
 *
 */
type UseRafResult<T extends unknown[]> = [
    /** `start` - function to invoke requestAnimationFrame. */
    (...args: T) => void,
    /** `cancel` — function to invoke cancelAnimationFrame. */
    () => void
];

/**
 * Whether the `prefers-reduced-motion` media query is active, as returned by [useReducedMotion](https://react-tools.ndria.dev/hooks/api-dom/useReducedMotion).
 * `true` when the user has requested reduced motion; `false` otherwise.
 */
type UseReducedMotionResult = boolean;

/**
 * Parameters accepted by [useScreenWakeLock](https://react-tools.ndria.dev/hooks/api-dom/useScreenWakeLock).
 */
interface UseScreenWakeLockProps {
    /**
     * Function executed when lock is released.
     */
    onRelease?: (evt?: Event) => void;
}
/**
 * Screen wake lock info object returned as the first element of [useScreenWakeLock](https://react-tools.ndria.dev/hooks/api-dom/useScreenWakeLock)'s tuple.
 */
interface UseScreenWakeLockInfo {
    /** `true` when the Screen Wake Lock API is available in the current browser. */
    isSupported: boolean;
    /**
     * The lock type currently held (`"screen"`), or `null` when no lock is active.
     */
    type: "screen" | null;
    /**
     * `true` when a wake lock is currently active; `false` when released; `null` before the
     * first `acquire()` call.
     */
    isActive: boolean | null;
}
/**
 * Result tuple returned by [useScreenWakeLock](https://react-tools.ndria.dev/hooks/api-dom/useScreenWakeLock).
 *
 */
type UseScreenWakeLockResult = [
    /** Current wake lock status. See {@link UseScreenWakeLockInfo}. */
    UseScreenWakeLockInfo,
    /** `acquire` — requests a screen wake lock. No-op when already active. */
    () => Promise<void>,
    /**`release` — releases the active wake lock. No-op when not active. */
    () => Promise<void>
];

/**
 * Result object returned by [useShare](https://react-tools.ndria.dev/hooks/api-dom/useShare).
 */
interface UseShareResult {
    /**
     * Invoke the native share sheet with the provided data.
     * @param data - `ShareData` object containing `title`, `text`, `url`, and/or `files`.
     */
    share: (data: ShareData) => Promise<void>;
    /** `true` when the Web Share API (`navigator.share`) is available in the current browser. */
    isSupported: boolean;
}

/**
 * Options that control the throttle behaviour of [useThrottle](https://react-tools.ndria.dev/hooks/api-dom/useThrottle).
 * Exactly one of `delay` or `waitFn` should be set.
 */
type UseThrottleOptions = {
    /**
     * Minimum number of milliseconds that must elapse between successive invocations
     * of `fn`. After `fn` is called, further calls are dropped until the delay has
     * expired. A value of `0` allows back-to-back calls on consecutive ticks.
     * Mutually exclusive with `waitFn`.
     */
    delay?: number;
    /**
     * When `true`, throttling is based on the completion of `fn` rather than a fixed
     * time interval. The next invocation is only allowed once the `Promise` returned
     * by the previous call has settled. If `fn` returns `void` (i.e. is synchronous),
     * the lock is released immediately after the call returns.
     * Mutually exclusive with `delay`.
     */
    waitFn?: boolean;
};
/**
 * Parameters accepted by [useThrottle](https://react-tools.ndria.dev/hooks/api-dom/useThrottle).
 *
 * @template T - The argument tuple type of the function to throttle. Inferred automatically from the `fn` argument.
 */
type UseThrottleProps<T extends unknown[]> = {
    /**
     * The function to throttle. Accepts any number of arguments and may return either
     * `void` or a `Promise<void>`. The same argument types are preserved on the returned
     * throttled function.
     */
    fn: (...args: T) => void | Promise<void>;
    /**
     * Configuration that controls the throttle strategy. Exactly one of `delay` or
     * `waitFn` must be provided — supplying neither will cause the throttled function
     * to throw at call time.
     */
    opts: UseThrottleOptions;
};
/**
 * Return value of {@link https://ndriadev.github.io/react-tools/hooks/api-dom/useThrottle}.
 *
 * @template T - The argument tuple type of the throttled function.
 */
type UseThrottleResult<T extends unknown[]> = [
    /**
     * The throttled version of `fn`. Calls are forwarded to `fn` only when the
     * throttle condition is not active; otherwise they are silently dropped.
     * Preserves the original argument signature of `fn`.
     */
    (...args: T) => void,
    /**
     * Resets the throttle state immediately, allowing the next call to `fn` to pass
     * through regardless of whether the delay has elapsed or the previous `Promise`
     * has settled.
     */
    () => void,
    /**
     * Bypasses throttling entirely and invokes `fn` immediately with the provided
     * arguments, also resetting the throttle state so the next throttled call is
     * treated as a fresh invocation.
     */
    (...args: T) => void
];

/**
 * Parameters accepted by [useTimeout](https://react-tools.ndria.dev/hooks/api-dom/useTimeout).
 *
 * @template TArgs - The argument tuple type of the callback. Inferred automatically from the `callback` argument.
 */
type UseTimeoutProps<TArgs extends unknown[]> = {
    /**
     * The function to invoke after `delay` milliseconds. Accepts any number of
     * arguments whose types are preserved on the returned `start` and `startPromisified`
     * functions.
     */
    callback: (...args: TArgs) => void;
    /**
     * Duration in milliseconds to wait before invoking `callback`. Passed directly
     * to `setTimeout`. A value of `0` defers execution to the next event loop tick.
     */
    delay: number;
};
/**
 * Return value of [useTimeout](https://react-tools.ndria.dev/hooks/api-dom/useTimeout).
 *
 * @template TArgs - The argument tuple type of the callback.
 */
type UseTimeoutResult<TArgs extends unknown[]> = [
    /**
     * Schedules `callback` to run after `delay` milliseconds, forwarding any provided
     * arguments. Cancels any previously pending timeout before scheduling a new one,
     * so calling this multiple times in quick succession only results in a single
     * invocation.
     */
    (...args: TArgs) => void,
    /**
     * Cancels the currently pending timeout, if any. Has no effect if no timeout
     * is active.
     */
    () => void,
    /**
     * Schedules `callback` exactly like the first tuple entry, but returns a `Promise`
     * that resolves once `callback` has been invoked. Useful when downstream logic
     * needs to await the timeout completion. Cancels any previously pending timeout
     * before scheduling a new one.
     */
    (...args: TArgs) => Promise<void>
];

/**
 * Parameters accepted by [useTitle](https://react-tools.ndria.dev/hooks/api-dom/useTitle).
 */
type UseTitleProps = {
    /**
     * Optional title to set on `document.title` immediately. When provided, the title
     * is applied both synchronously in the render body (for non-React environments such
     * as SSR or usage outside a component tree) and inside a `useLayoutEffect` for
     * standard React usage. When omitted, the current document title is left unchanged.
     */
    title?: string;
};
/**
 * Return value of [useTitle](https://react-tools.ndria.dev/hooks/api-dom/useTitle).
 */
type UseTitleResult = [
    /**
     * Returns the current value of `document.title` at call time. Not reactive —
     * does not trigger a re-render when the title changes externally. Call it on
     * demand when you need to read the latest title.
     */
    () => string,
    /**
     * Sets `document.title` to the provided string immediately. Can be called at
     * any time, inside or outside a component, and takes effect synchronously.
     */
    (title: string) => void
];

/**
 * Result object returned by [useVibrate](https://react-tools.ndria.dev/hooks/api-dom/useVibrate)
 */
interface UseVibrateResult {
    /**
     * Trigger a vibration pattern using the Vibration API.
     * @param pattern - Duration in ms, or an array alternating vibration/pause durations.
     */
    vibrate: (pattern: VibratePattern) => void;
    /** `true` when the Vibration API (`navigator.vibrate`) is available in the current environment. */
    isSupported: boolean;
    /** function to stop vibrating. */
    cancel: () => void;
}

/**
 * **`usePublishSubscribe`**: Communication system based on PubSub pattern. Instantiate a topic and use the publish and subscribe functions to communicate.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/usePublishSubscribe)
 * @template T Type of the message payload exchanged on the topic.
 * @param {string} topic
 * @returns {UsePublishSubscribeResult} result {@link UsePublishSubscribeResult}
 */
declare const usePublishSubscribe: <T>(topic: string) => UsePublishSubscribeResult<T>;

/**
 * **`useScript`**: Hook to dinamically load an external script like Google Analitycs.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useScript)
 * @param {UseScriptProps["attributes"]} attributes - {@link UseScriptProps}
 * @param {UseScriptProps["options"]} options - {@link UseScriptProps}
 * @returns {ReturnType<UseScript>} result {@link UseScript}
 */
declare const useScript: UseScript;

/**
 * **`useDebounce`**: Hook to delay a function execution with possibility to cancel execution and to invoke them immediately.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useDebounce)
 * @template T Type of the parameters function.
 * @param {UseDebounceFunction} fn - {@link UseDebounceFunction}
 * @param {UseDebounceOpts} opts - {@link UseDebounceOpts}
 * @returns {UseDebounceResult} result {@link UseDebounceResult}
 */
declare const useDebounce: <T extends unknown[]>(fn: UseDebounceFunction<T>, opts: UseDebounceOpts) => UseDebounceResult<T>;

/**
 * **`useThrottle`**: Hook to limit function execution frequency.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useThrottle)
 * @template T - The argument tuple type of the function to throttle. Inferred automatically from the `fn` argument.
 * @param {UseThrottleProps["fn"]} fn - {@link UseThrottleProps}
 * @param {UseThrottleProps["opts"]} opts - {@link UseThrottleProps}
 * @returns {UseThrottleResult} result {@link UseThrottleResult}
 */
declare const useThrottle: <T extends unknown[]>(fn: UseThrottleProps<T>["fn"], opts: UseThrottleProps<T>["opts"]) => UseThrottleResult<T>;

/**
 * **`useActiveElement`**: Hook that returns activeElement and listen its changes.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useActiveElement)
 * @returns {Element | null} activeELement
 */
declare const useActiveElement: () => Element | null;

/**
 * **`useRaf`**: Hook to execute a callback function with _requestAnimationFrame_ to optimize performance. Refer to (requestAnimationFrame)[https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame].
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useRaf)
 * @template T Type of arguments passed to the requestAnimationFrame callback function.
 * @param {UseRafProps["cb"]} cb - {@link UseRafProps}
 * @returns {UseRafResult} result {@link UseRafResult}
 */
declare const useRaf: <T extends unknown[]>(cb: UseRafProps<T>["cb"]) => UseRafResult<T>;

/**
 * **`useTimeout`**: Hook to handle setTimeout timer function with the possibility to clear and promisify execution.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useTimeout)
 * @template TArgs - The argument tuple type of the callback. Inferred automatically from the `callback` argument.
 * @param {UseTimeoutProps<T>["callback"]} callback - {@link UseTimeoutProps}
 * @param {UseTimeoutProps<T>["delay"]} delay - {@link UseTimeoutProps}
 * @returns {UseAudioResult} result {@link UseAudioResult}
 */
declare const useTimeout: <TArgs extends unknown[]>(callback: UseTimeoutProps<TArgs>["callback"], delay: UseTimeoutProps<TArgs>["delay"]) => UseTimeoutResult<TArgs>;

/**
 * **`useInterval`**: Hook to handle setInterval timer function with the possibility to clear and promisify execution.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useInterval)
 * @template T Type of callback function parameters.
 * @param {UseIntervalProps["callback"]} callback - {@link UseIntervalProps["callback"]}
 * @param {UseIntervalProps["delay"]} delay - {@link UseIntervalProps["delay"]}
 * @returns {UseIntervalResult} result {@link UseIntervalResult}
 */
declare const useInterval: <T extends unknown[]>(callback: UseIntervalProps<T>["callback"], delay: UseIntervalProps<T>["delay"]) => UseIntervalResult<T>;

/**
 * **`useTextSelection`**: Hook to track text selection.
 * @see [Selection API](https://developer.mozilla.org/en-US/docs/Web/API/Selection).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useTextSelection)
 * @param {UseTextSelectionProps} param - {@link UseTextSelectionProps}
 * @returns {UseTextSelectionResult} result {@link UseTextSelectionResult}
 */
declare const useTextSelection: ({ target, onStart, onChange, onEnd }?: UseTextSelectionProps) => UseTextSelectionResult;

/**
 * **`useClipboard`**: Hook to handle Clipboard.
 *
 * __*N.B.*__: The hook has the same compatibility issues as the Clipboard API for Firefox, i.e. it is currently impossible to read from the clipboard.
 * @see [Clipboard API](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useClipboard)
 * @param {UseClipboardProps} param - {@link UseClipboardProps}
 * @returns {UseClipboardResult} result {@link UseClipboardResult}
 */
declare function useClipboard({ useValue, dataType, target }: {
    useValue: true;
    dataType: "text";
    target?: RefObject<HTMLElement> | HTMLElement;
}): [string, (text: string) => Promise<void>, () => Promise<string>];
declare function useClipboard({ useValue, dataType, target }: {
    useValue: true;
    dataType: "any";
    target?: RefObject<HTMLElement> | HTMLElement;
}): [string | Blob | (string | Blob)[], (blob: Blob | Blob[]) => Promise<void>, () => Promise<string | Blob | (string | Blob)[]>];
declare function useClipboard({ useValue, dataType, target }: {
    useValue: false;
    dataType: "text";
    target?: RefObject<HTMLElement> | HTMLElement;
}): [(text: string) => Promise<void>, () => Promise<string>];
declare function useClipboard({ useValue, dataType, target }: {
    useValue: false;
    dataType: "any";
    target?: RefObject<HTMLElement> | HTMLElement;
}): [(blob: Blob | Blob[]) => Promise<void>, () => Promise<string | Blob | (string | Blob)[]>];

/**
 * **`useMediaQuery`**: Hook to handle CSS mediaQuery. It returns an object with __matches__ and __media__ properties and receives an optional _onChange_ function to handle _MediaQueryListEvent change_ event.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useMediaQuery)
 * @param {UseMediaQueryProps["mediaQuery"]} mediaQuery - {@link UseMediaQueryProps["mediaQuery"]}
 * @param {UseMediaQueryProps["onChange"]} [onChange] - {@link UseMediaQueryProps["onChange"]}
 * @returns {UseMediaQueryResult} result {@link UseMediaQueryResult}
 */
declare const useMediaQuery: (mediaQuery: UseMediaQueryProps["mediaQuery"], onChange?: UseMediaQueryProps["onChange"]) => UseMediaQueryResult;

/**
 * **`useColorScheme`**: Hook to handle ColorScheme.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useColorScheme)
 * @param {UseColorSchemeProps} param - {@link UseColorSchemeProps}
 * @returns {UseColorSchemeResult} result {@link UseColorSchemeResult}
 */
declare function useColorScheme({ defaultValue, getter, setter, returnValue }: {
    defaultValue: "dark" | "light" | "mediaQuery";
    getter?: () => "dark" | "light" | null | undefined;
    setter?: (schema: "light" | "dark") => void;
    returnValue: true;
}): ["light" | "dark", (schema: "light" | "dark") => void];
declare function useColorScheme({ defaultValue, getter, setter, returnValue }: {
    defaultValue: "dark" | "light" | "mediaQuery";
    getter?: () => "dark" | "light" | null | undefined;
    setter?: (schema: "light" | "dark") => void;
    returnValue: false;
}): ((schema: "light" | "dark") => void);

/**
 * **`useReducedMotion`**: Hook to detect if user prefers to reduce motion.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useReducedMotion)
 * @returns {UseReducedMotionResult} result {@link UseReducedMotionResult}
 */
declare const useReducedMotion: () => UseReducedMotionResult;

/**
 * **`useTitle`**: Hook to handling app page title. It works _outside Component_ also and it returns array of two functions to read and write title.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useTitle)
 * @param {UseTitleProps["title"]} [title] - {@link UseTitleProps["title"]}
 * @returns {UseTitleResult} result {@link UseTitleResult}
 */
declare const useTitle: (title?: UseTitleProps["title"]) => UseTitleResult;

/**
 * **`useIdleCallback`**: Hook to invoke a callback when the browser is idle.
 * @see [requestIdleCallback](https://developer.mozilla.org/en-US/docs/Web/API/Window/requestIdleCallback) in React. The __options__ parameter differs from _IdleRequestOptions_ type: it adds the possibility to pass another property __unsupportedBehavior__ to specify what do if requestIdleCallback is not supported.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useIdleCallback)
 * @param {UseIdleCallbackProps["cb"]} cb - {@link UseIdleCallbackProps["cb"]}
 * @param {UseIdleCallbackProps["opts"]} [opts] - {@link UseIdleCallbackProps["opts"]}
 * @returns {UseIdleCallbackResult} result {@link UseIdleCallbackResult}
 */
declare const useIdleCallback: (cb: UseIdleCallbackProps["cb"], opts?: UseIdleCallbackProps["opts"]) => UseIdleCallbackResult;

/**
 * **`useFullscreen`**:
 * @see [Fullscreen API](https://developer.mozilla.org/en-US/docs/Web/API/Fullscreen_API).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useFullscreen)
 * @template T Type of the observed DOM element.
 * @param {UseAudioProps} param - {@link UseAudioProps}
 * @returns {UseAudioResult} result {@link UseAudioResult}
 */
declare const useFullscreen: <T extends Element>({ onChange, onEnter, onExit }?: UseFullscreenProps) => UseFullscreenResult<T>;

/**
 * **`useBattery`**: Hook for accessing and monitoring device battery status.
 * @see [Battery Status API](https://developer.mozilla.org/en-US/docs/Web/API/Battery_Status_API).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useBattery)
 * @param {UseBatteryProps} [opts] - {@link UseBatteryProps}
 * @returns {BatteryStatus} result {@link BatteryStatus}
 */
declare const useBattery: (opts?: UseBatteryProps) => BatteryStatus;

/**
 * **`useGeolocation`**: Hook to use user's geographic location.
 * @see [GeoLocation API](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation_API).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useGeolocation)
 * @param {UseGeolocationProps} param - {@link UseGeolocationProps}
 * @returns {UseGeoLocationResult} result {@link UseGeoLocationResult}
 */
declare const useGeolocation: ({ mode, locationOptions, onError }: UseGeolocationProps) => UseGeoLocationResult;

/**
 * **`useShare`**:
 * @see (https://developer.mozilla.org/en-US/docs/Web/API/Web_Share_API).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useShare)
 * @returns {UseShareResult} result {@link UseShareResult}
 */
declare const useShare: () => UseShareResult;

/**
 * **`useEyeDropper`**:
 * @see [EyeDropper API](https://developer.mozilla.org/en-US/docs/Web/API/EyeDropper_API).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useEyeDropper)
 * @param {UseEyeDropperProps} param - {@link UseEyeDropperProps}
 * @returns {UseEyeDropperResult} result {@link UseEyeDropperResult}
 */
declare const useEyeDropper: ({ onStart, onFinish }?: UseEyeDropperProps) => UseEyeDropperResult;

/**
 * **`useDialogBox`**: Hook to use Dialog Box _prompt_, _alert_ or _confirm_.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useDialogBox)
 * @param {DialogType} type - {@link DialogType}
 * @returns {DialogHandler} result {@link DialogHandler}
 */
declare function useDialogBox(type: "prompt"): PromptHandler;
declare function useDialogBox(type: "alert"): AlertHandler;
declare function useDialogBox(type: "confirm"): ConfirmHandler;

/**
 * **`useDeviceMotion`**:
 * @see [device motion](https://developer.mozilla.org/en-US/docs/Web/API/Window/devicemotion_event).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useDeviceMotion)
 * @returns {UseDeviceMotionResult} result {@link UseDeviceMotionResult}
 */
declare const useDeviceMotion: () => UseDeviceMotionResult;

/**
 * **`useDeviceOrientation`**:
 * @see [device orientation](https://developer.mozilla.org/en-US/docs/Web/API/Window/deviceorientation_event).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useDeviceOrientation)
 * @returns {UseDeviceOrientationResult} result {@link UseDeviceOrientationResult}
 */
declare const useDeviceOrientation: () => UseDeviceOrientationResult;

/**
 * **`useVibrate`**: Hook to use device vibration hardware.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useVibrate)
 * @returns {UseVibrateResult} result {@link UseVibrateResult}
 */
declare const useVibrate: () => UseVibrateResult;

/**
 * **`useBluetooth`**: hook to connect and interact with bluetooth devices.
 * @see [Web Bluetooth API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Bluetooth_API).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useBLuetooth)
 * @returns {UseBluetoothResult} result {@link UseBluetoothResult}
 */
declare const useBluetooth: () => UseBluetoothResult;

/**
 * **`useScreenWakeLock`**:
 * @see [Screen Wake Lock API](https://developer.mozilla.org/en-US/docs/Web/API/Screen_Wake_Lock_API).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useScreenWakeLock)
 * @param {UseScreenWakeLockProps["onRelease"]} [onRelease] - {@link UseScreenWakeLockProps}
 * @returns {UseScreenWakeLockResult} result {@link UseScreenWakeLockResult}
 */
declare const useScreenWakeLock: (onRelease?: UseScreenWakeLockProps["onRelease"]) => UseScreenWakeLockResult;

/**
 * **`useSpeechRecognition`**: Hook to use _SpeechRecognition API_.
 * @see [Web Speech API](https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useSpeechRecognition)
 * @param {UseSpeechRecognitionProps} param - {@link UseSpeechRecognitionProps}
 * @returns {[SpeechRecognitionState, (config?: SpeechRecognitionConfig) => void, () => void, (resultAlso?: boolean) => void]} result {@link SpeechRecognitionState} {@link SpeechRecognitionConfig}
 */
declare const useSpeechRecognition: ({ alreadyStarted, defaultConfig, onAudioStart, onAudioEnd, onEnd, onError, onNoMatch, onResult, onSoundStart, onSoundEnd, onSpeechStart, onSpeechEnd, onStart }: UseSpeechRecognitionProps) => [SpeechRecognitionState, (config?: SpeechRecognitionConfig) => void, () => void, (resultAlso?: boolean) => void];

/**
 * **`useSpeechSynthesis`**: Hook to use _SpeechSynthesis API_.
 * @see [Web Speech API](https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesis).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useSpeechSynthesis)
 * @param {UseSpeechSynthesisProps} [opts] - {@link UseSpeechSynthesisProps}
 * @returns {ReturnType<UseSpeechSynthesis>} result {@link UseSpeechSynthesis}
 */
declare const useSpeechSynthesis: UseSpeechSynthesis;

/**
 * **`useFPS`**: Hook to detect FPS (Frames per second).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useFPS)
 * @param {UseFPSProps} param - {@link UseFPSProps}
 * @returns {UseFPSResult} result {@link UseFPSResult}
 */
declare const useFPS: ({ everySeconds, windowSize }?: UseFPSProps) => UseFPSResult;

/**
 * **`usePIP`**:
 * @see [(Picture-in-Picture API)](https://developer.mozilla.org/en-US/docs/Web/API/Picture-in-Picture_API).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/usePIP)
 * @param {UsePIPProps} param - {@link UsePIPProps}
 * @returns {UsePIPResult} result {@link UsePIPResult}
 */
declare const usePIP: ({ onOpen, onOpened, onClose, onError, target }: UsePIPProps) => UsePIPResult;

/**
 * **`useDocumentPIP`**:
 * @see [(Document-Picture-in-Picture API)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Picture-in-Picture_API).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useDocumentPIP)
 * @param {UseDocumentPIPProps} param - {@link UseDocumentPIPProps}
 * @returns {UseDocumentPIPProps} result {@link UseDocumentPIPProps}
 */
declare const useDocumentPIP: ({ options, onOpen, onOpened, onClose, onError }: UseDocumentPIPProps) => UseDocumentPIPResult;

/**
 * **`usePopover`**:
 * @see [Popover API](https://developer.mozilla.org/en-US/docs/Web/API/Popover_API).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/usePopover)
 * @template T - The HTML element type the attributes apply to.
 * @param {UsePopoverProps} param - {@link UsePopoverProps}
 * @returns {UsePopoverResult} result {@link UsePopoverResult}
 */
declare function usePopover({ mode, onBeforeToggle, onToggle }: UsePopoverProps): UsePopoverResult;

/**
 * **`useRemotePlayback`**:
 * @see [RemotePlayback API](https://developer.mozilla.org/en-US/docs/Web/API/RemotePlayback).
 * @template T - The `HTMLMediaElement` subtype (`HTMLVideoElement`, `HTMLAudioElement`, etc.) that the ref will be attached to.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useRemotePlayback)
 * @param {UseRemotePlaybackProps} param - {@link UseRemotePlaybackProps}
 * @returns {UseRemotePlaybackResult} result {@link UseRemotePlaybackResult}
 */
declare const useRemotePlayback: <T extends HTMLMediaElement>({ onConnecting, onConnect, onDisconnect, onError }?: UseRemotePlaybackProps) => UseRemotePlaybackResult<T>;

/**
 * **`useAnimation`**: hook to implement animation on elements.
 * @see [Web Animations API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Animations_API).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useAnimation)
 * @template T Type of the target DOM element (defaults to `Element`).
 * @param {UseAnimationProps} param - {@link UseAnimationProps}
 * @returns {UseAnimationResult} result {@link UseAnimationResult}
 */
declare const useAnimation: <T extends Element>({ keyFrames, immediate, opts, onCancel, onFinish, onRemove, onError }: UseAnimationProps) => UseAnimationResult<T>;

/**
 * **`useAudio`**: Hook to use an HTML audio element.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useAudio)
 * @param {UseAudioProps} param - {@link UseAudioProps}
 * @returns {UseAudioResult} result {@link UseAudioResult}
 */
declare const useAudio: (props: react.MediaHTMLAttributes<HTMLAudioElement>) => {
    MediaElement: react.ReactElement<react.DetailedReactHTMLElement<react.HTMLAttributes<HTMLAudioElement>, HTMLAudioElement>, string | react.JSXElementConstructor<any>>;
    state: HTMLMediaState;
    controls: {
        play: () => Promise<void> | undefined;
        pause: () => void;
        seek: (time: number) => void;
        playbackRate: (playbackRate: number) => void;
        volume: (volume: number) => void;
        mute: () => void;
        unmute: () => void;
    };
    ref: react.MutableRefObject<HTMLAudioElement | null>;
};

/**
 * **`useVideo`**: Hook to use an HTML video element. [See demo](https://react-tools.ndria.dev/#/hooks/api-dom/useVideo)
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useAudio)
 * @param {UseVideoProps} param - {@link UseVideoProps}
 * @returns {UseVideoResult} result {@link UseVideoResult}
 */
declare const useVideo: (props: react.MediaHTMLAttributes<HTMLVideoElement>) => {
    MediaElement: react.ReactElement<react.DetailedReactHTMLElement<react.HTMLAttributes<HTMLAudioElement>, HTMLAudioElement>, string | react.JSXElementConstructor<any>>;
    state: HTMLMediaState;
    controls: {
        play: () => Promise<void> | undefined;
        pause: () => void;
        seek: (time: number) => void;
        playbackRate: (playbackRate: number) => void;
        volume: (volume: number) => void;
        mute: () => void;
        unmute: () => void;
    };
    ref: react.MutableRefObject<HTMLVideoElement | null>;
};

/**
 * **`useEventSource`**:
 * @see [EventSource](https://developer.mozilla.org/en-US/docs/Web/API/EventSource) or [Server-Sent-Events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events) connection to an HTTP server, which sends events in text/event-stream format.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useEventSource)
 * @template T Expected type of the parsed message data.
 * @param {UseEventSourceProps} param - {@link UseEventSourceProps}
 * @returns {UseEventSourceResult} result {@link UseEventSourceResult}
 */
declare const useEventSource: <T>({ url, opts, events, immediateConnection, onOpen, onError, onMessage }: UseEventSourceProps) => UseEventSourceResult<T>;

/**
 * **`useWebSocket`**: Hook for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection.
 * @see [WebSocket API](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useWebSocket)
 * @template T Type of the data exchanged on the socket.
 * @param {UseWebSocketProps<T>} param - {@link UseWebSocketProps}
 * @returns {UseWebSocketResult<T>} result {@link UseWebSocketResult}
 */
declare const useWebSocket: <T = string | ArrayBuffer | Blob>({ url, protocols, binaryType, onOpen, onMessage, onError, onClose, immediateConnection, bufferingData, reconnect, parser }: UseWebSocketProps<T>) => UseWebSocketResult<T>;

/**
 * **`usePermission`**: Hook to query the status of API permissions attributed to the current context.
 * @see [PermissionAPI](https://developer.mozilla.org/en-US/docs/Web/API/Permissions_API).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/usePermission)
 * @param {TPermissionName} param - {@link TPermissionName}
 * @returns {UsePermissionResult} result {@link UsePermissionResult}
 */
declare function usePermission(permission: TPermissionName): UsePermissionResult;

/**
 * **`useMediaDevices`**:
 * @see [MediaDevices](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices) interface methods, that give access to any hardware source of media data.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useMediaDevices)
 * @param {UseMediaDevicesProps} param - {@link UseMediaDevicesProps}
 * @returns {UseMediaDevicesResult} result {@link UseMediaDevicesResult}
 */
declare function useMediaDevices(action: "devicesList"): (onDevicesChange?: ((evt: Event) => void | Promise<void>) | undefined) => Promise<MediaDeviceInfo[]>;
declare function useMediaDevices(action: "supportedConstraintsList"): (onDevicesChange?: ((evt: Event) => void | Promise<void>) | undefined) => MediaTrackSupportedConstraints;
declare function useMediaDevices(action: "DisplayCapture"): (options?: DisplayMediaStreamOptions, onDevicesChange?: ((evt: Event) => void | Promise<void>) | undefined) => Promise<MediaStream>;
declare function useMediaDevices(action: "mediaInputCapture"): (constraints?: MediaStreamConstraints, onDevicesChange?: ((evt: Event) => void | Promise<void>) | undefined) => Promise<MediaStream>;

/**
 * **`useDisplayMedia`**: Hook to capture the contents of a display.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useDisplayMedia)
 * @returns {UseDisplayMediaResult} result {@link UseDisplayMediaResult}
 */
declare const useDisplayMedia: () => UseDisplayMediaResult;

/**
 * **`useWebWorker`**: Hook to use Web Worker, handling registration and communication.
 * @see [Web Worker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useWebWorker)
 * @param {UseWebWorkerProps} param - {@link UseWebWorkerProps}
 * @returns {UseWebWorkerResult} result {@link UseWebWorkerResult}
 */
declare const useWebWorker: ({ url, options, onMessage, onError, onMessageError }: UseWebWorkerProps) => UseWebWorkerResult;

/**
 * **`useWebWorkerFn`**: Hook to run expensive functions using a Web Worker without blocking the UI handling execution as Promise.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useWebWorkerFn)
 * @template T - The type of the function to execute inside the Web Worker. Must be a callable accepting any number of arguments and returning any value.
 * @param {UseWebWorkerFnProps<T>["fn"]} fn - {@link UseWebWorkerFnProps}
 * @param {UseWebWorkerFnProps<T>["deps"]} [deps] - {@link UseWebWorkerFnProps}
 * @returns {UseWebWorkerFnResult} result {@link UseWebWorkerFnResult}
 */
declare const useWebWorkerFn: <T extends (...args: unknown[]) => unknown>(fn: UseWebWorkerFnProps<T>["fn"], deps?: UseWebWorkerFnProps<T>["deps"]) => UseWebWorkerFnResult<T>;

/**
 * **`usePromise`**: Hook to resolve promise with Suspense support. The component that uses it, it need to be wrapped with Suspense component. This hook can be used in conditional blocks.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/usePromise)
 * @template T - The resolved value type of the promise returned by `promise`.
 * @param {UsePromiseProps["promise"]} promise - {@link UsePromiseProps}
 * @param {UsePromiseProps["deps"]} deps - {@link UsePromiseProps}
 * @param {UsePromiseProps["options"]} [options] - {@link UsePromiseProps}
 * @returns {T | UsePromiseResultWithInvalidate} result {@link T | UsePromiseResultWithInvalidate}
 */
declare function usePromise<T>(promise: () => Promise<T>, deps: DependencyList, options: {
    cache?: "unmount" | number;
    cleanOnError?: boolean;
    identifier?: string;
    invalidateManually?: undefined;
}): T;
declare function usePromise<T>(promise: () => Promise<T>, deps: DependencyList, options: {
    cache?: "unmount" | number;
    cleanOnError?: boolean;
    identifier?: string;
    invalidateManually?: false;
}): T;
declare function usePromise<T>(promise: () => Promise<T>, deps: DependencyList, options: {
    cache?: "unmount" | number;
    cleanOnError?: boolean;
    identifier?: string;
    invalidateManually?: true;
}): [T, () => void];

/**
 * **`useParallelPromises`** – Executes multiple promises **in parallel** with Suspense.
 *
 * Suspends the component until **all** promises are resolved,
 * similar to `Promise.all`. If at least one fails, it propagates the error to
 * the nearest `ErrorBoundary`.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useParallelPromises)
 * @template T - A readonly tuple of zero-argument async factory functions. Inferred automatically from the `factories` argument. The return types of each factory determine the corresponding entry in the result tuple.
 * @param {UseParallelPromisesProps["factories"]} factories - {@link UseParallelPromisesProps["factories"]}
 * @param {UseParallelPromisesProps["deps"]} deps - {@link UseParallelPromisesProps["deps"]}
 * @param {UseParallelPromisesProps["options"]} [options] - {@link UseParallelPromisesProps["options"]}
 * @returns {UseParallelPromisesResult} result {@link UseParallelPromisesResult}
 */
declare function useParallelPromises<const T extends readonly (() => Promise<any>)[]>(factories: UseParallelPromisesProps<T>["factories"], deps: UseParallelPromisesProps<T>["deps"], options?: UseParallelPromisesProps<T>["options"]): UseParallelPromisesResult<T>;

/**
 * **`useFetch`**:
 * @see [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) with more control and the possibility to execute request with suspense support.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useFetch)
 * @template T The expected response body type.
 * @param {RequestInfo | URL } url
 * @param {UseFetchOptions} param - {@link UseFetchOptions}
 * @returns {UseFetchResult} result {@link UseFetchResult}
 */
declare const useFetch: <T>(url: RequestInfo | URL, { suspensable, onError, onLoading, ...rest }: UseFetchOptions) => UseFetchResult<T>;

/**
 * **`useLock`**: Hook to use [Web Locks API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Locks_API). [See demo](https://react-tools.ndria.dev/#/hooks/api-dom/useLock)
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useAudio)
 * @template T Return type of the lock callback.
 * @param {string} [name]
 * @param {LockOptions} [opts]
 * @returns {UseLockResult} result {@link UseLockResult}
 */
declare const useLock: <T>(name?: string, cb?: LockGrantedCallback<T>, opts?: LockOptions) => UseLockResult<T>;

/**
 * **`useBroadcastChannel`**: hook to use broadcast channel.
 * @see [Broadcast Channel API](https://developer.mozilla.org/en-US/docs/Web/API/Broadcast_Channel_API).
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/useBroadcastChannel)
 * @param {UseBroadcastChannelProps} params - {@link UseBroadcastChannelProps}
 * @returns {UseBroadcastChannelResult} result {@link UseBroadcastChannelResult}
 */
declare const useBroadcastChannel: <T>({ name, onMessage, onError }: UseBroadcastChannelProps<T>) => UseBroadcastChannelResult<T>;

/**
 * **`use`**: Polyfill of React 19's `use` hook for React 16.8 – 18.
 *
 * Reads the value of a **Promise** or a **React Context**, suspending the
 * component (via Suspense) when the promise is still pending, and resuming
 * with the resolved value once it settles.
 * @see [📖 Documentation](https://react-tools.ndria.dev/hooks/api-dom/use)
 *
 * @param input - A `Promise<T>` or a `React.Context<T>`.
 * @returns The resolved value `T`.
 */
declare function usePolyfill<T>(input: Promise<T> | react.Context<T>): T;
declare const use: typeof usePolyfill;

export { usePIP as A, useParallelPromises as B, usePermission as C, usePopover as D, usePromise as E, usePublishSubscribe as F, useRaf as G, useReducedMotion as H, useRemotePlayback as I, useScreenWakeLock as J, useScript as K, useShare as L, useSpeechRecognition as M, useSpeechSynthesis as N, useTextSelection as O, useThrottle as P, useTimeout as Q, useTitle as R, useVibrate as S, useVideo as T, useWebSocket as U, useWebWorker as V, useWebWorkerFn as W, useActiveElement as a, useAnimation as b, useAudio as c, useBattery as d, useBluetooth as e, useBroadcastChannel as f, useClipboard as g, useColorScheme as h, useDebounce as i, useDeviceMotion as j, useDeviceOrientation as k, useDialogBox as l, useDisplayMedia as m, useDocumentPIP as n, useEventSource as o, useEyeDropper as p, useFPS as q, useFetch as r, useFullscreen as s, useGeolocation as t, use as u, useIdleCallback as v, useInterval as w, useLock as x, useMediaDevices as y, useMediaQuery as z };
export type { BluetoothCharacteristicUUID as $, AlertHandler as X, BatteryStatus as Y, Bluetooth as Z, BluetoothCharacteristicProperties as _, UseMediaDevicesResult as a$, BluetoothDescriptorUUID as a0, BluetoothDevice as a1, BluetoothDevicesOptions as a2, BluetoothRemoteGATTCharacteristic as a3, BluetoothRemoteGATTDescriptor as a4, BluetoothRemoteGATTServer as a5, BluetoothRemoteGATTService as a6, BluetoothScanFilters as a7, BluetoothServiceUUID as a8, CaptureController as a9, UseBroadcastChannelResult as aA, UseDebounceFunction as aB, UseDebounceOpts as aC, UseDebounceResult as aD, UseDeviceMotionResult as aE, UseDeviceOrientationResult as aF, UseDisplayMediaResult as aG, UseDocumentPIPProps as aH, UseDocumentPIPResult as aI, UseEventSourceProps as aJ, UseEventSourceResult as aK, UseEyeDropperProps as aL, UseEyeDropperResult as aM, UseFPSProps as aN, UseFPSResult as aO, UseFetchOptions as aP, UseFetchResult as aQ, UseFullscreenProps as aR, UseFullscreenResult as aS, UseGeoLocationResult as aT, UseGeolocationProps as aU, UseIdleCallbackProps as aV, UseIdleCallbackResult as aW, UseIntervalProps as aX, UseIntervalResult as aY, UseLockResult as aZ, UseMediaDevicesProps as a_, ConfirmHandler as aa, DialogHandler as ab, DialogType as ac, DocumentPIPOptions as ad, DocumentPictureInPictureEvent as ae, HTMLAttributes as af, PromptHandler as ag, SpeechGrammar as ah, SpeechGrammarList as ai, SpeechRecognition as aj, SpeechRecognitionConfig as ak, SpeechRecognitionControls as al, SpeechRecognitionErrorCode as am, SpeechRecognitionErrorEvent as an, SpeechRecognitionEvent as ao, SpeechRecognitionState as ap, SpeechSynthesisSpeakParam as aq, TDisplayMediaStreamOptions as ar, TPermissionName as as, TPermissionState as at, UseAnimationProps as au, UseAnimationResult as av, UseBatteryProps as aw, UseBluetoothResult as ax, UseBluetoothState as ay, UseBroadcastChannelProps as az, UseMediaQueryProps as b0, UseMediaQueryResult as b1, UsePIPProps as b2, UsePIPResult as b3, UseParallelPromisesOptions as b4, UseParallelPromisesProps as b5, UseParallelPromisesResult as b6, UsePermissionResult as b7, UsePopoverProps as b8, UsePopoverResult as b9, UseWebSocketProps as bA, UseWebSocketResult as bB, UseWebWorkerFnProps as bC, UseWebWorkerFnResult as bD, UseWebWorkerProps as bE, UseWebWorkerResult as bF, UsePublishSubscribeResult as ba, UseRafProps as bb, UseRafResult as bc, UseReducedMotionResult as bd, UseRemotePlaybackProps as be, UseRemotePlaybackResult as bf, UseScreenWakeLockInfo as bg, UseScreenWakeLockProps as bh, UseScreenWakeLockResult as bi, UseScript as bj, UseScriptProps as bk, UseScriptStatus as bl, UseShareResult as bm, UseSpeechRecognitionProps as bn, UseSpeechSynthesis as bo, UseSpeechSynthesisProps as bp, UseTextSelectionProps as bq, UseTextSelectionResult as br, UseThrottleOptions as bs, UseThrottleProps as bt, UseThrottleResult as bu, UseTimeoutProps as bv, UseTimeoutResult as bw, UseTitleProps as bx, UseTitleResult as by, UseVibrateResult as bz };