import { Bool } from './bool.js';
import { Field } from './field.js';
import { ProvablePureExtended } from './types/struct.js';
import { Unconstrained } from './types/unconstrained.js';
export { createProvableBigInt, ProvableBigInt };
type BigIntParameter = {
    limbNum: number;
    limbSize: number;
    mask: bigint;
    max: bigint;
};
/**
 * Creates a class representing a ProvableBigInt with modular arithmetic capabilities.
 * This is particularly useful for implementing prime fields that don't fit into the native field.
 *
 * ```ts
 * const BigInt521 = createProvableBigInt(2n ** 521n - 1n); // creates a class for 521-bit integers
 * ```
 *
 * `createProvableBigInt(modulus, config?)` takes two parameters:
 * - `modulus`: The modulus of the field (must be a prime)
 * - `config`: Optional configuration for custom limb size and numbers
 *
 * The returned class supports comprehensive arithmetic operations including:
 * - Basic operations: addition, double, subtraction, multiplication, square, division
 * - Advanced operations: inverse, negate, sqrt, power
 * - Comparison operations: equals, assertEquals, greaterThan, lessthan, greaterThanOrEqual, lessThanOrEqual
 * - Conversion methods: fromBigInt, toBigInt, fromFields, toFields, fromBits, toBits
 *
 * Implementation details:
 *
 * Internally, a ProvableBigInt is represented as an array of Field elements (limbs),
 * where each limb holds 116 bits as default. The total size is determined by the configuration,
 * with preset options supporting different bit lengths:
 * - 348 bits (3 limbs)
 * - 464 bits (4 limbs)
 * - 580 bits (5 limbs)
 * - 1044 bits (9 limbs)
 * - 2088 bits (18 limbs)
 * - 4176 bits (36 limbs)
 *
 * Each arithmetic operation ensures the result is a valid element of the prime field.
 *
 * @example
 * ```ts
 * // Create a Provable BigInt class with modulus 2^521 - 1
 * const BigInt521 = createProvableBigInt(2n ** 521n - 1n);
 *
 * // Create instances
 * const a = BigInt521.fromBigInt(123n);
 * const b = BigInt521.fromBigInt(456n);
 * const c = BigInt521.fromBigInt(1024n);
 *
 * // Perform operations
 * const sum = a.add(b);
 * const double = a.double();
 * const diff = a.sub(b);
 * const product = a.mul(b);
 * const square = a.square();
 * const quotient = a.div(b);
 * const inverse = a.inverse();
 * const negation = a.negate();
 * const power = a.pow(b);
 * const sqrt = c.sqrt();
 * ```
 *
 * The class automatically handles modular reduction after
 * arithmetic operations to maintain valid representations. All operations are
 * designed to be provable and optimised for less constraints.
 *
 * @param modulus The modulus for the big integer arithmetic (must be prime)
 * @param config Optional configuration specifying a custom limb size and number
 * @returns A class representing ProvableBigInts with the specified modulus
 * @throws If the modulus is zero, negative, or exceeds the maximum supported size
 */
declare function createProvableBigInt(modulus: bigint, config?: BigIntParameter): {
    new (fields: Field[], value: Unconstrained<bigint>): {
        readonly Constructor: typeof ProvableBigInt;
        /**
         * Converts a ProvableBigInt instance to a JS bigint
         * @returns JS bigint representation of the ProvableBigInt
         */
        toBigInt(): bigint;
        /**
         * Converts a ProvableBigInt instance to field array representation of the limbs
         * @returns Limbs of the ProvableBigInt
         */
        toFields(): Field[];
        /**
         * Converts a ProvableBigInt instance to an array of bits
         * @returns An array of bits representing the ProvableBigInt
         */
        toBits(): Bool[];
        /**
         * Clones a ProvableBigInt instance
         * @returns A new ProvableBigInt instance with the same value
         */
        clone(): any;
        /**
         * Adds two ProvableBigInt instances
         * Cost: Cheap
         * @param a The ProvableBigInt to add
         * @returns The sum as a ProvableBigInt
         */
        add(a: any, isDouble?: boolean): any;
        /**
         * Doubles a ProvableBigInt
         * Cost: Cheap
         * @returns The double of a ProvableBigInt
         */
        double(): any;
        /**
         * Subtracts one ProvableBigInt from another
         * Cost: Cheap
         * @param a The ProvableBigInt to subtract
         * @returns The difference as a ProvableBigInt
         */
        sub(a: any): any;
        /**
         * Multiplies two ProvableBigInt instances
         * Cost: Cheap
         * @param a The ProvableBigInt to multiply
         * @returns The product as a ProvableBigInt
         */
        mul(a: any, isSquare?: boolean): any;
        /**
         * Computes the square root of a ProvableBigInt
         * Cost: Cheap
         * @returns The square root as a ProvableBigInt
         */
        square(): any;
        /**
         * Divides one ProvableBigInt by another.
         * Cost: Cheap-Moderate
         * @param a The divisor as a ProvableBigInt
         * @returns The quotient as ProvableBigInt
         */
        div(a: any): any;
        /**
         * Computes the modular inverse of a ProvableBigInt
         * Cost: Cheap
         * @returns The inverse as a ProvableBigInt
         */
        inverse(): any;
        /**
         * Computes the additive inverse of a ProvableBigInt
         * Cost: Cheap
         * @returns The additive inverse as a ProvableBigInt
         */
        negate(): any;
        /**
         * Computes the power of a ProvableBigInt raised to an exponent
         * Cost: Expensive
         * @param exp The exponent
         * @returns The result as a ProvableBigInt
         */
        pow(exp: any): any;
        /**
         * Computes the square root of a Provable BigInt
         * Cost: Cheap
         * @returns The square root as a ProvableBigInt
         */
        sqrt(): any;
        /**
         * Checks if one ProvableBigInt is greater than another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is greater than b
         *
         * TODO: Comparators should ensure than inputs are canonical fields (value < p).
         *       e.g.
         *       ```ts
         *       let delta = x.sub(x); // not guaranteed to be < p, could be = p
         *       delta.greaterThan(ProvableBigInt.zero()).assertTrue(); // (p > 0) = true, (0 > 0) = false
         *       ```
         *
         */
        greaterThan(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is greater than or equal to another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is greater than or equal to b
         *
         * TODO: @see {@link greaterThan}
         *
         */
        greaterThanOrEqual(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than b
         *
         * TODO: @see {@link greaterThan}
         *
         */
        lessThan(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than or equal to another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than or equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        lessThanOrEqual(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is equal to another
         * Cost: Cheap
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        equals(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than or equal to another
         * Cost: Cheap
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than or equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        assertEquals(a: any): void;
        fields: Field[];
        value: Unconstrained<bigint>;
    };
    /**
     * Returns a ProvableBigInt representing zero
     * @returns A ProvableBigInt representing zero
     */
    zero(): {
        readonly Constructor: typeof ProvableBigInt;
        /**
         * Converts a ProvableBigInt instance to a JS bigint
         * @returns JS bigint representation of the ProvableBigInt
         */
        toBigInt(): bigint;
        /**
         * Converts a ProvableBigInt instance to field array representation of the limbs
         * @returns Limbs of the ProvableBigInt
         */
        toFields(): Field[];
        /**
         * Converts a ProvableBigInt instance to an array of bits
         * @returns An array of bits representing the ProvableBigInt
         */
        toBits(): Bool[];
        /**
         * Clones a ProvableBigInt instance
         * @returns A new ProvableBigInt instance with the same value
         */
        clone(): any;
        /**
         * Adds two ProvableBigInt instances
         * Cost: Cheap
         * @param a The ProvableBigInt to add
         * @returns The sum as a ProvableBigInt
         */
        add(a: any, isDouble?: boolean): any;
        /**
         * Doubles a ProvableBigInt
         * Cost: Cheap
         * @returns The double of a ProvableBigInt
         */
        double(): any;
        /**
         * Subtracts one ProvableBigInt from another
         * Cost: Cheap
         * @param a The ProvableBigInt to subtract
         * @returns The difference as a ProvableBigInt
         */
        sub(a: any): any;
        /**
         * Multiplies two ProvableBigInt instances
         * Cost: Cheap
         * @param a The ProvableBigInt to multiply
         * @returns The product as a ProvableBigInt
         */
        mul(a: any, isSquare?: boolean): any;
        /**
         * Computes the square root of a ProvableBigInt
         * Cost: Cheap
         * @returns The square root as a ProvableBigInt
         */
        square(): any;
        /**
         * Divides one ProvableBigInt by another.
         * Cost: Cheap-Moderate
         * @param a The divisor as a ProvableBigInt
         * @returns The quotient as ProvableBigInt
         */
        div(a: any): any;
        /**
         * Computes the modular inverse of a ProvableBigInt
         * Cost: Cheap
         * @returns The inverse as a ProvableBigInt
         */
        inverse(): any;
        /**
         * Computes the additive inverse of a ProvableBigInt
         * Cost: Cheap
         * @returns The additive inverse as a ProvableBigInt
         */
        negate(): any;
        /**
         * Computes the power of a ProvableBigInt raised to an exponent
         * Cost: Expensive
         * @param exp The exponent
         * @returns The result as a ProvableBigInt
         */
        pow(exp: any): any;
        /**
         * Computes the square root of a Provable BigInt
         * Cost: Cheap
         * @returns The square root as a ProvableBigInt
         */
        sqrt(): any;
        /**
         * Checks if one ProvableBigInt is greater than another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is greater than b
         *
         * TODO: Comparators should ensure than inputs are canonical fields (value < p).
         *       e.g.
         *       ```ts
         *       let delta = x.sub(x); // not guaranteed to be < p, could be = p
         *       delta.greaterThan(ProvableBigInt.zero()).assertTrue(); // (p > 0) = true, (0 > 0) = false
         *       ```
         *
         */
        greaterThan(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is greater than or equal to another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is greater than or equal to b
         *
         * TODO: @see {@link greaterThan}
         *
         */
        greaterThanOrEqual(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than b
         *
         * TODO: @see {@link greaterThan}
         *
         */
        lessThan(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than or equal to another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than or equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        lessThanOrEqual(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is equal to another
         * Cost: Cheap
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        equals(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than or equal to another
         * Cost: Cheap
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than or equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        assertEquals(a: any): void;
        fields: Field[];
        value: Unconstrained<bigint>;
    };
    /**
     * Returns a ProvableBigInt representing one
     * @returns A ProvableBigInt representing one
     */
    one(): {
        readonly Constructor: typeof ProvableBigInt;
        /**
         * Converts a ProvableBigInt instance to a JS bigint
         * @returns JS bigint representation of the ProvableBigInt
         */
        toBigInt(): bigint;
        /**
         * Converts a ProvableBigInt instance to field array representation of the limbs
         * @returns Limbs of the ProvableBigInt
         */
        toFields(): Field[];
        /**
         * Converts a ProvableBigInt instance to an array of bits
         * @returns An array of bits representing the ProvableBigInt
         */
        toBits(): Bool[];
        /**
         * Clones a ProvableBigInt instance
         * @returns A new ProvableBigInt instance with the same value
         */
        clone(): any;
        /**
         * Adds two ProvableBigInt instances
         * Cost: Cheap
         * @param a The ProvableBigInt to add
         * @returns The sum as a ProvableBigInt
         */
        add(a: any, isDouble?: boolean): any;
        /**
         * Doubles a ProvableBigInt
         * Cost: Cheap
         * @returns The double of a ProvableBigInt
         */
        double(): any;
        /**
         * Subtracts one ProvableBigInt from another
         * Cost: Cheap
         * @param a The ProvableBigInt to subtract
         * @returns The difference as a ProvableBigInt
         */
        sub(a: any): any;
        /**
         * Multiplies two ProvableBigInt instances
         * Cost: Cheap
         * @param a The ProvableBigInt to multiply
         * @returns The product as a ProvableBigInt
         */
        mul(a: any, isSquare?: boolean): any;
        /**
         * Computes the square root of a ProvableBigInt
         * Cost: Cheap
         * @returns The square root as a ProvableBigInt
         */
        square(): any;
        /**
         * Divides one ProvableBigInt by another.
         * Cost: Cheap-Moderate
         * @param a The divisor as a ProvableBigInt
         * @returns The quotient as ProvableBigInt
         */
        div(a: any): any;
        /**
         * Computes the modular inverse of a ProvableBigInt
         * Cost: Cheap
         * @returns The inverse as a ProvableBigInt
         */
        inverse(): any;
        /**
         * Computes the additive inverse of a ProvableBigInt
         * Cost: Cheap
         * @returns The additive inverse as a ProvableBigInt
         */
        negate(): any;
        /**
         * Computes the power of a ProvableBigInt raised to an exponent
         * Cost: Expensive
         * @param exp The exponent
         * @returns The result as a ProvableBigInt
         */
        pow(exp: any): any;
        /**
         * Computes the square root of a Provable BigInt
         * Cost: Cheap
         * @returns The square root as a ProvableBigInt
         */
        sqrt(): any;
        /**
         * Checks if one ProvableBigInt is greater than another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is greater than b
         *
         * TODO: Comparators should ensure than inputs are canonical fields (value < p).
         *       e.g.
         *       ```ts
         *       let delta = x.sub(x); // not guaranteed to be < p, could be = p
         *       delta.greaterThan(ProvableBigInt.zero()).assertTrue(); // (p > 0) = true, (0 > 0) = false
         *       ```
         *
         */
        greaterThan(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is greater than or equal to another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is greater than or equal to b
         *
         * TODO: @see {@link greaterThan}
         *
         */
        greaterThanOrEqual(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than b
         *
         * TODO: @see {@link greaterThan}
         *
         */
        lessThan(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than or equal to another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than or equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        lessThanOrEqual(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is equal to another
         * Cost: Cheap
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        equals(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than or equal to another
         * Cost: Cheap
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than or equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        assertEquals(a: any): void;
        fields: Field[];
        value: Unconstrained<bigint>;
    };
    /**
     * Returns a ProvableBigInt representing one
     * @returns A ProvableBigInt representing one
     */
    max(): {
        readonly Constructor: typeof ProvableBigInt;
        /**
         * Converts a ProvableBigInt instance to a JS bigint
         * @returns JS bigint representation of the ProvableBigInt
         */
        toBigInt(): bigint;
        /**
         * Converts a ProvableBigInt instance to field array representation of the limbs
         * @returns Limbs of the ProvableBigInt
         */
        toFields(): Field[];
        /**
         * Converts a ProvableBigInt instance to an array of bits
         * @returns An array of bits representing the ProvableBigInt
         */
        toBits(): Bool[];
        /**
         * Clones a ProvableBigInt instance
         * @returns A new ProvableBigInt instance with the same value
         */
        clone(): any;
        /**
         * Adds two ProvableBigInt instances
         * Cost: Cheap
         * @param a The ProvableBigInt to add
         * @returns The sum as a ProvableBigInt
         */
        add(a: any, isDouble?: boolean): any;
        /**
         * Doubles a ProvableBigInt
         * Cost: Cheap
         * @returns The double of a ProvableBigInt
         */
        double(): any;
        /**
         * Subtracts one ProvableBigInt from another
         * Cost: Cheap
         * @param a The ProvableBigInt to subtract
         * @returns The difference as a ProvableBigInt
         */
        sub(a: any): any;
        /**
         * Multiplies two ProvableBigInt instances
         * Cost: Cheap
         * @param a The ProvableBigInt to multiply
         * @returns The product as a ProvableBigInt
         */
        mul(a: any, isSquare?: boolean): any;
        /**
         * Computes the square root of a ProvableBigInt
         * Cost: Cheap
         * @returns The square root as a ProvableBigInt
         */
        square(): any;
        /**
         * Divides one ProvableBigInt by another.
         * Cost: Cheap-Moderate
         * @param a The divisor as a ProvableBigInt
         * @returns The quotient as ProvableBigInt
         */
        div(a: any): any;
        /**
         * Computes the modular inverse of a ProvableBigInt
         * Cost: Cheap
         * @returns The inverse as a ProvableBigInt
         */
        inverse(): any;
        /**
         * Computes the additive inverse of a ProvableBigInt
         * Cost: Cheap
         * @returns The additive inverse as a ProvableBigInt
         */
        negate(): any;
        /**
         * Computes the power of a ProvableBigInt raised to an exponent
         * Cost: Expensive
         * @param exp The exponent
         * @returns The result as a ProvableBigInt
         */
        pow(exp: any): any;
        /**
         * Computes the square root of a Provable BigInt
         * Cost: Cheap
         * @returns The square root as a ProvableBigInt
         */
        sqrt(): any;
        /**
         * Checks if one ProvableBigInt is greater than another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is greater than b
         *
         * TODO: Comparators should ensure than inputs are canonical fields (value < p).
         *       e.g.
         *       ```ts
         *       let delta = x.sub(x); // not guaranteed to be < p, could be = p
         *       delta.greaterThan(ProvableBigInt.zero()).assertTrue(); // (p > 0) = true, (0 > 0) = false
         *       ```
         *
         */
        greaterThan(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is greater than or equal to another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is greater than or equal to b
         *
         * TODO: @see {@link greaterThan}
         *
         */
        greaterThanOrEqual(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than b
         *
         * TODO: @see {@link greaterThan}
         *
         */
        lessThan(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than or equal to another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than or equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        lessThanOrEqual(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is equal to another
         * Cost: Cheap
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        equals(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than or equal to another
         * Cost: Cheap
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than or equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        assertEquals(a: any): void;
        fields: Field[];
        value: Unconstrained<bigint>;
    };
    /**
     * Creates a ProvableBigInt instance from a JS bigint, string, number, or boolean
     * @param x
     * @returns ProvableBigInt instance from the input
     */
    from(x: bigint | string | number | boolean): {
        readonly Constructor: typeof ProvableBigInt;
        /**
         * Converts a ProvableBigInt instance to a JS bigint
         * @returns JS bigint representation of the ProvableBigInt
         */
        toBigInt(): bigint;
        /**
         * Converts a ProvableBigInt instance to field array representation of the limbs
         * @returns Limbs of the ProvableBigInt
         */
        toFields(): Field[];
        /**
         * Converts a ProvableBigInt instance to an array of bits
         * @returns An array of bits representing the ProvableBigInt
         */
        toBits(): Bool[];
        /**
         * Clones a ProvableBigInt instance
         * @returns A new ProvableBigInt instance with the same value
         */
        clone(): any;
        /**
         * Adds two ProvableBigInt instances
         * Cost: Cheap
         * @param a The ProvableBigInt to add
         * @returns The sum as a ProvableBigInt
         */
        add(a: any, isDouble?: boolean): any;
        /**
         * Doubles a ProvableBigInt
         * Cost: Cheap
         * @returns The double of a ProvableBigInt
         */
        double(): any;
        /**
         * Subtracts one ProvableBigInt from another
         * Cost: Cheap
         * @param a The ProvableBigInt to subtract
         * @returns The difference as a ProvableBigInt
         */
        sub(a: any): any;
        /**
         * Multiplies two ProvableBigInt instances
         * Cost: Cheap
         * @param a The ProvableBigInt to multiply
         * @returns The product as a ProvableBigInt
         */
        mul(a: any, isSquare?: boolean): any;
        /**
         * Computes the square root of a ProvableBigInt
         * Cost: Cheap
         * @returns The square root as a ProvableBigInt
         */
        square(): any;
        /**
         * Divides one ProvableBigInt by another.
         * Cost: Cheap-Moderate
         * @param a The divisor as a ProvableBigInt
         * @returns The quotient as ProvableBigInt
         */
        div(a: any): any;
        /**
         * Computes the modular inverse of a ProvableBigInt
         * Cost: Cheap
         * @returns The inverse as a ProvableBigInt
         */
        inverse(): any;
        /**
         * Computes the additive inverse of a ProvableBigInt
         * Cost: Cheap
         * @returns The additive inverse as a ProvableBigInt
         */
        negate(): any;
        /**
         * Computes the power of a ProvableBigInt raised to an exponent
         * Cost: Expensive
         * @param exp The exponent
         * @returns The result as a ProvableBigInt
         */
        pow(exp: any): any;
        /**
         * Computes the square root of a Provable BigInt
         * Cost: Cheap
         * @returns The square root as a ProvableBigInt
         */
        sqrt(): any;
        /**
         * Checks if one ProvableBigInt is greater than another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is greater than b
         *
         * TODO: Comparators should ensure than inputs are canonical fields (value < p).
         *       e.g.
         *       ```ts
         *       let delta = x.sub(x); // not guaranteed to be < p, could be = p
         *       delta.greaterThan(ProvableBigInt.zero()).assertTrue(); // (p > 0) = true, (0 > 0) = false
         *       ```
         *
         */
        greaterThan(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is greater than or equal to another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is greater than or equal to b
         *
         * TODO: @see {@link greaterThan}
         *
         */
        greaterThanOrEqual(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than b
         *
         * TODO: @see {@link greaterThan}
         *
         */
        lessThan(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than or equal to another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than or equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        lessThanOrEqual(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is equal to another
         * Cost: Cheap
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        equals(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than or equal to another
         * Cost: Cheap
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than or equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        assertEquals(a: any): void;
        fields: Field[];
        value: Unconstrained<bigint>;
    };
    /**
     * Creates a ProvableBigInt instance from a JS bigint
     * @param x
     * @returns ProvableBigInt instance from the input
     */
    fromBigInt(x: bigint): {
        readonly Constructor: typeof ProvableBigInt;
        /**
         * Converts a ProvableBigInt instance to a JS bigint
         * @returns JS bigint representation of the ProvableBigInt
         */
        toBigInt(): bigint;
        /**
         * Converts a ProvableBigInt instance to field array representation of the limbs
         * @returns Limbs of the ProvableBigInt
         */
        toFields(): Field[];
        /**
         * Converts a ProvableBigInt instance to an array of bits
         * @returns An array of bits representing the ProvableBigInt
         */
        toBits(): Bool[];
        /**
         * Clones a ProvableBigInt instance
         * @returns A new ProvableBigInt instance with the same value
         */
        clone(): any;
        /**
         * Adds two ProvableBigInt instances
         * Cost: Cheap
         * @param a The ProvableBigInt to add
         * @returns The sum as a ProvableBigInt
         */
        add(a: any, isDouble?: boolean): any;
        /**
         * Doubles a ProvableBigInt
         * Cost: Cheap
         * @returns The double of a ProvableBigInt
         */
        double(): any;
        /**
         * Subtracts one ProvableBigInt from another
         * Cost: Cheap
         * @param a The ProvableBigInt to subtract
         * @returns The difference as a ProvableBigInt
         */
        sub(a: any): any;
        /**
         * Multiplies two ProvableBigInt instances
         * Cost: Cheap
         * @param a The ProvableBigInt to multiply
         * @returns The product as a ProvableBigInt
         */
        mul(a: any, isSquare?: boolean): any;
        /**
         * Computes the square root of a ProvableBigInt
         * Cost: Cheap
         * @returns The square root as a ProvableBigInt
         */
        square(): any;
        /**
         * Divides one ProvableBigInt by another.
         * Cost: Cheap-Moderate
         * @param a The divisor as a ProvableBigInt
         * @returns The quotient as ProvableBigInt
         */
        div(a: any): any;
        /**
         * Computes the modular inverse of a ProvableBigInt
         * Cost: Cheap
         * @returns The inverse as a ProvableBigInt
         */
        inverse(): any;
        /**
         * Computes the additive inverse of a ProvableBigInt
         * Cost: Cheap
         * @returns The additive inverse as a ProvableBigInt
         */
        negate(): any;
        /**
         * Computes the power of a ProvableBigInt raised to an exponent
         * Cost: Expensive
         * @param exp The exponent
         * @returns The result as a ProvableBigInt
         */
        pow(exp: any): any;
        /**
         * Computes the square root of a Provable BigInt
         * Cost: Cheap
         * @returns The square root as a ProvableBigInt
         */
        sqrt(): any;
        /**
         * Checks if one ProvableBigInt is greater than another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is greater than b
         *
         * TODO: Comparators should ensure than inputs are canonical fields (value < p).
         *       e.g.
         *       ```ts
         *       let delta = x.sub(x); // not guaranteed to be < p, could be = p
         *       delta.greaterThan(ProvableBigInt.zero()).assertTrue(); // (p > 0) = true, (0 > 0) = false
         *       ```
         *
         */
        greaterThan(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is greater than or equal to another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is greater than or equal to b
         *
         * TODO: @see {@link greaterThan}
         *
         */
        greaterThanOrEqual(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than b
         *
         * TODO: @see {@link greaterThan}
         *
         */
        lessThan(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than or equal to another
         * Cost: Moderate
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than or equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        lessThanOrEqual(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is equal to another
         * Cost: Cheap
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        equals(a: any): Bool;
        /**
         * Checks if one ProvableBigInt is less than or equal to another
         * Cost: Cheap
         * @param a The ProvableBigInt to compare
         * @returns A Bool indicating if a is less than or equal to b
         *
         * TODO: @see {@link greaterThan}
         */
        assertEquals(a: any): void;
        fields: Field[];
        value: Unconstrained<bigint>;
    };
    Unsafe: {
        /**
         * Creates a ProvableBigInt instance from an limbs as an array of fields
         * **WARNING**: This method is UNSAFE and lacks checks on the fields. Use with caution as it can lead to incorrect results or security vulnerabilities.
         * @param fields The limbs of the ProvableBigInt. Must be of the correct length.
         * @returns A ProvableBigInt instance from the fields
         */
        fromFields(fields: Field[]): {
            readonly Constructor: typeof ProvableBigInt;
            /**
             * Converts a ProvableBigInt instance to a JS bigint
             * @returns JS bigint representation of the ProvableBigInt
             */
            toBigInt(): bigint;
            /**
             * Converts a ProvableBigInt instance to field array representation of the limbs
             * @returns Limbs of the ProvableBigInt
             */
            toFields(): Field[];
            /**
             * Converts a ProvableBigInt instance to an array of bits
             * @returns An array of bits representing the ProvableBigInt
             */
            toBits(): Bool[];
            /**
             * Clones a ProvableBigInt instance
             * @returns A new ProvableBigInt instance with the same value
             */
            clone(): any;
            /**
             * Adds two ProvableBigInt instances
             * Cost: Cheap
             * @param a The ProvableBigInt to add
             * @returns The sum as a ProvableBigInt
             */
            add(a: any, isDouble?: boolean): any;
            /**
             * Doubles a ProvableBigInt
             * Cost: Cheap
             * @returns The double of a ProvableBigInt
             */
            double(): any;
            /**
             * Subtracts one ProvableBigInt from another
             * Cost: Cheap
             * @param a The ProvableBigInt to subtract
             * @returns The difference as a ProvableBigInt
             */
            sub(a: any): any;
            /**
             * Multiplies two ProvableBigInt instances
             * Cost: Cheap
             * @param a The ProvableBigInt to multiply
             * @returns The product as a ProvableBigInt
             */
            mul(a: any, isSquare?: boolean): any;
            /**
             * Computes the square root of a ProvableBigInt
             * Cost: Cheap
             * @returns The square root as a ProvableBigInt
             */
            square(): any;
            /**
             * Divides one ProvableBigInt by another.
             * Cost: Cheap-Moderate
             * @param a The divisor as a ProvableBigInt
             * @returns The quotient as ProvableBigInt
             */
            div(a: any): any;
            /**
             * Computes the modular inverse of a ProvableBigInt
             * Cost: Cheap
             * @returns The inverse as a ProvableBigInt
             */
            inverse(): any;
            /**
             * Computes the additive inverse of a ProvableBigInt
             * Cost: Cheap
             * @returns The additive inverse as a ProvableBigInt
             */
            negate(): any;
            /**
             * Computes the power of a ProvableBigInt raised to an exponent
             * Cost: Expensive
             * @param exp The exponent
             * @returns The result as a ProvableBigInt
             */
            pow(exp: any): any;
            /**
             * Computes the square root of a Provable BigInt
             * Cost: Cheap
             * @returns The square root as a ProvableBigInt
             */
            sqrt(): any;
            /**
             * Checks if one ProvableBigInt is greater than another
             * Cost: Moderate
             * @param a The ProvableBigInt to compare
             * @returns A Bool indicating if a is greater than b
             *
             * TODO: Comparators should ensure than inputs are canonical fields (value < p).
             *       e.g.
             *       ```ts
             *       let delta = x.sub(x); // not guaranteed to be < p, could be = p
             *       delta.greaterThan(ProvableBigInt.zero()).assertTrue(); // (p > 0) = true, (0 > 0) = false
             *       ```
             *
             */
            greaterThan(a: any): Bool;
            /**
             * Checks if one ProvableBigInt is greater than or equal to another
             * Cost: Moderate
             * @param a The ProvableBigInt to compare
             * @returns A Bool indicating if a is greater than or equal to b
             *
             * TODO: @see {@link greaterThan}
             *
             */
            greaterThanOrEqual(a: any): Bool;
            /**
             * Checks if one ProvableBigInt is less than another
             * Cost: Moderate
             * @param a The ProvableBigInt to compare
             * @returns A Bool indicating if a is less than b
             *
             * TODO: @see {@link greaterThan}
             *
             */
            lessThan(a: any): Bool;
            /**
             * Checks if one ProvableBigInt is less than or equal to another
             * Cost: Moderate
             * @param a The ProvableBigInt to compare
             * @returns A Bool indicating if a is less than or equal to b
             *
             * TODO: @see {@link greaterThan}
             */
            lessThanOrEqual(a: any): Bool;
            /**
             * Checks if one ProvableBigInt is equal to another
             * Cost: Cheap
             * @param a The ProvableBigInt to compare
             * @returns A Bool indicating if a is equal to b
             *
             * TODO: @see {@link greaterThan}
             */
            equals(a: any): Bool;
            /**
             * Checks if one ProvableBigInt is less than or equal to another
             * Cost: Cheap
             * @param a The ProvableBigInt to compare
             * @returns A Bool indicating if a is less than or equal to b
             *
             * TODO: @see {@link greaterThan}
             */
            assertEquals(a: any): void;
            fields: Field[];
            value: Unconstrained<bigint>;
        };
        /**
         * Creates a ProvableBigInt instance from an array of bits
         * **WARNING**: This method is UNSAFE and lacks checks on the bits. Use with caution as it can lead to incorrect results or security vulnerabilities.
         * @param bits
         * @returns A ProvableBigInt instance from the bits
         */
        fromBits(bits: Bool[]): {
            readonly Constructor: typeof ProvableBigInt;
            /**
             * Converts a ProvableBigInt instance to a JS bigint
             * @returns JS bigint representation of the ProvableBigInt
             */
            toBigInt(): bigint;
            /**
             * Converts a ProvableBigInt instance to field array representation of the limbs
             * @returns Limbs of the ProvableBigInt
             */
            toFields(): Field[];
            /**
             * Converts a ProvableBigInt instance to an array of bits
             * @returns An array of bits representing the ProvableBigInt
             */
            toBits(): Bool[];
            /**
             * Clones a ProvableBigInt instance
             * @returns A new ProvableBigInt instance with the same value
             */
            clone(): any;
            /**
             * Adds two ProvableBigInt instances
             * Cost: Cheap
             * @param a The ProvableBigInt to add
             * @returns The sum as a ProvableBigInt
             */
            add(a: any, isDouble?: boolean): any;
            /**
             * Doubles a ProvableBigInt
             * Cost: Cheap
             * @returns The double of a ProvableBigInt
             */
            double(): any;
            /**
             * Subtracts one ProvableBigInt from another
             * Cost: Cheap
             * @param a The ProvableBigInt to subtract
             * @returns The difference as a ProvableBigInt
             */
            sub(a: any): any;
            /**
             * Multiplies two ProvableBigInt instances
             * Cost: Cheap
             * @param a The ProvableBigInt to multiply
             * @returns The product as a ProvableBigInt
             */
            mul(a: any, isSquare?: boolean): any;
            /**
             * Computes the square root of a ProvableBigInt
             * Cost: Cheap
             * @returns The square root as a ProvableBigInt
             */
            square(): any;
            /**
             * Divides one ProvableBigInt by another.
             * Cost: Cheap-Moderate
             * @param a The divisor as a ProvableBigInt
             * @returns The quotient as ProvableBigInt
             */
            div(a: any): any;
            /**
             * Computes the modular inverse of a ProvableBigInt
             * Cost: Cheap
             * @returns The inverse as a ProvableBigInt
             */
            inverse(): any;
            /**
             * Computes the additive inverse of a ProvableBigInt
             * Cost: Cheap
             * @returns The additive inverse as a ProvableBigInt
             */
            negate(): any;
            /**
             * Computes the power of a ProvableBigInt raised to an exponent
             * Cost: Expensive
             * @param exp The exponent
             * @returns The result as a ProvableBigInt
             */
            pow(exp: any): any;
            /**
             * Computes the square root of a Provable BigInt
             * Cost: Cheap
             * @returns The square root as a ProvableBigInt
             */
            sqrt(): any;
            /**
             * Checks if one ProvableBigInt is greater than another
             * Cost: Moderate
             * @param a The ProvableBigInt to compare
             * @returns A Bool indicating if a is greater than b
             *
             * TODO: Comparators should ensure than inputs are canonical fields (value < p).
             *       e.g.
             *       ```ts
             *       let delta = x.sub(x); // not guaranteed to be < p, could be = p
             *       delta.greaterThan(ProvableBigInt.zero()).assertTrue(); // (p > 0) = true, (0 > 0) = false
             *       ```
             *
             */
            greaterThan(a: any): Bool;
            /**
             * Checks if one ProvableBigInt is greater than or equal to another
             * Cost: Moderate
             * @param a The ProvableBigInt to compare
             * @returns A Bool indicating if a is greater than or equal to b
             *
             * TODO: @see {@link greaterThan}
             *
             */
            greaterThanOrEqual(a: any): Bool;
            /**
             * Checks if one ProvableBigInt is less than another
             * Cost: Moderate
             * @param a The ProvableBigInt to compare
             * @returns A Bool indicating if a is less than b
             *
             * TODO: @see {@link greaterThan}
             *
             */
            lessThan(a: any): Bool;
            /**
             * Checks if one ProvableBigInt is less than or equal to another
             * Cost: Moderate
             * @param a The ProvableBigInt to compare
             * @returns A Bool indicating if a is less than or equal to b
             *
             * TODO: @see {@link greaterThan}
             */
            lessThanOrEqual(a: any): Bool;
            /**
             * Checks if one ProvableBigInt is equal to another
             * Cost: Cheap
             * @param a The ProvableBigInt to compare
             * @returns A Bool indicating if a is equal to b
             *
             * TODO: @see {@link greaterThan}
             */
            equals(a: any): Bool;
            /**
             * Checks if one ProvableBigInt is less than or equal to another
             * Cost: Cheap
             * @param a The ProvableBigInt to compare
             * @returns A Bool indicating if a is less than or equal to b
             *
             * TODO: @see {@link greaterThan}
             */
            assertEquals(a: any): void;
            fields: Field[];
            value: Unconstrained<bigint>;
        };
    };
    _provable?: ProvablePureExtended<ProvableBigInt<ProvableBigInt<any>>, {
        fields: bigint[];
    }, {
        fields: string[];
    }> | undefined;
    readonly provable: ProvablePureExtended<ProvableBigInt<ProvableBigInt<any>>, {
        fields: bigint[];
    }, {
        fields: string[];
    }>;
    _modulus?: ProvableBigInt<any> | undefined;
    _config?: BigIntParameter | undefined;
    readonly modulus: ProvableBigInt<any>;
    readonly config: BigIntParameter;
};
declare abstract class ProvableBigInt<T> {
    fields: Field[];
    value: Unconstrained<bigint>;
    static _provable?: ProvablePureExtended<ProvableBigInt<ProvableBigInt<any>>, {
        fields: bigint[];
    }, {
        fields: string[];
    }>;
    static get provable(): ProvablePureExtended<ProvableBigInt<ProvableBigInt<any>>, {
        fields: bigint[];
    }, {
        fields: string[];
    }>;
    static _modulus?: ProvableBigInt<any>;
    static _config?: BigIntParameter;
    static get modulus(): ProvableBigInt<any>;
    static get config(): BigIntParameter;
    constructor(fields: Field[], value: Unconstrained<bigint>);
    abstract get Constructor(): typeof ProvableBigInt;
    abstract toBigInt(): bigint;
    abstract toFields(): Field[];
    abstract toBits(): Bool[];
    abstract clone(): T;
    abstract add(a: T, isDouble?: boolean): T;
    abstract double(): T;
    abstract sub(a: T): T;
    abstract mul(a: T, isSquare?: boolean): T;
    abstract square(): T;
    abstract div(a: T): T;
    abstract inverse(): T;
    abstract negate(): T;
    abstract pow(exp: T): T;
    abstract sqrt(): T;
    abstract greaterThan(a: T): Bool;
    abstract greaterThanOrEqual(a: T): Bool;
    abstract lessThan(a: T): Bool;
    abstract lessThanOrEqual(a: T): Bool;
    abstract equals(a: T): Bool;
    abstract assertEquals(a: T): void;
}