@unicom-cloud/ui 0.8.41

package/types/hooks/use-verification-code/interface.d.ts

@@ -0,0 +1,22 @@
+import { ClipboardEvent, MouseEvent, KeyboardEvent } from 'react';
+export interface VerificationCodeOptions {
+    length?: number;
+    defaultValue?: string;
+    value?: string;
+    onChange?: (value: string) => void;
+    onFinish?: (value: string) => void;
+    getInputRefList?: () => (HTMLInputElement | HTMLTextAreaElement)[];
+}
+export type VerificationCodeReturnType = {
+    filledValue: VerificationCodeOptions['value'][];
+    value: VerificationCodeOptions['value'];
+    setValue: (v: VerificationCodeOptions['value']) => void;
+    getInputProps: (index: number) => {
+        key: string | number;
+        value: string;
+        onClick: (e: MouseEvent) => void;
+        onKeyDown: (e: KeyboardEvent) => void;
+        onChange: (v: string) => void;
+        onPaste: (e: ClipboardEvent) => void;
+    };
+};

package/types/hooks/use-watermark/index.d.ts

@@ -0,0 +1,2 @@
+import { WatermarkOptions, WatermarkReturnType } from './interface';
+export default function useWatermark(params: WatermarkOptions): WatermarkReturnType;

package/types/hooks/use-watermark/interface.d.ts

@@ -0,0 +1,22 @@
+import { CSSProperties } from 'react';
+export interface WatermarkOptions {
+    zIndex?: CSSProperties['zIndex'];
+    width?: number | string;
+    height?: number | string;
+    rotate?: number;
+    image?: string;
+    content?: string | string[];
+    fontStyle?: {
+        color?: string;
+        fontFamily?: string;
+        fontSize?: number | string;
+        fontWeight?: number | string;
+    };
+    gap?: [number, number];
+    offset?: [number, number];
+    getContainer?: () => HTMLElement;
+}
+export type WatermarkReturnType = {
+    destroy: () => void;
+    setWatermark: (options: WatermarkOptions) => void;
+};

package/types/hooks/use-watermark/utils.d.ts

@@ -0,0 +1 @@
+export declare function getPixelRatio(context: any): number;

package/types/hooks/useAsync.d.ts

@@ -0,0 +1,20 @@
+import { DependencyList } from 'react';
+import { FunctionReturningPromise } from './misc/types';
+export type { AsyncState, AsyncFnReturn } from './useAsyncFn';
+export default function useAsync<T extends FunctionReturningPromise>(fn: T, deps?: DependencyList): {
+    loading: boolean;
+    error?: undefined;
+    value?: undefined;
+} | {
+    loading: false;
+    error: Error;
+    value?: undefined;
+} | {
+    loading: true;
+    error?: Error | undefined;
+    value?: import("./misc/types").PromiseType<ReturnType<T>> | undefined;
+} | {
+    loading: false;
+    error?: undefined;
+    value: import("./misc/types").PromiseType<ReturnType<T>>;
+};

package/types/hooks/useAsyncFn.d.ts

@@ -0,0 +1,23 @@
+import { DependencyList } from 'react';
+import { FunctionReturningPromise, PromiseType } from './misc/types';
+export type AsyncState<T> = {
+    loading: boolean;
+    error?: undefined;
+    value?: undefined;
+} | {
+    loading: true;
+    error?: Error | undefined;
+    value?: T;
+} | {
+    loading: false;
+    error: Error;
+    value?: undefined;
+} | {
+    loading: false;
+    error?: undefined;
+    value: T;
+};
+type StateFromFunctionReturningPromise<T extends FunctionReturningPromise> = AsyncState<PromiseType<ReturnType<T>>>;
+export type AsyncFnReturn<T extends FunctionReturningPromise = FunctionReturningPromise> = [StateFromFunctionReturningPromise<T>, T];
+export default function useAsyncFn<T extends FunctionReturningPromise>(fn: T, deps?: DependencyList, initialState?: StateFromFunctionReturningPromise<T>): AsyncFnReturn<T>;
+export {};

package/types/hooks/useAsyncRetry.d.ts

@@ -0,0 +1,27 @@
+import { DependencyList } from 'react';
+import { AsyncState } from './useAsync';
+export type AsyncStateRetry<T> = AsyncState<T> & {
+    retry(): void;
+};
+declare const useAsyncRetry: <T>(fn: () => Promise<T>, deps?: DependencyList) => {
+    retry: () => void;
+    loading: boolean;
+    error?: undefined;
+    value?: undefined;
+} | {
+    retry: () => void;
+    loading: false;
+    error: Error;
+    value?: undefined;
+} | {
+    retry: () => void;
+    loading: true;
+    error?: Error | undefined;
+    value?: T | undefined;
+} | {
+    retry: () => void;
+    loading: false;
+    error?: undefined;
+    value: T;
+};
+export default useAsyncRetry;

package/types/hooks/useAudio.d.ts

@@ -0,0 +1,11 @@
+declare const useAudio: (elOrProps: import("./factory/createHTMLMediaHook").HTMLMediaProps | import("react").ReactElement<import("./factory/createHTMLMediaHook").HTMLMediaProps, string | import("react").JSXElementConstructor<any>>) => readonly [import("react").ReactElement<import("./factory/createHTMLMediaHook").HTMLMediaProps & {
+    ref?: import("react").MutableRefObject<HTMLAudioElement | null> | undefined;
+}, string | import("react").JSXElementConstructor<any>>, import("./factory/createHTMLMediaHook").HTMLMediaState, {
+    play: () => Promise<void> | undefined;
+    pause: () => void;
+    seek: (time: number) => void;
+    volume: (volume: number) => void;
+    mute: () => void;
+    unmute: () => void;
+}, import("react").MutableRefObject<HTMLAudioElement | null>];
+export default useAudio;

package/types/hooks/useBeforeUnload.d.ts

@@ -0,0 +1,2 @@
+declare const useBeforeUnload: (enabled?: boolean | (() => boolean), message?: string) => void;
+export default useBeforeUnload;

package/types/hooks/useBoolean.d.ts

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

package/types/hooks/useClickAway.d.ts

@@ -0,0 +1,3 @@
+import { RefObject } from 'react';
+declare const useClickAway: <E extends Event = Event>(ref: RefObject<HTMLElement | null>, onClickAway: (event: E) => void, events?: string[]) => void;
+export default useClickAway;

package/types/hooks/useComputedState.d.ts

@@ -0,0 +1,4 @@
+import { ComponentState, PropsWithoutRef } from 'react';
+type Dependency<T> = PropsWithoutRef<T> | ComponentState;
+export default function useComputedState<T>(computed: () => any, deps: Dependency<T>[]): any;
+export {};

package/types/hooks/useCopyToClipboard.d.ts

@@ -0,0 +1,10 @@
+export interface CopyToClipboardState {
+    value?: string;
+    noUserInteraction: boolean;
+    error?: Error;
+}
+declare const useCopyToClipboard: () => [
+    CopyToClipboardState,
+    (value: string) => void
+];
+export default useCopyToClipboard;

package/types/hooks/useCounter.d.ts

@@ -0,0 +1,9 @@
+import { IHookStateInitAction, IHookStateSetAction } from './misc/hookState';
+export interface CounterActions {
+    inc: (delta?: number) => void;
+    dec: (delta?: number) => void;
+    get: () => number;
+    set: (value: IHookStateSetAction<number>) => void;
+    reset: (value?: IHookStateSetAction<number>) => void;
+}
+export default function useCounter(initialValue?: IHookStateInitAction<number>, max?: number | null, min?: number | null): [number, CounterActions];

package/types/hooks/useCreate.d.ts

@@ -0,0 +1 @@
+export default function useCreate(fn: any): void;

package/types/hooks/useCreation.d.ts

@@ -0,0 +1,2 @@
+export default useCreation;
+declare function useCreation(fn: any, deps: any): undefined;

package/types/hooks/useCustomCompareEffect.d.ts

@@ -0,0 +1,4 @@
+import { DependencyList, EffectCallback } from 'react';
+type DepsEqualFnType<TDeps extends DependencyList> = (prevDeps: TDeps, nextDeps: TDeps) => boolean;
+declare const useCustomCompareEffect: <TDeps extends DependencyList>(effect: EffectCallback, deps: TDeps, depsEqual: DepsEqualFnType<TDeps>) => void;
+export default useCustomCompareEffect;

package/types/hooks/useDebounce.d.ts

@@ -0,0 +1,3 @@
+import { DependencyList } from 'react';
+export type UseDebounceReturn = [() => boolean | null, () => void];
+export default function useDebounce(fn: Function, ms?: number, deps?: DependencyList): UseDebounceReturn;

package/types/hooks/useDefault.d.ts

@@ -0,0 +1,2 @@
+declare const useDefault: <TStateType>(defaultValue: TStateType, initialValue: TStateType | (() => TStateType)) => readonly [TStateType, import("react").Dispatch<import("react").SetStateAction<TStateType | null | undefined>>];
+export default useDefault;

package/types/hooks/useDrop.d.ts

@@ -0,0 +1,17 @@
+export interface DropAreaState {
+    over: boolean;
+}
+export interface DropAreaBond {
+    onDragOver: React.DragEventHandler;
+    onDragEnter: React.DragEventHandler;
+    onDragLeave: React.DragEventHandler;
+    onDrop: React.DragEventHandler;
+    onPaste: React.ClipboardEventHandler;
+}
+export interface DropAreaOptions {
+    onFiles?: (files: File[], event?: any) => void;
+    onText?: (text: string, event?: any) => void;
+    onUri?: (url: string, event?: any) => void;
+}
+declare const useDrop: (options?: DropAreaOptions, args?: never[]) => DropAreaState;
+export default useDrop;

package/types/hooks/useDropArea.d.ts

@@ -0,0 +1,17 @@
+export interface DropAreaState {
+    over: boolean;
+}
+export interface DropAreaBond {
+    onDragOver: React.DragEventHandler;
+    onDragEnter: React.DragEventHandler;
+    onDragLeave: React.DragEventHandler;
+    onDrop: React.DragEventHandler;
+    onPaste: React.ClipboardEventHandler;
+}
+export interface DropAreaOptions {
+    onFiles?: (files: File[], event?: any) => void;
+    onText?: (text: string, event?: any) => void;
+    onUri?: (url: string, event?: any) => void;
+}
+declare const useDropArea: (options?: DropAreaOptions) => [DropAreaBond, DropAreaState];
+export default useDropArea;

package/types/hooks/useEffectOnce.d.ts

@@ -0,0 +1,3 @@
+import { EffectCallback } from 'react';
+declare const useEffectOnce: (effect: EffectCallback) => void;
+export default useEffectOnce;

package/types/hooks/useEffectState.d.ts

@@ -0,0 +1,2 @@
+export default useEffectState;
+declare function useEffectState(props: any): any[];

package/types/hooks/useEnsuredForwardedRef.d.ts

@@ -0,0 +1,3 @@
+import { ForwardRefExoticComponent, MutableRefObject, PropsWithoutRef, RefAttributes, RefForwardingComponent } from 'react';
+export default function useEnsuredForwardedRef<T>(forwardedRef: MutableRefObject<T>): MutableRefObject<T>;
+export declare function ensuredForwardRef<T, P = {}>(Component: RefForwardingComponent<T, P>): ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>;

package/types/hooks/useError.d.ts

@@ -0,0 +1,2 @@
+declare const useError: () => ((err: Error) => void);
+export default useError;

package/types/hooks/useEvent.d.ts

@@ -0,0 +1,13 @@
+export interface ListenerType1 {
+    addEventListener(name: string, handler: (event?: any) => void, ...args: any[]): any;
+    removeEventListener(name: string, handler: (event?: any) => void, ...args: any[]): any;
+}
+export interface ListenerType2 {
+    on(name: string, handler: (event?: any) => void, ...args: any[]): any;
+    off(name: string, handler: (event?: any) => void, ...args: any[]): any;
+}
+export type UseEventTarget = ListenerType1 | ListenerType2;
+type AddEventListener<T> = T extends ListenerType1 ? T['addEventListener'] : T extends ListenerType2 ? T['on'] : never;
+export type UseEventOptions<T> = Parameters<AddEventListener<T>>[2];
+declare const useEvent: <T extends UseEventTarget>(name: Parameters<AddEventListener<T>>[0], handler?: null | undefined | Parameters<AddEventListener<T>>[1], target?: null | T | Window, options?: UseEventOptions<T>) => void;
+export default useEvent;

package/types/hooks/useEventListener.d.ts

@@ -0,0 +1,2 @@
+export default useEventListener;
+declare function useEventListener(event: any, handler: any, target?: Window & typeof globalThis): void;

package/types/hooks/useFavicon.d.ts

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

package/types/hooks/useFirstMountState.d.ts

@@ -0,0 +1 @@
+export default function useFirstMountState(): boolean;

package/types/hooks/useForceUpdate.d.ts

@@ -0,0 +1,2 @@
+export default useForceUpdate;
+declare function useForceUpdate(): () => void;

package/types/hooks/useFullscreen.d.ts

@@ -0,0 +1,10 @@
+import { RefObject } from 'react';
+export interface FullScreenOptions {
+    video?: RefObject<HTMLVideoElement & {
+        webkitEnterFullscreen?: () => void;
+        webkitExitFullscreen?: () => void;
+    }>;
+    onClose?: (error?: Error) => void;
+}
+declare const useFullscreen: (ref: RefObject<Element>, enabled: boolean, options?: FullScreenOptions) => boolean;
+export default useFullscreen;

package/types/hooks/useGeolocation.d.ts

@@ -0,0 +1,21 @@
+export interface IGeolocationPositionError {
+    readonly code: number;
+    readonly message: string;
+    readonly PERMISSION_DENIED: number;
+    readonly POSITION_UNAVAILABLE: number;
+    readonly TIMEOUT: number;
+}
+export interface GeoLocationSensorState {
+    loading: boolean;
+    accuracy: number | null;
+    altitude: number | null;
+    altitudeAccuracy: number | null;
+    heading: number | null;
+    latitude: number | null;
+    longitude: number | null;
+    speed: number | null;
+    timestamp: number | null;
+    error?: Error | IGeolocationPositionError;
+}
+declare const useGeolocation: (options?: PositionOptions) => GeoLocationSensorState;
+export default useGeolocation;

package/types/hooks/useGetSet.d.ts

@@ -0,0 +1,3 @@
+import { Dispatch } from 'react';
+import { IHookStateInitAction, IHookStateSetAction } from './misc/hookState';
+export default function useGetSet<S>(initialState: IHookStateInitAction<S>): [get: () => S, set: Dispatch<IHookStateSetAction<S>>];

package/types/hooks/useGetSetState.d.ts

@@ -0,0 +1,2 @@
+declare const useGetSetState: <T extends object>(initialState?: T) => [() => T, (patch: Partial<T>) => void];
+export default useGetSetState;

package/types/hooks/useHash.d.ts

@@ -0,0 +1,2 @@
+declare const useHash: () => readonly [string, (newHash: string) => void];
+export default useHash;

package/types/hooks/useHover.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export type Element = ((state: boolean) => React.ReactElement<any>) | React.ReactElement<any>;
+declare const useHover: (element: Element) => [React.ReactElement<any>, boolean];
+export default useHover;

package/types/hooks/useHoverDirty.d.ts

@@ -0,0 +1,3 @@
+import { RefObject } from 'react';
+declare const useHoverDirty: (ref: RefObject<Element>, enabled?: boolean) => boolean;
+export default useHoverDirty;

package/types/hooks/useId.d.ts

@@ -0,0 +1 @@
+export default function useId(prefix: string): string | undefined;

package/types/hooks/useIdle.d.ts

@@ -0,0 +1,2 @@
+declare const useIdle: (ms?: number, initialState?: boolean, events?: string[]) => boolean;
+export default useIdle;

package/types/hooks/useInView.d.ts

@@ -0,0 +1,11 @@
+interface UserInViewProps extends IntersectionObserverInit {
+    onChange?: (inView: boolean, entry: IntersectionObserverEntry) => void;
+    defaultInView?: boolean;
+    unobserverOnEnter?: boolean;
+    target?: Element;
+}
+declare function useInView(props: UserInViewProps): {
+    inView: boolean | undefined;
+    observer: IntersectionObserver | undefined;
+};
+export default useInView;

package/types/hooks/useIntersection.d.ts

@@ -0,0 +1,3 @@
+import { RefObject } from 'react';
+declare const useIntersection: (ref: RefObject<HTMLElement>, options: IntersectionObserverInit) => IntersectionObserverEntry | null;
+export default useIntersection;

package/types/hooks/useIntersectionObserver.d.ts

@@ -0,0 +1,7 @@
+export declare const supportIntersectionObserver: boolean;
+declare function useIntersectionObserver(callback: any, options?: {}): {
+    observer: IntersectionObserver | undefined;
+    cor: (elem: Element) => void;
+    dor: () => void;
+};
+export default useIntersectionObserver;

package/types/hooks/useInterval.d.ts

@@ -0,0 +1,2 @@
+export declare function useInterval(callback: Function, delay: null | number): () => void;
+export default useInterval;

package/types/hooks/useIsFirstRender.d.ts

@@ -0,0 +1 @@
+export default function useIsFirstRender(): boolean;

package/types/hooks/useIsomorphicLayoutEffect.d.ts

@@ -0,0 +1,3 @@
+import { useEffect } from 'react';
+declare const useIsomorphicLayoutEffect: typeof useEffect;
+export default useIsomorphicLayoutEffect;

package/types/hooks/useIsomorphicLayoutEffect2.d.ts

@@ -0,0 +1,3 @@
+import { useEffect } from 'react';
+declare const useIsomorphicLayoutEffect: typeof useEffect;
+export default useIsomorphicLayoutEffect;

package/types/hooks/useKey.d.ts

@@ -0,0 +1,12 @@
+import { DependencyList } from 'react';
+import { UseEventOptions, UseEventTarget } from './useEvent';
+export type KeyPredicate = (event: KeyboardEvent) => boolean;
+export type KeyFilter = null | undefined | string | ((event: KeyboardEvent) => boolean);
+export type Handler = (event: KeyboardEvent) => void;
+export interface UseKeyOptions<T extends UseEventTarget> {
+    event?: 'keydown' | 'keypress' | 'keyup';
+    target?: T | null;
+    options?: UseEventOptions<T>;
+}
+declare const useKey: <T extends UseEventTarget>(key: KeyFilter, fn?: Handler, opts?: UseKeyOptions<T>, deps?: DependencyList) => void;
+export default useKey;

package/types/hooks/useKeyPress.d.ts

@@ -0,0 +1,3 @@
+import { KeyFilter } from './useKey';
+declare const useKeyPress: (keyFilter: KeyFilter) => [boolean, KeyboardEvent | null];
+export default useKeyPress;

package/types/hooks/useKeyPressEvent.d.ts

@@ -0,0 +1,3 @@
+import { Handler, KeyFilter } from './useKey';
+declare const useKeyPressEvent: (key: string | KeyFilter, keydown?: Handler | null | undefined, keyup?: Handler | null | undefined, useKeyPress?: (keyFilter: KeyFilter) => [boolean, KeyboardEvent | null]) => void;
+export default useKeyPressEvent;

package/types/hooks/useKeyboardEvent.d.ts

@@ -0,0 +1,14 @@
+import { KeyboardEventHandler } from 'react';
+type CallBackEventType = 'onPressEnter' | 'onArrowUp' | 'onArrowLeft' | 'onArrowRight' | 'onArrowDown';
+export default function useKeyboardEvent(props?: {
+    onKeyDown?: KeyboardEventHandler;
+}): (callbacks: {
+    onPressEnter?: ((event: any) => void) | undefined;
+    onArrowUp?: ((event: any) => void) | undefined;
+    onArrowLeft?: ((event: any) => void) | undefined;
+    onArrowRight?: ((event: any) => void) | undefined;
+    onArrowDown?: ((event: any) => void) | undefined;
+}) => {
+    onKeyDown: (event: any) => void;
+};
+export {};

package/types/hooks/useLatest.d.ts

@@ -0,0 +1,4 @@
+declare const useLatest: <T>(value: T) => {
+    readonly current: T;
+};
+export default useLatest;

package/types/hooks/useLifecycles.d.ts

@@ -0,0 +1,2 @@
+declare const useLifecycles: (mount: any, unmount?: any) => void;
+export default useLifecycles;

package/types/hooks/useList.d.ts

@@ -0,0 +1,18 @@
+import { IHookStateInitAction, IHookStateSetAction } from './misc/hookState';
+export interface ListActions<T> {
+    set: (newList: IHookStateSetAction<T[]>) => void;
+    push: (...items: T[]) => void;
+    updateAt: (index: number, item: T) => void;
+    insertAt: (index: number, item: T) => void;
+    update: (predicate: (a: T, b: T) => boolean, newItem: T) => void;
+    updateFirst: (predicate: (a: T, b: T) => boolean, newItem: T) => void;
+    upsert: (predicate: (a: T, b: T) => boolean, newItem: T) => void;
+    sort: (compareFn?: (a: T, b: T) => number) => void;
+    filter: (callbackFn: (value: T, index?: number, array?: T[]) => boolean, thisArg?: any) => void;
+    removeAt: (index: number) => void;
+    remove: (index: number) => void;
+    clear: () => void;
+    reset: () => void;
+}
+declare function useList<T>(initialList?: IHookStateInitAction<T[]>): [T[], ListActions<T>];
+export default useList;

package/types/hooks/useLocalStorage.d.ts

@@ -0,0 +1,10 @@
+import { Dispatch, SetStateAction } from 'react';
+type parserOptions<T> = {
+    raw: true;
+} | {
+    raw: false;
+    serializer: (value: T) => string;
+    deserializer: (value: string) => T;
+};
+declare const useLocalStorage: <T>(key: string, initialValue?: T, options?: parserOptions<T>) => [T | undefined, Dispatch<SetStateAction<T | undefined>>, () => void];
+export default useLocalStorage;

package/types/hooks/useLocation.d.ts

@@ -0,0 +1,16 @@
+export interface LocationSensorState {
+    trigger: string;
+    state?: any;
+    length?: number;
+    hash?: string;
+    host?: string;
+    hostname?: string;
+    href?: string;
+    origin?: string;
+    pathname?: string;
+    port?: string;
+    protocol?: string;
+    search?: string;
+}
+declare const _default: () => LocationSensorState;
+export default _default;

package/types/hooks/useLockBodyScroll.d.ts

@@ -0,0 +1,8 @@
+import { RefObject } from 'react';
+export declare function getClosestBody(el: Element | HTMLElement | HTMLIFrameElement | null): HTMLElement | null;
+export interface BodyInfoItem {
+    counter: number;
+    initialOverflow: CSSStyleDeclaration['overflow'];
+}
+declare const _default: (_locked?: boolean, _elementRef?: RefObject<HTMLElement>) => void;
+export default _default;

package/types/hooks/useLogger.d.ts

@@ -0,0 +1,2 @@
+declare const useLogger: (componentName: string, ...rest: any[]) => void;
+export default useLogger;

package/types/hooks/useLongPress.d.ts

@@ -0,0 +1,12 @@
+interface Options {
+    isPreventDefault?: boolean;
+    delay?: number;
+}
+declare const useLongPress: (callback: (e: TouchEvent | MouseEvent) => void, { isPreventDefault, delay }?: Options) => {
+    readonly onMouseDown: (e: any) => void;
+    readonly onTouchStart: (e: any) => void;
+    readonly onMouseUp: () => void;
+    readonly onMouseLeave: () => void;
+    readonly onTouchEnd: () => void;
+};
+export default useLongPress;

package/types/hooks/useMap.d.ts

@@ -0,0 +1,11 @@
+export interface StableActions<T extends object> {
+    set: <K extends keyof T>(key: K, value: T[K]) => void;
+    setAll: (newMap: T) => void;
+    remove: <K extends keyof T>(key: K) => void;
+    reset: () => void;
+}
+export interface Actions<T extends object> extends StableActions<T> {
+    get: <K extends keyof T>(key: K) => T[K];
+}
+declare const useMap: <T extends object = any>(initialMap?: T) => [T, Actions<T>];
+export default useMap;

package/types/hooks/useMeasure.d.ts

@@ -0,0 +1,9 @@
+export type UseMeasureRect = Pick<DOMRectReadOnly, 'x' | 'y' | 'top' | 'left' | 'right' | 'bottom' | 'height' | 'width'>;
+export type UseMeasureRef<E extends Element = Element> = (element: E) => void;
+export type UseMeasureResult<E extends Element = Element> = [
+    UseMeasureRef<E>,
+    UseMeasureRect
+];
+declare function useMeasure<E extends Element = Element>(): UseMeasureResult<E>;
+declare const _default: typeof useMeasure;
+export default _default;

package/types/hooks/useMeasureDirty.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from 'react';
+export interface ContentRect {
+    width: number;
+    height: number;
+    top: number;
+    right: number;
+    left: number;
+    bottom: number;
+}
+declare const useMeasureDirty: (ref: RefObject<HTMLElement>) => ContentRect;
+export default useMeasureDirty;

package/types/hooks/useMedia.d.ts

@@ -0,0 +1,2 @@
+declare const useMedia: (query: string, defaultState?: boolean) => boolean;
+export default useMedia;

package/types/hooks/useMediaDevices.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => {};
+export default _default;

package/types/hooks/useMediatedState.d.ts

@@ -0,0 +1,9 @@
+import { Dispatch, SetStateAction } from 'react';
+export interface StateMediator<S = any> {
+    (newState: any): S;
+    (newState: any, dispatch: Dispatch<SetStateAction<S>>): void;
+}
+export type UseMediatedStateReturn<S = any> = [S, Dispatch<SetStateAction<S>>];
+export declare function useMediatedState<S = undefined>(mediator: StateMediator<S | undefined>): UseMediatedStateReturn<S | undefined>;
+export declare function useMediatedState<S = any>(mediator: StateMediator<S>, initialState: S): UseMediatedStateReturn<S>;
+export default useMediatedState;

package/types/hooks/useMergeProps.d.ts

@@ -0,0 +1,4 @@
+export type MergePropsOptions = {
+    _ignorePropsFromGlobal?: boolean;
+};
+export default function useMergeProps<PropsType>(componentProps: PropsType & MergePropsOptions, defaultProps: Partial<PropsType | undefined>, globalComponentConfig: Partial<PropsType | undefined>): PropsType;

package/types/hooks/useMergeValue.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export default function useMergeValue<T>(defaultStateValue: T, props?: {
+    defaultValue?: T;
+    value?: T;
+}): [T, React.Dispatch<React.SetStateAction<T>>, T];

package/types/hooks/useMethods.d.ts

@@ -0,0 +1,8 @@
+type CreateMethods<M, T> = (state: T) => {
+    [P in keyof M]: (payload?: any) => T;
+};
+type WrappedMethods<M> = {
+    [P in keyof M]: (...payload: any) => void;
+};
+declare const useMethods: <M, T>(createMethods: CreateMethods<M, T>, initialState: T) => [T, WrappedMethods<M>];
+export default useMethods;