import { AcessoIndiceVariavel, AcessoMetodo, AcessoMetodoOuPropriedade, AcessoPropriedade, AtribuicaoPorIndice, Atribuir, ComentarioComoConstruto, DefinirValor, Dicionario, EnquantoComoConstruto, FazerComoConstruto, ListaCompreensao, ParaCadaComoConstruto, ParaComoConstruto, Separador, TipoDe, Unario, Vetor, ImportarComoConstruto, Elvis, SeTernario, TuplaN, AjudaComoConstruto } from '../construtos';
import { ReferenciaMontao } from './estruturas';
import { ResultadoParcialInterpretadorInterface, RetornoInterpretadorInterface, VisitanteDeleguaInterface } from '../interfaces';
import { InterpretadorBase } from './interpretador-base';
import { Ajuda, Const, ConstMultiplo, Declaracao, Enquanto, Fazer, FuncaoDeclaracao, Para, ParaCada, Retorna, TendoComo, Var, VarMultiplo } from '../declaracoes';
import { RetornoQuebra } from '../quebras';
import { Montao } from './montao';
import { EnquantoInterface, FazerInterface, ParaCadaInterface, ParaInterface } from '../interfaces/delegua';
/**
 * O interpretador de Delégua, usado também por Pituguês usando herança.
 * @see InterpretadorPitugues
 */
export declare class Interpretador extends InterpretadorBase implements VisitanteDeleguaInterface {
    montao: Montao;
    acumularRetornos: boolean;
    constructor(diretorioBase: string, performance?: boolean, funcaoDeRetorno?: Function, funcaoDeRetornoMesmaLinha?: Function);
    /**
     * Cada dialeto que deriva deste interpretador conhece este ponto de inicialização.
     * A partir daqui, cada dialeto pode carregar as bibliotecas globais específicas do seu dialeto.
     */
    protected pontoInicializacaoBibliotecasGlobais(): void;
    protected resolverReferenciaMontao(referenciaMontao: ReferenciaMontao): any;
    resolverValor(objeto: any, referencia?: boolean): any;
    private serializarSemEspacos;
    paraTexto(objeto: any): string;
    avaliacaoDeclaracaoVarOuConst(declaracao: Const | ConstMultiplo | Var | VarMultiplo): Promise<any>;
    /**
     * Declaração de ajuda.
     * Neste interpretador básico, a ajuda apenas retorna texto sobre um determinado
     * tópico, ou ainda sobre a ajuda em si.
     * Outros ambientes implementam mecanismos mais sofisticados, como o modo de ajuda.
     * @param declaracao A declaração de ajuda.
     */
    visitarDeclaracaoAjuda(declaracao: Ajuda): Promise<any>;
    visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): Promise<any>;
    protected logicaComumExecucaoEnquanto(enquanto: EnquantoInterface, acumularRetornos: boolean): Promise<ResultadoParcialInterpretadorInterface | {
        valorRetornado: any[];
        tipo: string;
    }>;
    visitarDeclaracaoEnquanto(declaracao: Enquanto): Promise<any>;
    protected logicaComumExecucaoFazer(fazer: FazerInterface, acumularRetornos: boolean): Promise<{
        valorRetornado: any[];
        tipo: string;
    }>;
    visitarDeclaracaoFazer(declaracao: Fazer): Promise<any>;
    protected logicaComumExecucaoPara(para: ParaInterface, acumularRetornos: boolean): Promise<any>;
    visitarDeclaracaoPara(declaracao: Para): Promise<any>;
    protected logicaComumExecucaoParaCada(paraCada: ParaCadaInterface, acumularRetornos: boolean): Promise<any>;
    visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any>;
    visitarDeclaracaoTendoComo(declaracao: TendoComo): Promise<any>;
    visitarExpressaoAcessoIndiceVariavel(expressao: AcessoIndiceVariavel): Promise<any>;
    visitarExpressaoAcessoMetodo(expressao: AcessoMetodo): Promise<any>;
    /**
     * Casos que ocorrem aqui:
     *
     * - Quando o método ou propriedade é ou 'qualquer', ou vetor
     *   de 'qualquer' ('qualquer[]'), e uma primitiva é usada.
     * - Quando o objeto é uma classe definida em código.
     * @param {AcessoMetodoOuPropriedade} expressao A expressão de acesso a método ou propriedade.
     * @returns A primitiva encontrada.
     */
    visitarExpressaoAcessoMetodoOuPropriedade(expressao: AcessoMetodoOuPropriedade): Promise<any>;
    visitarExpressaoAcessoPropriedade(expressao: AcessoPropriedade): Promise<any>;
    visitarExpressaoAjuda(expressao: AjudaComoConstruto): Promise<any>;
    visitarExpressaoAtribuicaoPorIndice(expressao: AtribuicaoPorIndice): Promise<any>;
    /**
     * Em Delégua e Pituguês, comentários não são importantes para a interpretação.
     * @param expressao Uma `Promise` sempre resolvida.
     */
    visitarExpressaoComentario(expressao: ComentarioComoConstruto): Promise<any>;
    /**
     * Execução de uma expressão de atribuição.
     * @param expressao A expressão.
     * @returns O valor atribuído.
     */
    visitarExpressaoDeAtribuicao(expressao: Atribuir): Promise<any>;
    visitarExpressaoDefinirValor(expressao: DefinirValor): Promise<any>;
    /**
     * Dicionários em Delégua são passados por referência, portanto, são
     * armazenados no montão.
     */
    visitarExpressaoDicionario(expressao: Dicionario): Promise<any>;
    visitarExpressaoElvis(expressao: Elvis): Promise<any>;
    visitarExpressaoEnquanto(expressao: EnquantoComoConstruto): Promise<any> | void;
    visitarExpressaoFazer(expressao: FazerComoConstruto): Promise<any> | void;
    visitarExpressaoImportar(expressao: ImportarComoConstruto): Promise<any> | void;
    visitarExpressaoListaCompreensao(listaCompreensao: ListaCompreensao): Promise<any>;
    visitarExpressaoPara(expressao: ParaComoConstruto): Promise<any> | void;
    visitarExpressaoParaCada(expressao: ParaCadaComoConstruto): Promise<any>;
    visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra>;
    /**
     * Para Delégua e Pituguês, o separador é apenas um elemento de sintaxe.
     * Não há qualquer avaliação a ser feita.
     * @param expressao
     */
    visitarExpressaoSeparador(expressao: Separador): Promise<any>;
    visitarExpressaoSeTernario(expressao: SeTernario): Promise<any>;
    visitarExpressaoTipoDe(expressao: TipoDe): Promise<string>;
    visitarExpressaoUnaria(expressao: Unario): Promise<any>;
    visitarExpressaoVetor(expressao: Vetor): Promise<any>;
    /**
     * Executa o último escopo empilhado no topo na pilha de escopos do interpretador.
     * Esse método pega exceções, mas apenas as devolve.
     *
     * O tratamento das exceções é feito de acordo com o bloco chamador.
     * Por exemplo, em `tente ... pegue ... finalmente`, a exceção é capturada e tratada.
     * Em outros blocos, pode ser desejável ter o erro em tela.
     * @param manterAmbiente Se verdadeiro, ambiente do topo da pilha de escopo é copiado para o ambiente imediatamente abaixo.
     * @returns O resultado da execução do escopo, se houver.
     */
    executarUltimoEscopo(manterAmbiente?: boolean): Promise<ResultadoParcialInterpretadorInterface>;
    visitarExpressaoTuplaN(expressao: TuplaN): Promise<any>;
    /**
     * Método que efetivamente inicia o processo de interpretação.
     * @param declaracoes Um vetor de declarações gerado pelo Avaliador Sintático.
     * @param manterAmbiente Se ambiente de execução (variáveis, classes, etc.) deve ser mantido. Normalmente usado
     *                       pelo modo REPL (LAIR).
     * @returns Um objeto com o resultado da interpretação.
     */
    interpretar(declaracoes: Declaracao[], manterAmbiente?: boolean): Promise<RetornoInterpretadorInterface>;
}
//# sourceMappingURL=interpretador.d.ts.map