import type { MathTrait } from '../ops.ts';
export declare function id(...args: any[]): bigint;
export declare const sorted: <T extends number[] | number[][]>(x: T) => T;
export declare class DefaultMap<K, V> extends Map<K, V> {
    private defaultFn;
    constructor(values: [K, V][] | undefined, defaultFn: () => V);
    get(key: K): V;
}
type WeakArrayKey = {
    _id: bigint;
} | ArrayKey[];
type ArrayKey = {
    _id: bigint;
} | ArrayKey[] | string | ConstType | undefined;
export declare class ArrayMap<K extends ArrayKey, V, Internal extends [any, any] = [K, V]> {
    map: Map<bigint, Internal>;
    constructor(values?: Internal[]);
    get size(): number;
    get: (key: K) => V | undefined;
    set: (key: K, value: V) => void;
    has: (key: K) => boolean;
    entries: () => [K, V][];
    keys: () => K[];
    values: () => V[];
    delete: (k: K) => boolean;
    clear: () => void;
    setDefault: (key: K, defaultValue: V) => V;
}
export declare class WeakKeyMap<K extends WeakArrayKey, V extends any> extends ArrayMap<K, V, [WeakRef<K>, V]> {
    private finalizationGroup;
    constructor();
    get: (key: K) => V | undefined;
    set: (keyValue: K, value: V) => void;
    entries: () => [K, V][];
    delete: (k: K) => boolean;
    clear: () => void;
}
export declare class WeakValueMap<K extends ArrayKey, V extends object> extends ArrayMap<K, V, [K, WeakRef<V>]> {
    constructor();
    get: (key: K) => V | undefined;
    set: (key: K, value: V) => void;
    entries: () => [K, V][];
    delete: (k: K) => boolean;
    clear: () => void;
}
export declare class NotImplemented extends Error {
    constructor();
}
export declare const floatString: (x: number) => string;
export declare const constToNumeric: (x: ConstType) => number | bigint;
export declare const max: <T extends ConstType>(v: T[]) => number | T;
export declare const min: <T extends ConstType>(v: T[]) => number | T;
export declare const abs: <T extends ConstType>(x: T) => number | bigint;
export declare const trunc: <T extends ConstType>(x: T) => number | (T & bigint);
export declare const sqrt: <T extends ConstType>(x: T) => number | bigint;
export declare const sin: <T extends ConstType>(x: T) => number;
export declare const bigint_sqrt: (v: bigint) => bigint;
export declare const bigint_sin: (v: bigint) => number;
export declare const next: <A extends any>(arr: Iterator<A>, def: A) => A;
export declare const int_to_bytes: (int: number) => Uint8Array<ArrayBuffer>;
export declare const bytes_to_bigint: (bytes: Uint8Array) => bigint;
export declare const isInf: (x: number) => boolean;
export declare abstract class Enum {
    private readonly className;
    readonly name: string;
    readonly value: number;
    constructor(className: string, name: string, value: number);
    toString: () => string;
    [Symbol.toPrimitive](hint: 'string' | 'number' | 'default'): string | number;
}
export declare const random_id: () => string;
export declare const string_to_bytes: (text: string) => Uint8Array<ArrayBufferLike>;
export declare const bytes_to_string: (bytes: Uint8Array) => string;
export declare const bytes_to_hex: (arr: Uint8Array) => string;
export declare const concat_bytes: (...arrays: Uint8Array[]) => Uint8Array;
export declare function product<T extends any[][], Out extends any[] = T>(...arrays: T): Out;
export declare function product<T extends any[], Out extends any[] = T[]>(array: T, repeat?: number): Out;
export declare const divmod: (a: number, b: number) => number[];
export declare function counter(start?: number): Generator<number, void, unknown>;
export declare const list_str: (x?: any[]) => string;
export declare const entries: <K extends string, V extends any>(object: Record<K, V>) => [K, V][];
export declare function is_less_than(one: any[], two: any[]): boolean;
export type ConstType<This = never> = number | bigint | boolean | This;
export declare const isConst: (x: any) => x is ConstType;
export declare const is_eq: (one: any, two: any) => boolean;
export declare const intersection: <T>(...sets: Set<T>[]) => Set<T>;
export declare function set_default<K, V>(map: Map<K, V>, key: K, defaultValue: V): V;
type Iterableify<T> = {
    [K in keyof T]: Iterable<T[K]>;
};
export declare function zip<T extends Array<any>>(...toZip: Iterableify<T>): T[];
export declare function range(start: number, stop?: number, step?: number): number[];
export declare const tuple: <T extends any[]>(...t: T) => T;
export declare const assert: (condition: boolean) => condition is true;
export declare function permutations<T>(arr: T[], length?: number): T[][];
export declare function is_subset<T>(main: Set<T>, subset: Set<T>): boolean;
export declare function math_gcd(...numbers: number[]): number;
export declare const dedup: <T>(arr: T[]) => T[];
export declare const argsort: <T>(x: T[]) => number[];
export declare const all_same: <T>(items: T[]) => boolean;
export declare const isInt: (x: any) => x is number;
export declare const all_int: (t: any[]) => t is number[];
export declare const colored: (st: string, color?: string, background?: boolean) => string;
export declare const colorize_float: (x: number) => string;
export declare const memsize_to_str: (_b: number) => string;
export declare const ansistrip: (s: string) => string;
export declare const ansilen: (s: string) => number;
export declare const make_tuple: (x: number | number[], cnt: number) => number[];
export declare const flatten: <T>(l: T[][]) => T[];
export declare const fully_flatten: (l: any) => any[];
export declare const strip_parens: (s: string) => string;
export declare const round_up: (num: number, amt: number) => number;
export declare const lo32: (x: any) => number;
export declare const hi32: (x: any) => number;
export declare const data64: (data: number) => [number, number];
export declare const data64Le: (data: number) => [number, number];
export declare const getbits: (value: number, start: number, end: number) => number;
export declare const i2u: (bits: number, value: number) => number;
export declare const merge_dicts: <T extends string, U = any>(ds: Record<T, U>[]) => Record<T, U>;
export declare function merge_maps<K, V>(maps: Iterable<Map<K, V>>): Map<K, V>;
export declare function merge_sets<V>(sets: Iterable<Set<V>>): Set<V>;
export declare const partition: <T>(itr: T[], fn: (x: T) => boolean) => [T[], T[]];
export declare const get_single_element: <T>(x: T[]) => T;
export declare const unwrap: <T>(x: T | undefined) => T;
export declare const getChild: (obj: any, key: string) => any;
export declare const word_wrap: (x: string, wrap?: number) => string;
export declare const to_function_name: (s: string) => string;
export declare class Metadata {
    name: string;
    caller: string;
    backward: boolean;
    id: bigint;
    static cache: WeakValueMap<bigint, Metadata>;
    constructor(name: string, caller: string, backward?: boolean);
    toString: () => string;
}
declare class ContextVar<T> {
    private value;
    private tokens;
    constructor(value: T);
    get: () => T;
    set: (v: T) => string;
    reset: (token: string) => void;
}
export declare const _METADATA: ContextVar<Metadata | undefined>;
export declare class GlobalCounters {
    static global_ops: number;
    static global_mem: number;
    static time_sum_s: number;
    static kernel_count: number;
    static mem_used: number;
    static reset: () => [number, number, number, number];
}
export declare const perf: (start_ms: number) => number;
export declare const round: (value: number, decimals?: number) => number;
export declare const Timing: <T>(fn: () => Promise<T>) => Promise<[T, number]>;
export declare const _format_fcn: (fcn: any[]) => string;
export declare class Profiling {
}
export declare const _ensure_downloads_dir: () => string;
export declare const cpu_time_execution: <Args extends any[]>(fn: (...args: Args) => Promise<void> | void) => (...args: Args) => Promise<number>;
export declare const cpu_objdump: (lib: Uint8Array, objdumpTool?: string) => never;
export declare const capstone_flatdump: (lib: Uint8Array) => never;
export declare function replace<T>(instance: T, replacement: Partial<T>): T;
export type Slice = {
    from?: number;
    to?: number;
    by?: number;
};
/**
 * A Python-like slice function for arrays in TypeScript.
 * @param arr - The array you want to slice
 * @param options - An object containing start, stop, and step
 *   - start?: number (defaults to 0 if step > 0, or last index if step < 0)
 *   - stop?: number (defaults to arr.length if step > 0, or -arr.length - 1 if step < 0)
 *   - step?: number (defaults to 1)
 * @returns A new array sliced according to the options
 */
export declare function slice<T>(arr: T[], { from: start, to: stop, by: step }?: Slice): T[];
export declare function cache<Args extends any[], Return>(fn: (...args: Args) => Return): (...args: Args) => Return;
export declare function cache_fn<Args extends any[], Return>(fn: (...args: Args) => Return): (...args: Args) => Return;
export type Math = ConstType | MathTrait<any>;
type Return<A, B> = A extends MathTrait<any> ? A : B extends MathTrait<any> ? B : A extends bigint ? bigint : B extends bigint ? bigint : number;
export declare const num: <T extends number | any>(val: T) => number;
export declare const add: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const sub: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const mul: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const div: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const idiv: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const neg: <A extends Math>(a: A) => Return<A, A>;
export declare const mod: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const and: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const or: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const xor: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const lshift: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const rshift: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const lt: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const gt: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const le: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const ge: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const ne: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const eq: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare const polyN: <T extends Math>(x: T, p: Math[]) => T;
export declare const prod: <T extends Math>(x: T[]) => T;
export declare const sum: <T extends Math>(x: T[]) => T;
export declare const ceildiv: <A extends Math, B extends Math>(num: A, amt: B) => Return<A, B>;
export declare const pow: <A extends Math, B extends Math>(a: A, b: B) => Return<A, B>;
export declare function pairwise<T>(iterable: Iterable<T>): Generator<[T, T], void, unknown>;
export declare function accumulate<T>(iterable: Iterable<T>, func?: (acc: T, val: T) => T, initialValue?: T): Generator<T, void, unknown>;
declare class _Vars {
    _env: Record<string, string | number>;
    get: (key: string, def?: string) => string | undefined;
    get_num: (key: string, def?: number) => number;
    set: (key: string, value: string) => string;
    with: <Res>(overrides: Record<string, string | number>, fn: () => Res) => Res;
    withAsync: <Res>(overrides: Record<string, string | number>, fn: () => Promise<Res>) => Promise<Res>;
    get CI(): boolean;
    set CI(val: boolean);
    get DEBUG(): number;
    set DEBUG(val: number);
    get IMAGE(): number;
    set IMAGE(val: number);
    get BEAM(): number;
    set BEAM(val: number);
    get NOOPT(): number;
    set NOOPT(val: number);
    get JIT(): number;
    set JIT(val: number);
    get WINO(): number;
    set WINO(val: number);
    get CAPTURING(): number;
    set CAPTURING(val: number);
    get TRACEMETA(): number;
    set TRACEMETA(val: number);
    get USE_TC(): number;
    set USE_TC(val: number);
    get TC_OPT(): number;
    set TC_OPT(val: number);
    get AMX(): number;
    set AMX(val: number);
    get TRANSCENDENTAL(): number;
    set TRANSCENDENTAL(val: number);
    get FUSE_ARANGE(): number;
    set FUSE_ARANGE(val: number);
    get FUSE_CONV_BW(): number;
    set FUSE_CONV_BW(val: number);
    get SPLIT_REDUCEOP(): number;
    set SPLIT_REDUCEOP(val: number);
    get NO_MEMORY_PLANNER(): number;
    set NO_MEMORY_PLANNER(val: number);
    get RING(): number;
    set RING(val: number);
    get PICKLE_BUFFERS(): number;
    set PICKLE_BUFFERS(val: number);
    get PROFILE(): string | undefined;
    set PROFILE(val: string | undefined);
    get LRU(): number;
    set LRU(val: number);
    get CACHELEVEL(): number;
    set CACHELEVEL(val: number);
    get CAPTURE_PROCESS_REPLAY(): string | undefined;
    set CAPTURE_PROCESS_REPLAY(val: string | undefined);
    get TQDM(): number;
}
export declare const vars: _Vars;
export {};