import { RefObject, RefCallback, useEffect, ForwardedRef } from 'react';

type DeepPartial<Value> = Value extends object ? {
    [Key in keyof Value]?: DeepPartial<Value[Key]>;
} : Value;

type DeepWritable<Type> = Type extends Date | Error | Function | RegExp | boolean | number | string | null | undefined ? Type : Type extends Map<infer K, infer V> ? Map<DeepWritable<K>, DeepWritable<V>> : Type extends ReadonlyMap<infer K, infer V> ? Map<DeepWritable<K>, DeepWritable<V>> : Type extends WeakMap<infer K, infer V> ? WeakMap<DeepWritable<K>, DeepWritable<V>> : Type extends Set<infer U> ? Set<DeepWritable<U>> : Type extends ReadonlySet<infer U> ? Set<DeepWritable<U>> : Type extends WeakSet<infer U> ? WeakSet<DeepWritable<U>> : Type extends Promise<infer U> ? Promise<DeepWritable<U>> : Type extends Record<string, any> ? {
    -readonly [K in keyof Type]: DeepWritable<Type[K]>;
} : Type;

type DistributiveOmit<Obj, Keys extends keyof any> = Obj extends any ? Omit<Obj, Keys> : never;

type DistributivePick<Type, Key extends keyof Type> = Type extends unknown ? Pick<Type, Key> : never;

type Rect$1 = {
    height: number;
    width: number;
    x: number;
    y: number;
};
type TargetElement = any;

declare function getElementRect(element: TargetElement): Promise<Rect$1>;

type RemoveArray<ArrayLike> = ArrayLike extends any[] ? ArrayLike[number] : ArrayLike;
type PathImpl<Obj, Key extends keyof Obj> = Key extends string ? Obj[Key] extends Record<keyof any, any> ? `${Key}.${keyof RemoveArray<Obj[Key]> & (number | string)}` | `${Key}.${PathImpl<Obj[Key], keyof Obj[Key] & keyof RemoveArray<Obj[Key]>> & (number | string)}` : never : never;
type Path<Obj> = PathImpl<Obj, keyof Obj> | keyof Obj;

declare const addStyleValues: (...values: (number | string)[]) => string | number;

declare const convertRemToPixels: (value: number | string) => number | string;

declare function isDefined<Value>(value: Value | undefined): value is Value;

declare const get: (obj: Record<string, any>, path: string, defaultValue?: any) => any;

declare const range: (length: number) => any[];

declare const isRecord: (value: any) => boolean;

declare const uuidV4: () => string;

declare const useSafeDeps: <Value>(value: Value) => RefObject<Value>;

declare const toZeroPadded: (source: number | string | undefined, maxStringLength: number) => string;

declare const getDateString: (date: Date, divider?: string) => string;

declare function useBackHandler(handler: () => boolean): void;

type LayoutEvent = {
    width: number;
    height: number;
    top: number;
    left: number;
    right: number;
    bottom: number;
};
type UseLayoutEventResult = {
    ref: RefCallback<any | null>;
};
declare const useLayoutEvent: (callback?: (event: LayoutEvent) => void) => UseLayoutEventResult;

type UseInViewProps = {
    initialInView: boolean;
    onChange?: (inView: boolean) => void;
    options?: IntersectionObserverInit;
};
type UseInViewResult = {
    ref: RefCallback<any | null>;
    isInView: boolean;
};
declare const useInView: ({ initialInView, onChange, options }: UseInViewProps) => UseInViewResult;

type Rect = {
    height: number;
    width: number;
    x: number;
    y: number;
};

type Side = 'bottom' | 'left' | 'right' | 'top';
type Align = 'end' | 'start';
type Position = Side | `${Side}-${Align}`;

declare const getOffsetByPosition: ({ referenceRect, targetRect, position, spacing, }: {
    referenceRect: Rect;
    targetRect: Rect;
    position: Position;
    spacing?: number;
}) => {
    x: number;
    y: number;
};

declare const detectOverflow: ({ viewport, targetRect, }: {
    viewport: Pick<Rect, 'height' | 'width'>;
    targetRect: Rect;
}) => {
    top: number;
    bottom: number;
    left: number;
    right: number;
};

declare const flipPosition: (position: Position, flipAlignment?: boolean) => Position;

declare function useCallbackRef<CallbackFn extends (...args: any[]) => any>(callback: CallbackFn | undefined): CallbackFn;

type UseControllableStateProps<Value> = {
    value?: Value;
    defaultValue?: Value;
    onValueChange?: (value: Value) => void;
};
declare function useControllableState<Value>({ value: valueProp, defaultValue, onValueChange, }: UseControllableStateProps<Value>): readonly [Value, (nextValue: Value) => void];

declare const useIsomorphicLayoutEffect: typeof useEffect;

declare const useObjectMemo: <Value>(object: Value) => Value;

declare function useComposedRef(ref1?: ForwardedRef<any> | null, ref2?: ForwardedRef<any>): (node: HTMLDivElement) => void;

type UseEscapeEventResult = {
    ref: RefObject<HTMLElement>;
};
declare const useEscapeEvent: (callback: () => void) => UseEscapeEventResult;

type Without<T, U> = {
    [P in Exclude<keyof T, keyof U>]?: never;
};
type Either<T, U> = T | U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;

export { type Align, type DeepPartial, type DeepWritable, type DistributiveOmit, type DistributivePick, type Either, type LayoutEvent, type Path, type Position, type Rect$1 as Rect, type Side, type TargetElement, addStyleValues, convertRemToPixels, detectOverflow, flipPosition, get, getDateString, getElementRect, getOffsetByPosition, isDefined, isRecord, range, toZeroPadded, useBackHandler, useCallbackRef, useComposedRef, useControllableState, useEscapeEvent, useInView, useIsomorphicLayoutEffect, useLayoutEvent, useObjectMemo, useSafeDeps, uuidV4 };