@artel/artc 0.6.26039 → 0.8.26001

package/build/types/tree/m/Nodes.d.ts

@@ -1,17 +1,2072 @@
-import { PackageDialect, PackageLocale, Range } from '../../common/index.js';
+import { PackageLocale, Query, Range } from '../../common/index.js';
 import { ParserDiagnostic } from '../../parser/ParserDiagnostic.js';
-import { BaseNode, Token } from './BaseNode.js';
+import { BaseNode } from './BaseNode.js';
+import { KeywordFlags } from './KeywordFlags.js';
+import { KeywordKind } from './KeywordKind.js';
 import { NodeKind } from './NodeKind.js';
+import { NodesWithChild } from './NodesDebug.js';
+import { OperatorKind } from './OperatorKind.js';
+import { Token } from './Token.js';
+import { TokenKind } from './TokenKind.js';
+export type Comma = Token<TokenKind.Comma>;
+export type Plus = Token<TokenKind.Plus>;
+export type Semicolon = Token<TokenKind.Semicolon>;
+export type Identifier = Token<TokenKind.Identifier>;
+export type IdentifierParent = NodesWithChild<Identifier>;
+export type IdentifierListElement = Identifier | Comma;
+export type ObjectKeyword = Keyword<KeywordKind.Object>;
 export declare class SourceFile extends BaseNode {
     readonly kind = NodeKind.SourceFile;
+    readonly children: readonly [
+        PackageImportDirectiveList,
+        PackageMemberDeclarationList,
+        Token<TokenKind.EndOfFile>
+    ];
     readonly diagnostics: readonly ParserDiagnostic[];
     private readonly locale_;
-    private readonly dialect_;
-    readonly children: readonly (Node | undefined)[];
-    protected get thisAsNode(): Node;
     get locale(): PackageLocale;
-    get dialect(): PackageDialect;
-    get sourceFile(): SourceFile;
-    constructor(locale: PackageLocale, dialect: PackageDialect, diagnostics: readonly ParserDiagnostic[], rangeWithTrivia: Range | undefined);
+    get parent(): undefined;
+    get packageImportDirectiveList(): PackageImportDirectiveList;
+    get declarationList(): PackageMemberDeclarationList;
+    get endOfFileToken(): Token<TokenKind.EndOfFile>;
+    protected get thisAsNode(): Node;
+    constructor(packageImportDirectiveList: PackageImportDirectiveList, declarationList: PackageMemberDeclarationList, endOfFileToken: Token<TokenKind.EndOfFile>, locale: PackageLocale, diagnostics: readonly ParserDiagnostic[], rangeWithTrivia: Range | undefined);
+}
+export declare class Keyword<TKind extends KeywordKind = KeywordKind> extends BaseNode {
+    readonly kind = NodeKind.Keyword;
+    readonly children: readonly Identifier[];
+    readonly keywordKind: TKind;
+    readonly flags: KeywordFlags;
+    readonly operatorKind: OperatorKind | undefined;
+    get parent(): Node;
+    get tokens(): readonly Identifier[];
+    get isMissing(): boolean;
+    protected get thisAsNode(): Node;
+    constructor(tokens: readonly Identifier[], keywordKind: TKind, flags: KeywordFlags | undefined, operatorKind: OperatorKind | undefined, rangeWithTrivia: Range | undefined);
+}
+export type PackageMemberDeclarationListElement = PackageMemberDeclaration | Semicolon;
+export type PackageMemberDeclarationListParent = SourceFile | PackageMemberGroupDeclaration;
+export declare class PackageMemberDeclarationList extends BaseNode {
+    readonly kind = NodeKind.PackageMemberDeclarationList;
+    readonly children: readonly PackageMemberDeclarationListElement[];
+    get parent(): PackageMemberDeclarationListParent;
+    get elements(): readonly PackageMemberDeclarationListElement[];
+    get declarations(): Query<PackageMemberDeclaration>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly PackageMemberDeclarationListElement[], rangeWithTrivia: Range | undefined);
+    flatten(): Iterable<PackageSingleMemberDeclaration>;
+}
+export type PackageImportDirectiveListElement = PackageImportDirective | Semicolon;
+export declare class PackageImportDirectiveList extends BaseNode {
+    readonly kind = NodeKind.PackageImportDirectiveList;
+    readonly children: readonly PackageImportDirectiveListElement[];
+    get parent(): SourceFile;
+    get elements(): readonly PackageImportDirectiveListElement[];
+    get packageImportDirectives(): Query<PackageImportDirective>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly PackageImportDirectiveListElement[], rangeWithTrivia: Range | undefined);
+    flatten(): Iterable<PackageImport>;
+}
+export declare class PackageImportDirective extends BaseNode {
+    readonly kind = NodeKind.PackageImportDirective;
+    readonly children: readonly [
+        Keyword<KeywordKind.Import>,
+        Token<TokenKind.OpenBrace> | undefined,
+        PackageImportList,
+        Token<TokenKind.CloseBrace> | undefined,
+        Keyword<KeywordKind.End> | undefined
+    ];
+    get parent(): PackageImportDirectiveList;
+    get importKeyword(): Keyword<KeywordKind.Import>;
+    get openBraceToken(): Token<TokenKind.OpenBrace> | undefined;
+    get packageImportList(): PackageImportList;
+    get closeBraceToken(): Token<TokenKind.CloseBrace> | undefined;
+    get endKeyword(): Keyword<KeywordKind.End> | undefined;
+    protected get thisAsNode(): Node;
+    constructor(importKeyword: Keyword<KeywordKind.Import>, openBraceToken: Token<TokenKind.OpenBrace> | undefined, packageImportList: PackageImportList, closeBraceToken: Token<TokenKind.CloseBrace> | undefined, endKeyword: Keyword<KeywordKind.End> | undefined, rangeWithTrivia: Range | undefined);
+}
+export type PackageImportListElement = PackageImport | Semicolon;
+export declare class PackageImportList extends BaseNode {
+    readonly kind = NodeKind.PackageImportList;
+    readonly children: readonly PackageImportListElement[];
+    get parent(): PackageImportDirective;
+    get elements(): readonly PackageImportListElement[];
+    get packageImports(): Query<PackageImport>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly PackageImportListElement[], rangeWithTrivia: Range | undefined);
+}
+export declare class PackageImport extends BaseNode {
+    readonly kind = NodeKind.PackageImport;
+    readonly children: readonly [
+        Identifier | undefined,
+        Token<TokenKind.Equals> | undefined,
+        PackageName
+    ];
+    get parent(): PackageImportList;
+    get alias(): Identifier | undefined;
+    get equalsToken(): Token<TokenKind.Equals> | undefined;
+    get packageName(): PackageName;
+    protected get thisAsNode(): Node;
+    constructor(alias: Identifier | undefined, equalsToken: Token<TokenKind.Equals> | undefined, packageName: PackageName, rangeWithTrivia: Range | undefined);
+}
+export type PackageNamePart = Identifier | Token<TokenKind.Dot>;
+export declare class PackageName extends BaseNode {
+    readonly kind = NodeKind.PackageName;
+    readonly children: readonly PackageNamePart[];
+    get parent(): PackageImport;
+    get parts(): readonly PackageNamePart[];
+    get segments(): Query<Identifier>;
+    protected get thisAsNode(): Node;
+    constructor(parts: readonly PackageNamePart[], rangeWithTrivia: Range | undefined);
+}
+export type TypeSpecifier = NamedTypeSpecifier | LocalTypeSpecifier | UnionTypeSpecifier | ParenthesizedTypeSpecifier | NullableTypeSpecifier | MissingTypeSpecifier;
+export type NamedTypeSpecifierParent = BaseTypeList | NonNamedTypeSpecifierParent;
+export type NonNamedTypeSpecifierParent = PackageAliasTypeDeclaration | TypeParameterDeclaration | TypeArgumentList | TypeAnnotation | ParenthesizedTypeSpecifier | NullableTypeSpecifier | UnionTypeSpecifier;
+export declare class NamedTypeSpecifier extends BaseNode {
+    readonly kind = NodeKind.NamedTypeSpecifier;
+    readonly children: readonly [
+        QualifiedName,
+        TypeArgumentClause | undefined
+    ];
+    get parent(): NamedTypeSpecifierParent;
+    get qualifiedName(): QualifiedName;
+    get typeArgumentClause(): TypeArgumentClause | undefined;
+    protected get thisAsNode(): Node;
+    constructor(qualifiedName: QualifiedName, typeArgumentClause: TypeArgumentClause | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class UnionTypeSpecifier extends BaseNode {
+    readonly kind = NodeKind.UnionTypeSpecifier;
+    readonly children: readonly UnionTypeSpecifierTypeListElement[];
+    get parent(): NonNamedTypeSpecifierParent;
+    get typeListElements(): readonly UnionTypeSpecifierTypeListElement[];
+    get types(): Query<TypeSpecifier>;
+    protected get thisAsNode(): Node;
+    constructor(typeListElements: readonly UnionTypeSpecifierTypeListElement[], rangeWithTrivia: Range | undefined);
+}
+export type UnionTypeSpecifierTypeListElement = TypeSpecifier | Keyword<KeywordKind.Case>;
+export declare class ParenthesizedTypeSpecifier extends BaseNode {
+    readonly kind = NodeKind.ParenthesizedTypeSpecifier;
+    readonly children: readonly [
+        Token<TokenKind.OpenParenthesis>,
+        TypeSpecifier,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get parent(): NonNamedTypeSpecifierParent;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get typeSpecifier(): TypeSpecifier;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Node;
+    constructor(openParenthesisToken: Token<TokenKind.OpenParenthesis>, typeSpecifier: TypeSpecifier, closeParenthesisToken: Token<TokenKind.CloseParenthesis>, rangeWithTrivia: Range | undefined);
+}
+export declare class NullableTypeSpecifier extends BaseNode {
+    readonly kind = NodeKind.NullableTypeSpecifier;
+    readonly children: readonly [
+        TypeSpecifier,
+        Token<TokenKind.Question>
+    ];
+    get parent(): NonNamedTypeSpecifierParent;
+    get typeSpecifier(): TypeSpecifier;
+    get questionToken(): Token<TokenKind.Question>;
+    protected get thisAsNode(): Node;
+    constructor(typeSpecifier: TypeSpecifier, questionToken: Token<TokenKind.Question>, rangeWithTrivia: Range | undefined);
+}
+export declare class LocalTypeSpecifier extends BaseNode {
+    readonly kind = NodeKind.LocalTypeSpecifier;
+    readonly children: readonly [
+        LocalTypeDeclaration
+    ];
+    get parent(): NonNamedTypeSpecifierParent;
+    get typeDeclaration(): LocalTypeDeclaration;
+    protected get thisAsNode(): Node;
+    constructor(typeDeclaration: LocalTypeDeclaration, rangeWithTrivia: Range | undefined);
+}
+export declare class MissingTypeSpecifier extends BaseNode {
+    readonly kind = NodeKind.MissingTypeSpecifier;
+    get children(): readonly [];
+    get parent(): NonNamedTypeSpecifierParent;
+    protected get thisAsNode(): Node;
+    constructor(rangeWithTrivia: Range | undefined);
+}
+export type LocalTypeDeclaration = LocalStructuredTypeDeclaration | LocalFunctionTypeDeclaration;
+export declare class LocalFunctionTypeDeclaration extends BaseNode {
+    readonly kind = NodeKind.LocalFunctionTypeDeclaration;
+    readonly children: readonly [
+        Keyword<KeywordKind.Function>,
+        ParameterClause,
+        TypeAnnotation | undefined
+    ];
+    get parent(): LocalTypeSpecifier;
+    get functionKeyword(): Keyword<KeywordKind.Function>;
+    get parameterClause(): ParameterClause;
+    get returnTypeAnnotation(): TypeAnnotation | undefined;
+    protected get thisAsNode(): Node;
+    constructor(functionKeyword: Keyword<KeywordKind.Function>, parameterClause: ParameterClause, returnTypeAnnotation: TypeAnnotation | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class LocalStructuredTypeDeclaration extends BaseNode {
+    readonly kind = NodeKind.LocalStructuredTypeDeclaration;
+    readonly children: readonly [
+        Keyword<KeywordKind.Type>,
+        Identifier,
+        ExtendsClause | undefined,
+        TypeMemberDeclarationBlock
+    ];
+    get parent(): LocalStructuredTypeDeclarationParent;
+    get typeKeyword(): Keyword<KeywordKind.Type>;
+    get name(): Identifier;
+    get extendsClause(): ExtendsClause | undefined;
+    get memberBlock(): TypeMemberDeclarationBlock;
+    protected get thisAsNode(): Node;
+    constructor(typeKeyword: Keyword<KeywordKind.Type>, name: Identifier, extendsClause: ExtendsClause | undefined, memberBlock: TypeMemberDeclarationBlock, rangeWithTrivia: Range | undefined);
+}
+export type PackageSingleMemberDeclaration = PackageAliasTypeDeclaration | PackageFunctionDeclaration | PackageVariableDeclaration | PackageVariableGetterDeclaration | PackageVariableSetterDeclaration | MissingPackageMemberDeclaration | TranslationsDeclaration | PackageStatement | PackageTypeDeclaration | StaticMethodDeclaration | StaticFieldDeclaration | StaticFieldGetterDeclaration | StaticFieldSetterDeclaration;
+export type PackageMemberDeclaration = PackageSingleMemberDeclaration | PackageMemberGroupDeclaration;
+export declare class PackageAliasTypeDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageAliasTypeDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Type>,
+        Identifier,
+        TypeParameterClause | undefined,
+        Token<TokenKind.Equals>,
+        TypeSpecifier,
+        TypeMemberDeclarationBlock | undefined
+    ];
+    get parent(): PackageMemberDeclarationList;
+    get tagList(): TagList;
+    get typeKeyword(): Keyword<KeywordKind.Type>;
+    get name(): Identifier;
+    get typeParameterClause(): TypeParameterClause | undefined;
+    get equalsToken(): Token<TokenKind.Equals>;
+    get aliasedTypeSpecifier(): TypeSpecifier;
+    get memberBlock(): TypeMemberDeclarationBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, typeKeyword: Keyword<KeywordKind.Type>, name: Identifier, typeParameterClause: TypeParameterClause | undefined, equalsToken: Token<TokenKind.Equals>, aliasedTypeSpecifier: TypeSpecifier, memberBlock: TypeMemberDeclarationBlock | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class PackageMemberGroupDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageMemberGroupDeclaration;
+    readonly children: readonly [
+        TagList,
+        Token<TokenKind.OpenBrace>,
+        PackageMemberDeclarationList,
+        Token<TokenKind.CloseBrace>
+    ];
+    get parent(): PackageMemberDeclarationList;
+    get tagList(): TagList;
+    get openBraceToken(): Token<TokenKind.OpenBrace>;
+    get declarationList(): PackageMemberDeclarationList;
+    get closeBraceToken(): Token<TokenKind.CloseBrace>;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, openBraceToken: Token<TokenKind.OpenBrace>, declarationList: PackageMemberDeclarationList, closeBraceToken: Token<TokenKind.CloseBrace>, rangeWithTrivia: Range | undefined);
+}
+export declare class PackageFunctionDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageFunctionDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Function>,
+        Identifier,
+        TypeParameterClause | undefined,
+        ParameterClause,
+        TypeAnnotation | undefined,
+        FunctionBlock | undefined
+    ];
+    get parent(): PackageMemberDeclarationList;
+    get tagList(): TagList;
+    get functionKeyword(): Keyword<KeywordKind.Function>;
+    get name(): Identifier;
+    get typeParameterClause(): TypeParameterClause | undefined;
+    get parameterClause(): ParameterClause;
+    get returnTypeAnnotation(): TypeAnnotation | undefined;
+    get block(): FunctionBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, functionKeyword: Keyword<KeywordKind.Function>, name: Identifier, typeParameterClause: TypeParameterClause | undefined, parameterClause: ParameterClause, returnTypeAnnotation: TypeAnnotation | undefined, block: FunctionBlock | undefined, rangeWithTrivia: Range | undefined);
+}
+export type BaseTypeListElement = NamedTypeSpecifier | Plus;
+export declare class BaseTypeList extends BaseNode {
+    readonly kind = NodeKind.BaseTypeList;
+    readonly children: readonly BaseTypeListElement[];
+    get parent(): ExtendsClause;
+    get elements(): readonly BaseTypeListElement[];
+    get baseTypes(): Query<NamedTypeSpecifier>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly BaseTypeListElement[], rangeWithTrivia: Range | undefined);
+}
+export type TypeMemberDeclarationListElement = TypeMemberDeclaration | Semicolon;
+export declare class TypeMemberDeclarationList extends BaseNode {
+    readonly kind = NodeKind.TypeMemberDeclarationList;
+    readonly children: readonly TypeMemberDeclarationListElement[];
+    get parent(): TypeMemberDeclarationBlock;
+    get elements(): readonly TypeMemberDeclarationListElement[];
+    get members(): Query<TypeMemberDeclaration>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly TypeMemberDeclarationListElement[], rangeWithTrivia: Range | undefined);
+    flatten(): Iterable<TypeSingleMemberDeclaration>;
+}
+export type TypeMemberDeclarationBlockParent = PackageTypeDeclaration | LocalStructuredTypeDeclaration | PackageAliasTypeDeclaration | TypeMemberGroupDeclaration;
+export declare class TypeMemberDeclarationBlock extends BaseNode {
+    readonly kind = NodeKind.TypeMemberDeclarationBlock;
+    readonly children: readonly [
+        Token<TokenKind.OpenBrace> | undefined,
+        TypeMemberDeclarationList,
+        Token<TokenKind.CloseBrace> | undefined,
+        Keyword<KeywordKind.End> | undefined
+    ];
+    get parent(): TypeMemberDeclarationBlockParent;
+    get openBraceToken(): Token<TokenKind.OpenBrace> | undefined;
+    get memberList(): TypeMemberDeclarationList;
+    get closeBraceToken(): Token<TokenKind.CloseBrace> | undefined;
+    get endKeyword(): Keyword<KeywordKind.End> | undefined;
+    protected get thisAsNode(): Node;
+    constructor(openBraceToken: Token<TokenKind.OpenBrace> | undefined, memberList: TypeMemberDeclarationList, closeBraceToken: Token<TokenKind.CloseBrace> | undefined, endKeyword: Keyword<KeywordKind.End> | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class PackageTypeDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageTypeDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Type>,
+        Identifier,
+        TypeParameterClause | undefined,
+        ExtendsClause | undefined,
+        TypeMemberDeclarationBlock
+    ];
+    get parent(): PackageMemberDeclarationList;
+    get tagList(): TagList;
+    get typeKeyword(): Keyword<KeywordKind.Type>;
+    get name(): Identifier;
+    get typeParameterClause(): TypeParameterClause | undefined;
+    get extendsClause(): ExtendsClause | undefined;
+    get memberBlock(): TypeMemberDeclarationBlock;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, typeKeyword: Keyword<KeywordKind.Type>, name: Identifier, typeParameterClause: TypeParameterClause | undefined, extendsClause: ExtendsClause | undefined, memberBlock: TypeMemberDeclarationBlock, rangeWithTrivia: Range | undefined);
+}
+export type ExtendsClauseParent = PackageTypeDeclaration | LocalStructuredTypeDeclaration;
+export declare class ExtendsClause extends BaseNode {
+    readonly kind = NodeKind.ExtendsClause;
+    readonly children: readonly [
+        Keyword<KeywordKind.Extends>,
+        BaseTypeList
+    ];
+    get parent(): ExtendsClauseParent;
+    get extendsKeyword(): Keyword<KeywordKind.Extends>;
+    get baseTypeList(): BaseTypeList;
+    protected get thisAsNode(): Node;
+    constructor(extendsKeyword: Keyword<KeywordKind.Extends>, baseTypeList: BaseTypeList, rangeWithTrivia: Range | undefined);
+}
+export declare class PackageVariableDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageVariableDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Var> | undefined,
+        Identifier,
+        TypeAnnotation | undefined,
+        VariableInitializer | undefined
+    ];
+    get parent(): PackageMemberDeclarationList;
+    get tagList(): TagList;
+    get varKeyword(): Keyword<KeywordKind.Var> | undefined;
+    get name(): Identifier;
+    get typeAnnotation(): TypeAnnotation | undefined;
+    get initializer(): VariableInitializer | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, varKeyword: Keyword<KeywordKind.Var> | undefined, name: Identifier, typeAnnotation: TypeAnnotation | undefined, initializer: VariableInitializer | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class PackageVariableGetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageVariableGetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Var>,
+        Identifier,
+        ParameterClause,
+        TypeAnnotation,
+        FunctionBlock | undefined
+    ];
+    get parent(): PackageMemberDeclarationList;
+    get tagList(): TagList;
+    get varKeyword(): Keyword<KeywordKind.Var>;
+    get name(): Identifier;
+    get parameterClause(): ParameterClause;
+    get typeAnnotation(): TypeAnnotation;
+    get block(): FunctionBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, varKeyword: Keyword<KeywordKind.Var>, name: Identifier, parameterClause: ParameterClause, typeAnnotation: TypeAnnotation, block: FunctionBlock | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class PackageVariableSetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageVariableSetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Var>,
+        Identifier,
+        ParameterClause,
+        FunctionBlock | undefined
+    ];
+    get parent(): PackageMemberDeclarationList;
+    get tagList(): TagList;
+    get varKeyword(): Keyword<KeywordKind.Var>;
+    get name(): Identifier;
+    get parameterClause(): ParameterClause;
+    get block(): FunctionBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, varKeyword: Keyword<KeywordKind.Var>, name: Identifier, parameterClause: ParameterClause, block: FunctionBlock | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class PackageStatement extends BaseNode {
+    readonly kind = NodeKind.PackageStatement;
+    readonly children: readonly [
+        Statement
+    ];
+    get parent(): PackageMemberDeclarationList;
+    get statement(): Statement;
+    protected get thisAsNode(): Node;
+    constructor(statement: Statement, rangeWithTrivia: Range | undefined);
+}
+export type StaticDeclaration = StaticFieldDeclaration | StaticFieldGetterDeclaration | StaticFieldSetterDeclaration | StaticMethodDeclaration;
+export declare class StaticMethodDeclaration extends BaseNode {
+    readonly kind = NodeKind.StaticMethodDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Function>,
+        StaticNameClause,
+        TypeParameterClause | undefined,
+        ParameterClause,
+        TypeAnnotation | undefined,
+        FunctionBlock | undefined
+    ];
+    get parent(): PackageMemberDeclarationList;
+    get tagList(): TagList;
+    get functionKeyword(): Keyword<KeywordKind.Function>;
+    get staticNameClause(): StaticNameClause;
+    get typeParameterClause(): TypeParameterClause | undefined;
+    get parameterClause(): ParameterClause;
+    get returnTypeAnnotation(): TypeAnnotation | undefined;
+    get block(): FunctionBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, functionKeyword: Keyword<KeywordKind.Function>, staticNameClause: StaticNameClause, typeParameterClause: TypeParameterClause | undefined, parameterClause: ParameterClause, returnTypeAnnotation: TypeAnnotation | undefined, block: FunctionBlock | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class StaticFieldDeclaration extends BaseNode {
+    readonly kind = NodeKind.StaticFieldDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Var> | undefined,
+        StaticNameClause,
+        TypeAnnotation | undefined,
+        VariableInitializer | undefined
+    ];
+    get parent(): PackageMemberDeclarationList;
+    get tagList(): TagList;
+    get varKeyword(): Keyword<KeywordKind.Var> | undefined;
+    get staticNameClause(): StaticNameClause;
+    get typeAnnotation(): TypeAnnotation | undefined;
+    get initializer(): VariableInitializer | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, varKeyword: Keyword<KeywordKind.Var> | undefined, staticNameClause: StaticNameClause, typeAnnotation: TypeAnnotation | undefined, initializer: VariableInitializer | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class StaticFieldGetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.StaticFieldGetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Var>,
+        StaticNameClause,
+        ParameterClause,
+        TypeAnnotation,
+        FunctionBlock | undefined
+    ];
+    get parent(): PackageMemberDeclarationList;
+    get tagList(): TagList;
+    get varKeyword(): Keyword<KeywordKind.Var>;
+    get staticNameClause(): StaticNameClause;
+    get parameterClause(): ParameterClause;
+    get typeAnnotation(): TypeAnnotation;
+    get block(): FunctionBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, varKeyword: Keyword<KeywordKind.Var>, staticNameClause: StaticNameClause, parameterClause: ParameterClause, typeAnnotation: TypeAnnotation, block: FunctionBlock | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class StaticFieldSetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.StaticFieldSetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Var>,
+        StaticNameClause,
+        ParameterClause,
+        FunctionBlock | undefined
+    ];
+    get parent(): PackageMemberDeclarationList;
+    get tagList(): TagList;
+    get varKeyword(): Keyword<KeywordKind.Var>;
+    get staticNameClause(): StaticNameClause;
+    get parameterClause(): ParameterClause;
+    get block(): FunctionBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, varKeyword: Keyword<KeywordKind.Var>, staticNameClause: StaticNameClause, parameterClause: ParameterClause, block: FunctionBlock | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class StaticNameClause extends BaseNode {
+    readonly kind = NodeKind.StaticNameClause;
+    readonly children: readonly [
+        QualifiedName,
+        Token<TokenKind.LessThan> | undefined,
+        TypeParameterReferenceList | undefined,
+        Token<TokenKind.GreaterThan> | undefined,
+        Token<TokenKind.Dot>,
+        Identifier
+    ];
+    get parent(): StaticDeclaration;
+    get qualifiedTypeName(): QualifiedName;
+    get lessThanToken(): Token<TokenKind.LessThan> | undefined;
+    get typeParameterReferenceList(): TypeParameterReferenceList | undefined;
+    get greaterThanToken(): Token<TokenKind.GreaterThan> | undefined;
+    get separatingDotToken(): Token<TokenKind.Dot>;
+    get name(): Identifier;
+    protected get thisAsNode(): Node;
+    constructor(qualifiedTypeName: QualifiedName, lessThanToken: Token<TokenKind.LessThan> | undefined, typeParameterReferenceList: TypeParameterReferenceList | undefined, greaterThanToken: Token<TokenKind.GreaterThan> | undefined, separatingDotToken: Token<TokenKind.Dot>, name: Identifier, rangeWithTrivia: Range | undefined);
+}
+export declare class MissingPackageMemberDeclaration extends BaseNode {
+    readonly kind = NodeKind.MissingPackageMemberDeclaration;
+    readonly children: readonly [
+        TagList
+    ];
+    get parent(): PackageMemberDeclarationList;
+    get tagList(): TagList;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, rangeWithTrivia: Range | undefined);
+}
+export type TypeSingleMemberDeclaration = FieldDeclaration | FieldGetterDeclaration | FieldSetterDeclaration | VariantValueDeclaration | MethodDeclaration | IndexedElementGetterDeclaration | IndexedElementSetterDeclaration | MissingTypeMemberDeclaration;
+export type TypeMemberDeclaration = TypeSingleMemberDeclaration | TypeMemberGroupDeclaration;
+export declare class TypeMemberGroupDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeMemberGroupDeclaration;
+    readonly children: readonly [
+        TagList,
+        TypeMemberDeclarationBlock
+    ];
+    get parent(): TypeMemberDeclarationList;
+    get tagList(): TagList;
+    get memberBlock(): TypeMemberDeclarationBlock;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, memberBlock: TypeMemberDeclarationBlock, rangeWithTrivia: Range | undefined);
+}
+export declare class IndexedElementGetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.IndexedElementGetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Function>,
+        Token<TokenKind.OpenSquareBracket>,
+        Token<TokenKind.CloseSquareBracket>,
+        ParameterClause,
+        TypeAnnotation,
+        FunctionBlock | undefined
+    ];
+    get parent(): TypeMemberDeclarationList;
+    get tagList(): TagList;
+    get functionKeyword(): Keyword<KeywordKind.Function>;
+    get openSquareBracketToken(): Token<TokenKind.OpenSquareBracket>;
+    get closeSquareBracketToken(): Token<TokenKind.CloseSquareBracket>;
+    get parameterClause(): ParameterClause;
+    get typeAnnotation(): TypeAnnotation;
+    get block(): FunctionBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, functionKeyword: Keyword<KeywordKind.Function>, openSquareBracketToken: Token<TokenKind.OpenSquareBracket>, closeSquareBracketToken: Token<TokenKind.CloseSquareBracket>, parameterClause: ParameterClause, typeAnnotation: TypeAnnotation, block: FunctionBlock | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class IndexedElementSetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.IndexedElementSetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Function>,
+        Token<TokenKind.OpenSquareBracket>,
+        Token<TokenKind.CloseSquareBracket>,
+        Token<TokenKind.Equals>,
+        ParameterClause,
+        FunctionBlock | undefined
+    ];
+    get parent(): TypeMemberDeclarationList;
+    get tagList(): TagList;
+    get functionKeyword(): Keyword<KeywordKind.Function>;
+    get openSquareBracketToken(): Token<TokenKind.OpenSquareBracket>;
+    get closeSquareBracketToken(): Token<TokenKind.CloseSquareBracket>;
+    get equalsToken(): Token<TokenKind.Equals>;
+    get parameterClause(): ParameterClause;
+    get block(): FunctionBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, functionKeyword: Keyword<KeywordKind.Function>, openSquareBracketToken: Token<TokenKind.OpenSquareBracket>, closeSquareBracketToken: Token<TokenKind.CloseSquareBracket>, equalsToken: Token<TokenKind.Equals>, parameterClause: ParameterClause, block: FunctionBlock | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class MethodDeclaration extends BaseNode {
+    readonly kind = NodeKind.MethodDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Function>,
+        Token | Keyword,
+        TypeParameterClause | undefined,
+        ParameterClause,
+        TypeAnnotation | undefined,
+        FunctionBlock | undefined
+    ];
+    get parent(): TypeMemberDeclarationList;
+    get tagList(): TagList;
+    get functionKeyword(): Keyword<KeywordKind.Function>;
+    get name(): Token | Keyword;
+    get typeParameterClause(): TypeParameterClause | undefined;
+    get parameterClause(): ParameterClause;
+    get returnTypeAnnotation(): TypeAnnotation | undefined;
+    get block(): FunctionBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, functionKeyword: Keyword<KeywordKind.Function>, name: Token | Keyword, typeParameterClause: TypeParameterClause | undefined, parameterClause: ParameterClause, returnTypeAnnotation: TypeAnnotation | undefined, block: FunctionBlock | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class FieldDeclaration extends BaseNode {
+    readonly kind = NodeKind.FieldDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Var> | undefined,
+        Identifier,
+        TypeAnnotation | undefined,
+        VariableInitializer | undefined
+    ];
+    get parent(): TypeMemberDeclarationList;
+    get tagList(): TagList;
+    get varKeyword(): Keyword<KeywordKind.Var> | undefined;
+    get name(): Identifier;
+    get typeAnnotation(): TypeAnnotation | undefined;
+    get initializer(): VariableInitializer | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, varKeyword: Keyword<KeywordKind.Var> | undefined, name: Identifier, typeAnnotation: TypeAnnotation | undefined, initializer: VariableInitializer | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class FieldGetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.FieldGetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Var>,
+        Identifier,
+        ParameterClause,
+        TypeAnnotation,
+        FunctionBlock | undefined
+    ];
+    get parent(): TypeMemberDeclarationList;
+    get tagList(): TagList;
+    get varKeyword(): Keyword<KeywordKind.Var>;
+    get name(): Identifier;
+    get parameterClause(): ParameterClause;
+    get typeAnnotation(): TypeAnnotation;
+    get block(): FunctionBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, varKeyword: Keyword<KeywordKind.Var>, name: Identifier, parameterClause: ParameterClause, typeAnnotation: TypeAnnotation, block: FunctionBlock | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class FieldSetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.FieldSetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Var>,
+        Identifier,
+        ParameterClause,
+        FunctionBlock | undefined
+    ];
+    get parent(): TypeMemberDeclarationList;
+    get tagList(): TagList;
+    get varKeyword(): Keyword<KeywordKind.Var>;
+    get name(): Identifier;
+    get parameterClause(): ParameterClause;
+    get block(): FunctionBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, varKeyword: Keyword<KeywordKind.Var>, name: Identifier, parameterClause: ParameterClause, block: FunctionBlock | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class MissingTypeMemberDeclaration extends BaseNode {
+    readonly kind = NodeKind.MissingTypeMemberDeclaration;
+    readonly children: readonly [
+        TagList
+    ];
+    get parent(): TypeMemberDeclarationList;
+    get tagList(): TagList;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, rangeWithTrivia: Range | undefined);
+}
+export declare class NestedFunctionDeclaration extends BaseNode {
+    readonly kind = NodeKind.NestedFunctionDeclaration;
+    readonly children: readonly [
+        Keyword<KeywordKind.Function>,
+        Identifier,
+        TypeParameterClause | undefined,
+        ParameterClause,
+        TypeAnnotation | undefined,
+        FunctionBlock
+    ];
+    get parent(): NestedFunctionDeclarationStatement;
+    get functionKeyword(): Keyword<KeywordKind.Function>;
+    get name(): Identifier;
+    get typeParameterClause(): TypeParameterClause | undefined;
+    get parameterClause(): ParameterClause;
+    get returnTypeAnnotation(): TypeAnnotation | undefined;
+    get block(): FunctionBlock;
+    protected get thisAsNode(): Node;
+    constructor(functionKeyword: Keyword<KeywordKind.Function>, name: Identifier, typeParameterClause: TypeParameterClause | undefined, parameterClause: ParameterClause, returnTypeAnnotation: TypeAnnotation | undefined, block: FunctionBlock, rangeWithTrivia: Range | undefined);
+}
+export declare class LocalVariableDeclaration extends BaseNode {
+    readonly kind = NodeKind.LocalVariableDeclaration;
+    readonly children: readonly [
+        Keyword<KeywordKind.Var> | undefined,
+        Identifier,
+        TypeAnnotation | undefined,
+        VariableInitializer | undefined
+    ];
+    get parent(): LocalVariableDeclarationStatement;
+    get varKeyword(): Keyword<KeywordKind.Var> | undefined;
+    get name(): Identifier;
+    get typeAnnotation(): TypeAnnotation | undefined;
+    get initializer(): VariableInitializer | undefined;
+    protected get thisAsNode(): Node;
+    constructor(varKeyword: Keyword<KeywordKind.Var> | undefined, name: Identifier, typeAnnotation: TypeAnnotation | undefined, initializer: VariableInitializer | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class ForStatementVariableDeclaration extends BaseNode {
+    readonly kind = NodeKind.ForStatementVariableDeclaration;
+    readonly children: readonly [
+        Identifier
+    ];
+    get parent(): ForStatement;
+    get name(): Identifier;
+    protected get thisAsNode(): Node;
+    constructor(name: Identifier, rangeWithTrivia: Range | undefined);
+}
+export type Expression = ArrayLiteral | AssumptionExpression | BinaryExpression | FunctionLiteral | FunctionBlockLiteral | CallExpression | IdentifierExpression | IndexedAccessExpression | MissingExpression | ParenthesizedExpression | ConditionalExpression | PrefixUnaryExpression | MemberAccessExpression | ReferenceExpression | DereferenceExpression | TextLiteral | LocalizableTextLiteral | TextTemplateLiteral | LocalizableTextTemplateLiteral | GenericSpecializationExpression | DefaultMatchExpression | TokenExpression | KeywordExpression | ObjectExpression | BaseExpression;
+export type ExpressionParent = ArrayLiteralElementList | AssumptionExpression | AssignmentStatement | BinaryExpression | Argument | CallExpression | DisposeStatement | ErrorStatement | ImportantStatement | ExpressionStatement | ForStatement | IfStatement | IndexedAccessExpression | MatchExpressionList | ParenthesizedExpression | ConditionalExpression | PrefixUnaryExpression | MemberAccessExpression | ReferenceExpression | DereferenceExpression | ReturnStatement | TextTemplateSpan | SwitchStatement | WhileStatement | YieldStatement | GenericSpecializationExpression | ElseIfClause | TextTranslationDeclaration | VariableInitializer | CaseClause;
+export type ExpressionListElement = Expression | Comma;
+declare abstract class BaseExpressionNode extends BaseNode {
+    protected abstract get thisAsNode(): Expression;
+    unwrapParenthesizedExpressions(): Expression;
+    getParentSkippingParenthesizedExpressions(): ExpressionParent;
+}
+export declare class ArrayLiteral extends BaseExpressionNode {
+    readonly kind = NodeKind.ArrayLiteral;
+    readonly children: readonly [
+        Token<TokenKind.OpenSquareBracket>,
+        ArrayLiteralElementList,
+        Token<TokenKind.CloseSquareBracket>
+    ];
+    get parent(): ExpressionParent;
+    get openSquareBracketToken(): Token<TokenKind.OpenSquareBracket>;
+    get elementList(): ArrayLiteralElementList;
+    get closeSquareBracketToken(): Token<TokenKind.CloseSquareBracket>;
+    protected get thisAsNode(): Expression;
+    constructor(openSquareBracketToken: Token<TokenKind.OpenSquareBracket>, elementList: ArrayLiteralElementList, closeSquareBracketToken: Token<TokenKind.CloseSquareBracket>, rangeWithTrivia: Range | undefined);
+}
+export declare class ArrayLiteralElementList extends BaseNode {
+    readonly kind = NodeKind.ArrayLiteralElementList;
+    readonly children: readonly ExpressionListElement[];
+    get parent(): ArrayLiteral;
+    get elements(): readonly ExpressionListElement[];
+    get expressions(): Query<Expression>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly ExpressionListElement[], rangeWithTrivia: Range | undefined);
+}
+export declare class AssumptionExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.AssumptionExpression;
+    readonly children: readonly [
+        Expression,
+        Token<TokenKind.Question>
+    ];
+    get parent(): ExpressionParent;
+    get expression(): Expression;
+    get questionToken(): Token<TokenKind.Question>;
+    protected get thisAsNode(): Expression;
+    constructor(expression: Expression, questionToken: Token<TokenKind.Question>, rangeWithTrivia: Range | undefined);
+}
+export declare class BinaryExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.BinaryExpression;
+    readonly children: readonly [
+        Expression,
+        BinaryExpressionOperator,
+        Expression
+    ];
+    get parent(): ExpressionParent;
+    get left(): Expression;
+    get operator(): BinaryExpressionOperator;
+    get right(): Expression;
+    protected get thisAsNode(): Expression;
+    constructor(left: Expression, operator: BinaryExpressionOperator, right: Expression, rangeWithTrivia: Range | undefined);
+}
+export type BinaryExpressionOperator = Token<TokenKind.Plus> | Token<TokenKind.Minus> | Token<TokenKind.Asterisk> | Token<TokenKind.Slash> | Token<TokenKind.Percent> | Token<TokenKind.EqualsEquals> | Token<TokenKind.ExclamationEquals> | Token<TokenKind.LessThan> | Token<TokenKind.GreaterThan> | Token<TokenKind.LessThanOrEqual> | Token<TokenKind.GreaterThanOrEqual> | Token<TokenKind.QuestionQuestion> | Keyword<KeywordKind.Or> | Keyword<KeywordKind.And>;
+export declare class FunctionLiteral extends BaseExpressionNode {
+    readonly kind = NodeKind.FunctionLiteral;
+    readonly children: readonly [
+        Keyword<KeywordKind.Function>,
+        ParameterClause,
+        TypeAnnotation | undefined,
+        FunctionBlock
+    ];
+    get parent(): ExpressionParent;
+    get functionKeyword(): Keyword<KeywordKind.Function>;
+    get parameterClause(): ParameterClause;
+    get returnTypeAnnotation(): TypeAnnotation | undefined;
+    get block(): FunctionBlock;
+    protected get thisAsNode(): Expression;
+    constructor(functionKeyword: Keyword<KeywordKind.Function>, parameterClause: ParameterClause, returnTypeAnnotation: TypeAnnotation | undefined, block: FunctionBlock, rangeWithTrivia: Range | undefined);
+}
+export declare class FunctionBlockLiteral extends BaseExpressionNode {
+    readonly kind = NodeKind.FunctionBlockLiteral;
+    readonly children: readonly [
+        FunctionBlock
+    ];
+    get parent(): ExpressionParent;
+    get block(): FunctionBlock;
+    protected get thisAsNode(): Expression;
+    constructor(block: FunctionBlock, rangeWithTrivia: Range | undefined);
+}
+export type ArgumentListElement = Argument | Comma;
+export type ArgumentListParent = CallExpression | Tag | IndexedAccessExpression;
+export declare class ArgumentList extends BaseNode {
+    readonly kind = NodeKind.ArgumentList;
+    readonly children: readonly ArgumentListElement[];
+    get parent(): ArgumentListParent;
+    get elements(): readonly ArgumentListElement[];
+    get arguments(): Query<Argument>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly ArgumentListElement[], rangeWithTrivia: Range | undefined);
+}
+export declare class CallExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.CallExpression;
+    readonly children: readonly [
+        Expression,
+        Token<TokenKind.OpenParenthesis>,
+        ArgumentList,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get parent(): ExpressionParent;
+    get expression(): Expression;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get argumentList(): ArgumentList;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Expression;
+    constructor(expression: Expression, openParenthesisToken: Token<TokenKind.OpenParenthesis>, argumentList: ArgumentList, closeParenthesisToken: Token<TokenKind.CloseParenthesis>, rangeWithTrivia: Range | undefined);
+}
+export declare class IndexedAccessExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.IndexedAccessExpression;
+    readonly children: readonly [
+        Expression,
+        Token<TokenKind.OpenSquareBracket>,
+        ArgumentList,
+        Token<TokenKind.CloseSquareBracket>
+    ];
+    get parent(): ExpressionParent;
+    get expression(): Expression;
+    get openSquareBracketToken(): Token<TokenKind.OpenSquareBracket>;
+    get argumentList(): ArgumentList;
+    get closeSquareBracketToken(): Token<TokenKind.CloseSquareBracket>;
+    protected get thisAsNode(): Expression;
+    constructor(expression: Expression, openSquareBracketToken: Token<TokenKind.OpenSquareBracket>, argumentList: ArgumentList, closeSquareBracketToken: Token<TokenKind.CloseSquareBracket>, rangeWithTrivia: Range | undefined);
+}
+export declare class MissingExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.MissingExpression;
+    get children(): readonly [];
+    get parent(): ExpressionParent;
+    protected get thisAsNode(): Expression;
+    constructor(rangeWithTrivia: Range | undefined);
+}
+export declare class ParenthesizedExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.ParenthesizedExpression;
+    readonly children: readonly [
+        Token<TokenKind.OpenParenthesis>,
+        Expression,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get parent(): ExpressionParent;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get expression(): Expression;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Expression;
+    constructor(openParenthesisToken: Token<TokenKind.OpenParenthesis>, expression: Expression, closeParenthesisToken: Token<TokenKind.CloseParenthesis>, rangeWithTrivia: Range | undefined);
+}
+export declare class ConditionalExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.ConditionalExpression;
+    readonly children: readonly [
+        Keyword<KeywordKind.Cond>,
+        Token<TokenKind.OpenParenthesis>,
+        Expression,
+        Comma,
+        Expression,
+        Comma | undefined,
+        Expression | undefined,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get parent(): ExpressionParent;
+    get condKeyword(): Keyword<KeywordKind.Cond>;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get condition(): Expression;
+    get firstCommaToken(): Comma;
+    get firstExpression(): Expression;
+    get secondCommaToken(): Comma | undefined;
+    get secondExpression(): Expression | undefined;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Expression;
+    constructor(condKeyword: Keyword<KeywordKind.Cond>, openParenthesisToken: Token<TokenKind.OpenParenthesis>, condition: Expression, firstCommaToken: Comma, firstExpression: Expression, secondCommaToken: Comma | undefined, secondExpression: Expression | undefined, closeParenthesisToken: Token<TokenKind.CloseParenthesis>, rangeWithTrivia: Range | undefined);
+}
+export declare class PrefixUnaryExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.PrefixUnaryExpression;
+    readonly children: readonly [
+        PrefixUnaryExpressionOperator,
+        Expression
+    ];
+    get parent(): ExpressionParent;
+    get operator(): PrefixUnaryExpressionOperator;
+    get operand(): Expression;
+    protected get thisAsNode(): Expression;
+    constructor(operator: PrefixUnaryExpressionOperator, operand: Expression, rangeWithTrivia: Range | undefined);
+}
+export type PrefixUnaryExpressionOperator = Token<TokenKind.Plus> | Token<TokenKind.Minus> | Keyword<KeywordKind.Not>;
+export declare class MemberAccessExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.MemberAccessExpression;
+    readonly children: readonly [
+        Expression,
+        Token<TokenKind.Dot>,
+        Identifier
+    ];
+    get parent(): ExpressionParent;
+    get expression(): Expression;
+    get dotToken(): Token<TokenKind.Dot>;
+    get memberName(): Identifier;
+    protected get thisAsNode(): Expression;
+    constructor(expression: Expression, dotToken: Token<TokenKind.Dot>, memberName: Identifier, rangeWithTrivia: Range | undefined);
+}
+export declare class ReferenceExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.ReferenceExpression;
+    readonly children: readonly [
+        Keyword<KeywordKind.Reference>,
+        Token<TokenKind.OpenParenthesis>,
+        Expression,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get parent(): ExpressionParent;
+    get referenceKeyword(): Keyword<KeywordKind.Reference>;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get expression(): Expression;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Expression;
+    constructor(referenceKeyword: Keyword<KeywordKind.Reference>, openParenthesisToken: Token<TokenKind.OpenParenthesis>, expression: Expression, closeParenthesisToken: Token<TokenKind.CloseParenthesis>, rangeWithTrivia: Range | undefined);
+}
+export declare class DereferenceExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.DereferenceExpression;
+    readonly children: readonly [
+        Expression,
+        Token<TokenKind.Dot>,
+        Keyword<KeywordKind.Var>
+    ];
+    get parent(): ExpressionParent;
+    get expression(): Expression;
+    get dotToken(): Token<TokenKind.Dot>;
+    get varKeyword(): Keyword<KeywordKind.Var>;
+    protected get thisAsNode(): Expression;
+    constructor(expression: Expression, dotToken: Token<TokenKind.Dot>, varKeyword: Keyword<KeywordKind.Var>, rangeWithTrivia: Range | undefined);
+}
+export declare class TextTemplateLiteral extends BaseExpressionNode {
+    readonly kind = NodeKind.TextTemplateLiteral;
+    readonly children: readonly [
+        TextTemplateHead,
+        TextTemplateSpanList
+    ];
+    get parent(): ExpressionParent;
+    get head(): TextTemplateHead;
+    get spanList(): TextTemplateSpanList;
+    protected get thisAsNode(): Expression;
+    constructor(head: TextTemplateHead, spanList: TextTemplateSpanList, rangeWithTrivia: Range | undefined);
+}
+export declare class LocalizableTextTemplateLiteral extends BaseExpressionNode {
+    readonly kind = NodeKind.LocalizableTextTemplateLiteral;
+    readonly children: readonly [
+        TextTemplateHead,
+        TextTemplateSpanList,
+        Token<TokenKind.TextLiteralSuffix> | undefined
+    ];
+    get parent(): ExpressionParent;
+    get head(): TextTemplateHead;
+    get spanList(): TextTemplateSpanList;
+    get suffix(): Token<TokenKind.TextLiteralSuffix> | undefined;
+    protected get thisAsNode(): Expression;
+    constructor(head: TextTemplateHead, spanList: TextTemplateSpanList, suffix: Token<TokenKind.TextLiteralSuffix> | undefined, rangeWithTrivia: Range | undefined);
+}
+export type TextTemplateSpanListParent = TextTemplateLiteral | LocalizableTextTemplateLiteral;
+export declare class TextTemplateSpanList extends BaseNode {
+    readonly kind = NodeKind.TextTemplateSpanList;
+    readonly children: readonly TextTemplateSpan[];
+    get parent(): TextTemplateSpanListParent;
+    get spans(): readonly TextTemplateSpan[];
+    protected get thisAsNode(): Node;
+    constructor(spans: readonly TextTemplateSpan[], rangeWithTrivia: Range | undefined);
+}
+export type TextTemplateHead = Token<TokenKind.TextTemplateHead>;
+export type TextTemplatePart = Token<TokenKind.TextTemplatePart>;
+export type TextTemplateTail = Token<TokenKind.TextTemplateTail>;
+export declare class TextTemplateSpan extends BaseNode {
+    readonly kind = NodeKind.TextTemplateSpan;
+    readonly children: readonly [
+        Expression,
+        TextTemplatePart | TextTemplateTail
+    ];
+    get parent(): TextTemplateSpanList;
+    get expression(): Expression;
+    get text(): TextTemplatePart | TextTemplateTail;
+    protected get thisAsNode(): Node;
+    constructor(expression: Expression, text: TextTemplatePart | TextTemplateTail, rangeWithTrivia: Range | undefined);
+}
+export declare class TokenExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.TokenExpression;
+    readonly children: readonly [
+        TokenExpressionToken
+    ];
+    get parent(): ExpressionParent;
+    get token(): TokenExpressionToken;
+    protected get thisAsNode(): Expression;
+    constructor(token: TokenExpressionToken, rangeWithTrivia: Range | undefined);
+}
+export type TokenExpressionToken = Token<TokenKind.IntegerLiteral> | Token<TokenKind.RealLiteral> | Token<TokenKind.MeasureLiteral>;
+export declare class TextLiteral extends BaseExpressionNode {
+    readonly kind = NodeKind.TextLiteral;
+    readonly children: readonly [
+        Token<TokenKind.TextLiteral>
+    ];
+    get parent(): ExpressionParent;
+    get text(): Token<TokenKind.TextLiteral>;
+    protected get thisAsNode(): Expression;
+    constructor(text: Token<TokenKind.TextLiteral>, rangeWithTrivia: Range | undefined);
+}
+export declare class LocalizableTextLiteral extends BaseExpressionNode {
+    readonly kind = NodeKind.LocalizableTextLiteral;
+    readonly children: readonly [
+        Token<TokenKind.TextLiteral>,
+        Token<TokenKind.TextLiteralSuffix> | undefined
+    ];
+    get parent(): ExpressionParent;
+    get text(): Token<TokenKind.TextLiteral>;
+    get suffix(): Token<TokenKind.TextLiteralSuffix> | undefined;
+    protected get thisAsNode(): Expression;
+    constructor(text: Token<TokenKind.TextLiteral>, suffix: Token<TokenKind.TextLiteralSuffix> | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class KeywordExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.KeywordExpression;
+    readonly children: readonly [
+        KeywordExpressionKeyword
+    ];
+    get parent(): ExpressionParent;
+    get keyword(): KeywordExpressionKeyword;
+    protected get thisAsNode(): Expression;
+    constructor(keyword: KeywordExpressionKeyword, rangeWithTrivia: Range | undefined);
+}
+export type KeywordExpressionKeyword = Keyword<KeywordKind.Yes> | Keyword<KeywordKind.No> | Keyword<KeywordKind.Null>;
+export declare class ObjectExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.ObjectExpression;
+    readonly children: readonly [
+        ObjectKeyword
+    ];
+    get parent(): ExpressionParent;
+    get keyword(): ObjectKeyword;
+    protected get thisAsNode(): Expression;
+    constructor(keyword: ObjectKeyword, rangeWithTrivia: Range | undefined);
+}
+export declare class BaseExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.BaseExpression;
+    readonly children: readonly [
+        Keyword<KeywordKind.Base>
+    ];
+    get parent(): ExpressionParent;
+    get keyword(): Keyword<KeywordKind.Base>;
+    protected get thisAsNode(): Expression;
+    constructor(keyword: Keyword<KeywordKind.Base>, rangeWithTrivia: Range | undefined);
+}
+export declare class IdentifierExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.IdentifierExpression;
+    readonly children: readonly [
+        Identifier
+    ];
+    get parent(): ExpressionParent;
+    get identifier(): Identifier;
+    protected get thisAsNode(): Expression;
+    constructor(identifier: Identifier, rangeWithTrivia: Range | undefined);
+}
+export declare class GenericSpecializationExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.GenericSpecializationExpression;
+    readonly children: readonly [
+        Expression,
+        TypeArgumentClause
+    ];
+    get parent(): ExpressionParent;
+    get expression(): Expression;
+    get typeArgumentClause(): TypeArgumentClause;
+    protected get thisAsNode(): Expression;
+    constructor(expression: Expression, typeArgumentClause: TypeArgumentClause, rangeWithTrivia: Range | undefined);
+}
+export declare class DefaultMatchExpression extends BaseExpressionNode {
+    readonly kind = NodeKind.DefaultMatchExpression;
+    readonly children: readonly [
+        Token<TokenKind.Asterisk>
+    ];
+    get parent(): ExpressionParent;
+    get asteriskToken(): Token<TokenKind.Asterisk>;
+    protected get thisAsNode(): Expression;
+    constructor(asteriskToken: Token<TokenKind.Asterisk>, rangeWithTrivia: Range | undefined);
+}
+export type Statement = AssignmentStatement | RunStatement | TryStatement | IfStatement | ForStatement | WhileStatement | LoopStatement | ReturnStatement | ErrorStatement | LocalVariableDeclarationStatement | YieldStatement | MissingStatement | ImportantStatement | ExpressionStatement | SwitchStatement | BreakLoopStatement | ContinueLoopStatement | DisposeStatement | NestedFunctionDeclarationStatement | LocalStructuredTypeDeclarationStatement;
+export declare class AssignmentStatement extends BaseNode {
+    readonly kind = NodeKind.AssignmentStatement;
+    readonly children: readonly [
+        Expression,
+        AssignmentStatementOperator,
+        Expression
+    ];
+    get parent(): StatementParent;
+    get left(): Expression;
+    get operator(): AssignmentStatementOperator;
+    get right(): Expression;
+    protected get thisAsNode(): Node;
+    constructor(left: Expression, operator: AssignmentStatementOperator, right: Expression, rangeWithTrivia: Range | undefined);
+}
+export type AssignmentStatementOperator = Token<TokenKind.Equals> | Token<TokenKind.PlusEquals> | Token<TokenKind.MinusEquals> | Token<TokenKind.AsteriskEquals> | Token<TokenKind.SlashEquals> | Token<TokenKind.PercentEquals>;
+export type StatementListParent = FunctionBlock | StatementBlock;
+export type StatementListElement = Statement | Semicolon;
+export declare class StatementList extends BaseNode {
+    readonly kind = NodeKind.StatementList;
+    readonly children: readonly StatementListElement[];
+    get parent(): StatementListParent;
+    get elements(): readonly StatementListElement[];
+    get statements(): Query<Statement>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly StatementListElement[], rangeWithTrivia: Range | undefined);
+}
+export type StatementBlockParent = IfStatement | ElseIfClause | ElseClause | RunStatement | TryStatement | CatchClause | FinallyClause | ForStatement | LoopStatement | CaseClause | WhileStatement;
+export declare class StatementBlock extends BaseNode {
+    readonly kind = NodeKind.StatementBlock;
+    readonly children: readonly [
+        Token<TokenKind.OpenBrace> | undefined,
+        StatementList,
+        Token<TokenKind.CloseBrace> | undefined,
+        Keyword<KeywordKind.End> | undefined
+    ];
+    get parent(): StatementBlockParent;
+    get openBraceToken(): Token<TokenKind.OpenBrace> | undefined;
+    get statementList(): StatementList;
+    get closeBraceToken(): Token<TokenKind.CloseBrace> | undefined;
+    get endKeyword(): Keyword<KeywordKind.End> | undefined;
+    protected get thisAsNode(): Node;
+    constructor(openBraceToken: Token<TokenKind.OpenBrace> | undefined, statementList: StatementList, closeBraceToken: Token<TokenKind.CloseBrace> | undefined, endKeyword: Keyword<KeywordKind.End> | undefined, rangeWithTrivia: Range | undefined);
+}
+export type FunctionBlockParent = PackageVariableGetterDeclaration | PackageVariableSetterDeclaration | PackageFunctionDeclaration | FieldGetterDeclaration | FieldSetterDeclaration | IndexedElementGetterDeclaration | IndexedElementSetterDeclaration | MethodDeclaration | NestedFunctionDeclaration | FunctionLiteral | FunctionBlockLiteral | TextTranslationFunctionDeclaration | StaticMethodDeclaration | StaticFieldGetterDeclaration | StaticFieldSetterDeclaration;
+export declare class FunctionBlock extends BaseNode {
+    readonly kind = NodeKind.FunctionBlock;
+    readonly children: readonly [
+        Token<TokenKind.OpenBrace> | undefined,
+        StatementList,
+        Token<TokenKind.CloseBrace> | undefined,
+        Keyword<KeywordKind.End> | undefined
+    ];
+    get parent(): FunctionBlockParent;
+    get openBraceToken(): Token<TokenKind.OpenBrace> | undefined;
+    get statementList(): StatementList;
+    get closeBraceToken(): Token<TokenKind.CloseBrace> | undefined;
+    get endKeyword(): Keyword<KeywordKind.End> | undefined;
+    protected get thisAsNode(): Node;
+    constructor(openBraceToken: Token<TokenKind.OpenBrace> | undefined, statementList: StatementList, closeBraceToken: Token<TokenKind.CloseBrace> | undefined, endKeyword: Keyword<KeywordKind.End> | undefined, rangeWithTrivia: Range | undefined);
+}
+export type StatementParent = StatementList | PackageStatement;
+export declare class BreakLoopStatement extends BaseNode {
+    readonly kind = NodeKind.BreakLoopStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.BreakLoop>
+    ];
+    get parent(): StatementParent;
+    get breakLoopKeyword(): Keyword<KeywordKind.BreakLoop>;
+    protected get thisAsNode(): Node;
+    constructor(breakLoopKeyword: Keyword<KeywordKind.BreakLoop>, rangeWithTrivia: Range | undefined);
+}
+export declare class ContinueLoopStatement extends BaseNode {
+    readonly kind = NodeKind.ContinueLoopStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.ContinueLoop>
+    ];
+    get parent(): StatementParent;
+    get continueLoopKeyword(): Keyword<KeywordKind.ContinueLoop>;
+    protected get thisAsNode(): Node;
+    constructor(continueLoopKeyword: Keyword<KeywordKind.ContinueLoop>, rangeWithTrivia: Range | undefined);
+}
+export declare class DisposeStatement extends BaseNode {
+    readonly kind = NodeKind.DisposeStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Dispose>,
+        Expression
+    ];
+    get parent(): StatementParent;
+    get disposeKeyword(): Keyword<KeywordKind.Dispose>;
+    get expression(): Expression;
+    protected get thisAsNode(): Node;
+    constructor(disposeKeyword: Keyword<KeywordKind.Dispose>, expression: Expression, rangeWithTrivia: Range | undefined);
+}
+export declare class RunStatement extends BaseNode {
+    readonly kind = NodeKind.RunStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Run>,
+        StatementBlock
+    ];
+    get parent(): StatementParent;
+    get runKeyword(): Keyword<KeywordKind.Run>;
+    get block(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(runKeyword: Keyword<KeywordKind.Run>, block: StatementBlock, rangeWithTrivia: Range | undefined);
+}
+export declare class TryStatement extends BaseNode {
+    readonly kind = NodeKind.TryStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Try>,
+        StatementBlock,
+        CatchClause | undefined,
+        FinallyClause | undefined
+    ];
+    get parent(): StatementParent;
+    get tryKeyword(): Keyword<KeywordKind.Try>;
+    get block(): StatementBlock;
+    get catchClause(): CatchClause | undefined;
+    get finallyClause(): FinallyClause | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tryKeyword: Keyword<KeywordKind.Try>, block: StatementBlock, catchClause: CatchClause | undefined, finallyClause: FinallyClause | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class CatchClause extends BaseNode {
+    readonly kind = NodeKind.CatchClause;
+    readonly children: readonly [
+        Keyword<KeywordKind.Catch>,
+        ErrorVariableDeclaration | undefined,
+        StatementBlock
+    ];
+    get parent(): TryStatement;
+    get catchKeyword(): Keyword<KeywordKind.Catch>;
+    get errorVariable(): ErrorVariableDeclaration | undefined;
+    get block(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(catchKeyword: Keyword<KeywordKind.Catch>, errorVariable: ErrorVariableDeclaration | undefined, block: StatementBlock, rangeWithTrivia: Range | undefined);
+}
+export declare class ErrorVariableDeclaration extends BaseNode {
+    readonly kind = NodeKind.ErrorVariableDeclaration;
+    readonly children: readonly [
+        Identifier,
+        TypeAnnotation | undefined
+    ];
+    get parent(): CatchClause;
+    get name(): Identifier;
+    get typeAnnotation(): TypeAnnotation | undefined;
+    protected get thisAsNode(): Node;
+    constructor(name: Identifier, typeAnnotation: TypeAnnotation | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class FinallyClause extends BaseNode {
+    readonly kind = NodeKind.FinallyClause;
+    readonly children: readonly [
+        Keyword<KeywordKind.Finally>,
+        StatementBlock
+    ];
+    get parent(): TryStatement;
+    get finallyKeyword(): Keyword<KeywordKind.Finally>;
+    get block(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(finallyKeyword: Keyword<KeywordKind.Finally>, block: StatementBlock, rangeWithTrivia: Range | undefined);
+}
+export declare class ErrorStatement extends BaseNode {
+    readonly kind = NodeKind.ErrorStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Error>,
+        Expression
+    ];
+    get parent(): StatementParent;
+    get errorKeyword(): Keyword<KeywordKind.Error>;
+    get expression(): Expression;
+    protected get thisAsNode(): Node;
+    constructor(errorKeyword: Keyword<KeywordKind.Error>, expression: Expression, rangeWithTrivia: Range | undefined);
+}
+export declare class ImportantStatement extends BaseNode {
+    readonly kind = NodeKind.ImportantStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Important>,
+        Expression
+    ];
+    get parent(): StatementParent;
+    get importantKeyword(): Keyword<KeywordKind.Important>;
+    get expression(): Expression;
+    protected get thisAsNode(): Node;
+    constructor(importantKeyword: Keyword<KeywordKind.Important>, expression: Expression, rangeWithTrivia: Range | undefined);
+}
+export declare class ExpressionStatement extends BaseNode {
+    readonly kind = NodeKind.ExpressionStatement;
+    readonly children: readonly [
+        Expression
+    ];
+    get parent(): StatementParent;
+    get expression(): Expression;
+    protected get thisAsNode(): Node;
+    constructor(expression: Expression, rangeWithTrivia: Range | undefined);
+}
+export declare class ForStatement extends BaseNode {
+    readonly kind = NodeKind.ForStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.For>,
+        ForStatementVariableDeclaration,
+        ForStatementVariableDeclaration | undefined,
+        Keyword<KeywordKind.From>,
+        Expression,
+        StatementBlock
+    ];
+    get parent(): StatementParent;
+    get forKeyword(): Keyword<KeywordKind.For>;
+    get elementVariableDeclaration(): ForStatementVariableDeclaration;
+    get indexVariableDeclaration(): ForStatementVariableDeclaration | undefined;
+    get fromKeyword(): Keyword<KeywordKind.From>;
+    get enumeratedExpression(): Expression;
+    get block(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(forKeyword: Keyword<KeywordKind.For>, elementVariableDeclaration: ForStatementVariableDeclaration, indexVariableDeclaration: ForStatementVariableDeclaration | undefined, fromKeyword: Keyword<KeywordKind.From>, enumeratedExpression: Expression, block: StatementBlock, rangeWithTrivia: Range | undefined);
+}
+export declare class IfStatement extends BaseNode {
+    readonly kind = NodeKind.IfStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.If>,
+        Expression,
+        StatementBlock,
+        ElseIfClauseList,
+        ElseClause | undefined
+    ];
+    get parent(): StatementParent;
+    get ifKeyword(): Keyword<KeywordKind.If>;
+    get condition(): Expression;
+    get block(): StatementBlock;
+    get elseIfClauseList(): ElseIfClauseList;
+    get elseClause(): ElseClause | undefined;
+    protected get thisAsNode(): Node;
+    constructor(ifKeyword: Keyword<KeywordKind.If>, condition: Expression, block: StatementBlock, elseIfClauseList: ElseIfClauseList, elseClause: ElseClause | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class ElseIfClauseList extends BaseNode {
+    readonly kind = NodeKind.ElseIfClauseList;
+    readonly children: readonly ElseIfClause[];
+    get parent(): IfStatement;
+    get elseIfClauses(): readonly ElseIfClause[];
+    protected get thisAsNode(): Node;
+    constructor(elseIfClauses: readonly ElseIfClause[], rangeWithTrivia: Range | undefined);
+}
+export declare class ElseIfClause extends BaseNode {
+    readonly kind = NodeKind.ElseIfClause;
+    readonly children: readonly [
+        Keyword<KeywordKind.ElseIf>,
+        Expression,
+        StatementBlock
+    ];
+    get parent(): ElseIfClauseList;
+    get elseIfKeyword(): Keyword<KeywordKind.ElseIf>;
+    get condition(): Expression;
+    get block(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(elseIfKeyword: Keyword<KeywordKind.ElseIf>, condition: Expression, block: StatementBlock, rangeWithTrivia: Range | undefined);
+}
+export declare class ElseClause extends BaseNode {
+    readonly kind = NodeKind.ElseClause;
+    readonly children: readonly [
+        Keyword<KeywordKind.Else>,
+        StatementBlock
+    ];
+    get parent(): IfStatement;
+    get elseKeyword(): Keyword<KeywordKind.Else>;
+    get block(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(elseKeyword: Keyword<KeywordKind.Else>, block: StatementBlock, rangeWithTrivia: Range | undefined);
+}
+export declare class MissingStatement extends BaseNode {
+    readonly kind = NodeKind.MissingStatement;
+    get children(): readonly [];
+    get parent(): StatementParent;
+    protected get thisAsNode(): Node;
+    constructor(rangeWithTrivia: Range | undefined);
+}
+export declare class LocalVariableDeclarationStatement extends BaseNode {
+    readonly kind = NodeKind.LocalVariableDeclarationStatement;
+    readonly children: readonly [
+        LocalVariableDeclaration
+    ];
+    get parent(): StatementParent;
+    get declaration(): LocalVariableDeclaration;
+    protected get thisAsNode(): Node;
+    constructor(declaration: LocalVariableDeclaration, rangeWithTrivia: Range | undefined);
+}
+export declare class LocalStructuredTypeDeclarationStatement extends BaseNode {
+    readonly kind = NodeKind.LocalStructuredTypeDeclarationStatement;
+    readonly children: readonly [
+        LocalStructuredTypeDeclaration
+    ];
+    get parent(): StatementParent;
+    get declaration(): LocalStructuredTypeDeclaration;
+    protected get thisAsNode(): Node;
+    constructor(declaration: LocalStructuredTypeDeclaration, rangeWithTrivia: Range | undefined);
+}
+export declare class LoopStatement extends BaseNode {
+    readonly kind = NodeKind.LoopStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Loop>,
+        StatementBlock
+    ];
+    get parent(): StatementParent;
+    get loopKeyword(): Keyword<KeywordKind.Loop>;
+    get block(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(loopKeyword: Keyword<KeywordKind.Loop>, block: StatementBlock, rangeWithTrivia: Range | undefined);
+}
+export declare class ReturnStatement extends BaseNode {
+    readonly kind = NodeKind.ReturnStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Return>,
+        Expression | undefined
+    ];
+    get parent(): StatementParent;
+    get returnKeyword(): Keyword<KeywordKind.Return>;
+    get expression(): Expression | undefined;
+    protected get thisAsNode(): Node;
+    constructor(returnKeyword: Keyword<KeywordKind.Return>, expression: Expression | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class CaseClauseList extends BaseNode {
+    readonly kind = NodeKind.CaseClauseList;
+    readonly children: readonly CaseClause[];
+    get parent(): SwitchStatement;
+    get caseClauses(): readonly CaseClause[];
+    protected get thisAsNode(): Node;
+    constructor(caseClauses: readonly CaseClause[], rangeWithTrivia: Range | undefined);
+}
+export declare class SwitchStatement extends BaseNode {
+    readonly kind = NodeKind.SwitchStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Switch>,
+        Expression,
+        CaseClauseList
+    ];
+    get parent(): StatementParent;
+    get switchKeyword(): Keyword<KeywordKind.Switch>;
+    get expression(): Expression;
+    get caseClauseList(): CaseClauseList;
+    protected get thisAsNode(): Node;
+    constructor(switchKeyword: Keyword<KeywordKind.Switch>, expression: Expression, caseClauseList: CaseClauseList, rangeWithTrivia: Range | undefined);
+}
+export declare class MatchExpressionGroup extends BaseNode {
+    readonly kind = NodeKind.MatchExpressionGroup;
+    readonly children: readonly [
+        Token<TokenKind.OpenParenthesis>,
+        MatchExpressionList,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get parent(): CaseClause;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get matchExpressionList(): MatchExpressionList;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Node;
+    constructor(openParenthesisToken: Token<TokenKind.OpenParenthesis>, matchExpressionList: MatchExpressionList, closeParenthesisToken: Token<TokenKind.CloseParenthesis>, rangeWithTrivia: Range | undefined);
+}
+export declare class MatchExpressionList extends BaseNode {
+    readonly kind = NodeKind.MatchExpressionList;
+    readonly children: readonly ExpressionListElement[];
+    get parent(): MatchExpressionGroup;
+    get elements(): readonly ExpressionListElement[];
+    get matchExpressions(): Query<Expression>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly ExpressionListElement[], rangeWithTrivia: Range | undefined);
+}
+export declare class CaseClause extends BaseNode {
+    readonly kind = NodeKind.CaseClause;
+    readonly children: readonly [
+        Keyword<KeywordKind.Case>,
+        Expression | MatchExpressionGroup,
+        StatementBlock
+    ];
+    get parent(): CaseClauseList;
+    get caseKeyword(): Keyword<KeywordKind.Case>;
+    get matchExpressionOrGroup(): Expression | MatchExpressionGroup;
+    get block(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(caseKeyword: Keyword<KeywordKind.Case>, matchExpressionOrGroup: Expression | MatchExpressionGroup, block: StatementBlock, rangeWithTrivia: Range | undefined);
+}
+export declare class WhileStatement extends BaseNode {
+    readonly kind = NodeKind.WhileStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.While>,
+        Expression,
+        StatementBlock
+    ];
+    get parent(): StatementParent;
+    get whileKeyword(): Keyword<KeywordKind.While>;
+    get condition(): Expression;
+    get block(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(whileKeyword: Keyword<KeywordKind.While>, condition: Expression, block: StatementBlock, rangeWithTrivia: Range | undefined);
+}
+export declare class YieldStatement extends BaseNode {
+    readonly kind = NodeKind.YieldStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Yield>,
+        Expression
+    ];
+    get parent(): StatementParent;
+    get yieldKeyword(): Keyword<KeywordKind.Yield>;
+    get expression(): Expression;
+    protected get thisAsNode(): Node;
+    constructor(yieldKeyword: Keyword<KeywordKind.Yield>, expression: Expression, rangeWithTrivia: Range | undefined);
+}
+export declare class NestedFunctionDeclarationStatement extends BaseNode {
+    readonly kind = NodeKind.NestedFunctionDeclarationStatement;
+    readonly children: readonly [
+        NestedFunctionDeclaration
+    ];
+    get parent(): StatementParent;
+    get declaration(): NestedFunctionDeclaration;
+    protected get thisAsNode(): Node;
+    constructor(declaration: NestedFunctionDeclaration, rangeWithTrivia: Range | undefined);
+}
+export declare class TranslationsDeclaration extends BaseNode {
+    readonly kind = NodeKind.TranslationsDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Translations>,
+        Token<TokenKind.OpenBrace>,
+        TopLevelTranslationList,
+        Token<TokenKind.CloseBrace>
+    ];
+    get parent(): PackageMemberDeclarationList;
+    get tagList(): TagList;
+    get translationsKeyword(): Keyword<KeywordKind.Translations>;
+    get openBraceToken(): Token<TokenKind.OpenBrace>;
+    get translationList(): TopLevelTranslationList;
+    get closeBraceToken(): Token<TokenKind.CloseBrace>;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, translationsKeyword: Keyword<KeywordKind.Translations>, openBraceToken: Token<TokenKind.OpenBrace>, translationList: TopLevelTranslationList, closeBraceToken: Token<TokenKind.CloseBrace>, rangeWithTrivia: Range | undefined);
+}
+export type TopLevelTranslationListElement = TranslationDeclaration | Semicolon;
+export declare class TopLevelTranslationList extends BaseNode {
+    readonly kind = NodeKind.TopLevelTranslationList;
+    readonly children: readonly TopLevelTranslationListElement[];
+    get parent(): TranslationsDeclaration;
+    get elements(): readonly TopLevelTranslationListElement[];
+    get translationDeclarations(): Query<TranslationDeclaration>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly TopLevelTranslationListElement[], rangeWithTrivia: Range | undefined);
+}
+export type TranslationDeclaration = PackageVariableTranslationDeclaration | PackageFunctionTranslationDeclaration | TypeTranslationDeclaration | FunctionTypeTranslationDeclaration | TextTranslationDeclaration | TextTranslationFunctionDeclaration;
+export type TranslationParameterListParent = TranslationParameterClause | IndexParameterTranslationClause;
+export declare class TranslationParameterList extends BaseNode {
+    readonly kind = NodeKind.TranslationParameterList;
+    readonly children: readonly IdentifierListElement[];
+    get parent(): TranslationParameterListParent;
+    get elements(): readonly IdentifierListElement[];
+    get parameters(): Query<Identifier>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly IdentifierListElement[], rangeWithTrivia: Range | undefined);
+}
+export type TranslationParameterClauseParent = PackageFunctionTranslationDeclaration | MethodTranslation | FunctionTypeTranslationDeclaration;
+export declare class TranslationParameterClause extends BaseNode {
+    readonly kind = NodeKind.TranslationParameterClause;
+    readonly children: readonly [
+        Token<TokenKind.OpenParenthesis>,
+        TranslationParameterList,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get parent(): TranslationParameterClauseParent;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get parameterList(): TranslationParameterList;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Node;
+    constructor(openParenthesisToken: Token<TokenKind.OpenParenthesis>, parameterList: TranslationParameterList, closeParenthesisToken: Token<TokenKind.CloseParenthesis>, rangeWithTrivia: Range | undefined);
+}
+export declare class IndexParameterTranslationClause extends BaseNode {
+    readonly kind = NodeKind.IndexParameterTranslationClause;
+    readonly children: readonly [
+        Token<TokenKind.OpenSquareBracket>,
+        TranslationParameterList,
+        Token<TokenKind.CloseSquareBracket>
+    ];
+    get parent(): IndexerTranslation;
+    get openSquareBracketToken(): Token<TokenKind.OpenSquareBracket>;
+    get parameterList(): TranslationParameterList;
+    get closeSquareBracketToken(): Token<TokenKind.CloseSquareBracket>;
+    protected get thisAsNode(): Node;
+    constructor(openSquareBracketToken: Token<TokenKind.OpenSquareBracket>, parameterList: TranslationParameterList, closeSquareBracketToken: Token<TokenKind.CloseSquareBracket>, rangeWithTrivia: Range | undefined);
+}
+export declare class IndexerTranslation extends BaseNode {
+    readonly kind = NodeKind.IndexerTranslation;
+    readonly children: readonly [
+        IndexParameterTranslationClause,
+        Token<TokenKind.Minus>,
+        IndexParameterTranslationClause
+    ];
+    get parent(): TypeMemberTranslationList;
+    get sourceParameterClause(): IndexParameterTranslationClause;
+    get minusToken(): Token<TokenKind.Minus>;
+    get translatedParameterClause(): IndexParameterTranslationClause;
+    protected get thisAsNode(): Node;
+    constructor(sourceParameterClause: IndexParameterTranslationClause, minusToken: Token<TokenKind.Minus>, translatedParameterClause: IndexParameterTranslationClause, rangeWithTrivia: Range | undefined);
+}
+export declare class TranslationTypeParameterList extends BaseNode {
+    readonly kind = NodeKind.TranslationTypeParameterList;
+    readonly children: readonly IdentifierListElement[];
+    get parent(): TranslationTypeParameterClause;
+    get elements(): readonly IdentifierListElement[];
+    get typeParameters(): Query<Identifier>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly IdentifierListElement[], rangeWithTrivia: Range | undefined);
+}
+export type TranslationTypeParameterClauseParent = PackageFunctionTranslationDeclaration | MethodTranslation | FunctionTypeTranslationDeclaration | TypeTranslationDeclaration;
+export declare class TranslationTypeParameterClause extends BaseNode {
+    readonly kind = NodeKind.TranslationTypeParameterClause;
+    readonly children: readonly [
+        Token<TokenKind.LessThan>,
+        TranslationTypeParameterList,
+        Token<TokenKind.GreaterThan>
+    ];
+    get parent(): TranslationTypeParameterClauseParent;
+    get lessThanToken(): Token<TokenKind.LessThan>;
+    get typeParameterList(): TranslationTypeParameterList;
+    get greaterThanToken(): Token<TokenKind.GreaterThan>;
+    protected get thisAsNode(): Node;
+    constructor(lessThanToken: Token<TokenKind.LessThan>, typeParameterList: TranslationTypeParameterList, greaterThanToken: Token<TokenKind.GreaterThan>, rangeWithTrivia: Range | undefined);
+}
+export declare class PackageFunctionTranslationDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageFunctionTranslationDeclaration;
+    readonly children: readonly [
+        Keyword<KeywordKind.Function>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        TranslationParameterClause,
+        Token<TokenKind.Minus>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        TranslationParameterClause
+    ];
+    get parent(): TopLevelTranslationList;
+    get functionKeyword(): Keyword<KeywordKind.Function>;
+    get sourceName(): Identifier;
+    get sourceTypeParameterClause(): TranslationTypeParameterClause | undefined;
+    get sourceParameterClause(): TranslationParameterClause;
+    get minusToken(): Token<TokenKind.Minus>;
+    get translatedName(): Identifier;
+    get translatedTypeParameterClause(): TranslationTypeParameterClause | undefined;
+    get translatedParameterClause(): TranslationParameterClause;
+    protected get thisAsNode(): Node;
+    constructor(functionKeyword: Keyword<KeywordKind.Function>, sourceName: Identifier, sourceTypeParameterClause: TranslationTypeParameterClause | undefined, sourceParameterClause: TranslationParameterClause, minusToken: Token<TokenKind.Minus>, translatedName: Identifier, translatedTypeParameterClause: TranslationTypeParameterClause | undefined, translatedParameterClause: TranslationParameterClause, rangeWithTrivia: Range | undefined);
+}
+export declare class MethodTranslation extends BaseNode {
+    readonly kind = NodeKind.MethodTranslation;
+    readonly children: readonly [
+        Keyword<KeywordKind.Function>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        TranslationParameterClause,
+        Token<TokenKind.Minus>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        TranslationParameterClause
+    ];
+    get parent(): TypeMemberTranslationList;
+    get functionKeyword(): Keyword<KeywordKind.Function>;
+    get sourceName(): Identifier;
+    get sourceTypeParameterClause(): TranslationTypeParameterClause | undefined;
+    get sourceParameterClause(): TranslationParameterClause;
+    get minusToken(): Token<TokenKind.Minus>;
+    get translatedName(): Identifier;
+    get translatedTypeParameterClause(): TranslationTypeParameterClause | undefined;
+    get translatedParameterClause(): TranslationParameterClause;
+    protected get thisAsNode(): Node;
+    constructor(functionKeyword: Keyword<KeywordKind.Function>, sourceName: Identifier, sourceTypeParameterClause: TranslationTypeParameterClause | undefined, sourceParameterClause: TranslationParameterClause, minusToken: Token<TokenKind.Minus>, translatedName: Identifier, translatedTypeParameterClause: TranslationTypeParameterClause | undefined, translatedParameterClause: TranslationParameterClause, rangeWithTrivia: Range | undefined);
+}
+export declare class FunctionTypeTranslationDeclaration extends BaseNode {
+    readonly kind = NodeKind.FunctionTypeTranslationDeclaration;
+    readonly children: readonly [
+        Keyword<KeywordKind.Type>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        TranslationParameterClause,
+        Token<TokenKind.Minus>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        TranslationParameterClause
+    ];
+    get parent(): TopLevelTranslationList;
+    get typeKeyword(): Keyword<KeywordKind.Type>;
+    get sourceName(): Identifier;
+    get sourceTypeParameterClause(): TranslationTypeParameterClause | undefined;
+    get sourceParameterClause(): TranslationParameterClause;
+    get minusToken(): Token<TokenKind.Minus>;
+    get translatedName(): Identifier;
+    get translatedTypeParameterClause(): TranslationTypeParameterClause | undefined;
+    get translatedParameterClause(): TranslationParameterClause;
+    protected get thisAsNode(): Node;
+    constructor(typeKeyword: Keyword<KeywordKind.Type>, sourceName: Identifier, sourceTypeParameterClause: TranslationTypeParameterClause | undefined, sourceParameterClause: TranslationParameterClause, minusToken: Token<TokenKind.Minus>, translatedName: Identifier, translatedTypeParameterClause: TranslationTypeParameterClause | undefined, translatedParameterClause: TranslationParameterClause, rangeWithTrivia: Range | undefined);
+}
+export type QualifiedNamePart = Identifier | Token<TokenKind.Dot>;
+export type QualifiedNameParent = NamedTypeSpecifier | Tag | StaticNameClause;
+export declare class QualifiedName extends BaseNode {
+    readonly kind = NodeKind.QualifiedName;
+    readonly children: readonly QualifiedNamePart[];
+    get parent(): QualifiedNameParent;
+    get parts(): readonly QualifiedNamePart[];
+    get qualifiers(): Query<Identifier>;
+    protected get thisAsNode(): Node;
+    constructor(parts: readonly QualifiedNamePart[], rangeWithTrivia: Range | undefined);
+}
+export declare class PackageVariableTranslationDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageVariableTranslationDeclaration;
+    readonly children: readonly [
+        Identifier,
+        Token<TokenKind.Minus>,
+        Identifier
+    ];
+    get parent(): TopLevelTranslationList;
+    get sourceName(): Identifier;
+    get minusToken(): Token<TokenKind.Minus>;
+    get translatedName(): Identifier;
+    protected get thisAsNode(): Node;
+    constructor(sourceName: Identifier, minusToken: Token<TokenKind.Minus>, translatedName: Identifier, rangeWithTrivia: Range | undefined);
+}
+export declare class FieldOrVariantTranslation extends BaseNode {
+    readonly kind = NodeKind.FieldOrVariantTranslation;
+    readonly children: readonly [
+        Identifier,
+        Token<TokenKind.Minus>,
+        Identifier
+    ];
+    get parent(): TypeMemberTranslationList;
+    get sourceName(): Identifier;
+    get minusToken(): Token<TokenKind.Minus>;
+    get translatedName(): Identifier;
+    protected get thisAsNode(): Node;
+    constructor(sourceName: Identifier, minusToken: Token<TokenKind.Minus>, translatedName: Identifier, rangeWithTrivia: Range | undefined);
+}
+export type TypeMemberTranslationListElement = TypeMemberTranslation | Semicolon;
+export declare class TypeMemberTranslationList extends BaseNode {
+    readonly kind = NodeKind.TypeMemberTranslationList;
+    readonly children: readonly TypeMemberTranslationListElement[];
+    get parent(): TypeTranslationDeclaration;
+    get elements(): readonly TypeMemberTranslationListElement[];
+    get members(): Query<TypeMemberTranslation>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly TypeMemberTranslationListElement[], rangeWithTrivia: Range | undefined);
+}
+export declare class TypeTranslationDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeTranslationDeclaration;
+    readonly children: readonly [
+        Keyword<KeywordKind.Type>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        Token<TokenKind.Minus>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        Token<TokenKind.OpenBrace> | undefined,
+        TypeMemberTranslationList | undefined,
+        Token<TokenKind.CloseBrace> | undefined
+    ];
+    get parent(): TopLevelTranslationList;
+    get typeKeyword(): Keyword<KeywordKind.Type>;
+    get sourceName(): Identifier;
+    get sourceTypeParameterClause(): TranslationTypeParameterClause | undefined;
+    get minusToken(): Token<TokenKind.Minus>;
+    get translatedName(): Identifier;
+    get translatedTypeParameterClause(): TranslationTypeParameterClause | undefined;
+    get openBraceToken(): Token<TokenKind.OpenBrace> | undefined;
+    get memberList(): TypeMemberTranslationList | undefined;
+    get closeBraceToken(): Token<TokenKind.CloseBrace> | undefined;
+    protected get thisAsNode(): Node;
+    constructor(typeKeyword: Keyword<KeywordKind.Type>, sourceName: Identifier, sourceTypeParameterClause: TranslationTypeParameterClause | undefined, minusToken: Token<TokenKind.Minus>, translatedName: Identifier, translatedTypeParameterClause: TranslationTypeParameterClause | undefined, openBraceToken: Token<TokenKind.OpenBrace> | undefined, memberList: TypeMemberTranslationList | undefined, closeBraceToken: Token<TokenKind.CloseBrace> | undefined, rangeWithTrivia: Range | undefined);
+}
+export type TypeMemberTranslation = FieldOrVariantTranslation | MethodTranslation | IndexerTranslation;
+export type TextTranslationSource = TranslationTextLiteral | TranslationTextTemplate;
+export type TextTranslationTarget = TextLiteral | LocalizableTextLiteral | TextTemplateLiteral | LocalizableTextTemplateLiteral;
+export declare class TextTranslationDeclaration extends BaseNode {
+    readonly kind = NodeKind.TextTranslationDeclaration;
+    readonly children: readonly [
+        TextTranslationSource,
+        Token<TokenKind.Minus>,
+        TextTranslationTarget
+    ];
+    get parent(): TopLevelTranslationList;
+    get sourceText(): TextTranslationSource;
+    get minusToken(): Token<TokenKind.Minus>;
+    get targetText(): TextTranslationTarget;
+    protected get thisAsNode(): Node;
+    constructor(sourceText: TextTranslationSource, minusToken: Token<TokenKind.Minus>, translatedTextOrTranslationFunction: TextTranslationTarget, rangeWithTrivia: Range | undefined);
+}
+export declare class TextTranslationFunctionDeclaration extends BaseNode {
+    readonly kind = NodeKind.TextTranslationFunctionDeclaration;
+    readonly children: readonly [
+        TextTranslationSource,
+        Token<TokenKind.Minus>,
+        FunctionBlock
+    ];
+    get parent(): TopLevelTranslationList;
+    get sourceText(): TextTranslationSource;
+    get minusToken(): Token<TokenKind.Minus>;
+    get block(): FunctionBlock;
+    protected get thisAsNode(): Node;
+    constructor(sourceText: TextTranslationSource, minusToken: Token<TokenKind.Minus>, block: FunctionBlock, rangeWithTrivia: Range | undefined);
+}
+export type TranslationTextParent = TextTranslationDeclaration | TextTranslationFunctionDeclaration;
+export declare class TranslationTextLiteral extends BaseNode {
+    readonly kind = NodeKind.TranslationTextLiteral;
+    readonly children: readonly [
+        Token<TokenKind.TextLiteral>,
+        Token<TokenKind.TextLiteralSuffix> | undefined
+    ];
+    get parent(): TranslationTextParent;
+    get text(): Token<TokenKind.TextLiteral>;
+    get suffix(): Token<TokenKind.TextLiteralSuffix> | undefined;
+    protected get thisAsNode(): Node;
+    constructor(text: Token<TokenKind.TextLiteral>, suffix: Token<TokenKind.TextLiteralSuffix> | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class TranslationTextTemplate extends BaseNode {
+    readonly kind = NodeKind.TranslationTextTemplate;
+    readonly children: readonly [
+        TextTemplateHead,
+        TranslationTextTemplateSpanList,
+        Token<TokenKind.TextLiteralSuffix> | undefined
+    ];
+    get parent(): TranslationTextParent;
+    get head(): TextTemplateHead;
+    get spanList(): TranslationTextTemplateSpanList;
+    get suffix(): Token<TokenKind.TextLiteralSuffix> | undefined;
+    protected get thisAsNode(): Node;
+    constructor(head: TextTemplateHead, spanList: TranslationTextTemplateSpanList, code: Token<TokenKind.TextLiteralSuffix> | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class TranslationTextTemplateSpanList extends BaseNode {
+    readonly kind = NodeKind.TranslationTextTemplateSpanList;
+    readonly children: readonly TranslationTextTemplateSpan[];
+    get parent(): TranslationTextTemplate;
+    get spans(): readonly TranslationTextTemplateSpan[];
+    protected get thisAsNode(): Node;
+    constructor(spans: readonly TranslationTextTemplateSpan[], rangeWithTrivia: Range | undefined);
+}
+export declare class TranslationTextTemplateSpan extends BaseNode {
+    readonly kind = NodeKind.TranslationTextTemplateSpan;
+    readonly children: readonly [
+        TranslationTextTemplateParameter,
+        TextTemplatePart | TextTemplateTail
+    ];
+    get parent(): TranslationTextTemplateSpanList;
+    get parameter(): TranslationTextTemplateParameter;
+    get text(): TextTemplatePart | TextTemplateTail;
+    protected get thisAsNode(): Node;
+    constructor(parameter: TranslationTextTemplateParameter, text: TextTemplatePart | TextTemplateTail, rangeWithTrivia: Range | undefined);
+}
+export declare class TranslationTextTemplateParameter extends BaseNode {
+    readonly kind = NodeKind.TranslationTextTemplateParameter;
+    readonly children: readonly [
+        Identifier,
+        TypeAnnotation | undefined
+    ];
+    get parent(): TranslationTextTemplateSpan;
+    get name(): Identifier;
+    get typeAnnotation(): TypeAnnotation | undefined;
+    protected get thisAsNode(): Node;
+    constructor(name: Identifier, typeAnnotation: TypeAnnotation | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class VariantValueDeclaration extends BaseNode {
+    readonly kind = NodeKind.VariantValueDeclaration;
+    readonly children: readonly [
+        TagList,
+        Keyword<KeywordKind.Case>,
+        Identifier,
+        VariableInitializer | undefined
+    ];
+    get parent(): TypeMemberDeclarationList;
+    get tagList(): TagList;
+    get caseKeyword(): Keyword<KeywordKind.Case>;
+    get name(): Identifier;
+    get initializer(): VariableInitializer | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, caseKeyword: Keyword<KeywordKind.Case>, name: Identifier, initializer: VariableInitializer | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class TypeParameterDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeParameterDeclaration;
+    readonly children: readonly [
+        Keyword<KeywordKind.Type>,
+        Identifier,
+        Token<TokenKind.Colon> | undefined,
+        TypeSpecifier | undefined,
+        Token<TokenKind.Equals> | undefined,
+        TypeSpecifier | undefined
+    ];
+    get parent(): TypeParameterDeclarationList;
+    get typeKeyword(): Keyword<KeywordKind.Type>;
+    get name(): Identifier;
+    get colonToken(): Token<TokenKind.Colon> | undefined;
+    get constraint(): TypeSpecifier | undefined;
+    get equalsToken(): Token<TokenKind.Equals> | undefined;
+    get defaultType(): TypeSpecifier | undefined;
+    protected get thisAsNode(): Node;
+    constructor(typeKeyword: Keyword<KeywordKind.Type>, name: Identifier, colonToken: Token<TokenKind.Colon> | undefined, constraint: TypeSpecifier | undefined, equalsToken: Token<TokenKind.Equals> | undefined, defaultType: TypeSpecifier | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class TypeParameterReference extends BaseNode {
+    readonly kind = NodeKind.TypeParameterReference;
+    readonly children: readonly [
+        Keyword<KeywordKind.Type>,
+        Identifier
+    ];
+    get parent(): TypeParameterReferenceList;
+    get typeKeyword(): Keyword<KeywordKind.Type>;
+    get name(): Identifier;
+    protected get thisAsNode(): Node;
+    constructor(typeKeyword: Keyword<KeywordKind.Type>, name: Identifier, rangeWithTrivia: Range | undefined);
+}
+export declare class ParameterDeclaration extends BaseNode {
+    readonly kind = NodeKind.ParameterDeclaration;
+    readonly children: readonly [
+        TagList,
+        Identifier,
+        TypeAnnotation | undefined,
+        VariableInitializer | undefined
+    ];
+    get parent(): ParameterList;
+    get tagList(): TagList;
+    get name(): Identifier;
+    get typeAnnotation(): TypeAnnotation | undefined;
+    get initializer(): VariableInitializer | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, name: Identifier, typeAnnotation: TypeAnnotation | undefined, initializer: VariableInitializer | undefined, rangeWithTrivia: Range | undefined);
+}
+export declare class Argument extends BaseNode {
+    readonly kind = NodeKind.Argument;
+    readonly children: readonly [
+        Identifier | undefined,
+        Token<TokenKind.Equals> | undefined,
+        Expression
+    ];
+    get parent(): ArgumentList;
+    get name(): Identifier | undefined;
+    get equalsToken(): Token<TokenKind.Equals> | undefined;
+    get value(): Expression;
+    protected get thisAsNode(): Node;
+    constructor(name: Identifier | undefined, equalsToken: Token<TokenKind.Equals> | undefined, value: Expression, rangeWithTrivia: Range | undefined);
+}
+export type TagListParent = PackageMemberDeclaration | TypeMemberDeclaration | ParameterDeclaration;
+export declare class TagList extends BaseNode {
+    readonly kind = NodeKind.TagList;
+    readonly children: readonly Tag[];
+    get parent(): TagListParent;
+    get tags(): readonly Tag[];
+    protected get thisAsNode(): Node;
+    constructor(tags: readonly Tag[], rangeWithTrivia: Range | undefined);
+}
+export declare class Tag extends BaseNode {
+    readonly kind = NodeKind.Tag;
+    readonly children: readonly [
+        Token<TokenKind.HashSign>,
+        QualifiedName,
+        TypeArgumentClause | undefined,
+        Token<TokenKind.OpenParenthesis> | undefined,
+        ArgumentList | undefined,
+        Token<TokenKind.CloseParenthesis> | undefined
+    ];
+    get parent(): TagList;
+    get hashSignToken(): Token<TokenKind.HashSign>;
+    get name(): QualifiedName;
+    get typeArgumentClause(): TypeArgumentClause | undefined;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis> | undefined;
+    get argumentList(): ArgumentList | undefined;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis> | undefined;
+    protected get thisAsNode(): Node;
+    constructor(hashSignToken: Token<TokenKind.HashSign>, name: QualifiedName, typeArgumentClause: TypeArgumentClause | undefined, openParenthesisToken: Token<TokenKind.OpenParenthesis> | undefined, argumentList: ArgumentList | undefined, closeParenthesisToken: Token<TokenKind.CloseParenthesis> | undefined, rangeWithTrivia: Range | undefined);
+}
+export type ParameterClauseParent = PackageFunctionDeclaration | NestedFunctionDeclaration | FunctionLiteral | MethodDeclaration | LocalFunctionTypeDeclaration | IndexedElementGetterDeclaration | IndexedElementSetterDeclaration | StaticMethodDeclaration | FieldGetterDeclaration | FieldSetterDeclaration | StaticFieldGetterDeclaration | StaticFieldSetterDeclaration | PackageVariableGetterDeclaration | PackageVariableSetterDeclaration;
+export declare class ParameterClause extends BaseNode {
+    readonly kind = NodeKind.ParameterClause;
+    readonly children: readonly [
+        Token<TokenKind.OpenParenthesis>,
+        ParameterList,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get parent(): ParameterClauseParent;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get parameterList(): ParameterList;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Node;
+    constructor(openParenthesisToken: Token<TokenKind.OpenParenthesis>, parameterList: ParameterList, closeParenthesisToken: Token<TokenKind.CloseParenthesis>, rangeWithTrivia: Range | undefined);
+}
+export type ParameterListElement = ParameterDeclaration | Comma;
+export type ParameterListParent = ParameterClause;
+export declare class ParameterList extends BaseNode {
+    readonly kind = NodeKind.ParameterList;
+    readonly children: readonly ParameterListElement[];
+    get parent(): ParameterListParent;
+    get elements(): readonly ParameterListElement[];
+    get parameters(): Query<ParameterDeclaration>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly ParameterListElement[], rangeWithTrivia: Range | undefined);
+}
+export type TypeArgumentClauseParent = NamedTypeSpecifier | GenericSpecializationExpression | Tag;
+export declare class TypeArgumentClause extends BaseNode {
+    readonly kind = NodeKind.TypeArgumentClause;
+    readonly children: readonly [
+        Token<TokenKind.LessThan>,
+        TypeArgumentList,
+        Token<TokenKind.GreaterThan>
+    ];
+    get parent(): TypeArgumentClauseParent;
+    get lessThanToken(): Token<TokenKind.LessThan>;
+    get typeArgumentList(): TypeArgumentList;
+    get greaterThanToken(): Token<TokenKind.GreaterThan>;
+    protected get thisAsNode(): Node;
+    constructor(lessThanToken: Token<TokenKind.LessThan>, typeArgumentList: TypeArgumentList, greaterThanToken: Token<TokenKind.GreaterThan>, rangeWithTrivia: Range | undefined);
+}
+export type TypeArgumentListElement = TypeSpecifier | Comma;
+export declare class TypeArgumentList extends BaseNode {
+    readonly kind = NodeKind.TypeArgumentList;
+    readonly children: readonly TypeArgumentListElement[];
+    get parent(): TypeArgumentClause;
+    get elements(): readonly TypeArgumentListElement[];
+    get typeArguments(): Query<TypeSpecifier>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly TypeArgumentListElement[], rangeWithTrivia: Range | undefined);
+}
+export type TypeParameterClauseParent = PackageAliasTypeDeclaration | PackageFunctionDeclaration | MethodDeclaration | NestedFunctionDeclaration | PackageTypeDeclaration | StaticMethodDeclaration;
+export declare class TypeParameterClause extends BaseNode {
+    readonly kind = NodeKind.TypeParameterClause;
+    readonly children: readonly [
+        Token<TokenKind.LessThan>,
+        TypeParameterDeclarationList,
+        Token<TokenKind.GreaterThan>
+    ];
+    get parent(): TypeParameterClauseParent;
+    get lessThanToken(): Token<TokenKind.LessThan>;
+    get typeParameterList(): TypeParameterDeclarationList;
+    get greaterThanToken(): Token<TokenKind.GreaterThan>;
+    protected get thisAsNode(): Node;
+    constructor(lessThanToken: Token<TokenKind.LessThan>, typeParameterList: TypeParameterDeclarationList, greaterThanToken: Token<TokenKind.GreaterThan>, rangeWithTrivia: Range | undefined);
+}
+export type TypeParameterDeclarationListElement = TypeParameterDeclaration | Comma;
+export declare class TypeParameterDeclarationList extends BaseNode {
+    readonly kind = NodeKind.TypeParameterDeclarationList;
+    readonly children: readonly TypeParameterDeclarationListElement[];
+    get parent(): TypeParameterClause;
+    get elements(): readonly TypeParameterDeclarationListElement[];
+    get typeParameters(): Query<TypeParameterDeclaration>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly TypeParameterDeclarationListElement[], rangeWithTrivia: Range | undefined);
+}
+export type TypeParameterReferenceListElement = TypeParameterReference | Comma;
+export declare class TypeParameterReferenceList extends BaseNode {
+    readonly kind = NodeKind.TypeParameterReferenceList;
+    readonly children: readonly TypeParameterReferenceListElement[];
+    get parent(): StaticNameClause;
+    get elements(): readonly TypeParameterReferenceListElement[];
+    get typeParameters(): Query<TypeParameterReference>;
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly TypeParameterReferenceListElement[], rangeWithTrivia: Range | undefined);
+}
+export type TypeAnnotationParent = PackageFunctionDeclaration | PackageVariableDeclaration | PackageVariableGetterDeclaration | PackageVariableSetterDeclaration | NestedFunctionDeclaration | LocalVariableDeclaration | FunctionLiteral | ParameterDeclaration | IndexedElementGetterDeclaration | IndexedElementSetterDeclaration | MethodDeclaration | FieldDeclaration | FieldGetterDeclaration | FieldSetterDeclaration | ErrorVariableDeclaration | TranslationTextTemplateParameter | LocalFunctionTypeDeclaration | StaticMethodDeclaration | StaticFieldDeclaration | StaticFieldGetterDeclaration | StaticFieldSetterDeclaration;
+export declare class TypeAnnotation extends BaseNode {
+    readonly kind = NodeKind.TypeAnnotation;
+    readonly children: readonly [
+        Token<TokenKind.Colon>,
+        TypeSpecifier
+    ];
+    get parent(): TypeAnnotationParent;
+    get colonToken(): Token<TokenKind.Colon>;
+    get typeSpecifier(): TypeSpecifier;
+    protected get thisAsNode(): Node;
+    constructor(colonToken: Token<TokenKind.Colon>, typeSpecifier: TypeSpecifier, rangeWithTrivia: Range | undefined);
+}
+export declare class VariableInitializer extends BaseNode {
+    readonly kind = NodeKind.VariableInitializer;
+    readonly children: readonly [
+        Token<TokenKind.Equals>,
+        Expression
+    ];
+    get parent(): VariableInitializerParent;
+    get equalsToken(): Token<TokenKind.Equals>;
+    get value(): Expression;
+    protected get thisAsNode(): Node;
+    constructor(equalsToken: Token<TokenKind.Equals>, expression: Expression, rangeWithTrivia: Range | undefined);
 }
-export type Node = SourceFile | Token;
+export type LocalStructuredTypeDeclarationParent = LocalStructuredTypeDeclarationStatement | LocalTypeSpecifier;
+export type VariableInitializerParent = ParameterDeclaration | FieldDeclaration | LocalVariableDeclaration | PackageVariableDeclaration | VariantValueDeclaration | StaticFieldDeclaration;
+export type Node = SourceFile | Token | Keyword | Argument | ArgumentList | ArrayLiteral | ArrayLiteralElementList | AssignmentStatement | AssumptionExpression | BaseExpression | BaseTypeList | BinaryExpression | BreakLoopStatement | CallExpression | CaseClause | CaseClauseList | CatchClause | ConditionalExpression | ContinueLoopStatement | DefaultMatchExpression | DereferenceExpression | DisposeStatement | ElseClause | ElseIfClause | ElseIfClauseList | ErrorStatement | ErrorVariableDeclaration | ExpressionStatement | ExtendsClause | FieldDeclaration | FieldGetterDeclaration | FieldOrVariantTranslation | FieldSetterDeclaration | FinallyClause | ForStatement | ForStatementVariableDeclaration | FunctionBlock | FunctionBlockLiteral | FunctionLiteral | FunctionTypeTranslationDeclaration | GenericSpecializationExpression | IdentifierExpression | IfStatement | ImportantStatement | IndexParameterTranslationClause | IndexedAccessExpression | IndexedElementGetterDeclaration | IndexedElementSetterDeclaration | IndexerTranslation | KeywordExpression | LocalFunctionTypeDeclaration | LocalStructuredTypeDeclaration | LocalStructuredTypeDeclarationStatement | LocalTypeSpecifier | LocalVariableDeclaration | LocalVariableDeclarationStatement | LocalizableTextLiteral | LocalizableTextTemplateLiteral | LoopStatement | MatchExpressionGroup | MatchExpressionList | MemberAccessExpression | MethodDeclaration | MethodTranslation | MissingExpression | MissingPackageMemberDeclaration | MissingStatement | MissingTypeMemberDeclaration | MissingTypeSpecifier | NamedTypeSpecifier | NestedFunctionDeclaration | NestedFunctionDeclarationStatement | NullableTypeSpecifier | ObjectExpression | PackageAliasTypeDeclaration | PackageFunctionDeclaration | PackageFunctionTranslationDeclaration | PackageImport | PackageImportDirective | PackageImportDirectiveList | PackageImportList | PackageMemberDeclarationList | PackageMemberGroupDeclaration | PackageName | PackageStatement | PackageTypeDeclaration | PackageVariableDeclaration | PackageVariableGetterDeclaration | PackageVariableSetterDeclaration | PackageVariableTranslationDeclaration | ParameterClause | ParameterDeclaration | ParameterList | ParenthesizedExpression | ParenthesizedTypeSpecifier | PrefixUnaryExpression | QualifiedName | ReferenceExpression | ReturnStatement | RunStatement | StatementBlock | StatementList | StaticFieldDeclaration | StaticFieldGetterDeclaration | StaticFieldSetterDeclaration | StaticMethodDeclaration | StaticNameClause | SwitchStatement | Tag | TagList | TextLiteral | TextTemplateLiteral | TextTemplateSpan | TextTemplateSpanList | TextTranslationDeclaration | TextTranslationFunctionDeclaration | TokenExpression | TopLevelTranslationList | TranslationParameterClause | TranslationParameterList | TranslationTextLiteral | TranslationTextTemplate | TranslationTextTemplateParameter | TranslationTextTemplateSpan | TranslationTextTemplateSpanList | TranslationTypeParameterClause | TranslationTypeParameterList | TranslationsDeclaration | TryStatement | TypeAnnotation | TypeArgumentClause | TypeArgumentList | TypeMemberDeclarationBlock | TypeMemberDeclarationList | TypeMemberGroupDeclaration | TypeMemberTranslationList | TypeParameterClause | TypeParameterDeclaration | TypeParameterDeclarationList | TypeParameterReference | TypeParameterReferenceList | TypeTranslationDeclaration | UnionTypeSpecifier | VariableInitializer | VariantValueDeclaration | WhileStatement | YieldStatement;
+export {};