import { Construto, FuncaoConstruto, Leia } from '@designliquido/delegua/construtos';
import { Escreva, Declaracao, Se, Enquanto, Para, Escolha, Fazer, FuncaoDeclaracao, Expressao, Var, EscrevaMesmaLinha, Retorna, Const, Comentario, Sustar } from '@designliquido/delegua/declaracoes';
import { RetornoLexador, RetornoAvaliadorSintatico } from '@designliquido/delegua/interfaces/retornos';
import { AvaliadorSintaticoBase } from '@designliquido/delegua/avaliador-sintatico';
import { TipoInferencia } from '@designliquido/delegua/inferenciador';
import { ParametroInterface, SimboloInterface } from '@designliquido/delegua/interfaces';
import { Limpa } from '../construtos';
/**
 * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
 * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
 * Há dois grupos de estruturas de alto nível: Construtos e Declarações.
 */
export declare class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
    private declaracoes;
    private pilhaEscopos;
    constructor();
    verificarTipoSimboloAtual(tipo: string): boolean;
    avancarEDevolverAnterior(): SimboloInterface<string>;
    estaNoFinal(): boolean;
    declaracaoEscreva(): Promise<Escreva>;
    private validarEscopoProgramaEAvaliacaoSintatica;
    comparacaoIgualdade(): Promise<Construto>;
    primario(): Promise<Construto>;
    chamar(): Promise<Construto>;
    /**
     * Se símbolo de operação é `+`, `-`, `+=` ou `-=`, monta objeto `Binario` para
     * ser avaliado pelo Interpretador.
     * @returns Um Construto, normalmente um `Binario`, ou `Unario` se houver alguma operação unária para ser avaliada.
     */
    adicaoOuSubtracao(): Promise<Construto>;
    atribuir(): Promise<Construto>;
    declaracaoEscrevaMesmaLinha(): Promise<EscrevaMesmaLinha>;
    /**
     * Declaração para inclusão de uma biblioteca.
     * Exemplo: `inclua biblioteca Matematica --> mat` seria o mesmo que
     * `const mat = importar('Matematica')` em Delégua, ou
     * `inclua biblioteca Matematica` (sem o nome da variável) seria o
     * mesmo que `const Matematica = importar('Matematica')`
     * @returns Uma declaração do tipo `Importar`.
     */
    declaracaoInclua(): Const;
    blocoEscopo(): Promise<Declaracao[]>;
    declaracaoSe(): Promise<Se>;
    declaracaoEnquanto(): Promise<Enquanto>;
    declaracaoEscolha(): Promise<Escolha>;
    /**
     * No Portugol Studio, a palavra reservada é `faca`, sem acento.
     */
    declaracaoFazer(): Promise<Fazer>;
    simboloAtual(): SimboloInterface;
    verificarDefinicaoTipo(lexema: string): TipoInferencia;
    protected logicaComumParametros(): Promise<ParametroInterface[]>;
    corpoDaFuncao(tipo: string): Promise<FuncaoConstruto>;
    /**
     * Declaração de apenas uma variável.
     * Neste caso, o símbolo que determina o tipo da variável já foi consumido,
     * e o retorno conta com apenas uma variável retornada.
     */
    declaracaoDeVariavel(): Var;
    declaracaoCadeiasCaracteres(): Promise<Var[]>;
    declaracaoCaracteres(): Promise<Var[]>;
    declaracaoComentarioMultilinha(): Comentario;
    declaracaoComentarioUmaLinha(): Comentario;
    declaracaoExpressao(simboloAnterior?: SimboloInterface): Promise<Expressao>;
    private obterTamanhoEsperadoDimensao;
    /**
     * Método recursivo que lê os valores de inicialização de uma matriz de N dimensões.
     * @param {Construto[]} dimensoes O número de dimensões faltantes.
     * Cada passo recursivo usa o primeiro valor e chama a função passando esse vetor, mas sem
     * o primeiro valor.
     */
    protected lerValoresAtribuicaoMatriz(dimensoes: Construto[], indiceDimensaoAtual?: number): Promise<any[]>;
    protected declaracaoVetorOuMatriz(simboloTipo: SimboloInterface, identificador: SimboloInterface, dimensoes: Construto[], tipoDados?: string): Promise<Var>;
    protected declaracaoVariavelSemDimensoes(simboloInteiro: SimboloInterface, identificador: SimboloInterface, tipoDados?: string): Promise<Var>;
    protected logicaComumDimensoesMatrizes(): Promise<Construto[]>;
    declaracaoInteiros(): Promise<Var[]>;
    /**
     * Análise de uma declaração `leia()`. No VisuAlg, `leia()` aceita 1..N argumentos.
     * @returns Uma declaração `Leia`.
     */
    expressaoLeia(): Promise<Leia>;
    declaracaoLogicos(): Var[];
    declaracaoRetorne(): Promise<Retorna>;
    declaracaoPare(): Sustar;
    declaracaoPara(): Promise<Para>;
    declaracaoReais(): Promise<Var[]>;
    expressao(): Promise<Construto>;
    expressaoLimpa(): Limpa;
    funcao(tipo: string): Promise<FuncaoDeclaracao>;
    declaracaoDeConstantes(): Promise<Const>;
    resolverDeclaracaoForaDeBloco(): Promise<Declaracao | Declaracao[] | undefined>;
    /**
     * Usado quando há erros na avaliação sintática.
     * Garante que o avaliador sintático não entre em _loop_ infinito.
     * @returns Sempre retorna `void`.
     */
    protected sincronizar(): void;
    analisar(retornoLexador: RetornoLexador<SimboloInterface>, hashArquivo: number): Promise<RetornoAvaliadorSintatico<Declaracao>>;
}
//# sourceMappingURL=avaliador-sintatico-portugol-studio.d.ts.map