/**
 * @license
 * Copyright (c) 2025 Handsoncode. All rights reserved.
 */
import { Config } from '../Config';
import { TranslationSet } from '../i18n';
import { Maybe } from '../Maybe';
import { Interpreter } from './Interpreter';
import { FunctionMetadata, FunctionPluginDefinition, PluginArraySizeFunctionType, PluginFunctionType } from './plugin/FunctionPlugin';
export declare type FunctionTranslationsPackage = Record<string, TranslationSet>;
export declare class FunctionRegistry {
    private config;
    static plugins: Map<string, FunctionPluginDefinition>;
    private static readonly _protectedPlugins;
    private readonly instancePlugins;
    private readonly functions;
    private readonly arraySizeFunctions;
    private readonly volatileFunctions;
    private readonly arrayFunctions;
    private readonly structuralChangeFunctions;
    private readonly functionsWhichDoesNotNeedArgumentsToBeComputed;
    private readonly functionsMetadata;
    constructor(config: Config);
    static registerFunctionPlugin(plugin: FunctionPluginDefinition, translations?: FunctionTranslationsPackage): void;
    static registerFunction(functionId: string, plugin: FunctionPluginDefinition, translations?: FunctionTranslationsPackage): void;
    static unregisterFunction(functionId: string): void;
    static unregisterFunctionPlugin(plugin: FunctionPluginDefinition): void;
    static unregisterAll(): void;
    static getRegisteredFunctionIds(): string[];
    static getPlugins(): FunctionPluginDefinition[];
    static getFunctionPlugin(functionId: string): Maybe<FunctionPluginDefinition>;
    static functionIsProtected(functionId: string): boolean;
    private static loadTranslations;
    private static loadPluginFunctions;
    private static loadPluginFunction;
    /**
     * Handles deprecated metadata properties.
     */
    private static handleDeprecatedMetadata;
    /**
     * Loads a function into the registry.
     */
    private static loadFunctionUnprotected;
    private static protectedFunctions;
    private static protectedPlugins;
    initializePlugins(interpreter: Interpreter): void;
    getFunctionPlugin(functionId: string): Maybe<FunctionPluginDefinition>;
    /**
     * Returns the ids of all functions the function-metadata API (`getAvailableFunctions`/`getFunctionDetails`)
     * should describe: every function registered in this instance (aliases and any custom/user-registered functions
     * included), plus the protected ids (e.g. `VERSION`, `OFFSET`). `instancePlugins` already contains `VERSION`
     * (the constructor loads any protected id that has a plugin, unprotected, so it can be executed), but not
     * `OFFSET` (it has no plugin at all — it is transformed at parse time). Appending
     * `FunctionRegistry._protectedPlugins`'s keys explicitly covers both uniformly instead of relying on the
     * constructor's incidental loading; de-duplicated via `Set` because `VERSION` would otherwise be listed twice
     * (once from `instancePlugins`, once from `_protectedPlugins`). A user can see these ids via
     * `getAvailableFunctions`/`getFunctionDetails` even though they can never be unregistered (HF-249).
     *
     * Callability is the whole rule: omitting an id would hide a working function from a function picker. Whether a
     * listed id is *described as* a built-in depends on whether a catalogue entry exists for that id.
     */
    getListableFunctionIds(): string[];
    getFunction(functionId: string): Maybe<PluginFunctionType>;
    getArraySizeFunction(functionId: string): Maybe<PluginArraySizeFunctionType>;
    getMetadata(functionId: string): Maybe<FunctionMetadata>;
    getPlugins(): FunctionPluginDefinition[];
    getRegisteredFunctionIds(): string[];
    doesFunctionNeedArgumentToBeComputed: (functionId: string) => boolean;
    isFunctionVolatile: (functionId: string) => boolean;
    isArrayFunction: (functionId: string) => boolean;
    isFunctionDependentOnSheetStructureChange: (functionId: string) => boolean;
    private categorizeFunction;
}