/**
 * 未知类型的mapKey
 */
type UnknownMapKey = string | number | symbol;
/**
 * 非函数迭代类型
 */
type NonFuncItee = string | Record<any, any> | Array<any>;

/**
 * 将一个或多个源对象的可枚举属性值分配到目标对象。如果源对象有多个，则按照从左到右的顺序依次对target赋值，相同属性会被覆盖
 *
 * > 该函数会修改目标对象
 *
 * <ul>
 *  <li>当目标对象是null/undefined时，返回空对象</li>
 *  <li>当目标对象是基本类型时，返回对应的包装对象</li>
 *  <li>当目标对象是不可扩展/冻结/封闭状态时，返回目标对象</li>
 * </ul>
 * @example
 * //{x:1,y:3}
 * console.log(_.assign({x:1},{y:3}))
 *
 * @param target 目标对象
 * @param sources 源对象
 * @returns 返回target
 */
declare function assign<T extends Record<UnknownMapKey, any>>(target: T, ...sources: any[]): T;

/**
 * 与<code>assign</code>相同，但支持自定义处理器
 *
 * > 该函数会修改目标对象
 *
 * @example
 * //{x: 1, y: '3y', z: null}
 * console.log(_.assignWith({x:1},{y:3,z:4},(sv,tv,k)=>k=='z'?null:sv+k))
 *
 * @param target 目标对象
 * @param sources 源对象，可变参数。最后一个参数为函数时，签名为(src[k],target[k],k,src,target) 自定义赋值处理器，返回赋予target[k]的值
 * @returns 返回target
 */
declare function assignWith<T extends Record<UnknownMapKey, any>>(target: T, ...sources: any[]): T;

declare function clone<T extends Record<string | number | symbol, any>>(obj: T): T;
declare function clone<T extends Record<string | number | symbol, any>, U>(obj: T): U;

declare function cloneDeep<T extends Record<string | number | symbol, any>>(obj: T): T;
declare function cloneDeep<T extends Record<string | number | symbol, any>, U>(obj: T): U;

declare function cloneDeepWith<T extends Record<string | number | symbol, any>>(obj: T, handler?: (v: any, k: UnknownMapKey, obj: T) => any, skip?: (v: any, k: string | number | symbol) => boolean): T;
declare function cloneDeepWith<T extends Record<string | number | symbol, any>, U>(obj: T, handler?: (v: any, k: UnknownMapKey, obj: T) => any, skip?: (v: any, k: string | number | symbol) => boolean): U;

declare function cloneWith<T extends Record<string | number | symbol, any>>(obj: T, handler: (v: any, k?: string | number | symbol) => any, skip?: (v: any, k: string | number | symbol) => boolean): T;
declare function cloneWith<T extends Record<string | number | symbol, any>, U>(obj: T, handler: (v: any, k?: string | number | symbol) => any, skip?: (v: any, k: string | number | symbol) => boolean): U;

/**
 * 将一个或多个源对象的可枚举属性值分配到目标对象中属性值为undefined的属性上。
 * 如果源对象有多个，则按照从左到右的顺序依次对target赋值，相同属性会被忽略
 *
 * > 该函数会修改目标对象
 *
 * - 当目标对象是null/undefined时，返回空对象
 * - 当目标对象是基本类型时，返回对应的包装对象
 * - 当目标对象是不可扩展/冻结/封闭状态时，返回目标对象
 *
 * @example
 * //{a: 1, b: 2, c: 3}
 * console.log(_.defaults({a:1},{b:2},{c:3,b:1,a:2}))
 *
 * @param target 目标对象
 * @param sources 1-n个源对象
 * @returns 返回target
 * @since 0.21.0
 */
declare function defaults<T extends Record<UnknownMapKey, any>>(target: T, ...sources: any[]): T;

/**
 * 与<code>defaults</code>相同，但会递归对象属性
 *
 * > 该函数会修改目标对象
 *
 * @example
 * //{a: {x: 1, y: 2, z: 3}, b: 2}
 * console.log(_.defaultsDeep({a:{x:1}},{b:2},{a:{x:3,y:2}},{a:{z:3,x:4}}))
 *
 * @param target 目标对象
 * @param sources 1-n个源对象
 * @returns 返回target
 * @since 0.21.0
 */
declare function defaultsDeep<T extends Record<UnknownMapKey, any>>(target: T, ...sources: any[]): T;

/**
 * 判断两个值是否相等。使用<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness#Same-value-zero_equality">SameValueZero</a>
 * 算法进行值比较。
 *
 * @example
 * //true
 * console.log(_.eq(NaN,NaN))
 * //false
 * console.log(_.eq(1,'1'))
 *
 * @param a
 * @param b
 * @returns
 * @since 1.0.0
 */
declare function eq(a: unknown, b: unknown): boolean;

/**
 * 对`object`内的所有属性进行断言并返回第一个匹配的属性key
 *
 * @example
 * const libs = {
 *  'func.js':{platform:['web','nodejs'],tags:{utils:true}},
 *  'juth2':{platform:['web','java'],tags:{utils:false,middleware:true}},
 *  'soya2d':{platform:['web'],tags:{utils:true}}
 * }
 *
 * //func.js 查询对象的key
 * console.log(_.findKey(libs,'tags.utils'))
 * //juth2
 * console.log(_.findKey(libs,{'tags.utils':false}))
 * //tags
 * console.log(_.findKey(libs['soya2d'],'utils'))
 * //2
 * console.log(_.findKey([{a:1,b:2},{c:2},{d:3}],'d'))
 *
 * @param object 所有集合对象array / arrayLike / map / object / ...
 * @param predicate (value[,index|key[,collection]]) 断言
 * <br>当断言是函数时回调参数见定义
 * <br>其他类型请参考 {@link utils!iteratee}
 * @returns 第一个匹配断言的元素的key或undefined
 */
declare function findKey<V>(object: any, predicate: ((value: V, index: UnknownMapKey, collection: any) => boolean) | NonFuncItee): string | number | symbol | undefined;

/**
 * <code>toPairs</code>反函数，创建一个由键值对数组组成的对象
 *
 * @example
 * //{a:1,b:2,c:3}
 * console.log(_.fromPairs([['a', 1], ['b', 2], ['c', 3]]))
 *
 * @param pairs 键值对数组
 * @returns 对象
 */
declare function fromPairs(pairs: any[][]): Record<UnknownMapKey, any>;

/**
 * 返回对象中的函数属性key数组
 * @example
 * const funcs = {
 *  a(){},
 *  b(){}
 * };
 * //[a,b]
 * console.log(_.functions(funcs))
 * //[....]
 * console.log(_.functions(_))
 *
 * @param obj
 * @returns 函数名数组
 * @since 0.18.0
 */
declare function functions(obj: Record<UnknownMapKey, any>): string[];

/**
 * 通过path获取对象属性值
 *
 * @example
 * //2
 * console.log(_.get([1,2,3],1))
 * //Holyhigh
 * console.log(_.get({a:{b:[{x:'Holyhigh'}]}},['a','b',0,'x']))
 * //Holyhigh2
 * console.log(_.get({a:{b:[{x:'Holyhigh2'}]}},'a.b.0.x'))
 * //Holyhigh
 * console.log(_.get({a:{b:[{x:'Holyhigh'}]}},'a.b[0].x'))
 * //hi
 * console.log(_.get([[null,[null,null,'hi']]],'[0][1][2]'))
 * //not find
 * console.log(_.get({},'a.b[0].x','not find'))
 *
 * @param obj 需要获取属性值的对象，如果obj不是对象(isObject返回false)，则返回defaultValue
 * @param path 属性路径，可以是索引数字，字符串key，或者多级属性数组
 * @param defaultValue 如果path未定义，返回默认值
 * @returns 属性值或默认值
 */
declare function get<V>(obj: any, path: Array<string | number> | string | number, defaultValue?: any): V;

/**
 * 检查指定key是否存在于指定的obj中（不含prototype中）
 *
 * @example
 * //true
 * console.log(_.has({a:12},'a'))
 *
 * @param obj
 * @param key
 * @returns 如果key存在返回true
 */
declare function has(obj: Record<UnknownMapKey, any>, key: UnknownMapKey): boolean;

declare function keys<K>(obj: Map<K, any>): K[];
declare function keys<K extends keyof any>(obj: Record<K, any> | object): K[];

declare function keysIn<K>(obj: Map<K, any>): K[];
declare function keysIn<K extends keyof any>(obj: Record<K, any> | object): K[];

/**
 * 类似<code>assign</code>，但会递归源对象的属性合并到目标对象。
 * <br>如果目标对象属性值存在，但对应源对象的属性值为undefined，跳过合并操作。
 * 支持自定义处理器，如果处理器返回值为undefined，启用默认合并。
 * 该函数在对可选配置项与默认配置项进行合并时非常有用
 *
 * > 该函数会修改目标对象
 *
 * - 当目标对象是null/undefined时，返回空对象
 * - 当目标对象是基本类型时，返回对应的包装对象
 * - 当目标对象是不可扩展/冻结/封闭状态时，返回目标对象
 *
 * @example
 * //{x: 0, y: {a: 1, b: 2, c: 3, d: 4}}
 * console.log(_.merge({x:1,y:{a:1,b:2}},{x:2,y:{c:5,d:4}},{x:0,y:{c:3}}))
 * //[{x: 0, y: {a: 1, b: 2, c: 3, d: 4}}]
 * console.log(_.merge([{x:1,y:{a:1,b:2}}],[{x:2,y:{c:5,d:4}}],[{x:0,y:{c:3}}]))
 *
 * @param target 目标对象
 * @param sources 1-n个源对象
 * @returns 返回target
 * @since 0.22.0
 */
declare function merge<T extends Record<UnknownMapKey, any>>(target: T, ...sources: any[]): T;

/**
 * 与<code>merge</code>相同，但支持自定义处理器
 *
 * > 该函数会修改目标对象
 *
 * @example
 * //{x: 2, y: {a: 2, b: 4, c: 3, d: 27}}
 * console.log(_.mergeWith({x:1,y:{a:1,b:2,c:3}},{x:2,y:{a:2,d:3}},{y:{b:4}},(sv,tv,k)=>k=='d'?sv*9:undefined))
 *
 * @param target 目标对象
 * @param sources (...src[,handler(src[k],target[k],k,src,target,chain)])
 * src - 1-n个源对象;
 * handler - 自定义赋值处理器，返回赋予target[k]的值。默认使用<code>noop</code>
 * @returns 返回target
 * @since 0.22.0
 */
declare function mergeWith<T extends Record<UnknownMapKey, any>>(target: T, ...sources: any[]): T;

/**
 * 创建一个剔除指定属性的对象子集并返回。与pick()刚好相反
 * @example
 * //{a: 1, c: '3'}
 * console.log(_.omit({a:1,b:2,c:'3'},'b'))
 * //{a: 1}
 * console.log(_.omit({a:1,b:2,c:'3'},'b','c'))
 * //{c: '3'}
 * console.log(_.omit({a:1,b:2,c:'3'},['b','a']))
 *
 * @param obj 选取对象
 * @param props 属性集合
 * @returns 对象子集
 * @since 0.16.0
 */
declare function omit(obj: Record<UnknownMapKey, any>, ...props: (string | string[])[]): Record<UnknownMapKey, any>;

/**
 * 同<code>omit</code>，但支持断言函数进行剔除
 * @example
 * //{c: '3'}
 * console.log(_.omitBy({a:1,b:2,c:'3'},_.isNumber))
 *
 * @param obj 选取对象
 * @param predicate (v,k)断言函数
 * @returns 对象子集
 * @since 0.23.0
 */
declare function omitBy<V, K extends UnknownMapKey>(obj: Record<UnknownMapKey, any>, predicate?: (v: V, k: K) => boolean): Record<UnknownMapKey, any>;

/**
 * 解析标准/非标准JSON字符串
 * 如果str非字符串类型，返回原值
 * 如果str是无效JSON字符串，返回原值
 *
 * @example
 * //{a:1,b:2,c:'3'}
 * console.log(_.parseJSON("{a:1,b:2,c:'3'}"))
 * //{a:1,b:2,c:'3"'}
 * console.log(_.parseJSON(`[{"a":1,"b":2,"c":"3\\""}]`))
 * //true
 * console.log(_.parseJSON('true'))
 * //12
 * console.log(_.parseJSON('12'))
 *
 *
 * @param str JSON字符串
 * @param ignore 如果为true，当值为 NaN/Infinity 时忽略该属性，否则返回值对应字符串。默认false
 * @returns 解析后的对象或空对象
 * @since 1.9.0
 */
declare function parseJSON<T extends Record<string, any>>(str: string, ignore?: boolean): T;

/**
 * 创建一个指定属性的对象子集并返回
 * @example
 * //{b: 2}
 * console.log(_.pick({a:1,b:2,c:'3'},'b'))
 * //{b: 2,c:'3'}
 * console.log(_.pick({a:1,b:2,c:'3'},'b','c'))
 * //{a: 1, b: 2}
 * console.log(_.pick({a:1,b:2,c:'3'},['b','a']))
 *
 * @param obj 选取对象
 * @param props 属性集合
 * @returns 对象子集
 * @since 0.16.0
 */
declare function pick<T extends Record<UnknownMapKey, any>>(obj: T, ...props: (string | string[])[]): T;

/**
 * 同<code>pick</code>，但支持断言函数进行选取
 * @example
 * //{a: 1, b: 2}
 * console.log(_.pickBy({a:1,b:2,c:'3'},_.isNumber))
 *
 * @param obj 选取对象
 * @param predicate (v,k)断言函数
 * @returns 对象子集
 * @since 0.23.0
 */
declare function pickBy<V, K extends UnknownMapKey>(obj: Record<UnknownMapKey, any>, predicate?: (v: V, k: K) => boolean): Record<UnknownMapKey, any>;

/**
 * 创建一个函数，该函数返回指定对象的path属性值
 * @example
 * const libs = [
 *  {name:'func.js',platform:['web','nodejs'],tags:{utils:true},js:false},
 *  {name:'juth2',platform:['web','java'],tags:{utils:false,middleware:true},js:true},
 *  {name:'soya2d',platform:['web'],tags:{utils:true},js:true}
 * ];
 * //[true,false,true]
 * console.log(_.map(libs,_.prop('tags.utils')))
 * //nodejs
 * console.log(_.prop(['platform',1])(libs[0]))
 *
 * @param path
 * @returns 接收一个对象作为参数的函数
 * @since 0.17.0
 */
declare function prop<V>(path: string | string[]): (obj: Record<UnknownMapKey, any>) => V;

/**
 * 通过path设置对象属性值。如果路径不存在则创建，索引会创建数组，属性会创建对象
 * <div class="alert alert-secondary">
      该函数会修改源对象
    </div>

    @example
 * //{"a":1,"b":{"c":[undefined,{"x":10}]}}
 * console.log(_.set({a:1},'b.c.1.x',10))
 *
 * @param obj 需要设置属性值的对象，如果obj不是对象(isObject返回false)，直接返回obj
 * @param path 属性路径，可以是索引数字，字符串key，或者多级属性数组
 * @param value 任何值
 * @returns obj 修改后的源对象
 * @since 0.16.0
 */
declare function set<T extends Record<UnknownMapKey, any>>(obj: T, path: Array<string | number> | string | number, value: any): T;

/**
 * 解析传递参数并返回一个根据参数值创建的Object实例。
 * 支持数组对、k/v对、对象、混合方式等创建
 * 是 toPairs 的反函数
 *
 * @example
 * //{a:1,b:2}
 * console.log(_.toObject('a',1,'b',2))
 * //如果参数没有成对匹配，最后一个属性值则为undefined
 * //{a:1,b:2,c:undefined}
 * console.log(_.toObject('a',1,'b',2,'c'))
 * //{a:1,b:4,c:3} 重复属性会覆盖
 * console.log(_.toObject(['a',1,'b',2],['c',3],['b',4]))
 * //{a:1,b:2} 对象类型返回clone
 * console.log(_.toObject({a:1,b:2}))
 * //{1:now time,a:{}} 混合方式
 * console.log(_.toObject([1,new Date],'a',{}))
 *
 * @param vals 对象创建参数，可以是一个数组/对象或者多个成对匹配的基本类型或者多个不定的数组/对象
 * @returns 如果没有参数返回空对象
 */
declare function toObject<V extends Record<UnknownMapKey, any>>(...vals: any[]): V;

/**
 * 返回指定对象的所有[key,value]组成的二维数组
 *
 * @example
 * //[['a', 1], ['b', 2], ['c', 3]]
 * console.log(_.toPairs({a:1,b:2,c:3}))
 *
 * @param obj
 * @returns 二维数组
 */
declare function toPairs(obj: Record<UnknownMapKey, any>): any[][];

/**
 * 删除obj上path路径对应属性
 * @param obj 需要设置属性值的对象，如果obj不是对象(isObject返回false)，直接返回obj
 * @param path 属性路径，可以是索引数字，字符串key，或者多级属性数组
 * @since 1.0.0
 * @returns 成功返回true，失败或路径不存在返回false
 */
declare function unset(obj: Record<UnknownMapKey, any>, path: Array<string | number> | string | number): boolean;

/**
 * 返回对象/Map的所有value数组
 * <div class="alert alert-secondary">
      只返回对象的自身可枚举属性
    </div>
 *
 *
 * @example
 * let f = new Function("this.a=1;this.b=2;");
 * f.prototype.c = 3;
 * //[1,2]
 * console.log(_.values(new f()))
 *
 * @param obj
 * @returns 值列表
 */
declare function values<V>(obj: Map<any, V> | Record<string | number | symbol, V> | object): V[];

/**
 * 返回对象/Map的所有value数组
 * 包括原型链中的属性
 *
 * @example
 * let f = new Function("this.a=1;this.b=2;");
 * f.prototype.c = 3;
 * //[1,2,3]
 * console.log(_.valuesIn(new f()))
 *
 * @param obj
 * @returns 值列表
 */
declare function valuesIn<V>(obj: Map<any, V> | Record<string | number | symbol, V> | object): V[];

export { assign, assignWith, clone, cloneDeep, cloneDeepWith, cloneWith, defaults, defaultsDeep, eq, findKey, fromPairs, functions, get, has, keys, keysIn, merge, mergeWith, omit, omitBy, parseJSON, pick, pickBy, prop, set, toObject, toPairs, unset, values, valuesIn };