import BoardInterface from './board/BoardInterface';
declare class Debugger {
    private _traceSize;
    private _stepMaxCycles;
    constructor(_traceSize?: number, _stepMaxCycles?: number);
    attach(board: BoardInterface): Debugger;
    detach(): Debugger;
    clearAllBreakpoints(): Debugger;
    setBreakpoint(address: number, description?: string): Debugger;
    clearBreakpoint(address: number): Debugger;
    dumpBreakpoints(): string;
    loadBlock(block: Debugger.MemoryBlockInterface, at: number, from?: number, to?: number): void;
    disassembleAt(start: number, length: number): string;
    disassemble(length: number): string;
    trace(length?: number): string;
    dumpAt(start: number, length: number): string;
    dumpState(): string;
    dumpStack(): string;
    step(instructions: number): {
        cycles: number;
        cpuCycles: number;
    };
    stepClock(cycles: number): number;
    setBreakpointsEnabled(breakpointsEnabled: boolean): Debugger;
    setTraceEnabled(traceEnabled: boolean): Debugger;
    getBoard(): BoardInterface;
    getLastTrap(): BoardInterface.TrapPayload;
    private _humanReadableExecutionState;
    private _attachToCpuIfNecessary;
    private _cpuClockHandler;
    private _trapHandler;
    private _peek;
    private _poke;
    private _disassembler;
    private _cpu;
    private _bus;
    private _board;
    private _breakpoints;
    private _breakpointDescriptions;
    private _breakpointsEnabled;
    private _traceEnabled;
    private _trace;
    private _traceLength;
    private _traceIndex;
    private _lastInstructionPointer;
    private _lastTrap;
}
declare namespace Debugger {
    interface MemoryBlockInterface {
        [index: number]: number;
        length: number;
    }
}
export { Debugger as default };