declare class exprify {
    math: Readonly<{
        power: (a: number, b: number) => number;
        multiply: (a: number, b: number) => number;
        divide: (a: number, b: number) => number;
        add: (a: string, b: string) => string;
        subtract: (a: number, b: number) => number;
        modulus: (a: number, b: number) => number;
    }>;
    units: {
        getUnits: () => {};
        setUnits: (newUnits: {}) => void;
        updateType: (type: string | number, data: any) => void;
        addUnit: (type: string | number, key: string | number, unitObj: any) => void;
        compute(op: string, left: {
            unit: any;
            value: any;
        }, right: {
            unit: any;
            value: number;
        }): any;
        convert: (value: number, fromUnit: any, toUnit: any) => {
            value: number;
            unit: string;
        };
        getAllUnitsFlat: () => any[];
        findUnit: (input: string, relatedType?: string | null) => {
            type: string;
            key: string;
            data: any;
        } | null;
    };
    functions: {
        getAllFunctionsName(): string[];
        register(name: string, fn: any): void;
        get(name: string): any;
        has(name: any): boolean;
        remove(name: string | number): void;
        all(): any;
        clear(): void;
        extend(formulas?: {}): void;
        clone(): any;
    };
    variables: {
        set(name: string, value: number | undefined, { override }?: {
            override?: boolean | undefined;
        }): void;
        get(name: string | number): any;
        has(name: any): boolean;
        remove(name: string | number): void;
        all(): any;
        clear(): void;
        merge(obj?: {}): void;
        clone(): any;
    };
    _cache: Map<any, any>;
    setVariable(name: any, value: any): void;
    getVariable(name: any): any;
    addFunction(name: string, fn: any): void;
    _createContext(): {
        variables: any;
        functions: any;
        units: any;
        evaluate: any;
        withScope(scope?: {}): any;
    };
    tokenize(expr: any): ({
        type: string;
        value: any;
        pos: number;
    } | {
        type: string;
        value: string;
        pos?: undefined;
    } | {
        type: string;
        value?: undefined;
        pos?: undefined;
    } | {
        type: string;
        pos: number;
        value?: undefined;
    } | {
        type: string;
        value: any;
        unit: any;
        pos: number | undefined;
    })[];
    parse(expr: string): {
        tokens: ({
            type: string;
            value: any;
            pos: number;
        } | {
            type: string;
            value: string;
            pos?: undefined;
        } | {
            type: string;
            value?: undefined;
            pos?: undefined;
        } | {
            type: string;
            pos: number;
            value?: undefined;
        } | {
            type: string;
            value: any;
            unit: any;
            pos: number | undefined;
        })[];
        ast: any;
    };
    evaluate(expr: string, scope?: object): any;
    _evaluateRaw(expr: string, scope?: object): any;
    compile(expr: string): any;
    clearCache(): void;
    exportState(): {
        variables: any;
        functions: string[];
        units: {};
    };
    importState(state: any): this;
    chain(): Chain;
}
declare class Chain {
    constructor(exprifyInstance: exprify);
    _expr: exprify;
    _rawResult: any;
    evaluate(expr: any, scope?: {}): this;
    setVariable(name: any, value: any): this;
    compile(expr: any): any;
    done(): any;
}

export default exprify;