@fmfi-uk-1-ain-412/structure-explorer 0.0.6

package/dist/features/structure/structureSlice.d.ts

@@ -0,0 +1,886 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { RootState } from '../../app/store';
+import { default as Structure } from '../../model/Structure';
+export interface InterpretationState {
+    text: string;
+}
+export interface StructureState {
+    domain: string;
+    iC: Record<string, InterpretationState>;
+    iP: Record<string, InterpretationState>;
+    iF: Record<string, InterpretationState>;
+}
+export declare const structureSlice: import('@reduxjs/toolkit').Slice<StructureState, {
+    importStructureState: (_state: import('immer').WritableDraft<StructureState>, action: PayloadAction<string>) => any;
+    updateDomain: (state: import('immer').WritableDraft<StructureState>, action: PayloadAction<string>) => void;
+    updateInterpretationConstants: (state: import('immer').WritableDraft<StructureState>, action: PayloadAction<{
+        key: string;
+        value: string;
+    }>) => void;
+    updateInterpretationPredicates: (state: import('immer').WritableDraft<StructureState>, action: PayloadAction<{
+        key: string;
+        value: string;
+    }>) => void;
+    updateFunctionSymbols: (state: import('immer').WritableDraft<StructureState>, action: PayloadAction<{
+        key: string;
+        value: string;
+    }>) => void;
+}, "structure", "structure", import('@reduxjs/toolkit').SliceSelectors<StructureState>>;
+export declare const updateDomain: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "structure/updateDomain">, updateInterpretationConstants: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
+    key: string;
+    value: string;
+}, "structure/updateInterpretationConstants">, updateInterpretationPredicates: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
+    key: string;
+    value: string;
+}, "structure/updateInterpretationPredicates">, updateFunctionSymbols: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
+    key: string;
+    value: string;
+}, "structure/updateFunctionSymbols">, importStructureState: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "structure/importStructureState">;
+export declare const selectDomain: (state: RootState) => string;
+export declare const selectIc: (state: RootState) => Record<string, InterpretationState>;
+export declare const selectIcName: (state: RootState, name: string) => InterpretationState;
+export declare const selectIp: (state: RootState) => Record<string, InterpretationState>;
+export declare const selectIpName: (state: RootState, name: string) => InterpretationState;
+export declare const selectIf: (state: RootState) => Record<string, InterpretationState>;
+export declare const selectIfName: (state: RootState, name: string) => InterpretationState;
+export declare const selectParsedDomain: ((state: {
+    formulas: import('../formulas/formulasSlice').FormulasState;
+    language: import('../language/languageSlice').LanguageState;
+    structure: StructureState;
+    variables: import('../variables/variablesSlice').VariablesState;
+}) => {
+    error: Error;
+    parsed?: undefined;
+} | {
+    parsed: string[];
+    error?: undefined;
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: string) => {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string[];
+        error?: undefined;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: string) => {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string[];
+        error?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string[];
+        error?: undefined;
+    };
+    dependencies: [(state: RootState) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import('reselect').weakMapMemoize;
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectParsedConstant: ((state: {
+    formulas: import('../formulas/formulasSlice').FormulasState;
+    language: import('../language/languageSlice').LanguageState;
+    structure: StructureState;
+    variables: import('../variables/variablesSlice').VariablesState;
+}, name: string) => {
+    error: Error;
+    parsed?: undefined;
+} | {
+    parsed: string;
+    error?: undefined;
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: InterpretationState, resultFuncArgs_1: {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string[];
+        error?: undefined;
+    }) => {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string;
+        error?: undefined;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: InterpretationState, resultFuncArgs_1: {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string[];
+        error?: undefined;
+    }) => {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string;
+        error?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string;
+        error?: undefined;
+    };
+    dependencies: [(state: RootState, name: string) => InterpretationState, ((state: {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: import('../language/languageSlice').LanguageState;
+        structure: StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }) => {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string[];
+        error?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: string) => {
+            error: Error;
+            parsed?: undefined;
+        } | {
+            parsed: string[];
+            error?: undefined;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: string) => {
+            error: Error;
+            parsed?: undefined;
+        } | {
+            parsed: string[];
+            error?: undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            error: Error;
+            parsed?: undefined;
+        } | {
+            parsed: string[];
+            error?: undefined;
+        };
+        dependencies: [(state: RootState) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('reselect').weakMapMemoize;
+        argsMemoize: typeof import('reselect').weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import('reselect').weakMapMemoize;
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectParsedPredicate: ((state: {
+    formulas: import('../formulas/formulasSlice').FormulasState;
+    language: import('../language/languageSlice').LanguageState;
+    structure: StructureState;
+    variables: import('../variables/variablesSlice').VariablesState;
+}, name: string) => {
+    error?: undefined;
+    parsed?: undefined;
+} | {
+    error: undefined;
+    parsed: string[][];
+} | {
+    error: Error;
+    parsed?: undefined;
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: InterpretationState, resultFuncArgs_1: {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string[];
+        error?: undefined;
+    }, resultFuncArgs_2: {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }, resultFuncArgs_3: string) => {
+        error?: undefined;
+        parsed?: undefined;
+    } | {
+        error: undefined;
+        parsed: string[][];
+    } | {
+        error: Error;
+        parsed?: undefined;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: InterpretationState, resultFuncArgs_1: {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string[];
+        error?: undefined;
+    }, resultFuncArgs_2: {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }, resultFuncArgs_3: string) => {
+        error?: undefined;
+        parsed?: undefined;
+    } | {
+        error: undefined;
+        parsed: string[][];
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        error?: undefined;
+        parsed?: undefined;
+    } | {
+        error: undefined;
+        parsed: string[][];
+    } | {
+        error: Error;
+        parsed?: undefined;
+    };
+    dependencies: [(state: RootState, name: string) => InterpretationState, ((state: {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: import('../language/languageSlice').LanguageState;
+        structure: StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }) => {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string[];
+        error?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: string) => {
+            error: Error;
+            parsed?: undefined;
+        } | {
+            parsed: string[];
+            error?: undefined;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: string) => {
+            error: Error;
+            parsed?: undefined;
+        } | {
+            parsed: string[];
+            error?: undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            error: Error;
+            parsed?: undefined;
+        } | {
+            parsed: string[];
+            error?: undefined;
+        };
+        dependencies: [(state: RootState) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('reselect').weakMapMemoize;
+        argsMemoize: typeof import('reselect').weakMapMemoize;
+    }, ((state: {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: import('../language/languageSlice').LanguageState;
+        structure: StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }) => {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: string) => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: string) => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        dependencies: [(state: RootState) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('reselect').weakMapMemoize;
+        argsMemoize: typeof import('reselect').weakMapMemoize;
+    }, (_: RootState, name: string) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import('reselect').weakMapMemoize;
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectParsedFunction: ((state: {
+    formulas: import('../formulas/formulasSlice').FormulasState;
+    language: import('../language/languageSlice').LanguageState;
+    structure: StructureState;
+    variables: import('../variables/variablesSlice').VariablesState;
+}, name: string) => {
+    error?: undefined;
+    parsed?: undefined;
+} | {
+    error: Error;
+    parsed?: undefined;
+} | {
+    error: Error | undefined;
+    parsed: string[][];
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: InterpretationState, resultFuncArgs_1: {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string[];
+        error?: undefined;
+    }, resultFuncArgs_2: {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }, resultFuncArgs_3: string) => {
+        error?: undefined;
+        parsed?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        error: Error | undefined;
+        parsed: string[][];
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: InterpretationState, resultFuncArgs_1: {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string[];
+        error?: undefined;
+    }, resultFuncArgs_2: {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }, resultFuncArgs_3: string) => {
+        error?: undefined;
+        parsed?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        error: Error | undefined;
+        parsed: string[][];
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        error?: undefined;
+        parsed?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        error: Error | undefined;
+        parsed: string[][];
+    };
+    dependencies: [(state: RootState, name: string) => InterpretationState, ((state: {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: import('../language/languageSlice').LanguageState;
+        structure: StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }) => {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string[];
+        error?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: string) => {
+            error: Error;
+            parsed?: undefined;
+        } | {
+            parsed: string[];
+            error?: undefined;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: string) => {
+            error: Error;
+            parsed?: undefined;
+        } | {
+            parsed: string[];
+            error?: undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            error: Error;
+            parsed?: undefined;
+        } | {
+            parsed: string[];
+            error?: undefined;
+        };
+        dependencies: [(state: RootState) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('reselect').weakMapMemoize;
+        argsMemoize: typeof import('reselect').weakMapMemoize;
+    }, ((state: {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: import('../language/languageSlice').LanguageState;
+        structure: StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }) => {
+        parsed: Map<string, number>;
+        error?: undefined;
+    } | {
+        error: Error;
+        parsed?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: string) => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: string) => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        };
+        dependencies: [(state: RootState) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('reselect').weakMapMemoize;
+        argsMemoize: typeof import('reselect').weakMapMemoize;
+    }, (_: RootState, name: string) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import('reselect').weakMapMemoize;
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectStructure: ((state: {
+    formulas: import('../formulas/formulasSlice').FormulasState;
+    language: import('../language/languageSlice').LanguageState;
+    structure: StructureState;
+    variables: import('../variables/variablesSlice').VariablesState;
+}) => Structure) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: import('../language/languageSlice').LanguageState;
+        structure: StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }, resultFuncArgs_1: import('../../model/Language').Language, resultFuncArgs_2: {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string[];
+        error?: undefined;
+    }) => Structure;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: import('../language/languageSlice').LanguageState;
+        structure: StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }, resultFuncArgs_1: import('../../model/Language').Language, resultFuncArgs_2: {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string[];
+        error?: undefined;
+    }) => Structure) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Structure;
+    dependencies: [(state: RootState) => {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: import('../language/languageSlice').LanguageState;
+        structure: StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }, ((state: {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: import('../language/languageSlice').LanguageState;
+        structure: StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }) => import('../../model/Language').Language) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            parsed: Set<string>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }, resultFuncArgs_1: {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }, resultFuncArgs_2: {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }) => import('../../model/Language').Language;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            parsed: Set<string>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }, resultFuncArgs_1: {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }, resultFuncArgs_2: {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }) => import('../../model/Language').Language) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import('../../model/Language').Language;
+        dependencies: [((state: {
+            formulas: import('../formulas/formulasSlice').FormulasState;
+            language: import('../language/languageSlice').LanguageState;
+            structure: StructureState;
+            variables: import('../variables/variablesSlice').VariablesState;
+        }) => {
+            parsed: Set<string>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: string) => {
+                parsed: Set<string>;
+                error?: undefined;
+            } | {
+                error: Error;
+                parsed?: undefined;
+            };
+            memoizedResultFunc: ((resultFuncArgs_0: string) => {
+                parsed: Set<string>;
+                error?: undefined;
+            } | {
+                error: Error;
+                parsed?: undefined;
+            }) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => {
+                parsed: Set<string>;
+                error?: undefined;
+            } | {
+                error: Error;
+                parsed?: undefined;
+            };
+            dependencies: [(state: RootState) => string];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import('reselect').weakMapMemoize;
+            argsMemoize: typeof import('reselect').weakMapMemoize;
+        }, ((state: {
+            formulas: import('../formulas/formulasSlice').FormulasState;
+            language: import('../language/languageSlice').LanguageState;
+            structure: StructureState;
+            variables: import('../variables/variablesSlice').VariablesState;
+        }) => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: string) => {
+                parsed: Map<string, number>;
+                error?: undefined;
+            } | {
+                error: Error;
+                parsed?: undefined;
+            };
+            memoizedResultFunc: ((resultFuncArgs_0: string) => {
+                parsed: Map<string, number>;
+                error?: undefined;
+            } | {
+                error: Error;
+                parsed?: undefined;
+            }) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => {
+                parsed: Map<string, number>;
+                error?: undefined;
+            } | {
+                error: Error;
+                parsed?: undefined;
+            };
+            dependencies: [(state: RootState) => string];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import('reselect').weakMapMemoize;
+            argsMemoize: typeof import('reselect').weakMapMemoize;
+        }, ((state: {
+            formulas: import('../formulas/formulasSlice').FormulasState;
+            language: import('../language/languageSlice').LanguageState;
+            structure: StructureState;
+            variables: import('../variables/variablesSlice').VariablesState;
+        }) => {
+            parsed: Map<string, number>;
+            error?: undefined;
+        } | {
+            error: Error;
+            parsed?: undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: string) => {
+                parsed: Map<string, number>;
+                error?: undefined;
+            } | {
+                error: Error;
+                parsed?: undefined;
+            };
+            memoizedResultFunc: ((resultFuncArgs_0: string) => {
+                parsed: Map<string, number>;
+                error?: undefined;
+            } | {
+                error: Error;
+                parsed?: undefined;
+            }) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => {
+                parsed: Map<string, number>;
+                error?: undefined;
+            } | {
+                error: Error;
+                parsed?: undefined;
+            };
+            dependencies: [(state: RootState) => string];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import('reselect').weakMapMemoize;
+            argsMemoize: typeof import('reselect').weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('reselect').weakMapMemoize;
+        argsMemoize: typeof import('reselect').weakMapMemoize;
+    }, ((state: {
+        formulas: import('../formulas/formulasSlice').FormulasState;
+        language: import('../language/languageSlice').LanguageState;
+        structure: StructureState;
+        variables: import('../variables/variablesSlice').VariablesState;
+    }) => {
+        error: Error;
+        parsed?: undefined;
+    } | {
+        parsed: string[];
+        error?: undefined;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: string) => {
+            error: Error;
+            parsed?: undefined;
+        } | {
+            parsed: string[];
+            error?: undefined;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: string) => {
+            error: Error;
+            parsed?: undefined;
+        } | {
+            parsed: string[];
+            error?: undefined;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            error: Error;
+            parsed?: undefined;
+        } | {
+            parsed: string[];
+            error?: undefined;
+        };
+        dependencies: [(state: RootState) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import('reselect').weakMapMemoize;
+        argsMemoize: typeof import('reselect').weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import('reselect').weakMapMemoize;
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+};
+declare const _default: import('redux').Reducer<StructureState>;
+export default _default;