@cortex-js/compute-engine 0.32.0 → 0.32.1

package/dist/types/compute-engine/global-types.d.ts

@@ -0,0 +1,2930 @@
+/* 0.32.1 */
+import type { OneOf } from '../common/one-of';
+import type { Expression, MathJsonNumberObject, MathJsonStringObject, MathJsonFunctionObject, MathJsonSymbolObject, MathJsonSymbol, MathJsonDictionaryObject } from '../math-json';
+import type { Type, TypeReference, TypeResolver, TypeString } from '../common/type/types';
+import type { BoxedType } from '../common/type/boxed-type';
+import type { ConfigurationChangeListener } from '../common/configuration-change';
+import type { ExactNumericValueData, NumericValue, NumericValueData } from './numeric-value/types';
+import type { BigNum, IBigNum, Rational } from './numerics/types';
+import type { LatexDictionaryEntry, LatexString, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/types';
+import type { IndexedLatexDictionary } from './latex-syntax/dictionary/definitions';
+/** @category Compiling */
+export type CompiledType = boolean | number | string | object;
+/** @category Compiling */
+export type JSSource = string;
+/** @category Compiling */
+export type CompiledExpression = {
+    evaluate?: (scope: {
+        [symbol: string]: BoxedExpression;
+    }) => number | BoxedExpression;
+};
+/**
+ * Map of `TensorDataType` to JavaScript type.
+ *
+ * @category Tensors */
+export type DataTypeMap = {
+    float64: number;
+    float32: number;
+    int32: number;
+    uint8: number;
+    complex128: Complex;
+    complex64: Complex;
+    bool: boolean;
+    expression: BoxedExpression;
+};
+/**
+ * The type of the cells in a tensor.
+ * @category Tensors */
+export type TensorDataType = keyof DataTypeMap;
+/** @internal */
+export type NestedArray<T> = NestedArray_<T>[];
+/** @internal */
+export type NestedArray_<T> = T | NestedArray_<T>[];
+/**
+ * A record representing the type, shape and data of a tensor.
+ * @category Tensors */
+export interface TensorData<DT extends TensorDataType> {
+    dtype: DT;
+    shape: number[];
+    rank?: number;
+    data: DataTypeMap[DT][];
+}
+/** @category Tensors */
+export interface TensorField<T extends number | Complex | BoxedExpression | boolean | string = number> {
+    readonly one: T;
+    readonly zero: T;
+    readonly nan: T;
+    cast(x: T, dtype: 'float64'): undefined | number;
+    cast(x: T, dtype: 'float32'): undefined | number;
+    cast(x: T, dtype: 'int32'): undefined | number;
+    cast(x: T, dtype: 'uint8'): undefined | number;
+    cast(x: T, dtype: 'complex128'): undefined | Complex;
+    cast(x: T, dtype: 'complex64'): undefined | Complex;
+    cast(x: T, dtype: 'bool'): undefined | boolean;
+    cast(x: T, dtype: 'expression'): undefined | BoxedExpression;
+    cast(x: T[], dtype: 'float64'): undefined | number[];
+    cast(x: T[], dtype: 'float32'): undefined | number[];
+    cast(x: T[], dtype: 'int32'): undefined | number[];
+    cast(x: T[], dtype: 'uint8'): undefined | number[];
+    cast(x: T[], dtype: 'complex128'): undefined | Complex[];
+    cast(x: T[], dtype: 'complex64'): undefined | Complex[];
+    cast(x: T[], dtype: 'bool'): undefined | boolean[];
+    cast(x: T[], dtype: 'expression'): undefined | BoxedExpression[];
+    cast(x: T | T[], dtype: TensorDataType): undefined | Complex | number | boolean | BoxedExpression | Complex[] | number[] | boolean[] | BoxedExpression[];
+    expression(x: T): BoxedExpression;
+    isZero(x: T): boolean;
+    isOne(x: T): boolean;
+    equals(lhs: T, rhs: T): boolean;
+    add(lhs: T, rhs: T): T;
+    addn(...xs: T[]): T;
+    neg(x: T): T;
+    sub(lhs: T, rhs: T): T;
+    mul(lhs: T, rhs: T): T;
+    muln(...xs: T[]): T;
+    div(lhs: T, rhs: T): T;
+    pow(rhs: T, n: number): T;
+    conjugate(x: T): T;
+}
+/**
+ * @category Tensors
+ */
+export interface Tensor<DT extends TensorDataType> extends TensorData<DT> {
+    dtype: DT;
+    shape: number[];
+    rank: number;
+    data: DataTypeMap[DT][];
+    readonly field: TensorField<DT>;
+    readonly expression: BoxedExpression;
+    readonly array: NestedArray<DataTypeMap[DT]>;
+    readonly isSquare: boolean;
+    readonly isSymmetric: boolean;
+    readonly isSkewSymmetric: boolean;
+    readonly isDiagonal: boolean;
+    readonly isUpperTriangular: boolean;
+    readonly isLowerTriangular: boolean;
+    readonly isTriangular: boolean;
+    readonly isIdentity: boolean;
+    readonly isZero: boolean;
+    at(...indices: number[]): DataTypeMap[DT] | undefined;
+    diagonal(axis1?: number, axis2?: number): undefined | DataTypeMap[DT][];
+    trace(axis1?: number, axis2?: number): undefined | DataTypeMap[DT];
+    reshape(...shape: number[]): Tensor<DT>;
+    slice(index: number): Tensor<DT>;
+    flatten(): DataTypeMap[DT][];
+    upcast<DT extends TensorDataType>(dtype: DT): Tensor<DT>;
+    transpose(axis1?: number, axis2?: number): undefined | Tensor<DT>;
+    conjugateTranspose(axis1?: number, axis2?: number): undefined | Tensor<DT>;
+    determinant(): undefined | DataTypeMap[DT];
+    inverse(): undefined | Tensor<DT>;
+    pseudoInverse(): undefined | Tensor<DT>;
+    adjugateMatrix(): undefined | Tensor<DT>;
+    minor(axis1: number, axis2: number): undefined | DataTypeMap[DT];
+    map1(fn: (lhs: DataTypeMap[DT], rhs: DataTypeMap[DT]) => DataTypeMap[DT], scalar: DataTypeMap[DT]): Tensor<DT>;
+    map2(fn: (lhs: DataTypeMap[DT], rhs: DataTypeMap[DT]) => DataTypeMap[DT], rhs: Tensor<DT>): Tensor<DT>;
+    add(other: Tensor<DT> | DataTypeMap[DT]): Tensor<DT>;
+    subtract(other: Tensor<DT> | DataTypeMap[DT]): Tensor<DT>;
+    multiply(other: Tensor<DT> | DataTypeMap[DT]): Tensor<DT>;
+    divide(other: Tensor<DT> | DataTypeMap[DT]): Tensor<DT>;
+    power(other: Tensor<DT> | DataTypeMap[DT]): Tensor<DT>;
+    equals(other: Tensor<DT>): boolean;
+}
+/**
+ * :::info[THEORY OF OPERATIONS]
+ *
+ * The `BoxedExpression` interface includes the methods and properties
+ * applicable to all kinds of expression. For example it includes `expr.symbol`
+ * which only applies to symbols or `expr.ops` which only applies to
+ * function expressions.
+ *
+ * When a property is not applicable to this `BoxedExpression` its value is
+ * `null`. For example `expr.symbol` for a `BoxedNumber` is `null`.
+ *
+ * This convention makes it convenient to manipulate expressions without
+ * having to check what kind of instance they are before manipulating them.
+ * :::
+ *
+ * :::info[THEORY OF OPERATIONS]
+ * A boxed expression can represent a canonical or a non-canonical
+ * expression. A non-canonical expression is a "raw" form of the
+ * expression. For example, the non-canonical representation of `\frac{10}{20}`
+ * is `["Divide", 10, 20]`. The canonical representation of the same
+ * expression is the boxed number `1/2`.
+ *
+ * The canonical representation of symbols and function expressions are
+ * bound to a definition. The definition contains metadata about the symbol
+ * or function operator, such as its type, its signature, and other attributes.
+ * The value of symbols are tracked in a separate table for each
+ * evaluation context.
+ *
+ * The binding only occurs when the expression is constructed, if it is created
+ * as a canonical expression. If the expression is constructed as a
+ * non-canonical expression, no binding is done.
+ *
+ * <!--
+ * Rules:
+ * - nothing should cause the binding to occur outside of the constructor
+ * - if an operation require a canonical expression (e.g. evaluate()),
+ *  it should return undefined or throw an error if the expression is not
+ *   canonical
+ * -->
+ *
+ *
+ * :::
+ *
+ * :::info[THEORY OF OPERATIONS]
+ * The **value** of an expression is a number, a string, a boolean or a tensor.
+ *
+ * The value of number literals and strings are themselves.
+ *
+ * A symbol can have a value associated with it, in which case the value
+ * of the symbol is the value associated with it.
+ *
+ * Some symbols (unknowns) are purely symbolic and have no value associated
+ * with them.
+ *
+ * Function expressions do not have a value associated with them.
+ * For example, `["Add", 2, 3]` has no value associated with it, it is a
+ * symbolic expression.
+ *
+ * Some properties of a Boxed Expression are only applicable if the expression
+ * has a value associated with it. For example, `expr.isNumber` is only
+ * applicable if the value of the expression is a number, that is if the
+ * expression is a number literal or a symbol with a numeric value.
+ *
+ * The following properties are applicable to expressions with a value:
+ * - `expr.isNumber`
+ * :::
+ *
+ * To create a boxed expression:
+ *
+ * ### `ce.box()` and `ce.parse()`
+ *
+ * Use `ce.box()` or `ce.parse()`.
+ *
+ * Use `ce.parse()` to get a boxed expression from a LaTeX string.
+ * Use `ce.box()` to get a boxed expression from a MathJSON expression.
+ *
+ * By default, the result of these methods is a canonical expression. For
+ * example, if it is a rational literal, it is reduced to its canonical form.
+ * If it is a function expression:
+ *    - the arguments are put in canonical form
+ *    - the arguments of commutative functions are sorted
+ *    - invisible operators are made explicit
+ *    - a limited number of core simplifications are applied,
+ *      for example rationals are reduced
+ *    - sequences are flattened: `["Add", 1, ["Sequence", 2, 3]]` is
+ *      transformed to `["Add", 1, 2, 3]`
+ *    - associative functions are flattened: `["Add", 1, ["Add", 2, 3]]` is
+ *      transformed to `["Add", 1, 2, 3]`
+ *    - symbols are **not** replaced with their values (unless they have
+ *       a `holdUntil` flag set to `never`).
+ *
+ * ### `ce.function()`
+ *
+ * This is a specialized version of `ce.box()` for creating a new function
+ * expression.
+ *
+ * The canonical handler of the operator is called.
+ *
+ *
+ * ### Algebraic methods (`expr.add()`, `expr.mul()`, etc...)
+ *
+ * The boxed expression have some algebraic methods, i.e. `add()`, `mul()`,
+ * `div()`, `pow()`, etc. These methods are suitable for
+ * internal calculations, although they may be used as part of the public
+ * API as well.
+ *
+ *    - a runtime error is thrown if the expression is not canonical
+ *    - the arguments are not evaluated
+ *    - the canonical handler (of the corresponding operation) is not called
+ *    - some additional simplifications over canonicalization are applied.
+ *      For example number literals are combined.
+ *      However, the result is exact, and no approximation is made. Use `.N()`
+ *      to get an approximate value.
+ *      This is equivalent to calling `simplify()` on the expression (but
+ *      without simplifying the arguments).
+ *    - sequences were already flattened as part of the canonicalization process
+ *
+ * For 'add()' and 'mul()', which take multiple arguments, separate functions
+ * are provided that take an array of arguments. They are equivalent
+ * to calling the boxed algebraic method, i.e. `ce.Zero.add(1, 2, 3)` and
+ * `add(1, 2, 3)` are equivalent.
+ *
+ * These methods are not equivalent to calling `expr.evaluate()` on the
+ * expression: evaluate will replace symbols with their values, and
+ * evaluate the expression.
+ *
+ * For algebraic functions (`add()`, `mul()`, etc..), use the corresponding
+ * canonicalization function, i.e. `canonicalAdd(a, b)` instead of
+ * `ce.function('Add', [a, b])`.
+ *
+ * Another option is to use the algebraic methods directly, i.e. `a.add(b)`
+ * instead of `ce.function('Add', [a, b])`. However, the algebraic methods will
+ * apply further simplifications which may or may not be desirable. For
+ * example, number literals will be combined.
+ *
+ * ### `ce._fn()`
+ *
+ * This method is a low level method to create a new function expression which
+ * is typically invoked in the canonical handler of an operator definition.
+ *
+ * The arguments are not modified. The expression is not put in canonical
+ * form. The canonical handler is *not* called.
+ *
+ * A canonical flag can be set when calling this method, but it only
+ * asserts that the function expression is canonical. The caller is responsible
+ * for ensuring that is the case.
+ *
+ *
+ *
+ * ### Canonical Handlers
+ *
+ * Canonical handlers are responsible for:
+ *    - validating the signature: this can involve checking the
+ *      number of arguments. It is recommended to avoid checking the
+ *      type of non-literal arguments, since the type of symbols or
+ *      function expressions may change. Similarly, the canonicalization
+ *      process should not rely on the value of or assumptions about non-literal
+ *      arguments.
+ *    - flattening sequences
+ *    - flattening arguments if the function is associative
+ *    - sort the arguments (if the function is commutative)
+ *    - calling `ce._fn()` to create a new function expression
+ *
+ * When the canonical handler is invoked, the arguments have been put in
+ * canonical form unless the `lazy` flag is set to `true`.
+ *
+ * Note that the result of a canonical handler should be a canonical expression,
+ * but not all arguments need to be canonical. For example, the arguments of
+ * `["Declare", "x", 2]` are not canonical, since `x` refers to the name
+ * of the symbol, not its value.
+ *
+ * @category Boxed Expression
+ *
+ */
+export interface BoxedExpression {
+    /** @internal */
+    readonly hash: number;
+    /**
+     * The Compute Engine instance associated with this expression provides
+     * a context in which to interpret it, such as definition of symbols
+     * and functions.
+     */
+    readonly engine: ComputeEngine;
+    /**
+     *
+     * Return a JavaScript primitive value for the expression, based on
+     * `Object.valueOf()`.
+     *
+     * This method is intended to make it easier to work with JavaScript
+     * primitives, for example when mixing JavaScript computations with
+     * symbolic computations from the Compute Engine.
+     *
+     * If the expression is a **machine number**, a **bignum**, or a **rational**
+     * that can be converted to a machine number, return a JavaScript `number`.
+     * This conversion may result in a loss of precision.
+     *
+     * If the expression is the **symbol `"True"`** or the **symbol `"False"`**,
+     * return `true` or `false`, respectively.
+     *
+     * If the expression is a **symbol with a numeric value**, return the numeric
+     * value of the symbol.
+     *
+     * If the expression is a **string literal**, return the string value.
+     *
+     * If the expression is a **tensor** (list of number or multidimensional
+     * array or matrix), return an array of numbers, or an array of
+     * arrays of numbers, or an array of arrays of arrays of numbers.
+     *
+     * If the expression is a function expression return a string representation
+     * of the expression.
+     *
+     * @category Primitive Methods
+     */
+    valueOf(): number | number[] | number[][] | number[][][] | string | boolean;
+    /** Similar to`expr.valueOf()` but includes a hint.
+     *
+     * @category Primitive Methods
+     */
+    [Symbol.toPrimitive](hint: 'number' | 'string' | 'default'): number | string | null;
+    /**
+     * Return an ASCIIMath representation of the expression. This string is
+     * suitable to be output to the console for debugging, for example.
+     *
+     * Based on `Object.toString()`.
+     *
+     * To get a LaTeX representation of the expression, use `expr.latex`.
+     *
+     * Note that lazy collections are eagerly evaluated.
+     *
+     * Used when coercing a `BoxedExpression` to a `String`.
+     *
+     * @category Primitive Methods
+     */
+    toString(): string;
+    /** Serialize to a LaTeX string.
+     *
+     * Note that lazy collections are eagerly evaluated.
+     *
+     * Will ignore any LaTeX metadata.
+     */
+    toLatex(options?: Partial<SerializeLatexOptions>): LatexString;
+    /** LaTeX representation of this expression.
+     *
+     * If the expression was parsed from LaTeX, the LaTeX representation is
+     * the same as the input LaTeX.
+     *
+     * To customize the serialization, use `expr.toLatex()`.
+     *
+     * Note that lazy collections are eagerly evaluated.
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     *
+     */
+    get latex(): LatexString;
+    /** Used by `JSON.stringify()` to serialize this object to JSON.
+     *
+     * Method version of `expr.json`.
+     *
+     * Based on `Object.toJSON()`.
+     *
+     * Note that lazy collections are *not* eagerly evaluated.
+     *
+     * @category Primitive Methods
+     */
+    toJSON(): Expression;
+    /** Serialize to a MathJSON expression with specified options */
+    toMathJson(options?: Readonly<Partial<JsonSerializationOptions>>): Expression;
+    /** MathJSON representation of this expression.
+     *
+     * This representation always use shorthands when possible. Metadata is not
+     * included.
+     *
+     * Numbers are converted to JavaScript numbers and may lose precision.
+     *
+     * The expression is represented exactly and no sugaring is applied. For
+     * example, `["Power", "x", 2]` is not represented as `["Square", "x"]`.
+     *
+     * For more control over the serialization, use `expr.toMathJson()`.
+     *
+     * Note that lazy collections are *not* eagerly evaluated.
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     *
+     */
+    readonly json: Expression;
+    /**
+     * Output to the console a string representation of the expression.
+     *
+     * Note that lazy collections are eagerly evaluated when printed.
+     *
+     */
+    print(): void;
+    /** If the expression was constructed from a LaTeX string, the verbatim LaTeX
+     *  string it was parsed from.
+     */
+    verbatimLatex?: string;
+    /** If `true`, this expression is in a canonical form. */
+    get isCanonical(): boolean;
+    /** For internal use only, set when a canonical expression is created.
+     * @internal
+     */
+    set isCanonical(val: boolean);
+    /** If `true`, this expression is in a structural form.
+     *
+     * The structural form of an expression is used when applying rules to
+     * an expression. For example, a rational number is represented as a
+     * function expression instead of a `BoxedExpression` object.
+     *
+     */
+    get isStructural(): boolean;
+    /**
+     * Return the canonical form of this expression.
+     *
+     * If a function expression or symbol, they are first bound with a definition
+     * in the current scope.
+     *
+     * When determining the canonical form the following operator definition
+     * flags are applied:
+     * - `associative`: \\( f(a, f(b), c) \longrightarrow f(a, b, c) \\)
+     * - `idempotent`: \\( f(f(a)) \longrightarrow f(a) \\)
+     * - `involution`: \\( f(f(a)) \longrightarrow a \\)
+     * - `commutative`: sort the arguments.
+     *
+     * If this expression is already canonical, the value of canonical is
+     * `this`.
+     *
+     * The arguments of a canonical function expression may not all be
+     * canonical, for example in the `["Declare", "i", 2]` expression,
+     * `i` is not canonical since it is used only as the name of a symbol, not
+     * as a (potentially) existing symbol.
+     *
+     * :::info[Note]
+     * Partially canonical expressions, such as those produced through
+     * `CanonicalForm`, also yield an expression which is marked as `canonical`.
+     * This means that, likewise for partially canonical expressions, the
+     * `canonical` property will return the self-same expression (and
+     * 'isCanonical' will also be true).
+     * :::
+     *
+     */
+    get canonical(): BoxedExpression;
+    /**
+     * Return the structural form of this expression.
+     *
+     * Some expressions, such as rational numbers, are represented with
+     * a `BoxedExpression` object. In some cases, for example when doing a
+     * structural comparison of two expressions, it is useful to have a
+     * structural representation of the expression where the rational numbers
+     * is represented by a function expression instead.
+     *
+     * If there is a structural representation of the expression, return it,
+     * otherwise return `this`.
+     *
+     */
+    get structural(): BoxedExpression;
+    /** `false` if this expression or any of its subexpressions is an `["Error"]`
+     * expression.
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions. For
+     * non-canonical expression, this may indicate a syntax error while parsing
+     * LaTeX. For canonical expression, this may indicate argument type
+     * mismatch, or missing or unexpected arguments.
+     * :::
+     *
+     */
+    readonly isValid: boolean;
+    /** If *true*, evaluating this expression has no side-effects (does not
+     * change the state of the Compute Engine).
+     *
+     * If *false*, evaluating this expression may change the state of the
+     * Compute Engine or it may return a different value each time it is
+     * evaluated, even if the state of the Compute Engine is the same.
+     *
+     * As an example, the ["Add", 2, 3]` function expression is pure, but
+     * the `["Random"]` function expression is not pure.
+     *
+     * For a function expression to be pure, the function itself (its operator)
+     * must be pure, and all of its arguments must be pure too.
+     *
+     * A pure function expression may return a different value each time it is
+     * evaluated if its arguments are not constant. For example, the
+     * `["Add", "x", 1]` function expression is pure, but it is not
+     * constant, because `x` is not constant.
+     *
+     * :::info[Note]
+     * Applicable to canonical expressions only
+     * :::
+     */
+    readonly isPure: boolean;
+    /**
+     * `True` if evaluating this expression always returns the same value.
+     *
+     * If *true* and a function expression, implies that it is *pure* and
+     * that all of its arguments are constant.
+     *
+     * Number literals, symbols with constant values, and pure numeric functions
+     * with constant arguments are all *constant*, i.e.:
+     * - `42` is constant
+     * - `Pi` is constant
+     * - `["Divide", "Pi", 2]` is constant
+     * - `x` is not constant, unless declared with a constant flag.
+     * - `["Add", "x", 2]` is either constant only if `x` is constant.
+     */
+    readonly isConstant: boolean;
+    /** All the `["Error"]` subexpressions.
+     *
+     * If an expression includes an error, the expression is also an error.
+     * In that case, the `this.isValid` property is `false`.
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     *
+     */
+    readonly errors: ReadonlyArray<BoxedExpression>;
+    /** All the subexpressions matching the named operator, recursively.
+     *
+     * Example:
+     *
+     * ```js
+     * const expr = ce.parse('a + b * c + d');
+     * const subexpressions = expr.getSubexpressions('Add');
+     * // -> `[['Add', 'a', 'b'], ['Add', 'c', 'd']]`
+     * ```
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     *
+     */
+    getSubexpressions(operator: string): ReadonlyArray<BoxedExpression>;
+    /** All the subexpressions in this expression, recursively
+     *
+     * Example:
+     *
+     * ```js
+     * const expr = ce.parse('a + b * c + d');
+     * const subexpressions = expr.subexpressions;
+     * // -> `[['Add', 'a', 'b'], ['Add', 'c', 'd'], 'a', 'b', 'c', 'd']`
+     * ```
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     *
+     */
+    readonly subexpressions: ReadonlyArray<BoxedExpression>;
+    /**
+     *
+     * All the symbols in the expression, recursively
+     *
+     * ```js
+     * const expr = ce.parse('a + b * c + d');
+     * const symbols = expr.symbols;
+     * // -> ['a', 'b', 'c', 'd']
+     * ```
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     *
+     */
+    readonly symbols: ReadonlyArray<string>;
+    /**
+     * All the symbols used in the expression that do not have a value
+     * associated with them, i.e. they are declared but not defined.
+     */
+    readonly unknowns: ReadonlyArray<string>;
+    /**
+     * Return `true` if this expression is a number literal, for example
+     * `2`, `3.14`, `1/2`, `√2` etc.
+     *
+     * When `true`, `expr.numericValue` is not `null`.
+     *
+     * @category Numeric Expression
+     *
+     */
+    readonly isNumberLiteral: boolean;
+    /**
+     * Return the value of this expression, if a number literal.
+     *
+     * Note it is possible for `expr.numericValue` to be `null`, and for
+     * `expr.isNotZero` to be true. For example, when a symbol has been
+     * defined with an assumption.
+     *
+     * Conversely, `expr.isNumber` may be true even if `expr.numericValue` is
+     * `null`, for example the symbol `Pi` return `true` for `isNumber` but
+     * `expr.numericValue` is `null` (it's a symbol, not a number literal).
+     * Its value can be accessed with `expr.value`.
+     *
+     * To check if an expression is a number literal, use `expr.isNumberLiteral`.
+     * If `expr.isNumberLiteral` is `true`, `expr.numericValue` is not `null`.
+     *
+     * @category Numeric Expression
+     *
+     */
+    readonly numericValue: number | NumericValue | null;
+    /**
+     * Attempt to factor a numeric coefficient `c` and a `rest` out of a
+     * canonical expression such that `rest.mul(c)` is equal to `this`.
+     *
+     * Attempts to make `rest` a positive value (i.e. pulls out negative sign).
+     *
+     *```json
+     * ['Multiply', 2, 'x', 3, 'a']
+     *    -> [NumericValue(6), ['Multiply', 'x', 'a']]
+     *
+     * ['Divide', ['Multiply', 2, 'x'], ['Multiply', 3, 'y', 'a']]
+     *    -> [NumericValue({rational: [2, 3]}), ['Divide', 'x', ['Multiply, 'y', 'a']]]
+     * ```
+     */
+    toNumericValue(): [NumericValue, BoxedExpression];
+    /**
+     * If the value of this expression is not an **integer** return `undefined`.
+     *
+     * @category Numeric Expression
+     */
+    readonly isEven: boolean | undefined;
+    /**
+     * If the value of this expression is not an **integer** return `undefined`.
+     *
+     * @category Numeric Expression
+     */
+    readonly isOdd: boolean | undefined;
+    /**
+     * Return the real part of the value of this expression, if a number.
+     *
+     * Otherwise, return `NaN` (not a number).
+     *
+     * @category Numeric Expression
+     */
+    readonly re: number;
+    /**
+     * If value of this expression is a number, return the imaginary part of the
+     * value. If the value is a real number, the imaginary part is 0.
+     *
+     * Otherwise, return `NaN` (not a number).
+     *
+     * @category Numeric Expression
+     */
+    readonly im: number;
+    /**
+     * If the value of this expression is a number, return the real part of the
+     * value as a `BigNum`.
+     *
+     * If the value is not available as a bignum return `undefined`. That is,
+     * the value is not upconverted to a bignum.
+     *
+     * To get the real value either as a bignum or a number, use
+     * `expr.bignumRe ?? expr.re`.
+     *
+     * When using this pattern, the value is returned as a bignum if available,
+     * otherwise as a number or `NaN` if the value is not a number.
+     *
+     * @category Numeric Expression
+     *
+     */
+    readonly bignumRe: BigNum | undefined;
+    /**
+     * If the value of this expression is a number, return the imaginary part as
+     * a `BigNum`.
+     *
+     * It may be 0 if the number is real.
+     *
+     * If the value of the expression is not a number or the value is not
+     * available as a bignum return `undefined`. That is, the value is not
+     * upconverted to a bignum.
+     *
+     * To get the imaginary value either as a bignum or a number, use
+     * `expr.bignumIm ?? expr.im`.
+     *
+     * When using this pattern, the value is returned as a bignum if available, otherwise as a number or `NaN` if the value is not a number.
+     *
+     * @category Numeric Expression
+     */
+    readonly bignumIm: BigNum | undefined;
+    /**
+     * Return the sign of the expression.
+     *
+     * Note that complex numbers have no natural ordering, so if the value is an
+     * imaginary number (a complex number with a non-zero imaginary part),
+     * `this.sgn` will return `unsigned`.
+     *
+     * If a symbol, this does take assumptions into account, that is `this.sgn`
+     * will return `positive` if the symbol is assumed to be positive
+     * using `ce.assume()`.
+     *
+     * Non-canonical expressions return `undefined`.
+     *
+     * @category Numeric Expression
+     *
+     */
+    readonly sgn: Sign | undefined;
+    /** The value of this expression is > 0, same as `isGreaterEqual(0)`
+     *
+     * @category Numeric Expression
+     */
+    readonly isPositive: boolean | undefined;
+    /** The value of this expression is >= 0, same as `isGreaterEqual(0)`
+     *
+     * @category Numeric Expression
+     */
+    readonly isNonNegative: boolean | undefined;
+    /** The value of this expression is &lt; 0, same as `isLess(0)`
+     *
+     * @category Numeric Expression
+     */
+    readonly isNegative: boolean | undefined;
+    /** The  value of this expression is &lt;= 0, same as `isLessEqual(0)`
+     *
+     * @category Numeric Expression
+     */
+    readonly isNonPositive: boolean | undefined;
+    /** Negate (additive inverse) */
+    neg(): BoxedExpression;
+    /** Inverse (multiplicative inverse) */
+    inv(): BoxedExpression;
+    /** Absolute value */
+    abs(): BoxedExpression;
+    /** Addition */
+    add(rhs: number | BoxedExpression): BoxedExpression;
+    /** Subtraction */
+    sub(rhs: BoxedExpression): BoxedExpression;
+    /** Multiplication */
+    mul(rhs: NumericValue | number | BoxedExpression): BoxedExpression;
+    /** Division */
+    div(rhs: number | BoxedExpression): BoxedExpression;
+    /** Power */
+    pow(exp: number | BoxedExpression): BoxedExpression;
+    /** Exponentiation */
+    root(exp: number | BoxedExpression): BoxedExpression;
+    /** Square root */
+    sqrt(): BoxedExpression;
+    /** Logarithm (natural by default) */
+    ln(base?: number | BoxedExpression): BoxedExpression;
+    /**
+     * Return this expression expressed as a numerator.
+     */
+    get numerator(): BoxedExpression;
+    /**
+     * Return this expression expressed as a denominator.
+     */
+    get denominator(): BoxedExpression;
+    /**
+     * Return this expression expressed as a numerator and denominator.
+     */
+    get numeratorDenominator(): [BoxedExpression, BoxedExpression];
+    /** If this expression is a symbol, return the name of the symbol as a string.
+     * Otherwise, return `null`.
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     *
+     * @category Symbol Expression
+     *
+     */
+    readonly symbol: string | null;
+    /** If this expression is a string, return the value of the string.
+      * Otherwise, return `null`.
+      *
+      * :::info[Note]
+      * Applicable to canonical and non-canonical expressions.
+      * :::
+  
+      * @category String Expression
+      *
+      */
+    readonly string: string | null;
+    /**
+     * Return `true` if this expression is a function expression.
+     *
+     * If `true`, `expr.ops` is not `null`, and `expr.operator` is the name
+     * of the function.
+     *
+     * @category Function Expression
+     */
+    readonly isFunctionExpression: boolean;
+    /**
+     * The name of the operator of the expression.
+     *
+     * For example, the name of the operator of `["Add", 2, 3]` is `"Add"`.
+     *
+     * A string literal has a `"String"` operator.
+     *
+     * A symbol has a `"Symbol"` operator.
+     *
+     * A number has a `"Number"`, `"Real"`, `"Rational"` or `"Integer"` operator; amongst some others.
+     * Practically speaking, for fully canonical and valid expressions, all of these are likely to
+     * collapse to `"Number"`.
+     *
+     * @category Function Expression
+     */
+    readonly operator: string;
+    /** The list of operands of the function.
+     *
+     * If the expression is not a function, return `null`.
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     *
+     * @category Function Expression
+     *
+     */
+    readonly ops: null | ReadonlyArray<BoxedExpression>;
+    /** If this expression is a function, the number of operands, otherwise 0.
+     *
+     * Note that a function can have 0 operands, so to check if this expression
+     * is a function, check if `this.ops !== null` instead.
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     *
+     * @category Function Expression
+     *
+     */
+    readonly nops: number;
+    /** First operand, i.e.`this.ops[0]`.
+     *
+     * If there is no first operand, return the symbol `Nothing`.
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     *
+     * @category Function Expression
+     *
+     *
+     */
+    readonly op1: BoxedExpression;
+    /** Second operand, i.e.`this.ops[1]`
+     *
+     * If there is no second operand, return the symbol `Nothing`.
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     *
+     * @category Function Expression
+     *
+     *
+     */
+    readonly op2: BoxedExpression;
+    /** Third operand, i.e. `this.ops[2]`
+     *
+     * If there is no third operand, return the symbol `Nothing`.
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     *
+     * @category Function Expression
+     *
+     *
+     */
+    readonly op3: BoxedExpression;
+    /** If true, the expression has its own local scope that can be used
+     * for local variables and arguments. Only true if the expression is a
+     * function expression.
+     */
+    readonly isScoped: boolean;
+    /** If this expression has a local scope, return it. */
+    get localScope(): Scope | undefined;
+    /**
+     * Replace all the symbols in the expression as indicated.
+     *
+     * Note the same effect can be achieved with `this.replace()`, but
+     * using `this.subs()` is more efficient and simpler, but limited
+     * to replacing symbols.
+     *
+     * The result is bound to the current scope, not to `this.scope`.
+     *
+     * If `options.canonical` is not set, the result is canonical if `this`
+     * is canonical.
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     *
+     * If this is a function, an empty substitution is given, and the computed value of `canonical`
+     * does not differ from that of this expr.: then a call this method is analagous to requesting a
+     * *clone*.
+     * :::
+     *
+     */
+    subs(sub: Substitution, options?: {
+        canonical?: CanonicalOptions;
+    }): BoxedExpression;
+    /**
+     * Recursively replace all the subexpressions in the expression as indicated.
+     *
+     * To remove a subexpression, return an empty `["Sequence"]` expression.
+     *
+     * The `canonical` option is applied to each function subexpression after
+     * the substitution is applied.
+     *
+     * If no `options.canonical` is set, the result is canonical if `this`
+     * is canonical.
+     *
+     * **Default**: `{ canonical: this.isCanonical, recursive: true }`
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     */
+    map(fn: (expr: BoxedExpression) => BoxedExpression, options?: {
+        canonical: CanonicalOptions;
+        recursive?: boolean;
+    }): BoxedExpression;
+    /**
+     * Transform the expression by applying one or more replacement rules:
+     *
+     * - If the expression matches the `match` pattern and the `condition`
+     *  predicate is true, replace it with the `replace` pattern.
+     *
+     * - If no rules apply, return `null`.
+     *
+     * See also `expr.subs()` for a simple substitution of symbols.
+     *
+     * Procedure for the determining the canonical-status of the input expression and replacements:
+     *
+     * - If `options.canonical` is set, the *entire expr.* is canonicalized to this degree: whether
+     * the replacement occurs at the top-level, or within/recursively.
+     *
+     * - If otherwise, the *direct replacement will be canonical* if either the 'replaced' expression
+     * is canonical, or the given replacement (- is a BoxedExpression and -) is canonical.
+     * Notably also, if this replacement takes place recursively (not at the top-level), then exprs.
+     * containing the replaced expr. will still however have their (previous) canonical-status
+     * *preserved*... unless this expr. was previously non-canonical, and *replacements have resulted
+     * in canonical operands*. In this case, an expr. meeting this criteria will be updated to
+     * canonical status. (Canonicalization is opportunistic here, in other words).
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     *
+     * To match a specific symbol (not a wildcard pattern), the `match` must be
+     * a `BoxedExpression` (e.g., `{ match: ce.box('x'), replace: ... }`).
+     * For simple symbol substitution, consider using `subs()` instead.
+     * :::
+     */
+    replace(rules: BoxedRuleSet | Rule | Rule[], options?: Partial<ReplaceOptions>): null | BoxedExpression;
+    /**
+     * True if the expression includes a symbol `v` or a function operator `v`.
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     */
+    has(v: string | string[]): boolean;
+    /** Structural/symbolic equality (weak equality).
+     *
+     * `ce.parse('1+x', {canonical: false}).isSame(ce.parse('x+1', {canonical: false}))` is `false`.
+     *
+     * See `expr.isEqual()` for mathematical equality.
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     *
+     * @category Relational Operator
+     */
+    isSame(rhs: BoxedExpression): boolean;
+    /**
+     * Equivalent to `BoxedExpression.isSame()` but the argument can be
+     * a JavaScript primitive. For example, `expr.is(2)` is equivalent to
+     * `expr.isSame(ce.number(2))`.
+     *
+     * @category Primitive Methods
+     *
+     */
+    is(other: BoxedExpression | number | bigint | boolean | string): boolean;
+    /**
+     * If this expression matches `pattern`, return a substitution that makes
+     * `pattern` equal to `this`. Otherwise return `null`.
+     *
+     * If `pattern` includes wildcards (symbols that start
+     * with `_`), the substitution will include a prop for each matching named
+     * wildcard.
+     *
+     * If this expression matches `pattern` but there are no named wildcards,
+     * return the empty substitution, `{}`.
+     *
+     * Read more about [**patterns and rules**](/compute-engine/guides/patterns-and-rules/).
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     *
+     */
+    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    /** If this expression is a tensor, return the tensor data.
+     * Otherwise, return `null`.
+     *
+     * :::info[Note]
+     * Applicable to canonical and non-canonical expressions.
+     * :::
+     *
+     * @category Tensor Expression
+     *
+     */
+    readonly tensor: null | Tensor<any>;
+    /**
+     *
+     * The **shape** describes the **axes** of the expression, where each axis
+     * represent a way to index the elements of the expression.
+     *
+     * When the expression is a scalar (number), the shape is `[]`.
+     *
+     * When the expression is a vector of length `n`, the shape is `[n]`.
+     *
+     * When the expression is a `n` by `m` matrix, the shape is `[n, m]`.
+     *
+     * @category Tensor Expression
+     *
+     */
+    readonly shape: number[];
+    /**
+     * The **rank** refers to the number of dimensions (or axes) of the
+     * expression.
+     *
+     * Return 0 for a scalar, 1 for a vector, 2 for a matrix, > 2 for
+     * a multidimensional matrix.
+     *
+     * The rank is equivalent to the length of `expr.shape`
+     *
+     * :::info[Note]
+     * There are several definitions of rank in the literature.
+     * For example, the row rank of a matrix is the number of linearly
+     * independent rows. The rank can also refer to the number of non-zero
+     * singular values of a matrix.
+     * :::
+     *
+     * @category Tensor Expression
+     * */
+    readonly rank: number;
+    /**
+     *
+     * The value of both expressions are compared.
+     *
+     * If the expressions cannot be compared, return `undefined`
+     *
+     * @category Relational Operator
+     */
+    isLess(other: number | BoxedExpression): boolean | undefined;
+    /**
+     * The value of both expressions are compared.
+     *
+     * If the expressions cannot be compared, return `undefined`
+     * @category Relational Operator
+     */
+    isLessEqual(other: number | BoxedExpression): boolean | undefined;
+    /**
+     * The value of both expressions are compared.
+     *
+     * If the expressions cannot be compared, return `undefined`
+     * @category Relational Operator
+     */
+    isGreater(other: number | BoxedExpression): boolean | undefined;
+    /**
+     * The value of both expressions are compared.
+     *
+     * If the expressions cannot be compared, return `undefined`
+     * @category Relational Operator
+     */
+    isGreaterEqual(other: number | BoxedExpression): boolean | undefined;
+    /**
+     * If true, the value of this expression is "Not a Number".
+     *
+     * A value representing undefined result of computations, such as `0/0`,
+     * as per the floating point format standard IEEE-754.
+     *
+     * Note that if `isNaN` is true, `isNumber` is also true (yes, `NaN` is a
+     * number).
+     *
+     * @category Numeric Expression
+     *
+     */
+    readonly isNaN: boolean | undefined;
+    /**
+     * The numeric value of this expression is `±Infinity` or ComplexInfinity.
+     *
+     * @category Numeric Expression
+     */
+    readonly isInfinity: boolean | undefined;
+    /** This expression is a number, but not `±Infinity`, `ComplexInfinity` or
+     *  `NaN`
+     *
+     * @category Numeric Expression
+     */
+    readonly isFinite: boolean | undefined;
+    /**
+     * Wikidata identifier.
+     *
+     * If not a canonical expression, return `undefined`.
+     *
+     */
+    readonly wikidata: string | undefined;
+    /** An optional short description if a symbol or function expression.
+     *
+     * May include markdown. Each string is a paragraph.
+     *
+     * If not a canonical expression, return `undefined`.
+     *
+     */
+    readonly description: undefined | string[];
+    /** An optional URL pointing to more information about the symbol or
+     *  function operator.
+     *
+     * If not a canonical expression, return `undefined`.
+     *
+     */
+    readonly url: string | undefined;
+    /** Expressions with a higher complexity score are sorted
+     * first in commutative functions
+     *
+     * If not a canonical expression, return `undefined`.
+     */
+    readonly complexity: number | undefined;
+    /**
+     * For symbols and functions, a definition associated with the
+     * expression. `this.baseDefinition` is the base class of symbol and function
+     * definition.
+     *
+     * If not a canonical expression, return `undefined`.
+     *
+     */
+    readonly baseDefinition: BoxedBaseDefinition | undefined;
+    /**
+     * For function expressions, the definition of the operator associated with
+     * the expression. For symbols, the definition of the symbol if it is an
+     * operator, for example `"Sin"`.
+     *
+     * If not a canonical expression or not a function expression,
+     * its value is `undefined`.
+     *
+     */
+    readonly operatorDefinition: BoxedOperatorDefinition | undefined;
+    /**
+     * For symbols, a definition associated with the expression, if it is
+     * not an operator.
+     *
+     * If not a canonical expression, or not a value, its value is `undefined`.
+     *
+     */
+    readonly valueDefinition: BoxedValueDefinition | undefined;
+    /**
+     *
+     * Infer the type of this expression.
+     *
+     * For symbols, inference may take place for undeclared symbols,
+     * symbols with an `unknown` type, or symbols with an inferred type.
+     *
+     * Constant symbols always have a defined type, and will return `false`.
+     *
+     * For functions, inference only takes place if it has an *inferred
+     * signature*.
+     *
+     *
+     * For a successful inference, *narrows* the type for symbols,
+     * and for functions, narrows the *(return) type*.
+     *
+     * Subsequent inferences can be made and will refine previous ones if valid.
+     *
+     * If the given type is incompatible with the declared or previously inferred
+     * type, return `false`.
+     *
+     *
+     * @internal
+     */
+    infer(t: Type, inferenceMode?: 'narrow' | 'widen'): boolean;
+    /**
+     * Update the definition associated with this expression, using the
+     * current scope (`ce.context`).
+     *
+     * @internal
+     */
+    bind(): void;
+    /**
+     *
+     * Reset the cached value associated with this expression.
+     *
+     * Use when the environment, for example the precision, has changed to
+     * force the expression to be re-evaluated.
+     *
+     * @internal
+     */
+    reset(): void;
+    /**
+     * Return a simpler form of this expression.
+     *
+     * A series of rewriting rules are applied repeatedly, until no more rules
+     * apply.
+     *
+     * The values assigned to symbols and the assumptions about symbols may be
+     * used, for example `expr.isInteger` or `expr.isPositive`.
+     *
+     * No calculations involving decimal numbers (numbers that are not
+     * integers) are performed but exact calculations may be performed,
+     * for example:
+     *
+     * $$ \sin(\frac{\pi}{4}) \longrightarrow \frac{\sqrt{2}}{2} $$.
+     *
+     * The result is canonical.
+     *
+     * To manipulate symbolically non-canonical expressions, use `expr.replace()`.
+     *
+     */
+    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
+    /**
+     * Expand the expression: distribute multiplications over additions,
+     * and expand powers.
+     */
+    expand(): BoxedExpression;
+    /**
+     * Return the value of the canonical form of this expression.
+     *
+     * A pure expression always returns the same value (provided that it
+     * remains constant / values of sub-expressions or symbols do not change),
+     * and has no side effects.
+     *
+     * Evaluating an impure expression may return a varying value, and may have
+     * some side effects such as adjusting symbol assumptions.
+     *
+     * To perform approximate calculations, use `expr.N()` instead,
+     * or call with `options.numericApproximation` to `true`.
+     *
+     * It is possible that the result of `expr.evaluate()` may be the same as
+     * `expr.simplify()`.
+     *
+     * The result is in canonical form.
+     *
+     */
+    evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
+    /** Asynchronous version of `evaluate()`.
+     *
+     * The `options` argument can include a `signal` property, which is an
+     * `AbortSignal` object. If the signal is aborted, a `CancellationError` is thrown.
+     *
+     */
+    evaluateAsync(options?: Partial<EvaluateOptions>): Promise<BoxedExpression>;
+    /** Return a numeric approximation of the canonical form of this expression.
+     *
+     * Any necessary calculations, including on decimal numbers (non-integers),
+     * are performed.
+     *
+     * The calculations are performed according to the
+     * `precision` property of the `ComputeEngine`.
+     *
+     * To only perform exact calculations, use `this.evaluate()` instead.
+     *
+     * If the function is not numeric, the result of `this.N()` is the same as
+     * `this.evaluate()`.
+     *
+     * The result is in canonical form.
+     */
+    N(): BoxedExpression;
+    /**
+     * Compile the expression to a JavaScript function.
+     *
+     * The function takes an object as argument, with the keys being the
+     * symbols in the expression, and returns the value of the expression.
+     *
+     *
+     * ```javascript
+     * const expr = ce.parse("x^2 + y^2");
+     * const f = expr.compile();
+     * console.log(f({x: 2, y: 3}));
+     * // -> 13
+     * ```
+     *
+     * If the expression is a function literal, the function takes the
+     * arguments of the function as arguments, and returns the value of the
+     * expression.
+     *
+     * ```javascript
+     * const expr = ce.parse("(x) \mapsto 2x");
+     * const f = expr.compile();
+     * console.log(f(42));
+     * // -> 84
+     * ```
+     *
+     * If the expression cannot be compiled, a JS function is returned that
+     * falls back to the interpreting the expression, unless the
+     * `options.fallback` is set to `false`. If it is set to `false`, the
+     * function will throw an error if it cannot be compiled.
+     *
+     */
+    compile(options?: {
+        to?: 'javascript' | 'wgsl' | 'python' | 'webassembly';
+        functions?: Record<MathJsonSymbol, JSSource | ((...any: any[]) => any)>;
+        vars?: Record<MathJsonSymbol, JSSource>;
+        imports?: ((...any: any[]) => any)[];
+        preamble?: string;
+        fallback?: boolean;
+    }): ((...args: any[]) => any) & {
+        isCompiled?: boolean;
+    };
+    /**
+     * If this is an equation, solve the equation for the variables in vars.
+     * Otherwise, solve the equation `this = 0` for the variables in vars.
+     *
+     *
+     * ```javascript
+     * const expr = ce.parse("x^2 + 2*x + 1 = 0");
+     * console.log(expr.solve("x"));
+     * ```
+     *
+     *
+     */
+    solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
+    /**
+     * If this expression is a number literal, a string literal or a function
+     *  literal, return the expression.
+     *
+     * If the expression is a symbol, return the value of the symbol.
+     *
+     * Otherwise, the expression is a symbolic expression, including an unknown
+     * symbol, i.e. a symbol with no value, return `undefined`.
+     *
+     */
+    get value(): BoxedExpression | undefined;
+    /**
+     * If the expression is a symbol, set the value of the symbol.
+     *
+     * Will throw a runtime error if either not a symbol, or a symbol with the
+     * `constant` flag set to `true`.
+     *
+     * Setting the value of a symbol results in the forgetting of all assumptions
+     * about it in the current scope.
+     *
+     */
+    set value(value: boolean | string | BigNum | OneOf<[
+        {
+            re: number;
+            im: number;
+        },
+        {
+            num: number;
+            denom: number;
+        },
+        BoxedExpression
+    ]> | number[] | number | undefined);
+    /**
+     *
+     * The type of the value of this expression.
+     *
+     * If a symbol the type of the value of the symbol.
+     *
+     * If a function expression, the type of the value of the function
+     * (the result type).
+     *
+     * If a symbol with a `"function"` type (a function literal), returns the
+     * signature.
+     *
+     * If not valid, return `"error"`.
+     *
+     * If the type is not known, return `"unknown"`.
+     *
+     * @category Type Properties
+     */
+    get type(): BoxedType;
+    set type(type: Type | TypeString | BoxedType);
+    /** `true` if the value of this expression is a number.
+     *
+     *
+     * Note that in a fateful twist of cosmic irony, `NaN` ("Not a Number")
+     * **is** a number.
+     *
+     * If `isNumber` is `true`, this indicates that evaluating the expression
+     * will return a number.
+     *
+     * This does not indicate that the expression is a number literal. To check
+     * if the expression is a number literal, use `expr.isNumberLiteral`.
+     *
+     * For example, the expression `["Add", 1, "x"]` is a number if "x" is a
+     * number and `expr.isNumber` is `true`, but `isNumberLiteral` is `false`.
+     *
+     * @category Type Properties
+     */
+    readonly isNumber: boolean | undefined;
+    /**
+     *
+     * The value of this expression is an element of the set ℤ: ...,-2, -1, 0, 1, 2...
+     *
+     * Note that ±∞ and NaN are not integers.
+     *
+     * @category Type Properties
+     *
+     */
+    readonly isInteger: boolean | undefined;
+    /** The value of this expression is an element of the set ℚ, p/q with p ∈ ℕ, q ∈ ℤ ⃰  q >= 1
+     *
+     * Note that every integer is also a rational.
+     *
+     * This is equivalent to `this.type === "rational" || this.type === "integer"`
+     *
+     * Note that ±∞ and NaN are not rationals.
+     *
+     * @category Type Properties
+     *
+     */
+    readonly isRational: boolean | undefined;
+    /**
+     * The value of this expression is a real number.
+     *
+     * This is equivalent to `this.type === "rational" || this.type === "integer" || this.type === "real"`
+     *
+     * Note that ±∞ and NaN are not real numbers.
+     *
+     * @category Type Properties
+     */
+    readonly isReal: boolean | undefined;
+    /** Mathematical equality (strong equality), that is the value
+     * of this expression and the value of `other` are numerically equal.
+     *
+     * Both expressions are evaluated and the result is compared numerically.
+     *
+     * Numbers whose difference is less than `engine.tolerance` are
+     * considered equal. This tolerance is set when the `engine.precision` is
+     * changed to be such that the last two digits are ignored.
+     *
+     * Evaluating the expressions may be expensive. Other options to consider
+     * to compare two expressions include:
+     * - `expr.isSame(other)` for a structural comparison which does not involve
+     *   evaluating the expressions.
+     * - `expr.is(other)` for a comparison of a number literal
+     *
+     * **Examples**
+     *
+     * ```js
+     * let expr = ce.parse('2 + 2');
+     * console.log(expr.isEqual(4)); // true
+     * console.log(expr.isSame(ce.parse(4))); // false
+     * console.log(expr.is(4)); // false
+     *
+     * expr = ce.parse('4');
+     * console.log(expr.isEqual(4)); // true
+     * console.log(expr.isSame(ce.parse(4))); // true
+     * console.log(expr.is(4)); // true (fastest)
+     *
+     * ```
+     *
+     * @category Relational Operator
+     */
+    isEqual(other: number | BoxedExpression): boolean | undefined;
+    /**
+     * Is `true` if the expression is a collection.
+     *
+     * When `isCollection` is `true`, the expression:
+     *
+     * - has an `each()` method that returns a generator over the elements
+     *   of the collection.
+     * - has a `size` property that returns the number of elements in the
+     *   collection.
+     * - has a `contains(other)` method that returns `true` if the `other`
+     *   expression is in the collection.
+     *
+     */
+    isCollection: boolean;
+    /**
+     * Is `true` if this is an indexed collection, such as a list, a vector,
+     * a matrix, a tuple, etc...
+     *
+     * The elements of an indexed collection can be accessed by a one-based
+     * index.
+     *
+     * When `isIndexedCollection` is `true`, the expression:
+     * - has an `each()`, `size()` and `contains(rhs)` methods
+     *    as for a collection.
+     * - has an `at(index: number)` method that returns the element at the
+     *    specified index.
+     * - has an `indexWhere(predicate: (element: BoxedExpression) => boolean)`
+     *    method that returns the index of the first element that matches the
+     *    predicate.
+     */
+    isIndexedCollection: boolean;
+    /**
+     * False if not a collection, or if the elements of the collection
+     * are not computed lazily.
+     *
+     * The elements of a lazy collection are computed on demand, when
+     * iterating over the collection using `each()`.
+     *
+     * Use `ListFrom` and related functions to create eager collections from
+     * lazy collections.
+     *
+     */
+    isLazyCollection: boolean;
+    /**
+     * If this is a collection, return an iterator over the elements of the
+     * collection.
+     *
+     * ```js
+     * const expr = ce.parse('[1, 2, 3, 4]');
+     * for (const e of expr.each()) {
+     *  console.log(e);
+     * }
+     * ```
+     */
+    each(): Generator<BoxedExpression>;
+    /**
+     * If this is a collection, return true if the `rhs` expression is in the
+     * collection.
+     *
+     * Return `undefined` if the membership cannot be determined without
+     * iterating over the collection.
+     */
+    contains(rhs: BoxedExpression): boolean | undefined;
+    /**
+     * Check if this collection is a subset of another collection.
+     *
+     * @param other The other collection to check against.
+     * @param strict If true, the subset relation is strict (i.e., proper subset).
+     */
+    subsetOf(other: BoxedExpression, strict: boolean): boolean | undefined;
+    /**
+     * If this is a collection, return the number of elements in the collection.
+     *
+     * If the collection is infinite, return `Infinity`.
+     *
+     * If the number of elements cannot be determined, return `undefined`, for
+     * example, if the collection is lazy and not finite and the size cannot
+     * be determined without iterating over the collection.
+     *
+     */
+    get count(): number | undefined;
+    /** If this is a finite collection, return true. */
+    isFiniteCollection: boolean | undefined;
+    /** If this is an empty collection, return true.
+     *
+     * An empty collection has a size of 0.
+     */
+    isEmptyCollection: boolean | undefined;
+    /** If this is an indexed collection, return the element at the specified
+     *  index. The first element is at index 1.
+     *
+     * If the index is negative, return the element at index `size() + index + 1`.
+     *
+     * The last element is at index -1.
+     *
+     */
+    at(index: number): BoxedExpression | undefined;
+    /** If this is a keyed collection (map, record, tuple), return the value of
+     * the corresponding key.
+     *
+     * If `key` is a `BoxedExpression`, it should be a string.
+     *
+     */
+    get(key: string | BoxedExpression): BoxedExpression | undefined;
+    /**
+     * If this is an indexed collection, return the index of the first element
+     * that matches the predicate.
+     *
+     */
+    indexWhere(predicate: (element: BoxedExpression) => boolean): number | undefined;
+}
+/** A semi boxed expression is a MathJSON expression which can include some
+ * boxed terms.
+ *
+ * This is convenient when creating new expressions from portions
+ * of an existing `BoxedExpression` while avoiding unboxing and reboxing.
+ *
+ * @category Boxed Expression
+ */
+export type SemiBoxedExpression = number | bigint | string | BigNum | MathJsonNumberObject | MathJsonStringObject | MathJsonSymbolObject | MathJsonFunctionObject | MathJsonDictionaryObject | readonly [MathJsonSymbol, ...SemiBoxedExpression[]] | BoxedExpression;
+/** Interface for dictionary-like structures.
+ * Use `isDictionary()` to check if an expression is a dictionary.
+ */
+export interface DictionaryInterface {
+    get(key: string): BoxedExpression | undefined;
+    has(key: string): boolean;
+    get keys(): string[];
+    get entries(): [string, BoxedExpression][];
+    get values(): BoxedExpression[];
+}
+/**
+ * These handlers compare two expressions.
+ *
+ * If only one of the handlers is provided, the other is derived from it.
+ *
+ * Having both may be useful if comparing non-equality is faster than equality.
+ *
+ *  @category Definitions
+ *
+ */
+export interface EqHandlers {
+    eq: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
+    neq: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
+}
+/** @category Definitions */
+export type Hold = 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
+/**
+ * Options to control the serialization to MathJSON when using `BoxedExpression.toMathJson()`.
+ *
+ * @category Serialization
+ */
+export type JsonSerializationOptions = {
+    /** If true, the serialization applies some transformations to make
+     * the JSON more readable. For example, `["Power", "x", 2]` is serialized
+     * as `["Square", "x"]`.
+     */
+    prettify: boolean;
+    /** A list of space separated function names that should be excluded from
+     * the JSON output.
+     *
+     * Those functions are replaced with an equivalent, for example, `Square` with
+     * `Power`, etc...
+     *
+     * Possible values include `Sqrt`, `Root`, `Square`, `Exp`, `Subtract`,
+     * `Rational`, `Complex`
+     *
+     * **Default**: `[]` (none)
+     */
+    exclude: string[];
+    /** A list of space separated keywords indicating which MathJSON expressions
+     * can use a shorthand.
+     *
+     * **Default**: `["all"]`
+     */
+    shorthands: ('all' | 'number' | 'symbol' | 'function' | 'string' | 'dictionary')[];
+    /** A list of space separated keywords indicating which metadata should be
+     * included in the MathJSON. If metadata is included, shorthand notation
+     * is not used.
+     *
+     * **Default**: `[]`  (none)
+     */
+    metadata: ('all' | 'wikidata' | 'latex')[];
+    /** If true, repeating decimals are detected and serialized accordingly
+     * For example:
+     * - `1.3333333333333333` \( \to \) `1.(3)`
+     * - `0.142857142857142857142857142857142857142857142857142` \( \to \) `0.(1428571)`
+     *
+     * **Default**: `true`
+     */
+    repeatingDecimal: boolean;
+    /**
+     * The maximum number of significant digits in serialized numbers.
+     * - `"max"`: all availabe digits are serialized.
+     * - `"auto"`: use the same precision as the compute engine.
+     *
+     * **Default**: `"auto"`
+     */
+    fractionalDigits: 'auto' | 'max' | number;
+};
+/**
+ * Control how a pattern is matched to an expression.
+ *
+ * ## Wildcards
+ *
+ * Patterns can include wildcards to match parts of expressions:
+ *
+ * - **Universal (`_` or `_name`)**: Matches exactly one element
+ * - **Sequence (`__` or `__name`)**: Matches one or more elements
+ * - **Optional Sequence (`___` or `___name`)**: Matches zero or more elements
+ *
+ * Named wildcards capture values in the returned substitution:
+ * - `['Add', '_a', 1].match(['Add', 'x', 1])` → `{_a: 'x'}`
+ * - `['Add', '__a'].match(['Add', 1, 2, 3])` → `{__a: [1, 2, 3]}`
+ *
+ * ## Options
+ *
+ * - `substitution`: if present, assumes these values for a subset of
+ *    named wildcards, and ensure that subsequent occurrence of the same
+ *    wildcard have the same value.
+ * - `recursive`: if true, match recursively, otherwise match only the top
+ *    level.
+ * - `useVariations`: if false, only match expressions that are structurally identical.
+ *    If true, match expressions that are structurally identical or equivalent.
+ *    For example, when true, `["Add", '_a', 2]` matches `2`, with `_a = 0`.
+ *    **Default**: `false`
+ * - `matchPermutations`: if true (default), for commutative operators, try all
+ *    permutations of pattern operands. If false, match exact order only.
+ *
+ * @category Pattern Matching
+ *
+ */
+export type PatternMatchOptions = {
+    substitution?: BoxedSubstitution;
+    recursive?: boolean;
+    useVariations?: boolean;
+    /**
+     * If `true` (default), for commutative operators, try all permutations of
+     * the pattern operands to find a match.
+     *
+     * If `false`, only match in the exact order given. This can be useful
+     * when the pattern order is significant or for performance optimization
+     * with large patterns.
+     */
+    matchPermutations?: boolean;
+};
+/**
+ * @category Boxed Expression
+ *
+ */
+export type ReplaceOptions = {
+    /**
+     * If `true`, apply replacement rules to all sub-expressions.
+     *
+     * If `false`, only consider the top-level expression.
+     *
+     * **Default**: `false`
+     */
+    recursive: boolean;
+    /**
+     * If `true`, stop after the first rule that matches.
+     *
+     * If `false`, apply all the remaining rules even after the first match.
+     *
+     * **Default**: `false`
+     */
+    once: boolean;
+    /**
+     * If `true` the rule will use some equivalent variations to match.
+     *
+     * For example when `useVariations` is true:
+     * - `x` matches `a + x` with a = 0
+     * - `x` matches `ax` with a = 1
+     * - etc...
+     *
+     * Setting this to `true` can save time by condensing multiple rules
+     * into one. This can be particularly useful when describing equations
+     * solutions. However, it can lead to infinite recursion and should be
+     * used with caution.
+     *
+     */
+    useVariations: boolean;
+    /**
+     * If `true` (default), for commutative operators, try all permutations of
+     * the pattern operands to find a match.
+     *
+     * If `false`, only match in the exact order given. This can be useful
+     * when the pattern order is significant or for performance optimization
+     * with large patterns.
+     *
+     * **Default**: `true`
+     */
+    matchPermutations: boolean;
+    /**
+     * If `iterationLimit` > 1, the rules will be repeatedly applied
+     * until no rules apply, up to `iterationLimit` times.
+     *
+     * Note that if `once` is true, `iterationLimit` has no effect.
+     *
+     * **Default**: `1`
+     */
+    iterationLimit: number;
+    /**
+     * Indicate if the expression should be canonicalized after the replacement.
+     * If not provided, the expression is canonicalized if the expression
+     * that matched the pattern is canonical.
+     */
+    canonical: CanonicalOptions;
+};
+/**
+ * A bound symbol (i.e. one with an associated definition) has either a type
+ * (e.g. ∀ x ∈ ℝ), a value (x = 5) or both (π: value = 3.14... type = 'real').
+ *
+ * @category Definitions
+ */
+export type ValueDefinition = BaseDefinition & {
+    holdUntil: 'never' | 'evaluate' | 'N';
+    type: Type | TypeString | BoxedType;
+    /** If true, the type is inferred, and could be adjusted later
+     * as more information becomes available or if the symbol is explicitly
+     * declared.
+     */
+    inferred: boolean;
+    /** `value` can be a JS function since for some constants, such as
+     * `Pi`, the actual value depends on the `precision` setting of the
+     * `ComputeEngine` and possible other environment settings */
+    value: LatexString | SemiBoxedExpression | ((ce: ComputeEngine) => BoxedExpression | null);
+    eq: (a: BoxedExpression) => boolean | undefined;
+    neq: (a: BoxedExpression) => boolean | undefined;
+    cmp: (a: BoxedExpression) => '=' | '>' | '<' | undefined;
+    collection: CollectionHandlers;
+};
+/**
+ * Definition record for a function.
+ * @category Definitions
+ *
+ */
+export type OperatorDefinition = Partial<BaseDefinition> & Partial<OperatorDefinitionFlags> & {
+    /**
+     * The function signature, describing the type of the arguments and the
+     * return type.
+     *
+     * If a `type` handler is provided, the return type of the function should
+     * be a subtype of the return type in the signature.
+     *
+     */
+    signature?: Type | TypeString | BoxedType;
+    /**
+     * The type of the result (return type) based on the type of
+     * the arguments.
+     *
+     * Should be a subtype of the type indicated by the signature.
+     *
+     * For example, if the signature is `(number) -> real`, the type of the
+     * result could be `real` or `integer`, but not `complex`.
+     *
+     * :::info[Note]
+     * Do not evaluate the arguments.
+     *
+     * However, the type of the arguments can be used to determine the type of
+     * the result.
+     * :::
+     *
+     */
+    type?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: ComputeEngine;
+    }) => Type | TypeString | BoxedType | undefined;
+    /** Return the sign of the function expression.
+     *
+     * If the sign cannot be determined, return `undefined`.
+     *
+     * When determining the sign, only literal values and the values of
+     * symbols, if they are literals, should be considered.
+     *
+     * Do not evaluate the arguments.
+     *
+     * However, the type and sign of the arguments can be used to determine the
+     * sign.
+     *
+     */
+    sgn?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: ComputeEngine;
+    }) => Sign | undefined;
+    /** The value of this expression is > 0, same as `isGreater(0)`
+     *
+     * @category Numeric Expression
+     */
+    readonly isPositive?: boolean | undefined;
+    /** The value of this expression is >= 0, same as `isGreaterEqual(0)`
+     *
+     * @category Numeric Expression
+     */
+    readonly isNonNegative?: boolean | undefined;
+    /** The value of this expression is &lt; 0, same as `isLess(0)`
+     *
+     * @category Numeric Expression
+     */
+    readonly isNegative?: boolean | undefined;
+    /** The  value of this expression is &lt;= 0, same as `isLessEqual(0)`
+     *
+     * @category Numeric Expression
+     */
+    readonly isNonPositive?: boolean | undefined;
+    /** Return `true` if the function expression is even, `false` if it is odd
+     * and `undefined` if it is neither (for example if it is not a number,
+     * or if it is a complex number).
+     */
+    even?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: ComputeEngine;
+    }) => boolean | undefined;
+    /**
+     * A number used to order arguments.
+     *
+     * Argument with higher complexity are placed after arguments with
+     * lower complexity when ordered canonically in commutative functions.
+     *
+     * - Additive functions: 1000-1999
+     * - Multiplicative functions: 2000-2999
+     * - Root and power functions: 3000-3999
+     * - Log functions: 4000-4999
+     * - Trigonometric functions: 5000-5999
+     * - Hypertrigonometric functions: 6000-6999
+     * - Special functions (factorial, Gamma, ...): 7000-7999
+     * - Collections: 8000-8999
+     * - Inert and styling:  9000-9999
+     * - Logic: 10000-10999
+     * - Relational: 11000-11999
+     *
+     * **Default**: 100,000
+     */
+    complexity?: number;
+    /**
+     * Return the canonical form of the expression with the arguments `args`.
+     *
+     * The arguments (`args`) may not be in canonical form. If necessary, they
+     * can be put in canonical form.
+     *
+     * This handler should validate the type and number of the arguments
+     * (arity).
+     *
+     * If a required argument is missing, it should be indicated with a
+     * `["Error", "'missing"]` expression. If more arguments than expected
+     * are present, this should be indicated with an
+     * `["Error", "'unexpected-argument'"]` error expression
+     *
+     * If the type of an argument is not compatible, it should be indicated
+     * with an `incompatible-type` error.
+     *
+     * `["Sequence"]` expressions are not folded and need to be handled
+     *  explicitly.
+     *
+     * If the function is associative, idempotent or an involution,
+     * this handler should account for it. Notably, if it is commutative, the
+     * arguments should be sorted in canonical order.
+     *
+     *
+     * Values of symbols should not be substituted, unless they have
+     * a `holdUntil` attribute of `"never"`.
+     *
+     * The handler should not consider the value or any assumptions about any
+     * of the arguments that are symbols or functions (i.e. `arg.isZero`,
+     * `arg.isInteger`, etc...) since those may change over time.
+     *
+     * The result of the handler should be a canonical expression.
+     *
+     * If the arguments do not match, they should be replaced with an
+     * appropriate `["Error"]` expression. If the expression cannot be put in
+     * canonical form, the handler should return `null`.
+     *
+     */
+    canonical?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: ComputeEngine;
+        scope: Scope | undefined;
+    }) => BoxedExpression | null;
+    /**
+     * Evaluate a function expression.
+     *
+     * When the handler is invoked, the arguments have been evaluated, except
+     * if the `lazy` option is set to `true`.
+     *
+     * It is not necessary to further simplify or evaluate the arguments.
+     *
+     * If performing numerical calculations and `options.numericalApproximation`
+     * is `false` return an exact numeric value, for example return a rational
+     * number or a square root, rather than a floating point approximation.
+     * Use `ce.number()` to create the numeric value.
+     *
+     * If the expression cannot be evaluated, due to the values, types, or
+     * assumptions about its arguments, return `undefined` or
+     * an `["Error"]` expression.
+     */
+    evaluate?: ((ops: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
+        engine: ComputeEngine;
+    }) => BoxedExpression | undefined) | BoxedExpression;
+    /**
+     * An asynchronous version of `evaluate`.
+     *
+     */
+    evaluateAsync?: (ops: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
+        engine: ComputeEngine;
+    }) => Promise<BoxedExpression | undefined>;
+    /** Dimensional analysis
+     * @experimental
+     */
+    evalDimension?: (args: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
+        engine: ComputeEngine;
+    }) => BoxedExpression;
+    /** Return a compiled (optimized) expression. */
+    xcompile?: (expr: BoxedExpression) => CompiledExpression;
+    eq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
+    neq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
+    collection?: CollectionHandlers;
+};
+/**
+ * Metadata common to both symbols and functions.
+ *
+ * @category Definitions
+ *
+ */
+export interface BaseDefinition {
+    /**
+     * If a string, a short description, about one line long.
+     *
+     * Otherwise, a list of strings, each string a paragraph.
+     *
+     * May contain Markdown.
+     */
+    description: string | string[];
+    /** A list of examples of how to use this symbol or operator.
+     *
+     * Each example is a string, which can be a MathJSON expression or LaTeX, bracketed by `$` signs.
+     * For example, `["Add", 1, 2]` or `$\\sin(\\pi/4)$`.
+     */
+    examples: string | string[];
+    /** A URL pointing to more information about this symbol or operator. */
+    url: string;
+    /**
+     * A short string representing an entry in a wikibase.
+     *
+     * For example `"Q167"` is the [wikidata entry](https://www.wikidata.org/wiki/Q167)
+     * for the `Pi` constant.
+     */
+    wikidata: string;
+    /** If true, the value or type of the definition cannot be changed */
+    readonly isConstant?: boolean;
+}
+/** Options for `BoxedExpression.simplify()`
+ *
+ * @category Boxed Expression
+ */
+export type SimplifyOptions = {
+    /**
+     * The set of rules to apply. If `null`, use no rules. If not provided,
+     * use the default simplification rules.
+     */
+    rules?: null | Rule | ReadonlyArray<BoxedRule | Rule> | BoxedRuleSet;
+    /**
+     * Use this cost function to determine if a simplification is worth it.
+     *
+     * If not provided, `ce.costFunction`, the cost function of the engine is
+     * used.
+     */
+    costFunction?: (expr: BoxedExpression) => number;
+};
+/**
+ * A table mapping symbols to their definition.
+ *
+ * Symbols should be valid MathJSON symbols. In addition, the
+ * following rules are recommended:
+ *
+ * - Use only latin letters, digits and `-`: `/[a-zA-Z0-9-]+/`
+ * - The first character should be a letter: `/^[a-zA-Z]/`
+ * - Functions and symbols exported from a library should start with an uppercase letter `/^[A-Z]/`
+ *
+ * @category Definitions
+ *
+ */
+export type SymbolDefinition = OneOf<[ValueDefinition, OperatorDefinition]>;
+/**
+ * @category Definitions
+ *
+ */
+export type SymbolDefinitions = Readonly<{
+    [id: string]: Partial<SymbolDefinition>;
+}>;
+/**
+ * When a unitless value is passed to or returned from a trigonometric function,
+ * the angular unit of the value.
+ *
+ * | Angular Unit | Description |
+ * |:--------------|:-------------|
+ * | `rad` | radians, 2π radians is a full circle |
+ * | `deg` | degrees, 360 degrees is a full circle |
+ * | `grad` | gradians, 400 gradians is a full circle |
+ * | `turn` | turns, 1 turn is a full circle |
+ *
+ * To change the angular unit used by the Compute Engine, use:
+ *
+ * ```js
+ * ce.angularUnit = 'deg';
+ * ```
+ *
+ * @category Compute Engine
+ */
+export type AngularUnit = 'rad' | 'deg' | 'grad' | 'turn';
+/** @category Numerics */
+export type Sign = 
+/** The expression is equal to 0 */
+'zero'
+/** The expression is > 0 */
+ | 'positive'
+/** The expression is < 0 */
+ | 'negative'
+/** The expression is >= 0 and isPositive is either false or undefined*/
+ | 'non-negative'
+/** The expression is <= 0 and isNegative is either false or undefined*/
+ | 'non-positive'
+/** The expression is not equal to 0 (possibly with an imaginary part) and isPositive, isNegative, isUnsigned are all false or undefined */
+ | 'not-zero'
+/** The expression has an imaginary part or is NaN */
+ | 'unsigned';
+/**
+ * These handlers are the primitive operations that can be performed on
+ * all collections, indexed or not.
+ *
+ *  @category Definitions
+ */
+export interface BaseCollectionHandlers {
+    /**
+     * Return an iterator that iterates over the elements of the collection.
+     *
+     * The order in which the elements are returned is not defined. Requesting
+     * two iterators on the same collection may return the elements in a
+     * different order.
+     *
+     * @category Definitions
+     */
+    iterator: (collection: BoxedExpression) => Iterator<BoxedExpression, undefined> | undefined;
+    /** Return the number of elements in the collection.
+     *
+     * An empty collection has a count of 0.
+     */
+    count: (collection: BoxedExpression) => number | undefined;
+    /** Optional flag to quickly check if the collection is empty, without having to count exactly how may elements it has (useful for lazy evaluation). */
+    isEmpty?: (collection: BoxedExpression) => boolean | undefined;
+    /** Optional flag to quickly check if the collection is finite, without having to count exactly how many elements it has (useful for lazy evaluation). */
+    isFinite?: (collection: BoxedExpression) => boolean | undefined;
+    /** Return `true` if the collection is lazy, `false` otherwise.
+     * If the collection is lazy, it means that the elements are not
+     * computed until they are needed, for example when iterating over the
+     * collection.
+     *
+     * Default: `true`
+     */
+    isLazy?: (collection: BoxedExpression) => boolean;
+    /**
+     * Return `true` if the target expression is in the collection,
+     * `false` otherwise.
+     *
+     * Return `undefined` if the membership cannot be determined.
+     */
+    contains?: (collection: BoxedExpression, target: BoxedExpression) => boolean | undefined;
+    /**
+     * Return `true` if all the elements of `other` are in `collection`.
+     * Both `collection` and `other` are collections.
+     *
+     * If strict is `true`, the subset must be strict, that is, `collection` must
+     * have more elements than `other`.
+     *
+     * Return `undefined` if the subset relation cannot be determined.
+     */
+    subsetOf?: (collection: BoxedExpression, other: BoxedExpression, strict: boolean) => boolean | undefined;
+    /** Return the sign of all the elements of the collection. */
+    eltsgn?: (collection: BoxedExpression) => Sign | undefined;
+    /** Return the widest type of all the elements in the collection */
+    elttype?: (collection: BoxedExpression) => Type | undefined;
+}
+/**
+ * These additional collection handlers are applicable to indexed
+ * collections only.
+ *
+ * The elements of an indexed collection can be accessed by index, and
+ * the order of the elements is defined.
+ *
+ *  @category Definitions
+ */
+export interface IndexedCollectionHandlers {
+    /**
+     * Return the element at the specified index.
+     *
+     * The first element is `at(1)`, the last element is `at(-1)`.
+     *
+     * If the index is &lt;0, return the element at index `count() + index + 1`.
+     *
+     * The index can also be a string for example for records. The set of valid
+     * keys is returned by the `keys()` handler.
+     *
+     * If the index is invalid, return `undefined`.
+     */
+    at: (collection: BoxedExpression, index: number | string) => undefined | BoxedExpression;
+    /**
+     * Return the index of the first element that matches the predicate.
+     *
+     * If no element matches the predicate, return `undefined`.
+     */
+    indexWhere: (collection: BoxedExpression, predicate: (element: BoxedExpression) => boolean) => number | undefined;
+}
+/**
+ * The collection handlers are the primitive operations that can be
+ * performed on collections, such as lists, sets, tuples, etc...
+ *
+ *  @category Definitions
+ */
+export type CollectionHandlers = BaseCollectionHandlers & Partial<IndexedCollectionHandlers>;
+/**
+ *
+ * The definition for a value, represented as a tagged object literal.
+ * @category Definitions
+ *
+ */
+export type TaggedValueDefinition = {
+    value: BoxedValueDefinition;
+};
+/**
+ *
+ * The definition for an operator, represented as a tagged object literal.
+ *
+ * @category Definitions
+ *
+ */
+export type TaggedOperatorDefinition = {
+    operator: BoxedOperatorDefinition;
+};
+/**
+ * A definition can be either a value or an operator.
+ *
+ * It is collected in a tagged object literal, instead of being a simple union
+ * type, so that the type of the definition can be changed while keeping
+ * references to the definition in bound expressions.
+ *
+ * @category Definitions
+ *
+ */
+export type BoxedDefinition = TaggedValueDefinition | TaggedOperatorDefinition;
+/**
+ * @category Definitions
+ *
+ */
+export interface BoxedBaseDefinition extends Partial<BaseDefinition> {
+    /** If this is the definition of a collection, the set of primitive operations
+     * that can be performed on this collection (counting the number of elements,
+     * enumerating it, etc...).
+     */
+    collection?: CollectionHandlers;
+}
+/**
+ *
+ * @category Definitions
+ */
+export interface BoxedValueDefinition extends BoxedBaseDefinition {
+    /**
+      * If the symbol has a value, it is held as indicated in the table below.
+      * A green checkmark indicate that the symbol is substituted.
+  
+    <div className="symbols-table">
+  
+    | Operation     | `"never"` | `"evaluate"` | `"N"` |
+    | :---          | :-----:   | :----:      | :---:  |
+    | `canonical()` |    (X)    |              |       |
+    | `evaluate()`  |    (X)    |     (X)      |       |
+    | `"N()"`       |    (X)    |     (X)      |  (X)  |
+  
+    </div>
+  
+      * Some examples:
+      * - `ImaginaryUnit` has `holdUntil: 'never'`: it is substituted during canonicalization
+      * - `x` has `holdUntil: 'evaluate'` (variables)
+      * - `Pi` has `holdUntil: 'N'` (special numeric constant)
+      *
+      * **Default:** `evaluate`
+      */
+    holdUntil: 'never' | 'evaluate' | 'N';
+    /** This is either the initial value of the symbol (i.e. when a new
+     *  evaluation context is created), or its constant value, if a constant.
+     *  Otherwise, the current value is tracked in the evaluation context.
+     *
+     */
+    readonly value: BoxedExpression | undefined;
+    eq?: (a: BoxedExpression) => boolean | undefined;
+    neq?: (a: BoxedExpression) => boolean | undefined;
+    cmp?: (a: BoxedExpression) => '=' | '>' | '<' | undefined;
+    /**
+     * True if the type has been inferred. An inferred type can be updated as
+     * more information becomes available.
+     *
+     * A type that is not inferred, but has been set explicitly, cannot be updated.
+     */
+    inferredType: boolean;
+    type: BoxedType;
+}
+/**
+ * An operator definition can have some flags to indicate specific
+ * properties of the operator.
+ * @category Definitions
+ */
+export type OperatorDefinitionFlags = {
+    /**
+     * If `true`, the arguments to this operator are not automatically
+     * evaluated. The default is `false` (the arguments are evaluated).
+     *
+     * This can be useful for example for operators that take symbolic
+     * expressions as arguments, such as `Declare` or `Integrate`.
+     *
+     * This is also useful for operators that take an argument that is
+     * potentially an infinite collection.
+     *
+     * It will be up to the `evaluate()` handler to evaluate the arguments as
+     * needed. This is convenient to pass symbolic expressions as arguments
+     * to operators without having to explicitly use a `Hold` expression.
+     *
+     * This also applies to the `canonical()` handler.
+     *
+     */
+    lazy: boolean;
+    /**
+     * If `true`, the operator requires a new lexical scope when canonicalized.
+     * This will allow it to declare variables that are not visible outside
+     * the function expression using the operator.
+     *
+     * **Default**: `false`
+     */
+    scoped: boolean;
+    /**  If `true`, the operator is applied element by element to lists, matrices
+     * (`["List"]` or `["Tuple"]` expressions) and equations (relational
+     * operators).
+     *
+     * **Default**: `false`
+     */
+    broadcastable: boolean;
+    /** If `true`, `["f", ["f", a], b]` simplifies to `["f", a, b]`
+     *
+     * **Default**: `false`
+     */
+    associative: boolean;
+    /** If `true`, `["f", a, b]` equals `["f", b, a]`. The canonical
+     * version of the function will order the arguments.
+     *
+     * **Default**: `false`
+     */
+    commutative: boolean;
+    /**
+     * If `commutative` is `true`, the order of the arguments is determined by
+     * this function.
+     *
+     * If the function is not provided, the arguments are ordered by the
+     * default order of the arguments.
+     *
+     */
+    commutativeOrder: ((a: BoxedExpression, b: BoxedExpression) => number) | undefined;
+    /** If `true`, when the operator is univariate, `["f", ["Multiply", x, c]]`
+     * simplifies to `["Multiply", ["f", x], c]` where `c` is constant
+     *
+     * When the operator is multivariate, multiplicativity is considered only on
+     * the first argument: `["f", ["Multiply", x, y], z]` simplifies to
+     * `["Multiply", ["f", x, z], ["f", y, z]]`
+     *
+     * Default: `false`
+     */
+    /** If `true`, `["f", ["f", x]]` simplifies to `["f", x]`.
+     *
+     * **Default**: `false`
+     */
+    idempotent: boolean;
+    /** If `true`, `["f", ["f", x]]` simplifies to `x`.
+     *
+     * **Default**: `false`
+     */
+    involution: boolean;
+    /** If `true`, the value of this operator is always the same for a given
+     * set of arguments and it has no side effects.
+     *
+     * An expression using this operator is pure if the operator and all its
+     * arguments are pure.
+     *
+     * For example `Sin` is pure, `Random` isn't.
+     *
+     * This information may be used to cache the value of expressions.
+     *
+     * **Default:** `true`
+     */
+    pure: boolean;
+};
+/**
+ *
+ * The definition includes information specific about an operator, such as
+ * handlers to canonicalize or evaluate a function expression with this
+ * operator.
+ *
+ * @category Definitions
+ *
+ */
+export interface BoxedOperatorDefinition extends BoxedBaseDefinition, OperatorDefinitionFlags {
+    complexity: number;
+    /** If true, the signature was inferred from usage and may be modified
+     * as more information becomes available.
+     */
+    inferredSignature: boolean;
+    /** The type of the arguments and return value of this function */
+    signature: BoxedType;
+    /** If present, this handler can be used to more precisely determine the
+     * return type based on the type of the arguments. The arguments themselves
+     * should *not* be evaluated, only their types should be used.
+     */
+    type?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: ComputeEngine;
+    }) => Type | TypeString | BoxedType | undefined;
+    /** If present, this handler can be used to determine the sign of the
+     *  return value of the function, based on the sign and type of its
+     *  arguments.
+     *
+     * The arguments themselves should *not* be evaluated, only their types and
+     * sign should be used.
+     *
+     * This can be used in some case for example to determine when certain
+     * simplifications are valid.
+     */
+    sgn?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: ComputeEngine;
+    }) => Sign | undefined;
+    eq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
+    neq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
+    canonical?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: ComputeEngine;
+        scope: Scope | undefined;
+    }) => BoxedExpression | null;
+    evaluate?: (ops: ReadonlyArray<BoxedExpression>, options: Partial<EvaluateOptions> & {
+        engine?: ComputeEngine;
+    }) => BoxedExpression | undefined;
+    evaluateAsync?: (ops: ReadonlyArray<BoxedExpression>, options?: Partial<EvaluateOptions> & {
+        engine?: ComputeEngine;
+    }) => Promise<BoxedExpression | undefined>;
+    evalDimension?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: ComputeEngine;
+    }) => BoxedExpression;
+    compile?: (expr: BoxedExpression) => CompiledExpression;
+    /** @internal */
+    update(def: OperatorDefinition): void;
+}
+/** @category Assumptions */
+export interface Assumption {
+    isPositive: boolean | undefined;
+    isNonNegative: boolean | undefined;
+    isNegative: boolean | undefined;
+    isNonPositive: boolean | undefined;
+    isNumber: boolean | undefined;
+    isInteger: boolean | undefined;
+    isRational: boolean | undefined;
+    isReal: boolean | undefined;
+    isComplex: boolean | undefined;
+    isImaginary: boolean | undefined;
+    isFinite: boolean | undefined;
+    isInfinite: boolean | undefined;
+    isNaN: boolean | undefined;
+    isZero: boolean | undefined;
+    matches(t: BoxedType): boolean | undefined;
+    isGreater(other: BoxedExpression): boolean | undefined;
+    isGreaterEqual(other: BoxedExpression): boolean | undefined;
+    isLess(other: BoxedExpression): boolean | undefined;
+    isLessEqual(other: BoxedExpression): boolean | undefined;
+    isEqual(other: BoxedExpression): boolean | undefined;
+    toExpression(ce: ComputeEngine, x: MathJsonSymbol): BoxedExpression;
+}
+/** @category Assumptions */
+export interface ExpressionMapInterface<U> {
+    has(expr: BoxedExpression): boolean;
+    get(expr: BoxedExpression): U | undefined;
+    set(expr: BoxedExpression, value: U): void;
+    delete(expr: BoxedExpression): void;
+    clear(): void;
+    [Symbol.iterator](): IterableIterator<[BoxedExpression, U]>;
+    entries(): IterableIterator<[BoxedExpression, U]>;
+}
+/** @category Assumptions */
+export type AssumeResult = 'internal-error' | 'not-a-predicate' | 'contradiction' | 'tautology' | 'ok';
+/**
+ * When provided, canonical forms are used to put an expression in a
+ * "standard" form.
+ *
+ * Each canonical form applies some transformation to an expression. When
+ * specified as an array, each transformation is done in the order in which
+ * it was provided.
+ *
+ * - `InvisibleOperator`: replace use of the `InvisibleOperator` with
+ *    another operation, such as multiplication (i.e. `2x` or function
+ *    application (`f(x)`). Also replaces ['InvisibleOperator', real, imaginary] instances with
+ *    complex (imaginary) numbers.
+ * - `Number`: replace all numeric values with their
+ *    canonical representation, for example, reduce
+ *    rationals and replace complex numbers with no imaginary part with a real number.
+ * - `Multiply`: replace negation with multiplication by -1, remove 1 from multiplications, simplify signs (`-y \times -x` -> `x \times y`), complex numbers are promoted (['Multiply', 2, 'ImaginaryUnit'] -> `["Complex", 0, 2]`)
+ * - `Add`: replace `Subtract` with `Add`, removes 0 in addition, promote complex numbers (["Add", "a", ["Complex", 0, "b"] -> `["Complex", "a", "b"]`)
+ * - `Power`: simplify `Power` expression, for example, `x^{-1}` -> `\frac{1}{x}`, `x^0` -> `1`, `x^1` -> `x`, `1^x` -> `1`, `x^{\frac{1}{2}}` -> `\sqrt{x}`, `a^b^c` -> `a^{bc}`...
+ * - `Divide`: replace with a `Rational` number if numerator and denominator are integers, simplify, e.g. `\frac{x}{1}` -> `x`...
+ * - `Flatten`: remove any unnecessary `Delimiter` expression, and flatten any associative functions, for example `["Add", ["Add", "a", "b"], "c"]` -> `["Add", "a", "b", "c"]`
+ * - `Order`: when applicable, sort the arguments in a specific order, for
+ *    example for addition and multiplication.
+ *
+ *
+ * @category Boxed Expression
+ */
+export type CanonicalForm = 'InvisibleOperator' | 'Number' | 'Multiply' | 'Add' | 'Power' | 'Divide' | 'Flatten' | 'Order';
+/** @category Boxed Expression */
+export type CanonicalOptions = boolean | CanonicalForm | CanonicalForm[];
+/** Options for `BoxedExpression.evaluate()`
+ *
+ * @category Boxed Expression
+ */
+export type EvaluateOptions = {
+    /**
+     * If `true`, the evaluation will return a numeric approximation
+     * of the expression, if possible.
+     * If `false`, the evaluation will return an exact value, if possible.
+     * Defaults to `false`.
+     */
+    numericApproximation: boolean;
+    /**
+     * If `false`, and the result of the expression is a lazy collection,
+     * the collection will not be evaluated and will remain lazy.
+     *
+     * If `true` and the expression is a finite lazy collection,
+     * the collection will be evaluated and returned as a non-lazy collection.
+     *
+     * If an integer, the collection will be evaluated up to that many elements.
+     *
+     * If a pair of integers `[n,m]`, and the collection is finite, the first `n`
+     * elements will be evaluated, and the last `m` elements will be evaluated.
+     *
+     * Defaults to `false`.
+     */
+    materialization: boolean | number | [number, number];
+    signal: AbortSignal;
+    withArguments: Record<MathJsonSymbol, BoxedExpression>;
+};
+/**
+ * Metadata that can be associated with an MathJSON expression.
+ *
+ * @category Boxed Expression
+ */
+export type Metadata = {
+    latex?: string | undefined;
+    wikidata?: string | undefined;
+};
+/**
+  * A substitution describes the values of the wildcards in a pattern so that
+  * the pattern is equal to a target expression.
+  *
+  * A substitution can also be considered a more constrained version of a
+  * rule whose `match` is always a symbol.
+
+  * @category Pattern Matching
+  */
+export type Substitution<T = SemiBoxedExpression> = {
+    [symbol: string]: T;
+};
+/**
+ * @category Pattern Matching
+ *
+ */
+export type BoxedSubstitution = Substitution<BoxedExpression>;
+/**
+ * Given an expression and set of wildcards, return a new expression.
+ *
+ * For example:
+ *
+ * ```ts
+ * {
+ *    match: '_x',
+ *    replace: (expr, {_x}) => { return ['Add', 1, _x] }
+ * }
+ * ```
+ *
+ * @category Rules */
+export type RuleReplaceFunction = (expr: BoxedExpression, wildcards: BoxedSubstitution) => BoxedExpression | undefined;
+/** @category Rules */
+export type RuleConditionFunction = (wildcards: BoxedSubstitution, ce: ComputeEngine) => boolean;
+/** @category Rules */
+export type RuleFunction = (expr: BoxedExpression) => undefined | BoxedExpression | RuleStep;
+/** @category Rules */
+export type RuleStep = {
+    value: BoxedExpression;
+    because: string;
+};
+/** @category Rules */
+export type RuleSteps = RuleStep[];
+/**
+ * A rule describes how to modify an expression that matches a pattern `match`
+ * into a new expression `replace`.
+ *
+ * - `x-1` \( \to \) `1-x`
+ * - `(x+1)(x-1)` \( \to \) `x^2-1
+ *
+ * The patterns can be expressed as LaTeX strings or `SemiBoxedExpression`'s.
+ * Alternatively, match/replace logic may be specified by a `RuleFunction`, allowing both custom
+ * logic/conditions for the match, and either a *BoxedExpression* (or `RuleStep` if being
+ * descriptive) for the replacement.
+ *
+ * As a shortcut, a rule can be defined as a LaTeX string: `x-1 -> 1-x`.
+ * The expression to the left of `->` is the `match` and the expression to the
+ * right is the `replace`. When using LaTeX strings, single character variables
+ * are assumed to be wildcards. The rule LHS ('match') and RHS ('replace') may also be supplied
+ * separately: in this case following the same rules.
+ *
+ * When using MathJSON expressions, anonymous wildcards (`_`) will match any
+ * expression. Named wildcards (`_x`, `_a`, etc...) will match any expression
+ * and bind the expression to the wildcard name.
+ *
+ * In addition the sequence wildcard (`__1`, `__a`, etc...) will match
+ * a sequence of one or more expressions, and bind the sequence to the
+ * wildcard name.
+ *
+ * Sequence wildcards are useful when the number of elements in the sequence
+ * is not known in advance. For example, in a sum, the number of terms is
+ * not known in advance. ["Add", 0, `__a`] will match two or more terms and
+ * the `__a` wildcard will be a sequence of the matchign terms.
+ *
+ * If `exact` is false, the rule will match variants.
+ *
+ * For example 'x' will match 'a + x', 'x' will match 'ax', etc...
+ *
+ * For simplification rules, you generally want `exact` to be true, but
+ * to solve equations, you want it to be false. Default to true.
+ *
+ * When set to false, infinite recursion is possible.
+ *
+ * @category Rules
+ */
+export type Rule = string | RuleFunction | {
+    match?: LatexString | SemiBoxedExpression | BoxedExpression;
+    replace: LatexString | SemiBoxedExpression | RuleReplaceFunction | RuleFunction;
+    condition?: LatexString | RuleConditionFunction;
+    useVariations?: boolean;
+    id?: string;
+    onBeforeMatch?: (rule: Rule, expr: BoxedExpression) => void;
+    onMatch?: (rule: Rule, expr: BoxedExpression, replace: BoxedExpression | RuleStep) => void;
+};
+/**
+ *
+ * If the `match` property is `undefined`, all expressions match this rule
+ * and `condition` should also be `undefined`. The `replace` property should
+ * be a `BoxedExpression` or a `RuleFunction`, and further filtering can be
+ * done in the `replace` function.
+ *
+ * @category Rules
+ */
+export type BoxedRule = {
+    /** @internal */
+    readonly _tag: 'boxed-rule';
+    match: undefined | BoxedExpression;
+    replace: BoxedExpression | RuleReplaceFunction | RuleFunction;
+    condition: undefined | RuleConditionFunction;
+    useVariations?: boolean;
+    id?: string;
+    onBeforeMatch?: (rule: Rule, expr: BoxedExpression) => void;
+    onMatch?: (rule: Rule, expr: BoxedExpression, replace: BoxedExpression | RuleStep) => void;
+};
+/**
+ * To create a BoxedRuleSet use the `ce.rules()` method.
+ *
+ * Do not create a `BoxedRuleSet` directly.
+ *
+ * @category Rules
+ */
+export type BoxedRuleSet = {
+    rules: ReadonlyArray<BoxedRule>;
+};
+/**
+ * The argument of `ce.assign()` is a value that can be assigned to a variable.
+ * It can be a primitive value, a boxed expression, or a function that
+ * takes a list of arguments and returns a boxed expression.
+ * @category Compute Engine */
+export type AssignValue = boolean | number | bigint | SemiBoxedExpression | ((args: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
+    engine: ComputeEngine;
+}) => BoxedExpression) | undefined;
+/**
+ * A lexical scope is a table mapping symbols to their definitions. The
+ * symbols are the names of the variables, unknowns and functions in the scope.
+ *
+ * The lexical scope is used to resolve the metadata about symbols, such as
+ * their type, whether they are constant, etc...
+ *
+ * It does not resolve the values of the symbols, since those depend on the
+ * evaluation context. For example, the local variables of a recursive function
+ * will have the same lexical scope, but different values in each evaluation
+ * context.
+ *
+ * @category Definitions
+ */
+export type Scope = {
+    parent: Scope | null;
+    bindings: Map<string, BoxedDefinition>;
+    types?: Record<string, TypeReference>;
+};
+/**
+ * An evaluation context is a set of bindings mapping symbols to their
+ * values. It also includes a reference to the lexical scope of the
+ * context, as well as a set of assumptions about the values of the
+ * symbols.
+ *
+ *
+ * Eval contexts are arranged in a stack structure. When a new context is
+ * created, it is pushed on the top of the stack.
+ *
+ * A new eval context is created when a function expression that needs to track
+ * its own local variables and named arguments is evaluated. This kind of
+ * function is a "scoped" function, meaning that it has its own local variables
+ * and named arguments.
+ *
+ * For example, the `Sum` function creates a new eval context to track the local
+ * variable used as the index of the sum.
+ *
+ * The eval context stack is used to resolve the value of symbols.
+ *
+ * When a scoped recursive function is called, a new context is created for each
+ * recursive call.
+ *
+ * In contrast, the lexical scope is used to resolve the metadata about
+ * symbols, such as their type, whether they are constant, etc... A new
+ * scope is not created for recursive calls, since the metadata
+ * does not change, only the values of the symbols change.
+ *
+ * The name of the eval context is used to print a "stack trace" for
+ * debugging.
+ *
+ * @category Compute Engine
+ */
+export type EvalContext = {
+    lexicalScope: Scope;
+    assumptions: ExpressionMapInterface<boolean>;
+    values: Record<string, BoxedExpression | undefined>;
+    name: undefined | string;
+};
+/** @internal */
+export interface ComputeEngine extends IBigNum {
+    latexDictionary: readonly LatexDictionaryEntry[];
+    /** @private */
+    _indexedLatexDictionary: IndexedLatexDictionary;
+    decimalSeparator: LatexString;
+    readonly True: BoxedExpression;
+    readonly False: BoxedExpression;
+    readonly Pi: BoxedExpression;
+    readonly E: BoxedExpression;
+    readonly Nothing: BoxedExpression;
+    readonly Zero: BoxedExpression;
+    readonly One: BoxedExpression;
+    readonly Half: BoxedExpression;
+    readonly NegativeOne: BoxedExpression;
+    /** ImaginaryUnit */
+    readonly I: BoxedExpression;
+    readonly NaN: BoxedExpression;
+    readonly PositiveInfinity: BoxedExpression;
+    readonly NegativeInfinity: BoxedExpression;
+    readonly ComplexInfinity: BoxedExpression;
+    /** @internal */
+    readonly _BIGNUM_NAN: BigNum;
+    /** @internal */
+    readonly _BIGNUM_ZERO: BigNum;
+    /** @internal */
+    readonly _BIGNUM_ONE: BigNum;
+    /** @internal */
+    readonly _BIGNUM_TWO: BigNum;
+    /** @internal */
+    readonly _BIGNUM_HALF: BigNum;
+    /** @internal */
+    readonly _BIGNUM_PI: BigNum;
+    /** @internal */
+    readonly _BIGNUM_NEGATIVE_ONE: BigNum;
+    readonly context: EvalContext;
+    contextStack: ReadonlyArray<EvalContext>;
+    /** @internal */
+    readonly _typeResolver: TypeResolver;
+    /** Absolute time beyond which evaluation should not proceed
+     * @internal
+     */
+    _deadline?: number;
+    /** Time remaining before _deadline
+     * @internal
+     */
+    _timeRemaining: number;
+    /** @internal */
+    _generation: number;
+    timeLimit: number;
+    iterationLimit: number;
+    recursionLimit: number;
+    chop(n: number): number;
+    chop(n: BigNum): BigNum | 0;
+    chop(n: number | BigNum): number | BigNum;
+    bignum: (a: string | number | bigint | BigNum) => BigNum;
+    complex: (a: number | Complex, b?: number) => Complex;
+    /** @internal */
+    _numericValue(value: number | bigint | OneOf<[BigNum | NumericValueData | ExactNumericValueData]>): NumericValue;
+    set precision(p: number | 'machine' | 'auto');
+    get precision(): number;
+    tolerance: number;
+    angularUnit: AngularUnit;
+    costFunction: (expr: BoxedExpression) => number;
+    strict: boolean;
+    box(expr: NumericValue | SemiBoxedExpression, options?: {
+        canonical?: CanonicalOptions;
+        structural?: boolean;
+        scope?: Scope;
+    }): BoxedExpression;
+    function(name: string, ops: ReadonlyArray<SemiBoxedExpression>, options?: {
+        metadata?: Metadata;
+        canonical?: CanonicalOptions;
+        structural?: boolean;
+        scope?: Scope;
+    }): BoxedExpression;
+    /**
+     * This is a primitive to create a boxed function.
+     *
+     * In general, consider using `ce.box()` or `ce.function()` or
+     * `canonicalXXX()` instead.
+     *
+     * The caller must ensure that the arguments are in canonical form:
+     * - arguments are `canonical()`
+     * - arguments are sorted
+     * - arguments are flattened and desequenced
+     *
+     * @internal
+     */
+    _fn(name: string, ops: ReadonlyArray<BoxedExpression>, options?: {
+        metadata?: Metadata;
+        canonical?: boolean;
+        scope?: Scope;
+    }): BoxedExpression;
+    number(value: number | bigint | string | NumericValue | MathJsonNumberObject | BigNum | Complex | Rational, options?: {
+        metadata?: Metadata;
+        canonical?: CanonicalOptions;
+    }): BoxedExpression;
+    symbol(sym: string, options?: {
+        canonical?: CanonicalOptions;
+        metadata?: Metadata;
+    }): BoxedExpression;
+    string(s: string, metadata?: Metadata): BoxedExpression;
+    error(message: string | string[], where?: string): BoxedExpression;
+    typeError(expectedType: Type, actualType: undefined | Type | BoxedType, where?: SemiBoxedExpression): BoxedExpression;
+    hold(expr: SemiBoxedExpression): BoxedExpression;
+    tuple(...elements: ReadonlyArray<number>): BoxedExpression;
+    tuple(...elements: ReadonlyArray<BoxedExpression>): BoxedExpression;
+    type(type: Type | TypeString | BoxedType): BoxedType;
+    rules(rules: Rule | ReadonlyArray<Rule | BoxedRule> | BoxedRuleSet | undefined | null, options?: {
+        canonical?: boolean;
+    }): BoxedRuleSet;
+    getRuleSet(id?: 'harmonization' | 'solve-univariate' | 'standard-simplification'): BoxedRuleSet | undefined;
+    parse(latex: null, options?: Partial<ParseLatexOptions> & {
+        canonical?: CanonicalOptions;
+    }): null;
+    parse(latex: LatexString, options?: Partial<ParseLatexOptions> & {
+        canonical?: CanonicalOptions;
+    }): BoxedExpression;
+    parse(latex: LatexString | null, options?: Partial<ParseLatexOptions> & {
+        canonical?: CanonicalOptions;
+    }): BoxedExpression | null;
+    pushScope(scope?: Scope, name?: string): void;
+    popScope(): void;
+    /**
+     *
+     * When a new eval context is created, it has slots for the local variables
+     * from the current lexical scope. It also copies the current set of
+     * assumptions.
+     *
+     * Need a pointer to the current lexical scope (may have a scope chain without an evaluation context). Each lexical scope includes a pointer to the parent scope (it's a DAG).
+     *
+     * If a function is "scoped" (has a `scoped` flag), create a new lexical scope
+     * when the function is canonicalized, store the scope with the function
+     * definition (if the function has a lazy flag, and a canonical handler, it
+     * can behave like a scoped function, but a scoped flag is convenient,
+     * it would still evaluate the arguments).
+     *
+     * Note: if an expression is not canonical, evaluating it return itself.
+     * This is important to support arguments that are just symbol names
+     * (they are not canonicalized).
+     *
+     * When the function expression is evaluated, if it is "scoped", push the
+     * scope associated with the function (maybe not?) and a matching eval
+     * context, including all the symbols in the lexical scope (including
+     * constants). Need some way to indicate that a symbol maps to an argument
+     * (in value definition?).
+     *
+     * When searching the value of a symbol, start with the current
+     * eval context, then the previous one.
+     *
+     * When looking for a definition, start with the lexical scope of the
+     * current eval context, then the parent lexical context.
+     *
+     * @internal */
+    _pushEvalContext(scope: Scope, name?: string): void;
+    /** @internal */
+    _popEvalContext(): void;
+    /**
+     * Temporarily sets the lexical scope to the provided scope, then
+     * executes the function `f` in that scope and returns the result.
+     * @internal */
+    _inScope<T>(scope: Scope | undefined, f: () => T): T;
+    /**
+     * Use `ce.box(id)` instead
+     * @internal */
+    _getSymbolValue(id: MathJsonSymbol): BoxedExpression | undefined;
+    /**
+     * Use `ce.assign(id, value)` instead.
+     * @internal */
+    _setSymbolValue(id: MathJsonSymbol, value: BoxedExpression | boolean | number | undefined): void;
+    /** A list of the function calls to the current evaluation context */
+    trace: ReadonlyArray<string>;
+    lookupContext(id: MathJsonSymbol): undefined | EvalContext;
+    /** @internal */
+    _swapContext(context: EvalContext): void;
+    lookupDefinition(id: MathJsonSymbol): undefined | BoxedDefinition;
+    assign(ids: {
+        [id: MathJsonSymbol]: AssignValue;
+    }): ComputeEngine;
+    assign(id: MathJsonSymbol, value: AssignValue): ComputeEngine;
+    assign(arg1: MathJsonSymbol | {
+        [id: MathJsonSymbol]: AssignValue;
+    }, arg2?: AssignValue): ComputeEngine;
+    declareType(name: string, type: Type, options?: {
+        alias?: boolean;
+    }): void;
+    declare(symbols: {
+        [id: MathJsonSymbol]: Type | TypeString | Partial<SymbolDefinition>;
+    }): ComputeEngine;
+    declare(id: MathJsonSymbol, def: Type | TypeString | Partial<SymbolDefinition>, scope?: Scope): ComputeEngine;
+    declare(arg1: MathJsonSymbol | {
+        [id: MathJsonSymbol]: Type | TypeString | Partial<SymbolDefinition>;
+    }, arg2?: Type | TypeString | Partial<SymbolDefinition>, arg3?: Scope): ComputeEngine;
+    assume(predicate: BoxedExpression): AssumeResult;
+    forget(symbol?: MathJsonSymbol | MathJsonSymbol[]): void;
+    ask(pattern: BoxedExpression): BoxedSubstitution[];
+    verify(query: BoxedExpression): boolean;
+    /** @internal */
+    _shouldContinueExecution(): boolean;
+    /** @internal */
+    _checkContinueExecution(): void;
+    /** @internal */
+    _cache<T>(name: string, build: () => T, purge?: (t: T) => T | undefined): T;
+    /** @internal */
+    _reset(): void;
+    /** @internal */
+    listenToConfigurationChange(tracker: ConfigurationChangeListener): () => void;
+}