declare class Fraction {
    numer: number;
    denom: number;
    constructor(a: number, b: number);
    copy(): Fraction;
    reduce(): Fraction;
    equalTo(fraction: unknown): boolean;
    add(f: unknown, simplify?: boolean): Fraction;
    subtract(f: unknown, simplify?: boolean): Fraction;
    multiply(f: unknown, simplify?: boolean): Fraction;
    divide(f: unknown, simplify?: boolean): Fraction;
    pow(n: number, simplify?: boolean): Fraction;
    abs(): Fraction;
    valueOf(): number;
    toString(): string;
    toTex(): string;
    squareRootIsRational(): boolean;
    cubeRootIsRational(): boolean;
}

declare class Variable {
    variable: string;
    degree: number;
    constructor(variable: unknown);
    copy(): Variable;
    toString(): string;
    toTex(): string;
}

declare class Expression {
    #private;
    constants: Array<Fraction>;
    terms: Array<Term>;
    constructor(variable?: unknown);
    get variableNames(): string[];
    constant(): Fraction;
    simplify(): Expression;
    copy(): Expression;
    add(a: unknown, simplify?: boolean): Expression;
    subtract(a: unknown, simplify?: boolean): Expression;
    multiply(a: unknown, simplify?: boolean): Expression;
    divide(a: unknown, simplify?: boolean): Expression;
    pow(a: unknown, simplify?: boolean): Expression;
    eval(values: Record<string, number | Expression | Fraction>, simplify?: boolean): Expression;
    summation(variable: string, lower: number, upper: number, simplify?: boolean): Expression;
    toString(options?: {
        implicit: boolean;
    }): string;
    toTex(dict?: {
        multiplication: string;
    }): string;
    sort(): this;
    hasVariable(variable: string): boolean;
    onlyHasVariable(variable: string): boolean;
    noCrossProductsWithVariable(variable: string): boolean;
    noCrossProducts(): boolean;
    maxDegree(): number;
    maxDegreeOfVariable(variable: string): number;
    quadraticCoefficients(): {
        a: Fraction;
        b: Fraction;
        c: Fraction;
    };
    cubicCoefficients(): {
        a: Fraction;
        b: Fraction;
        c: Fraction;
        d: Fraction;
    };
}
declare class Term {
    #private;
    coefficients: Array<Fraction>;
    variables: Array<Variable>;
    constructor(variable?: unknown);
    coefficient(): Fraction;
    get variableNames(): string[];
    simplify(): Term;
    combineVars(): this;
    copy(): Term;
    add(term: unknown): Term;
    subtract(term: unknown): Term;
    multiply(a: unknown, simplify?: boolean): Term;
    divide(a: unknown, simplify?: boolean): Term;
    eval(values: Record<string, number | Expression | Fraction>, simplify?: boolean): Expression;
    hasVariable(variable: string): boolean;
    maxDegree(): number;
    maxDegreeOfVariable(variable: string): number;
    canBeCombinedWith(term: Term): boolean;
    onlyHasVariable(variable: string): boolean;
    sort(): this;
    toString(options?: {
        implicit: boolean;
    }): string;
    toTex(dict?: {
        multiplication: string;
    }): string;
}

declare class Equation {
    #private;
    lhs: Expression;
    rhs: Expression;
    constructor(lhs: unknown, rhs: unknown);
    get variableNames(): string[];
    copy(): Equation;
    /**
     * Solve the equation for the given variable.
     *
     * If the variable only occurs at degree 1 and its coefficient is a monomial
     * in other variables, like `a` in `ax + b = c`, the solution is expressed
     * using that coefficient, for example `c/a - b/a`. Since the coefficient
     * is symbolic, such a solution assumes that the coefficient is non-zero.
     * This assumption can only be checked once the solution is evaluated, where
     * a coefficient of zero results in a "Divide By Zero" error.
     */
    solveFor(variable: string, returnEquation?: boolean): Equation | Expression | Fraction | Fraction[] | number[] | undefined;
    /**
     * Divide given right-hand side by given coefficient.
     *
     * Defining this operation as a class member simplifies handling side-effects,
     * for example in case of inequations which reverse if the coefficient is
     * negative.
     * Note that you should be careful when introducing side-effects to
     * ensure the methods are operating on a copy to prevent inadvertent
     * modification.
     */
    divideRhsByCoefficient(rhs: Expression, coefficient: Fraction): Expression;
    eval(values: Record<string, number | Expression | Fraction>): Equation;
    evalToBoolean(values: Record<string, number | Expression | Fraction>): boolean;
    toString(options?: {
        implicit: boolean;
    }): string;
    toTex(): string;
    maxDegree(): number;
    maxDegreeOfVariable(variable: string): number;
    isLinear(): boolean;
    isQuadratic(variable: string): boolean;
}

declare function parse(input: string): Equation | Expression | undefined;
declare function toTex(input: unknown): string;

declare class Inequation extends Equation {
    #private;
    private isLessThan;
    private isInclusive;
    constructor(lhs: unknown, rhs: unknown, relation: string);
    copy(): Inequation;
    solveFor(variable: string): Inequation;
    /**
     * Solve for a variable with possible side-effects like changing inequality.
     * In order to preserve state, this should normally be invoked on a copy.
     *
     * Note that the visibility of this method had to be switched from `#` to
     * `private` due to an issue with the TypeScript compiler when it comes to
     * references to `super`:
     * https://github.com/microsoft/TypeScript/issues/44515
     */
    private solveForWithSideEffects;
    divideRhsByCoefficient(rhs: Expression, coefficient: Fraction): Expression;
    eval(values: Record<string, number | Expression | Fraction>): Inequation;
    evalToBoolean(values: Record<string, number | Expression | Fraction>): boolean;
    toString(options?: {
        implicit: boolean;
    }): string;
    toTex(): string;
}

declare class Parser {
    #private;
    private lexer;
    private current_token;
    constructor();
    update(): void;
    match(keyword: string): boolean;
    parse(input: string): Equation | Expression | undefined;
}

export { Equation, Expression, Fraction, Inequation, Parser, Term, Variable, parse, toTex };