/**
 * Structural contract for the BigNumber values manipulated here. Captures the
 * exact instance members and constructor statics used; the configured BigNumber
 * implementation (decimal.js / local Decimal) provides them.
 */
interface BigNumberValue {
    s: number;
    d: number[] | null;
    e: number;
    constructor: BigNumberCtor;
    isFinite(): boolean;
    isInteger(): boolean;
    isNaN(): boolean;
    isZero(): boolean;
    isNegative(): boolean;
    eq(other: BigNumberValue | number): boolean;
    lt(other: number): boolean;
    plus(other: BigNumberValue): BigNumberValue;
    times(other: BigNumberValue | string): BigNumberValue;
    div(other: BigNumberValue | string): BigNumberValue;
    pow(other: BigNumberValue): BigNumberValue;
    floor(): BigNumberValue;
    toNumber(): number;
}
interface BigNumberCtor {
    new (value: number | string): BigNumberValue;
    precision: number;
    config(options: {
        precision: number;
    }): void;
}
/** Bitwise operator applied to the individual bits (0/1) of two operands. */
type BitFunc = (a: number, b: number) => number;
/**
 * Bitwise and for Bignumbers
 *
 * Special Cases:
 *   N &  n =  N
 *   n &  0 =  0
 *   n & -1 =  n
 *   n &  n =  n
 *   I &  I =  I
 *  -I & -I = -I
 *   I & -I =  0
 *   I &  n =  n
 *   I & -n =  I
 *  -I &  n =  0
 *  -I & -n = -I
 *
 * @param {BigNumber} x
 * @param {BigNumber} y
 * @return {BigNumber} Result of `x` & `y`, is fully precise
 * @private
 */
export declare function bitAndBigNumber(x: BigNumberValue, y: BigNumberValue): BigNumberValue;
/**
 * Bitwise not
 * @param {BigNumber} x
 * @return {BigNumber} Result of ~`x`, fully precise
 *
 */
export declare function bitNotBigNumber(x: BigNumberValue): BigNumberValue;
/**
 * Bitwise OR for BigNumbers
 *
 * Special Cases:
 *   N |  n =  N
 *   n |  0 =  n
 *   n | -1 = -1
 *   n |  n =  n
 *   I |  I =  I
 *  -I | -I = -I
 *   I | -n = -1
 *   I | -I = -1
 *   I |  n =  I
 *  -I |  n = -I
 *  -I | -n = -n
 *
 * @param {BigNumber} x
 * @param {BigNumber} y
 * @return {BigNumber} Result of `x` | `y`, fully precise
 */
export declare function bitOrBigNumber(x: BigNumberValue, y: BigNumberValue): BigNumberValue;
/**
 * Applies bitwise function to numbers
 * @param {BigNumber} x
 * @param {BigNumber} y
 * @param {function (a, b)} func
 * @return {BigNumber}
 */
export declare function bitwise(x: BigNumberValue, y: BigNumberValue, func: BitFunc): BigNumberValue;
/**
 * Bitwise XOR for BigNumbers
 *
 * Special Cases:
 *   N ^  n =  N
 *   n ^  0 =  n
 *   n ^  n =  0
 *   n ^ -1 = ~n
 *   I ^  n =  I
 *   I ^ -n = -I
 *   I ^ -I = -1
 *  -I ^  n = -I
 *  -I ^ -n =  I
 *
 * @param {BigNumber} x
 * @param {BigNumber} y
 * @return {BigNumber} Result of `x` ^ `y`, fully precise
 *
 */
export declare function bitXor(x: BigNumberValue, y: BigNumberValue): BigNumberValue;
/**
 * Bitwise left shift
 *
 * Special Cases:
 *  n << -n = N
 *  n <<  N = N
 *  N <<  n = N
 *  n <<  0 = n
 *  0 <<  n = 0
 *  I <<  I = N
 *  I <<  n = I
 *  n <<  I = I
 *
 * @param {BigNumber} x
 * @param {BigNumber} y
 * @return {BigNumber} Result of `x` << `y`
 *
 */
export declare function leftShiftBigNumber(x: BigNumberValue, y: BigNumberValue): BigNumberValue;
/**
 * Arithmetic right shift `x >> y` of two BigNumber integers.
 *
 * Special Cases:
 *   n >> -n =  N
 *   n >>  N =  N
 *   N >>  n =  N
 *   I >>  I =  N
 *   n >>  0 =  n
 *   I >>  n =  I
 *  -I >>  n = -I
 *  -I >>  I = -I
 *   n >>  I =  I
 *  -n >>  I = -1
 *   0 >>  n =  0
 *
 * @param {BigNumber} x
 * @param {BigNumber} y
 * @return {BigNumber} Result of `x` >> `y`
 *
 */
export declare function rightArithShiftBigNumber(x: BigNumberValue, y: BigNumberValue): BigNumberValue;
/**
 * Bitwise right logical shift
 *
 * Special Cases:
 *   n >>> -n =  N
 *   n >>>  N =  N
 *   N >>>  n =  N
 *   I >>>  I =  N
 *   n >>>  0 =  n
 *   I >>>  n =  I
 *  -I >>>  n =  N
 *  -I >>>  I =  N
 *   n >>>  I =  0
 *  -n >>>  I =  0
 *   0 >>>  n =  0
 *
 * @param {BigNumber} x
 * @param {BigNumber} y
 * @return {BigNumber} Result of `x` >>> `y`
 *
 */
export declare function rightLogShiftBigNumber(x: BigNumberValue, y: BigNumberValue): BigNumberValue;
export {};
//# sourceMappingURL=bitwise.d.ts.map