brighterscript 1.0.0-alpha.23 → 1.0.0-alpha.25

package/dist/interfaces.d.ts

@@ -1,20 +1,25 @@
-import type { Range, Diagnostic, CodeAction, SemanticTokenTypes, SemanticTokenModifiers } from 'vscode-languageserver';
+/// <reference types="node" />
+import type { Range, Diagnostic, CodeAction, SemanticTokenTypes, SemanticTokenModifiers, Position, CompletionItem } from 'vscode-languageserver';
 import type { Scope } from './Scope';
 import type { BrsFile } from './files/BrsFile';
 import type { XmlFile } from './files/XmlFile';
+import type { FunctionScope } from './FunctionScope';
 import type { TypedFunctionType } from './types/TypedFunctionType';
 import type { ParseMode } from './parser/Parser';
 import type { Program } from './Program';
 import type { ProgramBuilder } from './ProgramBuilder';
-import type { FunctionStatement, ClassStatement, InterfaceStatement, EnumStatement } from './parser/Statement';
-import type { Expression, FunctionExpression } from './parser/Expression';
+import type { ClassStatement, ConstStatement, EnumStatement, FunctionStatement, NamespaceStatement } from './parser/Statement';
+import type { AstNode, Expression, Statement } from './parser/AstNode';
 import type { TranspileState } from './parser/TranspileState';
-import type { SourceMapGenerator, SourceNode } from 'source-map';
-import type { BscType, SymbolContainer } from './types/BscType';
-import type { Token } from './lexer/Token';
-import type { AstEditor } from './astUtils/AstEditor';
-import type { CustomType } from './types/CustomType';
-import type { InterfaceType } from './types/InterfaceType';
+import type { SourceNode } from 'source-map';
+import type { BscType } from './types/BscType';
+import type { Editor } from './astUtils/Editor';
+import type { Identifier, Token } from './lexer/Token';
+import type { BscFile } from './files/BscFile';
+import type { FileFactory } from './files/Factory';
+import type { LazyFileData } from './files/LazyFileData';
+import type { SymbolTable, SymbolTypeFlag } from './SymbolTable';
+import type { CallExpression } from './parser/Expression';
 export interface BsDiagnostic extends Diagnostic {
     file: BscFile;
     /**
@@ -22,7 +27,16 @@ export interface BsDiagnostic extends Diagnostic {
      */
     data?: any;
 }
-export declare type BscFile = BrsFile | XmlFile;
+export declare enum DiagnosticOrigin {
+    Program = "Program",
+    Scope = "Scope",
+    File = "File",
+    ASTSegment = "AstSegment"
+}
+export interface BsDiagnosticWithOrigin extends BsDiagnostic {
+    origin: DiagnosticOrigin;
+    astSegment?: AstNode;
+}
 export interface Callable {
     file: BscFile;
     name: string;
@@ -64,12 +78,12 @@ export interface FunctionCall {
      * The full range of this function call (from the start of the function name to its closing paren)
      */
     range: Range;
-    functionExpression: FunctionExpression;
+    expression: CallExpression;
+    functionScope: FunctionScope;
     file: BscFile;
-    name: Token;
+    name: string;
     args: CallableArg[];
     nameRange: Range;
-    isDottedInvocation: boolean;
 }
 /**
  * An argument for an expression call.
@@ -102,12 +116,12 @@ export interface FileObj {
  */
 export interface FileReference {
     /**
-     * The pkgPath to the referenced file.
+     * The destPath for the referenced file.
      */
-    pkgPath: string;
+    destPath: string;
     text: string;
     /**
-     * The file that is doing the import. Note this is NOT the file the pkgPath points to.
+     * The file that is doing the import. Note this is NOT the file the destPath points to.
      */
     sourceFile: XmlFile | BrsFile;
     /**
@@ -120,7 +134,7 @@ export interface FileReference {
 }
 export interface VariableDeclaration {
     name: string;
-    type: BscType;
+    getType: () => BscType;
     /**
      * The range for the variable name
      */
@@ -165,26 +179,109 @@ export interface CommentFlag {
 export declare type CompilerPluginFactory = () => CompilerPlugin;
 export interface CompilerPlugin {
     name: string;
+    /**
+     * Called before a new program is created
+     */
     beforeProgramCreate?: PluginHandler<BeforeProgramCreateEvent>;
+    /**
+     * Called after a new program is created
+     */
     afterProgramCreate?: PluginHandler<AfterProgramCreateEvent>;
-    beforePrepublish?: PluginHandler<BeforePrepublishEvent>;
-    afterPrepublish?: PluginHandler<AfterPrepublishEvent>;
-    beforePublish?: PluginHandler<BeforePublishEvent>;
-    afterPublish?: PluginHandler<AfterPublishEvent>;
+    /**
+     * Called before the program gets prepared for building
+     */
+    beforePrepareProgram?: PluginHandler<BeforePrepareProgramEvent>;
+    /**
+     * Called when the program gets prepared for building
+     */
+    prepareProgram?: PluginHandler<PrepareProgramEvent>;
+    /**
+     * Called after the program gets prepared for building
+     */
+    afterPrepareProgram?: PluginHandler<AfterPrepareProgramEvent>;
+    /**
+     * Called before the entire program is validated
+     */
     beforeProgramValidate?: PluginHandler<BeforeProgramValidateEvent>;
+    /**
+     * Called before the entire program is validated
+     */
+    onProgramValidate?: PluginHandler<OnProgramValidateEvent>;
+    /**
+     * Called after the program has been validated
+     */
     afterProgramValidate?: PluginHandler<AfterProgramValidateEvent>;
-    beforeProgramTranspile?: PluginHandler<BeforeProgramTranspileEvent>;
-    afterProgramTranspile?: PluginHandler<AfterProgramTranspileEvent>;
-    onGetCodeActions?: PluginHandler<OnGetCodeActionsEvent>;
-    onGetSemanticTokens?: PluginHandler<OnGetSemanticTokensEvent>;
+    /**
+     * Called right before the program is disposed/destroyed
+     */
+    beforeProgramDispose?: PluginHandler<BeforeProgramDisposeEvent>;
+    /**
+     * Emitted before the program starts collecting completions
+     */
+    beforeProvideCompletions?: PluginHandler<BeforeProvideCompletionsEvent>;
+    /**
+     * Use this event to contribute completions
+     */
+    provideCompletions?: PluginHandler<ProvideCompletionsEvent>;
+    /**
+     * Emitted after the program has finished collecting completions, but before they are sent to the client
+     */
+    afterProvideCompletions?: PluginHandler<AfterProvideCompletionsEvent>;
+    /**
+     * Called before the `provideHover` hook. Use this if you need to prepare any of the in-memory objects before the `provideHover` gets called
+     */
+    beforeProvideHover?: PluginHandler<BeforeProvideHoverEvent>;
+    /**
+     * Called when bsc looks for hover information. Use this if your plugin wants to contribute hover information.
+     */
+    provideHover?: PluginHandler<ProvideHoverEvent>;
+    /**
+     * Called after the `provideHover` hook. Use this if you want to intercept or sanitize the hover data (even from other plugins) before it gets sent to the client.
+     */
+    afterProvideHover?: PluginHandler<AfterProvideHoverEvent>;
+    /**
+     * Called after a scope was created
+     */
     afterScopeCreate?: PluginHandler<AfterScopeCreateEvent>;
     beforeScopeDispose?: PluginHandler<BeforeScopeDisposeEvent>;
+    onScopeDispose?: PluginHandler<OnScopeDisposeEvent>;
     afterScopeDispose?: PluginHandler<AfterScopeDisposeEvent>;
     beforeScopeValidate?: PluginHandler<BeforeScopeValidateEvent>;
     onScopeValidate?: PluginHandler<OnScopeValidateEvent>;
-    afterScopeValidate?: PluginHandler<AfterScopeValidateEvent>;
-    beforeFileParse?: PluginHandler<BeforeFileParseEvent>;
-    afterFileParse?: PluginHandler<AfterFileParseEvent>;
+    afterScopeValidate?: PluginHandler<BeforeScopeValidateEvent>;
+    onGetCodeActions?: PluginHandler<OnGetCodeActionsEvent>;
+    onGetSemanticTokens?: PluginHandler<OnGetSemanticTokensEvent>;
+    /**
+     * Called before plugins are asked to provide files to the program. (excludes virtual files produced by `provideFile` events).
+     * Call the `setFileData()` method to override the file contents.
+     */
+    beforeProvideFile?: PluginHandler<BeforeProvideFileEvent>;
+    /**
+     * Give plugins the opportunity to handle processing a file. (excludes virtual files produced by `provideFile` events)
+     */
+    provideFile?: PluginHandler<ProvideFileEvent>;
+    /**
+     * Called after a file was added to the program. (excludes virtual files produced by `provideFile` events)
+     */
+    afterProvideFile?: PluginHandler<AfterProvideFileEvent>;
+    /**
+     * Called before a file is added to the program.
+     * Includes physical files as well as any virtual files produced by `provideFile` events
+     */
+    beforeFileAdd?: PluginHandler<BeforeFileAddEvent>;
+    /**
+     * Called after a file has been added to the program.
+     * Includes physical files as well as any virtual files produced by `provideFile` events
+     */
+    afterFileAdd?: PluginHandler<AfterFileAddEvent>;
+    /**
+     * Called before a file is removed from the program. This includes physical and virtual files
+     */
+    beforeFileRemove?: PluginHandler<BeforeFileRemoveEvent>;
+    /**
+     * Called after a file has been removed from the program. This includes physical and virtual files
+     */
+    afterFileRemove?: PluginHandler<AfterFileRemoveEvent>;
     /**
      * Called before each file is validated
      */
@@ -197,34 +294,83 @@ export interface CompilerPlugin {
      * Called after each file is validated
      */
     afterFileValidate?: PluginHandler<AfterFileValidateEvent>;
-    beforeFileTranspile?: PluginHandler<BeforeFileTranspileEvent>;
-    afterFileTranspile?: PluginHandler<AfterFileTranspileEvent>;
-    beforeFileDispose?: PluginHandler<BeforeFileDisposeEvent>;
-    afterFileDispose?: PluginHandler<AfterFileDisposeEvent>;
-}
-export declare type PluginHandler<T> = (event: T) => void;
-export interface BeforeProgramCreateEvent {
-    builder: ProgramBuilder;
-}
-export interface BeforePrepublishEvent {
-    builder: ProgramBuilder;
-    program: Program;
-    files: FileObj[];
-}
-export interface AfterPrepublishEvent {
-    builder: ProgramBuilder;
-    program: Program;
-    files: FileObj[];
+    /**
+     * Called right before the program builds (i.e. generates the code and puts it in the stagingDir
+     */
+    beforeBuildProgram?: PluginHandler<BeforeBuildProgramEvent>;
+    /**
+     * Called right after the program builds (i.e. generates the code and puts it in the stagingDir
+     */
+    afterBuildProgram?: PluginHandler<AfterBuildProgramEvent>;
+    /**
+     * Before preparing the file for building
+     */
+    beforePrepareFile?: PluginHandler<BeforePrepareFileEvent>;
+    /**
+     * Prepare the file for building
+     */
+    prepareFile?: PluginHandler<PrepareFileEvent>;
+    /**
+     * After preparing the file for building
+     */
+    afterPrepareFile?: PluginHandler<AfterPrepareFileEvent>;
+    /**
+     * Before the program turns all file objects into their final buffers
+     */
+    beforeSerializeProgram?: PluginHandler<BeforeSerializeProgramEvent>;
+    /**
+     * Emitted right at the start of the program turning all file objects into their final buffers
+     */
+    onSerializeProgram?: PluginHandler<OnSerializeProgramEvent>;
+    /**
+     * After the program turns all file objects into their final buffers
+     */
+    afterSerializeProgram?: PluginHandler<AfterSerializeProgramEvent>;
+    /**
+     * Before turning the file into its final contents
+     */
+    beforeSerializeFile?: PluginHandler<BeforeSerializeFileEvent>;
+    /**
+     * Turn the file into its final contents (i.e. transpile a bs file, compress a jpeg, etc)
+     */
+    serializeFile?: PluginHandler<SerializeFileEvent>;
+    /**
+     * After turning the file into its final contents
+     */
+    afterSerializeFile?: PluginHandler<AfterSerializeFileEvent>;
+    /**
+     * Called before any files are written
+     */
+    beforeWriteProgram?: PluginHandler<BeforeWriteProgramEvent>;
+    /**
+     * Called after all files are written
+     */
+    afterWriteProgram?: PluginHandler<AfterWriteProgramEvent>;
+    /**
+     * Before a file is written to disk. These are raw files that contain the final output. One `File` may produce several of these
+     */
+    beforeWriteFile?: PluginHandler<BeforeWriteFileEvent>;
+    /**
+     * Called when a file should be persisted (usually writing to storage). These are raw files that contain the final output. One `File` may produce several of these.
+     * When a plugin has handled a file, it should be pushed to the `handledFiles` set so future plugins don't write the file multiple times
+     */
+    writeFile?: PluginHandler<WriteFileEvent>;
+    /**
+     * Before a file is written to disk. These are raw files that contain the final output. One `File` may produce several of these
+     */
+    afterWriteFile?: PluginHandler<AfterWriteFileEvent>;
 }
-export interface BeforePublishEvent {
-    builder: ProgramBuilder;
+export declare type PluginHandler<T, R = void> = (event: T) => R;
+export interface OnGetCodeActionsEvent<TFile extends BscFile = BscFile> {
     program: Program;
-    files: FileObj[];
+    file: TFile;
+    range: Range;
+    scopes: Scope[];
+    diagnostics: BsDiagnostic[];
+    codeActions: CodeAction[];
 }
-export interface AfterPublishEvent {
+export interface BeforeProgramCreateEvent {
     builder: ProgramBuilder;
-    program: Program;
-    files: FileObj[];
 }
 export interface AfterProgramCreateEvent {
     builder: ProgramBuilder;
@@ -233,27 +379,47 @@ export interface AfterProgramCreateEvent {
 export interface BeforeProgramValidateEvent {
     program: Program;
 }
-export interface AfterProgramValidateEvent {
-    program: Program;
-}
-export interface BeforeProgramTranspileEvent {
+export declare type OnProgramValidateEvent = BeforeProgramValidateEvent;
+export declare type AfterProgramValidateEvent = BeforeProgramValidateEvent;
+export interface ProvideCompletionsEvent<TFile extends BscFile = BscFile> {
     program: Program;
-    entries: TranspileEntry[];
-    editor: AstEditor;
+    file: TFile;
+    scopes: Scope[];
+    position: Position;
+    completions: CompletionItem[];
 }
-export interface AfterProgramTranspileEvent {
+export declare type BeforeProvideCompletionsEvent<TFile extends BscFile = BscFile> = ProvideCompletionsEvent<TFile>;
+export declare type AfterProvideCompletionsEvent<TFile extends BscFile = BscFile> = ProvideCompletionsEvent<TFile>;
+export interface BeforeBuildProgramEvent {
     program: Program;
-    entries: TranspileEntry[];
-    editor: AstEditor;
+    files: BscFile[];
+    editor: Editor;
 }
-export interface OnGetCodeActionsEvent {
+export declare type AfterBuildProgramEvent = BeforeBuildProgramEvent;
+export interface ProvideHoverEvent {
     program: Program;
     file: BscFile;
-    range: Range;
+    position: Position;
     scopes: Scope[];
-    diagnostics: BsDiagnostic[];
-    codeActions: CodeAction[];
+    hovers: Hover[];
+}
+export interface Hover {
+    /**
+     * The contents of the hover, written in markdown. If you want to display code in the hover, use code blocks, like this:
+     * ```text
+     *      ```brighterscript
+     *      some = "code" + "here"
+     *      ```
+     * ```
+     */
+    contents: string | string[];
+    /**
+     * An optional range
+     */
+    range?: Range;
 }
+export declare type BeforeProvideHoverEvent = ProvideHoverEvent;
+export declare type AfterProvideHoverEvent = ProvideHoverEvent;
 export interface AfterScopeCreateEvent {
     program: Program;
     scope: Scope;
@@ -262,30 +428,25 @@ export interface BeforeScopeDisposeEvent {
     program: Program;
     scope: Scope;
 }
-export interface AfterScopeDisposeEvent {
+export interface OnScopeDisposeEvent {
     program: Program;
     scope: Scope;
 }
-export interface BeforeScopeValidateEvent {
+export interface AfterScopeDisposeEvent {
     program: Program;
     scope: Scope;
 }
-export interface AfterScopeValidateEvent {
+export interface BeforeScopeValidateEvent {
     program: Program;
     scope: Scope;
 }
-export interface OnScopeGetCodeActionsEvent {
+export declare type AfterScopeValidateEvent = BeforeScopeValidateEvent;
+export interface BeforeFileParseEvent {
     program: Program;
-    scope: Scope;
-    file: BscFile;
-    range: Range;
-    /**
-     * A filtered list of diagnostics whose lines touch the lines of the given range
-     */
-    diagnostics: BsDiagnostic[];
-    codeActions: CodeAction[];
+    srcPath: string;
+    source: string;
 }
-export interface BeforeFileParseEvent {
+export interface OnFileParseEvent {
     program: Program;
     srcPath: string;
     source: string;
@@ -312,28 +473,30 @@ export interface OnGetSemanticTokensEvent<T extends BscFile = BscFile> {
      */
     semanticTokens: SemanticToken[];
 }
-export interface BeforeFileValidateEvent<T extends BscFile = BscFile> {
+export declare type BeforeFileValidateEvent = OnFileValidateEvent;
+export interface OnFileValidateEvent<T extends BscFile = BscFile> {
     program: Program;
     file: T;
 }
+export declare type AfterFileValidateEvent = OnFileValidateEvent;
 export interface OnFileValidateEvent<T extends BscFile = BscFile> {
     program: Program;
     file: T;
 }
-export interface AfterFileValidateEvent<T extends BscFile = BscFile> {
-    program: Program;
-    file: T;
+export interface TranspileEntry {
+    file: BscFile;
+    outputPath: string;
 }
-export interface BeforeFileTranspileEvent<TFile extends BscFile = BscFile> {
+export interface ScopeValidationOptions {
+    changedFiles?: BscFile[];
+    changedSymbols?: Map<SymbolTypeFlag, Set<string>>;
+    force?: boolean;
+}
+export interface OnScopeValidateEvent {
     program: Program;
-    file: TFile;
-    outputPath: string;
-    /**
-     * An editor that can be used to transform properties or arrays. Once the `afterFileTranspile` event has fired, these changes will be reverted,
-     * restoring the objects to their prior state. This is useful for changing code right before a file gets transpiled, but when you don't want
-     * the changes to persist in the in-memory file.
-     */
-    editor: Editor;
+    scope: Scope;
+    changedFiles?: BscFile[];
+    changedSymbols?: Map<SymbolTypeFlag, Set<string>>;
 }
 export interface AfterFileTranspileEvent<TFile extends BscFile = BscFile> {
     /**
@@ -349,45 +512,150 @@ export interface AfterFileTranspileEvent<TFile extends BscFile = BscFile> {
     /**
      * The sourceMaps for the generated code (if emitting source maps is enabled)
      */
-    map?: SourceMapGenerator;
+    map?: string;
     /**
      * The generated type definition file contents (if emitting type definitions are enabled)
      */
     typedef?: string;
+}
+export declare type BeforeProvideFileEvent<TFile extends BscFile = BscFile> = ProvideFileEvent<TFile>;
+export interface ProvideFileEvent<TFile extends BscFile = BscFile> {
+    /**
+     * The lower-case file extension for the srcPath. (i.e. ".brs", ".xml")
+     */
+    srcExtension: string;
     /**
-     * An editor that can be used to transform properties or arrays. Once the `afterFileTranspile` event has fired, these changes will be reverted,
-     * restoring the objects to their prior state. This is useful for changing code right before a file gets transpiled, but when you don't want
-     * the changes to persist in the in-memory file.
+     * The srcPath for the file. (i.e. `/user/bob/projects/VideoApp/source/main.bs`)
      */
+    srcPath: string;
+    /**
+     * The destPath for the file. (i.e. for `/user/bob/projects/VideoApp/source/main.bs`, destPath would be `source/main.bs`)
+     */
+    destPath: string;
+    /**
+     * A lazy-loading container for this file's data. Call `.get()` to lazy load the data, and `.set()` to override file contents
+     */
+    data: LazyFileData;
+    /**
+     * An array of files that should be added to the program as a result of this event
+     */
+    files: TFile[];
+    /**
+     * The program for this event
+     */
+    program: Program;
+    /**
+     * A factory used to create new instances of the BrighterScript built-in file types. This mitigates the issue
+     * of a plugin's version of a File not being the same as the LanguageServer or CLI version of BrighterScript
+     * (due to npm installing multiple versions of brighterscript)
+     */
+    fileFactory: FileFactory;
+}
+export declare type AfterProvideFileEvent<TFile extends BscFile = BscFile> = ProvideFileEvent<TFile>;
+export interface BeforeFileAddEvent<TFile extends BscFile = BscFile> {
+    file: TFile;
+    program: Program;
+}
+export declare type AfterFileAddEvent<TFile extends BscFile = BscFile> = BeforeFileAddEvent<TFile>;
+export interface BeforeFileRemoveEvent<TFile extends BscFile = BscFile> {
+    file: TFile;
+    program: Program;
+}
+export declare type AfterFileRemoveEvent<TFile extends BscFile = BscFile> = BeforeFileRemoveEvent<TFile>;
+export declare type BeforePrepareProgramEvent = PrepareProgramEvent;
+/**
+ * Event for when the program prepares itself for building
+ */
+export interface PrepareProgramEvent {
+    program: Program;
     editor: Editor;
 }
-export interface BeforeFileDisposeEvent {
+export declare type AfterPrepareProgramEvent = PrepareProgramEvent;
+export declare type BeforePrepareFileEvent<TFile extends BscFile = BscFile> = PrepareFileEvent<TFile>;
+/**
+ * Prepare the file for building
+ */
+export interface PrepareFileEvent<TFile extends BscFile = BscFile> {
     program: Program;
-    file: BscFile;
+    file: TFile;
+    editor: Editor;
+}
+export declare type OnPrepareFileEvent<TFile extends BscFile = BscFile> = PrepareFileEvent<TFile>;
+export declare type AfterPrepareFileEvent<TFile extends BscFile = BscFile> = PrepareFileEvent<TFile>;
+/**
+ * A container that holds the code, map, and typedef for serialized code files.
+ */
+export interface SerializedCodeFile {
+    code?: string;
+    map?: string;
+    typedef?: string;
 }
-export interface AfterFileDisposeEvent {
+export interface BeforeSerializeProgramEvent {
     program: Program;
-    file: BscFile;
+    files: BscFile[];
+    result: Map<BscFile, SerializedFile[]>;
 }
-export interface OnFileGetCodeActionsEvent {
+export declare type OnSerializeProgramEvent = BeforeSerializeProgramEvent;
+export declare type AfterSerializeProgramEvent = BeforeSerializeProgramEvent;
+/**
+ * During the `SerializeFile` events, this is how plugins will contribute file data for a specific file
+ */
+export interface SerializedFile {
+    /**
+     * The raw data for this file (i.e. a binary buffer for a .jpeg file, or the transpiled code for a .bs file)
+     */
+    data: Buffer;
+    /**
+     * The pkgPath for this chunk of data.
+     */
+    pkgPath: string;
+}
+export declare type BeforeSerializeFileEvent<TFile extends BscFile = BscFile> = SerializeFileEvent<TFile>;
+export interface SerializeFileEvent<TFile extends BscFile = BscFile> {
     program: Program;
-    file: BscFile;
-    range: Range;
+    file: TFile;
     /**
-     * A filtered list of diagnostics whose lines touch the lines of the given range
+     * The list of all files created across all the `SerializeFile` events.
+     * The key is the pkgPath of the file, and the
      */
-    diagnostics: BsDiagnostic[];
-    codeActions: CodeAction[];
+    result: Map<TFile, SerializedFile[]>;
 }
-export interface TranspileEntry {
+export declare type AfterSerializeFileEvent<TFile extends BscFile = BscFile> = SerializeFileEvent<TFile>;
+export interface BeforeWriteProgramEvent {
+    program: Program;
+    stagingDir: string;
+    files: Map<BscFile, SerializedFile[]>;
+}
+export declare type AfterWriteProgramEvent = BeforeWriteProgramEvent;
+export declare type BeforeWriteFileEvent = WriteFileEvent;
+export interface WriteFileEvent {
+    program: Program;
+    file: SerializedFile;
+    /**
+     * The full path to where the file was (or will be) written to.
+     */
+    outputPath: string;
+    /**
+     * A set of all files that have been properly written. Plugins should add any handled files to this list so future plugins don't write then again
+     */
+    processedFiles: Set<SerializedFile>;
+}
+export declare type AfterWriteFileEvent = BeforeWriteFileEvent;
+export interface TranspileObj {
     file: BscFile;
+    /**
+     * The absolute path to where the file should be written during build. (i.e. somewhere inside the stagingDir)
+     */
     outputPath: string;
 }
-export interface OnScopeValidateEvent {
+export interface BeforeFileDisposeEvent {
+    program: Program;
+    file: BscFile;
+}
+export declare type AfterFileDisposeEvent = BeforeFileDisposeEvent;
+export interface BeforeProgramDisposeEvent {
     program: Program;
-    scope: Scope;
 }
-export declare type Editor = Pick<AstEditor, 'addToArray' | 'hasChanges' | 'removeFromArray' | 'setArrayValue' | 'setProperty' | 'overrideTranspileResult' | 'arrayPop' | 'arrayPush' | 'arrayShift' | 'arraySplice' | 'arrayUnshift' | 'removeProperty' | 'edit'>;
 export interface SemanticToken {
     range: Range;
     tokenType: SemanticTokenTypes;
@@ -400,10 +668,7 @@ export interface TypedefProvider {
     getTypedef(state: TranspileState): Array<SourceNode | string>;
 }
 export declare type TranspileResult = Array<(string | SourceNode)>;
-/**
- * @param srcPath The absolute path to the source file on disk
- */
-export declare type FileResolver = (srcPath: string) => string | undefined | Thenable<string | undefined> | void;
+export declare type FileResolver = (srcPath: string) => string | Buffer | undefined | Thenable<string | Buffer | undefined> | void;
 export interface ExpressionInfo {
     expressions: Expression[];
     varExpressions: Expression[];
@@ -414,41 +679,66 @@ export interface FileLink<T> {
     item: T;
     file: BrsFile;
 }
-/**
- * Common interface to support Statements which define entities that have a member table
- * e.g. Class, Interface
- */
-export interface MemberSymbolTableProvider extends SymbolContainer {
-    buildSymbolTable(parent?: InheritableStatement): void;
-    hasParent(): boolean;
-    getPossibleFullParentNames(): string[];
-    getName(parseMode: ParseMode): string;
-    getThisBscType(): BscType;
-}
-export declare type InheritableStatement = ClassStatement | InterfaceStatement;
-export declare type InheritableType = CustomType | InterfaceType;
-export declare type NamedTypeStatement = InheritableStatement | EnumStatement;
-/**
- * Options for the parser functionDeclaration() method
- */
-export interface FunctionDeclarationParseOptions {
-    /**
-     * Function should have a name. Add a diagnostic if it is not there
-     * False for for anonymous functions
-     */
-    hasName?: boolean;
-    /**
-     * Function should have a body. Add a diagnostic if it is not there
-     * False for for functions defined in Interfaces
-     */
-    hasBody?: boolean;
-    /**
-    * Function should have an end token. Add a diagnostic if it is not there
-    * False for for functions defined in Interfaces
-    */
-    hasEnd?: boolean;
-    /**
-     *This function is only callable as a member for a class or interface, etc.
-     */
-    onlyCallableAsMember?: boolean;
+export interface ExtraSymbolData {
+    definingNode?: AstNode;
+    description?: string;
+    completionPriority?: number;
+    flags?: SymbolTypeFlag;
+    memberOfAncestor?: boolean;
+}
+export interface GetTypeOptions {
+    flags: SymbolTypeFlag;
+    typeChain?: TypeChainEntry[];
+    data?: ExtraSymbolData;
+    ignoreCall?: boolean;
+    onlyCacheResolvedTypes?: boolean;
+    ignoreCacheForRetrieval?: boolean;
+}
+export declare class TypeChainEntry {
+    name: string;
+    type: BscType;
+    range: Range;
+    separatorToken: Token;
+    data: ExtraSymbolData;
+    constructor(name: string, type: BscType, data: ExtraSymbolData, range: Range, separatorToken?: Token);
+    get isResolved(): boolean;
+}
+export interface TypeChainProcessResult {
+    itemName: string;
+    itemParentTypeName: string;
+    fullNameOfItem: string;
+    fullChainName: string;
+    range: Range;
+    containsDynamic: boolean;
+}
+export interface TypeCompatibilityData {
+    missingFields?: {
+        name: string;
+        expectedType: BscType;
+    }[];
+    fieldMismatches?: {
+        name: string;
+        expectedType: BscType;
+        actualType: BscType;
+    }[];
+    depth?: number;
+}
+export interface NamespaceContainer {
+    file: BscFile;
+    fullName: string;
+    fullNameLower: string;
+    parentNameLower: string;
+    nameParts: Identifier[];
+    nameRange: Range;
+    lastPartName: string;
+    lastPartNameLower: string;
+    functionStatements: Map<string, FunctionStatement>;
+    isTopLevel: boolean;
+    namespaceStatements?: NamespaceStatement[];
+    statements?: Statement[];
+    classStatements?: Map<string, ClassStatement>;
+    enumStatements?: Map<string, EnumStatement>;
+    constStatements?: Map<string, ConstStatement>;
+    namespaces?: Map<string, NamespaceContainer>;
+    symbolTable: SymbolTable;
 }