@types/jsbn

constructor(a: number, c: RandomGenerator);

constructor(a: number, b: number, c: RandomGenerator);

constructor(a: string, b?: number);

constructor(a: number[], b?: number);

constructor(a: BigInteger);

data: number[];

DB: number;

DM: number;

DV: number;

F1: number;

F2: number;

FV: number;

static ONE: BigInteger;

s: number;

t: number;

static ZERO: BigInteger;

abs: () => BigInteger;

add: (a: BigInteger) => BigInteger;

addTo: (a: BigInteger, r: BigInteger) => void;

am: (
    i: number,
    x: number,
    w: BigInteger,
    j: number,
    c: number,
    n: number
) => number;

and: (a: BigInteger) => BigInteger;

andNot: (a: BigInteger) => BigInteger;

bitCount: () => number;

bitLength: () => number;

bitwiseTo: (
    a: BigInteger,
    op: (x: number, y: number) => number,
    r: BigInteger
) => void;

byteValue: () => number;

changeBit: (n: number, op: (x: number, y: number) => number) => BigInteger;

chunkSize: (r: number) => number;

clamp: () => void;

clearBit: (n: number) => BigInteger;

clone: () => BigInteger;

compareTo: (a: BigInteger) => number;

copyTo: (r: BigInteger) => void;

dAddOffset: (n: number, w: number) => void;

divide: (a: BigInteger) => BigInteger;

divideAndRemainder: (a: BigInteger) => BigInteger[];

divRemTo: (m: BigInteger, q: BigInteger, r: BigInteger) => void;

dlShiftTo: (n: number, r: BigInteger) => void;

dMultiply: (n: number) => void;

drShiftTo: (n: number, r: BigInteger) => void;

equals: (a: BigInteger) => boolean;

exp: (e: number, z: Reduction) => BigInteger;

flipBit: (n: number) => BigInteger;

fromInt: (x: number) => void;

fromNumber: (a: number, b?: number, c?: number) => void;

fromRadix: (s: string, b: number) => void;

fromString: (x: string, b: number) => void;

gcd: (a: BigInteger) => BigInteger;

getLowestSetBit: () => number;

intValue: () => number;

invDigit: () => number;

isEven: () => boolean;

isProbablePrime: (t: number) => boolean;

lShiftTo: (n: number, r: BigInteger) => void;

max: (a: BigInteger) => BigInteger;

millerRabin: (t: number) => boolean;

min: (a: BigInteger) => BigInteger;

mod: (a: BigInteger) => BigInteger;

modInt: (n: number) => number;

modInverse: (m: BigInteger) => BigInteger;

modPow: (e: BigInteger, m: BigInteger) => BigInteger;

modPowInt: (e: number, m: BigInteger) => BigInteger;

multiply: (a: BigInteger) => BigInteger;

multiplyLowerTo: (a: BigInteger, n: number, r: BigInteger) => void;

multiplyTo: (a: BigInteger, r: BigInteger) => void;

multiplyUpperTo: (a: BigInteger, n: number, r: BigInteger) => void;

negate: () => BigInteger;

not: () => BigInteger;

or: (a: BigInteger) => BigInteger;

pow: (e: number) => BigInteger;

remainder: (a: BigInteger) => BigInteger;

rShiftTo: (n: number, r: BigInteger) => void;

setBit: (n: number) => BigInteger;

shiftLeft: (n: number) => BigInteger;

shiftRight: (n: number) => BigInteger;

shortValue: () => number;

signum: () => number;

square: () => BigInteger;

squareTo: (r: BigInteger) => void;

subTo: (a: BigInteger, r: BigInteger) => void;

subtract: (a: BigInteger) => BigInteger;

testBit: (n: number) => boolean;

toByteArray: () => number[];

toRadix: (b: number) => string;

toString: (b?: number) => string;

xor: (a: BigInteger) => BigInteger;

nextBytes: (bytes: number[]) => void;

convert: (x: BigInteger) => BigInteger;

mulTo: (x: BigInteger, y: BigInteger, r: BigInteger) => void;

reduce: (x: BigInteger) => void;

revert: (x: BigInteger) => BigInteger;

sqrTo: (x: BigInteger, r: BigInteger) => void;