import { AvaliadorSintaticoInterface, InterpretadorInterface, LexadorInterface, RetornoExecucaoInterface } from "@designliquido/delegua/interfaces";
import { Declaracao } from "@designliquido/delegua/declaracoes";
import { ImportadorInterface } from "./interfaces";
import { ServidorDepuracao } from "./depuracao";
import { NucleoExecucaoInterface } from "./interfaces/nucleo-execucao-interface";
import { NucleoComum } from "./nucleo-comum";
export declare class NucleoExecucao extends NucleoComum implements NucleoExecucaoInterface {
    interpretador: InterpretadorInterface;
    lexador: LexadorInterface<any>;
    avaliadorSintatico: AvaliadorSintaticoInterface<any, any>;
    importador: ImportadorInterface<any>;
    resolvedor: {
        resolver: (declaracoes: Declaracao[]) => Promise<Declaracao[]>;
    };
    servidorDepuracao: ServidorDepuracao;
    versao: string;
    dialeto: string;
    modoDepuracao: boolean;
    arquivosAbertos: {
        [identificador: string]: string;
    };
    conteudoArquivosAbertos: {
        [identificador: string]: string[];
    };
    dialetos: {
        [identificador: string]: string;
    };
    funcaoDeRetorno: Function;
    funcaoDeRetornoMesmaLinha: Function;
    funcaoLimpaTela: Function;
    argumentosPrograma: string[];
    constructor(versao: string, funcaoDeRetorno?: Function, funcaoDeRetornoMesmaLinha?: Function, funcaoLimpaTela?: Function);
    funcaoLimpaTelaPadrao(): void;
    configurarDialeto(dialeto?: string, performance?: boolean, depurador?: boolean, iniciarServidorDepuracaoLegado?: boolean): void;
    executarCodigoComoArgumento(codigo: string): Promise<void>;
    /**
     * Execução por arquivo.
     * @param caminhoRelativoArquivo O caminho no sistema operacional do arquivo a ser aberto.
     */
    carregarEExecutarArquivo(caminhoRelativoArquivo: string): Promise<any>;
    /**
     * LAIR (Leia-Avalie-Imprima-Repita) é o modo em que Delégua executa em modo console,
     * ou seja, esperando como entrada linhas de código fornecidas pelo usuário.
     */
    iniciarLairDelegua(): Promise<void>;
    /**
     * A execução do código de fato.
     * @param retornoImportador Dados retornados do Importador, como o retorno do Lexador, do Avaliador
     *                          Sintático e respectivos erros.
     * @param manterAmbiente Indicação se ambiente deve ser mantido ou não. Normalmente verdadeiro
     *                       para LAIR, falso para execução por arquivo.
     * @returns Um objeto com o resultado da execução.
     */
    executar(declaracoes: Declaracao[], manterAmbiente?: boolean): Promise<RetornoExecucaoInterface>;
    /**
     * Executa uma linha. Usado pelo modo LAIR e pelo servidor de depuração, quando recebe um comando 'avaliar'.
     * @param linhas As linhas a serem avaliada.
     * @returns O resultado da execução, com os retornos e respectivos erros, se houverem.
     */
    executarLinhas(linhas: string[]): Promise<RetornoExecucaoInterface>;
    /**
     * Instancia um servidor de depuração, normalmente recebendo requisições na porta 7777.
     */
    iniciarDepuracao(): void;
    /**
     * Pede ao servidor de depuração que finalize a execução.
     * Se não for feito, o servidor de depuração mantém um _stream_ aberto e nunca finaliza.
     * Mais informações: https://stackoverflow.com/a/47456805/1314276
     */
    finalizarDepuracao(): void;
    protected erroEmTempoDeExecucao(erro: any): void;
}
//# sourceMappingURL=nucleo-execucao.d.ts.map