import type { MathNode, ConstantNode, ArrayNode, OperatorNode } from '../utils/node.js';
import type { TypedFunction } from '../core/function/typed.js';
/** A Fraction-like runtime value (fraction.js) */
interface FractionLike {
    n: bigint;
    d: bigint;
    s: number;
    valueOf(): number;
}
/** Simplification options */
type Options = {
    context?: Record<string, Record<string, boolean>>;
    exactFractions?: boolean;
    fractionsLimit?: number;
};
/** A math function in the transform set (callable with an optional rawArgs flag) */
type TransformFn = ((...args: unknown[]) => unknown) & {
    rawArgs?: boolean;
};
type OperatorNodeCtor = new (op: string, fn: string, args: MathNode[]) => OperatorNode;
type FunctionNodeCtor = new (name: string, args: MathNode[]) => MathNode;
type ConstantNodeCtor = new (value?: unknown) => ConstantNode;
type ArrayNodeCtor = new (items: MathNode[]) => ArrayNode;
type AccessorNodeCtor = new (object: MathNode, index: MathNode) => MathNode;
type IndexNodeCtor = new (dimensions: MathNode[]) => MathNode;
type ObjectNodeCtor = new (properties: Record<string, MathNode>) => MathNode;
type SymbolNodeCtor = new (name: string) => MathNode;
export declare const createSimplifyConstant: import("../utils/factory.js").FactoryFunction<{
    typed: TypedFunction;
    config: {
        number?: string;
    };
    mathWithTransform: Record<string, TransformFn>;
    matrix: (data: unknown) => unknown;
    parse: (expr: string) => MathNode;
    isBounded: (n: unknown) => boolean;
    fraction?: (n: unknown) => FractionLike;
    bignumber?: (v: unknown) => unknown;
    AccessorNode: AccessorNodeCtor;
    ArrayNode: ArrayNodeCtor;
    ConstantNode: ConstantNodeCtor;
    FunctionNode: FunctionNodeCtor;
    IndexNode: IndexNodeCtor;
    ObjectNode: ObjectNodeCtor;
    OperatorNode: OperatorNodeCtor;
    SymbolNode: SymbolNodeCtor;
}, (expr: unknown, options?: Options) => MathNode>;
export {};
//# sourceMappingURL=simplifyConstant.d.ts.map