declare const isBrowser: boolean;

declare function isDefined<T>(value: T): value is Exclude<T, null | undefined>;

declare const isNumber: (value: any) => value is number;

declare function masking(character: string, range: [number, number] | [number] | ([number, number] | [number])[], maskCode?: string): string;

type Prettier<T> = {
    [K in keyof T]: T[K];
};

type RequiredSome<T, K extends keyof T> = Prettier<Omit<T, K> & Required<Pick<T, K>>>;

type Awaitable<T> = T | Promise<T>;

declare function makeDestructurable<T extends Record<string, unknown>, A extends readonly any[]>(obj: T, arr: A): T & A;

declare function awaitPromise<T, E = any>(promise: Awaitable<T>): Promise<({
    data: T;
    error: null;
    status: "fulfilled";
} & [T, null, "fulfilled"]) | ({
    data: null;
    error: E;
    status: "rejected";
} & [null, E, "rejected"])>;

interface Log {
    message: (msg: string) => void;
    info: (msg: string) => void;
    warn: (msg: string) => void;
    error: (msg: string) => void;
    success: (msg: string) => void;
}
declare const log: Log;

type Primitive = string | number | boolean | bigint | symbol | undefined | null;
declare function narrow<T>(t: Narrow<T>): T;
type Narrow<T> = T extends [] ? [] : {
    [K in keyof T]: T[K] extends Primitive ? T[K] : Narrow<T[K]>;
};
declare const n: typeof narrow;

export { type Awaitable, type Log, type Prettier, type RequiredSome, awaitPromise, isBrowser, isDefined, isNumber, log, makeDestructurable, masking, n, narrow };