@artel/artc 0.6.25191

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

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