brighterscript 0.66.0-alpha.8 → 0.67.0

package/dist/interfaces.d.ts

@@ -1,50 +1,36 @@
-/// <reference types="node" />
-import type { Range, Diagnostic, CodeAction, SemanticTokenTypes, SemanticTokenModifiers, Position, CompletionItem } from 'vscode-languageserver';
+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 { FunctionScope } from './FunctionScope';
-import type { TypedFunctionType } from './types/TypedFunctionType';
+import type { FunctionType } from './types/FunctionType';
 import type { ParseMode } from './parser/Parser';
-import type { Program } from './Program';
+import type { Program, SourceObj, TranspileObj } from './Program';
 import type { ProgramBuilder } from './ProgramBuilder';
-import type { ClassStatement, ConstStatement, EnumStatement, FunctionStatement, NamespaceStatement } from './parser/Statement';
-import type { AstNode, Expression, Statement } from './parser/AstNode';
+import type { FunctionStatement } from './parser/Statement';
+import type { Expression } from './parser/AstNode';
 import type { TranspileState } from './parser/TranspileState';
-import type { SourceNode } from 'source-map';
+import type { SourceMapGenerator, 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 { File } from './files/File';
-import type { FileFactory } from './files/Factory';
-import type { LazyFileData } from './files/LazyFileData';
-import type { SymbolTable, SymbolTypeFlag } from './SymbolTable';
-import type { CallExpression } from './parser/Expression';
+import type { AstEditor } from './astUtils/AstEditor';
+import type { Token } from './lexer/Token';
+import type { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver';
 export interface BsDiagnostic extends Diagnostic {
-    file: File;
+    file: BscFile;
     /**
      * 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.
      */
     data?: any;
 }
-export declare enum DiagnosticOrigin {
-    Program = "Program",
-    Scope = "Scope",
-    File = "File",
-    ASTSegment = "AstSegment"
-}
-export interface BsDiagnosticWithOrigin extends BsDiagnostic {
-    origin: DiagnosticOrigin;
-    astSegment?: AstNode;
-}
+export declare type BscFile = BrsFile | XmlFile;
 export interface Callable {
-    file: File;
+    file: BscFile;
     name: string;
     /**
      * Is the callable declared as "sub". If falsey, assumed declared as "function"
      */
     isSub: boolean;
-    type: TypedFunctionType;
+    type: FunctionType;
     /**
      * A short description of the callable. Should be a short sentence.
      */
@@ -78,7 +64,6 @@ export interface FunctionCall {
      * The full range of this function call (from the start of the function name to its closing paren)
      */
     range: Range;
-    expression: CallExpression;
     functionScope: FunctionScope;
     file: File;
     name: string;
@@ -116,12 +101,12 @@ export interface FileObj {
  */
 export interface FileReference {
     /**
-     * The destPath for the referenced file.
+     * The pkgPath to the referenced file.
      */
-    destPath: string;
+    pkgPath: string;
     text: string;
     /**
-     * The file that is doing the import. Note this is NOT the file the destPath points to.
+     * The file that is doing the import. Note this is NOT the file the pkgPath points to.
      */
     sourceFile: XmlFile | BrsFile;
     /**
@@ -132,9 +117,17 @@ export interface FileReference {
      */
     filePathRange?: Range;
 }
+export interface File {
+    /**
+     * The absolute path to the file, relative to the pkg
+     */
+    pkgPath: string;
+    srcPath: string;
+    getDiagnostics(): BsDiagnostic[];
+}
 export interface VariableDeclaration {
     name: string;
-    getType: () => BscType;
+    type: BscType;
     /**
      * The range for the variable name
      */
@@ -165,7 +158,7 @@ export interface CallableContainer {
 }
 export declare type CallableContainerMap = Map<string, CallableContainer[]>;
 export interface CommentFlag {
-    file: File;
+    file: BscFile;
     /**
      * The location of the ignore comment.
      */
@@ -176,45 +169,22 @@ export interface CommentFlag {
     affectedRange: Range;
     codes: DiagnosticCode[] | null;
 }
+declare type ValidateHandler = (scope: Scope, files: BscFile[], callables: CallableContainerMap) => void;
 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>;
-    /**
-     * 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>;
-    /**
-     * Called right before the program is disposed/destroyed
-     */
+    beforeProgramCreate?: (builder: ProgramBuilder) => void;
+    beforePrepublish?: (builder: ProgramBuilder, files: FileObj[]) => void;
+    afterPrepublish?: (builder: ProgramBuilder, files: FileObj[]) => void;
+    beforePublish?: (builder: ProgramBuilder, files: FileObj[]) => void;
+    afterPublish?: (builder: ProgramBuilder, files: FileObj[]) => void;
+    afterProgramCreate?: (program: Program) => void;
+    beforeProgramValidate?: (program: Program) => void;
+    afterProgramValidate?: (program: Program) => void;
+    beforeProgramTranspile?: (program: Program, entries: TranspileObj[], editor: AstEditor) => void;
+    afterProgramTranspile?: (program: Program, entries: TranspileObj[], editor: AstEditor) => void;
     beforeProgramDispose?: PluginHandler<BeforeProgramDisposeEvent>;
+    onGetCodeActions?: PluginHandler<OnGetCodeActionsEvent>;
     /**
      * Emitted before the program starts collecting completions
      */
@@ -240,165 +210,108 @@ export interface CompilerPlugin {
      */
     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<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
-     */
-    beforeFileValidate?: PluginHandler<BeforeFileValidateEvent>;
-    /**
-     * Called during the file validation process. If your plugin contributes file validations, this is a good place to contribute them.
-     */
-    onFileValidate?: PluginHandler<OnFileValidateEvent>;
-    /**
-     * Called after each file is validated
+     * Called before the `provideDefinition` hook
      */
-    afterFileValidate?: PluginHandler<AfterFileValidateEvent>;
+    beforeProvideDefinition?(event: BeforeProvideDefinitionEvent): any;
     /**
-     * Called right before the program builds (i.e. generates the code and puts it in the stagingDir
+     * Provide one or more `Location`s where the symbol at the given position was originally defined
+     * @param event
      */
-    beforeBuildProgram?: PluginHandler<BeforeBuildProgramEvent>;
+    provideDefinition?(event: ProvideDefinitionEvent): any;
     /**
-     * Called right after the program builds (i.e. generates the code and puts it in the stagingDir
+     * Called after `provideDefinition`. Use this if you want to intercept or sanitize the definition data provided by bsc or other plugins
+     * @param event
      */
-    afterBuildProgram?: PluginHandler<AfterBuildProgramEvent>;
+    afterProvideDefinition?(event: AfterProvideDefinitionEvent): any;
     /**
-     * Before preparing the file for building
+     * Called before the `provideReferences` hook
      */
-    beforePrepareFile?: PluginHandler<BeforePrepareFileEvent>;
+    beforeProvideReferences?(event: BeforeProvideReferencesEvent): any;
     /**
-     * Prepare the file for building
+     * Provide all of the `Location`s where the symbol at the given position is located
+     * @param event
      */
-    prepareFile?: PluginHandler<PrepareFileEvent>;
+    provideReferences?(event: ProvideReferencesEvent): any;
     /**
-     * After preparing the file for building
+     * Called after `provideReferences`. Use this if you want to intercept or sanitize the references data provided by bsc or other plugins
+     * @param event
      */
-    afterPrepareFile?: PluginHandler<AfterPrepareFileEvent>;
+    afterProvideReferences?(event: AfterProvideReferencesEvent): any;
     /**
-     * Before the program turns all file objects into their final buffers
+     * Called before the `provideDocumentSymbols` hook
      */
-    beforeSerializeProgram?: PluginHandler<BeforeSerializeProgramEvent>;
+    beforeProvideDocumentSymbols?(event: BeforeProvideDocumentSymbolsEvent): any;
     /**
-     * Emitted right at the start of the program turning all file objects into their final buffers
+     * Provide all of the `DocumentSymbol`s for the given file
+     * @param event
      */
-    onSerializeProgram?: PluginHandler<OnSerializeProgramEvent>;
+    provideDocumentSymbols?(event: ProvideDocumentSymbolsEvent): any;
     /**
-     * After the program turns all file objects into their final buffers
+     * Called after `provideDocumentSymbols`. Use this if you want to intercept or sanitize the document symbols data provided by bsc or other plugins
+     * @param event
      */
-    afterSerializeProgram?: PluginHandler<AfterSerializeProgramEvent>;
+    afterProvideDocumentSymbols?(event: AfterProvideDocumentSymbolsEvent): any;
     /**
-     * Before turning the file into its final contents
+     * Called before the `provideWorkspaceSymbols` hook
      */
-    beforeSerializeFile?: PluginHandler<BeforeSerializeFileEvent>;
+    beforeProvideWorkspaceSymbols?(event: BeforeProvideWorkspaceSymbolsEvent): any;
     /**
-     * Turn the file into its final contents (i.e. transpile a bs file, compress a jpeg, etc)
+     * Provide all of the workspace symbols for the entire project
+     * @param event
      */
-    serializeFile?: PluginHandler<SerializeFileEvent>;
+    provideWorkspaceSymbols?(event: ProvideWorkspaceSymbolsEvent): any;
     /**
-     * After turning the file into its final contents
+     * Called after `provideWorkspaceSymbols`. Use this if you want to intercept or sanitize the workspace symbols data provided by bsc or other plugins
+     * @param event
      */
-    afterSerializeFile?: PluginHandler<AfterSerializeFileEvent>;
-    /**
-     * Called before any files are written
-     */
-    beforeWriteProgram?: PluginHandler<BeforeWriteProgramEvent>;
-    /**
-     * Called after all files are written
-     */
-    afterWriteProgram?: PluginHandler<AfterWriteProgramEvent>;
+    afterProvideWorkspaceSymbols?(event: AfterProvideWorkspaceSymbolsEvent): any;
+    onGetSemanticTokens?: PluginHandler<OnGetSemanticTokensEvent>;
+    afterScopeCreate?: (scope: Scope) => void;
+    beforeScopeDispose?: (scope: Scope) => void;
+    afterScopeDispose?: (scope: Scope) => void;
+    beforeScopeValidate?: ValidateHandler;
+    onScopeValidate?: PluginHandler<OnScopeValidateEvent>;
+    afterScopeValidate?: ValidateHandler;
+    beforeFileParse?: (source: SourceObj) => void;
+    afterFileParse?: (file: BscFile) => void;
     /**
-     * Before a file is written to disk. These are raw files that contain the final output. One `File` may produce several of these
+     * Called before each file is validated
      */
-    beforeWriteFile?: PluginHandler<BeforeWriteFileEvent>;
+    beforeFileValidate?: PluginHandler<BeforeFileValidateEvent>;
     /**
-     * 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
+     * Called during the file validation process. If your plugin contributes file validations, this is a good place to contribute them.
      */
-    writeFile?: PluginHandler<WriteFileEvent>;
+    onFileValidate?: PluginHandler<OnFileValidateEvent>;
     /**
-     * Before a file is written to disk. These are raw files that contain the final output. One `File` may produce several of these
+     * Called after each file is validated
      */
-    afterWriteFile?: PluginHandler<AfterWriteFileEvent>;
+    afterFileValidate?: (file: BscFile) => void;
+    beforeFileTranspile?: PluginHandler<BeforeFileTranspileEvent>;
+    afterFileTranspile?: PluginHandler<AfterFileTranspileEvent>;
+    beforeFileDispose?: (file: BscFile) => void;
+    afterFileDispose?: (file: BscFile) => void;
 }
 export declare type PluginHandler<T, R = void> = (event: T) => R;
-export interface OnGetCodeActionsEvent<TFile extends File = File> {
+export interface OnGetCodeActionsEvent {
     program: Program;
-    file: TFile;
+    file: BscFile;
     range: Range;
     scopes: Scope[];
     diagnostics: BsDiagnostic[];
     codeActions: CodeAction[];
 }
-export interface BeforeProgramCreateEvent {
-    builder: ProgramBuilder;
-}
-export interface AfterProgramCreateEvent {
-    builder: ProgramBuilder;
-    program: Program;
-}
-export interface BeforeProgramValidateEvent {
-    program: Program;
-}
-export declare type OnProgramValidateEvent = BeforeProgramValidateEvent;
-export declare type AfterProgramValidateEvent = BeforeProgramValidateEvent;
-export interface ProvideCompletionsEvent<TFile extends File = File> {
+export interface ProvideCompletionsEvent<TFile extends BscFile = BscFile> {
     program: Program;
     file: TFile;
     scopes: Scope[];
     position: Position;
     completions: CompletionItem[];
 }
-export declare type BeforeProvideCompletionsEvent<TFile extends File = File> = ProvideCompletionsEvent<TFile>;
-export declare type AfterProvideCompletionsEvent<TFile extends File = File> = ProvideCompletionsEvent<TFile>;
-export interface BeforeBuildProgramEvent {
-    program: Program;
-    files: File[];
-    editor: Editor;
-}
-export declare type AfterBuildProgramEvent = BeforeBuildProgramEvent;
+export declare type BeforeProvideCompletionsEvent<TFile extends BscFile = BscFile> = ProvideCompletionsEvent<TFile>;
+export declare type AfterProvideCompletionsEvent<TFile extends BscFile = BscFile> = ProvideCompletionsEvent<TFile>;
 export interface ProvideHoverEvent {
     program: Program;
-    file: File;
+    file: BscFile;
     position: Position;
     scopes: Scope[];
     hovers: Hover[];
@@ -420,42 +333,63 @@ export interface Hover {
 }
 export declare type BeforeProvideHoverEvent = ProvideHoverEvent;
 export declare type AfterProvideHoverEvent = ProvideHoverEvent;
-export interface AfterScopeCreateEvent {
-    program: Program;
-    scope: Scope;
-}
-export interface BeforeScopeDisposeEvent {
-    program: Program;
-    scope: Scope;
-}
-export interface OnScopeDisposeEvent {
-    program: Program;
-    scope: Scope;
-}
-export interface AfterScopeDisposeEvent {
-    program: Program;
-    scope: Scope;
-}
-export interface BeforeScopeValidateEvent {
+export interface ProvideDefinitionEvent<TFile = BscFile> {
     program: Program;
-    scope: Scope;
+    /**
+     * 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 declare type AfterScopeValidateEvent = BeforeScopeValidateEvent;
-export interface BeforeFileParseEvent {
+export declare type BeforeProvideDefinitionEvent<TFile = BscFile> = ProvideDefinitionEvent<TFile>;
+export declare type AfterProvideDefinitionEvent<TFile = BscFile> = ProvideDefinitionEvent<TFile>;
+export interface ProvideReferencesEvent<TFile = BscFile> {
     program: Program;
-    srcPath: string;
-    source: string;
+    /**
+     * 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 interface OnFileParseEvent {
+export declare type BeforeProvideReferencesEvent<TFile = BscFile> = ProvideReferencesEvent<TFile>;
+export declare type AfterProvideReferencesEvent<TFile = BscFile> = ProvideReferencesEvent<TFile>;
+export interface ProvideDocumentSymbolsEvent<TFile = BscFile> {
     program: Program;
-    srcPath: string;
-    source: string;
+    /**
+     * The file that the `documentSymbol` request was invoked in
+     */
+    file: TFile;
+    /**
+     * The result list of symbols
+     */
+    documentSymbols: DocumentSymbol[];
 }
-export interface AfterFileParseEvent {
+export declare type BeforeProvideDocumentSymbolsEvent<TFile = BscFile> = ProvideDocumentSymbolsEvent<TFile>;
+export declare type AfterProvideDocumentSymbolsEvent<TFile = BscFile> = ProvideDocumentSymbolsEvent<TFile>;
+export interface ProvideWorkspaceSymbolsEvent {
     program: Program;
-    file: File;
+    /**
+     * The result list of symbols
+     */
+    workspaceSymbols: WorkspaceSymbol[];
 }
-export interface OnGetSemanticTokensEvent<T extends File = File> {
+export declare type BeforeProvideWorkspaceSymbolsEvent = ProvideWorkspaceSymbolsEvent;
+export declare type AfterProvideWorkspaceSymbolsEvent = ProvideWorkspaceSymbolsEvent;
+export interface OnGetSemanticTokensEvent<T extends BscFile = BscFile> {
     /**
      * The program this file is from
      */
@@ -473,32 +407,31 @@ export interface OnGetSemanticTokensEvent<T extends File = File> {
      */
     semanticTokens: SemanticToken[];
 }
-export declare type BeforeFileValidateEvent = OnFileValidateEvent;
-export interface OnFileValidateEvent<T extends File = File> {
+export interface BeforeFileValidateEvent<T extends BscFile = BscFile> {
     program: Program;
     file: T;
 }
-export declare type AfterFileValidateEvent = OnFileValidateEvent;
-export interface OnFileValidateEvent<T extends File = File> {
+export interface OnFileValidateEvent<T extends BscFile = BscFile> {
     program: Program;
     file: T;
 }
-export interface TranspileEntry {
-    file: File;
-    outputPath: string;
-}
-export interface ScopeValidationOptions {
-    changedFiles?: File[];
-    changedSymbols?: Map<SymbolTypeFlag, Set<string>>;
-    force?: boolean;
-}
 export interface OnScopeValidateEvent {
     program: Program;
     scope: Scope;
-    changedFiles?: File[];
-    changedSymbols?: Map<SymbolTypeFlag, Set<string>>;
 }
-export interface AfterFileTranspileEvent<TFile extends File = File> {
+export declare type Editor = Pick<AstEditor, 'addToArray' | 'hasChanges' | 'removeFromArray' | 'setArrayValue' | 'setProperty' | 'overrideTranspileResult' | 'arrayPop' | 'arrayPush' | 'arrayShift' | 'arraySplice' | 'arrayUnshift' | 'removeProperty' | 'edit'>;
+export interface BeforeFileTranspileEvent<TFile extends BscFile = BscFile> {
+    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;
+}
+export interface AfterFileTranspileEvent<TFile extends BscFile = BscFile> {
     /**
      * The program this event was triggered for
      */
@@ -512,147 +445,18 @@ export interface AfterFileTranspileEvent<TFile extends File = File> {
     /**
      * The sourceMaps for the generated code (if emitting source maps is enabled)
      */
-    map?: string;
+    map?: SourceMapGenerator;
     /**
      * The generated type definition file contents (if emitting type definitions are enabled)
      */
     typedef?: string;
-}
-export declare type BeforeProvideFileEvent<TFile extends File = File> = ProvideFileEvent<TFile>;
-export interface ProvideFileEvent<TFile extends File = File> {
-    /**
-     * 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;
     /**
-     * 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)
+     * 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.
      */
-    fileFactory: FileFactory;
-}
-export declare type AfterProvideFileEvent<TFile extends File = File> = ProvideFileEvent<TFile>;
-export interface BeforeFileAddEvent<TFile extends File = File> {
-    file: TFile;
-    program: Program;
-}
-export declare type AfterFileAddEvent<TFile extends File = File> = BeforeFileAddEvent<TFile>;
-export interface BeforeFileRemoveEvent<TFile extends File = File> {
-    file: TFile;
-    program: Program;
-}
-export declare type AfterFileRemoveEvent<TFile extends File = File> = 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 File = File> = PrepareFileEvent<TFile>;
-/**
- * Prepare the file for building
- */
-export interface PrepareFileEvent<TFile extends File = File> {
-    program: Program;
-    file: TFile;
     editor: Editor;
 }
-export declare type OnPrepareFileEvent<TFile extends File = File> = PrepareFileEvent<TFile>;
-export declare type AfterPrepareFileEvent<TFile extends File = File> = 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: File[];
-    result: Map<File, 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 {
-    /**
-     * 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 File = File> = SerializeFileEvent<TFile>;
-export interface SerializeFileEvent<TFile extends File = File> {
-    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 File = File> = SerializeFileEvent<TFile>;
-export interface BeforeWriteProgramEvent {
-    program: Program;
-    stagingDir: string;
-    files: Map<File, 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: File;
-    /**
-     * 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: File;
-}
-export declare type AfterFileDisposeEvent = BeforeFileDisposeEvent;
 export interface BeforeProgramDisposeEvent {
     program: Program;
 }
@@ -665,10 +469,16 @@ 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 FileResolver = (srcPath: string) => string | Buffer | undefined | Thenable<string | Buffer | undefined> | void;
+export declare type TranspileResult = Array<(string | SourceNode | TranspileResult)>;
+/**
+ * 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 FlattenedTranspileResult = Array<string | SourceNode>;
+export declare type FileResolver = (srcPath: string) => string | undefined | Thenable<string | undefined> | void;
 export interface ExpressionInfo {
     expressions: Expression[];
     varExpressions: Expression[];
@@ -679,64 +489,4 @@ export interface FileLink<T> {
     item: T;
     file: BrsFile;
 }
-export interface ExtraSymbolData {
-    definingNode?: AstNode;
-    description?: string;
-    completionPriority?: number;
-    flags?: SymbolTypeFlag;
-}
-export interface GetTypeOptions {
-    flags: SymbolTypeFlag;
-    typeChain?: TypeChainEntry[];
-    data?: ExtraSymbolData;
-    ignoreCall?: boolean;
-    onlyCacheResolvedTypes?: boolean;
-}
-export declare class TypeChainEntry {
-    name: string;
-    type: BscType;
-    flags: SymbolTypeFlag;
-    range: Range;
-    separatorToken: Token;
-    constructor(name: string, type: BscType, flags: SymbolTypeFlag, 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: File;
-    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;
-}
+export {};