import { DebugProtocol } from "@vscode/debugprotocol";
import { GdbClient } from "./gdbClient";
import SourceMap from "./sourceMap";
import { DisassemblyManager } from "./disassembly";
export interface BreakpointReference<T = DebugProtocol.SourceBreakpoint | DebugProtocol.DataBreakpoint> {
    address: number;
    breakpoint: T;
    hitCount: number;
    size?: number;
}
/**
 * Interface for sizes map, which can be implemented with persistence for VS Code
 */
export interface DataBreakpointSizes {
    get(id: string): number | undefined;
    set(id: string, size: number): void;
    delete(id: string): void;
    clear(): void;
}
/**
 * Breakpoint manager
 *
 * Handles adding and removing breakpoints to program
 */
declare class BreakpointManager {
    private gdb;
    private sourceMap;
    private disassembly;
    private sizes;
    /** Source breakpoints mapped by source and line number */
    private sourceBreakpoints;
    /** Source breakpoints mapped by address */
    private sourceBreakpointsByAddress;
    /** Data breakpoints mapped by address */
    private dataBreakpoints;
    /** Instruction breakoint addresses */
    private instructionBreakpoints;
    /** Temporary breakoint address groups */
    private temporaryBreakpoints;
    private nextId;
    constructor(gdb: GdbClient, sourceMap: SourceMap, disassembly: DisassemblyManager, sizes: DataBreakpointSizes);
    setSourceBreakpoints(source: DebugProtocol.Source, breakpoints: DebugProtocol.SourceBreakpoint[]): Promise<DebugProtocol.Breakpoint[]>;
    sourceBreakpointAtAddress(address: number): BreakpointReference<DebugProtocol.SourceBreakpoint> | undefined;
    setDataBreakpoints(breakpoints: DebugProtocol.DataBreakpoint[]): Promise<DebugProtocol.Breakpoint[]>;
    parseDataId(dataId: string): {
        name: string;
        displayValue: string;
        address: number;
    };
    dataBreakpointAtAddress(address: number): BreakpointReference<DebugProtocol.DataBreakpoint> | undefined;
    setInstructionBreakpoints(breakpoints: DebugProtocol.InstructionBreakpoint[]): Promise<DebugProtocol.Breakpoint[]>;
    instructionBreakpointAtAddress(address: number): boolean;
    addTemporaryBreakpoints(pc: number): Promise<void>;
    hasTemporaryBreakpoints(): boolean;
    temporaryBreakpointAtAddress(pc: number): boolean;
    clearTemporaryBreakpoints(): Promise<void>;
}
export default BreakpointManager;