brighterscript 0.66.0-alpha.0 → 0.66.0-alpha.10

package/dist/interfaces.d.ts

@@ -1,36 +1,50 @@
+/// <reference types="node" />
 import type { Range, Diagnostic, CodeAction, SemanticTokenTypes, SemanticTokenModifiers, Position, CompletionItem } from 'vscode-languageserver';
 import type { Scope } from './Scope';
 import type { BrsFile } from './files/BrsFile';
 import type { XmlFile } from './files/XmlFile';
 import type { FunctionScope } from './FunctionScope';
-import type { FunctionType } from './types/FunctionType';
+import type { TypedFunctionType } from './types/TypedFunctionType';
 import type { ParseMode } from './parser/Parser';
-import type { Program, SourceObj, TranspileObj } from './Program';
+import type { Program } from './Program';
 import type { ProgramBuilder } from './ProgramBuilder';
-import type { FunctionStatement } from './parser/Statement';
-import type { Expression } from './parser/AstNode';
+import type { ClassStatement, ConstStatement, EnumStatement, FunctionStatement, NamespaceStatement } from './parser/Statement';
+import type { AstNode, Expression, Statement } from './parser/AstNode';
 import type { TranspileState } from './parser/TranspileState';
-import type { SourceMapGenerator, SourceNode } from 'source-map';
+import type { SourceNode } from 'source-map';
 import type { BscType } from './types/BscType';
-import type { AstEditor } from './astUtils/AstEditor';
-import type { Token } from './lexer/Token';
-import type { SymbolTypeFlag } from './SymbolTable';
+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';
 export interface BsDiagnostic extends Diagnostic {
-    file: BscFile;
+    file: File;
     /**
      * 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 type BscFile = BrsFile | XmlFile;
+export declare enum DiagnosticOrigin {
+    Program = "Program",
+    Scope = "Scope",
+    File = "File",
+    ASTSegment = "AstSegment"
+}
+export interface BsDiagnosticWithOrigin extends BsDiagnostic {
+    origin: DiagnosticOrigin;
+    astSegment?: AstNode;
+}
 export interface Callable {
-    file: BscFile;
+    file: File;
     name: string;
     /**
      * 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.
      */
@@ -64,6 +78,7 @@ 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;
@@ -101,12 +116,12 @@ export interface FileObj {
  */
 export interface FileReference {
     /**
-     * The pkgPath to the referenced file.
+     * The destPath for the referenced file.
      */
-    pkgPath: string;
+    destPath: string;
     text: string;
     /**
-     * The file that is doing the import. Note this is NOT the file the pkgPath points to.
+     * The file that is doing the import. Note this is NOT the file the destPath points to.
      */
     sourceFile: XmlFile | BrsFile;
     /**
@@ -117,14 +132,6 @@ 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;
@@ -158,7 +165,7 @@ export interface CallableContainer {
 }
 export declare type CallableContainerMap = Map<string, CallableContainer[]>;
 export interface CommentFlag {
-    file: BscFile;
+    file: File;
     /**
      * The location of the ignore comment.
      */
@@ -169,21 +176,45 @@ 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;
-    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;
-    onGetCodeActions?: PluginHandler<OnGetCodeActionsEvent>;
+    /**
+     * 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
+     */
+    beforeProgramDispose?: PluginHandler<BeforeProgramDisposeEvent>;
     /**
      * Emitted before the program starts collecting completions
      */
@@ -208,15 +239,49 @@ export interface CompilerPlugin {
      * Called after the `provideHover` hook. Use this if you want to intercept or sanitize the hover data (even from other plugins) before it gets sent to the client.
      */
     afterProvideHover?: PluginHandler<AfterProvideHoverEvent>;
-    onGetSemanticTokens?: PluginHandler<OnGetSemanticTokensEvent>;
-    afterScopeCreate?: (scope: Scope) => void;
-    beforeScopeDispose?: (scope: Scope) => void;
-    afterScopeDispose?: (scope: Scope) => void;
-    beforeScopeValidate?: ValidateHandler;
+    /**
+     * 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?: ValidateHandler;
-    beforeFileParse?: (source: SourceObj) => void;
-    afterFileParse?: (file: BscFile) => void;
+    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
      */
@@ -228,33 +293,112 @@ export interface CompilerPlugin {
     /**
      * Called after each file is validated
      */
-    afterFileValidate?: (file: BscFile) => void;
-    beforeFileTranspile?: PluginHandler<BeforeFileTranspileEvent>;
-    afterFileTranspile?: PluginHandler<AfterFileTranspileEvent>;
-    beforeFileDispose?: (file: BscFile) => void;
-    afterFileDispose?: (file: BscFile) => void;
+    afterFileValidate?: PluginHandler<AfterFileValidateEvent>;
+    /**
+     * Called right before the program builds (i.e. generates the code and puts it in the stagingDir
+     */
+    beforeBuildProgram?: PluginHandler<BeforeBuildProgramEvent>;
+    /**
+     * Called right after the program builds (i.e. generates the code and puts it in the stagingDir
+     */
+    afterBuildProgram?: PluginHandler<AfterBuildProgramEvent>;
+    /**
+     * Before preparing the file for building
+     */
+    beforePrepareFile?: PluginHandler<BeforePrepareFileEvent>;
+    /**
+     * Prepare the file for building
+     */
+    prepareFile?: PluginHandler<PrepareFileEvent>;
+    /**
+     * After preparing the file for building
+     */
+    afterPrepareFile?: PluginHandler<AfterPrepareFileEvent>;
+    /**
+     * Before the program turns all file objects into their final buffers
+     */
+    beforeSerializeProgram?: PluginHandler<BeforeSerializeProgramEvent>;
+    /**
+     * Emitted right at the start of the program turning all file objects into their final buffers
+     */
+    onSerializeProgram?: PluginHandler<OnSerializeProgramEvent>;
+    /**
+     * After the program turns all file objects into their final buffers
+     */
+    afterSerializeProgram?: PluginHandler<AfterSerializeProgramEvent>;
+    /**
+     * Before turning the file into its final contents
+     */
+    beforeSerializeFile?: PluginHandler<BeforeSerializeFileEvent>;
+    /**
+     * Turn the file into its final contents (i.e. transpile a bs file, compress a jpeg, etc)
+     */
+    serializeFile?: PluginHandler<SerializeFileEvent>;
+    /**
+     * After turning the file into its final contents
+     */
+    afterSerializeFile?: PluginHandler<AfterSerializeFileEvent>;
+    /**
+     * Called before any files are written
+     */
+    beforeWriteProgram?: PluginHandler<BeforeWriteProgramEvent>;
+    /**
+     * Called after all files are written
+     */
+    afterWriteProgram?: PluginHandler<AfterWriteProgramEvent>;
+    /**
+     * Before a file is written to disk. These are raw files that contain the final output. One `File` may produce several of these
+     */
+    beforeWriteFile?: PluginHandler<BeforeWriteFileEvent>;
+    /**
+     * Called when a file should be persisted (usually writing to storage). These are raw files that contain the final output. One `File` may produce several of these.
+     * When a plugin has handled a file, it should be pushed to the `handledFiles` set so future plugins don't write the file multiple times
+     */
+    writeFile?: PluginHandler<WriteFileEvent>;
+    /**
+     * Before a file is written to disk. These are raw files that contain the final output. One `File` may produce several of these
+     */
+    afterWriteFile?: PluginHandler<AfterWriteFileEvent>;
 }
 export declare type PluginHandler<T, R = void> = (event: T) => R;
-export interface OnGetCodeActionsEvent {
+export interface OnGetCodeActionsEvent<TFile extends File = File> {
     program: Program;
-    file: BscFile;
+    file: TFile;
     range: Range;
     scopes: Scope[];
     diagnostics: BsDiagnostic[];
     codeActions: CodeAction[];
 }
-export interface ProvideCompletionsEvent<TFile extends BscFile = BscFile> {
+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> {
     program: Program;
     file: TFile;
     scopes: Scope[];
     position: Position;
     completions: CompletionItem[];
 }
-export declare type BeforeProvideCompletionsEvent<TFile extends BscFile = BscFile> = ProvideCompletionsEvent<TFile>;
-export declare type AfterProvideCompletionsEvent<TFile extends BscFile = BscFile> = ProvideCompletionsEvent<TFile>;
+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 interface ProvideHoverEvent {
     program: Program;
-    file: BscFile;
+    file: File;
     position: Position;
     scopes: Scope[];
     hovers: Hover[];
@@ -276,7 +420,42 @@ export interface Hover {
 }
 export declare type BeforeProvideHoverEvent = ProvideHoverEvent;
 export declare type AfterProvideHoverEvent = ProvideHoverEvent;
-export interface OnGetSemanticTokensEvent<T extends BscFile = BscFile> {
+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 {
+    program: Program;
+    scope: Scope;
+}
+export declare type AfterScopeValidateEvent = BeforeScopeValidateEvent;
+export interface BeforeFileParseEvent {
+    program: Program;
+    srcPath: string;
+    source: string;
+}
+export interface OnFileParseEvent {
+    program: Program;
+    srcPath: string;
+    source: string;
+}
+export interface AfterFileParseEvent {
+    program: Program;
+    file: File;
+}
+export interface OnGetSemanticTokensEvent<T extends File = File> {
     /**
      * The program this file is from
      */
@@ -294,31 +473,32 @@ export interface OnGetSemanticTokensEvent<T extends BscFile = BscFile> {
      */
     semanticTokens: SemanticToken[];
 }
-export interface BeforeFileValidateEvent<T extends BscFile = BscFile> {
+export declare type BeforeFileValidateEvent = OnFileValidateEvent;
+export interface OnFileValidateEvent<T extends File = File> {
     program: Program;
     file: T;
 }
-export interface OnFileValidateEvent<T extends BscFile = BscFile> {
+export declare type AfterFileValidateEvent = OnFileValidateEvent;
+export interface OnFileValidateEvent<T extends File = File> {
     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 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> {
+export interface AfterFileTranspileEvent<TFile extends File = File> {
     /**
      * The program this event was triggered for
      */
@@ -332,18 +512,150 @@ export interface AfterFileTranspileEvent<TFile extends BscFile = BscFile> {
     /**
      * The sourceMaps for the generated code (if emitting source maps is enabled)
      */
-    map?: SourceMapGenerator;
+    map?: string;
     /**
      * The generated type definition file contents (if emitting type definitions are enabled)
      */
     typedef?: string;
+}
+export declare type BeforeProvideFileEvent<TFile extends 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;
     /**
-     * An editor that can be used to transform properties or arrays. Once the `afterFileTranspile` event has fired, these changes will be reverted,
-     * restoring the objects to their prior state. This is useful for changing code right before a file gets transpiled, but when you don't want
-     * the changes to persist in the in-memory file.
+     * The srcPath for the file. (i.e. `/user/bob/projects/VideoApp/source/main.bs`)
      */
+    srcPath: string;
+    /**
+     * The destPath for the file. (i.e. for `/user/bob/projects/VideoApp/source/main.bs`, destPath would be `source/main.bs`)
+     */
+    destPath: string;
+    /**
+     * A lazy-loading container for this file's data. Call `.get()` to lazy load the data, and `.set()` to override file contents
+     */
+    data: LazyFileData;
+    /**
+     * An array of files that should be added to the program as a result of this event
+     */
+    files: TFile[];
+    /**
+     * The program for this event
+     */
+    program: Program;
+    /**
+     * A factory used to create new instances of the BrighterScript built-in file types. This mitigates the issue
+     * of a plugin's version of a File not being the same as the LanguageServer or CLI version of BrighterScript
+     * (due to npm installing multiple versions of brighterscript)
+     */
+    fileFactory: FileFactory;
+}
+export declare type AfterProvideFileEvent<TFile extends 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;
+}
 export interface SemanticToken {
     range: Range;
     tokenType: SemanticTokenTypes;
@@ -356,7 +668,7 @@ export interface TypedefProvider {
     getTypedef(state: TranspileState): Array<SourceNode | string>;
 }
 export declare type TranspileResult = Array<(string | SourceNode)>;
-export declare type FileResolver = (srcPath: string) => string | undefined | Thenable<string | undefined> | void;
+export declare type FileResolver = (srcPath: string) => string | Buffer | undefined | Thenable<string | Buffer | undefined> | void;
 export interface ExpressionInfo {
     expressions: Expression[];
     varExpressions: Expression[];
@@ -367,22 +679,65 @@ 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;
+    ignoreCacheForRetrieval?: boolean;
 }
 export declare class TypeChainEntry {
     name: string;
     type: BscType;
+    flags: SymbolTypeFlag;
     range: Range;
-    constructor(name: string, type: BscType, range: Range);
+    separatorToken: Token;
+    constructor(name: string, type: BscType, flags: SymbolTypeFlag, range: Range, separatorToken?: Token);
     get isResolved(): boolean;
 }
 export interface TypeChainProcessResult {
-    missingItemName: string;
-    missingItemParentTypeName: string;
-    fullNameOfMissingItem: string;
+    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 {};