import type { MathNode, SymbolNode, ConstantNode, OperatorNode, ParenthesisNode, ArrayNode, AccessorNode, IndexNode, ObjectNode, FunctionNode } from '../utils/node.js';
import type { TypedFunction } from '../core/function/typed.js';
interface AccessorNodeConstructor {
    new (object: MathNode, index: IndexNode): AccessorNode;
}
interface ArrayNodeConstructor {
    new (items: MathNode[]): ArrayNode;
}
interface ConstantNodeConstructor {
    new (value: unknown): ConstantNode;
}
interface FunctionNodeConstructor {
    new (name: string, args: MathNode[]): FunctionNode;
}
interface IndexNodeConstructor {
    new (dimensions: MathNode[]): IndexNode;
}
interface ObjectNodeConstructor {
    new (properties: Record<string, MathNode>): ObjectNode;
}
interface OperatorNodeConstructor {
    new (op: string, fn: string, args: MathNode[]): OperatorNode;
}
interface ParenthesisNodeConstructor {
    new (content: MathNode): ParenthesisNode;
}
interface SymbolNodeConstructor {
    new (name: string): SymbolNode;
}
interface SimplifyDependencies {
    typed: TypedFunction;
    parse: (expr: string) => MathNode;
    equal: (a: unknown, b: unknown) => boolean;
    resolve: (node: MathNode, scope?: Map<string, unknown> | null) => MathNode;
    simplifyConstant: (node: MathNode, options?: SimplifyOptions) => MathNode;
    simplifyCore: (node: MathNode, options?: SimplifyOptions) => MathNode;
    AccessorNode: AccessorNodeConstructor;
    ArrayNode: ArrayNodeConstructor;
    ConstantNode: ConstantNodeConstructor;
    FunctionNode: FunctionNodeConstructor;
    IndexNode: IndexNodeConstructor;
    ObjectNode: ObjectNodeConstructor;
    OperatorNode: OperatorNodeConstructor;
    ParenthesisNode: ParenthesisNodeConstructor;
    SymbolNode: SymbolNodeConstructor;
    replacer: (key: string, value: unknown) => unknown;
}
type SimplifyRule = string | {
    s?: string;
    l?: string;
    r?: string;
    repeat?: boolean;
    assuming?: Record<string, Record<string, boolean>>;
    imposeContext?: Record<string, Record<string, boolean>>;
    evaluate?: unknown;
    expanded?: unknown;
    expandedNC1?: unknown;
    expandedNC2?: unknown;
} | ((node: MathNode, options?: SimplifyOptions) => MathNode);
type SimplifyOptions = {
    consoleDebug?: boolean;
    context?: SimplifyContext;
    exactFractions?: boolean;
    fractionsLimit?: number;
};
type SimplifyContext = Record<string, Record<string, boolean>>;
export declare const createSimplify: import("../utils/factory.js").FactoryFunction<SimplifyDependencies, TypedFunction & {
    defaultContext?: SimplifyContext;
    realContext?: SimplifyContext;
    positiveContext?: SimplifyContext;
    rules?: SimplifyRule[];
}>;
export {};
//# sourceMappingURL=simplify.d.ts.map