import TransformerFunction from "./TransformerFunction";
import { ParameterResolver } from "../../ParameterResolver";
import { JsonTransformerFunction } from "../../JsonTransformerFunction";
import JsonElementStreamer from "../../JsonElementStreamer";
import BigNumber from "bignumber.js";
import { ArgumentsSet } from "./FunctionDescription";
declare class FunctionContext {
    protected static readonly CONTEXT_KEY = "context";
    protected static readonly DOUBLE_HASH_CURRENT = "##current";
    protected static readonly DOUBLE_HASH_INDEX = "##index";
    protected static readonly DOLLAR = "$";
    protected readonly path: string;
    protected readonly alias: string;
    protected readonly function: TransformerFunction;
    protected readonly extractor: JsonTransformerFunction;
    private readonly argsSet;
    private readonly isInline;
    private readonly args;
    private readonly defaultValues;
    private resolver;
    private readonly resolverFactory;
    private constructor();
    static createInline(path: string, input: string | null, args: (string | null)[], functionKey: string, func: any, resolver: any, extractor: any): FunctionContext;
    static createObject(path: string, definition: any, functionKey: string, func: any, resolver: any, extractor: any): FunctionContext;
    protected static recalcResolver(path: string, contextElement: any, resolver: ParameterResolver, extractor: JsonTransformerFunction): Promise<ParameterResolver>;
    /**
     * Check if the specified path is of the specified variable
     * @param _var variable name
     * @param path  path to check
     * @return true if the path is of the variable
     */
    static pathOfVar(_var: string, path: string): boolean;
    getAlias(): string;
    getPath(): string;
    getFunction(): TransformerFunction;
    getArgumentSet(): ArgumentsSet | null;
    getDefaultValue(name: string): any;
    apply(): Promise<any>;
    getResolver(): Promise<ParameterResolver>;
    has(name: string): boolean;
    getRaw(name: string | null): string | null | undefined;
    get(name: string | null, transform?: boolean): Promise<any>;
    getPathFor(key: number | string | null): string;
    isNull(value: any): boolean;
    getUnwrapped(name: string | null, reduceBigDecimals?: boolean): Promise<any>;
    compareTo(a: any, b: any): number | null;
    getJsonElement(name: string | null, transform?: boolean): Promise<any>;
    getBoolean(name: string | null, transform?: boolean): Promise<boolean | null>;
    getString(name: string | null, transform?: boolean): Promise<string | null>;
    getEnum(name: string | null, transform?: boolean): Promise<string | null>;
    getInteger(name: string | null, transform?: boolean): Promise<number | null>;
    getLong(name: string | null, transform?: boolean): Promise<bigint | null>;
    getBigDecimal(name: string | null, transform?: boolean): Promise<BigNumber | null>;
    getJsonArray(name: string | null, transform?: boolean): Promise<any[] | null>;
    /**
     * Use this method instead of getJsonArray if you plan on iterating over the array
     * The pros of using this method are
     * - That it will not transform all the array to a single (possibly huge) array in memory
     * - It lazy transforms the array elements, so if there is short-circuiting, some transformations might be prevented
     * @return JsonElementStreamer
     */
    getJsonElementStreamer(name: string | null): Promise<JsonElementStreamer | null>;
    transform(path: string | undefined, definition: any, allowReturningStreams?: boolean): Promise<any>;
    transformItem(definition: any, current: any, index?: number, additionalNameOrContext?: string | Record<string, any>, additional?: any): Promise<any>;
}
export default FunctionContext;
//# sourceMappingURL=FunctionContext.d.ts.map