/**
 * 判断参数是否全部为字母或数字字符串
 *
 * @example
 * //true
 * console.log(_.isAlnum('123'))
 * //true
 * console.log(_.isAlnum('123abc'))
 * //false
 * console.log(_.isAlnum(1))
 *
 * @param v
 * @returns
 * @since 1.15.0
 */
declare function isAlnum(v: unknown): v is string;

/**
 * 判断参数是否全部为字母，含国际字母表
 *
 * @example
 * //true
 * console.log(_.isAlpha('𰻞𰻞mian'))
 * //false
 * console.log(_.isAlpha(1))
 *
 * @param v
 * @returns
 * @since 1.15.0
 */
declare function isAlpha(v: unknown): v is string;

/**
 * 判断参数是否为Array对象的实例
 *
 * @example
 * //true
 * console.log(_.isArray([]))
 * //false
 * console.log(_.isArray(document.body.children))
 *
 * @param v
 * @returns
 */
declare function isArray<T>(v: unknown): v is T[];

/**
 * 内部使用类型
 *
 * @packageDocumentation
 */
/**
 * 列表类型
 */
interface IList {
    length: number;
    [Symbol.iterator]?: any;
    [index: number]: any;
}
/**
 * 类数组类型
 */
type ArrayLike<V = unknown> = Array<V> | string | NodeList | HTMLCollection | IList | NodeListOf<Node>;

/**
 * 判断参数是否为类数组对象
 *
 * @example
 * //true
 * console.log(_.isArrayLike('abc123'))
 * //true
 * console.log(_.isArrayLike([]))
 * //true
 * console.log(_.isArrayLike(document.body.children))
 *
 * @param v
 * @returns
 */
declare function isArrayLike<T>(v: unknown): v is ArrayLike<T>;

/**
 * 对字符串进行trim后进行验证。如果非字符串，转为字符串后进行验证
 * @example
 * //true
 * console.log(_.isBlank('  '))
 * //true
 * console.log(_.isBlank(null))
 * //false
 * console.log(_.isBlank({}))
 * //false
 * console.log(_.isBlank('     1'))
 *
 * @param v 字符串
 * @returns 如果字符串是null/undefined/\t \n \f \r或trim后长度为0，返回true
 * @since 0.16.0
 */
declare function isBlank(v: unknown): boolean;

/**
 * 判断值是不是一个布尔值
 *
 * @example
 * //true
 * console.log(_.isBoolean(false))
 * //false
 * console.log(_.isBoolean('true'))
 * //false
 * console.log(_.isBoolean(1))
 *
 * @param v
 * @returns
 */
declare function isBoolean(v: unknown): v is boolean;

/**
 * 判断值是不是自定义Element
 *
 * @example
 * //false
 * console.log(_.isCustomElement(document.body))
 * //true
 * console.log(_.isCustomElement(document.body.querySelector('l-ele')))
 *
 * @param v
 * @returns
 * @since 1.14.0
 */
declare function isCustomElement(v: unknown): v is HTMLElement;

/**
 * 判断值是不是一个Date实例
 *
 * @example
 * //true
 * console.log(_.isDate(new Date()))
 * //false
 * console.log(_.isDate('2020/1/1'))
 *
 * @param v
 * @returns
 */
declare function isDate(v: unknown): v is Date;

/**
 * isUndefined()的反向验证函数，在需要验证是否变量存在的场景下非常有用
 * @example
 * //true
 * console.log(_.isDefined(null))
 * //false
 * console.log(_.isDefined(undefined))
 *
 * @param v
 * @returns
 */
declare function isDefined(v: unknown): boolean;

/**
 * 判断值是不是Element的实例
 *
 * @example
 * //true
 * console.log(_.isElement(document.body))
 * //false
 * console.log(_.isElement(document))
 *
 * @param v
 * @returns
 * @since 1.0.0
 */
declare function isElement(v: unknown): v is globalThis.Element;

/**
 * 判断参数是否为空，包括`null/undefined/空字符串/0/[]/{}`都表示空
 *
 * 注意：相比isBlank，isEmpty只判断字符串长度是否为0
 *
 * @example
 * //true
 * console.log(_.isEmpty(null))
 * //true
 * console.log(_.isEmpty([]))
 * //false
 * console.log(_.isEmpty({x:1}))
 *
 * @param v
 * @returns
 */
declare function isEmpty(v: unknown): boolean;

/**
 * 判断两个值是否相等，对于非基本类型会进行深度比较，可以比较日期/正则/数组/对象等
 *
 * @example
 * //false
 * console.log(_.isEqual(1,'1'))
 * //true,false
 * let o = {a:1,b:[2,{c:['3','x']}]}
 * let oo = {a:1,b:[2,{c:['3','x']}]}
 * console.log(_.isEqual(o,oo),o == oo)
 * //true
 * console.log(_.isEqual([new Date('2010-2-1'),/12/],[new Date(1264953600000),new RegExp('12')]))
 * //false
 * console.log(_.isEqual([new Date('2010-2-1'),'abcd'],['2010/2/1','Abcd']))
 *
 * @param a
 * @param b
 * @returns
 * @since 1.0.0
 */
declare function isEqual(a: unknown, b: unknown): boolean;

/**
 * 同<code>isEqual</code>，但支持自定义比较器。如果未指定比较器则使用内置逻辑处理
 * 内置逻辑:
 *  - 如果是日期使用getTime对比
 *  - 如果是正则使用toString对比
 *  - 如果是元素节点使用tagName+id+class对比
 *  - 如果是函数使用name对比
 * @example
 * //true
 * console.log(_.isEqualWith([new Date('2010-2-1'),'abcd'],['2010/2/1','Abcd'],(av,bv)=>_.isDate(av)?av.toLocaleDateString() == bv:_.test(av,bv,'i')))
 *
 * @param a
 * @param b
 * @param [comparator] 比较器，参数(v1,v2)，返回true表示匹配。如果返回undefined使用对应内置比较器处理
 * @returns
 * @since 1.0.0
 */
declare function isEqualWith(a: any, b: any, comparator?: Function): boolean;

/**
 * 判断值是不是异常对象
 *
 * @example
 * //true
 * console.log(_.isError(new TypeError))
 * //false
 * console.log(_.isError(Error))
 * //true
 * try{a=b}catch(e){console.log(_.isError(e))}
 *
 * @param v
 * @returns
 * @since 1.0.0
 */
declare function isError(v: unknown): v is Error;

/**
 * 判断值是不是有限数字
 *
 * @example
 * //false
 * console.log(_.isFinite('0'))
 * //true
 * console.log(_.isFinite(0))
 * //true
 * console.log(_.isFinite(Number.MAX_VALUE))
 * //true
 * console.log(_.isFinite(99999999999999999999999999999999999999999999999999999999999999999999999))
 * //false
 * console.log(_.isFinite(Infinity))
 *
 * @param v
 * @returns
 * @since 1.0.0
 */
declare function isFinite(v: unknown): boolean;

/**
 * 判断参数是否为函数对象
 *
 * @example
 * //true
 * console.log(_.isFunction(new Function()))
 * //true
 * console.log(_.isFunction(()=>{}))
 *
 * @param v
 * @returns
 */
declare function isFunction(v: unknown): v is Function;

/**
 * 判断值是不是一个整数
 *
 * @example
 * //true
 * console.log(_.isInteger(-0))
 * //true
 * console.log(_.isInteger(5.0))
 * //false
 * console.log(_.isSafeInteger(5.000000000000001))
 * //true
 * console.log(_.isSafeInteger(5.0000000000000001))
 * //false
 * console.log(_.isInteger('5'))
 * //true
 * console.log(_.isInteger(Number.MAX_SAFE_INTEGER))
 * //true
 * console.log(_.isInteger(Number.MAX_VALUE))
 *
 * @param v
 * @returns
 */
declare function isInteger(v: unknown): v is number;

/**
 * 判断值是不是迭代器对象
 *
 * @example
 * //true
 * console.log(_.isIterator(new Map()))
 * //true
 * console.log(_.isIterator(new Map().values()))
 * //false
 * console.log(_.isIterator({a:1}))
 *
 * @param v
 * @returns
 * @since 1.10.0
 */
declare function isIterator(v: unknown): v is Iterable<any>;

/**
 * 判断参数是否为小写字母
 * @example
 * //false
 * console.log(_.isLowerCaseChar('A'))
 * //true
 * console.log(_.isLowerCaseChar('a'))
 * //false
 * console.log(_.isLowerCaseChar(null))
 *
 * @param v
 * @returns
 * @since 1.13.0
 */
declare function isLowerCaseChar(v: string): v is Lowercase<string>;

/**
 * 判断值是不是一个Map对象
 *
 * @example
 * //true
 * console.log(_.isMap(new Map()))
 * //false
 * console.log(_.isMap(new WeakMap()))
 *
 * @param v
 * @returns
 */
declare function isMap<K, V>(v: unknown): v is Map<K, V>;

/**
 * 检测props对象中的所有属性是否在object中存在，可用于对象的深度对比。
 * 使用<code>eq</code>作为值对比逻辑
 *
 * @example
 * let target = {a:{x:1,y:2},b:1}
 * //true
 * console.log(_.isMatch(target,{b:1}))
 * //true
 * console.log(_.isMatch(target,{a:{x:1}}))
 *
 * target = [{x:1,y:2},{b:1}]
 * //true
 * console.log(_.isMatch(target,{1:{b:1}}))
 * //true
 * console.log(_.isMatch(target,[{x:1}]))
 *
 * @param object
 * @param props 对比属性对象，如果是null，返回true
 * @returns 匹配所有props返回true
 * @since 0.17.0
 */
declare function isMatch<T extends Record<string | number | symbol, any>>(object: T, props: T): boolean;

/**
 * 检测props对象中的所有属性是否在object中存在并使用自定义比较器对属性值进行对比。可以用于对象的深度对比。
 * 当comparator参数是默认值时，与<code>isMath</code>函数相同
 *
 * @example
 * let target = {a:{x:1,y:2},b:1}
 * //true
 * console.log(_.isMatchWith(target,{b:1},_.eq))
 * //false
 * console.log(_.isMatchWith(target,{b:'1'},_.eq))
 *
 * target = {a:null,b:0}
 * //true
 * console.log(_.isMatchWith(target,{a:'',b:'0'},(a,b)=>_.isEmpty(a) && _.isEmpty(b)?true:a==b))
 *
 * @param target 如果不是对象类型，返回false
 * @param props 对比属性对象，如果是nil，返回true
 * @param comparator 比较器。参数(object[k],props[k],k,object,props)，返回true表示匹配
 * @returns 匹配所有props返回true
 * @since 0.18.1
 */
declare function isMatchWith<T extends Record<string | number | symbol, any>>(target: T, props: T, comparator: (v1: any, v2: any, k?: string, target?: T, props?: T) => boolean): boolean;

/**
 * 判断值是否NaN本身。与全局isNaN函数相比，只有NaN值本身才会返回true
 * <p>
 * isNaN(undefined) => true <br>
 * _.isNaN(undefined) => false
 * </p>
 *
 * @example
 * //true
 * console.log(_.isNaN(NaN))
 * //false
 * console.log(_.isNaN(null))
 * //false
 * console.log(_.isNaN(undefined))
 *
 * @param v
 * @returns
 */
declare function isNaN(v: unknown): boolean;

/**
 * 判断参数是否为本地函数
 *
 * @example
 * //true
 * console.log(_.isNative(Array))
 * //false
 * console.log(_.isNative(()=>{}))
 *
 * @param v
 * @returns
 */
declare function isNative(v: unknown): boolean;

/**
 * 判断值是否为null或undefined
 *
 * @example
 * //true
 * console.log(_.isNil(undefined))
 * //false
 * console.log(_.isNil(0))
 * //true
 * console.log(_.isNil(null))
 * //false
 * console.log(_.isNil(NaN))
 *
 * @param v
 * @returns
 * @since 1.0.0
 */
declare function isNil(v: unknown): v is null | undefined;

/**
 * 判断值是不是Node的实例
 *
 * @example
 * //true
 * console.log(_.isNode(document.body.attributes[0]))
 * //true
 * console.log(_.isNode(document))
 *
 * @param v
 * @returns
 * @since 1.5.0
 */
declare function isNode(v: unknown): v is globalThis.Node;

/**
 * 判断参数是否为null
 *
 * @example
 * //true
 * console.log(_.isNull(null))
 * //false
 * console.log(_.isNull(undefined))
 *
 * @param v
 * @returns
 */
declare function isNull(v: unknown): v is null;

/**
 * 判断参数是否为数字类型值
 *
 * @example
 * //true
 * console.log(_.isNumber(1))
 * //true
 * console.log(_.isNumber(Number.MAX_VALUE))
 * //false
 * console.log(_.isNumber('1'))
 *
 * @param v
 * @returns
 */
declare function isNumber(v: unknown): v is number;

/**
 * 判断参数是否为数字或数字字符串。不能判断BigInt
 *
 * @example
 * //true
 * console.log(_.isNumeric(1))
 * //true
 * console.log(_.isNumeric('-1.1'))
 * //false
 * console.log(_.isNumber('-1.1a'))
 *
 * @param v
 * @returns
 */
declare function isNumeric(v: unknown): v is number | string;

/**
 * 判断值是不是一个非基本类型外的值，如果true则认为值是一个对象
 * 同样，该方法还可以用来判断一个值是不是基本类型
 *
 * @example
 * //false
 * console.log(_.isObject(1))
 * //true
 * console.log(_.isObject(new String()))
 * //false
 * console.log(_.isObject(true))
 * //false
 * console.log(_.isObject(null))
 *
 * @param v value
 * @returns 是否对象。如果值是null返回false，即使typeof null === 'object'
 */
declare function isObject<T extends object>(v: unknown): v is T;

/**
 * 判断值是不是一个朴素对象，即通过Object创建的对象
 *
 * @example
 * //false
 * console.log(_.isPlainObject(1))
 * //false
 * console.log(_.isPlainObject(new String()))
 * //true
 * console.log(_.isPlainObject({}))
 * //false
 * console.log(_.isPlainObject(null))
 * //true
 * console.log(_.isPlainObject(new Object))
 * function Obj(){}
 * //false
 * console.log(_.isPlainObject(new Obj))
 *
 * @param v value
 * @returns 是否朴素对象
 * @since 0.19.0
 */
declare function isPlainObject(v: unknown): boolean;

/**
 * 判断参数是否为原始类型
 *
 * @example
 * //true
 * console.log(_.isPrimitive(1))
 * //true
 * console.log(_.isPrimitive(null)
 * //false
 * console.log(_.isPrimitive(new String()))
 * //true
 * console.log(_.isPrimitive(123n)
 *
 * @param v
 * @returns
 */
declare function isPrimitive(v: unknown): boolean;

/**
 * 判断值是不是一个正则对象
 *
 * @example
 * //true
 * console.log(_.isRegExp(new RegExp))
 * //true
 * console.log(_.isRegExp(/1/))
 *
 * @param v
 * @returns
 * @since 0.19.0
 */
declare function isRegExp(v: unknown): v is RegExp;

/**
 * 判断值是不是一个安全整数
 *
 * @example
 * //true
 * console.log(_.isSafeInteger(-0))
 * //true
 * console.log(_.isSafeInteger(5.0))
 * //false
 * console.log(_.isSafeInteger(5.000000000000001))
 * //true
 * console.log(_.isSafeInteger(5.0000000000000001))
 * //false
 * console.log(_.isSafeInteger('5'))
 * //true
 * console.log(_.isSafeInteger(Number.MAX_SAFE_INTEGER))
 * //false
 * console.log(_.isSafeInteger(Number.MAX_VALUE))
 *
 * @param v
 * @returns
 */
declare function isSafeInteger(v: unknown): v is number;

/**
 * 判断值是不是一个Set对象
 *
 * @example
 * //false
 * console.log(_.isSet(new WeakSet))
 * //true
 * console.log(_.isSet(new Set))
 *
 * @param v
 * @returns
 */
declare function isSet<T>(v: unknown): v is Set<T>;

/**
 * 判断参数是否为字符串，包括String类的实例以及基本类型string的值
 *
 * @example
 * //true
 * console.log(_.isString(new String('')))
 * //true
 * console.log(_.isString(''))
 *
 * @param v
 * @returns
 */
declare function isString(v: unknown): v is string;

/**
 * 判断值是不是Symbol
 *
 * @example
 * //true
 * console.log(_.isSymbol(Symbol()))
 *
 * @param v
 * @returns
 * @since 1.0.0
 */
declare function isSymbol(v: unknown): v is symbol;

/**
 * 判断参数是否为undefined
 * @example
 * //true
 * console.log(_.isUndefined(undefined))
 * //false
 * console.log(_.isUndefined(null))
 *
 * @param v
 * @returns
 */
declare function isUndefined(v: unknown): v is undefined;

/**
 * 判断参数是否为大写字母
 * @example
 * //true
 * console.log(_.isUpperCaseChar('A'))
 * //false
 * console.log(_.isUpperCaseChar(null))
 *
 * @param v
 * @returns
 * @since 1.13.0
 */
declare function isUpperCaseChar(v: string): v is Uppercase<string>;

/**
 * 判断值是不是一个WeakMap对象
 *
 * @example
 * //true
 * console.log(_.isWeakMap(new WeakMap))
 * //false
 * console.log(_.isWeakMap(new Map))
 *
 * @param v
 * @returns
 */
declare function isWeakMap<K extends object, V>(v: unknown): v is WeakMap<K, V>;

/**
 * 判断值是不是一个WeakSet对象
 *
 * @example
 * //true
 * console.log(_.isWeakSet(new WeakSet))
 * //false
 * console.log(_.isWeakSet(new Set))
 *
 * @param v
 * @returns
 */
declare function isWeakSet<T extends object>(v: unknown): v is WeakSet<T>;

export { isAlnum, isAlpha, isArray, isArrayLike, isBlank, isBoolean, isCustomElement, isDate, isDefined, isElement, isEmpty, isEqual, isEqualWith, isError, isFinite, isFunction, isInteger, isIterator, isLowerCaseChar, isMap, isMatch, isMatchWith, isNaN, isNative, isNil, isNode, isNull, isNumber, isNumeric, isObject, isPlainObject, isPrimitive, isRegExp, isSafeInteger, isSet, isString, isSymbol, isUndefined, isUpperCaseChar, isWeakMap, isWeakSet };