/**
 * @import { Curve, CurveWithOps } from "../../internal.js"
 */
/**
 * @template T
 * @template {Curve<T>} [C=Curve<T>]
 * @param {C} curve
 * @returns {CurveWithOps<T>}
 */
export function makeCurveWithOps<T, C extends Curve<T> = Curve<T>>(curve: C): CurveWithOps<T>;
/**
 * @template T
 * @template {Curve<T>} [C=Curve<T>]
 * @implements {CurveWithOps<T>}
 */
export class CurveWithOpsImpl<T, C extends Curve<T> = Curve<T>> {
    /**
     * @param {C} curve
     */
    constructor(curve: C);
    /**
     * @readonly
     * @protected
     * @type {C}
     */
    protected readonly curve: C;
    /**
     * @type {T}
     */
    get ZERO(): T;
    /**
     * @param {T} point
     * @returns {boolean}
     */
    isZero(point: T): boolean;
    /**
     * @param {T} point
     * @returns {boolean}
     */
    isValidPoint(point: T): boolean;
    /**
     * @param {T} a
     * @param {T} b
     * @returns {boolean}
     */
    equals(a: T, b: T): boolean;
    /**
     * @param {T} a
     * @param {T} b
     * @returns {T}
     */
    add(a: T, b: T): T;
    /**
     * @param {T} a
     * @param {T} b
     * @returns {T}
     */
    subtract(a: T, b: T): T;
    /**
     * @param {T} a
     * @returns {T}
     */
    negate(a: T): T;
    /**
     * Double-and-add algorithm
     * Seems to have acceptable performance.
     * Not constant-time, but for the signing algorithms this scalar is always a random private number
     * @param {T} point
     * @param {bigint} s
     * @returns {T}
     */
    scale(point: T, s: bigint): T;
}
import type { Curve } from "../../internal.js";
import type { CurveWithOps } from "../../internal.js";
//# sourceMappingURL=CurveWithOps.d.ts.map