import type { TimerOptions } from 'node:timers';
import { type Mapper } from './prototype.common.ts';
export declare function delay(milliseconds: number, options?: TimerOptions): Promise<void>;
export declare function assert<T>(assertion: T, message?: string): T;
/** 做参数校验，逻辑检查 */
export declare function check<T>(condition: T, message?: string): T;
/** 生成随机 id (number) */
export declare function genid(): number;
/** 生成随机 uint32 */
export declare function genu32(): number;
/** 通过 console.log 打印对象并返回
    @example
    log('label', obj)
    log(obj) */
export declare function log<TObj>(obj: TObj): TObj;
export declare function log<TObj>(label: string, obj: TObj): TObj;
/** 生成 0, 1, ..., n - 1 (不包括 n) 的数组，支持传入 generator 函数，通过 index 生成各个元素
    @example seq(10, i => `item-${i}`) */
export declare function seq<T = number>(n: number, generator?: (index: number) => T): T[];
/** 数组或 iterable 去重（可按 mapper 选择或计算某个值来去重），重复值保留最后出现的那个
    - mapper?: 可以是 key (string, number, symbol) 或 (obj: any) => any */
export declare function unique<TObj>(iterable: TObj[] | Iterable<TObj>, mapper?: keyof TObj | Mapper<TObj>): TObj[];
/** 字符串字典序比较 */
export declare function strcmp(l: string, r: string): -1 | 0 | 1;
/** 排序对象中 keys 的顺序，返回新的对象 */
export declare function sort_keys<TObj>(obj: TObj): TObj;
/** 比较 1.10.02 这种版本号
    - l, r: 两个版本号字符串
    - loose?: `false` 宽松模式，允许两个版本号格式（位数）不一致 */
export declare function vercmp(l: string, r: string, loose?: boolean): number;
/** 将 keys, values 数组按对应的顺序组合成一个对象 */
export declare function zip_object<TValue>(keys: (string | number)[], values: TValue[]): Record<string, TValue>;
/** 映射数据对象 (或数组) 中的 keys, 返回新对象 (或数组)
    - obj: 数据对象, 数据对象数组
    - mapper?: `to_snake_case` (key: string) => string 或者 Record<string, string> 一对一映射键
    - overrider?: 添加一些键到返回的新对象上，只对顶层有效 */
export declare function map_keys<TReturn = any>(obj: any, mapper?: ((key: string) => string) | Record<string, string>, overrider?: (mapped: any) => Partial<TReturn>, recursive?: boolean): TReturn;
/** 返回一个映射对象 keys 的函数，通常和 .map 函数一起使用 */
export declare function get_key_mapper<TReturn>(mapper?: ((key: string) => string) | Record<string, string>, overrider?: (mapped: any) => Partial<TReturn>): (obj: any) => TReturn;
/** 映射对象中的 values, 返回新对象 */
export declare function map_values<TValue, TNewValue>(obj: {
    [key: string]: TValue;
}, mapper: (value: TValue, key: string) => TNewValue): {
    [k: string]: TNewValue;
};
/** 过滤对象中的 keys, 返回新对象 */
export declare function filter_keys<TObj>(obj: TObj, filter: (key: string) => any): TObj;
/** 过滤对象中的 values, 返回新对象
    - obj
    - filter?: `not_empty` */
export declare function filter_values<TObj extends Record<string, any>>(obj: TObj, filter?: (value: TObj[string]) => any): TObj;
/** 简单选择对象中的部分 keys, 返回新对象 */
export declare function pick<TObject = any>(obj: TObject, keys: (keyof TObject)[]): TObject;
/** 忽略对象中的 keys, 返回新对象 */
export declare function omit<TObj>(obj: TObj, omit_keys: string[] | Set<string>): TObj;
/** 拼接 TypedArrays 生成一个完整的 Uint8Array */
export declare function concat(arrays: ArrayBufferView[]): Uint8Array<ArrayBuffer>;
export declare let encoder: TextEncoder;
/** 将字符串简单的编码为 utf-8 的 buffer (Uint8Array)。高频使用或者在流式处理时，考虑使用 TextEncoder 的 encodeInto 方法 */
export declare function encode(str: string): Uint8Array<ArrayBuffer>;
export declare function encode_into(str: string, buf: Uint8Array): TextEncoderEncodeIntoResult;
/** 将 utf-8 buffer (Uint8Array) 简单的解码为 string。
    在流式处理 (buffer 可能不完整) 时，应使用独立的 TextDecoder 实例调用 decode(buffer, { stream: true }) */
export declare function decode(buffer: Uint8Array): string;
/** 比较两个 buffer 内容是否相同，第二个可以传入 string 自动编码转换后比较，
    高频调用时建议提前编码 right 并缓存 */
export declare function buffer_equals(left: Uint8Array, right: Uint8Array | string): boolean;
export type OnTimeout = string | ((error: TimeoutError) => void | Promise<void>);
/** 在指定的时间 (milliseconds) 内运行某个任务，超时之后抛出错误或调用 on_timeout
    - milliseconds: 限时毫秒数
    - action?: 要等待运行的任务, async function 或 promise
    - on_timeout?: 超时后调用的函数，或者设置错误消息
        - 若传:
            - 传 string: 作为 TimeoutError 的 error message
            - 传 function: 超时时调用会调用 on_timeout，参数为 TimeoutError，然后等待 on_timeout 执行完成
                - on_timeout 函数正常运行: timeout 函数返回 null
                - on_timeout 报错: timeout 函数最终抛出这个错误
        - 若不传: 直接抛出 TimeoutError
    - print?: `true` 打印已超时任务的错误 */
export declare function timeout<TReturn>(milliseconds: number, action: Promise<TReturn> | (() => Promise<TReturn>), on_timeout?: OnTimeout, print?: boolean): Deferred2<TReturn>;
/** 轮询尝试 action 共 times 次，每次间隔 duration
    action 返回 trusy 值时认为成功，返回 action 的结果
    如果次数用尽仍然失败，返回 null */
export declare function poll<TResult>(duration: number, times: number, action: (breaker: () => void) => Promise<TResult>): Promise<TResult>;
export declare const one_day: number;
/** 获取到下一次 hour:minute 时钟所需 delay 的毫秒数 */
export declare function get_delay_to_clock(hour: number, minute?: number): number;
/** 每天在固定时间执行操作
    - hour: 0 - 23 之间的整数，在这个点执行
    - action */
export declare function schedule_everyday(hour: number, minute: number, action: () => void | Promise<void>): Promise<void>;
/** 模糊过滤字符串列表或对象列表，常用于根据用户输入补全或搜索过滤
    如果有完全匹配关键词的，只返回完全匹配关键词的候选项
    - query: 查询字符串，要求为全小写
    - items: TItem[], 要过滤的列表
    - keywords: string[][] 每个 item 对应一个全小写字符串的关键词数组，用于实际筛选匹配 */
export declare function fuzzyfilter<TItem>(query: string, items: TItem[], keywords: string[][], single_char_startswith?: boolean): TItem[];
export declare function get<TReturn = any>(obj: any, keypath: string): TReturn;
export declare function global_get<TReturn = any>(keypath: string): TReturn;
export declare function invoke<TReturn = any>(obj: any, funcpath: string, args: any[]): TReturn;
/** 时间间隔 (milliseconds) 格式化 */
export declare function delta2str(delta: number): string;
/** 默认日期时间格式 */
export declare const datetime_format: 'YYYY.MM.DD HH:mm:ss';
/** 默认日期格式 */
export declare const date_format: 'YYYY.MM.DD';
/** 默认时间格式 */
export declare const time_format: 'HH:mm:ss';
export declare class Timer {
    started: number;
    ended: number;
    /** 停止秒表，保存读数 */
    stop(): void;
    /** 如果秒表未停止，获取当前秒表读数；
        如果秒表已停止，获取停止时的秒表读数; */
    get(): number;
    /** 获取时间表示字符串，如 1.2 s
        - parenthesis?: `true` 字符串前后加上括号，如 (1.2 s) */
    getstr(parenthesis?: boolean): string;
    print(): void;
    /** 重置 started */
    reset(): void;
    get_and_reset(): number;
    getstr_and_reset(parenthesis?: boolean): string;
}
export declare class TimeoutError extends Error {
    name: 'TimeoutError';
}
/** https://stackoverflow.com/questions/63297164/how-to-only-accept-arraybuffer-as-parameter */
export type StrictArrayBuffer = ArrayBuffer & {
    buffer?: undefined;
};
export interface Deferred<TValue> extends Promise<TValue> {
    resolve(value: TValue | PromiseLike<TValue>): void;
    reject(error?: Error): void;
}
/** 创建一个 promise，后续可调用 promise.resolve, promise.reject 方法设置其状态和值
    - initial?: `undefined` 传入非 undefined 值（包括 null）时直接设置为 resolved 状态
    注: 下面的方法不能标记为 aysnc function, 否则会对返回值再做一层 Promise.resolve() 导致 reject, resolve 属性丢失 */
export declare function defer<TValue>(initial?: TValue): Deferred<TValue>;
export interface Deferred2<TValue> extends Promise<TValue> {
    resolve(value: TValue | PromiseLike<TValue>): void;
    reject(error?: Error): void;
    get settled(): boolean;
}
/** 有 settled 状态的 defer */
export declare function defer2<TValue>(initial?: TValue): Deferred2<TValue>;
export interface LockedAction<TResource, TResult> {
    (resource: TResource): TResult | Promise<TResult>;
}
/** @example
    let lock = new Lock(redis)
    
    // 锁定资源后在 action 回调中操作资源，回调 promise 完成后自动释放资源，
    // 三秒内未成功独占资源直接抛出 TimeoutError (开始执行后不受 signal abort 影响)
    await lock.request(async redis => {
        const value = await redis.get('key')
        await redis.set('key', value * 2)
    }, AbortSignal.timeout(3000))
    
    参考:
    https://developer.mozilla.org/en-US/docs/Web/API/Web_Locks_API
    https://github.com/metarhia/web-locks
    https://www.npmjs.com/package/async-lock  */
export declare class Lock<TResource = void> {
    /** 如果操作不需要独占资源，可以直接通过 lock.resource 访问，否则需要通过 await lock.request() 独占资源后再访问 */
    resource: TResource;
    /** 等待链，新的 await lock.request() 调用会等待当前等待链尾部的 promise 完成，并作为新的尾部 */
    ptail: Deferred<void>;
    /** 查询当前资源是否属于被锁定的状态，方便在资源闲置时做一些可选操作（操作前仍需锁定），或者做一些状态展示 */
    locked: boolean;
    /** 可以不传 resource，表示管理某个抽象或虚拟的资源 */
    constructor(resource?: TResource);
    /** 通过 await lock.request() 锁定资源以便独占访问，锁定资源后在 action 回调中操作资源，回调 promise 完成 (fullfilled 或 rejected) 后自动释放资源 */
    request<TResult>(action: LockedAction<TResource, TResult>, signal?: AbortSignal): Promise<TResult>;
}
/** 过滤符合 pattern 的行 */
export declare function grep(str: string, pattern: string | RegExp): string;
export declare function lowercase_first_letter(str: string): string;
/** 大于 n 的最小的 2 的幂次 */
export declare function ceil2(n: number): number;
/** 节流，最多只在时间间隔末尾调用一次，可以设置首次调用是否延后
    - duration
    - func
    - delay_first?: `false` */
export declare function throttle(duration: number, func: Function, delay_first?: boolean): (this: any, ...args: any[]) => void;
/** 防抖，间隔一段时间不再触发时调用，同时大幅优化减少 setTimeout, clearTimeout 的调用次数 */
export declare function debounce(duration: number, func: Function): (this: any, ...args: any[]) => void;
export declare function tomorrow(date?: Date | string | number): Date;
export declare function to_csv_field(str: string): string;
/** 设置 error.message 同时更新 error.stack */
export declare function set_error_message(error: Error, message: string): Error;
/** 比较两个数组中的元素完全相同，数组元素用引用比较 */
export declare function array_equals(a: any[], b: any[]): boolean;
export declare function deep_equals(a: any, b: any): boolean;
/** - with_date?: `false` */
export declare function nowstr(with_date?: boolean): string;
export declare function has_chinese(str: string): boolean;
export declare function fold_spaces(str: string): string;
