brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.50

package/dist/interfaces.d.ts

@@ -1,23 +1,91 @@
-import type { Range, Diagnostic, CodeAction, SemanticTokenTypes, SemanticTokenModifiers } from 'vscode-languageserver';
+/// <reference types="node" />
+/// <reference types="node" />
+import type { Range, CodeAction, Position, CompletionItem, Location, DocumentSymbol, WorkspaceSymbol, Disposable, FileChangeType, CodeDescription, DiagnosticRelatedInformation, DiagnosticSeverity, DiagnosticTag } 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 { FunctionStatement, NamespaceStatement } from './parser/Statement';
+import type { AstNode, Expression } from './parser/AstNode';
 import type { TranspileState } from './parser/TranspileState';
 import type { SourceNode } from 'source-map';
 import type { BscType } from './types/BscType';
-export interface BsDiagnostic extends Diagnostic {
-    file: BscFile;
+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 {
+    /**
+     * The location at which the message applies
+     */
+    location: Location;
+    /**
+     * The diagnostic's severity. Can be omitted. If omitted it is up to the
+     * client to interpret diagnostics as error, warning, info or hint.
+     */
+    severity?: DiagnosticSeverity;
+    /**
+     * The diagnostic's code, which usually appear in the user interface.
+     */
+    code?: number | string;
     /**
-     * A generic data container where additional details of the diagnostic can be stored. These are stripped out before being sent to a languageclient, and not printed to the console.
+     * An optional property to describe the error code.
+     * Requires the code field (above) to be present/not null.
+     *
+     * @since 3.16.0
+     */
+    codeDescription?: CodeDescription;
+    /**
+     * A human-readable string describing the source of this
+     * diagnostic, e.g. 'typescript' or 'super lint'. It usually
+     * appears in the user interface.
+     */
+    source?: string;
+    /**
+     * The diagnostic's message. It usually appears in the user interface
+     */
+    message: string;
+    /**
+     * Additional metadata about the diagnostic.
+     *
+     * @since 3.15.0
+     */
+    tags?: DiagnosticTag[];
+    /**
+     * An array of related diagnostic information, e.g. when symbol-names within
+     * a scope collide all definitions can be marked via this property.
+     */
+    relatedInformation?: DiagnosticRelatedInformation[];
+    /**
+     * A data entry field that is preserved between a `textDocument/publishDiagnostics`
+     * notification and `textDocument/codeAction` request.
+     *
+     * @since 3.16.0
      */
     data?: any;
+    /**
+     * The code used for this diagnostic in v0
+     */
+    legacyCode?: number | string;
+}
+export interface DiagnosticContext {
+    scopeSpecific?: boolean;
+    scope?: Scope;
+    tags?: string[];
+    segment?: AstNode;
+}
+export interface DiagnosticContextPair {
+    diagnostic: BsDiagnostic;
+    context?: DiagnosticContext;
 }
-export declare type BscFile = BrsFile | XmlFile;
 export interface Callable {
     file: BscFile;
     name: string;
@@ -25,7 +93,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 +122,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 +143,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 +161,7 @@ export interface FileReference {
 }
 export interface VariableDeclaration {
     name: string;
-    type: BscType;
+    getType: () => BscType;
     /**
      * The range for the variable name
      */
@@ -151,170 +203,713 @@ export interface CommentFlag {
     affectedRange: Range;
     codes: DiagnosticCode[] | null;
 }
-export declare type CompilerPluginFactory = () => CompilerPlugin;
-export interface CompilerPlugin {
+export interface PluginFactoryOptions {
+    /**
+     * What version of brighterscript is activating this plugin? (Useful for picking different plugins or behavior based on the version of brighterscript)
+     */
+    version: string;
+}
+export declare type PluginFactory = (options?: PluginFactoryOptions) => Plugin;
+/**
+ * @deprecated use `PluginFactory` instead
+ */
+export declare type CompilerPluginFactory = PluginFactory;
+/**
+ * @deprecated use `Plugin` instead
+ */
+export declare type CompilerPlugin = Plugin;
+export interface Plugin {
     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>;
-    onGetSemanticTokens?: PluginHandler<OnGetSemanticTokensEvent>;
-    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;
+    /**
+     * Called before a new program is created
+     */
+    beforeProvideProgram?(event: BeforeProvideProgramEvent): any;
+    provideProgram?(event: ProvideProgramEvent): any;
+    /**
+     * Called after a new program is created
+     */
+    afterProvideProgram?(event: AfterProvideProgramEvent): 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
+     */
+    beforeValidateProgram?(event: BeforeValidateProgramEvent): any;
+    /**
+     * Called before the entire program is validated
+     */
+    validateProgram?(event: ValidateProgramEvent): any;
+    /**
+     * Called after the program has been validated
+     */
+    afterValidateProgram?(event: AfterValidateProgramEvent): any;
+    /**
+     * Called right before the program is disposed/destroyed
+     */
+    beforeRemoveProgram?(event: BeforeRemoveProgramEvent): any;
+    removeProgram?(event: RemoveProgramEvent): any;
+    afterRemoveProgram?(event: AfterRemoveProgramEvent): 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
+     */
+    beforeProvideScope?(event: BeforeProvideScopeEvent): any;
+    provideScope?(event: ProvideScopeEvent): any;
+    afterProvideScope?(event: AfterProvideScopeEvent): any;
+    beforeRemoveScope?(event: BeforeRemoveProgramEvent): any;
+    removeScope?(event: RemoveScopeEvent): any;
+    afterRemoveScope?(event: AfterRemoveScopeEvent): 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;
+    beforeValidateScope?(event: BeforeValidateScopeEvent): any;
+    validateScope?(event: ValidateScopeEvent): any;
+    afterValidateScope?(event: AfterValidateScopeEvent): any;
+    beforeProvideCodeActions?(event: BeforeProvideCodeActionsEvent): any;
+    provideCodeActions?(event: ProvideCodeActionsEvent): any;
+    afterProvideCodeActions?(event: AfterProvideCodeActionsEvent): any;
+    beforeProvideSemanticTokens?(event: BeforeProvideSemanticTokensEvent): any;
+    provideSemanticTokens?(event: ProvideSemanticTokensEvent): any;
+    afterProvideSemanticTokens?(event: AfterProvideSemanticTokensEvent): 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
+     */
+    beforeAddFile?(event: BeforeAddFileEvent): any;
+    /**
+     * Called after a file has been added to the program.
+     * Includes physical files as well as any virtual files produced by `provideFile` events
+     */
+    afterAddFile?(event: AfterAddFileEvent): any;
+    /**
+     * Called before a file is removed from the program. This includes physical and virtual files
+     */
+    beforeRemoveFile?(event: BeforeRemoveFileEvent): any;
+    /**
+     * Called after a file has been removed from the program. This includes physical and virtual files
+     */
+    afterRemoveFile?(event: AfterRemoveFileEvent): any;
+    /**
+     * Called before each file is validated
+     */
+    beforeValidateFile?(event: BeforeValidateFileEvent): any;
+    /**
+     * Called during the file validation process. If your plugin contributes file validations, this is a good place to contribute them.
+     */
+    validateFile?(event: ValidateFileEvent): any;
+    /**
+     * Called after each file is validated
+     */
+    afterValidateFile?(event: AfterValidateFileEvent): any;
+    /**
+     * Called right before the program builds (i.e. generates the code and puts it in the outDir
+     */
+    beforeBuildProgram?(event: BeforeBuildProgramEvent): any;
+    /**
+     * Called right after the program builds (i.e. generates the code and puts it in the outDir
+     */
+    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
+     */
+    serializeProgram?(event: SerializeProgramEvent): 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 BeforePrepublishEvent {
-    builder: ProgramBuilder;
+export interface BeforeProvideCodeActionsEvent<TFile extends BscFile = BscFile> {
     program: Program;
-    files: FileObj[];
+    file: TFile;
+    range: Range;
+    scopes: Scope[];
+    diagnostics: BsDiagnostic[];
+    codeActions: CodeAction[];
 }
-export interface AfterPrepublishEvent {
-    builder: ProgramBuilder;
+export interface ProvideCodeActionsEvent<TFile extends BscFile = BscFile> {
     program: Program;
-    files: FileObj[];
+    file: TFile;
+    range: Range;
+    scopes: Scope[];
+    diagnostics: BsDiagnostic[];
+    codeActions: CodeAction[];
 }
-export interface BeforePublishEvent {
-    builder: ProgramBuilder;
+export interface AfterProvideCodeActionsEvent<TFile extends BscFile = BscFile> {
     program: Program;
-    files: FileObj[];
+    file: TFile;
+    range: Range;
+    scopes: Scope[];
+    diagnostics: BsDiagnostic[];
+    codeActions: CodeAction[];
 }
-export interface AfterPublishEvent {
+export interface BeforeProvideProgramEvent {
     builder: ProgramBuilder;
-    program: Program;
-    files: FileObj[];
+    program?: Program;
 }
-export interface AfterProgramCreateEvent {
+export interface ProvideProgramEvent {
     builder: ProgramBuilder;
-    program: Program;
+    program?: Program;
 }
-export interface BeforeProgramValidateEvent {
+export interface AfterProvideProgramEvent {
+    builder: ProgramBuilder;
     program: Program;
 }
-export interface AfterProgramValidateEvent {
+export interface BeforeValidateProgramEvent {
     program: Program;
 }
-export interface BeforeProgramTranspileEvent {
+export declare type ValidateProgramEvent = BeforeValidateProgramEvent;
+export interface AfterValidateProgramEvent extends BeforeValidateProgramEvent {
+    /**
+     * Was the validation cancelled? Will be false if the validation was completed
+     */
+    wasCancelled: boolean;
+}
+export interface ProvideCompletionsEvent<TFile extends BscFile = BscFile> {
     program: Program;
-    entries: TranspileEntry[];
+    file: TFile;
+    /**
+     * The scopes this file is a member of. If the file is a member of no scopes, this will be an empty array.
+     * Plugins can use `event.program.globalScope` if the file is not a member of any scopes
+     */
+    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 interface AfterScopeCreateEvent {
+export declare type BeforeProvideHoverEvent = ProvideHoverEvent;
+export declare type AfterProvideHoverEvent = ProvideHoverEvent;
+export interface BeforeProvideScopeEvent {
     program: Program;
     scope: Scope;
 }
-export interface BeforeScopeDisposeEvent {
+export interface ProvideScopeEvent {
     program: Program;
     scope: Scope;
 }
-export interface AfterScopeDisposeEvent {
+export interface AfterProvideScopeEvent {
     program: Program;
     scope: Scope;
 }
-export interface BeforeScopeValidateEvent {
+export interface BeforeRemoveProgramEvent {
+    program: Program;
+}
+export interface RemoveScopeEvent {
     program: Program;
     scope: Scope;
 }
-export interface AfterScopeValidateEvent {
+export interface AfterRemoveScopeEvent {
     program: Program;
     scope: Scope;
 }
-export interface OnScopeGetCodeActionsEvent {
+export interface BeforeValidateScopeEvent {
     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[];
 }
+export declare type AfterValidateScopeEvent = BeforeValidateScopeEvent;
 export interface BeforeFileParseEvent {
     program: Program;
     srcPath: string;
     source: string;
 }
+export interface OnFileParseEvent {
+    program: Program;
+    srcPath: string;
+    source: string;
+}
 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 interface BeforeFileTranspileEvent {
+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 BeforeProvideSemanticTokensEvent<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 interface ProvideSemanticTokensEvent<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 interface AfterProvideSemanticTokensEvent<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 BeforeValidateFileEvent = ValidateFileEvent;
+export interface ValidateFileEvent<T extends BscFile = BscFile> {
+    program: Program;
+    file: T;
+}
+export declare type AfterValidateFileEvent<T extends BscFile = BscFile> = ValidateFileEvent;
+export interface ValidateFileEvent<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?: BscFile[];
+    force?: boolean;
+    initialValidation?: boolean;
+}
+export interface ValidateScopeEvent {
     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 BeforeAddFileEvent<TFile extends BscFile = BscFile> {
+    file: TFile;
     program: Program;
-    file: BscFile;
 }
-export interface OnFileGetCodeActionsEvent {
+export declare type AfterAddFileEvent<TFile extends BscFile = BscFile> = BeforeAddFileEvent<TFile>;
+export interface BeforeRemoveFileEvent<TFile extends BscFile = BscFile> {
+    file: TFile;
     program: Program;
-    file: BscFile;
-    range: Range;
+}
+export declare type AfterRemoveFileEvent<TFile extends BscFile = BscFile> = BeforeRemoveFileEvent<TFile>;
+export declare type BeforePrepareProgramEvent = PrepareProgramEvent;
+/**
+ * Event for when the program prepares itself for building
+ */
+export interface PrepareProgramEvent {
+    program: Program;
+    editor: Editor;
+    files: BscFile[];
+}
+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;
     /**
-     * A filtered list of diagnostics whose lines touch the lines of the given range
+     * The scope that was linked for this event. A file may be included in multiple scopes, but we choose the most relevant scope.
+     * Plugins may unlink this scope and link another one, but must then reassign this property to that new scope so that other
+     * plugins can reference it.
      */
-    diagnostics: BsDiagnostic[];
-    codeActions: CodeAction[];
+    scope: Scope;
 }
-export interface TranspileEntry {
+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 SerializeProgramEvent = 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: TFile;
+    /**
+     * The scope that was linked for this event. A file may be included in multiple scopes, but we choose the most relevant scope.
+     * Plugins may unlink this scope and link another one, but must then reassign this property to that new scope so that other
+     * plugins can reference it.
+     */
+    scope: Scope;
+    /**
+     * 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;
+    outDir: 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 outDir)
+     */
     outputPath: string;
 }
-export interface OnGetSemanticTokensEvent {
+export interface BeforeFileDisposeEvent {
     program: Program;
     file: BscFile;
-    scopes: Scope[];
-    semanticTokens: SemanticToken[];
+}
+export declare type AfterFileDisposeEvent = BeforeFileDisposeEvent;
+export interface BeforeRemoveProgramEvent {
+    program: Program;
+}
+export interface RemoveProgramEvent {
+    program: Program;
+}
+export interface AfterRemoveProgramEvent {
+    program: Program;
 }
 export interface SemanticToken {
     range: Range;
@@ -325,16 +920,238 @@ export interface SemanticToken {
     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;
+    /**
+     * Is this type as defined in a doc comment?
+     */
+    isFromDocComment?: boolean;
+    /**
+     * Is this symbol built in to Brightscript?
+     */
+    isBuiltIn?: boolean;
+    /**
+     * Was this a result of a callfunc?
+     */
+    isFromCallFunc?: boolean;
+    /**
+     * Is this type created from a type statement - eg. is it a nickname for another type?
+     */
+    isFromTypeStatement?: boolean;
+}
+export interface GetTypeOptions {
+    flags: SymbolTypeFlag;
+    typeChain?: TypeChainEntry[];
+    data?: ExtraSymbolData;
+    /**
+     * get the type of this expression, NOT its return type
+     */
+    ignoreCall?: boolean;
+    onlyCacheResolvedTypes?: boolean;
+    ignoreCacheForRetrieval?: boolean;
+    isExistenceTest?: boolean;
+    preferDocType?: boolean;
+    /**
+     * For narrowing the type, which statement are we concerned with in the current block?
+     */
+    statementIndex?: number | 'end';
+    ignoreParentTables?: boolean;
+    /**
+     * If this is true, AA's, objects, nodes, etc, do not return dynamic if no member is found
+     */
+    ignoreDefaultDynamicMembers?: boolean;
+}
+export declare class TypeChainEntry {
+    constructor(options: {
+        name: string;
+        type: BscType;
+        data: ExtraSymbolData;
+        location?: Location;
+        separatorToken?: Token;
+        astNode: AstNode;
+    });
+    get location(): Location;
+    readonly name: string;
+    readonly type: BscType;
+    readonly data: ExtraSymbolData;
+    private readonly _location;
+    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
+     */
+    location: Location;
+    /**
+     * Does the chain contain a dynamic type?
+     */
+    containsDynamic: boolean;
+    /**
+     * The AstNode of the item
+     */
+    astNode: AstNode;
+    /**
+     * Does the chain contain a type that crossed a callFunc boundary?
+     */
+    crossedCallFunc: boolean;
+}
+export interface TypeCircularReferenceInfo {
+    isCircularReference: boolean;
+    referenceChainNames?: string[];
+}
+export interface TypeCompatibilityData {
+    missingFields?: {
+        name: string;
+        expectedType: BscType;
+    }[];
+    fieldMismatches?: {
+        name: string;
+        expectedType: BscType;
+        actualType: BscType;
+    }[];
+    parameterMismatches?: {
+        index: number;
+        expectedOptional?: boolean;
+        actualOptional?: boolean;
+        data: TypeCompatibilityData;
+    }[];
+    returnTypeMismatch?: TypeCompatibilityData;
+    expectedParamCount?: number;
+    actualParamCount?: number;
+    expectedVariadic?: boolean;
+    actualVariadic?: boolean;
+    depth?: number;
+    actualType?: BscType;
+    expectedType?: BscType;
+    allowNameEquality?: boolean;
+    unresolveableTarget?: string;
+}
+export interface NamespaceContainer {
+    file: BscFile;
+    fullName: string;
+    fullNameLower: string;
+    parentNameLower: string;
+    nameParts: Identifier[];
+    nameRange: Range;
+    lastPartName: string;
+    lastPartNameLower: string;
+    isTopLevel: boolean;
+    namespaceStatements?: NamespaceStatement[];
+    symbolTable: SymbolTable;
+}
+export interface ScopeNamespaceContainer {
+    namespaceContainers: NamespaceContainer[];
+    symbolTable: SymbolTable;
+    firstInstance: NamespaceContainer;
+}
+/**
+ * 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]>;
+};
+export declare type DisposableLike = Disposable | (() => any);
+export declare type MaybePromise<T> = T | Promise<T>;
+export interface FileChange {
+    /**
+     * Absolute path to the source file
+     */
+    srcPath: string;
+    /**
+     * What type of change was this.
+     */
+    type: FileChangeType;
+    /**
+     * If provided, this is the new contents of the file. If not provided, the file will be read from disk
+     */
+    fileContents?: string;
+    /**
+     * If true, this file change can have a project created exclusively for it, it no other projects handled it
+     */
+    allowStandaloneProject?: boolean;
+}