intelicoreact 1.8.69 → 2.0.0

package/dist/Functions/guards/typeGuards.d.ts

@@ -0,0 +1,193 @@
+/**
+ * @name isObject
+ * @description Функция isObject принимает значение и возвращает true, если переданное значение является объектом.
+ * @param value - значение для проверки
+ * @example
+ * const result = isObject({});
+ * console.log(result); // true
+ * @example
+ * const result = isObject([]);
+ * console.log(result); // false
+ */
+declare function isObject(value: unknown): value is object;
+/**
+ * @name isEnumValue
+ * @description Функция isEnumValue принимает значение и возвращает true, если переданное значение является значением enum.
+ * @param enumObject - enum для проверки
+ * @param value - значение для проверки
+ * @example
+ * enum Colors {
+ * Red = 'red',
+ * Green = 'green',
+ * Blue = 'blue',
+ * }
+ * const result = isEnumValue(Colors, 'red');
+ * console.log(result); // true
+ * @returns true - если значение является значением enum, false - если значение не является значением enum
+ */
+declare function isEnumValue<T extends string | number>(enumObject: Record<string, T>, value: unknown): value is T;
+/**
+ * @name isNullOrUndefined
+ * @description Функция isNullOrUndefined принимает значение и возвращает true, если переданное значение является null или undefined.
+ * @param value - значение для проверки
+ * @example
+ * isNullOrUndefined(null) // true
+ * isNullOrUndefined(undefined) // true
+ * isNullOrUndefined(1) // false
+ */
+declare function isNullOrUndefined(value: unknown): value is null | undefined;
+/**
+ * @name isTypedArray
+ * @description Функция isTypedArray принимает значение и возвращает true, если переданное значение является массивом определенного типа.
+ * @param value - значение для проверки
+ * @param type - тип для проверки
+ * @example
+ * isTypedArray([1, 2, 3], Number) // true
+ * isTypedArray([1, 2, 3], String) // false
+ */
+declare function isTypedArray<T>(value: unknown, type: new (...args: any[]) => T): value is T[];
+/**
+ * @name isArrayWithLength
+ * @description Функция isArrayWithLength принимает значение и возвращает true, если переданное значение является массивом определенной длины.
+ * @param value - значение для проверки
+ * @param length - длина массива
+ * @example
+ * isArrayWithLength([1, 2, 3], 3) // true
+ * isArrayWithLength([1, 2, 3], 2) // false
+ */
+declare function isArrayWithLength(value: unknown, length: number): value is unknown[];
+/**
+ * @name isTypeOrNull
+ * @description Функция isTypeOrNull принимает значение и возвращает true, если переданное значение является экземпляром класса или null.
+ * @param value - значение для проверки
+ * @param type - класс для проверки
+ * @example
+ * isTypeOrNull(null, SomeClass) // true
+ * isTypeOrNull(new SomeClass(), SomeClass) // true
+ */
+declare function isTypeOrNull<T>(value: unknown, type: new (...args: any[]) => T): value is T | null;
+/**
+ * @name isPrimitive
+ * @description Функция isPrimitive принимает значение и возвращает true, если переданное значение является примитивом.
+ * @param value - значение для проверки
+ * @example
+ * isPrimitive(42) // true
+ * isPrimitive('test') // true
+ * isPrimitive(true) // true
+ * isPrimitive(null) // true
+ * isPrimitive(undefined) // true
+ * isPrimitive({}) // false
+ */
+declare function isPrimitive(value: unknown): value is string | number | boolean | null | undefined;
+/**
+ * @name isReactElement
+ * @description Функция isReactElement принимает значение и возвращает true, если переданное значение является React элементом.
+ * @param value - значение для проверки
+ * @example
+ * isReactElement(<div>Test</div>) // true
+ * isReactElement('div') // false
+ */
+declare function isReactElement(value: unknown): value is React.ReactElement;
+/**
+ * @name isReactComponent
+ * @description Функция isReactComponent принимает значение и возвращает true, если переданное значение является React компонентом.
+ * @param value - значение для проверки
+ * @example
+ * const MyComponent = () => <div>Test</div>;
+ * isReactComponent(MyComponent) // true
+ * isReactComponent('div') // false
+ */
+declare function isReactComponent(value: unknown): value is React.ComponentType;
+/**
+ * @name isComponentType
+ * @description Функция isComponentType принимает значение и тип компонента, возвращает true, если переданное значение является компонентом указанного типа.
+ * @param value - значение для проверки
+ * @param componentType - тип компонента для проверки
+ * @example
+ * const MyComponent = () => <div>Test</div>;
+ * isComponentType(<MyComponent />, MyComponent) // true
+ */
+declare function isComponentType<T extends React.ComponentType>(value: unknown, componentType: T): value is React.ReactElement<React.ComponentProps<T>>;
+/**
+ * @name isReactEvent
+ * @description Функция isReactEvent принимает значение и возвращает true, если переданное значение является React событием.
+ * @param value - значение для проверки
+ * @example
+ * const handleClick = (e) => {
+ *   if (isReactEvent(e)) {
+ *     e.preventDefault();
+ *   }
+ * };
+ */
+declare function isReactEvent(value: unknown): value is React.SyntheticEvent;
+/**
+ * @name isRef
+ * @description Функция isRef принимает значение и возвращает true, если переданное значение является React рефом.
+ * @param value - значение для проверки
+ * @example
+ * const ref = useRef(null);
+ * isRef(ref) // true
+ */
+declare function isRef(value: unknown): value is React.RefObject<unknown>;
+/**
+ * @name isContext
+ * @description Функция isContext принимает значение и возвращает true, если переданное значение является React контекстом.
+ * @param value - значение для проверки
+ * @example
+ * const MyContext = React.createContext(null);
+ * isContext(MyContext) // true
+ */
+declare function isContext(value: unknown): value is React.Context<unknown>;
+/**
+ * @name isType
+ * @description Функция isType принимает значение и тип, возвращает true, если переданное значение соответствует указанному типу.
+ * @param value - значение для проверки
+ * @param type - тип для проверки
+ * @example
+ * interface User {
+ *   name: string;
+ *   age: number;
+ * }
+ *
+ * const user = { name: "John", age: 30 };
+ * const isUser = isType<User>(user,);
+ * console.log(isUser); // true
+ *
+ * const notUser = "John";
+ * console.log(isType<User>(notUser)); // false
+ */
+declare function isType<T>(value: unknown): value is T;
+declare const typesGuards: {
+    isArray: (value: unknown) => value is unknown[];
+    isObject: typeof isObject;
+    isNumber: (value: unknown) => value is number;
+    isString: (value: unknown) => value is string;
+    isBoolean: (value: unknown) => value is boolean;
+    isFunction: (value: unknown) => value is (...args: any[]) => any;
+    isInstanceOf: <T>(value: unknown, classType: new () => T) => value is T;
+    isEnumValue: typeof isEnumValue;
+    isNullOrUndefined: typeof isNullOrUndefined;
+    isTruthy: (value: unknown) => value is boolean | number | string | object;
+    isEmptyObject: (value: unknown) => value is object;
+    isEmptyArray: (value: unknown) => value is [];
+    isTypedArray: typeof isTypedArray;
+    isArrayWithLength: typeof isArrayWithLength;
+    isTypeOrNull: typeof isTypeOrNull;
+    nonNullable: <T>(value: T) => value is NonNullable<T>;
+    isDate: (value: unknown) => value is Date;
+    isPromise: (value: unknown) => value is Promise<unknown>;
+    isRegExp: (value: unknown) => value is RegExp;
+    isPrimitive: typeof isPrimitive;
+    isError: (value: unknown) => value is Error;
+    isSymbol: (value: unknown) => value is symbol;
+    isMap: (value: unknown) => value is Map<unknown, unknown>;
+    isSet: (value: unknown) => value is Set<unknown>;
+    isReactElement: typeof isReactElement;
+    isReactComponent: typeof isReactComponent;
+    isComponentType: typeof isComponentType;
+    isReactEvent: typeof isReactEvent;
+    isRef: typeof isRef;
+    isContext: typeof isContext;
+    isType: typeof isType;
+};
+export default typesGuards;

package/dist/Functions/hooks/useFormFieldsChangesManager.d.ts

@@ -0,0 +1,15 @@
+export default useFormFieldsChangesManager;
+declare function useFormFieldsChangesManager({ form, setForm, callback, validateField, settings }: {
+    form: any;
+    setForm: any;
+    callback: any;
+    validateField: any;
+    settings: any;
+}): {
+    assignChangesToField: (data: any, key: any, settings: any) => any[];
+    isFormMustBeChanget: boolean;
+    startChangesProcessing: () => void;
+    setIsFormMustBeChanget: () => void;
+    changesArray: any[];
+    DELAY_TIME: number;
+};

package/dist/Functions/locale/createTranslator.d.ts

@@ -0,0 +1,3 @@
+export default function createTranslator({ ...langCatalogs }: {
+    [x: string]: any;
+}): (text: any, values: any) => any;

package/dist/Functions/operations.d.ts

@@ -0,0 +1 @@
+export function addRangeDefault(from: any, to: any, currentValues: any, decimalPlaces: any): any;

package/dist/Functions/presets/inputMaskPresets.d.ts

@@ -0,0 +1,136 @@
+export namespace MASK_PRESETS {
+    export { BANK_ACCOUNT };
+    export { CC_EXPIRATION_DATE };
+    export { DATE_PRESET };
+    export { ZIP_PRESET };
+    export { SSN_PRESET };
+    export { MOBILE_PHONE_PRESET };
+    export { SHORT_SSN_PRESET };
+    export { ABA_PRESET };
+}
+declare namespace BANK_ACCOUNT {
+    let type: string;
+    let maskPattern: string;
+    let maskPlaceholder: string;
+    let isNumericMobileKeyboard: boolean;
+    let blinkErrors: boolean;
+    let showErrors: boolean;
+}
+declare namespace CC_EXPIRATION_DATE {
+    let type_1: string;
+    export { type_1 as type };
+    let maskPattern_1: string;
+    export { maskPattern_1 as maskPattern };
+    export let maskPatternPlaceholder: string;
+    export let usePatternPlaceholder: boolean;
+    let isNumericMobileKeyboard_1: boolean;
+    export { isNumericMobileKeyboard_1 as isNumericMobileKeyboard };
+    let blinkErrors_1: boolean;
+    export { blinkErrors_1 as blinkErrors };
+    let showErrors_1: boolean;
+    export { showErrors_1 as showErrors };
+    export let focusSelector: string;
+}
+declare namespace DATE_PRESET {
+    let type_2: string;
+    export { type_2 as type };
+    let maskPattern_2: string;
+    export { maskPattern_2 as maskPattern };
+    let maskPatternPlaceholder_1: string;
+    export { maskPatternPlaceholder_1 as maskPatternPlaceholder };
+    let usePatternPlaceholder_1: boolean;
+    export { usePatternPlaceholder_1 as usePatternPlaceholder };
+    let isNumericMobileKeyboard_2: boolean;
+    export { isNumericMobileKeyboard_2 as isNumericMobileKeyboard };
+    let blinkErrors_2: boolean;
+    export { blinkErrors_2 as blinkErrors };
+    let showErrors_2: boolean;
+    export { showErrors_2 as showErrors };
+    export let autocomplete: string;
+    let focusSelector_1: string;
+    export { focusSelector_1 as focusSelector };
+}
+declare namespace ZIP_PRESET {
+    let type_3: string;
+    export { type_3 as type };
+    let focusSelector_2: string;
+    export { focusSelector_2 as focusSelector };
+    let maskPattern_3: string;
+    export { maskPattern_3 as maskPattern };
+    let maskPlaceholder_1: string;
+    export { maskPlaceholder_1 as maskPlaceholder };
+    let isNumericMobileKeyboard_3: boolean;
+    export { isNumericMobileKeyboard_3 as isNumericMobileKeyboard };
+    let blinkErrors_3: boolean;
+    export { blinkErrors_3 as blinkErrors };
+    let showErrors_3: boolean;
+    export { showErrors_3 as showErrors };
+    let autocomplete_1: string;
+    export { autocomplete_1 as autocomplete };
+    export let rules: string;
+}
+declare namespace SSN_PRESET {
+    let type_4: string;
+    export { type_4 as type };
+    let maskPattern_4: string;
+    export { maskPattern_4 as maskPattern };
+    let maskPlaceholder_2: string;
+    export { maskPlaceholder_2 as maskPlaceholder };
+    let focusSelector_3: string;
+    export { focusSelector_3 as focusSelector };
+    let isNumericMobileKeyboard_4: boolean;
+    export { isNumericMobileKeyboard_4 as isNumericMobileKeyboard };
+    let blinkErrors_4: boolean;
+    export { blinkErrors_4 as blinkErrors };
+    let showErrors_4: boolean;
+    export { showErrors_4 as showErrors };
+}
+declare namespace MOBILE_PHONE_PRESET {
+    let type_5: string;
+    export { type_5 as type };
+    let maskPattern_5: string;
+    export { maskPattern_5 as maskPattern };
+    let maskPlaceholder_3: string;
+    export { maskPlaceholder_3 as maskPlaceholder };
+    let focusSelector_4: string;
+    export { focusSelector_4 as focusSelector };
+    let isNumericMobileKeyboard_5: boolean;
+    export { isNumericMobileKeyboard_5 as isNumericMobileKeyboard };
+    let blinkErrors_5: boolean;
+    export { blinkErrors_5 as blinkErrors };
+    let showErrors_5: boolean;
+    export { showErrors_5 as showErrors };
+    let autocomplete_2: string;
+    export { autocomplete_2 as autocomplete };
+}
+declare namespace SHORT_SSN_PRESET {
+    let type_6: string;
+    export { type_6 as type };
+    let maskPattern_6: string;
+    export { maskPattern_6 as maskPattern };
+    let maskPlaceholder_4: string;
+    export { maskPlaceholder_4 as maskPlaceholder };
+    let focusSelector_5: string;
+    export { focusSelector_5 as focusSelector };
+    let isNumericMobileKeyboard_6: boolean;
+    export { isNumericMobileKeyboard_6 as isNumericMobileKeyboard };
+    let blinkErrors_6: boolean;
+    export { blinkErrors_6 as blinkErrors };
+    let showErrors_6: boolean;
+    export { showErrors_6 as showErrors };
+}
+declare namespace ABA_PRESET {
+    let type_7: string;
+    export { type_7 as type };
+    let maskPattern_7: string;
+    export { maskPattern_7 as maskPattern };
+    let maskPlaceholder_5: string;
+    export { maskPlaceholder_5 as maskPlaceholder };
+    let isNumericMobileKeyboard_7: boolean;
+    export { isNumericMobileKeyboard_7 as isNumericMobileKeyboard };
+    let blinkErrors_7: boolean;
+    export { blinkErrors_7 as blinkErrors };
+    let showErrors_7: boolean;
+    export { showErrors_7 as showErrors };
+}
+export {};

package/dist/Functions/presets/inputPresets.d.ts

@@ -0,0 +1,16 @@
+export namespace NAME_SYMBOLS_EXCLUDER {
+    function fieldChangesMiddleware(value: string): string;
+    namespace blurTrim {
+        let trimStart: boolean;
+        let trimEnd: boolean;
+        let characters: string[];
+    }
+}
+export namespace ONLY_STRING_AND_DASH {
+    export function fieldChangesMiddleware_1(value: string): string;
+    export { fieldChangesMiddleware_1 as fieldChangesMiddleware };
+}
+export namespace INPUT_PRESETS {
+    export { NAME_SYMBOLS_EXCLUDER };
+    export { ONLY_STRING_AND_DASH };
+}

package/dist/Functions/presets/mobileKeyboardTypesPresets.d.ts

@@ -0,0 +1,17 @@
+export namespace ALL_KEYBOARD_TYPES {
+    namespace numeric {
+        let inputMode: string;
+    }
+    namespace email {
+        let inputMode_1: string;
+        export { inputMode_1 as inputMode };
+    }
+}
+export namespace NUMERIC_KEYBOARD {
+    import attributesOfNativeInput = ALL_KEYBOARD_TYPES.numeric;
+    export { attributesOfNativeInput };
+}
+export namespace EMAIL_KEYBOARD {
+    import attributesOfNativeInput_1 = ALL_KEYBOARD_TYPES.email;
+    export { attributesOfNativeInput_1 as attributesOfNativeInput };
+}

package/dist/Functions/schemas.d.ts

@@ -0,0 +1,3 @@
+export const forgotSchema: any;
+export const loginSchema: any;
+export const registerSchema: any;

package/dist/Functions/useBodyScrollLock.d.ts

@@ -0,0 +1,2 @@
+export default useBodyScrollLock;
+declare function useBodyScrollLock(isScrollBodyLocked: any): void;

package/dist/Functions/useClickOutside.d.ts

@@ -0,0 +1 @@
+export function useClickOutside(ref: any, setOut: any, open: any): void;

package/dist/Functions/useDebounce.d.ts

@@ -0,0 +1,4 @@
+export function useDebounce({ searchValue, delay }: {
+    searchValue: any;
+    delay: any;
+}): any;

package/dist/Functions/useFieldFocus.d.ts

@@ -0,0 +1,7 @@
+export default function useFieldsFocus({ form, setForm }: {
+    form: any;
+    setForm: any;
+}): {
+    setFocusTo: (key: any) => false | undefined;
+    setFocusToErroredField: () => false | undefined;
+};

package/dist/Functions/useFormTools/form-drivers/ArrayWithObjects.d.ts

@@ -0,0 +1,15 @@
+export default function ArrayWithObjects({ form, setForm, FormFields }: {
+    form: any;
+    setForm: any;
+    FormFields: any;
+}): {
+    joinData: (...args: any[]) => any;
+    getFieldData: (key: any) => any;
+    getFormFields: (argForm?: any) => any;
+    getFormField: (key: any, argForm?: any) => any;
+    setFormFields: (data: any) => void;
+    setFormField: (data: any, key?: null) => void;
+    getFormFieldsAsArray: (fields: any) => any;
+    getFormFieldsKeys: (fields: any) => any;
+    removeAllFormFields: () => void;
+};

package/dist/Functions/useFormTools/form-drivers/ObjectWithIterableObjects.d.ts

@@ -0,0 +1,12 @@
+export default function ObjectWithIterableObjects({ form, setForm, FormFields, }: {
+    form: any;
+    setForm: any;
+    FormFields: any;
+}): {
+    joinData: (...args: any[]) => any;
+    getFieldData: (key: any) => any;
+    getFormFields: () => any;
+    getFormField: (key: any) => any;
+    setFormFields: (data: any) => void;
+    setFormField: (data: any, key?: null) => void;
+};

package/dist/Functions/useFormTools/form-drivers/ObjectWithNamedKeyObjects.d.ts

@@ -0,0 +1,15 @@
+export default function ObjectWithNamedKeyObjects({ form, setForm, FormFields, }?: {
+    setForm?: (() => void) | undefined;
+}): {
+    joinData: (...args: any[]) => any;
+    getFieldData: (key: any) => any;
+    getFormField: (key: any, argForm?: any) => any;
+    setFormFields: (data: any) => void;
+    setFormField: (data: any, key?: null) => void;
+    getFormFields: () => any;
+    getFormFieldsAsArray: () => any;
+    getFormFieldsKeys: () => any;
+    removeAllFormFields: () => void;
+    removeFormField: (key: any) => void;
+    removeFormFields: ([...keys]: Iterable<any, void, undefined>) => void;
+};

package/dist/Functions/useFormTools/functions/General.d.ts

@@ -0,0 +1,15 @@
+export default function General({ form, FormFields }?: {
+    FormFields?: never[] | undefined;
+}): {
+    joinData: (...args: any[]) => any;
+    getFieldData: (key: any) => any;
+    popFormField: (fields: any, key: any) => {
+        item: undefined;
+        itemIndex: undefined;
+    };
+    updateFormField: (fields: any, data: any, key: any) => any;
+    getFormFields: (argForm?: any) => any;
+    getFormFieldsAsArray: (fields: any) => any;
+    getFieldClassName: (key: any, type: any) => string;
+    getFormFieldsKeys: (fields?: any) => any;
+};

package/dist/Functions/useFormTools/functions/RenderFields.d.ts

@@ -0,0 +1,7 @@
+export default function RenderFields({ form, fields, cols, FormDataDriver, RenderFieldComponent, onFieldChange, onFieldBlur, }?: {
+    cols?: number | undefined;
+    FormDataDriver?: (() => null) | undefined;
+    RenderFieldComponent?: (() => null) | undefined;
+    onFieldChange?: (() => null) | undefined;
+    onFieldBlur?: (() => null) | undefined;
+}): any;

package/dist/Functions/useFormTools/functions/usePrevious.d.ts

@@ -0,0 +1,2 @@
+export default usePrevious;
+declare function usePrevious(value: any): undefined;

package/dist/Functions/useFormTools/index.d.ts

@@ -0,0 +1,86 @@
+export default function useFormTools({ form, setForm, FormType, FormFields, FormDataDriverName, FormDataDriver, FocusControllerProps, goToNextFieldOnEnterPressed, }?: {
+    FormDataDriverName?: string | undefined;
+    FormDataDriver?: null | undefined;
+    FocusControllerProps?: {
+        setAutoFocus: boolean;
+        onlyEmptyFieldAutoFocus: boolean;
+    } | undefined;
+    goToNextFieldOnEnterPressed?: boolean | undefined;
+}): {
+    FormDataDrivers: {
+        ArrayWithObjects: {
+            handlers: typeof ArrayWithObjects;
+            default: boolean;
+        };
+        ObjectWithIterableObjects: {
+            handlers: typeof ObjectWithIterableObjects;
+        };
+        ObjectWithNamedKeyObjects: {
+            handlers: typeof ObjectWithNamedKeyObjects;
+        };
+    };
+    addOnChangeObserver: (key: any, cb: any) => null;
+    removeOnChangeObserver: (key: any, id: any) => void;
+    onChangeObservers: {};
+    onFieldChange: (key: any, value: any) => false | undefined;
+    toggleFormSubmitBlock: (key: any, value: any) => void;
+    clearFormSubmitBlockers: () => void;
+    isFormSubmitBlocked: boolean;
+    renderFormFields: never[];
+    setRenderFormFields: (data: any) => void;
+    addRenderFields: (fields: any) => void;
+    removeRenderFields: (fields: any) => void;
+    getFieldClassName: (key: any, type: any) => string;
+    isInitFocused: boolean;
+    setFirstFieldInitFocused: () => void;
+    resetIsInitFocused: () => void;
+    setFieldFocus: ({ key, cb, form: argForm, field }: {
+        key: any;
+        cb?: (() => void) | undefined;
+        form: any;
+        field: any;
+    }) => false | null | undefined;
+    setFieldBlur: ({ key, cb, form: argForm, field }: {
+        key: any;
+        cb?: (() => void) | undefined;
+        form: any;
+        field: any;
+    }) => false | null | undefined;
+    setFirstFieldFocus: () => false | undefined;
+    autoFocusedField: null;
+    addFocusFieldOnRender: (key: any, cb: any) => void;
+    removeFocusFieldOnRender: (key: any) => void;
+    addOnFieldRenderedObserver: (key: any, cb: any, isOnceCallable?: boolean) => null;
+    removeOnFieldRenderedObserver: (key: any, id: any) => void;
+    onFieldRenderedObservers: {};
+    updateFormField: (fields: any, data: any, key: any) => any;
+    addOnFormRenderObserver: (cb: any, { once }?: {
+        once?: boolean | undefined;
+    }) => void;
+    submitIsFormRendered: () => void;
+    resetIsFormRendered: () => void;
+    renderFields: ({ form: argForm, fields: argFields, cols: argCols, RenderFieldComponent, }: {
+        form?: any;
+        fields?: never[] | undefined;
+        cols?: number | undefined;
+        RenderFieldComponent: any;
+    }) => any;
+    scrollToField: ({ key, field, form: argForm }: {
+        key?: null | undefined;
+        field?: null | undefined;
+        form: any;
+    }) => false | undefined;
+    getFieldData: any;
+    getFormField: any;
+    setFormFields: any;
+    setFormField: (data: any, key: any) => any;
+    getFormFieldsAsArray: any;
+    getFormFieldsKeys: any;
+    removeAllFormFields: any;
+    removeFormField: any;
+    removeFormFields: any;
+    addErrorsToForm: (errors: any, argForm?: any) => void;
+};
+import ArrayWithObjects from "./form-drivers/ArrayWithObjects";
+import ObjectWithIterableObjects from "./form-drivers/ObjectWithIterableObjects";
+import ObjectWithNamedKeyObjects from "./form-drivers/ObjectWithNamedKeyObjects";

package/dist/Functions/useInputHighlightError.d.ts

@@ -0,0 +1,12 @@
+export function useInputHighlightError({ value, blinkTime, isUseErrorsBlink, }: {
+    value: any;
+    blinkTime: any;
+    isUseErrorsBlink: any;
+}): {
+    isToHighlightError: boolean;
+    setPreviousValue: React.Dispatch<any>;
+    setIsToHighlightError: React.Dispatch<React.SetStateAction<boolean>>;
+    hasHighlightError: (e: any) => void;
+};
+export default useInputHighlightError;
+import React from "react";

package/dist/Functions/useIsMobile/index.d.ts

@@ -0,0 +1,2 @@
+import useIsMobile from './useIsMobile';
+export default useIsMobile;

package/dist/Functions/useIsMobile/useIsMobile.d.ts

@@ -0,0 +1,18 @@
+interface UseIsMobileProps {
+    isWithoutWidthCheck?: boolean;
+}
+interface UseIsMobileProps {
+    isWithoutWidthCheck?: boolean;
+}
+/**
+ * Hook to detect if the current device is a mobile device
+ * @param props - Configuration options
+ * @param props.isWithoutWidthCheck - If true, only checks user agent without width verification
+ * @returns Object containing isMobile flag
+ */
+declare function useIsMobile({ isWithoutWidthCheck }?: UseIsMobileProps): {
+    isMobile: boolean;
+    isMobilePortrait: boolean;
+    isMobileLandscape: boolean;
+};
+export default useIsMobile;

package/dist/Functions/useKeyPress/useHandleKeyPress.d.ts

@@ -0,0 +1,35 @@
+import type TWithEventManagementAsObj from '../../types/declaration/TWithEventManagementAsObj';
+import type { ISuspendProcessing } from './useKeyPress';
+interface UseHandleKeyPressProps {
+    /** Callback function to be called when Escape key is pressed */
+    escCallback?: () => void;
+    /** Callback function to be called when Enter key is pressed */
+    enterCallback?: () => void;
+    /** Whether to allow key repeat events */
+    withClamping?: boolean;
+    withEventManagementStructure?: TWithEventManagementAsObj<'Modal'>;
+    /** Array of Keys (ev.key) to exclude from processing */
+    suspendProcessing?: null | ISuspendProcessing;
+}
+/**
+ * A hook that handles Enter and Escape key press events
+ *
+ * @param props - Configuration object for key press handling
+ * @param props.escCallback - Function to be called when Escape key is pressed
+ * @param props.enterCallback - Function to be called when Enter key is pressed
+ * @param props.withClamping - Whether to allow key repeat events (default: true)
+ * @param props.withEventManagementStructure - Structure for event management (e.g. Modal)
+ * @param props.suspendProcessing - Optional map of key -> predicate to suspend processing for specific keys
+ *
+ * @example
+ * ```tsx
+ * function Component() {
+ *   useHandleKeyPress({
+ *     escCallback: () => console.log('Esc pressed'),
+ *     enterCallback: () => console.log('Enter pressed'),
+ *   });
+ * }
+ * ```
+ */
+declare function useHandleKeyPress({ escCallback, enterCallback, withClamping, withEventManagementStructure, suspendProcessing, }: UseHandleKeyPressProps): void;
+export default useHandleKeyPress;

package/dist/Functions/useKeyPress/useKeyPress.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A hook that detects when a specific key is pressed
+ * @param targetKey - The key to listen for
+ * @param clamping - Whether to allow key repeat events
+ * @returns boolean indicating if the target key is currently pressed
+ */
+export interface ISuspendProcessing {
+    [key: string]: (event: globalThis.KeyboardEvent) => boolean;
+}
+export declare function isISuspendProcessing(x: unknown): x is ISuspendProcessing;
+declare function useKeyPress(targetKey: string, clamping?: boolean, isForbidden?: boolean, suspendProcessing?: null | ISuspendProcessing): boolean;
+export default useKeyPress;

package/dist/Functions/useLocalStorage.d.ts

@@ -0,0 +1,2 @@
+export default useLocalStorage;
+declare function useLocalStorage(key: any, initialValue: any): any[];