brighterscript 1.0.0-alpha.3 → 1.0.0-alpha.31

package/dist/interfaces.d.ts

@@ -1,15 +1,26 @@
-import type { Range, Diagnostic, CodeAction } from 'vscode-languageserver';
+/// <reference types="node" />
+import type { Range, Diagnostic, CodeAction, Position, CompletionItem, Location, DocumentSymbol, WorkspaceSymbol } from 'vscode-languageserver-protocol';
 import type { Scope } from './Scope';
 import type { BrsFile } from './files/BrsFile';
 import type { XmlFile } from './files/XmlFile';
-import type { FunctionType } from './types/FunctionType';
+import type { TypedFunctionType } from './types/TypedFunctionType';
 import type { ParseMode } from './parser/Parser';
 import type { Program } from './Program';
 import type { ProgramBuilder } from './ProgramBuilder';
-import type { Expression, FunctionStatement, FunctionExpression } from './parser';
+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 { SourceNode } from 'source-map';
 import type { BscType } from './types/BscType';
+import type { Identifier, Token } from './lexer/Token';
+import type { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver';
+import type { SymbolTable } from './SymbolTable';
+import type { SymbolTypeFlag } from './SymbolTypeFlag';
+import type { Editor } from './astUtils/Editor';
+import type { BscFile } from './files/BscFile';
+import type { FileFactory } from './files/Factory';
+import type { LazyFileData } from './files/LazyFileData';
+import type { BscTypeKind } from './types/BscTypeKind';
 export interface BsDiagnostic extends Diagnostic {
     file: BscFile;
     /**
@@ -17,7 +28,16 @@ export interface BsDiagnostic extends Diagnostic {
      */
     data?: any;
 }
-export declare type BscFile = BrsFile | XmlFile;
+export interface DiagnosticContext {
+    scopeSpecific?: boolean;
+    scope?: Scope;
+    tags?: string[];
+    segment?: AstNode;
+}
+export interface DiagnosticContextPair {
+    diagnostic: BsDiagnostic;
+    context?: DiagnosticContext;
+}
 export interface Callable {
     file: BscFile;
     name: string;
@@ -25,7 +45,7 @@ export interface Callable {
      * Is the callable declared as "sub". If falsey, assumed declared as "function"
      */
     isSub: boolean;
-    type: FunctionType;
+    type: TypedFunctionType;
     /**
      * A short description of the callable. Should be a short sentence.
      */
@@ -54,29 +74,13 @@ export interface Callable {
      */
     functionStatement: FunctionStatement;
 }
-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;
-    file: BscFile;
-    name: string;
-    args: CallableArg[];
-    nameRange: Range;
-}
-/**
- * An argument for an expression call.
- */
-export interface CallableArg {
-    text: string;
-    type: BscType;
-    range: Range;
-}
 export interface CallableParam {
     name: string;
     type: BscType;
-    isOptional?: boolean;
+    /**
+     * Is this parameter required or optional?
+     */
+    isOptional: boolean;
     /**
      * Indicates that an unlimited number of arguments can be passed in
      */
@@ -91,12 +95,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;
     /**
@@ -109,7 +113,7 @@ export interface FileReference {
 }
 export interface VariableDeclaration {
     name: string;
-    type: BscType;
+    getType: () => BscType;
     /**
      * The range for the variable name
      */
@@ -154,54 +158,253 @@ export interface CommentFlag {
 export declare type CompilerPluginFactory = () => CompilerPlugin;
 export interface CompilerPlugin {
     name: string;
-    beforeProgramCreate?: PluginHandler<BeforeProgramCreateEvent>;
-    afterProgramCreate?: PluginHandler<AfterProgramCreateEvent>;
-    beforePrepublish?: PluginHandler<BeforePrepublishEvent>;
-    afterPrepublish?: PluginHandler<AfterPrepublishEvent>;
-    beforePublish?: PluginHandler<BeforePublishEvent>;
-    afterPublish?: PluginHandler<AfterPublishEvent>;
-    beforeProgramValidate?: PluginHandler<BeforeProgramValidateEvent>;
-    afterProgramValidate?: PluginHandler<AfterProgramValidateEvent>;
-    beforeProgramTranspile?: PluginHandler<BeforeProgramTranspileEvent>;
-    afterProgramTranspile?: PluginHandler<AfterProgramTranspileEvent>;
-    onGetCodeActions?: PluginHandler<OnGetCodeActionsEvent>;
-    afterScopeCreate?: PluginHandler<AfterScopeCreateEvent>;
-    beforeScopeDispose?: PluginHandler<BeforeScopeDisposeEvent>;
-    afterScopeDispose?: PluginHandler<AfterScopeDisposeEvent>;
-    beforeScopeValidate?: PluginHandler<BeforeScopeValidateEvent>;
-    afterScopeValidate?: PluginHandler<AfterScopeValidateEvent>;
-    beforeFileParse?: PluginHandler<BeforeFileParseEvent>;
-    afterFileParse?: PluginHandler<AfterFileParseEvent>;
-    beforeFileValidate?: PluginHandler<BeforeFileValidateEvent>;
-    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 before a new program is created
+     */
+    beforeProgramCreate?(event: BeforeProgramCreateEvent): any;
+    /**
+     * Called after a new program is created
+     */
+    afterProgramCreate?(event: AfterProgramCreateEvent): any;
+    /**
+     * Called before the program gets prepared for building
+     */
+    beforePrepareProgram?(event: BeforePrepareProgramEvent): any;
+    /**
+     * Called when the program gets prepared for building
+     */
+    prepareProgram?(event: PrepareProgramEvent): any;
+    /**
+     * Called after the program gets prepared for building
+     */
+    afterPrepareProgram?(event: AfterPrepareProgramEvent): any;
+    /**
+     * Called before the entire program is validated
+     */
+    beforeProgramValidate?(event: BeforeProgramValidateEvent): any;
+    /**
+     * Called before the entire program is validated
+     */
+    onProgramValidate?(event: OnProgramValidateEvent): any;
+    /**
+     * Called after the program has been validated
+     */
+    afterProgramValidate?(event: AfterProgramValidateEvent): any;
+    /**
+     * Called right before the program is disposed/destroyed
+     */
+    beforeProgramDispose?(event: BeforeProgramDisposeEvent): any;
+    /**
+     * Emitted before the program starts collecting completions
+     */
+    beforeProvideCompletions?(event: BeforeProvideCompletionsEvent): any;
+    /**
+     * Use this event to contribute completions
+     */
+    provideCompletions?(event: ProvideCompletionsEvent): any;
+    /**
+     * Emitted after the program has finished collecting completions, but before they are sent to the client
+     */
+    afterProvideCompletions?(event: AfterProvideCompletionsEvent): any;
+    /**
+     * Called before the `provideHover` hook. Use this if you need to prepare any of the in-memory objects before the `provideHover` gets called
+     */
+    beforeProvideHover?(event: BeforeProvideHoverEvent): any;
+    /**
+     * Called when bsc looks for hover information. Use this if your plugin wants to contribute hover information.
+     */
+    provideHover?(event: ProvideHoverEvent): any;
+    /**
+     * 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?(event: AfterProvideHoverEvent): any;
+    /**
+     * Called after a scope was created
+     */
+    afterScopeCreate?(event: AfterScopeCreateEvent): any;
+    beforeScopeDispose?(event: BeforeScopeDisposeEvent): any;
+    onScopeDispose?(event: OnScopeDisposeEvent): any;
+    afterScopeDispose?(event: AfterScopeDisposeEvent): any;
+    beforeScopeValidate?(event: BeforeScopeValidateEvent): any;
+    /**
+     * Called before the `provideDefinition` hook
+     */
+    beforeProvideDefinition?(event: BeforeProvideDefinitionEvent): any;
+    /**
+     * Provide one or more `Location`s where the symbol at the given position was originally defined
+     * @param event
+     */
+    provideDefinition?(event: ProvideDefinitionEvent): any;
+    /**
+     * Called after `provideDefinition`. Use this if you want to intercept or sanitize the definition data provided by bsc or other plugins
+     * @param event
+     */
+    afterProvideDefinition?(event: AfterProvideDefinitionEvent): any;
+    /**
+     * Called before the `provideReferences` hook
+     */
+    beforeProvideReferences?(event: BeforeProvideReferencesEvent): any;
+    /**
+     * Provide all of the `Location`s where the symbol at the given position is located
+     * @param event
+     */
+    provideReferences?(event: ProvideReferencesEvent): any;
+    /**
+     * Called after `provideReferences`. Use this if you want to intercept or sanitize the references data provided by bsc or other plugins
+     * @param event
+     */
+    afterProvideReferences?(event: AfterProvideReferencesEvent): any;
+    /**
+     * Called before the `provideDocumentSymbols` hook
+     */
+    beforeProvideDocumentSymbols?(event: BeforeProvideDocumentSymbolsEvent): any;
+    /**
+     * Provide all of the `DocumentSymbol`s for the given file
+     * @param event
+     */
+    provideDocumentSymbols?(event: ProvideDocumentSymbolsEvent): any;
+    /**
+     * Called after `provideDocumentSymbols`. Use this if you want to intercept or sanitize the document symbols data provided by bsc or other plugins
+     * @param event
+     */
+    afterProvideDocumentSymbols?(event: AfterProvideDocumentSymbolsEvent): any;
+    /**
+     * Called before the `provideWorkspaceSymbols` hook
+     */
+    beforeProvideWorkspaceSymbols?(event: BeforeProvideWorkspaceSymbolsEvent): any;
+    /**
+     * Provide all of the workspace symbols for the entire project
+     * @param event
+     */
+    provideWorkspaceSymbols?(event: ProvideWorkspaceSymbolsEvent): any;
+    /**
+     * Called after `provideWorkspaceSymbols`. Use this if you want to intercept or sanitize the workspace symbols data provided by bsc or other plugins
+     * @param event
+     */
+    afterProvideWorkspaceSymbols?(event: AfterProvideWorkspaceSymbolsEvent): any;
+    onScopeValidate?(event: OnScopeValidateEvent): any;
+    afterScopeValidate?(event: BeforeScopeValidateEvent): any;
+    onGetCodeActions?(event: OnGetCodeActionsEvent): any;
+    onGetSemanticTokens?(event: OnGetSemanticTokensEvent): any;
+    /**
+     * 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?(event: BeforeProvideFileEvent): any;
+    /**
+     * Give plugins the opportunity to handle processing a file. (excludes virtual files produced by `provideFile` events)
+     */
+    provideFile?(event: ProvideFileEvent): any;
+    /**
+     * Called after a file was added to the program. (excludes virtual files produced by `provideFile` events)
+     */
+    afterProvideFile?(event: AfterProvideFileEvent): any;
+    /**
+     * Called before a file is added to the program.
+     * Includes physical files as well as any virtual files produced by `provideFile` events
+     */
+    beforeFileAdd?(event: BeforeFileAddEvent): any;
+    /**
+     * Called after a file has been added to the program.
+     * Includes physical files as well as any virtual files produced by `provideFile` events
+     */
+    afterFileAdd?(event: AfterFileAddEvent): any;
+    /**
+     * Called before a file is removed from the program. This includes physical and virtual files
+     */
+    beforeFileRemove?(event: BeforeFileRemoveEvent): any;
+    /**
+     * Called after a file has been removed from the program. This includes physical and virtual files
+     */
+    afterFileRemove?(event: AfterFileRemoveEvent): any;
+    /**
+     * Called before each file is validated
+     */
+    beforeFileValidate?(event: BeforeFileValidateEvent): any;
+    /**
+     * Called during the file validation process. If your plugin contributes file validations, this is a good place to contribute them.
+     */
+    onFileValidate?(event: OnFileValidateEvent): any;
+    /**
+     * Called after each file is validated
+     */
+    afterFileValidate?(event: AfterFileValidateEvent): any;
+    /**
+     * Called right before the program builds (i.e. generates the code and puts it in the stagingDir
+     */
+    beforeBuildProgram?(event: BeforeBuildProgramEvent): any;
+    /**
+     * Called right after the program builds (i.e. generates the code and puts it in the stagingDir
+     */
+    afterBuildProgram?(event: AfterBuildProgramEvent): any;
+    /**
+     * Before preparing the file for building
+     */
+    beforePrepareFile?(event: BeforePrepareFileEvent): any;
+    /**
+     * Prepare the file for building
+     */
+    prepareFile?(event: PrepareFileEvent): any;
+    /**
+     * After preparing the file for building
+     */
+    afterPrepareFile?(event: AfterPrepareFileEvent): any;
+    /**
+     * Before the program turns all file objects into their final buffers
+     */
+    beforeSerializeProgram?(event: BeforeSerializeProgramEvent): any;
+    /**
+     * Emitted right at the start of the program turning all file objects into their final buffers
+     */
+    onSerializeProgram?(event: OnSerializeProgramEvent): any;
+    /**
+     * After the program turns all file objects into their final buffers
+     */
+    afterSerializeProgram?(event: AfterSerializeProgramEvent): any;
+    /**
+     * Before turning the file into its final contents
+     */
+    beforeSerializeFile?(event: BeforeSerializeFileEvent): any;
+    /**
+     * Turn the file into its final contents (i.e. transpile a bs file, compress a jpeg, etc)
+     */
+    serializeFile?(event: SerializeFileEvent): any;
+    /**
+     * After turning the file into its final contents
+     */
+    afterSerializeFile?(event: AfterSerializeFileEvent): any;
+    /**
+     * Called before any files are written
+     */
+    beforeWriteProgram?(event: BeforeWriteProgramEvent): any;
+    /**
+     * Called after all files are written
+     */
+    afterWriteProgram?(event: AfterWriteProgramEvent): any;
+    /**
+     * Before a file is written to disk. These are raw files that contain the final output. One `File` may produce several of these
+     */
+    beforeWriteFile?(event: BeforeWriteFileEvent): any;
+    /**
+     * 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?(event: WriteFileEvent): any;
+    /**
+     * Before a file is written to disk. These are raw files that contain the final output. One `File` may produce several of these
+     */
+    afterWriteFile?(event: AfterWriteFileEvent): any;
 }
-export interface BeforePublishEvent {
-    builder: ProgramBuilder;
+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;
@@ -210,25 +413,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[];
+    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[];
+    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;
@@ -237,30 +462,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;
@@ -269,57 +489,435 @@ export interface AfterFileParseEvent {
     program: Program;
     file: BscFile;
 }
-export interface BeforeFileValidateEvent {
+export interface ProvideDefinitionEvent<TFile = BscFile> {
     program: Program;
-    file: BscFile;
+    /**
+     * The file that the getDefinition request was invoked in
+     */
+    file: TFile;
+    /**
+     * The position in the text document where the getDefinition request was invoked
+     */
+    position: Position;
+    /**
+     * The list of locations for where the item at the file and position was defined
+     */
+    definitions: Location[];
 }
-export interface AfterFileValidateEvent {
+export declare type BeforeProvideDefinitionEvent<TFile = BscFile> = ProvideDefinitionEvent<TFile>;
+export declare type AfterProvideDefinitionEvent<TFile = BscFile> = ProvideDefinitionEvent<TFile>;
+export interface ProvideReferencesEvent<TFile = BscFile> {
     program: Program;
-    file: BscFile;
+    /**
+     * The file that the getDefinition request was invoked in
+     */
+    file: TFile;
+    /**
+     * The position in the text document where the getDefinition request was invoked
+     */
+    position: Position;
+    /**
+     * The list of locations for where the item at the file and position was defined
+     */
+    references: Location[];
+}
+export declare type BeforeProvideReferencesEvent<TFile = BscFile> = ProvideReferencesEvent<TFile>;
+export declare type AfterProvideReferencesEvent<TFile = BscFile> = ProvideReferencesEvent<TFile>;
+export interface ProvideDocumentSymbolsEvent<TFile = BscFile> {
+    program: Program;
+    /**
+     * The file that the `documentSymbol` request was invoked in
+     */
+    file: TFile;
+    /**
+     * The result list of symbols
+     */
+    documentSymbols: DocumentSymbol[];
+}
+export declare type BeforeProvideDocumentSymbolsEvent<TFile = BscFile> = ProvideDocumentSymbolsEvent<TFile>;
+export declare type AfterProvideDocumentSymbolsEvent<TFile = BscFile> = ProvideDocumentSymbolsEvent<TFile>;
+export interface ProvideWorkspaceSymbolsEvent {
+    program: Program;
+    /**
+     * The result list of symbols
+     */
+    workspaceSymbols: WorkspaceSymbol[];
+}
+export declare type BeforeProvideWorkspaceSymbolsEvent = ProvideWorkspaceSymbolsEvent;
+export declare type AfterProvideWorkspaceSymbolsEvent = ProvideWorkspaceSymbolsEvent;
+export interface OnGetSemanticTokensEvent<T extends BscFile = BscFile> {
+    /**
+     * The program this file is from
+     */
+    program: Program;
+    /**
+     * The file to get semantic tokens for
+     */
+    file: T;
+    /**
+     * The list of scopes that this file is a member of
+     */
+    scopes: Scope[];
+    /**
+     * The list of semantic tokens being produced during this event.
+     */
+    semanticTokens: SemanticToken[];
+}
+export declare type BeforeFileValidateEvent = OnFileValidateEvent;
+export interface OnFileValidateEvent<T extends BscFile = BscFile> {
+    program: Program;
+    file: T;
 }
-export interface BeforeFileTranspileEvent {
+export declare type AfterFileValidateEvent<T extends BscFile = BscFile> = OnFileValidateEvent;
+export interface OnFileValidateEvent<T extends BscFile = BscFile> {
     program: Program;
+    file: T;
+}
+export interface TranspileEntry {
     file: BscFile;
     outputPath: string;
 }
-export interface AfterFileTranspileEvent {
+export interface ScopeValidationOptions {
+    filesToBeValidatedInScopeContext?: Set<BscFile>;
+    changedSymbols?: Map<SymbolTypeFlag, Set<string>>;
+    changedFiles?: Set<BscFile>;
+    force?: boolean;
+    initialValidation?: boolean;
+}
+export interface OnScopeValidateEvent {
     program: Program;
-    file: BscFile;
+    scope: Scope;
+    changedFiles?: BscFile[];
+    changedSymbols?: Map<SymbolTypeFlag, Set<string>>;
+}
+export interface AfterFileTranspileEvent<TFile extends BscFile = BscFile> {
+    /**
+     * The program this event was triggered for
+     */
+    program: Program;
+    file: TFile;
     outputPath: string;
+    /**
+     * The resulting transpiled file contents
+     */
+    code: string;
+    /**
+     * The sourceMaps for the generated code (if emitting source maps is enabled)
+     */
+    map?: string;
+    /**
+     * The generated type definition file contents (if emitting type definitions are enabled)
+     */
+    typedef?: string;
 }
-export interface BeforeFileDisposeEvent {
+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;
+    /**
+     * 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;
-    file: BscFile;
+    /**
+     * 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 interface AfterFileDisposeEvent {
+export declare type AfterProvideFileEvent<TFile extends BscFile = BscFile> = ProvideFileEvent<TFile>;
+export interface BeforeFileAddEvent<TFile extends BscFile = BscFile> {
+    file: TFile;
     program: Program;
-    file: BscFile;
 }
-export interface OnFileGetCodeActionsEvent {
+export declare type AfterFileAddEvent<TFile extends BscFile = BscFile> = BeforeFileAddEvent<TFile>;
+export interface BeforeFileRemoveEvent<TFile extends BscFile = BscFile> {
+    file: TFile;
     program: Program;
-    file: BscFile;
-    range: Range;
+}
+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 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: 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 BeforeSerializeProgramEvent {
+    program: Program;
+    files: BscFile[];
+    result: Map<BscFile, SerializedFile[]>;
+}
+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 {
     /**
-     * A filtered list of diagnostics whose lines touch the lines of the given range
+     * The raw data for this file (i.e. a binary buffer for a .jpeg file, or the transpiled code for a .bs file)
      */
-    diagnostics: BsDiagnostic[];
-    codeActions: CodeAction[];
+    data: Buffer;
+    /**
+     * The pkgPath for this chunk of data.
+     */
+    pkgPath: string;
 }
-export interface TranspileEntry {
+export declare type BeforeSerializeFileEvent<TFile extends BscFile = BscFile> = SerializeFileEvent<TFile>;
+export interface SerializeFileEvent<TFile extends BscFile = BscFile> {
+    program: Program;
+    file: TFile;
+    /**
+     * The list of all files created across all the `SerializeFile` events.
+     * The key is the pkgPath of the file, and the
+     */
+    result: Map<TFile, SerializedFile[]>;
+}
+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 BeforeFileDisposeEvent {
+    program: Program;
+    file: BscFile;
+}
+export declare type AfterFileDisposeEvent = BeforeFileDisposeEvent;
+export interface BeforeProgramDisposeEvent {
+    program: Program;
+}
+export interface SemanticToken {
+    range: Range;
+    tokenType: SemanticTokenTypes;
+    /**
+     * An optional array of modifiers for this token
+     */
+    tokenModifiers?: SemanticTokenModifiers[];
+}
 export interface TypedefProvider {
-    getTypedef(state: TranspileState): Array<SourceNode | string>;
+    getTypedef(state: TranspileState): TranspileResult;
 }
-export declare type TranspileResult = Array<(string | SourceNode)>;
+export declare type TranspileResult = Array<(string | SourceNode | TranspileResult)>;
 /**
- * @param srcPath The absolute path to the source file on disk
+ * This is the type that the SourceNode class is declared as taking in its constructor.
+ * The actual type that SourceNode accepts is the more permissive TranspileResult, but
+ * we need to use this declared type for some type casts.
  */
-export declare type FileResolver = (srcPath: string) => string | undefined | Thenable<string | undefined> | void;
+export declare type FlattenedTranspileResult = Array<string | SourceNode>;
+export declare type FileResolver = (srcPath: string) => string | Buffer | undefined | Thenable<string | Buffer | undefined> | void;
 export interface ExpressionInfo {
     expressions: Expression[];
     varExpressions: Expression[];
     uniqueVarNames: string[];
 }
 export declare type DiagnosticCode = number | string;
+export interface FileLink<T> {
+    item: T;
+    file: BrsFile;
+}
+export interface ExtraSymbolData {
+    /**
+     * What AST node defined this symbol?
+     */
+    definingNode?: AstNode;
+    /**
+     * Description of this symbol
+     */
+    description?: string;
+    /**
+     * the higher the number, the lower the priority
+     */
+    completionPriority?: number;
+    /**
+     * Flags for this symbol
+     */
+    flags?: SymbolTypeFlag;
+    /**
+     * this symbol comes from an ancestor symbol table
+     */
+    memberOfAncestor?: boolean;
+    /**
+     * Do not merge this symbol when merging symbol tables
+     */
+    doNotMerge?: boolean;
+    /**
+     * is this symbol an alias?
+     */
+    isAlias?: boolean;
+    /**
+     * Is this symbol an instance of the type.
+     *
+     * `true` means `true`, and `false` or `undefined` means `false`,
+     *
+     * so check for `=== true` or `!== true`
+     */
+    isInstance?: boolean;
+}
+export interface GetTypeOptions {
+    flags: SymbolTypeFlag;
+    typeChain?: TypeChainEntry[];
+    data?: ExtraSymbolData;
+    ignoreCall?: boolean;
+    onlyCacheResolvedTypes?: boolean;
+    ignoreCacheForRetrieval?: boolean;
+    isExistenceTest?: boolean;
+}
+export declare class TypeChainEntry {
+    constructor(options: {
+        name: string;
+        type: BscType;
+        data: ExtraSymbolData;
+        range?: Range;
+        separatorToken?: Token;
+        astNode: AstNode;
+    });
+    get range(): Range;
+    readonly name: string;
+    readonly type: BscType;
+    readonly data: ExtraSymbolData;
+    private readonly _range;
+    readonly separatorToken: Token;
+    isResolved: boolean;
+    astNode: AstNode;
+}
+export interface TypeChainProcessResult {
+    /**
+     * The name of the last item in the chain, OR the first unresolved item in the chain
+     */
+    itemName: string;
+    /**
+     * The TypeKind of the item of `itemName`
+     */
+    itemTypeKind: BscTypeKind | string;
+    /**
+     * The name of the parent of the item of `itemName`
+     */
+    itemParentTypeName: string;
+    /**
+     * The TypeKind of the parent of the item of `itemName`
+     */
+    itemParentTypeKind: BscTypeKind | string;
+    /**
+     * The complete chain leading up to the item of `itemName`
+     */
+    fullNameOfItem: string;
+    /**
+     * The complete chain (even including unresolved items)
+     */
+    fullChainName: string;
+    /**
+     * the range of the first unresolved item
+     */
+    range: Range;
+    /**
+     * Does the chain contain a dynamic type?
+     */
+    containsDynamic: boolean;
+    /**
+     * The AstNode of the item
+     */
+    astNode: AstNode;
+}
+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;
+}
+/**
+ * Use Writable<T> to remove readonly flag from properties in T
+ * Be careful!
+ */
+export declare type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export declare type DeepWriteable<T> = {
+    -readonly [P in keyof T]: DeepWriteable<T[P]>;
+};