/**
 * 删除对象中的某些键值对
 * @param obj - 源对象
 * @param fields - 需要删除的字段数组
 * @param ignoreEmpty - 是否忽略 undefined | null
 * @returns 返回新的对象
 * @example
 * ```ts
 * const obj = {
      a: 1,
      b: {
        c: 2,
        d: {
          e: 3,
        },
      },
      c: '',
      d: undefined,
    }
    const cloneObj = omit(obj, ['a'])
 * ```
 */
export declare function omit<T extends Record<string, any>, K extends keyof T>(obj: T, fields: K[] | string[], ignoreEmpty?: boolean): Omit<T, K>;
export type Writeable<T> = {
    -readonly [P in keyof T]: T[P];
};
/**
 * 从对象中取出指定的键值对
 * @param obj - 源对象
 * @param keys - 需要取出的键值对
 * @param ignoreEmpty - 是否忽略 undefined
 * @returns 返回新的对象
 * @example
 * ```ts
 *    const obj = {
      a: 1,
      b: {
        c: 2,
        d: {
          e: 3,
        },
      },
    }
    const cloneObj = pick(obj, ['b'])
 * ```
 */
export declare function pick<T, U extends keyof T>(obj: T, keys: ReadonlyArray<U> | string[], ignoreUndefined?: boolean): Writeable<Pick<T, U>>;
/**
 * 从对象中取出指定的键值对,第二个参数predicate（断言函数)
 * @param obj - 源对象
 * @param predicate - 断言函数,判断为真值的属性会被返回
 * @returns 返回新的对象
 * @example
 * ```ts
 *    const obj = {
      a: 1,
      b: {
        c: 2,
        d: {
          e: 3,
        },
      },
      c: '',
      d: undefined,
    }
    const cloneObj = pickBy(obj, (value) => !!value)
 * ```
 */
export declare function pickBy<T>(obj: T, predicate: (val: NonNullable<T>[keyof T], key: keyof T) => boolean): Partial<T>;
type OmitBy<T, F> = {
    [K in keyof T as F extends T[K] ? never : K]: T[K];
};
/**
 * 从对象中去除属性,通过第二个参数predicate（断言函数)
 * 与 {@link pickBy} 反向版
 * @param obj - 源对象
 * @param predicate - 断言函数,判断为真值的属性会被**去除**
 * @returns 返回新的对象
 * @example
 * ```ts
 * const obj = {
      a: 1,
      b: {
        c: 2,
        d: {
          e: 3,
        },
      },
      c: '',
      d: undefined,
    }
    const cloneObj = omitBy(obj, (value) => !value)
 * ```
 */
export declare function omitBy<T>(object: T, predicate: (value: T[keyof T], key: keyof T) => boolean): OmitBy<T, T[keyof T]>;
/**
 * 防抖函数
 * @param fn - 需要防抖的函数
 * @param delay - 防抖的时间
 * @example
 * ```ts
 * let handleSearch =()=>{}
 * const debounceSearch = debounce(handleSearch)
 * ```
 */
export declare const debounce: (fn: Function, delay?: number) => (this: unknown, ...args: any[]) => void;
/**
 * 节流函数
 * @param fn  - 需要节流的函数
 * @param limit - 节流的时间
 * @param exeLastFunc - 是否执行最后一次函数
 * @example
 * ```ts
 * let handleSearch =()=>{}
 * const throttleSearch = throttle(handleSearch)
 * ```
 */
export declare const throttle: <T extends (...args: any) => any>(fn: T, limit?: number, exeLastFunc?: boolean) => (this: unknown, ...args: Parameters<T>) => void;
/**
 * 生成当前浏览器唯一id
 * (自增+页面渲染时间+ random随机数)
 * 对于一般的唯一ID 生成来说是足够的
 * @param length -随机数长度 默认16
 * @example
 * ```ts
 * let uid11 = uniqueId(11) //11位
 * let uid16 = uniqueId() //16位
 * let uid19 = uniqueId(19) //19 位
 * let uid32 = uniqueId(32)
 * ```
 * @returns 唯一id
 */
export declare function uniqueId(length?: number): string;
/**
 * 将 Blob 对象转换为 base64 字符串
 * @param blob - Blob 对象
 * @param ignorePrefix - 是否忽略 dateUrl 前缀
 * @example
 * ```ts
 * let base64 = blobToBase64(blob)
 * let base64 = blobToBase64(blob,false)
 * ```
 */
export declare function blobToBase64(blob: Blob, ignorePrefix?: boolean): Promise<string>;
type DeepKeyOf<T> = T extends object ? {
    [K in keyof T]-?: K extends string ? K | `${K}.${DeepKeyOf<T[K]>}` : never;
}[keyof T] : never;
type DeepValueOf<T, K extends string> = K extends `${infer P}.${infer Rest}` ? P extends keyof T ? DeepValueOf<T[P], Rest> : '' : K extends keyof T ? T[K] : '';
/**
 * 从对象中获取指定路径的值
 * @param object -对象
 * @param path  - 指定路径
 * @example
 * ```ts
 * const obj = {
 *   a: { b: { c: 3 } }
 * }
 * const value = get(obj, 'a.b.c')
 * ```
 */
export declare function get<T, K extends DeepKeyOf<T>>(obj: T, path: K): DeepValueOf<T, K>;
/**
 * 对象转查询字符串
 * @param obj - 对象
 * @returns 查询字符串
 * @example
 * ```ts
 * const str = objToQString({ a: 1, b: 2 })
 * // 输出: 'a=1&b=2'
 * ```
 */
export declare function objToQString(obj: Record<string, any>): string;
/**
 * 查询字符串转对象
 * @param qString - 查询字符串
 * @returns 对象
 * @example
 * ```ts
 * const obj = qStringToObj('a=1&b=2')
 * // 输出: { a: 1, b: 2 }
 * ```
 */
export declare function qStringToObj(qString: string | null): Record<string, any>;
export {};