/**
 * @import { Field, FieldWithOps } from "../../internal.js"
 */
/**
 * @template T
 * @param {Field<T>} F
 * @returns {FieldWithOps<T>}
 */
export function makeFieldWithOps<T>(F: Field<T>): FieldWithOps<T>;
/**
 * Defines additional operations on a field (which use the basic operations as building blocks)
 *   * isZero(a)
 *   * isOne(a)
 *   * mod(a)
 *   * subtract(a, b)
 *   * negate(a)
 *   * square(a)
 *   * cube(a)
 *   * divide(a, b)
 *   * pow(a, p)
 *   * halve(a)
 *
 * @template T
 * @implements {FieldWithOps<T>}
 */
export class FieldWithOpsImpl<T> {
    /**
     * @param {Field<T>} F
     */
    constructor(F: Field<T>);
    /**
     * @readonly
     * @type {Field<T>}
     */
    readonly F: Field<T>;
    /**
     * @type {T}
     */
    get ZERO(): T;
    /**
     * @type {T}
     */
    get ONE(): T;
    /**
     * @param {T} a
     * @returns {boolean}
     */
    isZero(a: T): boolean;
    /**
     * @param {T} a
     * @returns {boolean}
     */
    isOne(a: T): boolean;
    /**
     * @param {T} a
     * @returns {T}
     */
    mod(a: T): T;
    /**
     * @param {T} a
     * @param {T[]} bs
     * @returns {T}
     */
    add(a: T, ...bs: T[]): T;
    /**
     * @param {T} a
     * @param {T} b
     * @returns {T}
     */
    subtract(a: T, b: T): T;
    /**
     * @param {T} a
     * @param {bigint} s
     * @returns {T}
     */
    scale(a: T, s: bigint): T;
    /**
     * @param {T} a
     * @returns {T}
     */
    negate(a: T): T;
    /**
     * @param {T} a
     * @param {T} b
     * @returns {T}
     */
    multiply(a: T, b: T): T;
    /**
     * @param {T} a
     * @returns {T}
     */
    square(a: T): T;
    /**
     * @param {T} a
     * @returns {T}
     */
    cube(a: T): T;
    /**
     * @param {T} a
     * @param {T} b
     * @returns {T}
     */
    divide(a: T, b: T): T;
    /**
     * @param {T} a
     * @returns {T}
     */
    invert(a: T): T;
    /**
     * Modular exponent
     * TODO: would a non-recursive version of this algorithm be faster?
     * @param {T} a
     * @param {bigint} p
     * @returns {T}
     */
    pow(a: T, p: bigint): T;
    /**
     * @param {T} a
     * @param {T} b
     * @returns {boolean}
     */
    equals(a: T, b: T): boolean;
    /**
     * @param {T} a
     * @returns {T}
     */
    halve(a: T): T;
}
import type { Field } from "../../internal.js";
import type { FieldWithOps } from "../../internal.js";
//# sourceMappingURL=FieldWithOps.d.ts.map