import * as _vue_reactivity from '@vue/reactivity';
import * as vue from 'vue';
import { Ref, Plugin, AppContext, MaybeRefOrGetter, MaybeRef } from 'vue';
import * as _vue_shared from '@vue/shared';

declare const getTag: <T>(value: T) => string;

declare const passwordLevel: (password: string) => number;

type Omit$1<T, K extends keyof any> = Pick$1<T, Exclude$1<keyof T, K>>;
type Pick$1<T, K extends keyof T> = {
    [P in K]: T[P];
};
type Partial<T> = {
    [P in keyof T]?: T[P];
};
type Required<T> = {
    [P in keyof T]-?: T[P];
};
type Exclude$1<T, U> = T extends U ? never : T;
type Extract<T, U> = T extends U ? T : never;
type Record$1<K extends keyof any, T> = {
    [P in K]: T;
};
type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};
type Arrayable<T> = T | T[];
type CallbackVoid<T = any> = (...args: T[]) => void;
type ComponentProps<T> = T extends new (...args: any) => {
    $props: infer P;
} ? NonNullable<P> : T extends (props: infer P, ...args: any) => any ? P : {};
type ComponentSlots<T> = T extends new (...args: any) => {
    $slots: infer S;
} ? NonNullable<S> : T extends (props: any, ctx: {
    slots: infer S;
    attrs: any;
    emit: any;
}, ...args: any) => any ? NonNullable<S> : {};
type ComponentEmits<T> = T extends new (...args: any) => {
    $emit: infer E;
} ? NonNullable<E> : {};
type ComponentExposed<T> = T extends new (...args: any) => infer E ? E : T extends (props: any, ctx: any, expose: (exposed: infer E) => any, ...args: any) => any ? NonNullable<E> : {};

declare const deepObjectValue: <T = object>(data: T, prop: string) => any;

declare const COLOR: {
    black: string;
    red: string;
    green: string;
    yellow: string;
    blue: string;
    magenta: string;
    cyan: string;
    white: string;
};
type ColorType = keyof typeof COLOR;
type LogBaseFn = (message: string, isBlock?: boolean) => void;
type LogLevel = 'log' | 'warn' | 'error' | 'wait' | 'ready' | 'info' | 'event';
type ChalkLog = Record<ColorType, LogBaseFn> & Record<LogLevel, LogBaseFn>;
declare const chalkLog: () => ChalkLog;

declare function toArray<T>(value: T): T extends readonly any[] ? T : [T];

declare function tryOnScopeDispose(fn: any): boolean;

declare function magicObject<T>(obj: T): NonNullable<T>;

type RequestAPI<P, R> = (params: P) => Promise<R>;
type Watcher<P> = {
    keys?: (keyof P)[];
    immediate?: boolean;
    deep?: boolean;
};
interface IUseTableList<T = any, P = any, D = any> {
    request: {
        api: RequestAPI<P, T>;
        params?: P;
        pageNumKey?: string;
        pageSizeKey?: string;
        handleParams?: (params: P) => P;
        watcher?: Watcher<P>;
    };
    response?: {
        listKey?: string;
        totalKey?: string;
        hasPage?: (res: D) => boolean;
        append?: boolean;
        responseHandler?: (res: D) => any;
    };
}
declare const useTableList: <T = any, P extends object = any, D = any>(config: IUseTableList<T, P, D>) => {
    params: Ref<P, P>;
    tableData: Ref<_vue_reactivity.UnwrapRefSimple<T>[], T[] | _vue_reactivity.UnwrapRefSimple<T>[]>;
    tableTotal: Ref<number, number>;
    tableLoading: Ref<boolean, boolean>;
    isLastPage: Ref<boolean, boolean>;
    updateApi: (newApi: RequestAPI<P, T>) => void;
    handleSearch: (pageNum?: number) => Promise<void>;
    handleReset: () => Promise<void>;
    handleSizeChange: (pageSize: number) => Promise<void>;
    handleCurrentChange: (pageNum: number) => Promise<void>;
};

declare const useBeforeDate: (date: number | string | Date, target?: number | string | Date, resDefault?: string | number | null) => string | number | null;

declare const useCamelize: (str: string, pascal?: boolean) => string;

declare const useCamel2kebab: (str: string, mark?: "-" | "_") => string;

declare const useChunk: <T = any>(value: T[], size?: number) => T[] | T[][];

declare const useCloneDeep: <T>(data: T) => T;

declare const useDebounceRef: <T>(data: T, delay?: number) => ([T] extends [vue.Ref<any, any>] ? _vue_shared.IfAny<T, vue.Ref<T, T>, T> : vue.Ref<vue.UnwrapRef<T>, T | vue.UnwrapRef<T>>) | vue.Ref<T, T>;

declare const useEmptyObject: <T>(data: T, defaultValue?: DeepPartial<T>) => T;

declare const useEncCard: (card: string) => string;

declare const useEncPhone: (phone: string) => string;

declare function useFirstToUpper(str: string): string;

type FormatDate = 'yyyy' | 'yyyy-MM' | 'yyyy-MM-dd' | 'yyyy-MM-dd HH:mm' | 'yyyy-MM-dd HH:mm:ss' | 'MM-dd' | 'HH:mm' | 'HH:mm:ss' | string;
declare const useFormatDate: (date: number | string | Date, format?: FormatDate) => string;

declare const useFormatBytes: (value: number, decimal?: number) => string;

declare const useFormValueWatcher: <T>(targets: T, origins: T) => boolean;

interface ILabelByValOptions<T> {
    valueKey?: keyof T;
    labelKey?: keyof T;
}
declare const useLabelByVal: <T = any>(list: T[], value: string | number, options?: ILabelByValOptions<T>) => any;

declare const useMerge: <T>(target: T, ...sources: DeepPartial<T>[]) => T;

type OmitKeys<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
declare const useOmit: <T extends object, K extends keyof T>(obj: T, keys: K[]) => Omit<T, K>;
declare const useDeepOmit: <T, K extends keyof T>(obj: T, keys: K[]) => OmitKeys<T, K>;

declare const usePick: <T, K extends keyof T>(obj: T, keys: K[]) => Pick<T, K>;

declare const usePriceToThousand: (price: string | number, decimals?: number, separator?: string, round?: boolean) => string;

type UseSFCWithInstall<T> = T & Plugin;
type UseSFCInstallWithContext<T> = UseSFCWithInstall<T> & {
    _context: AppContext | null;
};
type SFC = {
    name: string;
};
declare const useSFCWithInstall: <T extends SFC>(comp: T) => UseSFCWithInstall<T>;
declare const useSFCWithInstallFunction: <T>(fn: T, name: string) => UseSFCInstallWithContext<T>;

interface ISocketOptions {
    protocols?: string | string[];
    heartTime?: number;
    heartMessage?: string;
    autoClose?: boolean;
    isReconnect?: boolean;
    reconnectTime?: number;
    reconnectCount?: number | (() => boolean);
    onOpen?: (ws: WebSocket) => void;
    onClose?: (ws: WebSocket, e: CloseEvent) => void;
    onMessage?: (ws: WebSocket, e: MessageEvent) => void;
    beforeMessage?: (e: MessageEvent) => any;
    onError?: (ws: WebSocket, e: Event) => void;
    onFailed?: () => void;
}
interface ISocketReturn<T> {
    data?: Ref<T | null>;
    close: WebSocket['close'];
    websocketOpen: () => void;
    send: (data: string | ArrayBuffer | Blob, useBuffer?: boolean) => boolean;
    ws: Ref<WebSocket | undefined>;
}
declare const useWebSocket: <Data = any>(url: string, options?: ISocketOptions) => ISocketReturn<Data>;

interface ISort<T> {
    order?: 'dec' | 'asc';
    key?: keyof T;
    compareFn?: (a: T, b: T) => number;
}
declare const useSort: <T = any>(data: T[], options?: ISort<T>) => T[];

declare const useToFixedFix: (value: number, decimals?: number, round?: boolean) => number;

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

interface ITreeOptions {
    children?: string;
    pidKey?: string;
    pidValue?: string | number | null;
    parentKey?: string;
    pidFlag?: boolean;
}
declare const useTransformList: <T>(data: T[], options?: ITreeOptions) => Omit<T, "children">[];

type IProps<T = any> = T & {
    children: T[];
};
interface IOptions {
    parentKey?: string;
    pidKey?: string;
    pidValue?: string | number | null;
}
declare const useTransformTree: <T>(arrData: T[], options?: IOptions) => IProps<T>[];

declare function useValPassword(value: string, max?: number): boolean;
declare function useValPassword(value: string, min?: number, max?: number): boolean;

type UseRafTimeoutFn = () => void;
type UseRafTimeoutOptions = {
    delay?: number;
    isInterval?: boolean;
    immediate?: boolean;
};
type UseRafTimeoutReturn = {
    close: () => void;
    start: () => void;
};
declare const useRafTimeout: (execFn: UseRafTimeoutFn, options?: UseRafTimeoutOptions) => UseRafTimeoutReturn;

type UseResizeObserverOptions = {
    immediate: boolean;
    autoStop?: boolean;
} & ResizeObserverOptions;
type ResizeObserverTargets = HTMLElement | HTMLElement[] | Ref<HTMLElement> | Ref<HTMLElement>[];
type ResizeObserverReturn = {
    start: () => void;
    stop: () => void;
};
declare const useResizeObserver: (target: ResizeObserverTargets, callback: ResizeObserverCallback, options?: UseResizeObserverOptions) => ResizeObserverReturn;

type IDebounceFn = (...args: any[]) => void;
declare const useDebounce: <T extends (...args: any[]) => any>(func: T, delay?: number) => T;

type IThrottleFn = (...args: any[]) => void;
declare const useThrottle: <T extends IThrottleFn>(func: T, delay?: number) => T;

type WindowEventName = keyof WindowEventMap;
type DocumentEventName = keyof DocumentEventMap;
type HTMLElementEventName = keyof HTMLElementEventMap;
declare function useEventListener<E extends WindowEventName>(event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: Window, ev: WindowEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): CallbackVoid;
declare function useEventListener<E extends DocumentEventName>(target: DocumentOrShadowRoot, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: Document, ev: DocumentEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): CallbackVoid;
declare function useEventListener<E extends WindowEventName>(target: Window, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: Window, ev: WindowEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): CallbackVoid;
declare function useEventListener<E extends HTMLElementEventName>(target: MaybeRefOrGetter<Arrayable<HTMLElement> | null | undefined>, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<(this: HTMLElement, ev: HTMLElementEventMap[E]) => any>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): CallbackVoid;

type WebElement = HTMLElement | HTMLDivElement | Element | null;
type MaybeRefWebElement = MaybeRef<WebElement>;
type InterObserverTarget = Arrayable<MaybeRefWebElement>;
type InterObserverReturn = {
    pause: () => void;
    resume: () => void;
    stop: () => void;
    isActive: Ref<boolean>;
};
type InterObserverOptions = {
    immediate?: boolean;
} & IntersectionObserverInit;
declare const useIntersectObserver: (target: InterObserverTarget, callback: IntersectionObserverCallback, options?: InterObserverOptions) => InterObserverReturn;

declare const isCamelCase: (str: string) => boolean;

declare const isNumber: (value: any) => value is number;
declare const isNumeric: (value: any) => value is number;

declare function isNaN(value: unknown): boolean;

declare const isPhone: (phone: string) => boolean;

declare const isObjectLike: <T>(value: T) => value is T & object;

declare const isIdCard: (card: string) => boolean;

declare const isFunction: (value: any) => value is (...args: any[]) => any;

declare const isString: (value: any) => value is string;

declare const isEmpty: (value: unknown) => boolean;

declare const isArray: (value: any) => value is Array<any>;

declare const isKebabCase: (str: string) => boolean;

declare const isObject: <T = unknown>(value: T) => boolean;

declare const isBoolean: <T = unknown>(value: T) => boolean;

declare function isBaseEquals(value1: unknown, value2: unknown, ignoreNumbers?: boolean): boolean;
declare function isDeepEquals(value1: any, value2: any, ignoreNumbers?: boolean, seen?: WeakMap<any, boolean>): boolean;
declare function isEquals(value1: unknown, value2: unknown, ignoreNumbers?: boolean): boolean;

export { type Arrayable, type CallbackVoid, type ComponentEmits, type ComponentExposed, type ComponentProps, type ComponentSlots, type DeepPartial, type DocumentEventName, type Exclude$1 as Exclude, type Extract, type FormatDate, type HTMLElementEventName, type IDebounceFn, type ILabelByValOptions, type IOptions, type IProps, type ISocketOptions, type ISocketReturn, type ISort, type IThrottleFn, type ITreeOptions, type IUseTableList, type InterObserverOptions, type InterObserverReturn, type InterObserverTarget, type MaybeRefWebElement, type Omit$1 as Omit, type OmitKeys, type Partial, type Pick$1 as Pick, type Record$1 as Record, type RequestAPI, type Required, type ResizeObserverReturn, type ResizeObserverTargets, type SFC, type UseRafTimeoutFn, type UseRafTimeoutOptions, type UseRafTimeoutReturn, type UseResizeObserverOptions, type UseSFCInstallWithContext, type UseSFCWithInstall, type Watcher, type WebElement, type WindowEventName, chalkLog, deepObjectValue, getTag, isArray, isBaseEquals, isBoolean, isCamelCase, isDeepEquals, isEmpty, isEquals, isFunction, isIdCard, isKebabCase, isNaN, isNumber, isNumeric, isObject, isObjectLike, isPhone, isString, magicObject, passwordLevel, toArray, tryOnScopeDispose, useBeforeDate, useCamel2kebab, useCamelize, useChunk, useCloneDeep, useDebounce, useDebounceRef, useDeepOmit, useEmptyObject, useEncCard, useEncPhone, useEventListener, useFirstToUpper, useFormValueWatcher, useFormatBytes, useFormatDate, useIntersectObserver, useLabelByVal, useMerge, useOmit, usePick, usePriceToThousand, useRafTimeout, useResizeObserver, useSFCWithInstall, useSFCWithInstallFunction, useSort, useTableList, useThrottle, useToFixedFix, useToInteger, useTransformList, useTransformTree, useValPassword, useWebSocket };