import { default as default_2 } from 'intl-messageformat';
import type * as z from 'zod';

/**
 * 调整弹出元素 popRef 的位置
 *
 * @param popRef - 弹出对象，必须得是可见状态且有一个明确的 display 属性，必须得是一个具有 popover 属性的元素；
 * @param anchor - 锚定对象的范围；
 * @param padding - popRef 与 anchor 两者之间的间隙；
 * @param pos - 相对于 anchor 的弹出位置；
 * @param align - popRef 与 anchor 两者之间的对齐方式；
 *
 * @remarks 该操作会在 popRef 显示期间调整其父元素的 position 属性。
 */
export declare function adjustPopoverPosition(popRef: HTMLElement, anchor: DOMRect, padding?: number, pos?: PopoverPosition, align?: PopoverAlign): void;

/**
 * 封装了访问后端接口的基本功能
 */
export declare class API implements REST {
    #private;
    /**
     * 构建一个 API 的对象
     *
     * @param id - 保存令牌时的名称，在多实例中，通完此值判定不同的令牌；
     * @param s - 保存令牌的对象；
     * @param baseURL - API 的基地址，不能以 / 结尾；
     * @param contentType - 请求内容的类型；
     * @param accept - mimetype 返回内容的类型；
     * @param tokenPath - 相对于 baseURL 的登录地址，该地址应该包含 DELETE 和 PUT 两个请求，分别代表退出和刷新令牌；
     * @param locale - 请求报头 accept-language 的内容；
     * @param init - 默认的 {@link ReqInit} 对象，所有请求都会传递该对象内容，除非被请求的参数覆盖；
     */
    static build(id: string, s: Storage, baseURL: string, tokenPath: string, contentType: Mimetype, accept: Mimetype, locale: string, init?: Omit<ReqInit, 'signal'>): Promise<API>;
    private constructor();
    /**
     * 基于当前实现和参数 init 创建一个新的 {@link REST} 实例
     *
     * @param init - 请求的额外参数；
     */
    rest(init?: Omit<ReqInit, 'signal'>): REST;
    /**
     * 当前对象访问 API 是的基地址
     */
    get baseURL(): string;
    /**
     * 切换语言
     */
    setLocale(v: string): void;
    /**
     * 缓存 path 指向的 GET 接口数据
     *
     * @remarks
     * 以下操作会删除缓存内容：
     *  - 访问了该接口的非 GET 请求；
     *  - 调用 {@link uncache} 方法；
     *  - 调用 {@link clearCache} 方法；
     *  - 调用参数 deps 中的非 GET 请求；
     *  - token 发生变化；
     *
     * @param path - 相对于 {@link baseURL} 的接口地址；
     * @param deps - 缓存的依赖接口，这些依赖项的非 GET 接口一旦被调用，将更新当前的缓存项。
     *  支持在尾部以 * 作为通配符，用以匹配任意字符。
     *
     * NOTE: 查询的数据应该是不带分页的，否则可能会造成数据混乱。
     * NOTE: 相同的 path 多次调用，后续的调用将被忽略。
     */
    cache(path: string, ...deps: Array<string>): void;
    /**
     * 清除指定的缓存项
     *
     * @param path - 相对于 {@link baseURL} 的接口地址；
     */
    uncache(path: string): Promise<void>;
    /**
     * 清除所有的缓存项
     */
    clearCache(): Promise<void>;
    /**
     * 将 path 包装为一个完整的 API 访问地址
     *
     * @param path - 相对于 {@link baseURL} 的地址；
     */
    buildURL(path: string): string;
    api(): API;
    delete<R = never, PE = never>(path: string, token?: boolean, init?: ReqInit): Promise<Return<R, PE>>;
    post<R = never, PE = never>(path: string, body?: unknown, token?: boolean, init?: ReqInit): Promise<Return<R, PE>>;
    put<R = never, PE = never>(path: string, body?: unknown, token?: boolean, init?: ReqInit): Promise<Return<R, PE>>;
    patch<R = never, PE = never>(path: string, body?: unknown, token?: boolean, init?: ReqInit): Promise<Return<R, PE>>;
    get<R = never, PE = never>(path: string, token?: boolean, init?: ReqInit): Promise<Return<R, PE>>;
    request<R = never, PE = never>(path: string, method: Method, obj?: unknown, token?: boolean, init?: ReqInit): Promise<Return<R, PE>>;
    upload<R = never, PE = never>(path: string, obj: FormData, method?: 'POST' | 'PATCH' | 'PUT', token?: boolean, init?: ReqInit): Promise<Return<R, PE>>;
    /**
     * 设置登录状态
     *
     * @param ret - 表示执行登录操作之后返回的对象；
     * @returns 如果返回 true，表示操作成功，否则表示错误信息；
     */
    login(ret: Return<Token>): Promise<Problem | undefined | true>;
    /**
     * 退出当前的登录状态并断开需要登录的 SSE 连接
     */
    logout(): Promise<void>;
    /**
     * 当前是否是有效的登录状态
     *
     * @remarks
     * 此方法与 {@link API#getToken} 的不同在于当前方法不会主动刷新 token。
     * 所以是无法判断诸如服务端重启等非当前实例主动发起退出导致的状态。
     */
    isLogin(): boolean;
    /**
     * 获得令牌，如果令牌已经过期，会尝试刷新令牌，令牌不存在，则返回 undefined。
     */
    getToken(): Promise<string | undefined>;
    parse<R>(resp: Response): Promise<R | undefined>;
    /**
     * 获取用于订阅 SSE 的对象
     *
     * @param path - SSE 服务的地址；
     * @param needLogin - 是否需要登录状态才能访问；
     * 如果该值为 true，那么需要 path 参数提供的地址应该包含一 POST 请求，用于获取一个临时的访问令牌；
     */
    eventSource(path: string, needLogin?: boolean): Promise<Pick<EventSource, 'addEventListener' | 'removeEventListener'> | undefined>;
    /**
     * 关闭当前实例建立起来的所有 SSE 服务
     */
    closeEventSource(): Promise<void>;
}

/**
 * 表示与后端交互过程中的错误信息
 */
export declare class APIError extends Error {
    #private;
    /**
     * 将 {@link Problem} 转换为 {@link APIError} 对象
     */
    static fromProblem<E>(p: Problem<E>): APIError;
    /**
     * 构造函数
     *
     * @param status - 状态码；
     * @param title - 简要的错误说明；
     * @param headers - HTTP 响应头；
     * @param message - 详细的错误说明；
     */
    constructor(status: number, title?: string, headers?: Headers, message?: string);
    /**
     * 表示 HTTP 状态码
     */
    get status(): number;
    /**
     * 表示简要的错误说明
     */
    get title(): string | undefined;
    /**
     * 报头
     */
    get headers(): Headers | undefined;
}

/**
 * 获取数组元素的类型
 */
export declare type ArrayElement<T> = T extends readonly (infer U)[] ? U : never;

/**
 * 计算弹出对象的位置
 *
 * @param popRef - 弹出对象，必须得是可见状态的；
 * @param anchor - 锚定对象的范围；
 * @param pos - popRef 相对 anchor 的位置；
 * @param align - popRef 相对 anchor 的对齐方式；
 * @param padding - popRef 与 anchor 两者之间的间隙；
 * @param rtl - 是否是右到左的布局；
 *
 * @remarks
 * 不考虑越界问题，只考虑位置和对齐方式。
 */
export declare function calcPopoverPosition(popRef: HTMLElement, anchor: DOMRect, pos: PopoverPosition, align: PopoverAlign, padding?: number, rtl?: boolean): Point;

export declare type CancelMovable = () => void;

/**
 * 渲染单元格的方法
 *
 * @typeParam T - 导出数据中每行数据的类型；
 * @param id - 同 {@link Column#id}；
 * @param val - 如果该 id 存在于 T 中，那返回其在 T 中当前行的值，如果不存在则是 undefined；
 * @param obj - 表示是当前行的对象，其类型为 T；
 */
declare type CellRenderFunc<T extends object> = <K extends keyof T>(id: string | K, val?: K extends keyof T ? T[K] : unknown, obj?: T) => CellType;

/**
 * 导出数据每个单元格允许的类型
 */
export declare type CellType = string | number | boolean | Date | null | undefined;

/**
 * 定义导出列的相关信息
 *
 * @typeParam T - 导出数据中每行数据的类型
 */
export declare interface Column<T extends object> {
    /**
     * 导出列在对象 T 中的字段名，如果是自定义列，也可以是不存在于 T 中。
     */
    id: string | keyof T;
    /**
     * 导出列的标题，如果为空将直接采用 id
     */
    label?: string;
    /**
     * 如果导出列的内容需要进行转换可以使用此方法进行转换
     */
    content?: CellRenderFunc<T>;
    /**
     * 该列不需要导出
     */
    isUnexported?: boolean;
}

/**
 * 提供了可按用户分别保存配置的方法
 */
export declare class Config {
    #private;
    /**
     * 构造函数
     *
     * @param prefix - 配置项的命名前缀，用于区分不同模块的配置；
     * @param uid - 表示此配置对象的唯一 ID，一般为用户的 ID；
     * @param s - 存储位置，默认为 {@link window#localStorage}；
     */
    constructor(prefix: string, uid: string, s?: Storage);
    get prefix(): string;
    get storage(): Storage;
    /**
     * 获取当前配置项的 ID
     */
    get current(): string;
    /**
     * 切换用户
     *
     * @param uid - 新用户的 ID
     */
    switch(uid: string): void;
    /**
     * 获取配置项
     */
    get<T>(id: string): T | undefined;
    /**
     * 设置配置项
     */
    set<T>(id: string, obj: T): void;
    /**
     * 删除配置项
     */
    remove(id: string): void;
    /**
     * 清空当前用户的所有配置项
     */
    clear(): void;
}

/**
 * 创建一个可暂停的计时器
 *
 * @param startTime - 计时器的初始时间，单位为 ms；
 * @param step - 步长，也是计时器可暂停的最短时间，单位为 ms。
 * 该绝对值应该小于 startTime，否则为抛出异常，
 * 正数表示增长。负数表示减少，如果为负数，在计时器跑到 0 时会停止计时；
 * @param tick - 每一个 step 时间调用的方法，函数签名为 `{(value: number): void}`，value 表示剩余的时间；
 */
export declare function createTimer(startTime: number, step: number, tick?: (value: number) => void): {
    /**
     * 切换 {@link clear} 和 {@link start}
     */
    toggle(): void;
    /**
     * 停止并销毁计时器
     */
    stop(): void;
    /**
     * 暂停计时器，之后可用 {@link start} 继续
     */
    pause(): void;
    /**
     * 开始计时
     */
    start(): void;
    /**
     * 获取剩余时间
     */
    value(): number;
};

/**
 * 创建一个用于加载 zod 本地化语言的函数
 *
 * @param f - 加载 zod 本地化语言内容，比如 `(await import('../../node_modules/zod/v4/locales/en.js')).default`；
 * @returns 返回的是一个 {@link DictLoader} 函数，可在 {@link Locale.addDict} 中使用；
 */
export declare function createZodLocaleLoader(f: () => z.core.$ZodConfig): DictLoader;

export declare const day: number;

/**
 * 翻译对象
 */
export declare type Dict = Flattenable<string>;

/**
 * 翻译对象所有字段的联合类型
 */
export declare type DictKeys<T extends Dict> = FlattenKeys<T>;

/**
 * 加载翻译对象的方法
 *
 * @param locale - 当前语言环境；
 * @returns 翻译对象
 * 对于一些第三方库，可能并不需要返回其对象，而直接执行其对应的加载操作，
 * 那么可以返回一个 undefined。
 */
export declare type DictLoader = (locale: string) => Promise<Dict | undefined>;

/**
 * 一些与本地化相关的单位名称的显示方式
 *
 *  - full 显示完整的名称；
 *  - short 显示简短的名称；
 *  - narrow 以最简单的方式显示；
 *
 * 主要是针对 {@link Intl} 的一些预设，如果需要精细的控制，可自己实现。
 */
export declare type DisplayStyle = (typeof displayStyles)[number];

export declare const displayStyles: readonly ["full", "short", "narrow"];

/**
 * 表示时间段
 *
 * @remarks 可以是以下类型：
 * - number 表示的是纳秒；
 * - string Go 语言中表示时间段的字符串；
 */
export declare type Duration = number | string;

/**
 * 获取指定日期所在周的结束日期
 */
export declare function endOfISOWeek(date: Date): Date;

/**
 * 展开类型
 *
 * 支持以下几种方式：
 *
 * 1. 联合类型：
 * ```ts
 * type A = { a: string };
 * type B = { b: number };
 * type AB = A & B; // TypeScript 类型提示：A & B（不会显示实际结构）
 * type ExpandedAB = Expand<A & B>; // TypeScript 类型提示：{ a: string; b: number }
 * ```
 *
 * 2. extends
 * ```ts
 * interface C extends A {
 *     c: number;
 * }
 * type ExpandedC = Expand<C>; // TypeScript 类型提示：{ a: string; c: number }
 * ```
 *
 * 3. 引用
 * ```ts
 * interface D {
 *     d: number;
 *     a: A;
 * }
 * type ExpandedD = Expand<D>; // TypeScript 类型提示：{ d: number; a: { a: string } }
 * ```
 *
 * BUG: 无法处理泛型的展开，比如 `function<T extends A = A>` 中，对于 T 虽然指定了约束条件 A，
 * 但是还是无法作为 T 的一部分提前展开，以供函数中使用。
 *
 * NOTE: 该行为可能让编译时长变长，甚至可能因内在不足导致编译失败。
 */
export declare type ExpandType<T> = T extends object ? (T extends CallableFunction ? T : {
    [K in keyof T]: ExpandType<T[K]>;
}) : T;

/**
 * 提供从 API 分页接口导出数据的方法
 *
 * @typeParam T - 每一行数据的类型；
 * @typeParam Q - 查询参数的类型；
 */
export declare class Exporter<T extends object, Q extends Query> {
    #private;
    /**
     * 支持可导出的文件扩展名
     */
    static exts: string[];
    /**
     * 构造函数
     *
     * @param cols - 对列的定义
     */
    constructor(cols: Array<Column<T>>);
    /**
     * 从服务器获取全部数据到当前浏览器
     */
    fetch(load: FetchFunc<T, Q>, q: Q): Promise<void>;
    /**
     * 导出数据
     *
     * 将 {@link Exporter#fetch} 下载的数据导出给用户。
     *
     * @param filename - 文件名，如果是 excel，也作为工作表的名称；
     * @param lang - 语言；
     * @param ext - 后缀名，根据此值生成不同类型的文件；
     * @param appName - 部分格式的元数据中会标注的应用名称；
     * @param appVersion - 部分格式的元数据中会标注的应用版本；
     *
     * NOTE: 这将通过浏览器创建一个自动下载的功能。
     */
    export(filename: string, ext: (typeof Exporter.exts)[number], lang?: string, appName?: string, appVersion?: string): void;
}

/**
 * 从服务器获取数据的函数签名
 *
 * @typeParam T - 返回的行数据类型；
 * @typeParam Q - 查询参数的类型；
 */
declare type FetchFunc<T extends object, Q extends Query> = (q: Q) => Promise<Page<T> | Array<T> | undefined>;

/**
 * 将对象转换为扁平的格式
 *
 * @remarks
 * 作为 {@link flatten} 的返回值，具体说明也可参考 {@link flatten} 函数。
 *
 * @typeParam T - 对象类型；
 * @typeParam F - 对象字段的类型；
 */
export declare type Flatten<T extends Flattenable<F>, F = unknown> = FlattenT<T, F>;

/**
 * 将对象 dict 转换为一个扁平的对象
 *
 * @typeParam F - 如果对象类型单一，可以在此指定，比如翻译对象，其字段可能永远都是字符串；
 * @typeParam T - 需要被转换的对象类型。可以接受以下几种类型：
 *  - `type xx = {...}`
 *  - `interface zz ={[k: string]: unknown, ...}`
 *  - `interface yy ={...}`，如果该类型不符合 T 的类型需求，可以用 {@link Expand} 包装一下 `Example<yy>` 即可。
 *
 * 该操作，会将所有嵌套的字段转换为以 . 拼接的字符串字段名称，比如：
 * ```ts
 * interface Dict {
 *     f1: '1';
 *     f2: {
 *         f3: '3';
 *     }
 * }
 * ```
 * 将被转换为：
 * ```ts
 * interface Dict {
 *     f1: '1';
 *     'f2.f3': '3';
 * }
 * ```
 *
 * NOTE: 不支持数组形式的字段。
 */
export declare function flatten<T extends Flattenable<F>, F = unknown>(obj: T): Flatten<T, F>;

/**
 * 可转换为扁平对象的类型
 *
 * @typeParam T - 对象字段的类型；
 */
export declare type Flattenable<T = unknown> = {
    [k: string]: T | Flattenable<T>;
};

/**
 * 扁平化之后的所有字段名联合类型
 *
 * @typeParam T - 对象类型；
 * @typeParam FT - T 对象的字段类型；
 *
 * NOTE: 该类型不等价于 keyof Flatten，只包含字符串类型的字段名。
 */
export declare type FlattenKeys<T extends Flattenable<FT>, FT = unknown> = keyof Flatten<T, FT> & string;

declare type FlattenT<T extends Flattenable<F>, F = unknown, P extends string | null = null, TT = RemoveIndexSignature<Requiredify<T>>> = UnionToIntersection<{
    [K in keyof TT]: TT[K] extends Flattenable<F> ? FlattenT<TT[K], F, JoinPath<P, K>> : never;
}[keyof TT]> & {
    readonly [K in keyof TT as TT[K] extends Flattenable<F> ? never : JoinPath<P, K>]: Exclude<TT[K], Flattenable<F>>;
};

/**
 * 格式化 {@link Duration} 对象
 */
export declare function formatDuration(formatter: Intl.DurationFormat, duration: Duration): string;

/**
 * 将 {@link Duration} 转换为相对时间的字符串
 */
export declare function formatDuration2RelativeTime(formatter: Intl.RelativeTimeFormat, duration: Duration): string;

/**
 * 符合 ISO 8601 的周数计算
 */
export declare function getISOWeek(date: Date): [year: number, week: number];

/**
 * 获取指定日期所在周的范围
 */
export declare function getISOWeekRange(date: Date): [Date, Date];

/**
 * 根据周数找到对应的周的起止日期
 */
export declare function getISOWeekRangeByWeek(year: number, week: number): ReturnType<typeof getISOWeekRange>;

/**
 * 向上查找可滚动的容器
 *
 * @param direction - 检测滚动条的方向；
 * @param el - 从 el 开始向上查找；
 */
export declare function getScrollableParent(direction?: 'x' | 'y' | 'any', el?: HTMLElement | null): HTMLElement | undefined;

/**
 * 定义快捷键
 */
export declare class Hotkey {
    #private;
    /**
     * 初始化环境
     */
    static init(): void;
    /**
     * 注销环境
     */
    static destroy(): void;
    /**
     * 是否存在指定的快捷键
     */
    static hasKeys(key: string, ...modifiers: ModifierKeys): boolean;
    /**
     * 是否存在指定的快捷键
     */
    static has(hotkey: Hotkey): boolean;
    /**
     * 绑定快捷键
     *
     * @param handler - 处理函数；
     * @param key - 快捷键；
     * @param modifiers - 修饰符；
     */
    static bindKeys(handler: HotkeyHandler, key: string, ...modifiers: ModifierKeys): void;
    /**
     * 绑定快捷键
     *
     * @param hotkey - 快捷键；
     * @param handler - 快捷键处理函数；
     */
    static bind(hotkey: Hotkey, handler: HotkeyHandler): void;
    /**
     * 解绑快捷键
     *
     * @param hotkey - 快捷键；
     */
    static unbind(hotkey: Hotkey): void;
    /********************* 以下为实例方法 ***********************/
    readonly key: string;
    readonly modifiers: number;
    constructor(key: string, ...modifiers: ModifierKeys);
    /**
     * 判断 e 是否与当前实例相等
     */
    equal(e: Hotkey): boolean;
    /**
     * 判断事件 e 的按键是否与当前匹配
     */
    match(e: KeyboardEvent): boolean;
    /**
     * 获取当前快捷键的按键字符串
     */
    keys(): string[];
    /**
     * 将快捷键转换为一个可读的字符串
     *
     * @param os - 是否输出与当前系统相符的快捷键符号；
     */
    toString(os?: boolean): string;
}

export declare type HotkeyHandler = (e: KeyboardEvent) => void;

export declare const hour: number;

/**
 * 提供本地化相关的功能
 */
export declare class I18n implements Locale {
    #private;
    /**
     * 初始化
     *
     * @param fallback - 在找不到对应在的语言时采用的默认值；
     */
    static init(fallback: string): void;
    static get fallback(): string;
    /**
     * 创建一个用于缓存本地化对象的接口
     *
     * @remarks
     * 对于一些引入的第三方库，其本身可能提供了本地化的相关数据，但是又没有能力同时加载多个语言环境，比如 zod。
     * 当前方法返回的对象可以保存这些数据，以便在需要时直接使用，而无需再次加载。
     * @typeParam T - 缓存对象的类型；
     */
    static createObject<T>(): {
        /**
         * 获取指定语言的缓存对象
         *
         * @param locale - 语言标识符，如 'en-US' 或 'zh-CN'；
         * @param init - 当缓存中不存在指定语言的缓存对象时，调用该函数以初始化该对象；
         */
        get: {
            (locale: string): T | undefined;
            (locale: string, init: () => T): T;
        };
        /**
         * 设置指定语言的缓存对象
         *
         * @param locale - 语言标识符，如 'en-US' 或 'zh-CN'；
         * @param o - 缓存对象；
         */
        set(locale: string, o: T): void;
        /**
         * 返回所有的语言 ID
         */
        locales(): Array<string>;
        /**
         * 销毁指定语言的缓存对象
         *
         * @param locale - 语言标识符，如 'en-US' 或 'zh-CN'，如果未指定表示销毁所有；
         */
        destroy(locale?: string): void;
    };
    /**
     * 支持的语言数量
     */
    static languageSize(): number;
    /**
     * 支持语言列表
     */
    static languages(): Array<string>;
    /**
     * 以 locale 的指定的语言翻译 key 指向的内容
     *
     * @typeParam D - 翻译字典的对象，若指定了该对象，则会采用该对象的字段名作为 key 参数的类型。
     */
    static translate<D extends Dict>(locale: string, key: string | DictKeys<D>, args?: TranslateArgs): string;
    /**
     * 在当前支持的语言中找出与 l 最匹配的语言
     */
    static matchLanguage(l: string): string;
    /**
     * 添加支持的语言及他它的翻译对象的加载方法
     */
    static addDict(locale: string, ...loaders: Array<DictLoader>): Promise<void>;
    /**
     * 删除对某个语言的支持
     */
    static delDict(locale: string): void;
    /**
     * 构造函数
     * @param locale - 本地化字符串；
     * @param style - 显示风格；
     * @param tz - 时区，如果为空则采用 `Intl.DateTimeFormat().resolvedOptions().timeZone`；
     */
    constructor(locale: string, style: DisplayStyle, tz?: string);
    get locale(): Intl.Locale;
    get displayStyle(): DisplayStyle;
    get timezone(): string;
    datetimeFormat(o?: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
    dateFormat(o?: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
    timeFormat(o?: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
    numberFormat(o?: Intl.NumberFormatOptions): Intl.NumberFormat;
    durationFormat(o?: Intl.DurationFormatOptions): Intl.DurationFormat;
    relativeTimeFormat(o?: Intl.RelativeTimeFormatOptions): Intl.RelativeTimeFormat;
    match(locales: Array<string>, preset: string): string;
    get locales(): [string, string][];
    t<D extends Dict>(key: string | DictKeys<D>, args?: TranslateArgs): string;
    tt<D extends Dict>(locale: string, key: string | DictKeys<D>, args?: TranslateArgs): string;
}

/**
 * 判断参数 val 的类型是否为 {@link CellType}
 */
export declare function isCellType(val: unknown): val is CellType;

declare type JoinPath<P, B> = P extends string ? (B extends string ? `${P}.${B}` : P) : B extends string ? B : '';

/**
 * 提供本地化的接口
 *
 * @remarks
 * 除了翻译之外，对于一些常用的格式比如日期等也提供了支持。
 */
export declare interface Locale {
    get locale(): Intl.Locale;
    get displayStyle(): DisplayStyle;
    get timezone(): string;
    /**
     * 创建 {@link Intl#DateTimeFormat} 对象
     *
     * NOTE: 如果 o.timeStyle 和 o.dateStyle 都未指定，则使用构造函数指定的 style 参数。
     * 如果 o.timeZone 未指定，则使用构造函数指定的 timeZone 参数。
     */
    datetimeFormat(o?: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
    /**
     * 创建 {@link Intl#DateTimeFormat} 对象，只打印日期部分。
     */
    dateFormat(o?: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
    /**
     * 创建 {@link Intl#DateTimeFormat} 对象，只打印时间部分。
     */
    timeFormat(o?: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
    /**
     * 创建 {@link Intl#NumberFormat} 对象
     *
     * NOTE: 如果 o.unitDisplay 未指定，则使用构造函数指定的 style 参数。
     */
    numberFormat(o?: Intl.NumberFormatOptions): Intl.NumberFormat;
    /**
     * 创建 {@link Intl#DurationFormat} 对象
     *
     * NOTE: 如果 o.style 未指定，则使用构造函数指定的 style 参数。
     */
    durationFormat(o?: Intl.DurationFormatOptions): Intl.DurationFormat;
    /**
     * 创建 {@link Intl#RelativeTimeFormat} 对象
     *
     * NOTE: 如果 o.style 未指定，则使用构造函数指定的 style 参数。
     */
    relativeTimeFormat(o?: Intl.RelativeTimeFormatOptions): Intl.RelativeTimeFormat;
    /**
     * 查找 locales 中与当前的语言最配的一个 ID，若是实在无法匹配，则返回 preset。
     */
    match(locales: Array<string>, preset: string): string;
    /**
     * 返回支持的本地化列表
     *
     * @returns 返回语言 id 与语言名称的列表；
     */
    get locales(): Array<[id: string, displayName: string]>;
    /**
     * 翻译 key 指向的内容
     *
     * @typeParam D - 翻译字典的对象，若指定了该对象，则会采用该对象的字段名作为 key 参数的类型。
     */
    t<D extends Dict>(key: string | DictKeys<D>, args?: TranslateArgs): string;
    /**
     * 以 locale 的指定的语言翻译 key 指向的内容
     *
     * @typeParam D - 翻译字典的对象，若指定了该对象，则会采用该对象的字段名作为 key 参数的类型。
     */
    tt<D extends Dict>(locale: string, key: string | DictKeys<D>, args?: TranslateArgs): string;
}

/**
 * 从 available 中查找最符合 requested 的语言 ID
 *
 * @param requested - 匹配的值；
 * @param available - 被匹配的列表；
 * @param preset - 默认值，未找到时采用此值返回；
 * @param options - 可用的选项，只有一个字段 localeMatcher，该字段有以下两种取值：
 *  - lookup；
 *  - best fit；
 * 默认值为 lookup。
 */
export declare function matchLocales(requested: string, available: Readonly<Array<string>>, preset: string, options?: Options): string;

export declare type Method = (typeof methods)[number];

export declare const methods: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];

export declare type Mimetype = (typeof mimetypes)[number];

/**
 * 当前 API 支持的 mime type
 */
export declare const mimetypes: readonly ["application/json", "application/yaml", "application/cbor"];

export declare const minute: number;

/**
 * 支持的修饰符
 */
export declare type ModifierKey = (typeof modifiers)[number];

/**
 * 至少一个修饰符
 */
export declare type ModifierKeys = [ModifierKey, ...ModifierKey[]];

export declare const modifiers: readonly ["meta", "alt", "control", "shift"];

/**
 * 使一个容器成为一个可拖拽移动的对象
 *
 * @param toolbar - 鼠标控制区域；
 * @param container - 被移动的窗口，需要保证 toolbar 参数包含在 container 之内，且要 container 处于在可见状态；
 * @returns 销毁所有注册的事件；
 */
export declare function movable(toolbar: HTMLElement, container: HTMLElement): CancelMovable;

export declare const ms: number;

/**
 * 函数返回的值值可用于 {@link Intl#DurationFormat.format} 方法。
 */
export declare function nano2IntlDuration(nano: number): Partial<Record<Intl.DurationFormatUnit, number>>;

/**
 * 将纳秒转换为 {@link Intl#RelativeTimeFormat.format} 可用的参数
 * @param nano - 纳秒，如果为负数表示过去的时间；
 */
export declare function nano2IntlRelative(nano: number): [number, Intl.RelativeTimeFormatUnit];

/**
 * 添加该类的元素在打印时会被隐藏
 */
export declare const noPrint: string;

/**
 * 排除 T 中所有的可选字段组成一个新的对象
 */
export declare type OmitOptional<T> = Omit<T, OptionalKeys<T>>;

/**
 * 提取所有字段为可选类型的名称组成联合类型
 */
export declare type OptionalKeys<T> = NonNullable<{
    [K in keyof T]: undefined extends T[K] ? K : never;
}[keyof T]>;

declare interface Options {
    localeMatcher?: 'lookup' | 'best fit';
}

/**
 * 分页接口返回的对象
 *
 * @typeParam T - 表示当前页的类型
 */
export declare interface Page<T> {
    count: number;
    current: Array<T>;
    more?: boolean;
}

/**
 * 表示字段错误的列表
 *
 * @remarks
 * 同时表示了后端返回的 {@link Problem#params} 以及在前端数据验证中表示的验证错误。
 *
 * @typeParam K - 表示字段名的类型，默认为 string，但是在前端的数据验证中，可以收紧为某个对象的 keyof。
 */
export declare type Params<K extends string = string> = Array<{
    /**
     * 表示出错的字段名
     */
    name: K;
    /**
     * 错误信息
     */
    reason: string;
}>;

/**
 * parseDuration 将由 Go 语言的 Duration 字符串转换为纳秒
 */
export declare function parseDuration(val?: Duration): number;

/**
 * 提取 T 中所有的可选字段组成一个新的对象
 */
export declare type PickOptional<T> = Pick<T, OptionalKeys<T>>;

declare interface Point {
    x: number;
    y: number;
}

/**
 * 判断点是否在元素内
 */
export declare function pointInElement(x: number, y: number, elem: HTMLElement): boolean;

/**
 * 弹出框与锚点对象的对齐方式
 *
 * @remarks
 * - `start`：弹出框的起始位置对齐锚点的起始位置；
 * - `center`：弹出框的中心位置对齐锚点的中心位置；
 * - `end`：弹出框的结束位置对齐锚点的结束位置；
 */
export declare type PopoverAlign = 'start' | 'center' | 'end' | 'stretch';

export declare type PopoverPosition = 'top' | 'bottom' | 'left' | 'right';

/**
 * 这是 {@link CellRenderFunc} 的默认实现
 */
export declare function presetCellRenderFunc<T extends object, K extends keyof T>(_: string | K, val?: K extends keyof T ? T[K] : unknown, __?: T): CellType;

/**
 * 打印指定元素的内容
 *
 * @param elem - 该元素会被打印；
 * @param cls - 额外的 CSS 类；
 *
 * @remarks
 * 这会通过 cloneNode 创建新的节点，cls 只会应用在新节点上。
 */
export declare function printElement(elem: HTMLElement, cls?: string): void;

/**
 * 接口错误返回的对象
 *
 * @typeParam E - 表示 {@link extension} 字段的类型，如果该字段空值，不需要指定。
 */
export declare interface Problem<E = never> {
    type: string;
    title: string;
    status: number;
    detail?: string;
    instance?: string;
    extension?: E;
    headers?: Headers;
    /**
     * 具体的错误字段
     *
     * 根据 {@link status} 的不同，可能表示提交对象、查询参数或是报头的错误。
     */
    params?: Params;
}

/**
 * 查询参数的类型
 */
export declare interface Query {
    [k: string]: QueryValue | Array<QueryValue>;
    page?: number;
    size?: number;
}

/**
 * 将 Q 转换为查询参数
 *
 * 如果存在 q.page 属性，会自动将 page 的值减去 1，因为后端的 api 是从 0 页开始的。
 */
export declare function query2Search<Q extends Query>(q: Q): string;

/**
 * 查询参数的单个字段的类型
 */
declare type QueryValue = string | number | boolean | null | undefined;

/**
 * 生成随机数
 * @param min - 随机数的下限，包含此值在内；
 * @param max - 随机数的上限，包含此值在内；
 * @param decimals - 小数位数，如果小于等于 0，则返回整数；
 */
export declare function rand(min: number, max: number, decimals: number): number;

/**
 * 移除 interface 声明中的索引签名，展示真实的结构
 *
 * ```ts
 * interface Example {
 *   [key: string]: any;
 *   foo: string;
 *   bar: number;
 * }
 * RemoveIndexSignature<Example> // { foo: string; bar: number; }
 * ```
 */
export declare type RemoveIndexSignature<T> = {
    [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: T[K];
};

/**
 * API 请求时的额外参数
 */
export declare type ReqInit = Omit<RequestInit, 'method' | 'body'>;

declare type Requiredify<T> = {
    [K in keyof T]-?: T[K];
};

/**
 * RESTful 接口的基本操作方法
 */
export declare interface REST {
    /**
     * 返回关联的 {@link API} 对象
     */
    api(): API;
    /**
     * DELETE 请求
     *
     * @param path - 相对于 {@link API#baseURL} 的请求地址；
     * @param token - 是否带上令牌，如果此值为 true，那么在登录过期时会尝试刷新令牌。该值可能会被 init.headers 参数的相关设置覆盖；
     * @param init - 请求的额外参数；
     */
    delete<R = never, PE = never>(path: string, token?: boolean, init?: ReqInit): Promise<Return<R, PE>>;
    /**
     * POST 请求
     *
     * @param path - 相对于 {@link API#baseURL} 的请求地址；
     * @param body - 请求对象，会由 {@link Serializer} 进行转换，可以为空；
     * @param token - 是否带上令牌，如果此值为 true，那么在登录过期时会尝试刷新令牌。该值可能会被 init.headers 参数的相关设置覆盖；
     * @param init - 请求的额外参数；
     */
    post<R = never, PE = never>(path: string, body?: unknown, token?: boolean, init?: ReqInit): Promise<Return<R, PE>>;
    /**
     * PUT 请求
     *
     * @param path - 相对于 {@link API#baseURL} 的请求地址；
     * @param body - 请求对象，会由 {@link Serializer} 进行转换，可以为空；
     * @param token - 是否带上令牌，如果此值为 true，那么在登录过期时会尝试刷新令牌。该值可能会被 init.headers 参数的相关设置覆盖；
     * @param init - 请求的额外参数；
     */
    put<R = never, PE = never>(path: string, body?: unknown, token?: boolean, init?: ReqInit): Promise<Return<R, PE>>;
    /**
     * PATCH 请求
     *
     * @param path - 相对于 {@link API#baseURL} 的请求地址；
     * @param body - 请求对象，会由 #contentSerializer 进行转换，可以为空；
     * @param token - 是否带上令牌，如果此值为 true，那么在登录过期时会尝试刷新令牌。该值可能会被 init.headers 参数的相关设置覆盖；
     * @param init - 请求的额外参数；
     */
    patch<R = never, PE = never>(path: string, body?: unknown, token?: boolean, init?: ReqInit): Promise<Return<R, PE>>;
    /**
     * GET 请求
     *
     * @param path - 相对于 {@link API#baseURL} 的请求地址；
     * @param token - 是否带上令牌，如果此值为 true，那么在登录过期时会尝试刷新令牌。该值可能会被 init.headers 参数的相关设置覆盖；
     * @param init - 请求的额外参数；
     */
    get<R = never, PE = never>(path: string, token?: boolean, init?: ReqInit): Promise<Return<R, PE>>;
    /**
     * 执行普通的 API 请求
     *
     * @param path - 相对于 {@link API#baseURL} 的请求地址；
     * @param method - 请求方法；
     * @param obj - 请求对象，会由 #contentSerializer 进行转换，如果是 GET，可以为空；
     * @param token - 是否带上令牌，如果此值为 true，那么在登录过期时会尝试刷新令牌。该值可能会被 headers 参数的相关设置覆盖；
     * @param init - 请求的额外参数；
     * @typeParam R - 表示在接口操作成功的情况下返回的类型，如果不需要该数据可设置为 never；
     * @typeParam PE - 表示在接口操作失败之后，{@link Problem#extension} 字段的类型，如果该字段为空值，可设置为 never；
     */
    request<R = never, PE = never>(path: string, method: Method, obj?: unknown, token?: boolean, init?: ReqInit): Promise<Return<R, PE>>;
    /**
     * 执行上传操作
     *
     * @param path - 相对于 {@link API#baseURL} 的上传地址；
     * @param obj - 上传的对象；
     * @param token - 是否需要带上令牌，如果为 true，那么在登录过期时会尝试刷新令牌。该值可能会被 init.headers 参数的相关设置覆盖；
     * @param method - 请求方法，默认为 'POST'；
     * @param init - 请求的额外参数；
     */
    upload<R = never, PE = never>(path: string, obj: FormData, method?: 'POST' | 'PATCH' | 'PUT', token?: boolean, init?: ReqInit): Promise<Return<R, PE>>;
}

/**
 * 接口返回的对象
 *
 * @typeParam R - 表示在接口操作成功的情况下返回的类型，如果为空表示 never；
 * @typeParam PE - 表示在接口操作失败之后，{@link Problem#extension} 字段的类型，如果该字段为空值，表示为 never；
 */
export declare type Return<R = never, PE = never> = {
    /**
     * 返回的报头
     */
    headers?: Headers;
    /**
     * 服务端返回的类型
     */
    body?: Problem<PE>;
    /**
     * 状态码
     */
    status: number;
    /**
     * 是否出错了
     */
    ok: false;
} | {
    /**
     * 返回的报头
     */
    headers?: Headers;
    /**
     * 服务端返回的类型
     */
    body?: R;
    /**
     * 状态码
     */
    status: number;
    /**
     * 是否出错了
     */
    ok: true;
};

/**
 * 四舍五入丢弃多余的小数位，只留下 digits 指定的小数位数
 * @param num - 数值；
 * @param decimals - 小数位数；
 */
export declare function round(num: number, decimals: number): number;

export declare const second: number;

/**
 * 延时
 *
 * @param ms - 时间，以毫秒为单位
 */
export declare function sleep(ms: number): Promise<unknown>;

/**
 * 获取指定日期所在周的开始日期
 */
export declare function startOfISOWeek(date: Date): Date;

/**
 * 登录和刷新令牌接口返回的数据
 */
export declare interface Token {
    access_token: string;
    refresh_token: string;
    access_exp: number;
    refresh_exp: number;
}

export declare type TranslateArgs = Parameters<default_2['format']>[0];

/**
 * 联合类型转换为交叉类型
 */
declare type UnionToIntersection<T> = (T extends unknown ? (k: T) => void : never) extends (k: infer I) => void ? I : never;

export declare const us = 1000;

/**
 * 验证器
 *
 * @typeParam T - 需要验证的数据类型；
 */
export declare interface Validator<T extends Flattenable> {
    /**
     * 改变当前语言
     *
     * @remarks
     * 该操作会改变之后对数据验证时的错误信息
     */
    changeLocale(locale: Locale): void;
    /**
     * 验证数据
     *
     * @param obj - 需要验证的数据；
     * @param path - 如果不为空表示采用规则 path 验证 obj；
     */
    valid(obj: unknown, path?: FlattenKeys<T>): Promise<ValidResult<T>>;
}

/**
 * 验证数据的返回结果
 *
 * @typeParam T - 需要验证的数据类型；
 */
export declare type ValidResult<T extends Flattenable> = [data: T | undefined, errors: Params<FlattenKeys<T>> | undefined];

/**
 * 将 {@link z.ZodObject | Zod} 对象包装为 {@link Validator} 方法
 *
 * @param s - zod schema；
 * @param l - Locale 对象；
 * @typeParam T - 被验证对象的类型；
 */
export declare function zodValidator<T extends Flattenable>(s: z.ZodObject, l?: Locale): Validator<T>;

export { }