@artel/artc 0.6.25191

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

@@ -0,0 +1,2235 @@
+import { ParserDiagnostic } from '../../parser/ParserDiagnostic.js';
+import { KeywordKind, NodeKind, TokenKind } from '../index.js';
+import * as red from '../red/index.js';
+import { BaseNode } from './BaseNode.js';
+import { Token } from './Token.js';
+export declare class SourceFile extends BaseNode {
+    readonly diagnostics: readonly ParserDiagnostic[];
+    readonly kind = NodeKind.SourceFile;
+    readonly children: readonly [
+        PackageImportDirectiveList,
+        PackageMemberDeclarationList,
+        Token<TokenKind.EndOfFile>
+    ];
+    get packageImportDirectiveList(): PackageImportDirectiveList;
+    get declarationList(): PackageMemberDeclarationList;
+    get endOfFileToken(): Token<TokenKind.EndOfFile>;
+    getSourceCode(): string;
+    protected get thisAsNode(): Node;
+    constructor(packageImportDirectiveList: PackageImportDirectiveList, declarationList: PackageMemberDeclarationList, endOfFileToken: Token<TokenKind.EndOfFile>, diagnostics: readonly ParserDiagnostic[]);
+    toRed(): red.SourceFile;
+}
+export type PackageMemberDeclarationListElement = PackageMemberDeclaration | Semicolon;
+export declare class PackageMemberDeclarationList extends BaseNode {
+    readonly kind = NodeKind.PackageMemberDeclarationList;
+    readonly children: readonly PackageMemberDeclarationListElement[];
+    get elements(): readonly PackageMemberDeclarationListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly PackageMemberDeclarationListElement[]);
+    toRed(rangeStart: number, parent: red.PackageMemberDeclarationListParent): red.PackageMemberDeclarationList;
+}
+export type Identifier = Token<TokenKind.Identifier>;
+export type Comma = Token<TokenKind.Comma>;
+export type Semicolon = Token<TokenKind.Semicolon>;
+export declare class Keyword<TKind extends KeywordKind = KeywordKind> extends BaseNode {
+    readonly keywordKind: TKind;
+    readonly isMissing: boolean;
+    readonly kind = NodeKind.Keyword;
+    readonly children: readonly Identifier[];
+    get tokens(): readonly Identifier[];
+    protected get thisAsNode(): Node;
+    constructor(keywordKind: TKind, tokens: readonly Identifier[], isMissing?: boolean);
+    toRed(rangeStart: number, parent: red.KeywordParent): red.Keyword<TKind>;
+}
+export type PackageImportDirectiveListElement = PackageImportDirective | Semicolon;
+export declare class PackageImportDirectiveList extends BaseNode {
+    readonly kind = NodeKind.PackageImportDirectiveList;
+    readonly children: readonly PackageImportDirectiveListElement[];
+    get elements(): readonly PackageImportDirectiveListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly PackageImportDirectiveListElement[]);
+    toRed(rangeStart: number, parent: red.PackageImportDirectiveListParent): red.PackageImportDirectiveList;
+}
+export type PackageImportDirective = SinglePackageImportDirective | PackageGroupImportDirective;
+export declare class SinglePackageImportDirective extends BaseNode {
+    readonly kind = NodeKind.SinglePackageImportDirective;
+    readonly children: readonly [
+        Keyword<KeywordKind.Import>,
+        PackageImport
+    ];
+    get importKeyword(): Keyword<KeywordKind.Import>;
+    get packageImport(): PackageImport;
+    protected get thisAsNode(): Node;
+    constructor(importKeyword: Keyword<KeywordKind.Import>, packageImport: PackageImport);
+    toRed(rangeStart: number, parent: red.PackageImportDirectiveParent): red.SinglePackageImportDirective;
+}
+export declare class PackageGroupImportDirective extends BaseNode {
+    readonly kind = NodeKind.PackageGroupImportDirective;
+    readonly children: readonly [
+        Keyword<KeywordKind.Import>,
+        Token<TokenKind.OpenBrace>,
+        PackageImportList,
+        Token<TokenKind.CloseBrace>
+    ];
+    get importKeyword(): Keyword<KeywordKind.Import>;
+    get openBraceToken(): Token<TokenKind.OpenBrace>;
+    get packageImportList(): PackageImportList;
+    get closeBraceToken(): Token<TokenKind.CloseBrace>;
+    protected get thisAsNode(): Node;
+    constructor(importKeyword: Keyword<KeywordKind.Import>, openBraceToken: Token<TokenKind.OpenBrace>, packageImportList: PackageImportList, closeBraceToken: Token<TokenKind.CloseBrace>);
+    toRed(rangeStart: number, parent: red.PackageImportDirectiveParent): red.PackageGroupImportDirective;
+}
+export type PackageImportListElement = PackageImport | Semicolon;
+export declare class PackageImportList extends BaseNode {
+    readonly kind = NodeKind.PackageImportList;
+    readonly children: readonly PackageImportListElement[];
+    get elements(): readonly PackageImportListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly PackageImportListElement[]);
+    toRed(rangeStart: number, parent: red.PackageImportListParent): red.PackageImportList;
+}
+export declare class PackageImport extends BaseNode {
+    readonly kind = NodeKind.PackageImport;
+    readonly children: readonly [
+        Identifier | undefined,
+        Token<TokenKind.Equals> | undefined,
+        PackagePath
+    ];
+    get alias(): Identifier | undefined;
+    get equalsToken(): Token<TokenKind.Equals> | undefined;
+    get packagePath(): PackagePath;
+    protected get thisAsNode(): Node;
+    constructor(alias: Identifier | undefined, equalsToken: Token<TokenKind.Equals> | undefined, packagePath: PackagePath);
+    toRed(rangeStart: number, parent: red.PackageImportParent): red.PackageImport;
+}
+export type PackagePathPart = Identifier | Token<TokenKind.Dot>;
+export declare class PackagePath extends BaseNode {
+    readonly kind = NodeKind.PackagePath;
+    readonly children: readonly PackagePathPart[];
+    get parts(): readonly PackagePathPart[];
+    protected get thisAsNode(): Node;
+    constructor(parts: readonly PackagePathPart[]);
+    toRed(rangeStart: number, parent: red.PackagePathParent): red.PackagePath;
+}
+export type TypeSpecifier = NamedTypeSpecifier | AnonymousTypeSpecifier | UnionTypeSpecifier | ParenthesizedTypeSpecifier | NullableTypeSpecifier | InvalidTypeSpecifier;
+export declare class NamedTypeSpecifier extends BaseNode {
+    readonly kind = NodeKind.NamedTypeSpecifier;
+    readonly children: readonly [
+        QualifiedName,
+        TypeArgumentClause | undefined
+    ];
+    get qualifiedName(): QualifiedName;
+    get typeArgumentClause(): TypeArgumentClause | undefined;
+    protected get thisAsNode(): Node;
+    constructor(qualifiedName: QualifiedName, typeArgumentClause: TypeArgumentClause | undefined);
+    toRed(rangeStart: number, parent: red.NamedTypeSpecifierParent): red.NamedTypeSpecifier;
+}
+export declare class UnionTypeSpecifier extends BaseNode {
+    readonly kind = NodeKind.UnionTypeSpecifier;
+    readonly children: readonly [
+        UnionTypeSpecifierTypeList
+    ];
+    get typeList(): UnionTypeSpecifierTypeList;
+    protected get thisAsNode(): Node;
+    constructor(typeList: UnionTypeSpecifierTypeList);
+    toRed(rangeStart: number, parent: red.NonNamedTypeSpecifierParent): red.UnionTypeSpecifier;
+}
+export type UnionTypeSpecifierTypeListElement = TypeSpecifier | Token<TokenKind.Bar>;
+export declare class UnionTypeSpecifierTypeList extends BaseNode {
+    readonly kind = NodeKind.UnionTypeSpecifierTypeList;
+    readonly children: readonly UnionTypeSpecifierTypeListElement[];
+    get elements(): readonly UnionTypeSpecifierTypeListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly UnionTypeSpecifierTypeListElement[]);
+    toRed(rangeStart: number, parent: red.UnionTypeSpecifierTypeListParent): red.UnionTypeSpecifierTypeList;
+}
+export declare class ParenthesizedTypeSpecifier extends BaseNode {
+    readonly kind = NodeKind.ParenthesizedTypeSpecifier;
+    readonly children: readonly [
+        Token<TokenKind.OpenParenthesis>,
+        TypeSpecifier,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    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>);
+    toRed(rangeStart: number, parent: red.NonNamedTypeSpecifierParent): red.ParenthesizedTypeSpecifier;
+}
+export declare class NullableTypeSpecifier extends BaseNode {
+    readonly kind = NodeKind.NullableTypeSpecifier;
+    readonly children: readonly [
+        TypeSpecifier,
+        Token<TokenKind.Question>
+    ];
+    get typeSpecifier(): TypeSpecifier;
+    get questionToken(): Token<TokenKind.Question>;
+    protected get thisAsNode(): Node;
+    constructor(typeSpecifier: TypeSpecifier, questionToken: Token<TokenKind.Question>);
+    toRed(rangeStart: number, parent: red.NonNamedTypeSpecifierParent): red.NullableTypeSpecifier;
+}
+export declare class AnonymousTypeSpecifier extends BaseNode {
+    readonly kind = NodeKind.AnonymousTypeSpecifier;
+    readonly children: readonly [
+        AnonymousTypeDeclaration
+    ];
+    get typeDeclaration(): AnonymousTypeDeclaration;
+    protected get thisAsNode(): Node;
+    constructor(typeDeclaration: AnonymousTypeDeclaration);
+    toRed(rangeStart: number, parent: red.NonNamedTypeSpecifierParent): red.AnonymousTypeSpecifier;
+}
+export declare class InvalidTypeSpecifier extends BaseNode {
+    readonly kind = NodeKind.InvalidTypeSpecifier;
+    readonly children: never[];
+    protected get thisAsNode(): Node;
+    constructor();
+    toRed(rangeStart: number, parent: red.NonNamedTypeSpecifierParent): red.InvalidTypeSpecifier;
+}
+export type AnonymousTypeDeclaration = AnonymousMethodTypeDeclaration | AnonymousStructuredTypeDeclaration | AnonymousVariantTypeDeclaration;
+export declare class AnonymousMethodTypeDeclaration extends BaseNode {
+    readonly kind = NodeKind.AnonymousMethodTypeDeclaration;
+    readonly children: readonly [
+        MethodTypeDeclarationBody
+    ];
+    get body(): MethodTypeDeclarationBody;
+    protected get thisAsNode(): Node;
+    constructor(body: MethodTypeDeclarationBody);
+    toRed(rangeStart: number, parent: red.AnonymousTypeDeclarationParent): red.AnonymousMethodTypeDeclaration;
+}
+export declare class AnonymousStructuredTypeDeclaration extends BaseNode {
+    readonly kind = NodeKind.AnonymousStructuredTypeDeclaration;
+    readonly children: readonly [
+        StructuredTypeDeclarationBody
+    ];
+    get body(): StructuredTypeDeclarationBody;
+    protected get thisAsNode(): Node;
+    constructor(body: StructuredTypeDeclarationBody);
+    toRed(rangeStart: number, parent: red.AnonymousTypeDeclarationParent): red.AnonymousStructuredTypeDeclaration;
+}
+export declare class AnonymousVariantTypeDeclaration extends BaseNode {
+    readonly kind = NodeKind.AnonymousVariantTypeDeclaration;
+    readonly children: readonly [
+        VariantTypeDeclarationBody
+    ];
+    get body(): VariantTypeDeclarationBody;
+    protected get thisAsNode(): Node;
+    constructor(body: VariantTypeDeclarationBody);
+    toRed(rangeStart: number, parent: red.AnonymousTypeDeclarationParent): red.AnonymousVariantTypeDeclaration;
+}
+export type PackageMemberDeclaration = TranslationsDeclaration | PackageAliasTypeDeclaration | PackageMemberGroupDeclaration | TypeExtensionDeclaration | PackageConstructorDeclaration | PackageEntryPointDeclaration | PackageMethodDeclaration | PackageMethodTypeDeclaration | PackageStructuredTypeDeclaration | PackageVariableDeclaration | PackageVariableGetterDeclaration | PackageVariableSetterDeclaration | PackageVariantTypeDeclaration | InvalidPackageMemberDeclaration;
+export type TopLevelTranslationListElement = TopLevelTranslation | Semicolon;
+export declare class TopLevelTranslationList extends BaseNode {
+    readonly kind = NodeKind.TopLevelTranslationList;
+    readonly children: readonly TopLevelTranslationListElement[];
+    get elements(): readonly TopLevelTranslationListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly TopLevelTranslationListElement[]);
+    toRed(rangeStart: number, parent: red.TopLevelTranslationListParent): red.TopLevelTranslationList;
+}
+export declare class TranslationsDeclaration extends BaseNode {
+    readonly kind = NodeKind.TranslationsDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Translations>,
+        Token<TokenKind.OpenBrace>,
+        TopLevelTranslationList,
+        Token<TokenKind.CloseBrace>
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    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, modifierList: ModifierList, translationsKeyword: Keyword<KeywordKind.Translations>, openBraceToken: Token<TokenKind.OpenBrace>, translationList: TopLevelTranslationList, closeBraceToken: Token<TokenKind.CloseBrace>);
+    toRed(rangeStart: number, parent: red.PackageMemberDeclarationParent): red.TranslationsDeclaration;
+}
+export declare class PackageAliasTypeDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageAliasTypeDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Type>,
+        Identifier,
+        TypeParameterClause | undefined,
+        Token<TokenKind.Equals>,
+        AliasTypeDeclarationBody
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get typeKeyword(): Keyword<KeywordKind.Type>;
+    get name(): Identifier;
+    get typeParameterClause(): TypeParameterClause | undefined;
+    get equalsToken(): Token<TokenKind.Equals>;
+    get body(): AliasTypeDeclarationBody;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, typeKeyword: Keyword<KeywordKind.Type>, name: Identifier, typeParameterClause: TypeParameterClause | undefined, equalsToken: Token<TokenKind.Equals>, body: AliasTypeDeclarationBody);
+    toRed(rangeStart: number, parent: red.PackageMemberDeclarationParent): red.PackageAliasTypeDeclaration;
+}
+export declare class AliasTypeDeclarationBody extends BaseNode {
+    readonly kind = NodeKind.AliasTypeDeclarationBody;
+    readonly children: readonly [
+        TypeSpecifier,
+        TypeMemberDeclarationBlock | undefined
+    ];
+    get aliasedTypeSpecifier(): TypeSpecifier;
+    get memberBlock(): TypeMemberDeclarationBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(aliasedTypeSpecifier: TypeSpecifier, memberBlock: TypeMemberDeclarationBlock | undefined);
+    toRed(rangeStart: number, parent: red.AliasTypeDeclarationBodyParent): red.AliasTypeDeclarationBody;
+}
+export declare class PackageMemberGroupDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageMemberGroupDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Token<TokenKind.OpenBrace>,
+        PackageMemberDeclarationList,
+        Token<TokenKind.CloseBrace>
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get openBraceToken(): Token<TokenKind.OpenBrace>;
+    get declarationList(): PackageMemberDeclarationList;
+    get closeBraceToken(): Token<TokenKind.CloseBrace>;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, openBraceToken: Token<TokenKind.OpenBrace>, declarationList: PackageMemberDeclarationList, closeBraceToken: Token<TokenKind.CloseBrace>);
+    toRed(rangeStart: number, parent: red.PackageMemberDeclarationParent): red.PackageMemberGroupDeclaration;
+}
+export declare class PackageConstructorDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageConstructorDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.OnCreate>,
+        StatementBlock
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get onCreateKeyword(): Keyword<KeywordKind.OnCreate>;
+    get body(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, onCreateKeyword: Keyword<KeywordKind.OnCreate>, body: StatementBlock);
+    toRed(rangeStart: number, parent: red.PackageMemberDeclarationParent): red.PackageConstructorDeclaration;
+}
+export declare class PackageEntryPointDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageEntryPointDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Run>,
+        StatementBlock
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get runKeyword(): Keyword<KeywordKind.Run>;
+    get body(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, runKeyword: Keyword<KeywordKind.Run>, body: StatementBlock);
+    toRed(rangeStart: number, parent: red.PackageMemberDeclarationParent): red.PackageEntryPointDeclaration;
+}
+export declare class PackageMethodDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageMethodDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Operation>,
+        Identifier,
+        TypeParameterClause | undefined,
+        ParameterClause,
+        TypeAnnotation | undefined,
+        StatementBlock | undefined
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get operationKeyword(): Keyword<KeywordKind.Operation>;
+    get name(): Identifier;
+    get typeParameterClause(): TypeParameterClause | undefined;
+    get parameterClause(): ParameterClause;
+    get returnTypeAnnotation(): TypeAnnotation | undefined;
+    get body(): StatementBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, operationKeyword: Keyword<KeywordKind.Operation>, name: Identifier, typeParameterClause: TypeParameterClause | undefined, parameterClause: ParameterClause, returnTypeAnnotation: TypeAnnotation | undefined, body: StatementBlock | undefined);
+    toRed(rangeStart: number, parent: red.PackageMemberDeclarationParent): red.PackageMethodDeclaration;
+}
+export declare class PackageMethodTypeDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageMethodTypeDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Type>,
+        Identifier,
+        TypeParameterClause | undefined,
+        Token<TokenKind.Equals>,
+        MethodTypeDeclarationBody
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get typeKeyword(): Keyword<KeywordKind.Type>;
+    get name(): Identifier;
+    get typeParameterClause(): TypeParameterClause | undefined;
+    get equalsToken(): Token<TokenKind.Equals>;
+    get body(): MethodTypeDeclarationBody;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, typeKeyword: Keyword<KeywordKind.Type>, name: Identifier, typeParameterClause: TypeParameterClause | undefined, equalsToken: Token<TokenKind.Equals>, body: MethodTypeDeclarationBody);
+    toRed(rangeStart: number, parent: red.PackageMemberDeclarationParent): red.PackageMethodTypeDeclaration;
+}
+export declare class MethodTypeDeclarationBody extends BaseNode {
+    readonly kind = NodeKind.MethodTypeDeclarationBody;
+    readonly children: readonly [
+        Keyword<KeywordKind.Async> | undefined,
+        Keyword<KeywordKind.Operation>,
+        ParameterClause,
+        TypeAnnotation | undefined
+    ];
+    get asyncKeyword(): Keyword<KeywordKind.Async> | undefined;
+    get operationKeyword(): Keyword<KeywordKind.Operation>;
+    get parameterClause(): ParameterClause;
+    get returnTypeAnnotation(): TypeAnnotation | undefined;
+    protected get thisAsNode(): Node;
+    constructor(asyncKeyword: Keyword<KeywordKind.Async> | undefined, operationKeyword: Keyword<KeywordKind.Operation>, parameterClause: ParameterClause, returnTypeAnnotation: TypeAnnotation | undefined);
+    toRed(rangeStart: number, parent: red.MethodTypeDeclarationBodyParent): red.MethodTypeDeclarationBody;
+}
+export type BaseTypeListElement = NamedTypeSpecifier | Comma;
+export declare class BaseTypeList extends BaseNode {
+    readonly kind = NodeKind.BaseTypeList;
+    readonly children: readonly BaseTypeListElement[];
+    get elements(): readonly BaseTypeListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly BaseTypeListElement[]);
+    toRed(rangeStart: number, parent: red.BaseTypeListParent): red.BaseTypeList;
+}
+export type TypeMemberDeclarationListElement = TypeMemberDeclaration | Semicolon;
+export declare class TypeMemberDeclarationList extends BaseNode {
+    readonly kind = NodeKind.TypeMemberDeclarationList;
+    readonly children: readonly TypeMemberDeclarationListElement[];
+    get elements(): readonly TypeMemberDeclarationListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly TypeMemberDeclarationListElement[]);
+    toRed(rangeStart: number, parent: red.TypeMemberDeclarationListParent): red.TypeMemberDeclarationList;
+}
+export declare class TypeMemberDeclarationBlock extends BaseNode {
+    readonly kind = NodeKind.TypeMemberDeclarationBlock;
+    readonly children: readonly [
+        Token<TokenKind.OpenBrace>,
+        TypeMemberDeclarationList,
+        Token<TokenKind.CloseBrace>
+    ];
+    get openBraceToken(): Token<TokenKind.OpenBrace>;
+    get memberList(): TypeMemberDeclarationList;
+    get closeBraceToken(): Token<TokenKind.CloseBrace>;
+    protected get thisAsNode(): Node;
+    constructor(openBraceToken: Token<TokenKind.OpenBrace>, memberList: TypeMemberDeclarationList, closeBraceToken: Token<TokenKind.CloseBrace>);
+    toRed(rangeStart: number, parent: red.TypeMemberDeclarationBlockParent): red.TypeMemberDeclarationBlock;
+}
+export declare class PackageStructuredTypeDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageStructuredTypeDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Type>,
+        Identifier,
+        TypeParameterClause | undefined,
+        Token<TokenKind.Equals>,
+        StructuredTypeDeclarationBody
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get typeKeyword(): Keyword<KeywordKind.Type>;
+    get name(): Identifier;
+    get typeParameterClause(): TypeParameterClause | undefined;
+    get equalsToken(): Token<TokenKind.Equals>;
+    get body(): StructuredTypeDeclarationBody;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, typeKeyword: Keyword<KeywordKind.Type>, name: Identifier, typeParameterClause: TypeParameterClause | undefined, equalsToken: Token<TokenKind.Equals>, body: StructuredTypeDeclarationBody);
+    toRed(rangeStart: number, parent: red.PackageMemberDeclarationParent): red.PackageStructuredTypeDeclaration;
+}
+export declare class StructuredTypeDeclarationBody extends BaseNode {
+    readonly kind = NodeKind.StructuredTypeDeclarationBody;
+    readonly children: readonly [
+        StructuredTypeKindKeyword,
+        BaseTypeList | undefined,
+        TypeMemberDeclarationBlock
+    ];
+    get structuredTypeKindKeyword(): StructuredTypeKindKeyword;
+    get baseTypeList(): BaseTypeList | undefined;
+    get memberBlock(): TypeMemberDeclarationBlock;
+    protected get thisAsNode(): Node;
+    constructor(structuredTypeKindKeyword: StructuredTypeKindKeyword, baseTypeList: BaseTypeList | undefined, memberBlock: TypeMemberDeclarationBlock);
+    toRed(rangeStart: number, parent: red.StructuredTypeDeclarationBodyParent): red.StructuredTypeDeclarationBody;
+}
+export type StructuredTypeKindKeyword = Keyword<KeywordKind.Object> | Keyword<KeywordKind.PlainObject> | Keyword<KeywordKind.Aspect>;
+export declare class PackageVariableDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageVariableDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Identifier,
+        TypeAnnotation | undefined,
+        Token<TokenKind.Equals> | undefined,
+        Expression | undefined
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get name(): Identifier;
+    get typeAnnotation(): TypeAnnotation | undefined;
+    get equalsToken(): Token<TokenKind.Equals> | undefined;
+    get initializer(): Expression | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, name: Identifier, typeAnnotation: TypeAnnotation | undefined, equalsToken: Token<TokenKind.Equals> | undefined, initializer: Expression | undefined);
+    toRed(rangeStart: number, parent: red.PackageMemberDeclarationParent): red.PackageVariableDeclaration;
+}
+export declare class PackageVariableGetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageVariableGetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Get>,
+        Identifier,
+        TypeAnnotation,
+        StatementBlock | undefined
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get getKeyword(): Keyword<KeywordKind.Get>;
+    get name(): Identifier;
+    get typeAnnotation(): TypeAnnotation;
+    get body(): StatementBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, getKeyword: Keyword<KeywordKind.Get>, name: Identifier, typeAnnotation: TypeAnnotation, body: StatementBlock | undefined);
+    toRed(rangeStart: number, parent: red.PackageMemberDeclarationParent): red.PackageVariableGetterDeclaration;
+}
+export declare class PackageVariableSetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageVariableSetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Set>,
+        Identifier,
+        SetterParameterClause | undefined,
+        StatementBlock | undefined
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get setKeyword(): Keyword<KeywordKind.Set>;
+    get name(): Identifier;
+    get setterParameterClause(): SetterParameterClause | undefined;
+    get body(): StatementBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, setKeyword: Keyword<KeywordKind.Set>, name: Identifier, setterParameterClause: SetterParameterClause | undefined, body: StatementBlock | undefined);
+    toRed(rangeStart: number, parent: red.PackageMemberDeclarationParent): red.PackageVariableSetterDeclaration;
+}
+export declare class PackageVariantTypeDeclaration extends BaseNode {
+    readonly kind = NodeKind.PackageVariantTypeDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Type>,
+        Identifier,
+        TypeParameterClause | undefined,
+        Token<TokenKind.Equals>,
+        VariantTypeDeclarationBody
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get typeKeyword(): Keyword<KeywordKind.Type>;
+    get name(): Identifier;
+    get typeParameterClause(): TypeParameterClause | undefined;
+    get equalsToken(): Token<TokenKind.Equals>;
+    get body(): VariantTypeDeclarationBody;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, typeKeyword: Keyword<KeywordKind.Type>, name: Identifier, typeParameterClause: TypeParameterClause | undefined, equalsToken: Token<TokenKind.Equals>, body: VariantTypeDeclarationBody);
+    toRed(rangeStart: number, parent: red.PackageMemberDeclarationParent): red.PackageVariantTypeDeclaration;
+}
+export declare class VariantTypeDeclarationBody extends BaseNode {
+    readonly kind = NodeKind.VariantTypeDeclarationBody;
+    readonly children: readonly [
+        Keyword<KeywordKind.Variant>,
+        BaseTypeList | undefined,
+        TypeMemberDeclarationBlock
+    ];
+    get variantKeyword(): Keyword<KeywordKind.Variant>;
+    get baseTypeList(): BaseTypeList | undefined;
+    get memberBlock(): TypeMemberDeclarationBlock;
+    protected get thisAsNode(): Node;
+    constructor(variantKeyword: Keyword<KeywordKind.Variant>, baseTypeList: BaseTypeList | undefined, memberBlock: TypeMemberDeclarationBlock);
+    toRed(rangeStart: number, parent: red.VariantTypeDeclarationBodyParent): red.VariantTypeDeclarationBody;
+}
+export declare class TypeExtensionDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeExtensionDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Type>,
+        ExtendedTypeClause,
+        Token<TokenKind.PlusEquals>,
+        TypeMemberDeclarationBlock
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get typeKeyword(): Keyword<KeywordKind.Type>;
+    get extendedTypeClause(): ExtendedTypeClause;
+    get plusEqualsToken(): Token<TokenKind.PlusEquals>;
+    get memberBlock(): TypeMemberDeclarationBlock;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, typeKeyword: Keyword<KeywordKind.Type>, extendedTypeClause: ExtendedTypeClause, plusEqualsToken: Token<TokenKind.PlusEquals>, memberBlock: TypeMemberDeclarationBlock);
+    toRed(rangeStart: number, parent: red.PackageMemberDeclarationParent): red.TypeExtensionDeclaration;
+}
+export declare class ExtendedTypeClauseCommaList extends BaseNode {
+    readonly kind = NodeKind.ExtendedTypeClauseCommaList;
+    readonly children: readonly Comma[];
+    get commas(): readonly Comma[];
+    protected get thisAsNode(): Node;
+    constructor(commas: readonly Comma[]);
+    toRed(rangeStart: number, parent: red.ExtendedTypeClauseCommaListParent): red.ExtendedTypeClauseCommaList;
+}
+export declare class ExtendedTypeClause extends BaseNode {
+    readonly kind = NodeKind.ExtendedTypeClause;
+    readonly children: readonly [
+        QualifiedName,
+        Token<TokenKind.LessThan> | undefined,
+        ExtendedTypeClauseCommaList | undefined,
+        Token<TokenKind.GreaterThan> | undefined
+    ];
+    get qualifiedName(): QualifiedName;
+    get lessThanToken(): Token<TokenKind.LessThan> | undefined;
+    get commaList(): ExtendedTypeClauseCommaList | undefined;
+    get greaterThanToken(): Token<TokenKind.GreaterThan> | undefined;
+    protected get thisAsNode(): Node;
+    constructor(qualifiedName: QualifiedName, lessThanToken: Token<TokenKind.LessThan> | undefined, commaList: ExtendedTypeClauseCommaList | undefined, greaterThanToken: Token<TokenKind.GreaterThan> | undefined);
+    toRed(rangeStart: number, parent: red.ExtendedTypeClauseParent): red.ExtendedTypeClause;
+}
+export declare class InvalidPackageMemberDeclaration extends BaseNode {
+    readonly kind = NodeKind.InvalidPackageMemberDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList);
+    toRed(rangeStart: number, parent: red.InvalidPackageMemberDeclarationParent): red.InvalidPackageMemberDeclaration;
+}
+export type TypeMemberDeclaration = TypeVariableDeclaration | TypeVariableGetterDeclaration | TypeVariableSetterDeclaration | VariantDeclaration | TypeMethodDeclaration | TypeConstructorDeclaration | TypeDestructorDeclaration | TypeIndexedGetterDeclaration | TypeIndexedSetterDeclaration | TypeDereferencedVariableGetterDeclaration | TypeDereferencedVariableSetterDeclaration | TypeMemberGroupDeclaration | InvalidTypeMemberDeclaration;
+export declare class TypeMemberGroupDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeMemberGroupDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        TypeMemberDeclarationBlock
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get memberBlock(): TypeMemberDeclarationBlock;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, memberBlock: TypeMemberDeclarationBlock);
+    toRed(rangeStart: number, parent: red.TypeMemberDeclarationParent): red.TypeMemberGroupDeclaration;
+}
+export declare class TypeConstructorDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeConstructorDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.OnCreate>,
+        ParameterClause,
+        StatementBlock | undefined
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get onCreateKeyword(): Keyword<KeywordKind.OnCreate>;
+    get parameterClause(): ParameterClause;
+    get body(): StatementBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, onCreateKeyword: Keyword<KeywordKind.OnCreate>, parameterClause: ParameterClause, body: StatementBlock | undefined);
+    toRed(rangeStart: number, parent: red.TypeMemberDeclarationParent): red.TypeConstructorDeclaration;
+}
+export declare class TypeDestructorDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeDestructorDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.OnDispose>,
+        ParameterClause,
+        StatementBlock | undefined
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get onDisposeKeyword(): Keyword<KeywordKind.OnDispose>;
+    get parameterClause(): ParameterClause;
+    get body(): StatementBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, onDisposeKeyword: Keyword<KeywordKind.OnDispose>, parameterClause: ParameterClause, body: StatementBlock | undefined);
+    toRed(rangeStart: number, parent: red.TypeMemberDeclarationParent): red.TypeDestructorDeclaration;
+}
+export declare class TypeIndexedGetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeIndexedGetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Get>,
+        TypeIndexerParameterClause,
+        TypeAnnotation,
+        StatementBlock | undefined
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get getKeyword(): Keyword<KeywordKind.Get>;
+    get parameterClause(): TypeIndexerParameterClause;
+    get typeAnnotation(): TypeAnnotation;
+    get body(): StatementBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, getKeyword: Keyword<KeywordKind.Get>, parameterClause: TypeIndexerParameterClause, typeAnnotation: TypeAnnotation, body: StatementBlock | undefined);
+    toRed(rangeStart: number, parent: red.TypeMemberDeclarationParent): red.TypeIndexedGetterDeclaration;
+}
+export declare class TypeIndexedSetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeIndexedSetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Set>,
+        TypeIndexerParameterClause,
+        SetterParameterClause | undefined,
+        StatementBlock | undefined
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get setKeyword(): Keyword<KeywordKind.Set>;
+    get parameterClause(): TypeIndexerParameterClause;
+    get setterParameterClause(): SetterParameterClause | undefined;
+    get body(): StatementBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, setKeyword: Keyword<KeywordKind.Set>, parameterClause: TypeIndexerParameterClause, setterParameterClause: SetterParameterClause | undefined, body: StatementBlock | undefined);
+    toRed(rangeStart: number, parent: red.TypeMemberDeclarationParent): red.TypeIndexedSetterDeclaration;
+}
+export declare class TypeIndexerParameterClause extends BaseNode {
+    readonly kind = NodeKind.TypeIndexerParameterClause;
+    readonly children: readonly [
+        Token<TokenKind.OpenSquareBracket>,
+        ParameterList,
+        Token<TokenKind.CloseSquareBracket>
+    ];
+    get openSquareBracketToken(): Token<TokenKind.OpenSquareBracket>;
+    get parameterList(): ParameterList;
+    get closeSquareBracketToken(): Token<TokenKind.CloseSquareBracket>;
+    protected get thisAsNode(): Node;
+    constructor(openSquareBracketToken: Token<TokenKind.OpenSquareBracket>, parameterList: ParameterList, closeSquareBracketToken: Token<TokenKind.CloseSquareBracket>);
+    toRed(rangeStart: number, parent: red.TypeIndexerParameterClauseParent): red.TypeIndexerParameterClause;
+}
+export declare class TypeDereferencedVariableGetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeDereferencedVariableGetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Get>,
+        Token<TokenKind.Caret>,
+        TypeAnnotation,
+        StatementBlock | undefined
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get getKeyword(): Keyword<KeywordKind.Get>;
+    get caretToken(): Token<TokenKind.Caret>;
+    get typeAnnotation(): TypeAnnotation;
+    get body(): StatementBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, getKeyword: Keyword<KeywordKind.Get>, caretToken: Token<TokenKind.Caret>, typeAnnotation: TypeAnnotation, body: StatementBlock | undefined);
+    toRed(rangeStart: number, parent: red.TypeMemberDeclarationParent): red.TypeDereferencedVariableGetterDeclaration;
+}
+export declare class TypeDereferencedVariableSetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeDereferencedVariableSetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Set>,
+        Token<TokenKind.Caret>,
+        SetterParameterClause | undefined,
+        StatementBlock | undefined
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get setKeyword(): Keyword<KeywordKind.Set>;
+    get caretToken(): Token<TokenKind.Caret>;
+    get setterParameterClause(): SetterParameterClause | undefined;
+    get body(): StatementBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, setKeyword: Keyword<KeywordKind.Set>, caretToken: Token<TokenKind.Caret>, setterParameterClause: SetterParameterClause | undefined, body: StatementBlock | undefined);
+    toRed(rangeStart: number, parent: red.TypeMemberDeclarationParent): red.TypeDereferencedVariableSetterDeclaration;
+}
+export declare class TypeMethodDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeMethodDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Operation>,
+        Identifier,
+        TypeParameterClause | undefined,
+        ParameterClause,
+        TypeAnnotation | undefined,
+        StatementBlock | undefined
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get operationKeyword(): Keyword<KeywordKind.Operation>;
+    get name(): Identifier;
+    get typeParameterClause(): TypeParameterClause | undefined;
+    get parameterClause(): ParameterClause;
+    get returnTypeAnnotation(): TypeAnnotation | undefined;
+    get body(): StatementBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, operationKeyword: Keyword<KeywordKind.Operation>, name: Identifier, typeParameterClause: TypeParameterClause | undefined, parameterClause: ParameterClause, returnTypeAnnotation: TypeAnnotation | undefined, body: StatementBlock | undefined);
+    toRed(rangeStart: number, parent: red.TypeMemberDeclarationParent): red.TypeMethodDeclaration;
+}
+export declare class TypeVariableDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeVariableDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Identifier,
+        TypeAnnotation | undefined,
+        Token<TokenKind.Equals> | undefined,
+        Expression | undefined
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get name(): Identifier;
+    get typeAnnotation(): TypeAnnotation | undefined;
+    get equalsToken(): Token<TokenKind.Equals> | undefined;
+    get initializer(): Expression | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, name: Identifier, typeAnnotation: TypeAnnotation | undefined, equalsToken: Token<TokenKind.Equals> | undefined, initializer: Expression | undefined);
+    toRed(rangeStart: number, parent: red.TypeMemberDeclarationParent): red.TypeVariableDeclaration;
+}
+export declare class TypeVariableGetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeVariableGetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Get>,
+        Identifier,
+        TypeAnnotation,
+        StatementBlock | undefined
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get getKeyword(): Keyword<KeywordKind.Get>;
+    get name(): Identifier;
+    get typeAnnotation(): TypeAnnotation;
+    get body(): StatementBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, getKeyword: Keyword<KeywordKind.Get>, name: Identifier, typeAnnotation: TypeAnnotation, body: StatementBlock | undefined);
+    toRed(rangeStart: number, parent: red.TypeMemberDeclarationParent): red.TypeVariableGetterDeclaration;
+}
+export declare class TypeVariableSetterDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeVariableSetterDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Keyword<KeywordKind.Set>,
+        Identifier,
+        SetterParameterClause | undefined,
+        StatementBlock | undefined
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get setKeyword(): Keyword<KeywordKind.Set>;
+    get name(): Identifier;
+    get setterParameterClause(): SetterParameterClause | undefined;
+    get body(): StatementBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, setKeyword: Keyword<KeywordKind.Set>, name: Identifier, setterParameterClause: SetterParameterClause | undefined, body: StatementBlock | undefined);
+    toRed(rangeStart: number, parent: red.TypeMemberDeclarationParent): red.TypeVariableSetterDeclaration;
+}
+export declare class InvalidTypeMemberDeclaration extends BaseNode {
+    readonly kind = NodeKind.InvalidTypeMemberDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList);
+    toRed(rangeStart: number, parent: red.TypeMemberDeclarationParent): red.InvalidTypeMemberDeclaration;
+}
+export declare class NestedMethodDeclaration extends BaseNode {
+    readonly kind = NodeKind.NestedMethodDeclaration;
+    readonly children: readonly [
+        Keyword<KeywordKind.Async> | undefined,
+        Keyword<KeywordKind.Operation>,
+        Identifier,
+        TypeParameterClause | undefined,
+        ParameterClause,
+        TypeAnnotation | undefined,
+        StatementBlock
+    ];
+    get asyncKeyword(): Keyword<KeywordKind.Async> | undefined;
+    get operationKeyword(): Keyword<KeywordKind.Operation>;
+    get name(): Identifier;
+    get typeParameterClause(): TypeParameterClause | undefined;
+    get parameterClause(): ParameterClause;
+    get returnTypeAnnotation(): TypeAnnotation | undefined;
+    get body(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(asyncKeyword: Keyword<KeywordKind.Async> | undefined, operationKeyword: Keyword<KeywordKind.Operation>, name: Identifier, typeParameterClause: TypeParameterClause | undefined, parameterClause: ParameterClause, returnTypeAnnotation: TypeAnnotation | undefined, body: StatementBlock);
+    toRed(rangeStart: number, parent: red.NestedMethodDeclarationParent): red.NestedMethodDeclaration;
+}
+export declare class LocalVariableDeclaration extends BaseNode {
+    readonly kind = NodeKind.LocalVariableDeclaration;
+    readonly children: readonly [
+        Keyword<KeywordKind.Let> | Keyword<KeywordKind.Const>,
+        Identifier,
+        TypeAnnotation | undefined,
+        Token<TokenKind.Equals> | undefined,
+        Expression | undefined
+    ];
+    get letOrConstKeyword(): Keyword<KeywordKind.Let> | Keyword<KeywordKind.Const>;
+    get name(): Identifier;
+    get typeAnnotation(): TypeAnnotation | undefined;
+    get equalsToken(): Token<TokenKind.Equals> | undefined;
+    get initializer(): Expression | undefined;
+    protected get thisAsNode(): Node;
+    constructor(letOrConstKeyword: Keyword<KeywordKind.Let> | Keyword<KeywordKind.Const>, name: Identifier, typeAnnotation: TypeAnnotation | undefined, equalsToken: Token<TokenKind.Equals> | undefined, initializer: Expression | undefined);
+    toRed(rangeStart: number, parent: red.LocalVariableDeclarationParent): red.LocalVariableDeclaration;
+}
+export declare class EnumerationVariableDeclaration extends BaseNode {
+    readonly kind = NodeKind.EnumerationVariableDeclaration;
+    readonly children: readonly [
+        Identifier
+    ];
+    get name(): Identifier;
+    protected get thisAsNode(): Node;
+    constructor(name: Identifier);
+    toRed(rangeStart: number, parent: red.EnumerationVariableDeclarationParent): red.EnumerationVariableDeclaration;
+}
+export type Expression = ArrayLiteral | AsExpression | AssertionExpression | AssumptionExpression | BinaryExpression | MethodBlockLiteral | CallExpression | IdentifierExpression | AutotypeCallExpression | IndexedAccessExpression | InvalidExpression | IsExpression | UnobservableExpression | NotExpression | MethodLiteral | ParenthesizedExpression | WhenTernaryExpression | PrefixUnaryExpression | PropertyAccessExpression | ReferenceExpression | DereferenceExpression | TextTemplateLiteral | TransactionalExpression | GenericSpecializationExpression | DefaultMatchExpression | TokenExpression | KeywordExpression | ObjectExpression | BaseExpression;
+export declare class ArrayLiteral extends BaseNode {
+    readonly kind = NodeKind.ArrayLiteral;
+    readonly children: readonly [
+        Token<TokenKind.OpenSquareBracket>,
+        ArrayLiteralElementList,
+        Token<TokenKind.CloseSquareBracket>
+    ];
+    get openSquareBracketToken(): Token<TokenKind.OpenSquareBracket>;
+    get elementList(): ArrayLiteralElementList;
+    get closeSquareBracketToken(): Token<TokenKind.CloseSquareBracket>;
+    protected get thisAsNode(): Node;
+    constructor(openSquareBracketToken: Token<TokenKind.OpenSquareBracket>, elementList: ArrayLiteralElementList, closeSquareBracketToken: Token<TokenKind.CloseSquareBracket>);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.ArrayLiteral;
+}
+export type ArrayLiteralElementListElement = Expression | Comma;
+export declare class ArrayLiteralElementList extends BaseNode {
+    readonly kind = NodeKind.ArrayLiteralElementList;
+    readonly children: readonly ArrayLiteralElementListElement[];
+    get elements(): readonly ArrayLiteralElementListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly ArrayLiteralElementListElement[]);
+    toRed(rangeStart: number, parent: red.ArrayLiteralElementListParent): red.ArrayLiteralElementList;
+}
+export declare class AssertionExpression extends BaseNode {
+    readonly kind = NodeKind.AssertionExpression;
+    readonly children: readonly [
+        Expression,
+        Token<TokenKind.Exclamation>
+    ];
+    get expression(): Expression;
+    get exclamationToken(): Token<TokenKind.Exclamation>;
+    protected get thisAsNode(): Node;
+    constructor(expression: Expression, exclamationToken: Token<TokenKind.Exclamation>);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.AssertionExpression;
+}
+export declare class AssumptionExpression extends BaseNode {
+    readonly kind = NodeKind.AssumptionExpression;
+    readonly children: readonly [
+        Expression,
+        Token<TokenKind.Question>
+    ];
+    get expression(): Expression;
+    get questionToken(): Token<TokenKind.Question>;
+    protected get thisAsNode(): Node;
+    constructor(expression: Expression, questionToken: Token<TokenKind.Question>);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.AssumptionExpression;
+}
+export declare class AsExpression extends BaseNode {
+    readonly kind = NodeKind.AsExpression;
+    readonly children: readonly [
+        Expression,
+        Keyword<KeywordKind.As>,
+        TypeSpecifier
+    ];
+    get expression(): Expression;
+    get asKeyword(): Keyword<KeywordKind.As>;
+    get typeSpecifier(): TypeSpecifier;
+    protected get thisAsNode(): Node;
+    constructor(expression: Expression, asKeyword: Keyword<KeywordKind.As>, typeSpecifier: TypeSpecifier);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.AsExpression;
+}
+export declare class BinaryExpression extends BaseNode {
+    readonly kind = NodeKind.BinaryExpression;
+    readonly children: readonly [
+        Expression,
+        BinaryExpressionOperator,
+        Expression
+    ];
+    get left(): Expression;
+    get operator(): BinaryExpressionOperator;
+    get right(): Expression;
+    protected get thisAsNode(): Node;
+    constructor(left: Expression, operator: BinaryExpressionOperator, right: Expression);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.BinaryExpression;
+}
+export type BinaryExpressionOperator = Token<TokenKind.Plus> | Token<TokenKind.Minus> | Token<TokenKind.Asterisk> | Token<TokenKind.Slash> | Token<TokenKind.Backslash> | Token<TokenKind.BackslashBackslash> | Token<TokenKind.EqualsEquals> | Token<TokenKind.ExclamationEquals> | Token<TokenKind.LessThan> | Token<TokenKind.GreaterThan> | Token<TokenKind.LessThanEquals> | Token<TokenKind.GreaterThanEquals> | Token<TokenKind.QuestionQuestion> | Keyword<KeywordKind.Or> | Keyword<KeywordKind.And> | Keyword<KeywordKind.Xor>;
+export declare class MethodBlockLiteral extends BaseNode {
+    readonly kind = NodeKind.MethodBlockLiteral;
+    readonly children: readonly [
+        StatementBlock
+    ];
+    get body(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(body: StatementBlock);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.MethodBlockLiteral;
+}
+export type CallArgumentListElement = CallArgument | Comma;
+export declare class CallArgumentList extends BaseNode {
+    readonly kind = NodeKind.CallArgumentList;
+    readonly children: readonly CallArgumentListElement[];
+    get elements(): readonly CallArgumentListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly CallArgumentListElement[]);
+    toRed(rangeStart: number, parent: red.CallArgumentListParent): red.CallArgumentList;
+}
+export declare class CallExpression extends BaseNode {
+    readonly kind = NodeKind.CallExpression;
+    readonly children: readonly [
+        Expression,
+        Token<TokenKind.OpenParenthesis>,
+        CallArgumentList,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get expression(): Expression;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get callArgumentList(): CallArgumentList;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Node;
+    constructor(expression: Expression, openParenthesisToken: Token<TokenKind.OpenParenthesis>, callArgumentList: CallArgumentList, closeParenthesisToken: Token<TokenKind.CloseParenthesis>);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.CallExpression;
+}
+export declare class AutotypeCallExpression extends BaseNode {
+    readonly kind = NodeKind.AutotypeCallExpression;
+    readonly children: readonly [
+        Keyword<KeywordKind.Autotype>,
+        Token<TokenKind.OpenParenthesis>,
+        CallArgumentList,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get autotypeKeyword(): Keyword<KeywordKind.Autotype>;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get callArgumentList(): CallArgumentList;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Node;
+    constructor(autotypeKeyword: Keyword<KeywordKind.Autotype>, openParenthesisToken: Token<TokenKind.OpenParenthesis>, callArgumentList: CallArgumentList, closeParenthesisToken: Token<TokenKind.CloseParenthesis>);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.AutotypeCallExpression;
+}
+export type IndexedAccessArgumentListElement = Expression | Comma;
+export declare class IndexedAccessArgumentList extends BaseNode {
+    readonly kind = NodeKind.IndexedAccessArgumentList;
+    readonly children: readonly IndexedAccessArgumentListElement[];
+    get elements(): readonly IndexedAccessArgumentListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly IndexedAccessArgumentListElement[]);
+    toRed(rangeStart: number, parent: red.IndexedAccessArgumentListParent): red.IndexedAccessArgumentList;
+}
+export declare class IndexedAccessExpression extends BaseNode {
+    readonly kind = NodeKind.IndexedAccessExpression;
+    readonly children: readonly [
+        Expression,
+        Token<TokenKind.OpenSquareBracket>,
+        IndexedAccessArgumentList,
+        Token<TokenKind.CloseSquareBracket>
+    ];
+    get expression(): Expression;
+    get openSquareBracketToken(): Token<TokenKind.OpenSquareBracket>;
+    get argumentsList(): IndexedAccessArgumentList;
+    get closeSquareBracketToken(): Token<TokenKind.CloseSquareBracket>;
+    protected get thisAsNode(): Node;
+    constructor(expression: Expression, openSquareBracketToken: Token<TokenKind.OpenSquareBracket>, argumentsList: IndexedAccessArgumentList, closeSquareBracketToken: Token<TokenKind.CloseSquareBracket>);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.IndexedAccessExpression;
+}
+export declare class InvalidExpression extends BaseNode {
+    readonly kind = NodeKind.InvalidExpression;
+    readonly children: never[];
+    protected get thisAsNode(): Node;
+    constructor();
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.InvalidExpression;
+}
+export declare class IsExpression extends BaseNode {
+    readonly kind = NodeKind.IsExpression;
+    readonly children: readonly [
+        Expression,
+        Keyword<KeywordKind.Is>,
+        TypeSpecifier
+    ];
+    get expression(): Expression;
+    get isKeyword(): Keyword<KeywordKind.Is>;
+    get typeSpecifier(): TypeSpecifier;
+    protected get thisAsNode(): Node;
+    constructor(expression: Expression, isKeyword: Keyword<KeywordKind.Is>, typeSpecifier: TypeSpecifier);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.IsExpression;
+}
+export declare class UnobservableExpression extends BaseNode {
+    readonly kind = NodeKind.UnobservableExpression;
+    readonly children: readonly [
+        Keyword<KeywordKind.Unobservable>,
+        Token<TokenKind.OpenParenthesis>,
+        Expression,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get unobservableKeyword(): Keyword<KeywordKind.Unobservable>;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get expression(): Expression;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Node;
+    constructor(unobservableKeyword: Keyword<KeywordKind.Unobservable>, openParenthesisToken: Token<TokenKind.OpenParenthesis>, expression: Expression, closeParenthesisToken: Token<TokenKind.CloseParenthesis>);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.UnobservableExpression;
+}
+export declare class NotExpression extends BaseNode {
+    readonly kind = NodeKind.NotExpression;
+    readonly children: readonly [
+        Keyword<KeywordKind.Not>,
+        Token<TokenKind.OpenParenthesis>,
+        Expression,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get notKeyword(): Keyword<KeywordKind.Not>;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get expression(): Expression;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Node;
+    constructor(notKeyword: Keyword<KeywordKind.Not>, openParenthesisToken: Token<TokenKind.OpenParenthesis>, expression: Expression, closeParenthesisToken: Token<TokenKind.CloseParenthesis>);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.NotExpression;
+}
+export declare class MethodLiteral extends BaseNode {
+    readonly kind = NodeKind.MethodLiteral;
+    readonly children: readonly [
+        Keyword<KeywordKind.Async> | undefined,
+        Keyword<KeywordKind.Operation>,
+        ParameterClause,
+        TypeAnnotation | undefined,
+        StatementBlock
+    ];
+    get asyncKeyword(): Keyword<KeywordKind.Async> | undefined;
+    get operationKeyword(): Keyword<KeywordKind.Operation>;
+    get parameterClause(): ParameterClause;
+    get returnTypeAnnotation(): TypeAnnotation | undefined;
+    get body(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(asyncKeyword: Keyword<KeywordKind.Async> | undefined, operationKeyword: Keyword<KeywordKind.Operation>, parameterClause: ParameterClause, returnTypeAnnotation: TypeAnnotation | undefined, body: StatementBlock);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.MethodLiteral;
+}
+export declare class ParenthesizedExpression extends BaseNode {
+    readonly kind = NodeKind.ParenthesizedExpression;
+    readonly children: readonly [
+        Token<TokenKind.OpenParenthesis>,
+        Expression,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get expression(): Expression;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Node;
+    constructor(openParenthesisToken: Token<TokenKind.OpenParenthesis>, expression: Expression, closeParenthesisToken: Token<TokenKind.CloseParenthesis>);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.ParenthesizedExpression;
+}
+export declare class WhenTernaryExpression extends BaseNode {
+    readonly kind = NodeKind.WhenTernaryExpression;
+    readonly children: readonly [
+        Expression,
+        Keyword<KeywordKind.When>,
+        Expression,
+        Token<TokenKind.Colon>,
+        Expression
+    ];
+    get firstExpression(): Expression;
+    get whenKeyword(): Keyword<KeywordKind.When>;
+    get condition(): Expression;
+    get colonToken(): Token<TokenKind.Colon>;
+    get secondExpression(): Expression;
+    protected get thisAsNode(): Node;
+    constructor(firstExpression: Expression, whenKeyword: Keyword<KeywordKind.When>, condition: Expression, colonToken: Token<TokenKind.Colon>, secondExpression: Expression);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.WhenTernaryExpression;
+}
+export declare class PrefixUnaryExpression extends BaseNode {
+    readonly kind = NodeKind.PrefixUnaryExpression;
+    readonly children: readonly [
+        PrefixUnaryExpressionOperator,
+        Expression
+    ];
+    get operator(): PrefixUnaryExpressionOperator;
+    get operand(): Expression;
+    protected get thisAsNode(): Node;
+    constructor(operator: PrefixUnaryExpressionOperator, operand: Expression);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.PrefixUnaryExpression;
+}
+export type PrefixUnaryExpressionOperator = Token<TokenKind.Plus> | Token<TokenKind.Minus>;
+export declare class PropertyAccessExpression extends BaseNode {
+    readonly kind = NodeKind.PropertyAccessExpression;
+    readonly children: readonly [
+        Expression,
+        Token<TokenKind.Dot>,
+        Identifier
+    ];
+    get expression(): Expression;
+    get dotToken(): Token<TokenKind.Dot>;
+    get propertyName(): Identifier;
+    protected get thisAsNode(): Node;
+    constructor(expression: Expression, dotToken: Token<TokenKind.Dot>, propertyName: Identifier);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.PropertyAccessExpression;
+}
+export declare class ReferenceExpression extends BaseNode {
+    readonly kind = NodeKind.ReferenceExpression;
+    readonly children: readonly [
+        Keyword<KeywordKind.Reference>,
+        Token<TokenKind.OpenParenthesis>,
+        Expression,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get referenceKeyword(): Keyword<KeywordKind.Reference>;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get expression(): Expression;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Node;
+    constructor(referenceKeyword: Keyword<KeywordKind.Reference>, openParenthesisToken: Token<TokenKind.OpenParenthesis>, expression: Expression, closeParenthesisToken: Token<TokenKind.CloseParenthesis>);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.ReferenceExpression;
+}
+export declare class DereferenceExpression extends BaseNode {
+    readonly kind = NodeKind.DereferenceExpression;
+    readonly children: readonly [
+        Expression,
+        Token<TokenKind.Caret>
+    ];
+    get expression(): Expression;
+    get caretToken(): Token<TokenKind.Caret>;
+    protected get thisAsNode(): Node;
+    constructor(expression: Expression, caretToken: Token<TokenKind.Caret>);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.DereferenceExpression;
+}
+export declare class TextTemplateLiteral extends BaseNode {
+    readonly kind = NodeKind.TextTemplateLiteral;
+    readonly children: readonly [
+        TextTemplateHead,
+        TextTemplateSpanList
+    ];
+    get head(): TextTemplateHead;
+    get spanList(): TextTemplateSpanList;
+    protected get thisAsNode(): Node;
+    constructor(head: TextTemplateHead, spanList: TextTemplateSpanList);
+    toRed(rangeStart: number, parent: red.TextTemplateLiteralParent): red.TextTemplateLiteral;
+}
+export declare class TextTemplateSpanList extends BaseNode {
+    readonly kind = NodeKind.TextTemplateSpanList;
+    readonly children: readonly TextTemplateSpan[];
+    get spans(): readonly TextTemplateSpan[];
+    protected get thisAsNode(): Node;
+    constructor(spans: readonly TextTemplateSpan[]);
+    toRed(rangeStart: number, parent: red.TextTemplateSpanListParent): red.TextTemplateSpanList;
+}
+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 expression(): Expression;
+    get text(): TextTemplatePart | TextTemplateTail;
+    protected get thisAsNode(): Node;
+    constructor(expression: Expression, text: TextTemplatePart | TextTemplateTail);
+    toRed(rangeStart: number, parent: red.TextTemplateSpanParent): red.TextTemplateSpan;
+}
+export declare class TokenExpression extends BaseNode {
+    readonly kind = NodeKind.TokenExpression;
+    readonly children: readonly [
+        TokenExpressionToken
+    ];
+    get token(): TokenExpressionToken;
+    protected get thisAsNode(): Node;
+    constructor(token: TokenExpressionToken);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.TokenExpression;
+}
+export type TokenExpressionToken = Token<TokenKind.CharLiteral> | Token<TokenKind.TextLiteral> | Token<TokenKind.IntegerLiteral> | Token<TokenKind.RealLiteral> | Token<TokenKind.MeasureLiteral>;
+export declare class KeywordExpression extends BaseNode {
+    readonly kind = NodeKind.KeywordExpression;
+    readonly children: readonly [
+        KeywordExpressionKeyword
+    ];
+    get keyword(): KeywordExpressionKeyword;
+    protected get thisAsNode(): Node;
+    constructor(keyword: KeywordExpressionKeyword);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.KeywordExpression;
+}
+export type KeywordExpressionKeyword = Keyword<KeywordKind.Yes> | Keyword<KeywordKind.No> | Keyword<KeywordKind.None>;
+export declare class ObjectExpression extends BaseNode {
+    readonly kind = NodeKind.ObjectExpression;
+    readonly children: readonly [
+        Keyword<KeywordKind.Object>
+    ];
+    get keyword(): Keyword<KeywordKind.Object>;
+    protected get thisAsNode(): Node;
+    constructor(keyword: Keyword<KeywordKind.Object>);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.ObjectExpression;
+}
+export declare class BaseExpression extends BaseNode {
+    readonly kind = NodeKind.BaseExpression;
+    readonly children: readonly [
+        Keyword<KeywordKind.Base>
+    ];
+    get keyword(): Keyword<KeywordKind.Base>;
+    protected get thisAsNode(): Node;
+    constructor(keyword: Keyword<KeywordKind.Base>);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.BaseExpression;
+}
+export declare class IdentifierExpression extends BaseNode {
+    readonly kind = NodeKind.IdentifierExpression;
+    readonly children: readonly [
+        Identifier
+    ];
+    get identifier(): Identifier;
+    protected get thisAsNode(): Node;
+    constructor(identifier: Identifier);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.IdentifierExpression;
+}
+export declare class TransactionalExpression extends BaseNode {
+    readonly kind = NodeKind.TransactionalExpression;
+    readonly children: readonly [
+        Keyword<KeywordKind.Transactional>,
+        Token<TokenKind.OpenParenthesis>,
+        Expression,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get transactionalKeyword(): Keyword<KeywordKind.Transactional>;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get expression(): Expression;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Node;
+    constructor(transactionalKeyword: Keyword<KeywordKind.Transactional>, openParenthesisToken: Token<TokenKind.OpenParenthesis>, expression: Expression, closeParenthesisToken: Token<TokenKind.CloseParenthesis>);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.TransactionalExpression;
+}
+export declare class GenericSpecializationExpression extends BaseNode {
+    readonly kind = NodeKind.GenericSpecializationExpression;
+    readonly children: readonly [
+        Expression,
+        TypeArgumentClause
+    ];
+    get expression(): Expression;
+    get typeArgumentClause(): TypeArgumentClause;
+    protected get thisAsNode(): Node;
+    constructor(expression: Expression, typeArgumentClause: TypeArgumentClause);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.GenericSpecializationExpression;
+}
+export declare class DefaultMatchExpression extends BaseNode {
+    readonly kind = NodeKind.DefaultMatchExpression;
+    readonly children: readonly [
+        Token<TokenKind.Asterisk>
+    ];
+    get asteriskToken(): Token<TokenKind.Asterisk>;
+    protected get thisAsNode(): Node;
+    constructor(asteriskToken: Token<TokenKind.Asterisk>);
+    toRed(rangeStart: number, parent: red.ExpressionParent): red.DefaultMatchExpression;
+}
+export type Statement = RunStatement | EmptyStatement | IfStatement | ForStatement | WhileStatement | LoopStatement | ReturnStatement | ErrorStatement | LocalVariableDeclarationStatement | AssignmentStatement | YieldStatement | InvalidStatement | ExpressionStatement | SwitchStatement | BreakLoopStatement | ContinueLoopStatement | NestedMethodDeclarationStatement | TransactionalStatement | UnobservableStatement | DisposeStatement;
+export declare class AssignmentStatement extends BaseNode {
+    readonly kind = NodeKind.AssignmentStatement;
+    readonly children: readonly [
+        Expression,
+        AssignmentStatementOperator,
+        Expression
+    ];
+    get left(): Expression;
+    get operator(): AssignmentStatementOperator;
+    get right(): Expression;
+    protected get thisAsNode(): Node;
+    constructor(left: Expression, operator: AssignmentStatementOperator, right: Expression);
+    toRed(rangeStart: number, parent: red.StatementParent): red.AssignmentStatement;
+}
+export type AssignmentStatementOperator = Token<TokenKind.Equals> | Token<TokenKind.PlusEquals> | Token<TokenKind.MinusEquals> | Token<TokenKind.AsteriskEquals> | Token<TokenKind.SlashEquals> | Token<TokenKind.BackslashEquals>;
+export type StatementListElement = Statement | Semicolon;
+export declare class StatementList extends BaseNode {
+    readonly kind = NodeKind.StatementList;
+    readonly children: readonly StatementListElement[];
+    get elements(): readonly StatementListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly StatementListElement[]);
+    toRed(rangeStart: number, parent: red.StatementListParent): red.StatementList;
+}
+export declare class StatementBlock extends BaseNode {
+    readonly kind = NodeKind.StatementBlock;
+    readonly children: readonly [
+        Token<TokenKind.OpenBrace>,
+        StatementList,
+        Token<TokenKind.CloseBrace>
+    ];
+    get openBraceToken(): Token<TokenKind.OpenBrace>;
+    get statementList(): StatementList;
+    get closeBraceToken(): Token<TokenKind.CloseBrace>;
+    protected get thisAsNode(): Node;
+    constructor(openBraceToken: Token<TokenKind.OpenBrace>, statementList: StatementList, closeBraceToken: Token<TokenKind.CloseBrace>);
+    toRed(rangeStart: number, parent: red.StatementBlockParent): red.StatementBlock;
+}
+export declare class BreakLoopStatement extends BaseNode {
+    readonly kind = NodeKind.BreakLoopStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.BreakLoop>
+    ];
+    get breakLoopKeyword(): Keyword<KeywordKind.BreakLoop>;
+    protected get thisAsNode(): Node;
+    constructor(breakLoopKeyword: Keyword<KeywordKind.BreakLoop>);
+    toRed(rangeStart: number, parent: red.StatementParent): red.BreakLoopStatement;
+}
+export declare class ContinueLoopStatement extends BaseNode {
+    readonly kind = NodeKind.ContinueLoopStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.ContinueLoop>
+    ];
+    get continueLoopKeyword(): Keyword<KeywordKind.ContinueLoop>;
+    protected get thisAsNode(): Node;
+    constructor(continueLoopKeyword: Keyword<KeywordKind.ContinueLoop>);
+    toRed(rangeStart: number, parent: red.StatementParent): red.ContinueLoopStatement;
+}
+export declare class DisposeStatement extends BaseNode {
+    readonly kind = NodeKind.DisposeStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Dispose>,
+        Expression
+    ];
+    get disposeKeyword(): Keyword<KeywordKind.Dispose>;
+    get expression(): Expression;
+    protected get thisAsNode(): Node;
+    constructor(disposeKeyword: Keyword<KeywordKind.Dispose>, expression: Expression);
+    toRed(rangeStart: number, parent: red.StatementParent): red.DisposeStatement;
+}
+export declare class RunStatementClauseList extends BaseNode {
+    readonly kind = NodeKind.RunStatementClauseList;
+    readonly children: readonly RunStatementClause[];
+    get clauses(): readonly RunStatementClause[];
+    protected get thisAsNode(): Node;
+    constructor(clauses: readonly RunStatementClause[]);
+    toRed(rangeStart: number, parent: red.RunStatementClauseListParent): red.RunStatementClauseList;
+}
+export declare class RunStatement extends BaseNode {
+    readonly kind = NodeKind.RunStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Run>,
+        StatementBlock,
+        RunStatementClauseList
+    ];
+    get runKeyword(): Keyword<KeywordKind.Run>;
+    get body(): StatementBlock;
+    get clauseList(): RunStatementClauseList;
+    protected get thisAsNode(): Node;
+    constructor(runKeyword: Keyword<KeywordKind.Run>, body: StatementBlock, clauseList: RunStatementClauseList);
+    toRed(rangeStart: number, parent: red.RunStatementParent): red.RunStatement;
+}
+export type RunStatementClause = OnErrorClause | FinallyClause;
+export declare class OnErrorClause extends BaseNode {
+    readonly kind = NodeKind.OnErrorClause;
+    readonly children: readonly [
+        Keyword<KeywordKind.OnError>,
+        ErrorVariableDeclaration | undefined,
+        StatementBlock
+    ];
+    get onErrorKeyword(): Keyword<KeywordKind.OnError>;
+    get errorVariable(): ErrorVariableDeclaration | undefined;
+    get body(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(onErrorKeyword: Keyword<KeywordKind.OnError>, errorVariable: ErrorVariableDeclaration | undefined, body: StatementBlock);
+    toRed(rangeStart: number, parent: red.OnErrorClauseParent): red.OnErrorClause;
+}
+export declare class ErrorVariableDeclaration extends BaseNode {
+    readonly kind = NodeKind.ErrorVariableDeclaration;
+    readonly children: readonly [
+        Identifier,
+        TypeAnnotation | undefined
+    ];
+    get name(): Identifier;
+    get typeAnnotation(): TypeAnnotation | undefined;
+    protected get thisAsNode(): Node;
+    constructor(name: Identifier, typeAnnotation: TypeAnnotation | undefined);
+    toRed(rangeStart: number, parent: red.ErrorVariableDeclarationParent): red.ErrorVariableDeclaration;
+}
+export declare class FinallyClause extends BaseNode {
+    readonly kind = NodeKind.FinallyClause;
+    readonly children: readonly [
+        Keyword<KeywordKind.Finally>,
+        StatementBlock
+    ];
+    get finallyKeyword(): Keyword<KeywordKind.Finally>;
+    get body(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(finallyKeyword: Keyword<KeywordKind.Finally>, body: StatementBlock);
+    toRed(rangeStart: number, parent: red.FinallyClauseParent): red.FinallyClause;
+}
+export declare class EmptyStatement extends BaseNode {
+    readonly kind = NodeKind.EmptyStatement;
+    readonly children: readonly [
+        Semicolon
+    ];
+    get semicolonToken(): Semicolon;
+    protected get thisAsNode(): Node;
+    constructor(semicolonToken: Semicolon);
+    toRed(rangeStart: number, parent: red.EmptyStatementParent): red.EmptyStatement;
+}
+export declare class ErrorStatement extends BaseNode {
+    readonly kind = NodeKind.ErrorStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Error>,
+        Expression | undefined
+    ];
+    get errorKeyword(): Keyword<KeywordKind.Error>;
+    get expression(): Expression | undefined;
+    protected get thisAsNode(): Node;
+    constructor(errorKeyword: Keyword<KeywordKind.Error>, expression: Expression | undefined);
+    toRed(rangeStart: number, parent: red.ErrorStatementParent): red.ErrorStatement;
+}
+export declare class ExpressionStatement extends BaseNode {
+    readonly kind = NodeKind.ExpressionStatement;
+    readonly children: readonly [
+        Expression
+    ];
+    get expression(): Expression;
+    protected get thisAsNode(): Node;
+    constructor(expression: Expression);
+    toRed(rangeStart: number, parent: red.ExpressionStatementParent): red.ExpressionStatement;
+}
+export type EnumerationVariableListElement = EnumerationVariableDeclaration | Comma;
+export declare class EnumerationVariableList extends BaseNode {
+    readonly kind = NodeKind.EnumerationVariableList;
+    readonly children: readonly EnumerationVariableListElement[];
+    get elements(): readonly EnumerationVariableListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly EnumerationVariableListElement[]);
+    toRed(rangeStart: number, parent: red.EnumerationVariableListParent): red.EnumerationVariableList;
+}
+export declare class ForStatement extends BaseNode {
+    readonly kind = NodeKind.ForStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.For>,
+        EnumerationVariableList,
+        Keyword<KeywordKind.From>,
+        Expression,
+        StatementBlock
+    ];
+    get forKeyword(): Keyword<KeywordKind.For>;
+    get enumerationVariableList(): EnumerationVariableList;
+    get fromKeyword(): Keyword<KeywordKind.From>;
+    get enumeratedExpression(): Expression;
+    get body(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(forKeyword: Keyword<KeywordKind.For>, enumerationVariableList: EnumerationVariableList, fromKeyword: Keyword<KeywordKind.From>, enumeratedExpression: Expression, body: StatementBlock);
+    toRed(rangeStart: number, parent: red.StatementParent): red.ForStatement;
+}
+export declare class IfStatement extends BaseNode {
+    readonly kind = NodeKind.IfStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.If>,
+        Expression,
+        StatementBlock,
+        ElseIfClauseList,
+        Keyword<KeywordKind.Else> | undefined,
+        StatementBlock | undefined
+    ];
+    get ifKeyword(): Keyword<KeywordKind.If>;
+    get condition(): Expression;
+    get thenBlock(): StatementBlock;
+    get elseIfClauseList(): ElseIfClauseList;
+    get elseKeyword(): Keyword<KeywordKind.Else> | undefined;
+    get elseBlock(): StatementBlock | undefined;
+    protected get thisAsNode(): Node;
+    constructor(ifKeyword: Keyword<KeywordKind.If>, condition: Expression, thenBlock: StatementBlock, elseIfClauseList: ElseIfClauseList, elseKeyword: Keyword<KeywordKind.Else> | undefined, elseBlock: StatementBlock | undefined);
+    toRed(rangeStart: number, parent: red.StatementParent): red.IfStatement;
+}
+export declare class ElseIfClauseList extends BaseNode {
+    readonly kind = NodeKind.ElseIfClauseList;
+    readonly children: readonly ElseIfClause[];
+    get elseIfClauses(): readonly ElseIfClause[];
+    protected get thisAsNode(): Node;
+    constructor(elseIfClauses: readonly ElseIfClause[]);
+    toRed(rangeStart: number, parent: red.ElseIfClauseListParent): red.ElseIfClauseList;
+}
+export declare class ElseIfClause extends BaseNode {
+    readonly kind = NodeKind.ElseIfClause;
+    readonly children: readonly [
+        Keyword<KeywordKind.ElseIf>,
+        Expression,
+        StatementBlock
+    ];
+    get elseIfKeyword(): Keyword<KeywordKind.ElseIf>;
+    get condition(): Expression;
+    get thenBlock(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(elseIfKeyword: Keyword<KeywordKind.ElseIf>, condition: Expression, thenBlock: StatementBlock);
+    toRed(rangeStart: number, parent: red.ElseIfClauseParent): red.ElseIfClause;
+}
+export declare class InvalidStatement extends BaseNode {
+    readonly kind = NodeKind.InvalidStatement;
+    readonly children: never[];
+    protected get thisAsNode(): Node;
+    constructor();
+    toRed(rangeStart: number, parent: red.StatementParent): red.InvalidStatement;
+}
+export declare class NestedMethodDeclarationStatement extends BaseNode {
+    readonly kind = NodeKind.NestedMethodDeclarationStatement;
+    readonly children: readonly [
+        NestedMethodDeclaration
+    ];
+    get declaration(): NestedMethodDeclaration;
+    protected get thisAsNode(): Node;
+    constructor(declaration: NestedMethodDeclaration);
+    toRed(rangeStart: number, parent: red.StatementParent): red.NestedMethodDeclarationStatement;
+}
+export declare class LocalVariableDeclarationStatement extends BaseNode {
+    readonly kind = NodeKind.LocalVariableDeclarationStatement;
+    readonly children: readonly [
+        LocalVariableDeclaration
+    ];
+    get declaration(): LocalVariableDeclaration;
+    protected get thisAsNode(): Node;
+    constructor(declaration: LocalVariableDeclaration);
+    toRed(rangeStart: number, parent: red.StatementParent): red.LocalVariableDeclarationStatement;
+}
+export declare class UnobservableStatement extends BaseNode {
+    readonly kind = NodeKind.UnobservableStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Unobservable>,
+        StatementBlock
+    ];
+    get unobservableKeyword(): Keyword<KeywordKind.Unobservable>;
+    get body(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(unobservableKeyword: Keyword<KeywordKind.Unobservable>, body: StatementBlock);
+    toRed(rangeStart: number, parent: red.StatementParent): red.UnobservableStatement;
+}
+export declare class LoopStatement extends BaseNode {
+    readonly kind = NodeKind.LoopStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Loop>,
+        StatementBlock,
+        Keyword<KeywordKind.RepeatWhile> | undefined,
+        Expression | undefined
+    ];
+    get loopKeyword(): Keyword<KeywordKind.Loop>;
+    get body(): StatementBlock;
+    get repeatWhileKeyword(): Keyword<KeywordKind.RepeatWhile> | undefined;
+    get condition(): Expression | undefined;
+    protected get thisAsNode(): Node;
+    constructor(loopKeyword: Keyword<KeywordKind.Loop>, body: StatementBlock, repeatWhileKeyword: Keyword<KeywordKind.RepeatWhile> | undefined, condition: Expression | undefined);
+    toRed(rangeStart: number, parent: red.StatementParent): red.LoopStatement;
+}
+export declare class ReturnStatement extends BaseNode {
+    readonly kind = NodeKind.ReturnStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Return>,
+        Expression | undefined
+    ];
+    get returnKeyword(): Keyword<KeywordKind.Return>;
+    get expression(): Expression | undefined;
+    protected get thisAsNode(): Node;
+    constructor(returnKeyword: Keyword<KeywordKind.Return>, expression: Expression | undefined);
+    toRed(rangeStart: number, parent: red.StatementParent): red.ReturnStatement;
+}
+export declare class CaseClauseList extends BaseNode {
+    readonly kind = NodeKind.CaseClauseList;
+    readonly children: readonly SwitchStatementCaseClause[];
+    get caseClauses(): readonly SwitchStatementCaseClause[];
+    protected get thisAsNode(): Node;
+    constructor(caseClauses: readonly SwitchStatementCaseClause[]);
+    toRed(rangeStart: number, parent: red.CaseClauseListParent): red.CaseClauseList;
+}
+export declare class SwitchStatement extends BaseNode {
+    readonly kind = NodeKind.SwitchStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Switch>,
+        Expression,
+        CaseClauseList
+    ];
+    get switchKeyword(): Keyword<KeywordKind.Switch>;
+    get expression(): Expression;
+    get caseClauseList(): CaseClauseList;
+    protected get thisAsNode(): Node;
+    constructor(switchKeyword: Keyword<KeywordKind.Switch>, expression: Expression, caseClauseList: CaseClauseList);
+    toRed(rangeStart: number, parent: red.SwitchStatementParent): red.SwitchStatement;
+}
+export type MatchExpressionListElement = Expression | Comma;
+export declare class MatchExpressionList extends BaseNode {
+    readonly kind = NodeKind.MatchExpressionList;
+    readonly children: readonly MatchExpressionListElement[];
+    get elements(): readonly MatchExpressionListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly MatchExpressionListElement[]);
+    toRed(rangeStart: number, parent: red.MatchExpressionListParent): red.MatchExpressionList;
+}
+export declare class SwitchStatementCaseClause extends BaseNode {
+    readonly kind = NodeKind.SwitchStatementCaseClause;
+    readonly children: readonly [
+        Keyword<KeywordKind.Case>,
+        MatchExpressionList,
+        StatementBlock
+    ];
+    get caseKeyword(): Keyword<KeywordKind.Case>;
+    get matchExpressionList(): MatchExpressionList;
+    get body(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(caseKeyword: Keyword<KeywordKind.Case>, matchExpressionList: MatchExpressionList, body: StatementBlock);
+    toRed(rangeStart: number, parent: red.SwitchStatementCaseClauseParent): red.SwitchStatementCaseClause;
+}
+export declare class TransactionalStatement extends BaseNode {
+    readonly kind = NodeKind.TransactionalStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Transactional>,
+        StatementBlock
+    ];
+    get transactionalKeyword(): Keyword<KeywordKind.Transactional>;
+    get body(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(transactionalKeyword: Keyword<KeywordKind.Transactional>, body: StatementBlock);
+    toRed(rangeStart: number, parent: red.StatementParent): red.TransactionalStatement;
+}
+export declare class WhileStatement extends BaseNode {
+    readonly kind = NodeKind.WhileStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.While>,
+        Expression,
+        StatementBlock
+    ];
+    get whileKeyword(): Keyword<KeywordKind.While>;
+    get condition(): Expression;
+    get body(): StatementBlock;
+    protected get thisAsNode(): Node;
+    constructor(whileKeyword: Keyword<KeywordKind.While>, condition: Expression, body: StatementBlock);
+    toRed(rangeStart: number, parent: red.StatementParent): red.WhileStatement;
+}
+export declare class YieldStatement extends BaseNode {
+    readonly kind = NodeKind.YieldStatement;
+    readonly children: readonly [
+        Keyword<KeywordKind.Yield>,
+        Expression
+    ];
+    get yieldKeyword(): Keyword<KeywordKind.Yield>;
+    get expression(): Expression;
+    protected get thisAsNode(): Node;
+    constructor(yieldKeyword: Keyword<KeywordKind.Yield>, expression: Expression);
+    toRed(rangeStart: number, parent: red.StatementParent): red.YieldStatement;
+}
+export type TopLevelTranslation = PackageImportTranslation | PackageVariableTranslation | PackageMethodTranslation | TypeTranslation | MethodTypeTranslation | TextLiteralTranslation | TextTemplateLiteralTranslation;
+export type TranslationParameterListElement = Identifier | Comma;
+export declare class TranslationParameterList extends BaseNode {
+    readonly kind = NodeKind.TranslationParameterList;
+    readonly children: readonly TranslationParameterListElement[];
+    get elements(): readonly TranslationParameterListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly TranslationParameterListElement[]);
+    toRed(rangeStart: number, parent: red.TranslationParameterListParent): red.TranslationParameterList;
+}
+export declare class TranslationParameterClause extends BaseNode {
+    readonly kind = NodeKind.TranslationParameterClause;
+    readonly children: readonly [
+        Token<TokenKind.OpenParenthesis>,
+        TranslationParameterList,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    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>);
+    toRed(rangeStart: number, parent: red.TranslationParameterClauseParent): red.TranslationParameterClause;
+}
+export declare class ConstructorTranslation extends BaseNode {
+    readonly kind = NodeKind.ConstructorTranslation;
+    readonly children: readonly [
+        Keyword<KeywordKind.OnCreate>,
+        TranslationParameterClause,
+        Token<TokenKind.MinusGreaterThan>,
+        TranslationParameterClause
+    ];
+    get onCreateKeyword(): Keyword<KeywordKind.OnCreate>;
+    get sourceParameterClause(): TranslationParameterClause;
+    get minusGreaterThanToken(): Token<TokenKind.MinusGreaterThan>;
+    get translatedParameterClause(): TranslationParameterClause;
+    protected get thisAsNode(): Node;
+    constructor(onCreateKeyword: Keyword<KeywordKind.OnCreate>, sourceParameterClause: TranslationParameterClause, minusGreaterThanToken: Token<TokenKind.MinusGreaterThan>, translatedParameterClause: TranslationParameterClause);
+    toRed(rangeStart: number, parent: red.TypeMemberTranslationParent): red.ConstructorTranslation;
+}
+export declare class IndexerTranslationParameterClause extends BaseNode {
+    readonly kind = NodeKind.IndexerTranslationParameterClause;
+    readonly children: readonly [
+        Token<TokenKind.OpenSquareBracket>,
+        TranslationParameterList,
+        Token<TokenKind.CloseSquareBracket>
+    ];
+    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>);
+    toRed(rangeStart: number, parent: red.IndexerTranslationParameterClauseParent): red.IndexerTranslationParameterClause;
+}
+export declare class IndexerTranslation extends BaseNode {
+    readonly kind = NodeKind.IndexerTranslation;
+    readonly children: readonly [
+        IndexerTranslationParameterClause,
+        Token<TokenKind.MinusGreaterThan>,
+        IndexerTranslationParameterClause
+    ];
+    get sourceParameterClause(): IndexerTranslationParameterClause;
+    get minusGreaterThanToken(): Token<TokenKind.MinusGreaterThan>;
+    get translatedParameterClause(): IndexerTranslationParameterClause;
+    protected get thisAsNode(): Node;
+    constructor(sourceParameterClause: IndexerTranslationParameterClause, minusGreaterThanToken: Token<TokenKind.MinusGreaterThan>, translatedParameterClause: IndexerTranslationParameterClause);
+    toRed(rangeStart: number, parent: red.TypeMemberTranslationParent): red.IndexerTranslation;
+}
+export type TranslationTypeParameterListElement = Identifier | Comma;
+export declare class TranslationTypeParameterList extends BaseNode {
+    readonly kind = NodeKind.TranslationTypeParameterList;
+    readonly children: readonly TranslationTypeParameterListElement[];
+    get elements(): readonly TranslationTypeParameterListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly TranslationTypeParameterListElement[]);
+    toRed(rangeStart: number, parent: red.TranslationTypeParameterListParent): red.TranslationTypeParameterList;
+}
+export declare class TranslationTypeParameterClause extends BaseNode {
+    readonly kind = NodeKind.TranslationTypeParameterClause;
+    readonly children: readonly [
+        Token<TokenKind.LessThan>,
+        TranslationTypeParameterList,
+        Token<TokenKind.GreaterThan>
+    ];
+    get lessThanToken(): Token<TokenKind.LessThan>;
+    get parameterList(): TranslationTypeParameterList;
+    get greaterThanToken(): Token<TokenKind.GreaterThan>;
+    protected get thisAsNode(): Node;
+    constructor(lessThanToken: Token<TokenKind.LessThan>, parameterList: TranslationTypeParameterList, greaterThanToken: Token<TokenKind.GreaterThan>);
+    toRed(rangeStart: number, parent: red.TranslationTypeParameterClauseParent): red.TranslationTypeParameterClause;
+}
+export declare class PackageMethodTranslation extends BaseNode {
+    readonly kind = NodeKind.PackageMethodTranslation;
+    readonly children: readonly [
+        Keyword<KeywordKind.Operation>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        TranslationParameterClause,
+        Token<TokenKind.MinusGreaterThan>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        TranslationParameterClause
+    ];
+    get operationKeyword(): Keyword<KeywordKind.Operation>;
+    get sourceName(): Identifier;
+    get sourceTypeParameterClause(): TranslationTypeParameterClause | undefined;
+    get sourceParameterClause(): TranslationParameterClause;
+    get minusGreaterThanToken(): Token<TokenKind.MinusGreaterThan>;
+    get translatedName(): Identifier;
+    get translatedTypeParameterClause(): TranslationTypeParameterClause | undefined;
+    get translatedParameterClause(): TranslationParameterClause;
+    protected get thisAsNode(): Node;
+    constructor(operationKeyword: Keyword<KeywordKind.Operation>, sourceName: Identifier, sourceTypeParameterClause: TranslationTypeParameterClause | undefined, sourceParameterClause: TranslationParameterClause, minusGreaterThanToken: Token<TokenKind.MinusGreaterThan>, translatedName: Identifier, translatedTypeParameterClause: TranslationTypeParameterClause | undefined, translatedParameterClause: TranslationParameterClause);
+    toRed(rangeStart: number, parent: red.PackageMethodTranslationParent): red.PackageMethodTranslation;
+}
+export declare class TypeMethodTranslation extends BaseNode {
+    readonly kind = NodeKind.TypeMethodTranslation;
+    readonly children: readonly [
+        Keyword<KeywordKind.Operation>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        TranslationParameterClause,
+        Token<TokenKind.MinusGreaterThan>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        TranslationParameterClause
+    ];
+    get operationKeyword(): Keyword<KeywordKind.Operation>;
+    get sourceName(): Identifier;
+    get sourceTypeParameterClause(): TranslationTypeParameterClause | undefined;
+    get sourceParameterClause(): TranslationParameterClause;
+    get minusGreaterThanToken(): Token<TokenKind.MinusGreaterThan>;
+    get translatedName(): Identifier;
+    get translatedTypeParameterClause(): TranslationTypeParameterClause | undefined;
+    get translatedParameterClause(): TranslationParameterClause;
+    protected get thisAsNode(): Node;
+    constructor(operationKeyword: Keyword<KeywordKind.Operation>, sourceName: Identifier, sourceTypeParameterClause: TranslationTypeParameterClause | undefined, sourceParameterClause: TranslationParameterClause, minusGreaterThanToken: Token<TokenKind.MinusGreaterThan>, translatedName: Identifier, translatedTypeParameterClause: TranslationTypeParameterClause | undefined, translatedParameterClause: TranslationParameterClause);
+    toRed(rangeStart: number, parent: red.TypeMethodTranslationParent): red.TypeMethodTranslation;
+}
+export declare class MethodTypeTranslation extends BaseNode {
+    readonly kind = NodeKind.MethodTypeTranslation;
+    readonly children: readonly [
+        Keyword<KeywordKind.Type>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        TranslationParameterClause,
+        Token<TokenKind.MinusGreaterThan>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        TranslationParameterClause
+    ];
+    get typeKeyword(): Keyword<KeywordKind.Type>;
+    get sourceName(): Identifier;
+    get sourceTypeParameterClause(): TranslationTypeParameterClause | undefined;
+    get sourceParameterClause(): TranslationParameterClause;
+    get minusGreaterThanToken(): Token<TokenKind.MinusGreaterThan>;
+    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, minusGreaterThanToken: Token<TokenKind.MinusGreaterThan>, translatedName: Identifier, translatedTypeParameterClause: TranslationTypeParameterClause | undefined, translatedParameterClause: TranslationParameterClause);
+    toRed(rangeStart: number, parent: red.MethodTypeTranslationParent): red.MethodTypeTranslation;
+}
+export declare class PackageImportTranslation extends BaseNode {
+    readonly kind = NodeKind.PackageImportTranslation;
+    readonly children: readonly [
+        Keyword<KeywordKind.Import>,
+        QualifiedName,
+        Token<TokenKind.MinusGreaterThan>,
+        QualifiedName
+    ];
+    get importKeyword(): Keyword<KeywordKind.Import>;
+    get sourceName(): QualifiedName;
+    get minusGreaterThanToken(): Token<TokenKind.MinusGreaterThan>;
+    get translatedName(): QualifiedName;
+    protected get thisAsNode(): Node;
+    constructor(importKeyword: Keyword<KeywordKind.Import>, sourceName: QualifiedName, minusGreaterThanToken: Token<TokenKind.MinusGreaterThan>, translatedName: QualifiedName);
+    toRed(rangeStart: number, parent: red.PackageImportTranslationParent): red.PackageImportTranslation;
+}
+export type QualifiedNamePart = Identifier | Token<TokenKind.Dot>;
+export declare class QualifiedName extends BaseNode {
+    readonly kind = NodeKind.QualifiedName;
+    readonly children: readonly QualifiedNamePart[];
+    get parts(): readonly QualifiedNamePart[];
+    protected get thisAsNode(): Node;
+    constructor(parts: readonly QualifiedNamePart[]);
+    toRed(rangeStart: number, parent: red.QualifiedNameParent): red.QualifiedName;
+}
+export declare class PackageVariableTranslation extends BaseNode {
+    readonly kind = NodeKind.PackageVariableTranslation;
+    readonly children: readonly [
+        Identifier,
+        Token<TokenKind.MinusGreaterThan>,
+        Identifier
+    ];
+    get sourceName(): Identifier;
+    get minusGreaterThanToken(): Token<TokenKind.MinusGreaterThan>;
+    get translatedName(): Identifier;
+    protected get thisAsNode(): Node;
+    constructor(sourceName: Identifier, minusGreaterThanToken: Token<TokenKind.MinusGreaterThan>, translatedName: Identifier);
+    toRed(rangeStart: number, parent: red.PackageVariableTranslationParent): red.PackageVariableTranslation;
+}
+export declare class TypeVariableOrVariantTranslation extends BaseNode {
+    readonly kind = NodeKind.TypeVariableOrVariantTranslation;
+    readonly children: readonly [
+        Identifier,
+        Token<TokenKind.MinusGreaterThan>,
+        Identifier
+    ];
+    get sourceName(): Identifier;
+    get minusGreaterThanToken(): Token<TokenKind.MinusGreaterThan>;
+    get translatedName(): Identifier;
+    protected get thisAsNode(): Node;
+    constructor(sourceName: Identifier, minusGreaterThanToken: Token<TokenKind.MinusGreaterThan>, translatedName: Identifier);
+    toRed(rangeStart: number, parent: red.TypeVariableOrVariantTranslationParent): red.TypeVariableOrVariantTranslation;
+}
+export type TypeMemberTranslationListElement = TypeMemberTranslation | Semicolon;
+export declare class TypeMemberTranslationList extends BaseNode {
+    readonly kind = NodeKind.TypeMemberTranslationList;
+    readonly children: readonly TypeMemberTranslationListElement[];
+    get elements(): readonly TypeMemberTranslationListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly TypeMemberTranslationListElement[]);
+    toRed(rangeStart: number, parent: red.TypeMemberTranslationListParent): red.TypeMemberTranslationList;
+}
+export declare class TypeTranslation extends BaseNode {
+    readonly kind = NodeKind.TypeTranslation;
+    readonly children: readonly [
+        Keyword<KeywordKind.Type>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        Token<TokenKind.MinusGreaterThan>,
+        Identifier,
+        TranslationTypeParameterClause | undefined,
+        Token<TokenKind.OpenBrace> | undefined,
+        TypeMemberTranslationList | undefined,
+        Token<TokenKind.CloseBrace> | undefined
+    ];
+    get typeKeyword(): Keyword<KeywordKind.Type>;
+    get sourceName(): Identifier;
+    get sourceTypeParameterClause(): TranslationTypeParameterClause | undefined;
+    get minusGreaterThanToken(): Token<TokenKind.MinusGreaterThan>;
+    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, minusGreaterThanToken: Token<TokenKind.MinusGreaterThan>, translatedName: Identifier, translatedTypeParameterClause: TranslationTypeParameterClause | undefined, openBraceToken: Token<TokenKind.OpenBrace> | undefined, memberList: TypeMemberTranslationList | undefined, closeBraceToken: Token<TokenKind.CloseBrace> | undefined);
+    toRed(rangeStart: number, parent: red.TypeTranslationParent): red.TypeTranslation;
+}
+export type TypeMemberTranslation = TypeVariableOrVariantTranslation | TypeMethodTranslation | IndexerTranslation | ConstructorTranslation;
+export declare class TextLiteralTranslation extends BaseNode {
+    readonly kind = NodeKind.TextLiteralTranslation;
+    readonly children: readonly [
+        Token<TokenKind.TextLiteral>,
+        Token<TokenKind.MinusGreaterThan>,
+        Token<TokenKind.TextLiteral>
+    ];
+    get sourceTextLiteral(): Token<TokenKind.TextLiteral>;
+    get minusGreaterThanToken(): Token<TokenKind.MinusGreaterThan>;
+    get translatedTextLiteral(): Token<TokenKind.TextLiteral>;
+    protected get thisAsNode(): Node;
+    constructor(sourceTextLiteral: Token<TokenKind.TextLiteral>, minusGreaterThanToken: Token<TokenKind.MinusGreaterThan>, translatedTextLiteral: Token<TokenKind.TextLiteral>);
+    toRed(rangeStart: number, parent: red.TextLiteralTranslationParent): red.TextLiteralTranslation;
+}
+export declare class TextTemplateLiteralTranslation extends BaseNode {
+    readonly kind = NodeKind.TextTemplateLiteralTranslation;
+    readonly children: readonly [
+        TextTemplateLiteral,
+        Token<TokenKind.MinusGreaterThan>,
+        TextTemplateLiteral
+    ];
+    get sourceTextTemplateLiteral(): TextTemplateLiteral;
+    get minusGreaterThanToken(): Token<TokenKind.MinusGreaterThan>;
+    get translatedTextTemplateLiteral(): TextTemplateLiteral;
+    protected get thisAsNode(): Node;
+    constructor(sourceTextTemplateLiteral: TextTemplateLiteral, minusGreaterThanToken: Token<TokenKind.MinusGreaterThan>, translatedTextTemplateLiteral: TextTemplateLiteral);
+    toRed(rangeStart: number, parent: red.TextTemplateLiteralTranslationParent): red.TextTemplateLiteralTranslation;
+}
+export declare class VariantDeclaration extends BaseNode {
+    readonly kind = NodeKind.VariantDeclaration;
+    readonly children: readonly [
+        TagList,
+        ModifierList,
+        Identifier,
+        Token<TokenKind.Equals> | undefined,
+        Expression | undefined
+    ];
+    get tagList(): TagList;
+    get modifierList(): ModifierList;
+    get name(): Identifier;
+    get equalsToken(): Token<TokenKind.Equals> | undefined;
+    get value(): Expression | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, modifierList: ModifierList, name: Identifier, equalsToken: Token<TokenKind.Equals> | undefined, value: Expression | undefined);
+    toRed(rangeStart: number, parent: red.TypeMemberDeclarationParent): red.VariantDeclaration;
+}
+export declare class TypeParameterDeclaration extends BaseNode {
+    readonly kind = NodeKind.TypeParameterDeclaration;
+    readonly children: readonly [
+        Identifier,
+        Token<TokenKind.Colon> | undefined,
+        TypeSpecifier | undefined,
+        Token<TokenKind.Equals> | undefined,
+        TypeSpecifier | undefined
+    ];
+    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(name: Identifier, colonToken: Token<TokenKind.Colon> | undefined, constraint: TypeSpecifier | undefined, equalsToken: Token<TokenKind.Equals> | undefined, defaultType: TypeSpecifier | undefined);
+    toRed(rangeStart: number, parent: red.TypeParameterDeclarationParent): red.TypeParameterDeclaration;
+}
+export declare class ParameterDeclaration extends BaseNode {
+    readonly kind = NodeKind.ParameterDeclaration;
+    readonly children: readonly [
+        TagList,
+        Identifier,
+        TypeAnnotation | undefined,
+        Token<TokenKind.Equals> | undefined,
+        Expression | undefined
+    ];
+    get tagList(): TagList;
+    get name(): Identifier;
+    get typeAnnotation(): TypeAnnotation | undefined;
+    get equalsToken(): Token<TokenKind.Equals> | undefined;
+    get defaultValue(): Expression | undefined;
+    protected get thisAsNode(): Node;
+    constructor(tagList: TagList, name: Identifier, typeAnnotation: TypeAnnotation | undefined, equalsToken: Token<TokenKind.Equals> | undefined, defaultValue: Expression | undefined);
+    toRed(rangeStart: number, parent: red.ParameterDeclarationParent): red.ParameterDeclaration;
+}
+export declare class CallArgument extends BaseNode {
+    readonly kind = NodeKind.CallArgument;
+    readonly children: readonly [
+        Identifier | undefined,
+        Token<TokenKind.Equals> | undefined,
+        Expression
+    ];
+    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);
+    toRed(rangeStart: number, parent: red.CallArgumentParent): red.CallArgument;
+}
+export declare class TagList extends BaseNode {
+    readonly kind = NodeKind.TagList;
+    readonly children: readonly Tag[];
+    get tags(): readonly Tag[];
+    protected get thisAsNode(): Node;
+    constructor(tags: readonly Tag[]);
+    toRed(rangeStart: number, parent: red.TagListParent): red.TagList;
+}
+export declare class Tag extends BaseNode {
+    readonly kind = NodeKind.Tag;
+    readonly children: readonly [
+        Token<TokenKind.HashSign>,
+        NamedTypeSpecifier,
+        Token<TokenKind.OpenParenthesis> | undefined,
+        CallArgumentList | undefined,
+        Token<TokenKind.CloseParenthesis> | undefined
+    ];
+    get hashSignToken(): Token<TokenKind.HashSign>;
+    get typeSpecifier(): NamedTypeSpecifier;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis> | undefined;
+    get callArgumentList(): CallArgumentList | undefined;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis> | undefined;
+    protected get thisAsNode(): Node;
+    constructor(hashSignToken: Token<TokenKind.HashSign>, typeSpecifier: NamedTypeSpecifier, openParenthesisToken: Token<TokenKind.OpenParenthesis> | undefined, callArgumentList: CallArgumentList | undefined, closeParenthesisToken: Token<TokenKind.CloseParenthesis> | undefined);
+    toRed(rangeStart: number, parent: red.TagParent): red.Tag;
+}
+export declare class ModifierList extends BaseNode {
+    readonly kind = NodeKind.ModifierList;
+    readonly children: readonly Modifier[];
+    get modifiers(): readonly Modifier[];
+    protected get thisAsNode(): Node;
+    constructor(modifiers: readonly Modifier[]);
+    toRed(rangeStart: number, parent: red.ModifierListParent): red.ModifierList;
+}
+export declare class Modifier extends BaseNode {
+    readonly kind = NodeKind.Modifier;
+    readonly children: readonly [
+        ModifierKeyword,
+        Token<TokenKind.OpenParenthesis> | undefined,
+        ModifierLevelKeyword | undefined,
+        Token<TokenKind.CloseParenthesis> | undefined
+    ];
+    get value(): ModifierKeyword;
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis> | undefined;
+    get level(): ModifierLevelKeyword | undefined;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis> | undefined;
+    protected get thisAsNode(): Node;
+    constructor(value: ModifierKeyword, openParenthesisToken: Token<TokenKind.OpenParenthesis> | undefined, level: ModifierLevelKeyword | undefined, closeParenthesisToken: Token<TokenKind.CloseParenthesis> | undefined);
+    toRed(rangeStart: number, parent: red.ModifierParent): red.Modifier;
+}
+export type ModifierKeyword = Keyword<ModifierKeywordKind>;
+export type ModifierKeywordKind = KeywordKind.Const | KeywordKind.Hidden | KeywordKind.Abstract | KeywordKind.Static | KeywordKind.Redefinable | KeywordKind.Redefined | KeywordKind.Async | KeywordKind.Observable | KeywordKind.Consistent;
+export type ModifierLevelKeyword = Keyword<KeywordKind.InType> | Keyword<KeywordKind.InFamily> | Keyword<KeywordKind.InFile> | Keyword<KeywordKind.InPackage>;
+export declare class ParameterClause extends BaseNode {
+    readonly kind = NodeKind.ParameterClause;
+    readonly children: readonly [
+        Token<TokenKind.OpenParenthesis>,
+        ParameterList,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    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>);
+    toRed(rangeStart: number, parent: red.ParameterClauseParent): red.ParameterClause;
+}
+export type ParameterListElement = ParameterDeclaration | Comma;
+export declare class ParameterList extends BaseNode {
+    readonly kind = NodeKind.ParameterList;
+    readonly children: readonly ParameterListElement[];
+    get elements(): readonly ParameterListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly ParameterListElement[]);
+    toRed(rangeStart: number, parent: red.ParameterListParent): red.ParameterList;
+}
+export declare class SetterParameterClause extends BaseNode {
+    readonly kind = NodeKind.SetterParameterClause;
+    readonly children: readonly [
+        Token<TokenKind.OpenParenthesis>,
+        SetterParameterDeclaration,
+        Token<TokenKind.CloseParenthesis>
+    ];
+    get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
+    get parameterDeclaration(): SetterParameterDeclaration;
+    get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
+    protected get thisAsNode(): Node;
+    constructor(openParenthesisToken: Token<TokenKind.OpenParenthesis>, parameterDeclaration: SetterParameterDeclaration, closeParenthesisToken: Token<TokenKind.CloseParenthesis>);
+    toRed(rangeStart: number, parent: red.SetterParameterClauseParent): red.SetterParameterClause;
+}
+export declare class SetterParameterDeclaration extends BaseNode {
+    readonly kind = NodeKind.SetterParameterDeclaration;
+    readonly children: readonly [
+        Identifier,
+        TypeAnnotation
+    ];
+    get name(): Identifier;
+    get typeAnnotation(): TypeAnnotation;
+    protected get thisAsNode(): Node;
+    constructor(name: Identifier, typeAnnotation: TypeAnnotation);
+    toRed(rangeStart: number, parent: red.SetterParameterDeclarationParent): red.SetterParameterDeclaration;
+}
+export declare class TypeArgumentClause extends BaseNode {
+    readonly kind = NodeKind.TypeArgumentClause;
+    readonly children: readonly [
+        Token<TokenKind.LessThan>,
+        TypeArgumentList,
+        Token<TokenKind.GreaterThan>
+    ];
+    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>);
+    toRed(rangeStart: number, parent: red.TypeArgumentClauseParent): red.TypeArgumentClause;
+}
+export type TypeArgumentListElement = TypeSpecifier | Comma;
+export declare class TypeArgumentList extends BaseNode {
+    readonly kind = NodeKind.TypeArgumentList;
+    readonly children: readonly TypeArgumentListElement[];
+    get elements(): readonly TypeArgumentListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly TypeArgumentListElement[]);
+    toRed(rangeStart: number, parent: red.TypeArgumentListParent): red.TypeArgumentList;
+}
+export declare class TypeParameterClause extends BaseNode {
+    readonly kind = NodeKind.TypeParameterClause;
+    readonly children: readonly [
+        Token<TokenKind.LessThan>,
+        TypeParameterList,
+        Token<TokenKind.GreaterThan>
+    ];
+    get lessThanToken(): Token<TokenKind.LessThan>;
+    get typeParameterList(): TypeParameterList;
+    get greaterThanToken(): Token<TokenKind.GreaterThan>;
+    protected get thisAsNode(): Node;
+    constructor(lessThanToken: Token<TokenKind.LessThan>, typeParameterList: TypeParameterList, greaterThanToken: Token<TokenKind.GreaterThan>);
+    toRed(rangeStart: number, parent: red.TypeParameterClauseParent): red.TypeParameterClause;
+}
+export type TypeParameterListElement = TypeParameterDeclaration | Comma;
+export declare class TypeParameterList extends BaseNode {
+    readonly kind = NodeKind.TypeParameterList;
+    readonly children: readonly TypeParameterListElement[];
+    get elements(): readonly TypeParameterListElement[];
+    protected get thisAsNode(): Node;
+    constructor(elements: readonly TypeParameterListElement[]);
+    toRed(rangeStart: number, parent: red.TypeParameterListParent): red.TypeParameterList;
+}
+export declare class TypeAnnotation extends BaseNode {
+    readonly kind = NodeKind.TypeAnnotation;
+    readonly children: readonly [
+        Token<TokenKind.Colon>,
+        TypeSpecifier
+    ];
+    get colonToken(): Token<TokenKind.Colon>;
+    get typeSpecifier(): TypeSpecifier;
+    protected get thisAsNode(): Node;
+    constructor(colonToken: Token<TokenKind.Colon>, typeSpecifier: TypeSpecifier);
+    toRed(rangeStart: number, parent: red.TypeAnnotationParent): red.TypeAnnotation;
+}
+export type Node = SourceFile | PackageMemberDeclarationList | Keyword | PackageImportDirectiveList | SinglePackageImportDirective | PackageGroupImportDirective | PackageImportList | PackageImport | PackagePath | NamedTypeSpecifier | UnionTypeSpecifier | UnionTypeSpecifierTypeList | ParenthesizedTypeSpecifier | NullableTypeSpecifier | AnonymousTypeSpecifier | InvalidTypeSpecifier | AnonymousMethodTypeDeclaration | AnonymousStructuredTypeDeclaration | AnonymousVariantTypeDeclaration | TopLevelTranslationList | TranslationsDeclaration | PackageAliasTypeDeclaration | AliasTypeDeclarationBody | PackageMemberGroupDeclaration | PackageConstructorDeclaration | PackageEntryPointDeclaration | PackageMethodDeclaration | PackageMethodTypeDeclaration | MethodTypeDeclarationBody | BaseTypeList | TypeMemberDeclarationList | TypeMemberDeclarationBlock | PackageStructuredTypeDeclaration | StructuredTypeDeclarationBody | PackageVariableDeclaration | PackageVariableGetterDeclaration | PackageVariableSetterDeclaration | PackageVariantTypeDeclaration | VariantTypeDeclarationBody | TypeExtensionDeclaration | ExtendedTypeClauseCommaList | ExtendedTypeClause | InvalidPackageMemberDeclaration | TypeMemberGroupDeclaration | TypeConstructorDeclaration | TypeDestructorDeclaration | TypeIndexedGetterDeclaration | TypeIndexedSetterDeclaration | TypeIndexerParameterClause | TypeDereferencedVariableGetterDeclaration | TypeDereferencedVariableSetterDeclaration | TypeMethodDeclaration | TypeVariableDeclaration | TypeVariableGetterDeclaration | TypeVariableSetterDeclaration | InvalidTypeMemberDeclaration | NestedMethodDeclaration | LocalVariableDeclaration | EnumerationVariableDeclaration | ArrayLiteral | ArrayLiteralElementList | AssertionExpression | AssumptionExpression | AsExpression | BinaryExpression | MethodBlockLiteral | CallArgumentList | CallExpression | AutotypeCallExpression | IndexedAccessArgumentList | IndexedAccessExpression | InvalidExpression | IsExpression | UnobservableExpression | NotExpression | MethodLiteral | ParenthesizedExpression | WhenTernaryExpression | PrefixUnaryExpression | PropertyAccessExpression | ReferenceExpression | DereferenceExpression | TextTemplateLiteral | TextTemplateSpanList | TextTemplateSpan | TokenExpression | KeywordExpression | ObjectExpression | BaseExpression | IdentifierExpression | TransactionalExpression | GenericSpecializationExpression | DefaultMatchExpression | AssignmentStatement | StatementList | StatementBlock | BreakLoopStatement | ContinueLoopStatement | DisposeStatement | RunStatementClauseList | RunStatement | OnErrorClause | ErrorVariableDeclaration | FinallyClause | EmptyStatement | ErrorStatement | ExpressionStatement | EnumerationVariableList | ForStatement | IfStatement | ElseIfClauseList | ElseIfClause | InvalidStatement | NestedMethodDeclarationStatement | LocalVariableDeclarationStatement | UnobservableStatement | LoopStatement | ReturnStatement | CaseClauseList | SwitchStatement | MatchExpressionList | SwitchStatementCaseClause | TransactionalStatement | WhileStatement | YieldStatement | TranslationParameterList | TranslationParameterClause | ConstructorTranslation | IndexerTranslationParameterClause | IndexerTranslation | TranslationTypeParameterList | TranslationTypeParameterClause | PackageMethodTranslation | TypeMethodTranslation | MethodTypeTranslation | PackageImportTranslation | QualifiedName | PackageVariableTranslation | TypeVariableOrVariantTranslation | TypeMemberTranslationList | TypeTranslation | TextLiteralTranslation | TextTemplateLiteralTranslation | VariantDeclaration | TypeParameterDeclaration | ParameterDeclaration | CallArgument | TagList | Tag | ModifierList | Modifier | ParameterClause | ParameterList | SetterParameterClause | SetterParameterDeclaration | TypeArgumentClause | TypeArgumentList | TypeParameterClause | TypeParameterList | TypeAnnotation | Token;