import Tnx from './tnxcore.ts';

declare global {

    interface Window {
        tnx: Tnx;
        WxLogin: (options: Record<string, any>) => void;
    }

    interface Number {

        /**
         * 获取当前数值四舍五入到指定精度后的结果
         * @param scale 精度，即小数点后的位数
         * @returns 四舍五入后的结果数值
         */
        halfUp(scale: number): number;

        /**
         * 转换为百分比字符串
         * @param scale 小数保留位数
         */
        toPercent(scale?: number): string;

    }

    interface String {

        firstToLowerCase(): string;

        firstToUpperCase(): string;

        format(...args: any[]): string;

        toCharArray(): string[];

        replaceAll(regex: string | RegExp, replacement: string): string;

        allIndexOf(searchString: string, position?: number): number[];

        splitToIntArray(separator: string): number[];

        splitByUpperCaseLetter(byNumber?: boolean): string[];

        wildcardMatches(...patterns: string[]): boolean;

    }

    interface Date {

        format(pattern: string): string;

        formatDateTime(): string;

        formatDate(): string;

        formatTime(): string;

        formatTimeMillisecond(): string;

        formatTimeMinute(): string;

        formatDateMinute(): string;

        formatDateMonth(): string;

        plusMilliseconds(milliseconds: number): Date;

        plusSeconds(seconds: number): Date;

        plusMinutes(minutes: number): Date;

        plusHours(hours: number): Date;

        plusDays(days: number): Date;

        plusMonths(months: number): Date;

        plusYears(years: number): Date;

        applyTime(hours: number, minutes: number, seconds: number, milliseconds: number): void;

    }

    interface Array<T> {

        contains(element: ((e: T) => boolean) | T): boolean;

        containsIgnoreCase(element: string): boolean;

        remove(element: ((e: T) => boolean) | T): T | undefined;

        removeIf(predicate: (e: T) => boolean): boolean;

        clone(deep?: boolean): T[];

        get(fn: (e: T) => boolean): T | undefined;

        equals(other: T[], predicate?: (a: T, b: T) => boolean): boolean;

    }

    interface Boolean {

        toText(): string | undefined;

    }

    interface Element {

        getFirstChildWithoutTagName(tagName: string): ChildNode | undefined;

        toggleClass(className: string): void;

        getParentIf(predicate?: (parent: Element) => boolean): Element | null;

    }

    type PermanentableDate = {
        permanent: boolean;
        value: string;
    }

    type Authority = {
        type?: string;
        rank?: string;
        permission?: string;
    }

}