import * as net from 'net';
import { InterpretadorComDepuracaoInterface } from '@designliquido/delegua/interfaces';
import { NucleoExecucaoInterface } from '../interfaces/nucleo-execucao-interface';
/**
 * Esta foi a primeira implementacão do mecanismo de depuração, usando comunicação por _sockets_.
 * Inicialmente uma integração foi implementada na extensão do VSCode, mas o protocolo de
 * comunicação nunca foi exatamente maturado, em favor de uma implementação na extensão
 * usando a linguagem diretamente.
 *
 * Tem também propósito didático: por usar texto simples em vez de JSON-RPC, é a forma mais direta
 * de entender o que um depurador faz. Os comandos que não existem no protocolo histórico (a partir
 * de `capacidades`, abaixo) foram adicionados para espelhar, um a um, as requisições/eventos do
 * Debug Adapter Protocol implementado em `dap/`, documentados em `README.md`.
 */
export declare class ServidorDepuracao {
    instanciaNucleoExecucao: NucleoExecucaoInterface;
    servidor: net.Server;
    conexoes: {
        [chave: number]: any;
    };
    contadorConexoes: number;
    interpretador: InterpretadorComDepuracaoInterface;
    private registroFrames;
    private registroVariaveis;
    private filaPorConexao;
    constructor(instanciaNucleoExecucao: NucleoExecucaoInterface);
    validarPontoParada: (caminhoArquivo: string, linha: number, conexao: net.Socket) => any;
    comandoAdentrarEscopo: (conexao: net.Socket) => Promise<any>;
    comandoAdicionarPontoParada: (comando: string[], conexao: net.Socket) => any;
    comandoAvaliar: (comando: string[], conexao: net.Socket) => Promise<any>;
    comandoAvaliarVariavel: (comando: string[], conexao: net.Socket) => Promise<any>;
    /**
     * Equivalente a `initialize` do DAP: descreve a própria superfície de protocolo em vez do
     * cliente ter que adivinhar quais comandos existem.
     */
    comandoCapacidades: (conexao: net.Socket) => any;
    comandoContinuar: (conexao: net.Socket) => Promise<any>;
    /**
     * Equivalente a `setBreakpoints` do DAP: substitui, numa única chamada, todo o conjunto de
     * pontos de parada de um arquivo, respondendo `verificado`/`nao-verificado` por linha.
     * `adicionar-ponto-parada`/`remover-ponto-parada` continuam existindo para edição incremental
     * e compartilham a mesma validação via `validarPontoParada`.
     */
    comandoDefinirPontosParada: (comando: string[], conexao: net.Socket) => any;
    /**
     * Equivalente a `disconnect` do DAP: finaliza a sessão de depuração do núcleo de execução
     * (diferente de `tchau`, que só encerra a conexão de quem pediu) e avisa todos os clientes.
     */
    comandoEncerrarSessao: (conexao: net.Socket) => any;
    /**
     * Equivalente a `scopes` do DAP: dado um `frameId` obtido via `pilha-execucao`, responde a
     * referência de variáveis daquele quadro, para consulta com `variaveis-referencia`.
     */
    comandoEscopos: (comando: string[], conexao: net.Socket) => any;
    comandoPilhaExecucao: (conexao: net.Socket) => any;
    comandoPontosParada: (conexao: net.Socket) => any;
    comandoProximo: (conexao: net.Socket) => Promise<any>;
    /**
     * Equivalente a `launch` do DAP, mas vindo do cliente em vez de configurado pela CLI: permite
     * trocar ou recarregar o programa em depuração sem reiniciar o processo Node.
     */
    comandoReiniciar: (comando: string[], conexao: net.Socket) => Promise<any>;
    comandoRemoverPontoParada: (comando: string[], conexao: net.Socket) => any;
    comandoSairEscopo: (conexao: net.Socket) => Promise<any>;
    /**
     * Equivalente a `threads` do DAP. O interpretador Delégua é de thread única, mas o comando
     * existe para completar o paralelo de protocolo e preparar terreno para suporte futuro.
     */
    comandoLinhasExecucao: (conexao: net.Socket) => any;
    comandoVariaveis: (conexao: net.Socket) => any;
    /**
     * Equivalente a `variables` do DAP: dada uma referência obtida via `escopos` (ou outra
     * `variaveis-referencia` anterior), lista as variáveis daquele recipiente. Quando um valor é
     * objeto ou vetor, uma nova referência é registrada para ele, permitindo navegação recursiva
     * em vez do `JSON.stringify` cego usado por `variaveis`.
     */
    comandoVariaveisReferencia: (comando: string[], conexao: net.Socket) => any;
    /**
     * Emite um evento assíncrono (estilo `stopped`/`continued`/`terminated` do DAP) para todos os
     * clientes conectados, sem que precisem pollar comandos como `pilha-execucao` após cada passo.
     */
    private emitirEvento;
    /** Localiza arquivo/linha da declaração em execução no topo da pilha de escopos. */
    private obterLocalizacaoAtual;
    /** Emite `parado` (com a localização atual) ou `encerrado`, conforme o resultado de um passo/continue. */
    private emitirEventoDeParada;
    /** Despacha um comando de texto já tokenizado para o `comando*` correspondente. */
    private executarComando;
    /**
     * Despacha um comando, serializando-o após qualquer comando assíncrono ainda pendente na mesma
     * conexão. Quando a fila está ociosa, o comando é executado de forma síncrona/imediata, igual ao
     * comportamento histórico; só quando há um comando assíncrono em andamento é que a execução do
     * próximo comando é adiada até ele terminar — evitando que dois comandos leiam/alterem o estado
     * do interpretador ao mesmo tempo quando um cliente envia vários comandos em sequência rápida.
     */
    private despacharComando;
    private registrarNaFila;
    /**
     * Função que descreve como conexão com clientes de depuração deve ser operada.
     * @param conexao Instância de conexão, tipo net.Socket.
     */
    operarConexao: (conexao: net.Socket) => void;
    iniciarServidorDepuracao(): net.AddressInfo;
    escreverSaidaParaTodosClientes(mensagem: string): void;
    finalizarServidorDepuracao(): void;
}
//# sourceMappingURL=servidor-depuracao.d.ts.map