import type { CodeWithSourceMap } from 'source-map';
import type { DebugProtocol } from '@vscode/debugprotocol';
import type { Project } from './ProjectManager';
import type { SourceMapManager } from './SourceMapManager';
import type { LocationManager } from './LocationManager';
export declare class BreakpointManager {
    private sourceMapManager;
    private locationManager;
    /**
     * @deprecated temporary flag. AST-based breakpoint validation is disabled in production because Roku
     * silently relocates a breakpoint on a non-runnable line to the next runnable line, so rejecting it
     * would take away behavior the user has. Enabled in tests. Remove once we can relocate breakpoints
     * ourselves instead of dropping them.
     */
    private enableAstBreakpointValidation;
    constructor(sourceMapManager: SourceMapManager, locationManager: LocationManager, 
    /**
     * @deprecated temporary flag. AST-based breakpoint validation is disabled in production because Roku
     * silently relocates a breakpoint on a non-runnable line to the next runnable line, so rejecting it
     * would take away behavior the user has. Enabled in tests. Remove once we can relocate breakpoints
     * ourselves instead of dropping them.
     */
    enableAstBreakpointValidation?: boolean);
    private logger;
    launchConfiguration: {
        sourceDirs: string[];
        rootDir: string;
        enableSourceMaps?: boolean;
        /**
         * When true the session uses the DebugProtocol (on-device) debugger, which sets breakpoints by
         * line number. When false/undefined it's a telnet session, where breakpoints are only possible by
         * writing literal `STOP` statements into the staged files.
         */
        enableDebugProtocol?: boolean;
    };
    private emitter;
    private emit;
    /**
     * Subscribe to an event
     */
    on(eventName: 'breakpoints-verified', handler: (data: {
        breakpoints: AugmentedSourceBreakpoint[];
    }) => any): any;
    /**
     * Get a promise that resolves the next time the specified event occurs
     */
    once(eventName: 'breakpoints-verified'): Promise<{
        breakpoints: AugmentedSourceBreakpoint[];
    }>;
    /**
     * A map of breakpoints by what file they were set in.
     * This does not handle any source-to-dest mapping...these breakpoints are stored in the file they were set in.
     * These breakpoints are all set before launch, and then this list is not changed again after that.
     * (this concept may need to be modified once we get live breakpoint support)
     */
    private breakpointsByFilePath;
    /**
     * A list of breakpoints that failed to delete and will be deleted as soon as possible
     */
    failedDeletions: BreakpointWorkItem[];
    /**
     * A sequence used to generate unique client breakpoint IDs
     */
    private breakpointIdSequence;
    /**
     * breakpoint lines are 1-based, and columns are zero-based
     */
    setBreakpoint(srcPath: string, breakpoint: AugmentedSourceBreakpoint | DebugProtocol.SourceBreakpoint): AugmentedSourceBreakpoint;
    /**
     * Delete a breakpoint
     */
    deleteBreakpoint(hash: string): any;
    deleteBreakpoint(breakpoint: AugmentedSourceBreakpoint): any;
    deleteBreakpoint(srcPath: string, breakpoint: Breakpoint): any;
    /**
     * Delete a set of breakpoints
     */
    deleteBreakpoints(args: BreakpointRef[]): void;
    /**
     * Get a breakpoint by providing the data you have available
     */
    getBreakpoint(hash: BreakpointRef): AugmentedSourceBreakpoint;
    getBreakpoint(srcPath: string, breakpoint: Breakpoint): AugmentedSourceBreakpoint;
    /**
     * Given a breakpoint ref, turn it into a hash
     */
    private refToHash;
    /**
     * Get breakpoints by providing a list of breakpoint refs
     * @param refs a list of breakpoint refs for breakpoints to get
     * @param includeHistoric if true, will also look through historic breakpoints for a match.
     */
    getBreakpoints(refs: BreakpointRef[]): AugmentedSourceBreakpoint[];
    private deviceIdByDestHash;
    /**
      * Find a breakpoint by its deviceId
      * @returns the breakpoint, or undefined if not found
      */
    private getBreakpointByDeviceId;
    /**
     * Set the deviceId of a breakpoint
     */
    setBreakpointDeviceId(srcHash: string, destHast: string, deviceId: number): void;
    /**
     * Mark this breakpoint as verified
     */
    verifyBreakpoint(deviceId: number, isVerified?: boolean): boolean;
    private queueEventStates;
    /**
     * Queue future events to be fired when data settles. Typically this is data that needs synced back to vscode.
     * This queues up a future function that will emit a batch of all the specified breakpoints.
     * @param hash the breakpoint hash that identifies this specific breakpoint based on its features
     */
    private queueEvent;
    /**
     * Generate a hash based on the features of the breakpoint. Every breakpoint that exists at the same location
     * and has the same features should have the same hash.
     */
    private getBreakpointSrcHash;
    /**
     * Generate a hash based on the features of the breakpoint. Every breakpoint that exists at the same location
     * and has the same features should have the same hash.
     */
    private getBreakpointDestHash;
    /**
     * Set/replace/delete the list of breakpoints for this file.
     * @param srcPath
     * @param allBreakpointsForFile
     */
    replaceBreakpoints(srcPath: string, allBreakpointsForFile: DebugProtocol.SourceBreakpoint[]): AugmentedSourceBreakpoint[];
    /**
     * Get a list of all breakpoint tasks that should be performed.
     * This will also exclude files with breakpoints that are not in scope.
     * @param willInjectStop true for telnet (a literal `STOP` is baked in at each breakpoint). Only used by
     * the AST line check (see {@link isValidBreakpointLine}), which is gated behind enableAstBreakpointValidation
     * and off by default; when on, it lets telnet exclude lines where injecting a `STOP` would be invalid.
     */
    private getBreakpointWork;
    sortAndRemoveDuplicateBreakpoints<T extends {
        line: number;
        column?: number;
    }>(breakpoints: Array<T>): T[];
    /**
     * Reconcile every breakpoint against the project's staged files, marking any that can't be placed
     * (unsupported file type, or a file not in the project) as failed. Returns the placeable breakpoints
     * keyed by staging file path.
     *
     * For telnet there is no on-device breakpoint API, so this also bakes a literal `STOP` into the staged
     * files for each breakpoint and registers them as permanent/verified. DebugProtocol writes nothing
     * (the device breaks by line number). The choice is made here from `launchConfiguration.enableDebugProtocol`.
     */
    validateAndWriteBreakpointsForProject(project: Project): Promise<Record<string, BreakpointWorkItem[]>>;
    /**
     * Write STOP statements into the project's staging files for each breakpoint location and update the
     * sourcemaps to match. Marks the written breakpoints as verified and registers them as permanent.
     * Telnet only — `validateAndWriteBreakpointsForProject` calls this when no on-device breakpoint API
     * is available.
     */
    private writeBreakpointsForProject;
    private registerPermanentBreakpoint;
    /**
     * The list of breakpoints that were permanently written to a file at the start of a debug session. Used for line offset calculations.
     */
    private permanentBreakpointsBySrcPath;
    /**
     * Cache of parsed ASTs keyed by staging file path.
     * Populated lazily in isValidBreakpointLine. Clear on new debug session.
     */
    private stagingFileAstCache;
    /**
     * Clear the staging file AST cache. Should be called at the start of each debug session
     * so stale parsed ASTs don't carry over after files are re-staged.
     */
    clearStagingFileAstCache(): void;
    /**
     * Reset all per-session state so a relaunch/restart starts clean. A restart re-stages the project,
     * so cached parsed ASTs from the previous run are stale, and the diff baseline must be cleared so the
     * next client sees every breakpoint as a fresh add. (The `<script>`-reference set lives on the
     * freshly-created Project, so it doesn't need resetting here.)
     */
    reset(): void;
    /**
     * Returns whether a 1-based line number in a staging file is a valid breakpoint location.
     *
     * Guiding principle: a breakpoint is ALWAYS allowed unless we can point to specific, real
     * code proving it is invalid. We never drop a breakpoint just because we are unsure.
     *
     * The only thing we are always certain about is the blacklist: the innermost statement at the
     * line is a positively-identified non-executable construct (comment, import/library, namespace/
     * class/enum/interface/const/field/type declaration). Those are invalid for every debugger type.
     *
     * Everything else depends on `willInjectStop`:
     * - DebugProtocol (`willInjectStop === false`): the device breaks by line number and we inject
     *   nothing, so we cannot prove any non-blacklisted line is unbreakable. We KEEP it — including
     *   continuation lines of a multi-line literal and structural keyword lines (`end if`, `else`,
     *   `end sub`, ...).
     * - Telnet (`willInjectStop === true`): we inject a literal `STOP` statement *before* the line.
     *   Injecting a `STOP` into the middle of a multi-line literal, or before a structural keyword,
     *   produces invalid BrightScript. We can identify those lines precisely: they are *covered* by
     *   some statement's range but no statement *starts* on them. Those are excluded for telnet only.
     *
     * A truly empty (whitespace-only) line that no node covers is genuinely non-executable in both
     * modes. A non-empty line that no node covers means the AST is incomplete/broken (partial or
     * failed parse) — we fail open and KEEP it. A read/parse error also fails open.
     *
     * The returned object is designed to support future breakpoint-correction: callers can check
     * `correctedLine` to suggest moving the breakpoint to a nearby valid line rather than dropping it.
     *
     * @param willInjectStop true when a literal `STOP` will be injected at this location (telnet)
     */
    private isValidBreakpointLine;
    /**
     * Write breakpoints to the specified file, and update the sourcemaps to match
     */
    private writeBreakpointsToFile;
    private bpIndex;
    getSourceAndMapWithBreakpoints(fileContents: string, originalFilePath: string, breakpoints: BreakpointWorkItem[]): CodeWithSourceMap;
    private getBreakpointLines;
    /**
     * Get the list of breakpoints for the specified file path, or an empty array
     */
    private getBreakpointsForFile;
    /**
     * Get the permanent breakpoint with the specified hash
     * @returns the breakpoint with the matching hash, or undefined
     */
    getPermanentBreakpoint(hash: string): BreakpointWorkItem;
    /**
     * Get the list of breakpoints that were written to the source file
     */
    getPermanentBreakpointsForFile(srcPath: string): BreakpointWorkItem[];
    /**
     * File paths can be different casing sometimes,
     * so find the existing key if it exists, or return the file path if it doesn't exist
     */
    sanitizeSourceFilePath(filePath: string): string;
    /**
     * Determine if there's a breakpoint set at the given staging folder and line.
     * This is not trivial, so only run when absolutely necessary
     * @param projects the list of projects to scan
     * @param pkgPath the path to the file in the staging directory
     * @param line the 0-based line for the breakpoint
     */
    lineHasBreakpoint(projects: Project[], pkgPath: string, line: number): Promise<boolean>;
    /**
     * Get a diff of all breakpoints that have changed since the last time the diff was retrieved.
     * Sets the new baseline to the current state, so the next diff will be based on this new baseline.
     *
     * All projects should be passed in every time.
     */
    getDiff(projects: Project[]): Promise<Diff>;
    /**
     * Set the pending status of the given list of breakpoints.
     *
     * Whenever the breakpoint is currently being handled by an adapter (i.e. add/update/delete), it should
     * be marked "pending". Then, when the response comes back (success or fail), "pending" should be set to false.
     * In this way, we can ensure that all breakpoints can be synchronized with the device
     */
    setPending(srcPath: string, breakpoints: Breakpoint[], isPending: boolean): void;
    /**
     * Determine whether the current breakpoint is pending or not
     */
    isPending(srcPath: string, breakpoint: Breakpoint): any;
    isPending(hash: string): any;
    /**
     * A map of breakpoint hashes, and whether that breakpoint is currently pending or not.
     */
    private breakpointPendingStatus;
    /**
     * Flag indicating whether a `getDiff` function is currently running
     */
    private isGetDiffRunning;
    private lastState;
    clearBreakpointLastState(): void;
}
export interface Diff {
    added: BreakpointWorkItem[];
    removed: BreakpointWorkItem[];
    unchanged: BreakpointWorkItem[];
}
export interface AugmentedSourceBreakpoint extends DebugProtocol.SourceBreakpoint {
    /**
     * The path to the source file where this breakpoint was originally set
     */
    srcPath: string;
    /**
     * A unique hash generated for the breakpoint at this exact file/line/column/feature. Every breakpoint with these same features should get the same hash
     */
    srcHash: string;
    /**
     * A unique ID the debug adapter generates to help send updates to the client about this breakpoint
     */
    id: number;
    /**
     * This breakpoint has been verified (i.e. we were able to set it at the given location)
     */
    verified: boolean;
    /** A message about the state of the breakpoint.
        This is shown to the user and can be used to explain why a breakpoint could not be verified.
    */
    message?: string;
    /** A machine-readable explanation of why a breakpoint may not be verified. If a breakpoint is verified or a specific reason is not known, the adapter should omit this property. Possible values include:

        - `pending`: Indicates a breakpoint might be verified in the future, but the adapter cannot verify it in the current state.
            - `failed`: Indicates a breakpoint was not able to be verified, and the adapter does not believe it can be verified without intervention.
    */
    reason?: 'pending' | 'failed';
}
export interface BreakpointWorkItem {
    /**
     * The path to the source file where this breakpoint was originally set
     */
    srcPath: string;
    /**
     * The absolute path to the file in the staging folder
     */
    stagingFilePath: string;
    /**
     * The device path (i.e. `pkg:/source/main.brs`)
     */
    pkgPath: string;
    /**
     * The path to the rootDir for this breakpoint
     */
    rootDirFilePath: string;
    /**
     * The 1-based line number
     */
    line: number;
    /**
     * The device-provided breakpoint id. A missing ID means this breakpoint has not yet been verified by the device.
     */
    deviceId?: number;
    /**
     * An id generated by the debug adapter used to identify this breakpoint in the client
     */
    id: number;
    /**
     * A unique hash generated for the breakpoint at this exact file/line/column/feature. Every breakpoint with these same features should get the same hash
     */
    srcHash: string;
    /**
     *
     */
    destHash: string;
    /**
     * The 0-based column index
     */
    column: number;
    /**
     * If set, this breakpoint will only activate when this condition evaluates to true
     */
    condition?: string;
    /**
     * If set, this breakpoint will only activate once the breakpoint has been hit this many times.
     */
    hitCondition?: string;
    /**
     * If set, this breakpoint will emit a log message at runtime and will not actually stop at the breakpoint
     */
    logMessage?: string;
    /**
     * The name of the component library this belongs to. Will be null for the main project
     */
    componentLibraryName?: string;
    /**
     * `sourceMap` means derived from a source map.
     * `fileMap` means derived from the {src;dest} entry used by roku-deploy
     * `sourceDirs` means derived by walking up the `sourceDirs` list until a relative file was found
     */
    type: 'fileMap' | 'sourceDirs' | 'sourceMap';
}
export type Breakpoint = DebugProtocol.SourceBreakpoint | AugmentedSourceBreakpoint;
/**
 * A way to reference a breakpoint.
 * - `string` - a hash
 * - `AugmentedSourceBreakpoint` an actual breakpoint
 * - `{hash: string}` - an object containing a breakpoint hash
 * - `Breakpoint & {srcPath: string}` - an object with all the properties of a breakpoint _and_ an explicitly defined `srcPath`
 */
export type BreakpointRef = string | AugmentedSourceBreakpoint | {
    srcHash: string;
} | (Breakpoint & {
    srcPath: string;
});
/**
 * Result of validating whether a staging-file line is executable.
 * `correctedLine` is reserved for future breakpoint-correction support: when a
 * breakpoint is placed on a non-executable line the debugger can suggest a nearby
 * executable line (like VS Code does for other languages) rather than silently
 * dropping the breakpoint.
 */
export interface LineValidationResult {
    isValid: boolean;
    /** Future: 1-based line to move the breakpoint to, if different from the requested line. */
    correctedLine?: number;
}