/** * Copyright 2017 Matt Acosta * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import { AnonymousClassSyntaxNode, AnonymousFunctionSyntaxNode, AnonymousObjectCreationSyntaxNode, ArgumentSyntaxNode, ArraySyntaxNode, ArrayElementSyntaxNode, ArrowFunctionSyntaxNode, AssignmentSyntaxNode, BinarySyntaxNode, BreakSyntaxNode, ClassConstantSyntaxNode, ClassConstantDeclarationSyntaxNode, ClassConstantElementSyntaxNode, ClassDeclarationSyntaxNode, CloneSyntaxNode, ClosureUseSyntaxNode, ConditionalSyntaxNode, ConstantSyntaxNode, ConstantDeclarationSyntaxNode, ConstantElementSyntaxNode, ContinueSyntaxNode, DeclareSyntaxNode, DeclareBlockSyntaxNode, DestructuringAssignmentSyntaxNode, DoWhileSyntaxNode, EchoSyntaxNode, ElementAccessSyntaxNode, ElseSyntaxNode, ElseBlockSyntaxNode, ElseIfSyntaxNode, ElseIfBlockSyntaxNode, EmptyIntrinsicSyntaxNode, ErrorControlSyntaxNode, EvalIntrinsicSyntaxNode, ExitIntrinsicSyntaxNode, ExpressionGroupSyntaxNode, ExpressionStatementSyntaxNode, FlexibleHeredocElementSyntaxNode, FlexibleHeredocTemplateSyntaxNode, ForSyntaxNode, ForBlockSyntaxNode, ForEachSyntaxNode, ForEachBlockSyntaxNode, FullyQualifiedNameSyntaxNode, FunctionDeclarationSyntaxNode, FunctionInvocationSyntaxNode, GlobalSyntaxNode, GoToSyntaxNode, HaltCompilerSyntaxNode, HeredocTemplateSyntaxNode, IfSyntaxNode, IfBlockSyntaxNode, IncompleteMemberSyntaxNode, IncompleteNamedTraitAdaptationSyntaxNode, IncompleteReferencedTraitAdaptationSyntaxNode, IndirectMemberAccessSyntaxNode, IndirectMethodInvocationSyntaxNode, IndirectObjectCreationSyntaxNode, IndirectScopedInvocationSyntaxNode, IndirectStringVariableSyntaxNode, IndirectVariableSyntaxNode, InstanceOfSyntaxNode, InterfaceDeclarationSyntaxNode, IsSetIntrinsicSyntaxNode, LabelSyntaxNode, LexicalVariableSyntaxNode, ListDestructureSyntaxNode, ListDestructureElementSyntaxNode, LiteralSyntaxNode, LocalVariableSyntaxNode, MethodDeclarationSyntaxNode, MethodReferenceSyntaxNode, NamedMemberAccessSyntaxNode, NamedMethodInvocationSyntaxNode, NamedObjectCreationSyntaxNode, NamedScopedInvocationSyntaxNode, NamedTraitAliasSyntaxNode, NamedTypeSyntaxNode, NamespaceDeclarationSyntaxNode, NamespaceGroupDeclarationSyntaxNode, ParameterSyntaxNode, PartiallyQualifiedNameSyntaxNode, PostfixUnarySyntaxNode, PredefinedTypeSyntaxNode, PrintIntrinsicSyntaxNode, PropertyDeclarationSyntaxNode, PropertyElementSyntaxNode, ReferencedTraitAliasSyntaxNode, RelativeNameSyntaxNode, ReturnSyntaxNode, ScriptInclusionSyntaxNode, ShellCommandTemplateSyntaxNode, StatementBlockSyntaxNode, StaticSyntaxNode, StaticElementSyntaxNode, StaticPropertySyntaxNode, StringElementAccessSyntaxNode, StringExpressionSyntaxNode, StringTemplateSyntaxNode, StringVariableSyntaxNode, SwitchSyntaxNode, SwitchBlockSyntaxNode, SwitchCaseSyntaxNode, ThrowSyntaxNode, TraitDeclarationSyntaxNode, TraitPrecedenceSyntaxNode, TraitUseSyntaxNode, TraitUseGroupSyntaxNode, TrySyntaxNode, TryCatchSyntaxNode, TryFinallySyntaxNode, UnarySyntaxNode, UnsetSyntaxNode, UseDeclarationSyntaxNode, UseElementSyntaxNode, UseGroupDeclarationSyntaxNode, WhileSyntaxNode, WhileBlockSyntaxNode, YieldSyntaxNode, YieldFromSyntaxNode } from '../syntax/SyntaxNode.Generated'; import { INode } from './INode'; import { Node } from './Node'; import { NodeFlags } from './NodeFlags'; import { NodeList } from './NodeList'; import { NodeTransform } from './NodeTransform.Generated'; import { NodeVisitor } from './NodeVisitor.Generated'; import { SyntaxDiagnostic } from '../../diagnostics/SyntaxDiagnostic'; import { SyntaxNode } from '../syntax/SyntaxNode'; import { TokenNode } from './TokenNode'; export declare abstract class ExpressionNode extends Node { } export declare abstract class NameNode extends Node { abstract readonly namespaceName: NodeList; } export declare abstract class StatementNode extends Node { } export declare abstract class TraitAliasNode extends Node { abstract readonly asKeyword: TokenNode; abstract readonly modifier: TokenNode | null; abstract readonly alias: TokenNode | null; abstract readonly semicolon: TokenNode; } export declare abstract class TypeNode extends Node { abstract readonly question: TokenNode | null; } export declare class AnonymousClassNode extends Node { readonly classKeyword: TokenNode; readonly openParen: TokenNode | null; readonly argumentList: NodeList | null; readonly closeParen: TokenNode | null; readonly extendsKeyword: TokenNode | null; readonly baseType: NameNode | null; readonly implementsKeyword: TokenNode | null; readonly interfaces: NodeList | null; readonly openBrace: TokenNode; readonly members: NodeList | null; readonly closeBrace: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(classKeyword: TokenNode, openParen: TokenNode | null, argumentList: NodeList | null, closeParen: TokenNode | null, extendsKeyword: TokenNode | null, baseType: NameNode | null, implementsKeyword: TokenNode | null, interfaces: NodeList | null, openBrace: TokenNode, members: NodeList | null, closeBrace: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): AnonymousClassSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): AnonymousClassNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ArgumentNode extends Node { readonly ellipsis: TokenNode | null; readonly value: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(ellipsis: TokenNode | null, value: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ArgumentSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ArgumentNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ArrayElementNode extends Node { readonly key: ExpressionNode | null; readonly doubleArrow: TokenNode | null; readonly valueOperator: TokenNode | null; readonly value: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(key: ExpressionNode | null, doubleArrow: TokenNode | null, valueOperator: TokenNode | null, value: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ArrayElementSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ArrayElementNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ClassConstantElementNode extends Node { readonly identifierOrKeyword: TokenNode; readonly equal: TokenNode; readonly expression: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(identifierOrKeyword: TokenNode, equal: TokenNode, expression: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ClassConstantElementSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ClassConstantElementNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ClosureUseNode extends Node { readonly useKeyword: TokenNode; readonly openParen: TokenNode; readonly variables: NodeList; readonly closeParen: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(useKeyword: TokenNode, openParen: TokenNode, variables: NodeList, closeParen: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ClosureUseSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ClosureUseNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ConstantElementNode extends Node { readonly identifier: TokenNode; readonly equal: TokenNode; readonly expression: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(identifier: TokenNode, equal: TokenNode, expression: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ConstantElementSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ConstantElementNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ElseNode extends Node { readonly elseKeyword: TokenNode; readonly statement: StatementNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(elseKeyword: TokenNode, statement: StatementNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ElseSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ElseNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ElseBlockNode extends Node { readonly elseKeyword: TokenNode; readonly colon: TokenNode; readonly statements: NodeList | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(elseKeyword: TokenNode, colon: TokenNode, statements: NodeList | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ElseBlockSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ElseBlockNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ElseIfNode extends Node { readonly elseIfKeyword: TokenNode; readonly openParen: TokenNode; readonly condition: ExpressionNode; readonly closeParen: TokenNode; readonly statement: StatementNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(elseIfKeyword: TokenNode, openParen: TokenNode, condition: ExpressionNode, closeParen: TokenNode, statement: StatementNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ElseIfSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ElseIfNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ElseIfBlockNode extends Node { readonly elseIfKeyword: TokenNode; readonly openParen: TokenNode; readonly condition: ExpressionNode; readonly closeParen: TokenNode; readonly colon: TokenNode; readonly statements: NodeList | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(elseIfKeyword: TokenNode, openParen: TokenNode, condition: ExpressionNode, closeParen: TokenNode, colon: TokenNode, statements: NodeList | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ElseIfBlockSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ElseIfBlockNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class FlexibleHeredocElementNode extends Node { readonly indent: TokenNode; readonly template: NodeList | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(indent: TokenNode, template: NodeList | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): FlexibleHeredocElementSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): FlexibleHeredocElementNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class IncompleteNamedTraitAdaptationNode extends Node { readonly identifierOrKeyword: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(identifierOrKeyword: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): IncompleteNamedTraitAdaptationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): IncompleteNamedTraitAdaptationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class IncompleteReferencedTraitAdaptationNode extends Node { readonly reference: MethodReferenceNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(reference: MethodReferenceNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): IncompleteReferencedTraitAdaptationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): IncompleteReferencedTraitAdaptationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ListDestructureNode extends Node { readonly listKeyword: TokenNode; readonly openParen: TokenNode; readonly variables: NodeList | null; readonly closeParen: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(listKeyword: TokenNode, openParen: TokenNode, variables: NodeList | null, closeParen: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ListDestructureSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ListDestructureNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ListDestructureElementNode extends Node { readonly key: ExpressionNode | null; readonly doubleArrow: TokenNode | null; readonly ampersand: TokenNode | null; readonly value: ExpressionNode | ListDestructureNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(key: ExpressionNode | null, doubleArrow: TokenNode | null, ampersand: TokenNode | null, value: ExpressionNode | ListDestructureNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ListDestructureElementSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ListDestructureElementNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class MethodReferenceNode extends Node { readonly className: NameNode; readonly doubleColon: TokenNode; readonly methodName: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(className: NameNode, doubleColon: TokenNode, methodName: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): MethodReferenceSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): MethodReferenceNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ParameterNode extends Node { readonly type: NamedTypeNode | PredefinedTypeNode | null; readonly ampersand: TokenNode | null; readonly ellipsis: TokenNode | null; readonly variable: TokenNode; readonly equal: TokenNode | null; readonly expression: ExpressionNode | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(type: NamedTypeNode | PredefinedTypeNode | null, ampersand: TokenNode | null, ellipsis: TokenNode | null, variable: TokenNode, equal: TokenNode | null, expression: ExpressionNode | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ParameterSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ParameterNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class PropertyElementNode extends Node { readonly variable: TokenNode; readonly equal: TokenNode | null; readonly expression: ExpressionNode | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(variable: TokenNode, equal: TokenNode | null, expression: ExpressionNode | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): PropertyElementSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): PropertyElementNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class StaticElementNode extends Node { readonly variable: TokenNode; readonly equal: TokenNode | null; readonly expression: ExpressionNode | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(variable: TokenNode, equal: TokenNode | null, expression: ExpressionNode | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): StaticElementSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): StaticElementNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class SwitchCaseNode extends Node { readonly clauseKeyword: TokenNode; readonly expression: ExpressionNode | null; readonly separator: TokenNode; readonly statements: NodeList | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(clauseKeyword: TokenNode, expression: ExpressionNode | null, separator: TokenNode, statements: NodeList | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): SwitchCaseSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): SwitchCaseNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class TraitPrecedenceNode extends Node { readonly methodReference: MethodReferenceNode; readonly insteadOfKeyword: TokenNode; readonly traitNames: NodeList; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(methodReference: MethodReferenceNode, insteadOfKeyword: TokenNode, traitNames: NodeList, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): TraitPrecedenceSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): TraitPrecedenceNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class TryCatchNode extends Node { readonly catchKeyword: TokenNode; readonly openParen: TokenNode; readonly typeNames: NodeList; readonly variable: TokenNode; readonly closeParen: TokenNode; readonly statements: StatementBlockNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(catchKeyword: TokenNode, openParen: TokenNode, typeNames: NodeList, variable: TokenNode, closeParen: TokenNode, statements: StatementBlockNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): TryCatchSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): TryCatchNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class TryFinallyNode extends Node { readonly finallyKeyword: TokenNode; readonly statements: StatementBlockNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(finallyKeyword: TokenNode, statements: StatementBlockNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): TryFinallySyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): TryFinallyNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class UseElementNode extends Node { readonly typeKeyword: TokenNode | null; readonly target: NameNode; readonly asKeyword: TokenNode | null; readonly alias: TokenNode | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(typeKeyword: TokenNode | null, target: NameNode, asKeyword: TokenNode | null, alias: TokenNode | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): UseElementSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): UseElementNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare abstract class IntrinsicNode extends ExpressionNode { } export declare abstract class InvocationNode extends ExpressionNode { abstract readonly openParen: TokenNode; abstract readonly argumentList: NodeList | null; abstract readonly closeParen: TokenNode; } export declare abstract class IterationNode extends StatementNode { } export declare abstract class JumpNode extends StatementNode { } export declare abstract class MemberAccessNode extends ExpressionNode { abstract readonly dereferencable: ExpressionNode; abstract readonly objectOperator: TokenNode; } export declare abstract class MemberInvocationNode extends InvocationNode { abstract readonly dereferenceable: ExpressionNode; abstract readonly objectOperator: TokenNode; abstract readonly openParen: TokenNode; abstract readonly argumentList: NodeList | null; abstract readonly closeParen: TokenNode; } export declare abstract class ObjectCreationNode extends ExpressionNode { abstract readonly newKeyword: TokenNode; } export declare abstract class ScopedAccessNode extends ExpressionNode { abstract readonly qualifier: ExpressionNode | NameNode; abstract readonly doubleColon: TokenNode; } export declare abstract class ScopedInvocationNode extends InvocationNode { abstract readonly qualifier: ExpressionNode | NameNode; abstract readonly doubleColon: TokenNode; abstract readonly openParen: TokenNode; abstract readonly argumentList: NodeList | null; abstract readonly closeParen: TokenNode; } export declare abstract class SelectionNode extends StatementNode { } export declare abstract class TypeDeclarationNode extends StatementNode { abstract readonly identifier: TokenNode; abstract readonly openBrace: TokenNode; abstract readonly members: NodeList | null; abstract readonly closeBrace: TokenNode; } export declare abstract class VariableNode extends ExpressionNode { } export declare class AnonymousFunctionNode extends ExpressionNode { readonly staticKeyword: TokenNode | null; readonly functionKeyword: TokenNode; readonly ampersand: TokenNode | null; readonly openParen: TokenNode; readonly parameters: NodeList | null; readonly closeParen: TokenNode; readonly useClause: ClosureUseNode | null; readonly colon: TokenNode | null; readonly returnType: NamedTypeNode | PredefinedTypeNode | null; readonly statements: StatementBlockNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(staticKeyword: TokenNode | null, functionKeyword: TokenNode, ampersand: TokenNode | null, openParen: TokenNode, parameters: NodeList | null, closeParen: TokenNode, useClause: ClosureUseNode | null, colon: TokenNode | null, returnType: NamedTypeNode | PredefinedTypeNode | null, statements: StatementBlockNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): AnonymousFunctionSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): AnonymousFunctionNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class AnonymousObjectCreationNode extends ObjectCreationNode { readonly newKeyword: TokenNode; readonly anonymousClass: AnonymousClassNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(newKeyword: TokenNode, anonymousClass: AnonymousClassNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): AnonymousObjectCreationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): AnonymousObjectCreationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ArrayNode extends ExpressionNode { readonly arrayKeyword: TokenNode | null; readonly openParenOrBracket: TokenNode; readonly initializerList: NodeList | null; readonly closeParenOrBracket: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(arrayKeyword: TokenNode | null, openParenOrBracket: TokenNode, initializerList: NodeList | null, closeParenOrBracket: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ArraySyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ArrayNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ArrowFunctionNode extends ExpressionNode { readonly staticKeyword: TokenNode | null; readonly fnKeyword: TokenNode; readonly ampersand: TokenNode | null; readonly openParen: TokenNode; readonly parameters: NodeList | null; readonly closeParen: TokenNode; readonly colon: TokenNode | null; readonly returnType: NamedTypeNode | PredefinedTypeNode | null; readonly doubleArrow: TokenNode; readonly expr: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(staticKeyword: TokenNode | null, fnKeyword: TokenNode, ampersand: TokenNode | null, openParen: TokenNode, parameters: NodeList | null, closeParen: TokenNode, colon: TokenNode | null, returnType: NamedTypeNode | PredefinedTypeNode | null, doubleArrow: TokenNode, expr: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ArrowFunctionSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ArrowFunctionNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class AssignmentNode extends ExpressionNode { readonly leftOperand: ExpressionNode; readonly operator: TokenNode; readonly ampersand: TokenNode | null; readonly rightOperand: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(leftOperand: ExpressionNode, operator: TokenNode, ampersand: TokenNode | null, rightOperand: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): AssignmentSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): AssignmentNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class BinaryNode extends ExpressionNode { readonly leftOperand: ExpressionNode; readonly operator: TokenNode; readonly rightOperand: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(leftOperand: ExpressionNode, operator: TokenNode, rightOperand: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): BinarySyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): BinaryNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class BreakNode extends JumpNode { readonly breakKeyword: TokenNode; readonly depth: ExpressionNode | null; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(breakKeyword: TokenNode, depth: ExpressionNode | null, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): BreakSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): BreakNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ClassConstantNode extends ScopedAccessNode { readonly qualifier: ExpressionNode | NameNode; readonly doubleColon: TokenNode; readonly identifier: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(qualifier: ExpressionNode | NameNode, doubleColon: TokenNode, identifier: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ClassConstantSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ClassConstantNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ClassConstantDeclarationNode extends StatementNode { readonly modifiers: NodeList | null; readonly constKeyword: TokenNode; readonly elements: NodeList; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(modifiers: NodeList | null, constKeyword: TokenNode, elements: NodeList, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ClassConstantDeclarationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ClassConstantDeclarationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ClassDeclarationNode extends TypeDeclarationNode { readonly modifiers: NodeList | null; readonly classKeyword: TokenNode; readonly identifier: TokenNode; readonly extendsKeyword: TokenNode | null; readonly baseType: NameNode | null; readonly implementsKeyword: TokenNode | null; readonly interfaces: NodeList | null; readonly openBrace: TokenNode; readonly members: NodeList | null; readonly closeBrace: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(modifiers: NodeList | null, classKeyword: TokenNode, identifier: TokenNode, extendsKeyword: TokenNode | null, baseType: NameNode | null, implementsKeyword: TokenNode | null, interfaces: NodeList | null, openBrace: TokenNode, members: NodeList | null, closeBrace: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ClassDeclarationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ClassDeclarationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class CloneNode extends ExpressionNode { readonly cloneKeyword: TokenNode; readonly expression: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(cloneKeyword: TokenNode, expression: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): CloneSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): CloneNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ConditionalNode extends ExpressionNode { readonly condition: ExpressionNode; readonly question: TokenNode; readonly trueExpr: ExpressionNode | null; readonly colon: TokenNode; readonly falseExpr: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(condition: ExpressionNode, question: TokenNode, trueExpr: ExpressionNode | null, colon: TokenNode, falseExpr: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ConditionalSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ConditionalNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ConstantNode extends ExpressionNode { readonly name: NameNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(name: NameNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ConstantSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ConstantNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ConstantDeclarationNode extends StatementNode { readonly constKeyword: TokenNode; readonly elements: NodeList; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(constKeyword: TokenNode, elements: NodeList, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ConstantDeclarationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ConstantDeclarationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ContinueNode extends JumpNode { readonly continueKeyword: TokenNode; readonly depth: ExpressionNode | null; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(continueKeyword: TokenNode, depth: ExpressionNode | null, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ContinueSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ContinueNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class DeclareNode extends StatementNode { readonly declareKeyword: TokenNode; readonly openParen: TokenNode; readonly directives: NodeList; readonly closeParen: TokenNode; readonly statement: StatementNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(declareKeyword: TokenNode, openParen: TokenNode, directives: NodeList, closeParen: TokenNode, statement: StatementNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): DeclareSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): DeclareNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class DeclareBlockNode extends StatementNode { readonly declareKeyword: TokenNode; readonly openParen: TokenNode; readonly directives: NodeList; readonly closeParen: TokenNode; readonly colon: TokenNode; readonly statements: NodeList | null; readonly endDeclare: TokenNode; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(declareKeyword: TokenNode, openParen: TokenNode, directives: NodeList, closeParen: TokenNode, colon: TokenNode, statements: NodeList | null, endDeclare: TokenNode, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): DeclareBlockSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): DeclareBlockNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class DestructuringAssignmentNode extends ExpressionNode { readonly unpackedList: ArrayNode | ListDestructureNode; readonly operator: TokenNode; readonly operand: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(unpackedList: ArrayNode | ListDestructureNode, operator: TokenNode, operand: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): DestructuringAssignmentSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): DestructuringAssignmentNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class DoWhileNode extends IterationNode { readonly doKeyword: TokenNode; readonly statement: StatementNode; readonly whileKeyword: TokenNode; readonly openParen: TokenNode; readonly condition: ExpressionNode; readonly closeParen: TokenNode; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(doKeyword: TokenNode, statement: StatementNode, whileKeyword: TokenNode, openParen: TokenNode, condition: ExpressionNode, closeParen: TokenNode, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): DoWhileSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): DoWhileNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class EchoNode extends StatementNode { readonly echoKeyword: TokenNode | null; readonly expressionList: NodeList; readonly semicolon: TokenNode | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(echoKeyword: TokenNode | null, expressionList: NodeList, semicolon: TokenNode | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): EchoSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): EchoNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ElementAccessNode extends ExpressionNode { readonly dereferencable: ExpressionNode; readonly openBraceOrBracket: TokenNode; readonly index: ExpressionNode | null; readonly closeBraceOrBracket: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(dereferencable: ExpressionNode, openBraceOrBracket: TokenNode, index: ExpressionNode | null, closeBraceOrBracket: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ElementAccessSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ElementAccessNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class EmptyIntrinsicNode extends IntrinsicNode { readonly emptyKeyword: TokenNode; readonly openParen: TokenNode; readonly expression: ExpressionNode; readonly closeParen: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(emptyKeyword: TokenNode, openParen: TokenNode, expression: ExpressionNode, closeParen: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): EmptyIntrinsicSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): EmptyIntrinsicNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ErrorControlNode extends ExpressionNode { readonly at: TokenNode; readonly expression: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(at: TokenNode, expression: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ErrorControlSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ErrorControlNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class EvalIntrinsicNode extends IntrinsicNode { readonly evalKeyword: TokenNode; readonly openParen: TokenNode; readonly expression: ExpressionNode; readonly closeParen: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(evalKeyword: TokenNode, openParen: TokenNode, expression: ExpressionNode, closeParen: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): EvalIntrinsicSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): EvalIntrinsicNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ExitIntrinsicNode extends IntrinsicNode { readonly exitOrDieKeyword: TokenNode; readonly openParen: TokenNode | null; readonly expression: ExpressionNode | null; readonly closeParen: TokenNode | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(exitOrDieKeyword: TokenNode, openParen: TokenNode | null, expression: ExpressionNode | null, closeParen: TokenNode | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ExitIntrinsicSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ExitIntrinsicNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ExpressionGroupNode extends ExpressionNode { readonly openParen: TokenNode; readonly expression: ExpressionNode; readonly closeParen: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(openParen: TokenNode, expression: ExpressionNode, closeParen: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ExpressionGroupSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ExpressionGroupNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ExpressionStatementNode extends StatementNode { readonly expression: ExpressionNode | null; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(expression: ExpressionNode | null, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ExpressionStatementSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ExpressionStatementNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class FlexibleHeredocTemplateNode extends ExpressionNode { readonly heredocStart: TokenNode; readonly flexibleElements: NodeList; readonly heredocEnd: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(heredocStart: TokenNode, flexibleElements: NodeList, heredocEnd: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): FlexibleHeredocTemplateSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): FlexibleHeredocTemplateNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ForNode extends IterationNode { readonly forKeyword: TokenNode; readonly openParen: TokenNode; readonly initializers: NodeList | null; readonly firstSemicolon: TokenNode; readonly conditions: NodeList | null; readonly secondSemicolon: TokenNode; readonly incrementors: NodeList | null; readonly closeParen: TokenNode; readonly statement: StatementNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(forKeyword: TokenNode, openParen: TokenNode, initializers: NodeList | null, firstSemicolon: TokenNode, conditions: NodeList | null, secondSemicolon: TokenNode, incrementors: NodeList | null, closeParen: TokenNode, statement: StatementNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ForSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ForNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ForBlockNode extends IterationNode { readonly forKeyword: TokenNode; readonly openParen: TokenNode; readonly initializers: NodeList | null; readonly firstSemicolon: TokenNode; readonly conditions: NodeList | null; readonly secondSemicolon: TokenNode; readonly incrementors: NodeList | null; readonly closeParen: TokenNode; readonly colon: TokenNode; readonly statements: NodeList | null; readonly endForKeyword: TokenNode; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(forKeyword: TokenNode, openParen: TokenNode, initializers: NodeList | null, firstSemicolon: TokenNode, conditions: NodeList | null, secondSemicolon: TokenNode, incrementors: NodeList | null, closeParen: TokenNode, colon: TokenNode, statements: NodeList | null, endForKeyword: TokenNode, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ForBlockSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ForBlockNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ForEachNode extends IterationNode { readonly forEachKeyword: TokenNode; readonly openParen: TokenNode; readonly source: ExpressionNode; readonly asKeyword: TokenNode; readonly key: ExpressionNode | null; readonly doubleArrow: TokenNode | null; readonly ampersand: TokenNode | null; readonly value: ExpressionNode | ListDestructureNode; readonly closeParen: TokenNode; readonly statement: StatementNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(forEachKeyword: TokenNode, openParen: TokenNode, source: ExpressionNode, asKeyword: TokenNode, key: ExpressionNode | null, doubleArrow: TokenNode | null, ampersand: TokenNode | null, value: ExpressionNode | ListDestructureNode, closeParen: TokenNode, statement: StatementNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ForEachSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ForEachNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ForEachBlockNode extends IterationNode { readonly forEachKeyword: TokenNode; readonly openParen: TokenNode; readonly source: ExpressionNode; readonly asKeyword: TokenNode; readonly key: ExpressionNode | null; readonly doubleArrow: TokenNode | null; readonly ampersand: TokenNode | null; readonly value: ExpressionNode | ListDestructureNode; readonly closeParen: TokenNode; readonly colon: TokenNode; readonly statements: NodeList | null; readonly endForEach: TokenNode; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(forEachKeyword: TokenNode, openParen: TokenNode, source: ExpressionNode, asKeyword: TokenNode, key: ExpressionNode | null, doubleArrow: TokenNode | null, ampersand: TokenNode | null, value: ExpressionNode | ListDestructureNode, closeParen: TokenNode, colon: TokenNode, statements: NodeList | null, endForEach: TokenNode, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ForEachBlockSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ForEachBlockNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class FullyQualifiedNameNode extends NameNode { readonly leadingBackslash: TokenNode; readonly namespaceName: NodeList; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(leadingBackslash: TokenNode, namespaceName: NodeList, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): FullyQualifiedNameSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): FullyQualifiedNameNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class FunctionDeclarationNode extends StatementNode { readonly functionKeyword: TokenNode; readonly ampersand: TokenNode | null; readonly identifier: TokenNode; readonly openParen: TokenNode; readonly parameters: NodeList | null; readonly closeParen: TokenNode; readonly colon: TokenNode | null; readonly returnType: NamedTypeNode | PredefinedTypeNode | null; readonly statements: StatementBlockNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(functionKeyword: TokenNode, ampersand: TokenNode | null, identifier: TokenNode, openParen: TokenNode, parameters: NodeList | null, closeParen: TokenNode, colon: TokenNode | null, returnType: NamedTypeNode | PredefinedTypeNode | null, statements: StatementBlockNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): FunctionDeclarationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): FunctionDeclarationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class FunctionInvocationNode extends InvocationNode { readonly reference: ExpressionNode | NameNode; readonly openParen: TokenNode; readonly argumentList: NodeList | null; readonly closeParen: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(reference: ExpressionNode | NameNode, openParen: TokenNode, argumentList: NodeList | null, closeParen: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): FunctionInvocationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): FunctionInvocationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class GlobalNode extends StatementNode { readonly globalKeyword: TokenNode; readonly variables: NodeList; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(globalKeyword: TokenNode, variables: NodeList, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): GlobalSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): GlobalNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class GoToNode extends JumpNode { readonly gotoKeyword: TokenNode; readonly label: TokenNode; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(gotoKeyword: TokenNode, label: TokenNode, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): GoToSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): GoToNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class HaltCompilerNode extends StatementNode { readonly haltCompilerKeyword: TokenNode; readonly openParen: TokenNode; readonly closeParen: TokenNode; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(haltCompilerKeyword: TokenNode, openParen: TokenNode, closeParen: TokenNode, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): HaltCompilerSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): HaltCompilerNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class HeredocTemplateNode extends ExpressionNode { readonly heredocStart: TokenNode; readonly template: NodeList | null; readonly heredocEnd: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(heredocStart: TokenNode, template: NodeList | null, heredocEnd: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): HeredocTemplateSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): HeredocTemplateNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class IfNode extends SelectionNode { readonly ifKeyword: TokenNode; readonly openParen: TokenNode; readonly condition: ExpressionNode; readonly closeParen: TokenNode; readonly statement: StatementNode; readonly elseIfClauses: NodeList | null; readonly elseClause: ElseNode | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(ifKeyword: TokenNode, openParen: TokenNode, condition: ExpressionNode, closeParen: TokenNode, statement: StatementNode, elseIfClauses: NodeList | null, elseClause: ElseNode | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): IfSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): IfNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class IfBlockNode extends SelectionNode { readonly ifKeyword: TokenNode; readonly openParen: TokenNode; readonly condition: ExpressionNode; readonly closeParen: TokenNode; readonly colon: TokenNode; readonly statements: NodeList | null; readonly elseIfClauses: NodeList | null; readonly elseClause: ElseBlockNode | null; readonly endIfKeyword: TokenNode; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(ifKeyword: TokenNode, openParen: TokenNode, condition: ExpressionNode, closeParen: TokenNode, colon: TokenNode, statements: NodeList | null, elseIfClauses: NodeList | null, elseClause: ElseBlockNode | null, endIfKeyword: TokenNode, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): IfBlockSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): IfBlockNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class IncompleteMemberNode extends StatementNode { readonly modifiers: NodeList; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(modifiers: NodeList, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): IncompleteMemberSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): IncompleteMemberNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class IndirectMemberAccessNode extends MemberAccessNode { readonly dereferencable: ExpressionNode; readonly objectOperator: TokenNode; readonly openBrace: TokenNode | null; readonly member: ExpressionNode; readonly closeBrace: TokenNode | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(dereferencable: ExpressionNode, objectOperator: TokenNode, openBrace: TokenNode | null, member: ExpressionNode, closeBrace: TokenNode | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): IndirectMemberAccessSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): IndirectMemberAccessNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class IndirectMethodInvocationNode extends MemberInvocationNode { readonly dereferenceable: ExpressionNode; readonly objectOperator: TokenNode; readonly openBrace: TokenNode | null; readonly member: ExpressionNode; readonly closeBrace: TokenNode | null; readonly openParen: TokenNode; readonly argumentList: NodeList | null; readonly closeParen: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(dereferenceable: ExpressionNode, objectOperator: TokenNode, openBrace: TokenNode | null, member: ExpressionNode, closeBrace: TokenNode | null, openParen: TokenNode, argumentList: NodeList | null, closeParen: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): IndirectMethodInvocationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): IndirectMethodInvocationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class IndirectObjectCreationNode extends ObjectCreationNode { readonly newKeyword: TokenNode; readonly classNameReference: ExpressionNode; readonly openParen: TokenNode | null; readonly argumentList: NodeList | null; readonly closeParen: TokenNode | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(newKeyword: TokenNode, classNameReference: ExpressionNode, openParen: TokenNode | null, argumentList: NodeList | null, closeParen: TokenNode | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): IndirectObjectCreationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): IndirectObjectCreationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class IndirectScopedInvocationNode extends ScopedInvocationNode { readonly qualifier: ExpressionNode | NameNode; readonly doubleColon: TokenNode; readonly openBrace: TokenNode | null; readonly member: ExpressionNode; readonly closeBrace: TokenNode | null; readonly openParen: TokenNode; readonly argumentList: NodeList | null; readonly closeParen: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(qualifier: ExpressionNode | NameNode, doubleColon: TokenNode, openBrace: TokenNode | null, member: ExpressionNode, closeBrace: TokenNode | null, openParen: TokenNode, argumentList: NodeList | null, closeParen: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): IndirectScopedInvocationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): IndirectScopedInvocationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class IndirectStringVariableNode extends ExpressionNode { readonly dollarOpenBrace: TokenNode; readonly expression: ExpressionNode; readonly closeBrace: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(dollarOpenBrace: TokenNode, expression: ExpressionNode, closeBrace: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): IndirectStringVariableSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): IndirectStringVariableNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class IndirectVariableNode extends VariableNode { readonly dollar: TokenNode; readonly openBrace: TokenNode | null; readonly expression: ExpressionNode; readonly closeBrace: TokenNode | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(dollar: TokenNode, openBrace: TokenNode | null, expression: ExpressionNode, closeBrace: TokenNode | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): IndirectVariableSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): IndirectVariableNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class InstanceOfNode extends ExpressionNode { readonly operand: ExpressionNode; readonly instanceOfKeyword: TokenNode; readonly classNameOrReference: ExpressionNode | NameNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(operand: ExpressionNode, instanceOfKeyword: TokenNode, classNameOrReference: ExpressionNode | NameNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): InstanceOfSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): InstanceOfNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class InterfaceDeclarationNode extends TypeDeclarationNode { readonly interfaceKeyword: TokenNode; readonly identifier: TokenNode; readonly extendsKeyword: TokenNode | null; readonly baseInterfaces: NodeList | null; readonly openBrace: TokenNode; readonly members: NodeList | null; readonly closeBrace: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(interfaceKeyword: TokenNode, identifier: TokenNode, extendsKeyword: TokenNode | null, baseInterfaces: NodeList | null, openBrace: TokenNode, members: NodeList | null, closeBrace: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): InterfaceDeclarationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): InterfaceDeclarationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class IsSetIntrinsicNode extends IntrinsicNode { readonly isSetKeyword: TokenNode; readonly openParen: TokenNode; readonly expressions: NodeList; readonly closeParen: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(isSetKeyword: TokenNode, openParen: TokenNode, expressions: NodeList, closeParen: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): IsSetIntrinsicSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): IsSetIntrinsicNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class LabelNode extends StatementNode { readonly label: TokenNode; readonly colon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(label: TokenNode, colon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): LabelSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): LabelNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class LexicalVariableNode extends VariableNode { readonly ampersand: TokenNode | null; readonly variable: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(ampersand: TokenNode | null, variable: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): LexicalVariableSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): LexicalVariableNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class LiteralNode extends ExpressionNode { readonly value: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(value: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): LiteralSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): LiteralNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class LocalVariableNode extends VariableNode { readonly variable: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(variable: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): LocalVariableSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): LocalVariableNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class MethodDeclarationNode extends StatementNode { readonly modifiers: NodeList | null; readonly functionKeyword: TokenNode; readonly ampersand: TokenNode | null; readonly identifierOrKeyword: TokenNode; readonly openParen: TokenNode; readonly parameters: NodeList | null; readonly closeParen: TokenNode; readonly colon: TokenNode | null; readonly returnType: NamedTypeNode | PredefinedTypeNode | null; readonly statements: StatementBlockNode | null; readonly semicolon: TokenNode | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(modifiers: NodeList | null, functionKeyword: TokenNode, ampersand: TokenNode | null, identifierOrKeyword: TokenNode, openParen: TokenNode, parameters: NodeList | null, closeParen: TokenNode, colon: TokenNode | null, returnType: NamedTypeNode | PredefinedTypeNode | null, statements: StatementBlockNode | null, semicolon: TokenNode | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): MethodDeclarationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): MethodDeclarationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class NamedMemberAccessNode extends MemberAccessNode { readonly dereferencable: ExpressionNode; readonly objectOperator: TokenNode; readonly member: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(dereferencable: ExpressionNode, objectOperator: TokenNode, member: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): NamedMemberAccessSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): NamedMemberAccessNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class NamedMethodInvocationNode extends MemberInvocationNode { readonly dereferenceable: ExpressionNode; readonly objectOperator: TokenNode; readonly identifierOrKeyword: TokenNode; readonly openParen: TokenNode; readonly argumentList: NodeList | null; readonly closeParen: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(dereferenceable: ExpressionNode, objectOperator: TokenNode, identifierOrKeyword: TokenNode, openParen: TokenNode, argumentList: NodeList | null, closeParen: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): NamedMethodInvocationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): NamedMethodInvocationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class NamedObjectCreationNode extends ObjectCreationNode { readonly newKeyword: TokenNode; readonly className: NameNode; readonly openParen: TokenNode | null; readonly argumentList: NodeList | null; readonly closeParen: TokenNode | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(newKeyword: TokenNode, className: NameNode, openParen: TokenNode | null, argumentList: NodeList | null, closeParen: TokenNode | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): NamedObjectCreationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): NamedObjectCreationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class NamedScopedInvocationNode extends ScopedInvocationNode { readonly qualifier: ExpressionNode | NameNode; readonly doubleColon: TokenNode; readonly member: TokenNode; readonly openParen: TokenNode; readonly argumentList: NodeList | null; readonly closeParen: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(qualifier: ExpressionNode | NameNode, doubleColon: TokenNode, member: TokenNode, openParen: TokenNode, argumentList: NodeList | null, closeParen: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): NamedScopedInvocationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): NamedScopedInvocationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class NamedTraitAliasNode extends TraitAliasNode { readonly methodName: TokenNode; readonly asKeyword: TokenNode; readonly modifier: TokenNode | null; readonly alias: TokenNode | null; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(methodName: TokenNode, asKeyword: TokenNode, modifier: TokenNode | null, alias: TokenNode | null, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): NamedTraitAliasSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): NamedTraitAliasNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class NamedTypeNode extends TypeNode { readonly question: TokenNode | null; readonly typeName: NameNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(question: TokenNode | null, typeName: NameNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): NamedTypeSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): NamedTypeNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class NamespaceDeclarationNode extends StatementNode { readonly namespaceKeyword: TokenNode; readonly name: NameNode; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(namespaceKeyword: TokenNode, name: NameNode, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): NamespaceDeclarationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): NamespaceDeclarationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class NamespaceGroupDeclarationNode extends StatementNode { readonly namespaceKeyword: TokenNode; readonly name: NameNode | null; readonly openBrace: TokenNode; readonly statements: NodeList | null; readonly closeBrace: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(namespaceKeyword: TokenNode, name: NameNode | null, openBrace: TokenNode, statements: NodeList | null, closeBrace: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): NamespaceGroupDeclarationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): NamespaceGroupDeclarationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class PartiallyQualifiedNameNode extends NameNode { readonly namespaceName: NodeList; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(namespaceName: NodeList, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): PartiallyQualifiedNameSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): PartiallyQualifiedNameNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class PostfixUnaryNode extends ExpressionNode { readonly operand: ExpressionNode; readonly operator: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(operand: ExpressionNode, operator: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): PostfixUnarySyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): PostfixUnaryNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class PredefinedTypeNode extends TypeNode { readonly question: TokenNode | null; readonly keyword: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(question: TokenNode | null, keyword: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): PredefinedTypeSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): PredefinedTypeNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class PrintIntrinsicNode extends IntrinsicNode { readonly printKeyword: TokenNode; readonly expression: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(printKeyword: TokenNode, expression: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): PrintIntrinsicSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): PrintIntrinsicNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class PropertyDeclarationNode extends StatementNode { readonly modifiers: NodeList; readonly type: NamedTypeNode | PredefinedTypeNode | null; readonly properties: NodeList; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(modifiers: NodeList, type: NamedTypeNode | PredefinedTypeNode | null, properties: NodeList, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): PropertyDeclarationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): PropertyDeclarationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ReferencedTraitAliasNode extends TraitAliasNode { readonly reference: MethodReferenceNode; readonly asKeyword: TokenNode; readonly modifier: TokenNode | null; readonly alias: TokenNode | null; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(reference: MethodReferenceNode, asKeyword: TokenNode, modifier: TokenNode | null, alias: TokenNode | null, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ReferencedTraitAliasSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ReferencedTraitAliasNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class RelativeNameNode extends NameNode { readonly namespaceKeyword: TokenNode; readonly leadingBackslash: TokenNode; readonly namespaceName: NodeList; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(namespaceKeyword: TokenNode, leadingBackslash: TokenNode, namespaceName: NodeList, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): RelativeNameSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): RelativeNameNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ReturnNode extends JumpNode { readonly returnKeyword: TokenNode; readonly expression: ExpressionNode | null; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(returnKeyword: TokenNode, expression: ExpressionNode | null, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ReturnSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ReturnNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ScriptInclusionNode extends IntrinsicNode { readonly inclusionKeyword: TokenNode; readonly expression: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(inclusionKeyword: TokenNode, expression: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ScriptInclusionSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ScriptInclusionNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ShellCommandTemplateNode extends ExpressionNode { readonly openBackQuote: TokenNode; readonly template: NodeList | null; readonly closeBackQuote: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(openBackQuote: TokenNode, template: NodeList | null, closeBackQuote: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ShellCommandTemplateSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ShellCommandTemplateNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class StatementBlockNode extends StatementNode { readonly openBrace: TokenNode; readonly statements: NodeList | null; readonly closeBrace: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(openBrace: TokenNode, statements: NodeList | null, closeBrace: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): StatementBlockSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): StatementBlockNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class StaticNode extends StatementNode { readonly staticKeyword: TokenNode; readonly variables: NodeList; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(staticKeyword: TokenNode, variables: NodeList, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): StaticSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): StaticNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class StaticPropertyNode extends ScopedAccessNode { readonly qualifier: ExpressionNode | NameNode; readonly doubleColon: TokenNode; readonly member: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(qualifier: ExpressionNode | NameNode, doubleColon: TokenNode, member: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): StaticPropertySyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): StaticPropertyNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class StringElementAccessNode extends ExpressionNode { readonly variable: TokenNode; readonly openBracket: TokenNode; readonly minus: TokenNode | null; readonly index: TokenNode; readonly closeBracket: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(variable: TokenNode, openBracket: TokenNode, minus: TokenNode | null, index: TokenNode, closeBracket: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): StringElementAccessSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): StringElementAccessNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class StringExpressionNode extends ExpressionNode { readonly openBrace: TokenNode; readonly expression: ExpressionNode; readonly closeBrace: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(openBrace: TokenNode, expression: ExpressionNode, closeBrace: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): StringExpressionSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): StringExpressionNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class StringTemplateNode extends ExpressionNode { readonly openQuote: TokenNode; readonly template: NodeList; readonly closeQuote: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(openQuote: TokenNode, template: NodeList, closeQuote: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): StringTemplateSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): StringTemplateNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class StringVariableNode extends VariableNode { readonly identifier: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(identifier: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): StringVariableSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): StringVariableNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class SwitchNode extends SelectionNode { readonly switchKeyword: TokenNode; readonly openParen: TokenNode; readonly expression: ExpressionNode; readonly closeParen: TokenNode; readonly openBrace: TokenNode; readonly caseSemicolon: TokenNode | null; readonly caseClauses: NodeList | null; readonly closeBrace: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(switchKeyword: TokenNode, openParen: TokenNode, expression: ExpressionNode, closeParen: TokenNode, openBrace: TokenNode, caseSemicolon: TokenNode | null, caseClauses: NodeList | null, closeBrace: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): SwitchSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): SwitchNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class SwitchBlockNode extends SelectionNode { readonly switchKeyword: TokenNode; readonly openParen: TokenNode; readonly expression: ExpressionNode; readonly closeParen: TokenNode; readonly colon: TokenNode; readonly caseSemicolon: TokenNode | null; readonly caseClauses: NodeList | null; readonly endSwitch: TokenNode; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(switchKeyword: TokenNode, openParen: TokenNode, expression: ExpressionNode, closeParen: TokenNode, colon: TokenNode, caseSemicolon: TokenNode | null, caseClauses: NodeList | null, endSwitch: TokenNode, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): SwitchBlockSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): SwitchBlockNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class ThrowNode extends StatementNode { readonly throwKeyword: TokenNode; readonly expression: ExpressionNode; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(throwKeyword: TokenNode, expression: ExpressionNode, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): ThrowSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): ThrowNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class TraitDeclarationNode extends TypeDeclarationNode { readonly traitKeyword: TokenNode; readonly identifier: TokenNode; readonly openBrace: TokenNode; readonly members: NodeList | null; readonly closeBrace: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(traitKeyword: TokenNode, identifier: TokenNode, openBrace: TokenNode, members: NodeList | null, closeBrace: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): TraitDeclarationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): TraitDeclarationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class TraitUseNode extends StatementNode { readonly useKeyword: TokenNode; readonly traitNames: NodeList; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(useKeyword: TokenNode, traitNames: NodeList, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): TraitUseSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): TraitUseNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class TraitUseGroupNode extends StatementNode { readonly useKeyword: TokenNode; readonly traitNames: NodeList; readonly openBrace: TokenNode; readonly adaptations: NodeList | null; readonly closeBrace: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(useKeyword: TokenNode, traitNames: NodeList, openBrace: TokenNode, adaptations: NodeList | null, closeBrace: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): TraitUseGroupSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): TraitUseGroupNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class TryNode extends StatementNode { readonly tryKeyword: TokenNode; readonly statements: StatementBlockNode; readonly catchClauses: NodeList | null; readonly finallyClause: TryFinallyNode | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(tryKeyword: TokenNode, statements: StatementBlockNode, catchClauses: NodeList | null, finallyClause: TryFinallyNode | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): TrySyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): TryNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class UnaryNode extends ExpressionNode { readonly operator: TokenNode; readonly operand: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(operator: TokenNode, operand: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): UnarySyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): UnaryNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class UnsetNode extends StatementNode { readonly unsetKeyword: TokenNode; readonly openParen: TokenNode; readonly expressionList: NodeList; readonly closeParen: TokenNode; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(unsetKeyword: TokenNode, openParen: TokenNode, expressionList: NodeList, closeParen: TokenNode, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): UnsetSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): UnsetNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class UseDeclarationNode extends StatementNode { readonly useKeyword: TokenNode; readonly useType: TokenNode | null; readonly declarations: NodeList; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(useKeyword: TokenNode, useType: TokenNode | null, declarations: NodeList, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): UseDeclarationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): UseDeclarationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class UseGroupDeclarationNode extends StatementNode { readonly useKeyword: TokenNode; readonly useType: TokenNode | null; readonly rootName: NodeList; readonly openBrace: TokenNode; readonly declarations: NodeList; readonly closeBrace: TokenNode; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(useKeyword: TokenNode, useType: TokenNode | null, rootName: NodeList, openBrace: TokenNode, declarations: NodeList, closeBrace: TokenNode, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): UseGroupDeclarationSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): UseGroupDeclarationNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class WhileNode extends IterationNode { readonly whileKeyword: TokenNode; readonly openParen: TokenNode; readonly condition: ExpressionNode; readonly closeParen: TokenNode; readonly statement: StatementNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(whileKeyword: TokenNode, openParen: TokenNode, condition: ExpressionNode, closeParen: TokenNode, statement: StatementNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): WhileSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): WhileNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class WhileBlockNode extends IterationNode { readonly whileKeyword: TokenNode; readonly openParen: TokenNode; readonly condition: ExpressionNode; readonly closeParen: TokenNode; readonly colon: TokenNode; readonly statements: NodeList | null; readonly endWhileKeyword: TokenNode; readonly semicolon: TokenNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(whileKeyword: TokenNode, openParen: TokenNode, condition: ExpressionNode, closeParen: TokenNode, colon: TokenNode, statements: NodeList | null, endWhileKeyword: TokenNode, semicolon: TokenNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): WhileBlockSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): WhileBlockNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class YieldNode extends ExpressionNode { readonly yieldKeyword: TokenNode; readonly key: ExpressionNode | null; readonly doubleArrow: TokenNode | null; readonly value: ExpressionNode | null; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(yieldKeyword: TokenNode, key: ExpressionNode | null, doubleArrow: TokenNode | null, value: ExpressionNode | null, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): YieldSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): YieldNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; } export declare class YieldFromNode extends ExpressionNode { readonly yieldFromKeyword: TokenNode; readonly delegate: ExpressionNode; protected _flags: NodeFlags; protected _fullWidth: number; protected hash: number; constructor(yieldFromKeyword: TokenNode, delegate: ExpressionNode, diagnostics?: ReadonlyArray); get count(): number; get flags(): number; get fullWidth(): number; accept(visitor: NodeVisitor): void; acceptResult(visitor: NodeTransform): T; childAt(index: number): INode | null; createSyntaxNode(parent: SyntaxNode, offset: number): YieldFromSyntaxNode; hashCode(): number; withDiagnostics(diagnostics: ReadonlyArray): YieldFromNode; protected computeHashCode(): number; protected updateFlagsAndWidth(flags: NodeFlags, fullWidth: number): void; }