import { KeyboardEvent as KeyboardEvent$1, SyntheticEvent, ComponentType, LazyExoticComponent } from 'react';
import { K as KeyboardEventCode, R as RecursivePartial } from './react-tools.Ozx07lAu.js';

/**
 * Parameters accepted by [changeStringCase](https://react-tools.ndria.dev/utils/changeStringCase).
 */
type ChangeStringCaseProps = {
    /**
     * The input string to transform. When `undefined` or an empty string,
     * the function returns an empty string.
     */
    string?: string;
    /**
     * The target casing style to convert the input string to:
     * - **`"camelCase"`** — e.g. `"myVariableName"`
     * - **`"pascalCase"`** — e.g. `"MyVariableName"`
     * - **`"snakeCase"`** — e.g. `"my_variable_name"`
     * - **`"kebabCase"`** — e.g. `"my-variable-name"`
     */
    caseType: "pascalCase" | "snakeCase" | "kebabCase" | "camelCase";
    /**
     * An optional delimiter hint used when tokenising the input string. Accepts:
     * - **`"upperCase"`** — Splits on uppercase letters (for camelCase / PascalCase input).
     * - **`"lowerCase"`** — Splits on lowercase letters.
     * - **any other string** — Used as a literal separator character (e.g. `"-"`, `"_"`, `" "`).
     * When omitted, the function infers word boundaries automatically.
     */
    delimiter?: "upperCase" | "lowerCase" | string;
};

/**
 * Parameters accepted by [clickElementOnKeydownEvent](https://react-tools.ndria.dev/utils/clickElementOnKeydownEvent).
 *
 * A {@link KeyboardEventCode} string identifying the key that triggers a
 * programmatic `.click()` on the focused element when pressed (e.g. `"Enter"`,
 * `"Space"`). Returns a stable `keydown` event handler to attach to a DOM
 * element or `document`.
 */
type ClickElementOnKeydownEventProps = KeyboardEventCode;
/**
 * Return value of [clickElementOnKeydownEvent](https://react-tools.ndria.dev/utils/clickElementOnKeydownEvent).
 *
 * A `keydown` event handler that calls `.click()` on `document.activeElement`
 * whenever the configured key code is pressed.
 */
type ClickElementOnKeydownEventResult = (e: KeyboardEvent) => void;

/**
 * Parameters accepted by [defaultSerializer](https://react-tools.ndria.dev/utils/defaultSerializer).
 * A generic serializer that converts a value of type `T` to its string
 * representation using `JSON.stringify`. Used as the default serializer
 * in storage hooks and utilities when no custom serializer is provided.
 *
 * @template T - The type of the value to serialize.
 * @param target - The value to convert to a JSON string.
 * @returns The JSON string representation of `target`.
 */
type DefaultSerializerProps<T> = {
    target: T;
};

/**
 * Return value of [detectBrowser](https://react-tools.ndria.dev/utils/detectBrowser).
 * Detects the current browser based on `navigator.userAgent` and known
 * engine fingerprints.
 *
 * @returns One of `"chrome"`, `"firefox"`, `"safari"`, `"opera"`, `"edge"`,
 *   or `"No detection"` when the browser cannot be identified.
 */
type DetectBrowserResult = "chrome" | "firefox" | "safari" | "opera" | "edge" | "No detection";

/**
 * Options forwarded to `HTMLCanvasElement.toDataURL()` when converting a canvas
 * or image element to a base64-encoded data URL.
 */
interface ToDataURLOptions {
    /**
     * The MIME type of the output image format (e.g. `"image/png"`,
     * `"image/jpeg"`, `"image/webp"`). When omitted, defaults to `"image/png"`.
     */
    type?: string;
    /**
     * A number between `0` and `1` specifying the image quality for lossy
     * formats such as `"image/jpeg"` or `"image/webp"`. `1` is highest quality,
     * `0` is lowest. Ignored for lossless formats like `"image/png"`.
     */
    quality?: number;
}
/**
 * Options accepted by {@link getBase64} when the target is a plain object,
 * `Map`, `Set`, or array that requires custom serialization before encoding.
 *
 * @template T - The type of the value to serialize.
 */
interface UseBase64ObjectOptions<T> {
    /**
     * A custom serializer function that converts the target value to a string
     * before base64-encoding. Required for object, `Map`, `Set`, and array
     * targets — use `JSON.stringify` or a custom implementation depending on
     * the structure of `T`.
     */
    serializer: (v: T) => string;
}
/**
 * Parameters accepted by all overloads of [getBase64](https://react-tools.ndria.dev/utils/getBase64).
 *
 * @template T - The type of the input value. Determines which overload is
 *   selected and which `options` shape is accepted.
 */
type GetBase64Props<T> = {
    target: string;
    options?: undefined;
} | {
    target: Blob;
    options?: undefined;
} | {
    target: ArrayBuffer;
    options?: undefined;
} | {
    target: HTMLCanvasElement;
    options?: ToDataURLOptions;
} | {
    target: HTMLImageElement;
    options?: ToDataURLOptions;
} | {
    target: T extends object ? T : never;
    options?: UseBase64ObjectOptions<T>;
} | {
    target: T extends Map<string, unknown> ? T : never;
    options?: UseBase64ObjectOptions<T>;
} | {
    target: T extends Set<unknown> ? T : never;
    options?: UseBase64ObjectOptions<T>;
} | {
    target: T[];
    options?: UseBase64ObjectOptions<T[]>;
};

/**
 * Parameters accepted by [getKeyObjectFromValue](https://react-tools.ndria.dev/utils/getKeyObjectFromValue).
 *
 * @template T - The object type to search within.
 * @template E - The type of the key to return. Defaults to `keyof T`.
 */
type GetKeyObjectFromValueProps<T extends Record<string, unknown>> = {
    /**
     * The object to search through. Its values are compared against `value`
     * using strict equality.
     */
    object: T;
    /**
     * The value to look up within `object`. When a property of `object` strictly
     * equals this value, the corresponding key is returned. When omitted or when
     * no match is found, `undefined` is returned.
     */
    value?: unknown;
};
/**
 * Return value of [getKeyObjectFromValue](https://react-tools.ndria.dev/utils/getKeyObjectFromValue).
 *
 * The key of type `E` whose associated value in the object strictly equals the
 * searched `value`, or `undefined` when no match is found.
 *
 * @template E - The key type, defaulting to `keyof T`.
 */
type GetKeyObjectFromValueResult<E extends string | number | symbol> = E | undefined;

/**
 * Parameters accepted by [getObjectFromDottedString](https://react-tools.ndria.dev/utils/getObjectFromDottedString).
 *
 * @template T - The type of the value to set at the resolved path.
 * @template E - The object type to build or update.
 */
type GetObjectFromDottedStringProps<T, E extends Record<string, unknown>> = {
    /**
     * A dot-separated path string describing where to set the value within the
     * object (e.g. `"user.address.city"`). Each segment corresponds to a nested
     * property key.
     */
    path: string;
    /**
     * The value to assign at the location described by `path`.
     */
    value: T;
    /**
     * An optional existing object to update. When provided, the value is set
     * within a deep clone of this object. When omitted, a new object is built
     * from scratch following the structure described by `path`.
     */
    object?: E;
};

/**
 * Parameters accepted by [hotKeyHandler](https://react-tools.ndria.dev/utils/hotKeyHandler).
 */
type HotKeyHandlerProps = {
    /**
     * The keyboard shortcut string to match against incoming events. Supports
     * the following formats:
     * - A bare key string (e.g. `"s"`, `"Enter"`).
     * - A single modifier combined with a key using `+` (e.g. `"ctrl+s"`).
     * - Two modifiers combined with a key using `+` (e.g. `"ctrl+shift+z"`).
     *
     * Supported modifiers: `"alt"`, `"ctrl"`, `"meta"`, `"shift"`,
     * `"ctrlCommand"` (maps to `ctrl` on Windows/Linux, `meta` on macOS).
     */
    hotKeys: `${string}` | `${"alt" | "ctrl" | "meta" | "shift" | "ctrlCommand"}+${string}` | `${"alt" | "ctrl" | "meta" | "shift" | "ctrlCommand"}+${"alt" | "ctrl" | "meta" | "shift" | "ctrlCommand"}+${string}`;
    /**
     * The handler invoked when the configured hotkey combination is matched.
     * Receives the triggering {@link KeyboardEvent} or {@link KeyEvt}. May
     * return a `Promise` for async handlers.
     */
    listener: (evt: KeyboardEvent | KeyboardEvent$1<HTMLElement>) => void | Promise<void>;
};
/**
 * Return value of [hotKeyHandler](https://react-tools.ndria.dev/utils/hotKeyHandler).
 *
 * A `keydown` / `keyup` event handler that checks each incoming event against
 * the configured hotkey combination and invokes `listener` when matched.
 * Attach this to a DOM element or `window` via `addEventListener`.
 */
type HotKeyHandlerResult = (evt: KeyboardEvent | KeyboardEvent$1<HTMLElement>) => void;

/**
 * Parameters accepted by [isAsync](https://react-tools.ndria.dev/utils/isAsync).
 *
 * @template T - The argument tuple type of the function, when `fn` is callable.
 * @template E - The return or resolved value type.
 */
type IsAsyncProps<T extends unknown[], E = unknown> = {
    /**
     * The value to inspect. Accepts:
     * - A plain value of type `E` — considered synchronous.
     * - A `Promise<E>` — considered asynchronous.
     * - A function `(...args: T) => E | Promise<E>` — considered asynchronous
     *   if the function is declared `async` or its `toString()` representation
     *   contains the `async` keyword.
     */
    fn: E | Promise<E> | ((...args: T) => E | Promise<E>);
};

/**
 * Parameters accepted by [isDeepEqual](https://react-tools.ndria.dev/utils/isDeepEqual).
 */
type IsDeepEqualProps = {
    /**
     * The first value to compare.
     */
    objA: unknown;
    /**
     * The second value to compare.
     */
    objB: unknown;
    /**
     * An internal `WeakMap` used to track already-visited object pairs and
     * handle circular references. Should not be passed by callers — it is
     * managed automatically by recursive calls.
     */
    map?: WeakMap<object, unknown>;
};

/**
 * Parameters accepted by [isMouseEvent](https://react-tools.ndria.dev/utils/isMouseEvent).
 *
 * @param event - The React {@link SyntheticEvent} to inspect.
 * @returns `true` when the underlying native event is a {@link MouseEvent}, `false` otherwise.
 */
interface IIsMouseEvent {
    (event: SyntheticEvent): boolean;
}

/**
 * Parameters accepted by [isShallowEqual](https://react-tools.ndria.dev/utils/isShallowEqual).
 */
type IsShallowEqualProps = {
    /**
     * The first value to compare.
     */
    objA: unknown;
    /**
     * The second value to compare.
     */
    objB: unknown;
};

/**
 * Parameters accepted by [isTouchEvent](https://react-tools.ndria.dev/utils/isTouchEvent).
 *
 * @param event - The React {@link SyntheticEvent} or native {@link Event} to
 *   inspect.
 * @returns `true` when the event is (or wraps) a {@link TouchEvent}, `false`
 *   otherwise. Falls back to a `"touches"` property check on browsers that
 *   do not expose `window.TouchEvent`.
 */
interface IIsTouchEvent {
    (event: SyntheticEvent | Event): boolean;
}

/**
 * Parameters accepted by [lazy](https://react-tools.ndria.dev/utils/lazy).
 *
 * @template T - The `ComponentType` exported by the dynamic module.
 */
type LazyProps<T extends ComponentType<unknown>> = {
    /**
     * A dynamic import factory that returns a `Promise` resolving to a module
     * object whose values are `ComponentType` instances (e.g.
     * `() => import("./MyComponent")`). The resolved component is cached after
     * the first load.
     */
    load: () => Promise<{
        [k: string]: T;
    }>;
    /**
     * Optional configuration.
     */
    opts?: {
        /**
         * The named export key to use as the component. When omitted, the
         * `default` export is used.
         */
        componentName?: string;
        /**
         * Called synchronously before the factory `Promise` is initiated.
         */
        beforeLoad?: () => void;
        /**
         * Called after the factory `Promise` resolves and the component is ready.
         */
        afterLoad?: () => void;
    };
};
/**
 * Return value of [lazy](https://react-tools.ndria.dev/utils/lazy).
 *
 * A {@link LazyExoticComponent} wrapping the resolved component `T`, compatible
 * with `<Suspense>` for code-splitting.
 *
 * @template T - The `ComponentType` exported by the dynamic module.
 */
type LazyResult<T extends ComponentType<unknown>> = LazyExoticComponent<T>;

/**
 * Parameters accepted by [mergeObjects](https://react-tools.ndria.dev/utils/mergeObjects).
 *
 * @template T - The target object type.
 */
type MergeObjectsProps<T extends object> = {
    /**
     * The base object whose properties are used as defaults. Properties present
     * in `newObj` override those in `oldObj`.
     */
    oldObj: T;
    /**
     * A partial object containing the properties to merge into `oldObj`. Accepts
     * a {@link RecursivePartial} so deeply nested properties can be partially
     * overridden without supplying the full subtree.
     */
    newObj: RecursivePartial<T>;
    /**
     * When `true`, properties in `newObj` whose value is explicitly `undefined`
     * are written into the result, overriding the corresponding `oldObj` value
     * with `undefined`. When `false` or omitted, `undefined` values in `newObj`
     * are ignored and the `oldObj` value is preserved.
     */
    forceUndefinedValue?: boolean;
};

/**
 * Parameters accepted by [removePropertiesFromArrayObjects](https://react-tools.ndria.dev/utils/removePropertiesFromArrayObjects).
 *
 * @template T - The type of the objects in the array.
 * @template E - The type of the property key(s) to remove. Defaults to
 *   `keyof T`.
 */
type RemovePropertiesFromArrayObjectsProps<T, E extends string | number | symbol = keyof T> = {
    /**
     * The array of objects from which properties should be removed.
     */
    array: T[];
    /**
     * A single property key or an array of property keys to omit from each
     * object in `array`.
     */
    property: E | E[];
};
/**
 * Return value of [removePropertiesFromArrayObjects](https://react-tools.ndria.dev/utils/removePropertiesFromArrayObjects).
 *
 * An array of objects of the same type as the input, with the specified
 * property or properties omitted from each element.
 *
 * @template T - The original object type.
 * @template E - The omitted property key type.
 */
type RemovePropertiesFromArrayObjectsResult<T, E extends string | number | symbol = keyof T> = Omit<T, E>[];

/**
 * **`isShallowEqual`**: It returns true if the params are equal until first level depth.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/isShallowEqual)
 * @param {IsShallowEqualProps["objA"]} objA - {@link IsShallowEqualProps}
 * @param {IsShallowEqualProps["objB"]} objB - {@link IsShallowEqualProps}
 * @returns {boolean} result
 */
declare const isShallowEqual: (objA: IsShallowEqualProps["objA"], objB: IsShallowEqualProps["objB"]) => boolean;

/**
 * __`isDeepEqual`__: It returns true if the params are equal in depth.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/isDeepEqual)
 * @param {IsDeepEqualProps["objA"]} objA - {@link IsDeepEqualProps}
 * @param {IsDeepEqualProps["objB"]} objB - {@link IsDeepEqualProps}
 * @param {IsDeepEqualProps["map"]} map - {@link IsDeepEqualProps}
 * @returns {boolean} result
 */
declare const isDeepEqual: (objA: IsDeepEqualProps["objA"], objB: IsDeepEqualProps["objB"], map?: IsDeepEqualProps["map"]) => boolean;

/**
 * __`isMouseEvent`__: It returns `true` when the underlying native event is a {@link MouseEvent}, `false` otherwise.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/isMouseEvent)
 * @param {SyntheticEvent} event - {@link SyntheticEvent}
 * @returns {boolean} result
 */
declare const isMouseEvent: IIsMouseEvent;

/**
 * __`isTouchEvent`__: It returns true if the event param is of TouchEvent type.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/isTouchEvent)
 * @param {SyntheticEvent | Event} event
 * @returns {boolean} result
 */
declare const isTouchEvent: IIsTouchEvent;

/**
 * **`isClient`**: Returns `true` when running in a browser environment where `window` and `window.document` are available, `false` in SSR or non-browser contexts.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/isClient)
 * @returns {boolean} result
 */
declare const isClient: () => boolean;

/**
 * **`isAsync`**: It detects if a function is asynchronous.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/isAsync)
 * @template T - The argument tuple type of the function, when `fn` is callable.
 * @template E - The return or resolved value type.
 * @param {IsAsyncProps<T, E>["fn"]} fn - {@link IsAsyncProps}
 * @returns {boolean} result
 */
declare const isAsync: <T extends unknown[], E = unknown>(fn: IsAsyncProps<T, E>["fn"]) => boolean;

/**
 * **`hotKeyHandler`**: utility function for _onKeyDown_ and _onKeyUp_ events handler that supports keys combination.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/hotKeyHandler)
 * @param {HotKeyHandlerProps["hotKeys"]} hotKeys - {@link HotKeyHandlerProps}
 * @param {HotKeyHandlerProps["listener"]} listener - {@link HotKeyHandlerProps}
 * @returns {HotKeyHandlerResult} result - {@link HotKeyHandlerResult}
 */
declare const hotKeyHandler: (hotKeys: HotKeyHandlerProps["hotKeys"], listener: HotKeyHandlerProps["listener"]) => HotKeyHandlerResult;

/**
 * **`detectBrowser`**: It detects used browser or return __"No detection"__.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/detectBrowser)
 * @returns {DetectBrowserResult} result - {@link DetectBrowserResult}
 */
declare function detectBrowser(): DetectBrowserResult;

/**
 * **`defaultSerializer`**: Function to serialize any type of value.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/defaultSerializer)
 * @template T - The type of the value to serialize.
 * @param {AlphanumericCompareProps} target - {@link AlphanumericCompareProps}
 * @returns {string}
 */
declare function defaultSerializer<T>(target: DefaultSerializerProps<T>["target"]): string;

/**
 * **`getBase64`**: Function to obtain a Base64 from value specified if supported, otherwise throw an Error.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/getBase64)
 * @template T - The type of the value to serialize.
 * @param {GetBase64Props<T>["target"]} target - {@link GetBase64Props}
 * @param {GetBase64Props<T>["options"]} [options] - {@link GetBase64Props}
 * @returns {Promise<string>} result
 */
declare function getBase64(target: string, options?: undefined): Promise<string>;
declare function getBase64(target: Blob, options?: undefined): Promise<string>;
declare function getBase64(target: ArrayBuffer, options?: undefined): Promise<string>;
declare function getBase64(target: HTMLCanvasElement, options?: ToDataURLOptions): Promise<string>;
declare function getBase64(target: HTMLImageElement, options?: ToDataURLOptions): Promise<string>;
declare function getBase64<T extends object>(target: T, options?: UseBase64ObjectOptions<T>): Promise<string>;
declare function getBase64<T extends Map<string, unknown>>(target: T, options?: UseBase64ObjectOptions<T>): Promise<string>;
declare function getBase64<T extends Set<unknown>>(target: T, options?: UseBase64ObjectOptions<T>): Promise<string>;
declare function getBase64<T>(target: T[], options?: UseBase64ObjectOptions<T[]>): Promise<string>;

/**
 * **`removePropertiesFromArrayObjects`**: Function that, given an array of objects and a property or an array of properties, return a new array without specified properties.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/removePropertiesFromArrayObjects)
 * @template T - The type of the objects in the array.
 * @template E - The type of the property key(s) to remove. Defaults to
 * @param {RemovePropertiesFromArrayObjectsProps<T, E>["array"]} array - {@link RemovePropertiesFromArrayObjectsProps}
 * @param {RemovePropertiesFromArrayObjectsProps<T, E>["property"]} property - {@link RemovePropertiesFromArrayObjectsProps}
 * @returns {RemovePropertiesFromArrayObjectsResult<T, E>} result - {@link RemovePropertiesFromArrayObjectsResult}
 */
declare function removePropertiesFromArrayObjects<T, E extends string | number | symbol = keyof T>(array: RemovePropertiesFromArrayObjectsProps<T, E>["array"], property: RemovePropertiesFromArrayObjectsProps<T, E>["property"]): RemovePropertiesFromArrayObjectsResult<T, E>;

/**
 * **`uniqueElementsArray`**: Function that given one or more array of object, returns a single array with unique elements by a specified property, an array of properties or _none_.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/uniqueElementsArray)
 * @template T - The element type of the input arrays.
 * @param {UniqueElementsArrayProps<T>["property"]} property - {@link UniqueElementsArrayProps}
 * @param {UniqueElementsArrayProps<T>["args"]} args - {@link UniqueElementsArrayProps}
 * @returns {UniqueElementsArrayResult<T>} result - {@link UniqueElementsArrayResult}
 */
declare function uniqueElementsArray<T extends string | number | boolean | ((...args: unknown[]) => unknown) | bigint>(property: "none", ...args: (T[])[]): T[];
declare function uniqueElementsArray<T extends object>(property: keyof T | (keyof T)[] | "none", ...args: (T[])[]): T[];

/**
 * **`getKeyObjectFromValue`**: Function that given an object and a value, returns the corrispondent key of this value or undefined.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/getKeyObjectFromValue)
 * @template T - The object type to search within.
 * @template E - The type of the key to return. Defaults to `keyof T`.
 * @param {GetKeyObjectFromValueProps<T>["object"]} object - {@link GetKeyObjectFromValueProps}
 * @param {GetKeyObjectFromValueProps<T>["value"]} [value] - {@link GetKeyObjectFromValueProps}
 * @returns {GetKeyObjectFromValueResult<E>} result - {@link GetKeyObjectFromValueResult}
 */
declare function getKeyObjectFromValue<T extends Record<string, unknown>, E extends string | number | symbol = keyof T>(object: GetKeyObjectFromValueProps<T>["object"], value?: GetKeyObjectFromValueProps<T>["value"]): GetKeyObjectFromValueResult<E>;

/**
 * **`getObjectFromDottedString`**: Function that, given a path, a value and an optional object, returns an object with as many properties as there are in the path, assigning the value passed to the last one specified. [See demo](https://react-tools.ndria.dev/#/utils/getObjectFromDottedString)
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/getObjectFromDottedString)
 * @template T - The type of the value to set at the resolved path.
 * @template E - The object type to build or update.
 * @param {GetObjectFromDottedStringProps<T, E>["path"]} path - {@link GetObjectFromDottedStringProps}
 * @param {GetObjectFromDottedStringProps<T, E>["value"]} value - {@link GetObjectFromDottedStringProps}
 * @param {GetObjectFromDottedStringProps<T, E>["object"]} [object] - {@link GetObjectFromDottedStringProps}
 * @returns {E} result
 */
declare function getObjectFromDottedString<T, E extends Record<string, unknown>>(path: GetObjectFromDottedStringProps<T, E>["path"], value: GetObjectFromDottedStringProps<T, E>["value"], object?: GetObjectFromDottedStringProps<T, E>["object"]): E;

/**
 * **`mergeObjects`**: Function that, given two objects version, merges them into a single one. Via an optional parameter _forceUndefinedValue_ you can define how undefined values are treated.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/mergeObjects)
 * @template T - The target object type.
 * @param {MergeObjectsProps<T>["oldObj"]} oldObj - {@link MergeObjectsProps}
 * @param {MergeObjectsProps<T>["newObj"]} newObj - {@link MergeObjectsProps}
 * @param {MergeObjectsProps<T>["forceUndefinedValue"]} [forceUndefinedValue] - {@link MergeObjectsProps}
 * @returns {T} result
 */
declare function mergeObjects<T extends object>(oldObj: MergeObjectsProps<T>["oldObj"], newObj: MergeObjectsProps<T>["newObj"], forceUndefinedValue?: MergeObjectsProps<T>["forceUndefinedValue"]): T;

/**
 * **`alphanumericCompare`**: Function which, given two strings, the type of comparison to be verified, and optional options, performs the comparison between the two strings and returns a boolean indicating whether the indicated comparison is respected or not.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/alphanumericCompare)
 * @param {AlphanumericCompareProps} props - {@link AlphanumericCompareProps}
 * @returns {boolean|number} result
 */
declare function alphanumericCompare({ string1, string2, compareType, locales, opts }: {
    string1: string;
    string2: string;
    compareType?: undefined;
    locales?: Intl.LocalesArgument;
    opts?: Intl.CollatorOptions;
}): number;
declare function alphanumericCompare({ string1, string2, compareType, locales, opts }: {
    string1: string;
    string2: string;
    compareType?: "<" | ">" | "=" | ">=" | "<=";
    locales?: Intl.LocalesArgument;
    opts?: Intl.CollatorOptions;
}): boolean;

/**
 * **`changeStringCase`**: Function that given a string, a case type, and an optional delimiter, returns the string in the specified case or empty string.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/changeStringCase)
 * @param {ChangeStringCaseProps} props - {@link ChangeStringCaseProps}
 * @returns {string} result
 */
declare function changeStringCase({ string, caseType, delimiter }: ChangeStringCaseProps): string;

/**
 * **`lazy`**: Wrapper around _React.lazy_ that works also with component without default export and with possibility to execute a function before and after component loading.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/lazy)
 * @template T - The `ComponentType` exported by the dynamic module.
 * @param {LazyProps<T>["load"]} load - {@link LazyProps}
 * @param {LazyProps<T>["opts"]} opts - {@link LazyProps}
 * @returns {LazyResult<T>} result - {@link LazyResult}
 */
declare const lazy: <T extends ComponentType<unknown>>(load: LazyProps<T>["load"], opts?: LazyProps<T>["opts"]) => LazyResult<T>;

/**
 * **`clickElementOnKeydownEvent`**: Function which, given a triggering code, executes _click_ on element when a keyDown event with triggering code is executed.
 * @see [📖 Documentation](https://react-tools.ndria.dev/utils/clickElementOnKeydownEvent)
 * @param {ClickElementOnKeydownEventProps} codeTriggering - {@link ClickElementOnKeydownEventProps}
 * @returns {ClickElementOnKeydownEventResult} result - {@link ClickElementOnKeydownEventResult}
 */
declare function clickElementOnKeydownEvent(codeTriggering: ClickElementOnKeydownEventProps): ClickElementOnKeydownEventResult;

export { isShallowEqual as A, isTouchEvent as B, lazy as E, mergeObjects as F, removePropertiesFromArrayObjects as J, uniqueElementsArray as K, alphanumericCompare as n, changeStringCase as o, clickElementOnKeydownEvent as p, defaultSerializer as q, detectBrowser as r, getBase64 as s, getKeyObjectFromValue as t, getObjectFromDottedString as u, hotKeyHandler as v, isAsync as w, isClient as x, isDeepEqual as y, isMouseEvent as z };
export type { ChangeStringCaseProps as C, DefaultSerializerProps as D, GetBase64Props as G, HotKeyHandlerProps as H, IIsMouseEvent as I, LazyProps as L, MergeObjectsProps as M, RemovePropertiesFromArrayObjectsProps as R, ToDataURLOptions as T, UseBase64ObjectOptions as U, ClickElementOnKeydownEventProps as a, ClickElementOnKeydownEventResult as b, DetectBrowserResult as c, GetKeyObjectFromValueProps as d, GetKeyObjectFromValueResult as e, GetObjectFromDottedStringProps as f, HotKeyHandlerResult as g, IIsTouchEvent as h, IsAsyncProps as i, IsDeepEqualProps as j, IsShallowEqualProps as k, LazyResult as l, RemovePropertiesFromArrayObjectsResult as m };