brighterscript 0.66.0-alpha.9 → 0.67.1

package/dist/parser/Statement.d.ts

@@ -1,24 +1,16 @@
 import type { Token, Identifier } from '../lexer/Token';
 import { TokenKind } from '../lexer/TokenKind';
-import type { DottedGetExpression, FunctionExpression, FunctionParameterExpression, TypeExpression } from './Expression';
-import { VariableExpression } from './Expression';
+import type { NamespacedVariableNameExpression, FunctionExpression, FunctionParameterExpression } from './Expression';
 import type { Range } from 'vscode-languageserver';
 import type { BrsTranspileState } from './BrsTranspileState';
 import { ParseMode } from './Parser';
 import type { WalkVisitor, WalkOptions } from '../astUtils/visitors';
-import { type GetTypeOptions, type TranspileResult, type TypedefProvider } from '../interfaces';
-import type { SourceNode } from 'source-map';
+import type { TranspileResult, TypedefProvider } from '../interfaces';
+import type { BscType } from '../types/BscType';
 import type { TranspileState } from './TranspileState';
 import { SymbolTable } from '../SymbolTable';
 import type { Expression } from './AstNode';
-import { AstNodeKind } from './AstNode';
 import { Statement } from './AstNode';
-import { ClassType } from '../types/ClassType';
-import { EnumMemberType, EnumType } from '../types/EnumType';
-import { NamespaceType } from '../types/NamespaceType';
-import { InterfaceType } from '../types/InterfaceType';
-import type { BscType } from '../types/BscType';
-import { TypedFunctionType } from '../types/TypedFunctionType';
 export declare class EmptyStatement extends Statement {
     /**
      * Create a negative range to indicate this is an interpolated location
@@ -29,7 +21,6 @@ export declare class EmptyStatement extends Statement {
      * Create a negative range to indicate this is an interpolated location
      */
     range?: Range);
-    readonly kind = AstNodeKind.EmptyStatement;
     transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
@@ -39,51 +30,48 @@ export declare class EmptyStatement extends Statement {
 export declare class Body extends Statement implements TypedefProvider {
     statements: Statement[];
     constructor(statements?: Statement[]);
-    readonly kind = AstNodeKind.Body;
     symbolTable: SymbolTable;
     get range(): Range;
     transpile(state: BrsTranspileState): TranspileResult;
-    getTypedef(state: BrsTranspileState): any[];
+    getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class AssignmentStatement extends Statement {
-    equals: Token;
-    name: Identifier;
-    value: Expression;
-    asToken?: Token;
-    typeExpression?: TypeExpression;
-    constructor(equals: Token, name: Identifier, value: Expression, asToken?: Token, typeExpression?: TypeExpression);
-    readonly kind = AstNodeKind.AssignmentStatement;
-    readonly range: Range;
+    readonly equals: Token;
+    readonly name: Identifier;
+    readonly value: Expression;
+    constructor(equals: Token, name: Identifier, value: Expression);
+    readonly range: Range | undefined;
+    /**
+     * Get the name of the wrapping namespace (if it exists)
+     * @deprecated use `.findAncestor(isFunctionExpression)` instead.
+     */
+    get containingFunction(): FunctionExpression;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): BscType;
 }
 export declare class Block extends Statement {
     readonly statements: Statement[];
-    readonly startingRange: Range;
-    constructor(statements: Statement[], startingRange: Range);
-    readonly kind = AstNodeKind.Block;
-    readonly range: Range;
+    readonly startingRange?: Range;
+    constructor(statements: Statement[], startingRange?: Range);
+    readonly range: Range | undefined;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class ExpressionStatement extends Statement {
     readonly expression: Expression;
     constructor(expression: Expression);
-    readonly kind = AstNodeKind.ExpressionStatement;
-    readonly range: Range;
+    readonly range: Range | undefined;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class CommentStatement extends Statement implements Expression, TypedefProvider {
     comments: Token[];
     constructor(comments: Token[]);
-    readonly kind = AstNodeKind.CommentStatement;
-    range: Range;
+    range: Range | undefined;
     get text(): string;
-    transpile(state: BrsTranspileState): any[];
-    getTypedef(state: TranspileState): any[];
+    transpile(state: BrsTranspileState): TranspileResult;
+    getTypedef(state: TranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class ExitForStatement extends Statement {
@@ -93,9 +81,8 @@ export declare class ExitForStatement extends Statement {
     constructor(tokens: {
         exitFor: Token;
     });
-    readonly kind = AstNodeKind.ExitForStatement;
     readonly range: Range;
-    transpile(state: BrsTranspileState): SourceNode[];
+    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class ExitWhileStatement extends Statement {
@@ -105,26 +92,27 @@ export declare class ExitWhileStatement extends Statement {
     constructor(tokens: {
         exitWhile: Token;
     });
-    readonly kind = AstNodeKind.ExitWhileStatement;
     readonly range: Range;
-    transpile(state: BrsTranspileState): SourceNode[];
+    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class FunctionStatement extends Statement implements TypedefProvider {
     name: Identifier;
     func: FunctionExpression;
     constructor(name: Identifier, func: FunctionExpression);
-    readonly kind: AstNodeKind;
-    readonly range: Range;
+    readonly range: Range | undefined;
     /**
      * Get the name of this expression based on the parse mode
      */
     getName(parseMode: ParseMode): string;
-    getLeadingTrivia(): Token[];
-    transpile(state: BrsTranspileState): any[];
-    getTypedef(state: BrsTranspileState): any[];
+    /**
+     * Get the name of the wrapping namespace (if it exists)
+     * @deprecated use `.findAncestor(isNamespaceStatement)` instead.
+     */
+    get namespaceName(): NamespacedVariableNameExpression;
+    transpile(state: BrsTranspileState): TranspileResult;
+    getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): TypedFunctionType;
 }
 export declare class IfStatement extends Statement {
     readonly tokens: {
@@ -143,18 +131,16 @@ export declare class IfStatement extends Statement {
         else?: Token;
         endIf?: Token;
     }, condition: Expression, thenBranch: Block, elseBranch?: IfStatement | Block, isInline?: boolean);
-    readonly kind = AstNodeKind.IfStatement;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class IncrementStatement extends Statement {
     readonly value: Expression;
     readonly operator: Token;
     constructor(value: Expression, operator: Token);
-    readonly kind = AstNodeKind.IncrementStatement;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | SourceNode)[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode | TranspileResult)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 /** Used to indent the current `print` position to the next 16-character-width output zone. */
@@ -182,9 +168,8 @@ export declare class PrintStatement extends Statement {
     constructor(tokens: {
         print: Token;
     }, expressions: Array<Expression | PrintSeparatorTab | PrintSeparatorSpace>);
-    readonly kind = AstNodeKind.PrintStatement;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | SourceNode)[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class DimStatement extends Statement {
@@ -194,9 +179,8 @@ export declare class DimStatement extends Statement {
     dimensions?: Expression[];
     closingSquare?: Token;
     constructor(dimToken: Token, identifier?: Identifier, openingSquare?: Token, dimensions?: Expression[], closingSquare?: Token);
-    readonly kind = AstNodeKind.DimStatement;
-    range: Range;
-    transpile(state: BrsTranspileState): (string | SourceNode)[];
+    range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class GotoStatement extends Statement {
@@ -208,9 +192,8 @@ export declare class GotoStatement extends Statement {
         goto: Token;
         label: Token;
     });
-    readonly kind = AstNodeKind.GotoStatement;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): (string | SourceNode)[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class LabelStatement extends Statement {
@@ -222,10 +205,8 @@ export declare class LabelStatement extends Statement {
         identifier: Token;
         colon: Token;
     });
-    readonly kind = AstNodeKind.LabelStatement;
-    readonly range: Range;
-    getLeadingTrivia(): Token[];
-    transpile(state: BrsTranspileState): SourceNode[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class ReturnStatement extends Statement {
@@ -236,9 +217,8 @@ export declare class ReturnStatement extends Statement {
     constructor(tokens: {
         return: Token;
     }, value?: Expression);
-    readonly kind = AstNodeKind.ReturnStatement;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class EndStatement extends Statement {
@@ -248,9 +228,8 @@ export declare class EndStatement extends Statement {
     constructor(tokens: {
         end: Token;
     });
-    readonly kind = AstNodeKind.EndStatement;
     readonly range: Range;
-    transpile(state: BrsTranspileState): SourceNode[];
+    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class StopStatement extends Statement {
@@ -260,9 +239,8 @@ export declare class StopStatement extends Statement {
     constructor(tokens: {
         stop: Token;
     });
-    readonly kind = AstNodeKind.StopStatement;
     readonly range: Range;
-    transpile(state: BrsTranspileState): SourceNode[];
+    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class ForStatement extends Statement {
@@ -275,9 +253,8 @@ export declare class ForStatement extends Statement {
     stepToken?: Token;
     increment?: Expression;
     constructor(forToken: Token, counterDeclaration: AssignmentStatement, toToken: Token, finalValue: Expression, body: Block, endForToken: Token, stepToken?: Token, increment?: Expression);
-    readonly kind = AstNodeKind.ForStatement;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class ForEachStatement extends Statement {
@@ -294,9 +271,8 @@ export declare class ForEachStatement extends Statement {
         in: Token;
         endFor: Token;
     }, item: Token, target: Expression, body: Block);
-    readonly kind = AstNodeKind.ForEachStatement;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class WhileStatement extends Statement {
@@ -310,9 +286,8 @@ export declare class WhileStatement extends Statement {
         while: Token;
         endWhile: Token;
     }, condition: Expression, body: Block);
-    readonly kind = AstNodeKind.WhileStatement;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class DottedSetStatement extends Statement {
@@ -321,8 +296,7 @@ export declare class DottedSetStatement extends Statement {
     readonly value: Expression;
     readonly dot?: Token;
     constructor(obj: Expression, name: Identifier, value: Expression, dot?: Token);
-    readonly kind = AstNodeKind.DottedSetStatement;
-    readonly range: Range;
+    readonly range: Range | undefined;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
@@ -332,10 +306,10 @@ export declare class IndexedSetStatement extends Statement {
     readonly value: Expression;
     readonly openingSquare: Token;
     readonly closingSquare: Token;
-    constructor(obj: Expression, index: Expression, value: Expression, openingSquare: Token, closingSquare: Token);
-    readonly kind = AstNodeKind.IndexedSetStatement;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): TranspileResult;
+    readonly additionalIndexes?: Expression[];
+    constructor(obj: Expression, index: Expression, value: Expression, openingSquare: Token, closingSquare: Token, additionalIndexes?: Expression[]);
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): any[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class LibraryStatement extends Statement implements TypedefProvider {
@@ -347,19 +321,17 @@ export declare class LibraryStatement extends Statement implements TypedefProvid
         library: Token;
         filePath: Token | undefined;
     });
-    readonly kind = AstNodeKind.LibraryStatement;
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
-    getTypedef(state: BrsTranspileState): any[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
+    getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class NamespaceStatement extends Statement implements TypedefProvider {
     keyword: Token;
-    nameExpression: VariableExpression | DottedGetExpression;
+    nameExpression: NamespacedVariableNameExpression;
     body: Body;
     endKeyword: Token;
-    constructor(keyword: Token, nameExpression: VariableExpression | DottedGetExpression, body: Body, endKeyword: Token);
-    readonly kind = AstNodeKind.NamespaceStatement;
+    constructor(keyword: Token, nameExpression: NamespacedVariableNameExpression, body: Body, endKeyword: Token);
     /**
      * The string name for this namespace
      */
@@ -368,21 +340,17 @@ export declare class NamespaceStatement extends Statement implements TypedefProv
     private _range;
     cacheRange(): Range;
     getName(parseMode: ParseMode): string;
-    getLeadingTrivia(): Token[];
-    getNameParts(): Identifier[];
     transpile(state: BrsTranspileState): TranspileResult;
-    getTypedef(state: BrsTranspileState): string[];
+    getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): NamespaceType;
 }
 export declare class ImportStatement extends Statement implements TypedefProvider {
     readonly importToken: Token;
-    readonly filePathToken: Token;
-    constructor(importToken: Token, filePathToken: Token);
-    readonly kind = AstNodeKind.ImportStatement;
-    range: Range;
-    filePath: string;
-    transpile(state: BrsTranspileState): (string | SourceNode)[];
+    readonly filePathToken: Token | undefined;
+    constructor(importToken: Token, filePathToken: Token | undefined);
+    filePath: string | undefined;
+    range: Range | undefined;
+    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
     /**
      * Get the typedef for this statement
      */
@@ -390,21 +358,23 @@ export declare class ImportStatement extends Statement implements TypedefProvide
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class InterfaceStatement extends Statement implements TypedefProvider {
-    parentInterfaceName: TypeExpression;
+    parentInterfaceName: NamespacedVariableNameExpression;
     body: Statement[];
-    constructor(interfaceToken: Token, name: Identifier, extendsToken: Token, parentInterfaceName: TypeExpression, body: Statement[], endInterfaceToken: Token);
-    readonly kind = AstNodeKind.InterfaceStatement;
+    constructor(interfaceToken: Token, name: Identifier, extendsToken: Token, parentInterfaceName: NamespacedVariableNameExpression, body: Statement[], endInterfaceToken: Token);
     tokens: {
         interface: Token;
         name: Identifier;
         extends: Token;
         endInterface: Token;
     };
-    range: Range;
-    get fields(): InterfaceFieldStatement[];
-    get methods(): InterfaceMethodStatement[];
-    hasParentInterface(): boolean;
-    getLeadingTrivia(): Token[];
+    range: Range | undefined;
+    /**
+     * Get the name of the wrapping namespace (if it exists)
+     * @deprecated use `.findAncestor(isNamespaceStatement)` instead.
+     */
+    get namespaceName(): NamespacedVariableNameExpression;
+    get fields(): Statement[];
+    get methods(): Statement[];
     /**
      * The name of the interface WITH its leading namespace (if applicable)
      */
@@ -420,50 +390,41 @@ export declare class InterfaceStatement extends Statement implements TypedefProv
     transpile(state: BrsTranspileState): TranspileResult;
     getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): InterfaceType;
 }
 export declare class InterfaceFieldStatement extends Statement implements TypedefProvider {
-    typeExpression?: TypeExpression;
+    type: BscType;
     transpile(state: BrsTranspileState): TranspileResult;
-    constructor(nameToken: Identifier, asToken: Token, typeExpression?: TypeExpression, optionalToken?: Token);
-    readonly kind = AstNodeKind.InterfaceFieldStatement;
-    range: Range;
+    constructor(nameToken: Identifier, asToken: Token, typeToken: Token, type: BscType, optionalToken?: Token);
+    range: Range | undefined;
     tokens: {
+        optional?: Token;
         name: Identifier;
         as: Token;
-        optional?: Token;
+        type: Token;
     };
-    getLeadingTrivia(): Token[];
     get name(): string;
     get isOptional(): boolean;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getTypedef(state: BrsTranspileState): (string | SourceNode)[];
-    getType(options: GetTypeOptions): BscType;
+    getTypedef(state: BrsTranspileState): TranspileResult;
 }
 export declare class InterfaceMethodStatement extends Statement implements TypedefProvider {
     params: FunctionParameterExpression[];
-    returnTypeExpression?: TypeExpression;
+    returnType?: BscType;
     transpile(state: BrsTranspileState): TranspileResult;
-    constructor(functionTypeToken: Token, nameToken: Identifier, leftParen: Token, params: FunctionParameterExpression[], rightParen: Token, asToken?: Token, returnTypeExpression?: TypeExpression, optionalToken?: Token);
-    readonly kind = AstNodeKind.InterfaceMethodStatement;
+    constructor(functionTypeToken: Token, nameToken: Identifier, leftParen: Token, params: FunctionParameterExpression[], rightParen: Token, asToken?: Token, returnTypeToken?: Token, returnType?: BscType, optionalToken?: Token);
     get range(): Range;
-    /**
-     * Get the name of this method.
-     */
-    getName(parseMode: ParseMode): string;
     tokens: {
         optional?: Token;
         functionType: Token;
         name: Identifier;
         leftParen: Token;
         rightParen: Token;
-        as: Token;
+        as: Token | undefined;
+        returnType: Token | undefined;
     };
     get isOptional(): boolean;
-    getLeadingTrivia(): Token[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
     getTypedef(state: BrsTranspileState): TranspileResult;
-    getType(options: GetTypeOptions): TypedFunctionType;
 }
 export declare class ClassStatement extends Statement implements TypedefProvider {
     readonly classKeyword: Token;
@@ -474,20 +435,23 @@ export declare class ClassStatement extends Statement implements TypedefProvider
     body: Statement[];
     readonly end: Token;
     readonly extendsKeyword?: Token;
-    readonly parentClassName?: TypeExpression;
+    readonly parentClassName?: NamespacedVariableNameExpression;
     constructor(classKeyword: Token, 
     /**
      * The name of the class (without namespace prefix)
      */
-    name: Identifier, body: Statement[], end: Token, extendsKeyword?: Token, parentClassName?: TypeExpression);
-    readonly kind = AstNodeKind.ClassStatement;
+    name: Identifier, body: Statement[], end: Token, extendsKeyword?: Token, parentClassName?: NamespacedVariableNameExpression);
+    /**
+     * Get the name of the wrapping namespace (if it exists)
+     * @deprecated use `.findAncestor(isNamespaceStatement)` instead.
+     */
+    get namespaceName(): NamespacedVariableNameExpression;
     getName(parseMode: ParseMode): string;
-    getLeadingTrivia(): Token[];
     memberMap: Record<string, MemberStatement>;
     methods: MethodStatement[];
     fields: FieldStatement[];
-    readonly range: Range;
-    transpile(state: BrsTranspileState): any[];
+    readonly range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     getTypedef(state: BrsTranspileState): TranspileResult;
     /**
      * Find the parent index for this class's parent.
@@ -523,22 +487,19 @@ export declare class ClassStatement extends Statement implements TypedefProvider
      */
     private getTranspiledClassFunction;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): ClassType;
 }
 export declare class MethodStatement extends FunctionStatement {
     override: Token;
     constructor(modifiers: Token | Token[], name: Identifier, func: FunctionExpression, override: Token);
-    readonly kind: AstNodeKind;
     modifiers: Token[];
     get accessModifier(): Token;
-    readonly range: Range;
+    readonly range: Range | undefined;
     /**
      * Get the name of this method.
      */
     getName(parseMode: ParseMode): string;
-    getLeadingTrivia(): Token[];
-    transpile(state: BrsTranspileState): any[];
-    getTypedef(state: BrsTranspileState): (string | SourceNode)[];
+    transpile(state: BrsTranspileState): TranspileResult;
+    getTypedef(state: BrsTranspileState): TranspileResult;
     /**
      * All child classes must call the parent constructor. The type checker will warn users when they don't call it in their own class,
      * but we still need to call it even if they have omitted it. This injects the super call if it's missing
@@ -550,29 +511,41 @@ export declare class MethodStatement extends FunctionStatement {
     private injectFieldInitializersForConstructor;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
+/**
+ * @deprecated use `MethodStatement`
+ */
+export declare class ClassMethodStatement extends MethodStatement {
+}
 export declare class FieldStatement extends Statement implements TypedefProvider {
     readonly accessModifier?: Token;
     readonly name?: Identifier;
     readonly as?: Token;
-    readonly typeExpression?: TypeExpression;
+    readonly type?: Token;
     readonly equal?: Token;
     readonly initialValue?: Expression;
     readonly optional?: Token;
-    constructor(accessModifier?: Token, name?: Identifier, as?: Token, typeExpression?: TypeExpression, equal?: Token, initialValue?: Expression, optional?: Token);
-    readonly kind = AstNodeKind.FieldStatement;
+    constructor(accessModifier?: Token, name?: Identifier, as?: Token, type?: Token, equal?: Token, initialValue?: Expression, optional?: Token);
     /**
      * Derive a ValueKind from the type token, or the initial value.
      * Defaults to `DynamicType`
      */
-    getType(options: GetTypeOptions): BscType;
-    readonly range: Range;
-    getLeadingTrivia(): Token[];
+    getType(): BscType;
+    readonly range: Range | undefined;
     get isOptional(): boolean;
     transpile(state: BrsTranspileState): TranspileResult;
-    getTypedef(state: BrsTranspileState): any[];
+    getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
+/**
+ * @deprecated use `FieldStatement`
+ */
+export declare class ClassFieldStatement extends FieldStatement {
+}
 export declare type MemberStatement = FieldStatement | MethodStatement;
+/**
+ * @deprecated use `MemeberStatement`
+ */
+export declare type ClassMemberStatement = MemberStatement;
 export declare class TryCatchStatement extends Statement {
     tokens: {
         try: Token;
@@ -584,8 +557,7 @@ export declare class TryCatchStatement extends Statement {
         try: Token;
         endTry?: Token;
     }, tryBranch?: Block, catchStatement?: CatchStatement);
-    readonly kind = AstNodeKind.TryCatchStatement;
-    readonly range: Range;
+    readonly range: Range | undefined;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
@@ -598,8 +570,7 @@ export declare class CatchStatement extends Statement {
     constructor(tokens: {
         catch: Token;
     }, exceptionVariable?: Identifier, catchBranch?: Block);
-    readonly kind = AstNodeKind.CatchStatement;
-    range: Range;
+    range: Range | undefined;
     transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
@@ -607,9 +578,8 @@ export declare class ThrowStatement extends Statement {
     throwToken: Token;
     expression?: Expression;
     constructor(throwToken: Token, expression?: Expression);
-    readonly kind = AstNodeKind.ThrowStatement;
-    range: Range;
-    transpile(state: BrsTranspileState): (string | SourceNode)[];
+    range: Range | undefined;
+    transpile(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }
 export declare class EnumStatement extends Statement implements TypedefProvider {
@@ -624,11 +594,13 @@ export declare class EnumStatement extends Statement implements TypedefProvider
         name: Identifier;
         endEnum: Token;
     }, body: Array<EnumMemberStatement | CommentStatement>);
-    readonly kind = AstNodeKind.EnumStatement;
-    symbolTable: SymbolTable;
-    get range(): Range;
+    get range(): Range | undefined;
+    /**
+     * Get the name of the wrapping namespace (if it exists)
+     * @deprecated use `.findAncestor(isNamespaceStatement)` instead.
+     */
+    get namespaceName(): NamespacedVariableNameExpression;
     getMembers(): EnumMemberStatement[];
-    getLeadingTrivia(): Token[];
     /**
      * Get a map of member names and their values.
      * All values are stored as their AST LiteralExpression representation (i.e. string enum values include the wrapping quotes)
@@ -646,7 +618,6 @@ export declare class EnumStatement extends Statement implements TypedefProvider
     transpile(state: BrsTranspileState): any[];
     getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): EnumType;
 }
 export declare class EnumMemberStatement extends Statement implements TypedefProvider {
     tokens: {
@@ -658,17 +629,18 @@ export declare class EnumMemberStatement extends Statement implements TypedefPro
         name: Identifier;
         equal?: Token;
     }, value?: Expression);
-    readonly kind = AstNodeKind.EnumMemberStatement;
-    get range(): Range;
     /**
      * The name of the member
      */
     get name(): string;
-    getLeadingTrivia(): Token[];
+    get range(): Range;
+    /**
+     * Get the value of this enum. Requires that `.parent` is set
+     */
+    getValue(): string;
     transpile(state: BrsTranspileState): TranspileResult;
-    getTypedef(state: BrsTranspileState): (string | SourceNode)[];
+    getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): EnumMemberType;
 }
 export declare class ConstStatement extends Statement implements TypedefProvider {
     tokens: {
@@ -682,18 +654,15 @@ export declare class ConstStatement extends Statement implements TypedefProvider
         name: Identifier;
         equals: Token;
     }, value: Expression);
-    readonly kind = AstNodeKind.ConstStatement;
-    range: Range;
+    range: Range | undefined;
     get name(): string;
-    getLeadingTrivia(): Token[];
     /**
      * The name of the statement WITH its leading namespace (if applicable)
      */
     get fullName(): string;
     transpile(state: BrsTranspileState): TranspileResult;
-    getTypedef(state: BrsTranspileState): (string | SourceNode)[];
+    getTypedef(state: BrsTranspileState): TranspileResult;
     walk(visitor: WalkVisitor, options: WalkOptions): void;
-    getType(options: GetTypeOptions): BscType;
 }
 export declare class ContinueStatement extends Statement {
     tokens: {
@@ -704,8 +673,7 @@ export declare class ContinueStatement extends Statement {
         continue: Token;
         loopType: Token;
     });
-    readonly kind = AstNodeKind.ContinueStatement;
-    range: Range;
-    transpile(state: BrsTranspileState): (string | SourceNode)[];
+    range: Range | undefined;
+    transpile(state: BrsTranspileState): (string | import("source-map").SourceNode)[];
     walk(visitor: WalkVisitor, options: WalkOptions): void;
 }