import type { MapDocumentNode } from '@superfaceai/ast';
import type { IConfig, ICrypto, ILogger, MapInterpreterError } from '../../interfaces';
import type { ISandbox } from '../../interfaces/sandbox';
import type { NonPrimitive, Result, Variables } from '../../lib';
import { SDKExecutionError, UnexpectedError } from '../../lib';
import type { IServiceSelector } from '../services';
import type { MapInterpreterExternalHandler } from './external-handler';
import type { AuthCache, SecurityConfiguration } from './http';
import type { IFetch } from './http/interfaces';
export interface MapParameters<TInput extends NonPrimitive | undefined = undefined> {
    usecase?: string;
    input?: TInput;
    parameters?: Record<string, string>;
    services: IServiceSelector;
    security: SecurityConfiguration[];
}
declare type PerformResult = Result<Variables | undefined, MapInterpreterError | UnexpectedError | SDKExecutionError>;
export declare class MapInterpreter<TInput extends NonPrimitive | undefined> {
    private readonly parameters;
    private static handleFinalOutcome;
    private static wrapOutcomeError;
    private static enrichError;
    private static gatherOperations;
    private static findEntry;
    private static initializeInput;
    private static destroyInput;
    private static resolveOutcomeVariables;
    private readonly http;
    private readonly externalHandler;
    private readonly sandbox;
    private readonly config;
    private readonly logger?;
    private readonly log;
    constructor(parameters: MapParameters<TInput>, { fetchInstance, externalHandler, sandbox, config, logger, crypto, }: {
        fetchInstance: IFetch & AuthCache;
        externalHandler?: MapInterpreterExternalHandler;
        sandbox: ISandbox;
        config: IConfig;
        crypto: ICrypto;
        logger?: ILogger;
    });
    perform(ast: MapDocumentNode): Promise<PerformResult>;
    private performStream;
    private createVisitor;
}
export {};