import type { DataflowProcessorInformation } from '../processor';
import type { DataflowInformation, ExitPointType } from '../info';
import { processAccess } from '../internal/process/functions/call/built-in/built-in-access';
import { processIfThenElse } from '../internal/process/functions/call/built-in/built-in-if-then-else';
import { processAssignment } from '../internal/process/functions/call/built-in/built-in-assignment';
import { processSpecialBinOp } from '../internal/process/functions/call/built-in/built-in-special-bin-op';
import { processPipe } from '../internal/process/functions/call/built-in/built-in-pipe';
import { processForLoop } from '../internal/process/functions/call/built-in/built-in-for-loop';
import { processRepeatLoop } from '../internal/process/functions/call/built-in/built-in-repeat-loop';
import { processWhileLoop } from '../internal/process/functions/call/built-in/built-in-while-loop';
import type { Identifier, IdentifierDefinition, IdentifierReference } from './identifier';
import { ReferenceType } from './identifier';
import { processReplacementFunction } from '../internal/process/functions/call/built-in/built-in-replacement';
import { processQuote } from '../internal/process/functions/call/built-in/built-in-quote';
import { processFunctionDefinition } from '../internal/process/functions/call/built-in/built-in-function-definition';
import { processExpressionList } from '../internal/process/functions/call/built-in/built-in-expression-list';
import { processGet } from '../internal/process/functions/call/built-in/built-in-get';
import type { AstIdMap, ParentInformation, RNodeWithParent } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
import type { RFunctionArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
import type { RSymbol } from '../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
import { processLibrary } from '../internal/process/functions/call/built-in/built-in-library';
import { processSourceCall } from '../internal/process/functions/call/built-in/built-in-source';
import type { ForceArguments } from '../internal/process/functions/call/common';
import { processApply } from '../internal/process/functions/call/built-in/built-in-apply';
import type { LinkTo } from '../../queries/catalog/call-context-query/call-context-query-format';
import { processList } from '../internal/process/functions/call/built-in/built-in-list';
import { processVector } from '../internal/process/functions/call/built-in/built-in-vector';
import { processRm } from '../internal/process/functions/call/built-in/built-in-rm';
import { processEvalCall } from '../internal/process/functions/call/built-in/built-in-eval';
import type { REnvironmentInformation } from './environment';
import type { Value } from '../eval/values/r-value';
import { resolveAsMinus, resolveAsPlus, resolveAsSeq, resolveAsVector } from '../eval/resolve/resolve';
import type { DataflowGraph } from '../graph/graph';
import type { VariableResolve } from '../../config';
import type { BuiltInConstantDefinition, BuiltInDefinition, BuiltInFunctionDefinition, BuiltInReplacementDefinition } from './built-in-config';
export type BuiltIn = `built-in:${string}`;
export declare function builtInId(name: string): BuiltIn;
export declare function isBuiltIn(name: NodeId | string): name is BuiltIn;
export type BuiltInIdentifierProcessor = <OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>) => DataflowInformation;
export type BuiltInIdentifierProcessorWithConfig<Config> = <OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: Config) => DataflowInformation;
export interface BuiltInIdentifierDefinition extends IdentifierReference {
    type: ReferenceType.BuiltInFunction;
    definedAt: BuiltIn;
    processor: BuiltInIdentifierProcessor;
    config?: object;
}
export interface BuiltInIdentifierConstant<T = unknown> extends IdentifierReference {
    type: ReferenceType.BuiltInConstant;
    definedAt: BuiltIn;
    value: T;
}
export type UseAsProcessors = 'builtin:default' | 'builtin:return' | 'builtin:stop';
export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
    readonly returnsNthArgument?: number | 'last';
    readonly cfg?: ExitPointType;
    readonly readAllArguments?: boolean;
    readonly hasUnknownSideEffects?: boolean | LinkTo;
    /** record mapping the actual function name called to the arguments that should be treated as function calls */
    readonly treatAsFnCall?: Record<string, readonly string[]>;
    /** Name that should be used for the origin (useful when needing to differentiate between
     * functions like 'return' that use the default builtin processor)
     */
    readonly useAsProcessor?: UseAsProcessors;
}
export type BuiltInEvalHandler = (resolve: VariableResolve, a: RNodeWithParent, env?: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap) => Value;
declare function defaultBuiltInProcessor<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { returnsNthArgument, useAsProcessor, forceArgs, readAllArguments, cfg, hasUnknownSideEffects, treatAsFnCall }: DefaultBuiltInProcessorConfiguration): DataflowInformation;
export declare const BuiltInProcessorMapper: {
    readonly 'builtin:default': typeof defaultBuiltInProcessor;
    readonly 'builtin:eval': typeof processEvalCall;
    readonly 'builtin:apply': typeof processApply;
    readonly 'builtin:expression-list': typeof processExpressionList;
    readonly 'builtin:source': typeof processSourceCall;
    readonly 'builtin:access': typeof processAccess;
    readonly 'builtin:if-then-else': typeof processIfThenElse;
    readonly 'builtin:get': typeof processGet;
    readonly 'builtin:rm': typeof processRm;
    readonly 'builtin:library': typeof processLibrary;
    readonly 'builtin:assignment': typeof processAssignment;
    readonly 'builtin:special-bin-op': typeof processSpecialBinOp;
    readonly 'builtin:pipe': typeof processPipe;
    readonly 'builtin:function-definition': typeof processFunctionDefinition;
    readonly 'builtin:quote': typeof processQuote;
    readonly 'builtin:for-loop': typeof processForLoop;
    readonly 'builtin:repeat-loop': typeof processRepeatLoop;
    readonly 'builtin:while-loop': typeof processWhileLoop;
    readonly 'builtin:replacement': typeof processReplacementFunction;
    readonly 'builtin:list': typeof processList;
    readonly 'builtin:vector': typeof processVector;
};
export declare const BuiltInEvalHandlerMapper: {
    readonly 'built-in:c': typeof resolveAsVector;
    readonly 'built-in::': typeof resolveAsSeq;
    readonly 'built-in:+': typeof resolveAsPlus;
    readonly 'built-in:-': typeof resolveAsMinus;
};
export type BuiltInMappingName = keyof typeof BuiltInProcessorMapper;
export type ConfigOfBuiltInMappingName<N extends BuiltInMappingName> = Parameters<typeof BuiltInProcessorMapper[N]>[4];
export type BuiltInMemory = Map<Identifier, IdentifierDefinition[]>;
export declare class BuiltIns {
    /**
     * Register a built-in constant (like `NULL` or `TRUE`) to the given {@link builtIns}
     */
    registerBuiltInConstant<T>({ names, value, assumePrimitive }: BuiltInConstantDefinition<T>): void;
    /**
     * Register a built-in function (like `print` or `c`) to the given {@link builtIns}
     */
    registerBuiltInFunctions<BuiltInProcessor extends BuiltInMappingName>({ names, processor, config, assumePrimitive }: BuiltInFunctionDefinition<BuiltInProcessor>): void;
    /**
     * Registers all combinations of replacements
     */
    registerReplacementFunctions({ names, suffixes, assumePrimitive, config }: BuiltInReplacementDefinition): void;
    /**
     * Register a single {@link BuiltInDefinition} to the given memories in {@link builtIns}
     */
    registerBuiltInDefinition(definition: BuiltInDefinition): void;
    /**
     * The built-in {@link REnvironmentInformation|environment} is the root of all environments.
     *
     * For its default content (when not overwritten by a flowR config),
     * see the {@link DefaultBuiltinConfig}.
     */
    builtInMemory: BuiltInMemory;
    /**
     * The twin of the {@link builtInMemory} but with less built ins defined for
     * cases in which we want some commonly overwritten variables to remain open.
     * If you do not know if you need the empty environment, you do not need the empty environment (right now).
     *
     * @see {@link builtInMemory}
     */
    emptyBuiltInMemory: BuiltInMemory;
    set(identifier: Identifier, definition: IdentifierDefinition[], includeInEmptyMemory: boolean | undefined): void;
}
export {};