import type { MathNode } from '../../utils/node.js';
type OperatorContext = Record<string, Record<string, boolean>>;
/** Minimal runtime shape of an OperatorNode used here */
export interface OpNodeLike extends MathNode {
    op: string;
    fn: string;
    args: MathNode[];
    implicit?: boolean;
}
/** Minimal runtime shape of a FunctionNode used here */
export interface FuncNodeLike extends MathNode {
    name: string;
    args: MathNode[];
}
type OperatorNodeCtor = new (op: string, fn: string, args: MathNode[], implicit?: boolean) => MathNode;
type FunctionNodeCtor = new (fn: MathNode, args: MathNode[]) => MathNode;
type SymbolNodeCtor = new (name: string) => MathNode;
export declare const createUtil: import("../../utils/factory.js").FactoryFunction<{
    FunctionNode: FunctionNodeCtor;
    OperatorNode: OperatorNodeCtor;
    SymbolNode: SymbolNodeCtor;
}, {
    createMakeNodeFunction: (node: OpNodeLike | FuncNodeLike) => (args: MathNode[]) => MathNode;
    hasProperty: (nodeOrName: string | MathNode, property: string, context?: OperatorContext) => boolean;
    isCommutative: (node: string | MathNode, context?: OperatorContext) => boolean;
    isAssociative: (node: string | MathNode, context?: OperatorContext) => boolean;
    mergeContext: (primary: OperatorContext | undefined, secondary: OperatorContext | undefined) => OperatorContext;
    flatten: (node: MathNode & {
        args?: MathNode[];
    }, context?: OperatorContext) => void;
    allChildren: (node: MathNode & {
        args?: MathNode[];
        op?: string;
    }, context: OperatorContext) => MathNode[];
    unflattenr: (node: MathNode & {
        args?: MathNode[];
    }, context?: OperatorContext) => void;
    unflattenl: (node: MathNode & {
        args?: MathNode[];
    }, context?: OperatorContext) => void;
    defaultContext: OperatorContext;
    realContext: OperatorContext;
    positiveContext: OperatorContext;
}>;
export {};
//# sourceMappingURL=util.d.ts.map