import type { FileEntry } from 'roku-deploy';
import type { BreakpointManager } from './BreakpointManager';
import type { LocationManager, SourceLocation } from './LocationManager';
import { Cache } from 'brighterscript/dist/Cache';
import type { ScopeFunction } from '../bsc/BscProject';
import type { Position } from 'brighterscript';
export declare const componentLibraryPostfix = "__lib";
/**
 * Staging info for a single project, used when describing all projects to a client.
 */
export interface ProjectStagingInfo {
    /**
     * The kind of project. `main` is the application project (always exactly one); `componentLibrary`
     * is a component library project.
     */
    type: 'main' | 'componentLibrary';
    /**
     * Absolute path to the project's staging directory.
     */
    stagingDir: string;
}
/**
 * Manages the collection of brightscript projects being used in a debug session.
 * Will contain the main project (in rootDir), as well as component libraries.
 */
export declare class ProjectManager {
    constructor(options: {
        /**
         * A class that keeps track of all the breakpoints for a debug session.
         * It needs to be notified of any changes in breakpoints
         */
        breakpointManager: BreakpointManager;
        locationManager: LocationManager;
    });
    private breakpointManager;
    private locationManager;
    launchConfiguration: {
        enableSourceMaps?: boolean;
        enableDebugProtocol?: boolean;
        packagePath: string;
    };
    logger: import("@rokucommunity/logger").Logger;
    mainProject: Project;
    componentLibraryProjects: ComponentLibraryProject[];
    addComponentLibraryProject(project: ComponentLibraryProject): void;
    getAllProjects(): Project[];
    /**
     * Get the list of staging folder paths from all projects
     */
    getStagingDirs(): string[];
    /**
     * Get staging-dir info for every project. The main project is always first; component libraries
     * follow in order. This main-first ordering is a contract that clients rely on, so it is covered
     * by unit tests to guard against regressions.
     */
    getProjectStagingInfo(): ProjectStagingInfo[];
    /**
     * Get all of the functions avaiable for all scopes for this file.
     * @param pkgPath the device path of the file (probably with `pkg:` or `libpkg` or something...)
     * @returns
     */
    getScopeFunctionsForFile(pkgPath: string): Promise<Array<ScopeFunction>>;
    /**
     * Get the range of the scope for the given position in the file
     * @param pkgPath the device path of the file (probably with `pkg:` or `libpkg` or something...)
     * @param position the position in the file to get the scope range for
     */
    getScopeRange(pkgPath: string, position: Position): Promise<{
        start: {
            line: number;
            column: number;
        };
        end: {
            line: number;
            column: number;
        };
    }>;
    /**
     * Given a debugger path and line number, compensate for the injected breakpoint line offsets
     * @param filePath - the path to the file that may or may not have breakpoints
     * @param debuggerLineNumber - the line number from the debugger
     */
    getLineNumberOffsetByBreakpoints(filePath: string, debuggerLineNumber: number): any;
    sourceLocationCache: Cache<string, Promise<SourceLocation>>;
    /**
     * @param debuggerPath
     * @param debuggerLineNumber - the 1-based line number from the debugger
     * @param debuggerColumnNumber - the 1-based column number from the debugger
     */
    getSourceLocation(debuggerPath: string, debuggerLineNumber: number, debuggerColumnNumber?: number): Promise<SourceLocation>;
    /**
     *
     * @param stagingDir - the path to
     */
    registerEntryBreakpoint(stagingDir: string): Promise<void>;
    /**
     * Given a debugger-relative file path, find the path to that file in the staging directory.
     * This supports the standard out dir, as well as component library out dirs
     * @param debuggerPath the path to the file which was provided by the debugger
     * @param stagingDir - the path to the root of the staging folder (where all of the files were copied before deployment)
     * @return a full path to the file in the staging directory
     */
    getStagingFileInfo(debuggerPath: string): Promise<{
        relativePath: string;
        absolutePath: string;
        project: Project;
    }>;
    /**
     * Resolve a debugger-reported path to a staging file within a specific project. Returns undefined if the
     * path could not be mapped into that project's staging directory.
     */
    private buildStagingFileInfo;
    dispose(): void;
}
export interface AddProjectParams {
    rootDir: string;
    outDir: string;
    packagePath?: string;
    sourceDirs?: string[];
    files: Array<FileEntry>;
    injectRaleTrackerTask?: boolean;
    raleTrackerTaskFileLocation?: string;
    injectRdbOnDeviceComponent?: boolean;
    rdbFilesBasePath?: string;
    bsConst?: Record<string, boolean>;
    stagingDir?: string;
    enhanceREPLCompletions: boolean;
}
export declare class Project {
    constructor(params: AddProjectParams);
    rootDir: string;
    outDir: string;
    packagePath: string;
    sourceDirs: string[];
    files: Array<FileEntry>;
    stagingDir: string;
    fileMappings: Array<{
        src: string;
        dest: string;
    }>;
    /**
     * Absolute staging paths of every file referenced by a `<script uri="...">` tag in any staged XML
     * component. Roku loads these as BrightScript regardless of file extension, so they are valid
     * breakpoint targets even when they don't end in `.brs`. Populated during `stage()` (the single
     * staging-file walk in `preprocessStagingFiles`) so consumers don't have to re-scan the staging dir.
     */
    scriptReferencedFiles: Set<string>;
    bsConst: Record<string, boolean>;
    injectRaleTrackerTask: boolean;
    raleTrackerTaskFileLocation: string;
    injectRdbOnDeviceComponent: boolean;
    rdbFilesBasePath: string;
    enhanceREPLCompletions: boolean;
    /**
     * A BrighterScript project for the stagingDir
     */
    private stagingBscProject;
    get postfix(): string;
    private logger;
    stage(): Promise<void>;
    /**
     * Get all of the functions available for all scopes for this file.
     * @param relativePath path to the file relative to rootDir
     * @returns
     */
    getScopeFunctionsForFile(relativePath: string): any[] | Promise<ScopeFunction[]>;
    /**
     * Get the range of the scope for the given position in the file
     * @param relativePath path to the file relative to rootDir
     * @param position the position in the file to get the scope range for
     */
    getScopeRange(relativePath: string, position: Position): Promise<import("vscode-languageserver-types").Range>;
    /**
     * If the project uses sourceDirs, replace every `fileMapping.src` with its original location in sourceDirs
     */
    private resolveFileMappingsForSourceDirs;
    /**
     * Walk every staged file once and apply all necessary rewrites for files that were moved
     * from a different source location:
     *  - .map files: rewrite `sources` paths to be relative to the new staging location
     *  - .brs/.xml files: rewrite the sourceMappingURL comment path to point to the staged map
     */
    private preprocessStagingFiles;
    /**
     * Parse a staged XML file's contents for `<script uri="...">` tags and add each referenced file's
     * absolute staging path to {@link scriptReferencedFiles}. `pkg:/`/`libpkg:/` uris resolve from the
     * staging root; bare relative uris resolve from the XML file's own directory. Roku loads these as
     * BrightScript regardless of extension, so they are valid breakpoint targets.
     * @param contents the already-loaded file contents (read once by the staging walk)
     */
    private collectScriptReferencedFiles;
    /**
     * Per-path write locks. Async file ops interleave (e.g. `preprocessStagingFiles` fans out
     * tasks that can target the same staging `.map`), so we queue all writes to a given path
     * through a single promise chain. Entries clean themselves up once their chain is idle.
     */
    private writeLocks;
    private serializeWrite;
    /**
     * Serialized wrapper around `fsExtra.writeFile`. Use in place of `fsExtra.writeFile` anywhere
     * a path might also be written by another concurrent task in this Project.
     */
    private writeFile;
    /**
     * Serialized wrapper around `fsExtra.copyFile`. The dest path is the one we serialize on,
     * since that's what gets written.
     */
    private copyFile;
    /**
     * Rewrite the `sources` paths in a staged .map file so they are relative to the map's
     * new staging location rather than the original source directory.
     */
    private fixSourceMapSources;
    static readonly binaryExtensions: Set<string>;
    /**
     * Extracts the sourceMappingURL comment from the given file contents.
     *
     * `match[3]` is the path (which may be relative or absolute)
     * @param contents
     * @returns
     */
    static getSourceMapComment(contents: string): {
        /**
         * The entire matched comment, including any leading whitespace and comment characters (e.g. `'` or `<!--`), which should be preserved when rewriting the comment
         */
        fullMatch: string;
        /**
         * The leading whitespace and comment characters (e.g. `'` or `<!--`) before the actual `sourceMappingURL` text, which should be preserved when rewriting the comment
         */
        leadingInfo: string;
        /**
         * The entire comment text without the leadingInfo (e.g. `//# sourceMappingURL=someFile.map`)
         */
        wholeComment: string;
        /**
         * The path to the source map file (e.g. `someFile.map`)
         */
        mapPath: string;
    };
    /**
     * Rewrite the sourceMappingURL comment in a staged .brs or .xml file so the path points
     * to the map file's new staging location.
     *
     * Recognised comment forms (# and legacy @ are both accepted; // is optional for brs/xml):
     *   BRS:   ' [//] [#|@] sourceMappingURL=<path>
     *   XML:   <!-- [//] [#|@] sourceMappingURL=<path> -->
     *   other: // \s* [#|@] sourceMappingURL=<path>
     *
     * When rewriting, the canonical modern form is always written:
     *   BRS:   '//# sourceMappingURL=<path>
     *   XML:   <!--//# sourceMappingURL=<path> -->
     *   other: //# sourceMappingURL=<path>
     */
    private fixSourceMapComment;
    private colocateSourceMap;
    /**
     * Apply the bsConst transformations to the manifest file for this project
     */
    transformManifestWithBsConst(): Promise<void>;
    updateManifestBsConsts(consts: Record<string, boolean>, fileContents: string): string;
    static RALE_TRACKER_TASK_CODE: string;
    static RALE_TRACKER_ENTRY: string;
    /**
     * Search the project files for the comment "' vscode_rale_tracker_entry" and replace it with the code needed to start the TrackerTask.
     */
    copyAndTransformRaleTrackerTask(): Promise<void>;
    static RDB_ODC_NODE_CODE: string;
    static RDB_ODC_ENTRY: string;
    /**
     * Search the project files for the RTA_ODC_ENTRY comment and replace it with the code needed to start RTA_OnDeviceComponent which is used by RDB.
     */
    copyAndTransformRDB(): Promise<void>;
    /**
     *
     * @param stagingPath
     */
    zipPackage(params: {
        retainStagingFolder: boolean;
    }): Promise<void>;
    /**
     * Get the file paths from roku-deploy, and ensure the dest paths are absolute
     * (`dest` paths are relative in later versions of roku-deploy)
     */
    protected getFileMappings(): Promise<import("roku-deploy").StandardizedFileEntry[]>;
    dispose(): void;
}
export interface ComponentLibraryConstructorParams extends AddProjectParams {
    outFile: string;
    libraryIndex: number;
    install?: boolean;
    enablePostfix?: boolean;
}
export declare class ComponentLibraryProject extends Project {
    constructor(params: ComponentLibraryConstructorParams);
    outFile: string;
    libraryIndex: number;
    install: boolean;
    /**
     * Should this component library's `.brs` files be renamed with a `__lib<index>` postfix during staging?
     * Postfixing is how the debugger maps a device-reported file path back to the component library it came
     * from. When disabled, file names are left untouched (useful when a library loads files by a fixed name
     * at runtime), at the cost of degraded source mapping for this library's files while debugging.
     */
    enablePostfix: boolean;
    /**
     * The name of the component library that this project represents. This is loaded during `this.computeOutFileName`
     */
    name: string;
    /**
     * Takes a component Library and checks the outFile for replaceable values pulled from the libraries manifest
     * @param manifestPath the path to the manifest file to check
     */
    private computeOutFileName;
    stage(): Promise<void>;
    /**
     * The text used as a postfix for every brs file so we can accurately track the location of the files
     * back to their original component library whenever the debugger truncates the file path.
     */
    get postfix(): string;
    postfixFiles(): Promise<void>;
}