@flint.fyi/typescript-language 0.0.0

package/lib/lib/types/ast.d.ts

@@ -0,0 +1,2066 @@
+import ts from "typescript";
+
+//#region lib/types/ast.d.ts
+interface AbstractKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.AbstractKeyword;
+  readonly parent: ModifierParent;
+}
+type AccessorDeclaration = GetAccessorDeclaration | SetAccessorDeclaration;
+interface AccessorKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.AccessorKeyword;
+  readonly parent: ModifierParent;
+}
+type AdditiveOperator = ts.SyntaxKind.MinusToken | ts.SyntaxKind.PlusToken;
+type AdditiveOperatorOrHigher = AdditiveOperator | MultiplicativeOperatorOrHigher;
+interface AnyKeyword extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.AnyKeyword;
+  readonly parent: TypeNodeParent;
+}
+type ArrayBindingElement = BindingElement | OmittedExpression;
+interface ArrayBindingPattern extends ts.Node {
+  readonly elements: ts.NodeArray<ArrayBindingElement>;
+  readonly kind: ts.SyntaxKind.ArrayBindingPattern;
+  readonly parent: BindingElement | ParameterDeclaration | VariableDeclaration;
+}
+interface ArrayLiteralExpression extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly elements: ts.NodeArray<Expression>;
+  readonly kind: ts.SyntaxKind.ArrayLiteralExpression;
+  readonly parent: LeftHandSideExpressionParent;
+}
+interface ArrayTypeNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly elementType: TypeNode;
+  readonly kind: ts.SyntaxKind.ArrayType;
+  readonly parent: TypeNodeParent;
+}
+interface ArrowFunction extends ts.Node {
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _flowContainerBrand: any;
+  _functionLikeDeclarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  readonly asteriskToken?: AsteriskToken | undefined;
+  readonly body: ConciseBody;
+  readonly equalsGreaterThanToken: EqualsGreaterThanToken;
+  readonly exclamationToken?: ExclamationToken | undefined;
+  readonly kind: ts.SyntaxKind.ArrowFunction;
+  readonly modifiers?: ts.NodeArray<Modifier>;
+  readonly name: never;
+  readonly parameters: ts.NodeArray<ParameterDeclaration>;
+  readonly parent: ExpressionParent;
+  readonly questionToken?: QuestionToken | undefined;
+  readonly type?: TypeNode | undefined;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration> | undefined;
+}
+interface AsExpression extends ts.Node {
+  _expressionBrand: any;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.AsExpression;
+  readonly parent: ExpressionParent;
+  readonly type: TypeNode;
+}
+interface AssertsKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.AssertsKeyword;
+  readonly parent: TypePredicateNode;
+}
+type AssignmentOperator = CompoundAssignmentOperator | ts.SyntaxKind.EqualsToken;
+type AssignmentOperatorOrHigher = AssignmentOperator | LogicalOperatorOrHigher | ts.SyntaxKind.QuestionQuestionToken;
+interface AsteriskToken extends ts.Node {
+  readonly kind: ts.SyntaxKind.AsteriskToken;
+  readonly parent: AccessorDeclaration | ArrowFunction | ConstructorDeclaration | FunctionDeclaration | FunctionExpression | MethodDeclaration | YieldExpression;
+}
+interface AsyncKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.AsyncKeyword;
+  readonly parent: ModifierParent;
+}
+interface AwaitExpression extends ts.Node {
+  _expressionBrand: any;
+  _unaryExpressionBrand: any;
+  readonly expression: UnaryExpression;
+  readonly kind: ts.SyntaxKind.AwaitExpression;
+  readonly parent: AwaitExpression | DeleteExpression | ExpressionParent | PrefixUnaryExpression | TypeAssertion | TypeOfExpression | VoidExpression;
+}
+interface AwaitKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.AwaitKeyword;
+  readonly parent: ForOfStatement;
+}
+interface BigIntKeyword extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.BigIntKeyword;
+  readonly parent: TypeNodeParent;
+}
+interface BigIntLiteral extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _literalExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  hasExtendedUnicodeEscape?: boolean;
+  isUnterminated?: boolean;
+  readonly kind: ts.SyntaxKind.BigIntLiteral;
+  readonly parent: ClassStaticBlockDeclaration | ConstructorDeclaration | FunctionOrConstructorTypeNodeBase | JSDocFunctionType | LeftHandSideExpressionParent | LiteralTypeNode | MethodDeclaration | SemicolonClassElement | TypeElement;
+  text: string;
+}
+interface BinaryExpression extends ts.Node {
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _jsdocContainerBrand: any;
+  readonly kind: ts.SyntaxKind.BinaryExpression;
+  readonly left: Expression;
+  readonly operatorToken: BinaryOperatorToken;
+  readonly parent: ExpressionParent;
+  readonly right: Expression;
+}
+type BinaryOperator = AssignmentOperatorOrHigher | ts.SyntaxKind.CommaToken;
+interface BinaryOperatorToken extends ts.Node {
+  readonly kind: BinaryOperator;
+  readonly parent: BinaryExpression;
+}
+interface BindingElement extends ts.Node {
+  _declarationBrand: any;
+  _flowContainerBrand: any;
+  readonly dotDotDotToken?: DotDotDotToken;
+  readonly initializer?: Expression;
+  readonly kind: ts.SyntaxKind.BindingElement;
+  readonly name: BindingName;
+  readonly parent: BindingPattern;
+  readonly propertyName?: PropertyName;
+}
+type BindingName = BindingPattern | Identifier;
+type BindingPattern = ArrayBindingPattern | ObjectBindingPattern;
+type BitwiseOperator = ts.SyntaxKind.AmpersandToken | ts.SyntaxKind.BarToken | ts.SyntaxKind.CaretToken;
+type BitwiseOperatorOrHigher = BitwiseOperator | EqualityOperatorOrHigher;
+interface Block extends ts.Node {
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _statementBrand: any;
+  readonly kind: ts.SyntaxKind.Block;
+  readonly parent: AccessorDeclaration | ArrowFunction | CatchClause | ClassStaticBlockDeclaration | ConstructorDeclaration | FunctionDeclaration | FunctionExpression | MethodDeclaration | StatementParent | TryStatement;
+  readonly statements: ts.NodeArray<Statement>;
+}
+interface BooleanKeyword extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.BooleanKeyword;
+  readonly parent: TypeNodeParent;
+}
+type BooleanLiteral = FalseLiteral | TrueLiteral;
+interface BreakStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly kind: ts.SyntaxKind.BreakStatement;
+  readonly label?: Identifier;
+  readonly parent: StatementParent;
+}
+interface CallExpression extends ts.Node {
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly arguments: ts.NodeArray<Expression>;
+  readonly expression: LeftHandSideExpression;
+  readonly kind: ts.SyntaxKind.CallExpression;
+  readonly parent: LeftHandSideExpressionParent;
+  readonly questionDotToken?: QuestionDotToken;
+  readonly typeArguments?: ts.NodeArray<TypeNode>;
+}
+interface CallSignatureDeclaration extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _typeElementBrand: any;
+  readonly kind: ts.SyntaxKind.CallSignature;
+  readonly name?: PropertyName;
+  readonly parameters: ts.NodeArray<ParameterDeclaration>;
+  readonly parent: InterfaceDeclaration | MappedTypeNode | TypeLiteralNode;
+  readonly questionToken?: QuestionToken | undefined;
+  readonly type?: TypeNode | undefined;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration> | undefined;
+}
+interface CaseBlock extends ts.Node {
+  _localsContainerBrand: any;
+  readonly clauses: ts.NodeArray<CaseOrDefaultClause>;
+  readonly kind: ts.SyntaxKind.CaseBlock;
+  readonly parent: SwitchStatement;
+}
+interface CaseClause extends ts.Node {
+  _jsdocContainerBrand: any;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.CaseClause;
+  readonly parent: CaseBlock;
+  readonly statements: ts.NodeArray<Statement>;
+}
+type CaseOrDefaultClause = CaseClause | DefaultClause;
+interface CatchClause extends ts.Node {
+  _localsContainerBrand: any;
+  readonly block: Block;
+  readonly kind: ts.SyntaxKind.CatchClause;
+  readonly parent: TryStatement;
+  readonly variableDeclaration?: VariableDeclaration;
+}
+interface ClassDeclaration extends ts.Node {
+  readonly kind: ts.SyntaxKind.ClassDeclaration;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly parent: StatementParent;
+  /** May be undefined in `export default class { ... }`. */
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly heritageClauses?: ts.NodeArray<HeritageClause>;
+  readonly members: ts.NodeArray<ClassElement>;
+  readonly name?: Identifier;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration>;
+}
+type ClassElement = ClassStaticBlockDeclaration | ConstructorDeclaration | GetAccessorDeclaration | IndexSignatureDeclaration | MethodDeclaration | PropertyDeclaration | SemicolonClassElement | SetAccessorDeclaration;
+interface ClassExpression extends ts.Node {
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _jsdocContainerBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly heritageClauses?: ts.NodeArray<HeritageClause>;
+  readonly kind: ts.SyntaxKind.ClassExpression;
+  readonly members: ts.NodeArray<ClassElement>;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly name?: Identifier;
+  readonly parent: LeftHandSideExpressionParent;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration>;
+}
+interface ClassStaticBlockDeclaration extends ts.Node {
+  _classElementBrand: any;
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  readonly body: Block;
+  readonly kind: ts.SyntaxKind.ClassStaticBlockDeclaration;
+  readonly name?: PropertyName;
+  readonly parent: ClassDeclaration | ClassExpression;
+}
+interface ColonToken extends ts.Node {
+  readonly kind: ts.SyntaxKind.ColonToken;
+  readonly parent: ConditionalExpression;
+}
+interface CommaListExpression extends ts.Node {
+  _expressionBrand: any;
+  readonly elements: ts.NodeArray<Expression>;
+  readonly kind: ts.SyntaxKind.CommaListExpression;
+  readonly parent: ExpressionParent;
+}
+type CompoundAssignmentOperator = ts.SyntaxKind.AmpersandAmpersandEqualsToken | ts.SyntaxKind.AmpersandEqualsToken | ts.SyntaxKind.AsteriskAsteriskEqualsToken | ts.SyntaxKind.AsteriskEqualsToken | ts.SyntaxKind.BarBarEqualsToken | ts.SyntaxKind.BarEqualsToken | ts.SyntaxKind.CaretEqualsToken | ts.SyntaxKind.GreaterThanGreaterThanEqualsToken | ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | ts.SyntaxKind.LessThanLessThanEqualsToken | ts.SyntaxKind.MinusEqualsToken | ts.SyntaxKind.PercentEqualsToken | ts.SyntaxKind.PlusEqualsToken | ts.SyntaxKind.QuestionQuestionEqualsToken | ts.SyntaxKind.SlashEqualsToken;
+interface ComputedPropertyName extends ts.Node {
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.ComputedPropertyName;
+  readonly parent: BindingElement | ClassStaticBlockDeclaration | ConstructorDeclaration | EnumMember | FunctionOrConstructorTypeNodeBase | JSDocFunctionType | JsxSpreadAttribute | MethodDeclaration | PropertyAssignment | PropertyDeclaration | SemicolonClassElement | SpreadAssignment | TypeElement;
+}
+type ConciseBody = Expression | FunctionBody;
+interface ConditionalExpression extends ts.Node {
+  _expressionBrand: any;
+  readonly colonToken: ColonToken;
+  readonly condition: Expression;
+  readonly kind: ts.SyntaxKind.ConditionalExpression;
+  readonly parent: ExpressionParent;
+  readonly questionToken: QuestionToken;
+  readonly whenFalse: Expression;
+  readonly whenTrue: Expression;
+}
+interface ConditionalTypeNode extends ts.Node {
+  _localsContainerBrand: any;
+  _typeNodeBrand: any;
+  readonly checkType: TypeNode;
+  readonly extendsType: TypeNode;
+  readonly falseType: TypeNode;
+  readonly kind: ts.SyntaxKind.ConditionalType;
+  readonly parent: TypeNodeParent;
+  readonly trueType: TypeNode;
+}
+interface ConstKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.ConstKeyword;
+  readonly parent: ModifierParent;
+}
+interface ConstructorDeclaration extends ts.Node {
+  _classElementBrand: any;
+  _declarationBrand: any;
+  _functionLikeDeclarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  readonly asteriskToken?: AsteriskToken | undefined;
+  readonly body?: FunctionBody | undefined;
+  readonly exclamationToken?: ExclamationToken | undefined;
+  readonly kind: ts.SyntaxKind.Constructor;
+  readonly modifiers?: ts.NodeArray<ModifierLike> | undefined;
+  readonly name?: PropertyName;
+  readonly parameters: ts.NodeArray<ParameterDeclaration>;
+  readonly parent: ClassDeclaration | ClassExpression;
+  readonly questionToken?: QuestionToken | undefined;
+  readonly type?: TypeNode | undefined;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration> | undefined;
+}
+interface ConstructorTypeNode extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.ConstructorType;
+  readonly modifiers?: ts.NodeArray<Modifier>;
+  readonly name?: PropertyName;
+  readonly parameters: ts.NodeArray<ParameterDeclaration>;
+  readonly parent: TypeNodeParent;
+  readonly type: TypeNode;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration> | undefined;
+}
+interface ConstructSignatureDeclaration extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _typeElementBrand: any;
+  readonly kind: ts.SyntaxKind.ConstructSignature;
+  readonly name?: PropertyName;
+  readonly parameters: ts.NodeArray<ParameterDeclaration>;
+  readonly parent: InterfaceDeclaration | MappedTypeNode | TypeLiteralNode;
+  readonly questionToken?: QuestionToken | undefined;
+  readonly type?: TypeNode | undefined;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration> | undefined;
+}
+interface ContinueStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly kind: ts.SyntaxKind.ContinueStatement;
+  readonly label?: Identifier;
+  readonly parent: StatementParent;
+}
+interface DebuggerStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly kind: ts.SyntaxKind.DebuggerStatement;
+  readonly parent: StatementParent;
+}
+type DeclarationStatement = ClassDeclaration | EnumDeclaration | ExportAssignment | ExportDeclaration | FunctionDeclaration | ImportEqualsDeclaration | InterfaceDeclaration | MissingDeclaration | ModuleDeclaration | NamespaceExportDeclaration | TypeAliasDeclaration;
+interface DeclareKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.DeclareKeyword;
+  readonly parent: ModifierParent;
+}
+interface Decorator extends ts.Node {
+  readonly expression: LeftHandSideExpression;
+  readonly kind: ts.SyntaxKind.Decorator;
+  readonly parent: AccessorDeclaration | ClassDeclaration | ClassExpression | ConstructorDeclaration | EnumDeclaration | ExportAssignment | ExportDeclaration | FunctionDeclaration | ImportDeclaration | ImportEqualsDeclaration | IndexSignatureDeclaration | InterfaceDeclaration | JSDocNamespaceDeclaration | MethodDeclaration | ModuleDeclaration | NamespaceDeclaration | ParameterDeclaration | PropertyDeclaration | TypeAliasDeclaration | VariableStatement;
+}
+interface DefaultClause extends ts.Node {
+  readonly kind: ts.SyntaxKind.DefaultClause;
+  readonly parent: CaseBlock;
+  readonly statements: ts.NodeArray<Statement>;
+}
+interface DefaultKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.DefaultKeyword;
+  readonly parent: ModifierParent;
+}
+interface DeleteExpression extends ts.Node {
+  _expressionBrand: any;
+  _unaryExpressionBrand: any;
+  readonly expression: UnaryExpression;
+  readonly kind: ts.SyntaxKind.DeleteExpression;
+  readonly parent: AwaitExpression | DeleteExpression | ExpressionParent | PrefixUnaryExpression | TypeAssertion | TypeOfExpression | VoidExpression;
+}
+interface DoStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.DoStatement;
+  readonly parent: StatementParent;
+  readonly statement: Statement;
+}
+interface DotDotDotToken extends ts.Node {
+  readonly kind: ts.SyntaxKind.DotDotDotToken;
+  readonly parent: BindingElement | ParameterDeclaration;
+}
+interface ElementAccessExpression extends ts.Node {
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly argumentExpression: Expression;
+  readonly expression: LeftHandSideExpression;
+  readonly kind: ts.SyntaxKind.ElementAccessExpression;
+  readonly parent: LeftHandSideExpressionParent;
+  readonly questionDotToken?: QuestionDotToken;
+}
+interface EmptyStatement extends ts.Node {
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly kind: ts.SyntaxKind.EmptyStatement;
+  readonly parent: StatementParent;
+}
+type EntityName = Identifier | QualifiedName;
+interface EnumDeclaration extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly kind: ts.SyntaxKind.EnumDeclaration;
+  readonly members: ts.NodeArray<EnumMember>;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly name: Identifier;
+  readonly parent: StatementParent;
+}
+interface EnumMember extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  readonly initializer?: Expression;
+  readonly kind: ts.SyntaxKind.EnumMember;
+  readonly name: PropertyName;
+  readonly parent: EnumDeclaration;
+}
+type EqualityOperator = ts.SyntaxKind.EqualsEqualsEqualsToken | ts.SyntaxKind.EqualsEqualsToken | ts.SyntaxKind.ExclamationEqualsEqualsToken | ts.SyntaxKind.ExclamationEqualsToken;
+type EqualityOperatorOrHigher = EqualityOperator | RelationalOperatorOrHigher;
+interface EqualsGreaterThanToken extends ts.Node {
+  readonly kind: ts.SyntaxKind.EqualsGreaterThanToken;
+  readonly parent: ArrowFunction;
+}
+interface EqualsToken extends ts.Node {
+  readonly kind: ts.SyntaxKind.EqualsToken;
+  readonly parent: ShorthandPropertyAssignment;
+}
+interface ExclamationToken extends ts.Node {
+  readonly kind: ts.SyntaxKind.ExclamationToken;
+  readonly parent: AccessorDeclaration | ArrowFunction | ConstructorDeclaration | FunctionDeclaration | FunctionExpression | MethodDeclaration | PropertyDeclaration | VariableDeclaration;
+}
+type ExponentiationOperator = ts.SyntaxKind.AsteriskAsteriskToken;
+interface ExportAssignment extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly expression: Expression;
+  readonly isExportEquals?: boolean;
+  readonly kind: ts.SyntaxKind.ExportAssignment;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly name?: Identifier | NumericLiteral | StringLiteral;
+  readonly parent: StatementParent;
+}
+interface ExportDeclaration extends ts.Node {
+  readonly isTypeOnly: boolean;
+  readonly kind: ts.SyntaxKind.ExportDeclaration;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly parent: StatementParent;
+  /** Will not be assigned in the case of `export * from "foo";` */
+  readonly exportClause?: NamedExportBindings;
+  /** If this is not a StringLiteral it will be a grammar error. */
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly attributes?: ImportAttributes;
+  readonly moduleSpecifier?: Expression;
+  readonly name?: Identifier | NumericLiteral | StringLiteral;
+}
+interface ExportKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.ExportKeyword;
+  readonly parent: ModifierParent;
+}
+interface ExportSpecifier extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  readonly isTypeOnly: boolean;
+  readonly kind: ts.SyntaxKind.ExportSpecifier;
+  readonly name: ModuleExportName;
+  readonly parent: NamedExports;
+  readonly propertyName?: ModuleExportName;
+}
+type Expression = ArrowFunction | AsExpression | BinaryExpression | CommaListExpression | ConditionalExpression | JsxClosingFragment | JsxExpression | JsxOpeningElement | JsxOpeningFragment | OmittedExpression | SatisfiesExpression | SpreadElement | SyntheticExpression | UnaryExpression | YieldExpression;
+interface ExpressionStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.ExpressionStatement;
+  readonly parent: StatementParent;
+}
+interface ExpressionWithTypeArguments extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _typeNodeBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly expression: LeftHandSideExpression;
+  readonly kind: ts.SyntaxKind.ExpressionWithTypeArguments;
+  readonly parent: ArrayLiteralExpression | ArrayTypeNode | ArrowFunction | AsExpression | AwaitExpression | BinaryExpression | BindingElement | CallExpression | CallSignatureDeclaration | CaseClause | CommaListExpression | ComputedPropertyName | ConditionalExpression | ConditionalTypeNode | ConstructorDeclaration | ConstructSignatureDeclaration | Decorator | DeleteExpression | ElementAccessExpression | EnumMember | ExportAssignment | ExportDeclaration | ExpressionStatement | ExternalModuleReference | FunctionDeclaration | FunctionExpression | FunctionOrConstructorTypeNodeBase | HeritageClause | IfStatement | ImportAttribute | ImportDeclaration | IndexedAccessTypeNode | IndexSignatureDeclaration | IntersectionTypeNode | IterationStatement | JSDocFunctionType | JSDocNamepathType | JSDocNonNullableType | JSDocNullableType | JSDocOptionalType | JSDocTypeExpression | JSDocVariadicType | JsxExpression | JsxOpeningElement | JsxSelfClosingElement | JsxSpreadAttribute | MappedTypeNode | MethodSignature | NamedTupleMember | NewExpression | NodeWithTypeArguments | NonNullExpression | ObjectLiteralElementLike | OptionalTypeNode | ParameterDeclaration | ParenthesizedExpression | ParenthesizedTypeNode | PartiallyEmittedExpression | PostfixUnaryExpression | PrefixUnaryExpression | PropertyAccessExpression | PropertyDeclaration | PropertySignature | RestTypeNode | ReturnStatement | SatisfiesExpression | SpreadElement | SwitchStatement | TaggedTemplateExpression | TemplateLiteralTypeSpan | TemplateSpan | ThrowStatement | TupleTypeNode | TypeAliasDeclaration | TypeAssertion | TypeOfExpression | TypeOperatorNode | TypeParameterDeclaration | TypePredicateNode | UnionTypeNode | VariableDeclaration | VoidExpression | WithStatement | YieldExpression;
+  readonly typeArguments?: ts.NodeArray<TypeNode>;
+}
+interface ExternalModuleReference extends ts.Node {
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.ExternalModuleReference;
+  readonly parent: ImportEqualsDeclaration;
+}
+interface FalseLiteral extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly kind: ts.SyntaxKind.FalseKeyword;
+  readonly parent: LeftHandSideExpressionParent | LiteralTypeNode;
+}
+type ForInitializer = Expression | VariableDeclarationList;
+interface ForInStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _statementBrand: any;
+  readonly expression: Expression;
+  readonly initializer: ForInitializer;
+  readonly kind: ts.SyntaxKind.ForInStatement;
+  readonly parent: StatementParent;
+  readonly statement: Statement;
+}
+interface ForOfStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _statementBrand: any;
+  readonly awaitModifier?: AwaitKeyword;
+  readonly expression: Expression;
+  readonly initializer: ForInitializer;
+  readonly kind: ts.SyntaxKind.ForOfStatement;
+  readonly parent: StatementParent;
+  readonly statement: Statement;
+}
+interface ForStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _statementBrand: any;
+  readonly condition?: Expression;
+  readonly incrementor?: Expression;
+  readonly initializer?: ForInitializer;
+  readonly kind: ts.SyntaxKind.ForStatement;
+  readonly parent: StatementParent;
+  readonly statement: Statement;
+}
+type FunctionBody = Block;
+interface FunctionDeclaration extends ts.Node {
+  _declarationBrand: any;
+  _functionLikeDeclarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _statementBrand: any;
+  readonly asteriskToken?: AsteriskToken | undefined;
+  readonly body?: FunctionBody;
+  readonly exclamationToken?: ExclamationToken | undefined;
+  readonly kind: ts.SyntaxKind.FunctionDeclaration;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly name?: Identifier;
+  readonly parameters: ts.NodeArray<ParameterDeclaration>;
+  readonly parent: StatementParent;
+  readonly questionToken?: QuestionToken | undefined;
+  readonly type?: TypeNode | undefined;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration> | undefined;
+}
+interface FunctionExpression extends ts.Node {
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _flowContainerBrand: any;
+  _functionLikeDeclarationBrand: any;
+  _jsdocContainerBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _localsContainerBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly asteriskToken?: AsteriskToken | undefined;
+  readonly body: FunctionBody;
+  readonly exclamationToken?: ExclamationToken | undefined;
+  readonly kind: ts.SyntaxKind.FunctionExpression;
+  readonly modifiers?: ts.NodeArray<Modifier>;
+  readonly name?: Identifier;
+  readonly parameters: ts.NodeArray<ParameterDeclaration>;
+  readonly parent: LeftHandSideExpressionParent;
+  readonly questionToken?: QuestionToken | undefined;
+  readonly type?: TypeNode | undefined;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration> | undefined;
+}
+type FunctionOrConstructorTypeNodeBase = ConstructorTypeNode | FunctionTypeNode;
+interface FunctionTypeNode extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.FunctionType;
+  readonly name?: PropertyName;
+  readonly parameters: ts.NodeArray<ParameterDeclaration>;
+  readonly parent: TypeNodeParent;
+  readonly type: TypeNode;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration> | undefined;
+}
+interface GetAccessorDeclaration extends ts.Node {
+  _classElementBrand: any;
+  _declarationBrand: any;
+  _flowContainerBrand: any;
+  _functionLikeDeclarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _objectLiteralBrand: any;
+  _typeElementBrand: any;
+  readonly asteriskToken?: AsteriskToken | undefined;
+  readonly body?: FunctionBody;
+  readonly exclamationToken?: ExclamationToken | undefined;
+  readonly kind: ts.SyntaxKind.GetAccessor;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly name: PropertyName;
+  readonly parameters: ts.NodeArray<ParameterDeclaration>;
+  readonly parent: ClassDeclaration | ClassExpression | InterfaceDeclaration | MappedTypeNode | ObjectLiteralExpressionBase | TypeLiteralNode;
+  readonly questionToken?: QuestionToken | undefined;
+  readonly type?: TypeNode | undefined;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration> | undefined;
+}
+interface HeritageClause extends ts.Node {
+  readonly kind: ts.SyntaxKind.HeritageClause;
+  readonly parent: ClassDeclaration | ClassExpression | InterfaceDeclaration;
+  readonly token: ts.SyntaxKind.ExtendsKeyword | ts.SyntaxKind.ImplementsKeyword;
+  readonly types: ts.NodeArray<ExpressionWithTypeArguments>;
+}
+interface Identifier extends ts.Node {
+  readonly kind: ts.SyntaxKind.Identifier;
+  readonly parent: ArrayLiteralExpression | ArrowFunction | AsExpression | AwaitExpression | BinaryExpression | BindingElement | BreakStatement | CallExpression | CaseClause | ClassExpression | ClassStaticBlockDeclaration | CommaListExpression | ComputedPropertyName | ConditionalExpression | ConstructorDeclaration | ContinueStatement | DeclarationStatement | Decorator | DeleteExpression | ElementAccessExpression | EnumMember | ExportSpecifier | ExpressionStatement | ExternalModuleReference | FunctionExpression | FunctionOrConstructorTypeNodeBase | IfStatement | ImportAttribute | ImportClause | ImportDeclaration | ImportSpecifier | IterationStatement | JSDocFunctionType | JSDocLink | JSDocLinkCode | JSDocLinkPlain | JSDocMemberName | JSDocNamespaceDeclaration | JSDocPropertyLikeTag | JSDocReturnTag | JSDocTemplateTag | JsxAttributeLike | JsxClosingElement | JsxExpression | JsxNamespacedName | JsxOpeningElement | JsxSelfClosingElement | JsxTagNamePropertyAccess | LabeledStatement | MetaProperty | MethodDeclaration | NamedTupleMember | NamespaceDeclaration | NamespaceExport | NamespaceImport | NewExpression | NodeWithTypeArguments | NonNullExpression | ParameterDeclaration | ParenthesizedExpression | PartiallyEmittedExpression | PostfixUnaryExpression | PrefixUnaryExpression | PropertyAccessExpression | PropertyAssignment | PropertyDeclaration | QualifiedName | ReturnStatement | SatisfiesExpression | SemicolonClassElement | ShorthandPropertyAssignment | SpreadAssignment | SpreadElement | SwitchStatement | TaggedTemplateExpression | TemplateSpan | ThrowStatement | TypeAssertion | TypeElement | TypeOfExpression | TypeParameterDeclaration | TypePredicateNode | VariableDeclaration | VoidExpression | WithStatement | YieldExpression;
+  /**
+   * Prefer to use `id.unescapedText`. (Note: This is available only in services, not internally to the TypeScript compiler.)
+   * Text of identifier, but if the identifier begins with two underscores, this will begin with three.
+   */
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly escapedText: ts.__String;
+  readonly text: string;
+}
+interface IfStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly elseStatement?: Statement;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.IfStatement;
+  readonly parent: StatementParent;
+  readonly thenStatement: Statement;
+}
+interface ImportAttribute extends ts.Node {
+  readonly kind: ts.SyntaxKind.ImportAttribute;
+  readonly name: ImportAttributeName;
+  readonly parent: ImportAttributes;
+  readonly value: Expression;
+}
+type ImportAttributeName = Identifier | StringLiteral;
+interface ImportAttributes extends ts.Node {
+  readonly elements: ts.NodeArray<ImportAttribute>;
+  readonly kind: ts.SyntaxKind.ImportAttributes;
+  readonly multiLine?: boolean;
+  readonly parent: ExportDeclaration | ImportDeclaration | ImportTypeNode;
+  readonly token: ts.SyntaxKind.AssertKeyword | ts.SyntaxKind.WithKeyword;
+}
+interface ImportClause extends ts.Node {
+  readonly kind: ts.SyntaxKind.ImportClause;
+  readonly parent: ImportDeclaration;
+  /** @deprecated Use `phaseModifier` instead */
+  _declarationBrand: any;
+  readonly isTypeOnly: boolean;
+  readonly name?: Identifier;
+  readonly namedBindings?: NamedImportBindings;
+  readonly phaseModifier: ImportPhaseModifierSyntaxKind | undefined;
+}
+interface ImportDeclaration extends ts.Node {
+  readonly importClause?: ImportClause;
+  readonly kind: ts.SyntaxKind.ImportDeclaration;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly parent: StatementParent;
+  /** If this is not a StringLiteral it will be a grammar error. */
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly attributes?: ImportAttributes;
+  readonly moduleSpecifier: Expression;
+}
+interface ImportEqualsDeclaration extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly isTypeOnly: boolean;
+  readonly kind: ts.SyntaxKind.ImportEqualsDeclaration;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly moduleReference: ModuleReference;
+  readonly name: Identifier;
+  readonly parent: StatementParent;
+}
+interface ImportExpression extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly kind: ts.SyntaxKind.ImportKeyword;
+  readonly parent: LeftHandSideExpressionParent;
+}
+type ImportPhaseModifierSyntaxKind = ts.SyntaxKind.DeferKeyword | ts.SyntaxKind.TypeKeyword;
+interface ImportSpecifier extends ts.Node {
+  _declarationBrand: any;
+  readonly isTypeOnly: boolean;
+  readonly kind: ts.SyntaxKind.ImportSpecifier;
+  readonly name: Identifier;
+  readonly parent: NamedImports;
+  readonly propertyName?: ModuleExportName;
+}
+interface ImportTypeNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly argument: TypeNode;
+  readonly attributes?: ImportAttributes;
+  readonly isTypeOf: boolean;
+  readonly kind: ts.SyntaxKind.ImportType;
+  readonly parent: TypeNodeParent;
+  readonly qualifier?: EntityName;
+  readonly typeArguments?: ts.NodeArray<TypeNode>;
+}
+interface IndexedAccessTypeNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly indexType: TypeNode;
+  readonly kind: ts.SyntaxKind.IndexedAccessType;
+  readonly objectType: TypeNode;
+  readonly parent: TypeNodeParent;
+}
+interface IndexSignatureDeclaration extends ts.Node {
+  _classElementBrand: any;
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _typeElementBrand: any;
+  readonly kind: ts.SyntaxKind.IndexSignature;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly name?: PropertyName;
+  readonly parameters: ts.NodeArray<ParameterDeclaration>;
+  readonly parent: ClassDeclaration | ClassExpression | InterfaceDeclaration | MappedTypeNode | TypeLiteralNode;
+  readonly questionToken?: QuestionToken | undefined;
+  readonly type: TypeNode;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration> | undefined;
+}
+interface InferTypeNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.InferType;
+  readonly parent: TypeNodeParent;
+  readonly typeParameter: TypeParameterDeclaration;
+}
+interface InKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.InKeyword;
+  readonly parent: ModifierParent;
+}
+interface InterfaceDeclaration extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly heritageClauses?: ts.NodeArray<HeritageClause>;
+  readonly kind: ts.SyntaxKind.InterfaceDeclaration;
+  readonly members: ts.NodeArray<TypeElement>;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly name: Identifier;
+  readonly parent: StatementParent;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration>;
+}
+interface IntersectionTypeNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.IntersectionType;
+  readonly parent: TypeNodeParent;
+  readonly types: ts.NodeArray<TypeNode>;
+}
+interface IntrinsicKeyword extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.IntrinsicKeyword;
+  readonly parent: TypeNodeParent;
+}
+type IterationStatement = DoStatement | ForInStatement | ForOfStatement | ForStatement | WhileStatement;
+interface JSDocAllType extends ts.Node {
+  _jsDocTypeBrand: any;
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.JSDocAllType;
+  readonly parent: TypeNodeParent;
+}
+type JSDocComment = JSDocLink | JSDocLinkCode | JSDocLinkPlain | JSDocText;
+interface JSDocFunctionType extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _jsDocTypeBrand: any;
+  _localsContainerBrand: any;
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.JSDocFunctionType;
+  readonly name?: PropertyName;
+  readonly parameters: ts.NodeArray<ParameterDeclaration>;
+  readonly parent: TypeNodeParent;
+  readonly type?: TypeNode | undefined;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration> | undefined;
+}
+interface JSDocLink extends ts.Node {
+  readonly kind: ts.SyntaxKind.JSDocLink;
+  readonly name?: EntityName | JSDocMemberName;
+  readonly parent: JSDocPropertyLikeTag | JSDocReturnTag | JSDocTemplateTag;
+  text: string;
+}
+interface JSDocLinkCode extends ts.Node {
+  readonly kind: ts.SyntaxKind.JSDocLinkCode;
+  readonly name?: EntityName | JSDocMemberName;
+  readonly parent: JSDocPropertyLikeTag | JSDocReturnTag | JSDocTemplateTag;
+  text: string;
+}
+interface JSDocLinkPlain extends ts.Node {
+  readonly kind: ts.SyntaxKind.JSDocLinkPlain;
+  readonly name?: EntityName | JSDocMemberName;
+  readonly parent: JSDocPropertyLikeTag | JSDocReturnTag | JSDocTemplateTag;
+  text: string;
+}
+interface JSDocMemberName extends ts.Node {
+  readonly kind: ts.SyntaxKind.JSDocMemberName;
+  readonly left: EntityName | JSDocMemberName;
+  readonly parent: JSDocLink | JSDocLinkCode | JSDocLinkPlain | JSDocMemberName;
+  readonly right: Identifier;
+}
+interface JSDocNamepathType extends ts.Node {
+  _jsDocTypeBrand: any;
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.JSDocNamepathType;
+  readonly parent: TypeNodeParent;
+  readonly type: TypeNode;
+}
+type JSDocNamespaceBody = Identifier | JSDocNamespaceDeclaration;
+interface JSDocNamespaceDeclaration extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _statementBrand: any;
+  readonly body?: JSDocNamespaceBody;
+  readonly kind: ts.SyntaxKind.ModuleDeclaration;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly name: Identifier;
+  readonly parent: JSDocNamespaceDeclaration | ModuleDeclaration;
+}
+interface JSDocNonNullableType extends ts.Node {
+  _jsDocTypeBrand: any;
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.JSDocNonNullableType;
+  readonly parent: TypeNodeParent;
+  readonly postfix: boolean;
+  readonly type: TypeNode;
+}
+interface JSDocNullableType extends ts.Node {
+  _jsDocTypeBrand: any;
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.JSDocNullableType;
+  readonly parent: TypeNodeParent;
+  readonly postfix: boolean;
+  readonly type: TypeNode;
+}
+interface JSDocOptionalType extends ts.Node {
+  _jsDocTypeBrand: any;
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.JSDocOptionalType;
+  readonly parent: TypeNodeParent;
+  readonly type: TypeNode;
+}
+interface JSDocParameterTag extends ts.Node {
+  readonly kind: ts.SyntaxKind.JSDocParameterTag;
+  readonly name: EntityName;
+  readonly parent: JSDocSignature | JSDocTypeLiteral;
+  readonly typeExpression?: JSDocTypeExpression;
+  /** Whether the property name came before the type -- non-standard for JSDoc, but Typescript-like */
+  _declarationBrand: any;
+  readonly comment?: string | ts.NodeArray<JSDocComment>;
+  readonly isBracketed: boolean;
+  readonly isNameFirst: boolean;
+  readonly tagName: Identifier;
+}
+type JSDocPropertyLikeTag = JSDocParameterTag | JSDocPropertyTag;
+interface JSDocPropertyTag extends ts.Node {
+  readonly kind: ts.SyntaxKind.JSDocPropertyTag;
+  readonly name: EntityName;
+  readonly parent: JSDocTypeLiteral;
+  readonly typeExpression?: JSDocTypeExpression;
+  /** Whether the property name came before the type -- non-standard for JSDoc, but Typescript-like */
+  _declarationBrand: any;
+  readonly comment?: string | ts.NodeArray<JSDocComment>;
+  readonly isBracketed: boolean;
+  readonly isNameFirst: boolean;
+  readonly tagName: Identifier;
+}
+interface JSDocReturnTag extends ts.Node {
+  readonly comment?: string | ts.NodeArray<JSDocComment>;
+  readonly kind: ts.SyntaxKind.JSDocReturnTag;
+  readonly parent: JSDocSignature;
+  readonly tagName: Identifier;
+  readonly typeExpression?: JSDocTypeExpression;
+}
+interface JSDocSignature extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _jsDocTypeBrand: any;
+  _localsContainerBrand: any;
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.JSDocSignature;
+  readonly parameters: readonly JSDocParameterTag[];
+  readonly parent: TypeNodeParent;
+  readonly type: JSDocReturnTag | undefined;
+  readonly typeParameters?: readonly JSDocTemplateTag[];
+}
+interface JSDocTemplateTag extends ts.Node {
+  readonly comment?: string | ts.NodeArray<JSDocComment>;
+  readonly constraint: JSDocTypeExpression | undefined;
+  readonly kind: ts.SyntaxKind.JSDocTemplateTag;
+  readonly parent: JSDocSignature;
+  readonly tagName: Identifier;
+  readonly typeParameters: ts.NodeArray<TypeParameterDeclaration>;
+}
+interface JSDocText extends ts.Node {
+  readonly kind: ts.SyntaxKind.JSDocText;
+  readonly parent: JSDocPropertyLikeTag | JSDocReturnTag | JSDocTemplateTag;
+  text: string;
+}
+type JSDocType = JSDocAllType | JSDocFunctionType | JSDocNamepathType | JSDocNonNullableType | JSDocNullableType | JSDocOptionalType | JSDocSignature | JSDocTypeLiteral | JSDocUnknownType | JSDocVariadicType;
+interface JSDocTypeExpression extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.JSDocTypeExpression;
+  readonly parent: JSDocPropertyLikeTag | JSDocReturnTag | JSDocTemplateTag | TypeNodeParent;
+  readonly type: TypeNode;
+}
+interface JSDocTypeLiteral extends ts.Node {
+  readonly jsDocPropertyTags?: readonly JSDocPropertyLikeTag[];
+  readonly kind: ts.SyntaxKind.JSDocTypeLiteral;
+  readonly parent: TypeNodeParent;
+  /** If true, then this type literal represents an *array* of its type. */
+  _declarationBrand: any;
+  _jsDocTypeBrand: any;
+  _typeNodeBrand: any;
+  readonly isArrayType: boolean;
+}
+interface JSDocUnknownType extends ts.Node {
+  _jsDocTypeBrand: any;
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.JSDocUnknownType;
+  readonly parent: TypeNodeParent;
+}
+interface JSDocVariadicType extends ts.Node {
+  _jsDocTypeBrand: any;
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.JSDocVariadicType;
+  readonly parent: TypeNodeParent;
+  readonly type: TypeNode;
+}
+interface JsxAttribute extends ts.Node {
+  _declarationBrand: any;
+  readonly initializer?: JsxAttributeValue;
+  readonly kind: ts.SyntaxKind.JsxAttribute;
+  readonly name: JsxAttributeName;
+  readonly parent: JsxAttributes;
+}
+type JsxAttributeLike = JsxAttribute | JsxSpreadAttribute;
+type JsxAttributeName = Identifier | JsxNamespacedName;
+interface JsxAttributes extends ts.Node {
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly kind: ts.SyntaxKind.JsxAttributes;
+  readonly parent: JsxOpeningElement | JsxSelfClosingElement | LeftHandSideExpressionParent;
+  readonly properties: ts.NodeArray<JsxAttributeLike>;
+}
+type JsxAttributeValue = JsxElement | JsxExpression | JsxFragment | JsxSelfClosingElement | StringLiteral;
+type JsxChild = JsxElement | JsxExpression | JsxFragment | JsxSelfClosingElement | JsxText;
+interface JsxClosingElement extends ts.Node {
+  readonly kind: ts.SyntaxKind.JsxClosingElement;
+  readonly parent: JsxElement;
+  readonly tagName: JsxTagNameExpression;
+}
+interface JsxClosingFragment extends ts.Node {
+  _expressionBrand: any;
+  readonly kind: ts.SyntaxKind.JsxClosingFragment;
+  readonly parent: ExpressionParent | JsxFragment;
+}
+interface JsxElement extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly children: ts.NodeArray<JsxChild>;
+  readonly closingElement: JsxClosingElement;
+  readonly kind: ts.SyntaxKind.JsxElement;
+  readonly openingElement: JsxOpeningElement;
+  readonly parent: ArrayLiteralExpression | ArrowFunction | AsExpression | AwaitExpression | BinaryExpression | BindingElement | CallExpression | CaseClause | CommaListExpression | ComputedPropertyName | ConditionalExpression | Decorator | DeleteExpression | ElementAccessExpression | EnumMember | ExportAssignment | ExportDeclaration | ExpressionStatement | ExpressionWithTypeArguments | ExternalModuleReference | IfStatement | ImportAttribute | ImportDeclaration | IterationStatement | JsxAttributeLike | JsxElement | JsxExpression | JsxFragment | NewExpression | NonNullExpression | ParameterDeclaration | ParenthesizedExpression | PartiallyEmittedExpression | PostfixUnaryExpression | PrefixUnaryExpression | PropertyAccessExpression | PropertyAssignment | PropertyDeclaration | ReturnStatement | SatisfiesExpression | ShorthandPropertyAssignment | SpreadAssignment | SpreadElement | SwitchStatement | TaggedTemplateExpression | TemplateSpan | ThrowStatement | TypeAssertion | TypeOfExpression | TypeParameterDeclaration | VariableDeclaration | VoidExpression | WithStatement | YieldExpression;
+}
+interface JsxExpression extends ts.Node {
+  _expressionBrand: any;
+  readonly dotDotDotToken?: Token<ts.SyntaxKind.DotDotDotToken, JsxExpression>;
+  readonly expression?: Expression;
+  readonly kind: ts.SyntaxKind.JsxExpression;
+  readonly parent: ArrayLiteralExpression | ArrowFunction | AsExpression | BinaryExpression | BindingElement | CallExpression | CaseClause | CommaListExpression | ComputedPropertyName | ConditionalExpression | ElementAccessExpression | EnumMember | ExportAssignment | ExportDeclaration | ExpressionStatement | ExternalModuleReference | IfStatement | ImportAttribute | ImportDeclaration | IterationStatement | JsxAttributeLike | JsxElement | JsxExpression | JsxFragment | NewExpression | NonNullExpression | ParameterDeclaration | ParenthesizedExpression | PartiallyEmittedExpression | PropertyAssignment | PropertyDeclaration | ReturnStatement | SatisfiesExpression | ShorthandPropertyAssignment | SpreadAssignment | SpreadElement | SwitchStatement | TemplateSpan | ThrowStatement | TypeParameterDeclaration | VariableDeclaration | WithStatement | YieldExpression;
+}
+interface JsxFragment extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly children: ts.NodeArray<JsxChild>;
+  readonly closingFragment: JsxClosingFragment;
+  readonly kind: ts.SyntaxKind.JsxFragment;
+  readonly openingFragment: JsxOpeningFragment;
+  readonly parent: ArrayLiteralExpression | ArrowFunction | AsExpression | AwaitExpression | BinaryExpression | BindingElement | CallExpression | CaseClause | CommaListExpression | ComputedPropertyName | ConditionalExpression | Decorator | DeleteExpression | ElementAccessExpression | EnumMember | ExportAssignment | ExportDeclaration | ExpressionStatement | ExpressionWithTypeArguments | ExternalModuleReference | IfStatement | ImportAttribute | ImportDeclaration | IterationStatement | JsxAttributeLike | JsxElement | JsxExpression | JsxFragment | NewExpression | NonNullExpression | ParameterDeclaration | ParenthesizedExpression | PartiallyEmittedExpression | PostfixUnaryExpression | PrefixUnaryExpression | PropertyAccessExpression | PropertyAssignment | PropertyDeclaration | ReturnStatement | SatisfiesExpression | ShorthandPropertyAssignment | SpreadAssignment | SpreadElement | SwitchStatement | TaggedTemplateExpression | TemplateSpan | ThrowStatement | TypeAssertion | TypeOfExpression | TypeParameterDeclaration | VariableDeclaration | VoidExpression | WithStatement | YieldExpression;
+}
+interface JsxNamespacedName extends ts.Node {
+  readonly kind: ts.SyntaxKind.JsxNamespacedName;
+  readonly name: Identifier;
+  readonly namespace: Identifier;
+  readonly parent: JsxAttribute | JsxClosingElement | JsxOpeningElement | JsxSelfClosingElement;
+}
+interface JsxOpeningElement extends ts.Node {
+  _expressionBrand: any;
+  readonly attributes: JsxAttributes;
+  readonly kind: ts.SyntaxKind.JsxOpeningElement;
+  readonly parent: ExpressionParent | JsxElement;
+  readonly tagName: JsxTagNameExpression;
+  readonly typeArguments?: ts.NodeArray<TypeNode>;
+}
+interface JsxOpeningFragment extends ts.Node {
+  _expressionBrand: any;
+  readonly kind: ts.SyntaxKind.JsxOpeningFragment;
+  readonly parent: ExpressionParent | JsxFragment;
+}
+interface JsxSelfClosingElement extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly attributes: JsxAttributes;
+  readonly kind: ts.SyntaxKind.JsxSelfClosingElement;
+  readonly parent: ArrayLiteralExpression | ArrowFunction | AsExpression | AwaitExpression | BinaryExpression | BindingElement | CallExpression | CaseClause | CommaListExpression | ComputedPropertyName | ConditionalExpression | Decorator | DeleteExpression | ElementAccessExpression | EnumMember | ExportAssignment | ExportDeclaration | ExpressionStatement | ExpressionWithTypeArguments | ExternalModuleReference | IfStatement | ImportAttribute | ImportDeclaration | IterationStatement | JsxAttributeLike | JsxElement | JsxExpression | JsxFragment | NewExpression | NonNullExpression | ParameterDeclaration | ParenthesizedExpression | PartiallyEmittedExpression | PostfixUnaryExpression | PrefixUnaryExpression | PropertyAccessExpression | PropertyAssignment | PropertyDeclaration | ReturnStatement | SatisfiesExpression | ShorthandPropertyAssignment | SpreadAssignment | SpreadElement | SwitchStatement | TaggedTemplateExpression | TemplateSpan | ThrowStatement | TypeAssertion | TypeOfExpression | TypeParameterDeclaration | VariableDeclaration | VoidExpression | WithStatement | YieldExpression;
+  readonly tagName: JsxTagNameExpression;
+  readonly typeArguments?: ts.NodeArray<TypeNode>;
+}
+interface JsxSpreadAttribute extends ts.Node {
+  _declarationBrand: any;
+  _objectLiteralBrand: any;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.JsxSpreadAttribute;
+  readonly name?: PropertyName;
+  readonly parent: JsxAttributes;
+}
+type JsxTagNameExpression = Identifier | JsxNamespacedName | JsxTagNamePropertyAccess | ThisExpression;
+interface JsxTagNamePropertyAccess extends ts.Node {
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly expression: Identifier | JsxTagNamePropertyAccess | ThisExpression;
+  readonly kind: ts.SyntaxKind.PropertyAccessExpression;
+  readonly name: MemberName;
+  readonly parent: JsxClosingElement | JsxOpeningElement | JsxSelfClosingElement | JsxTagNamePropertyAccess;
+  readonly questionDotToken?: QuestionDotToken;
+}
+interface JsxText extends ts.Node {
+  readonly containsOnlyTriviaWhiteSpaces: boolean;
+  hasExtendedUnicodeEscape?: boolean;
+  isUnterminated?: boolean;
+  readonly kind: ts.SyntaxKind.JsxText;
+  readonly parent: JsxElement | JsxFragment;
+  text: string;
+}
+interface LabeledStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly kind: ts.SyntaxKind.LabeledStatement;
+  readonly label: Identifier;
+  readonly parent: StatementParent;
+  readonly statement: Statement;
+}
+type LeftHandSideExpression = CallExpression | MemberExpression | NonNullExpression | PartiallyEmittedExpression;
+type LiteralExpression = BigIntLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | RegularExpressionLiteral | StringLiteral;
+interface LiteralTypeNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.LiteralType;
+  readonly literal: BooleanLiteral | LiteralExpression | NullLiteral | PrefixUnaryExpression;
+  readonly parent: TypeNodeParent;
+}
+type LogicalOperator = ts.SyntaxKind.AmpersandAmpersandToken | ts.SyntaxKind.BarBarToken;
+type LogicalOperatorOrHigher = BitwiseOperatorOrHigher | LogicalOperator;
+interface MappedTypeNode extends ts.Node {
+  readonly kind: ts.SyntaxKind.MappedType;
+  readonly nameType?: TypeNode;
+  readonly parent: TypeNodeParent;
+  readonly questionToken?: MinusToken | PlusToken | QuestionToken;
+  readonly readonlyToken?: MinusToken | PlusToken | ReadonlyKeyword;
+  readonly type?: TypeNode;
+  readonly typeParameter: TypeParameterDeclaration;
+  /** Used only to produce grammar errors */
+  _declarationBrand: any;
+  _localsContainerBrand: any;
+  _typeNodeBrand: any;
+  readonly members?: ts.NodeArray<TypeElement>;
+}
+type MemberExpression = ElementAccessExpression | ExpressionWithTypeArguments | PrimaryExpression | PropertyAccessExpression | TaggedTemplateExpression;
+type MemberName = Identifier | PrivateIdentifier;
+interface MetaProperty extends ts.Node {
+  _expressionBrand: any;
+  _flowContainerBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly keywordToken: ts.SyntaxKind.ImportKeyword | ts.SyntaxKind.NewKeyword;
+  readonly kind: ts.SyntaxKind.MetaProperty;
+  readonly name: Identifier;
+  readonly parent: LeftHandSideExpressionParent;
+}
+interface MethodDeclaration extends ts.Node {
+  _classElementBrand: any;
+  _declarationBrand: any;
+  _flowContainerBrand: any;
+  _functionLikeDeclarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _objectLiteralBrand: any;
+  readonly asteriskToken?: AsteriskToken | undefined;
+  readonly body?: FunctionBody | undefined;
+  readonly exclamationToken?: ExclamationToken | undefined;
+  readonly kind: ts.SyntaxKind.MethodDeclaration;
+  readonly modifiers?: ts.NodeArray<ModifierLike> | undefined;
+  readonly name: PropertyName;
+  readonly parameters: ts.NodeArray<ParameterDeclaration>;
+  readonly parent: ClassDeclaration | ClassExpression | ObjectLiteralExpressionBase;
+  readonly questionToken?: QuestionToken | undefined;
+  readonly type?: TypeNode | undefined;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration> | undefined;
+}
+interface MethodSignature extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _typeElementBrand: any;
+  readonly kind: ts.SyntaxKind.MethodSignature;
+  readonly modifiers?: ts.NodeArray<Modifier>;
+  readonly name: PropertyName;
+  readonly parameters: ts.NodeArray<ParameterDeclaration>;
+  readonly parent: InterfaceDeclaration | MappedTypeNode | TypeLiteralNode;
+  readonly questionToken?: QuestionToken | undefined;
+  readonly type?: TypeNode | undefined;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration> | undefined;
+}
+interface MinusToken extends ts.Node {
+  readonly kind: ts.SyntaxKind.MinusToken;
+  readonly parent: MappedTypeNode;
+}
+interface MissingDeclaration extends ts.Node {
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _jsdocContainerBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _statementBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly kind: ts.SyntaxKind.MissingDeclaration;
+  readonly name?: Identifier;
+  readonly parent: ArrayLiteralExpression | ArrowFunction | AsExpression | AwaitExpression | BinaryExpression | BindingElement | CallExpression | CommaListExpression | ComputedPropertyName | ConditionalExpression | Decorator | DeleteExpression | ElementAccessExpression | EnumMember | ExportAssignment | ExportDeclaration | ExpressionStatement | ExpressionWithTypeArguments | ExternalModuleReference | ImportAttribute | ImportDeclaration | JsxExpression | JsxSpreadAttribute | NewExpression | NonNullExpression | ParameterDeclaration | ParenthesizedExpression | PartiallyEmittedExpression | PostfixUnaryExpression | PrefixUnaryExpression | PropertyAccessExpression | PropertyAssignment | PropertyDeclaration | ReturnStatement | SatisfiesExpression | ShorthandPropertyAssignment | SpreadAssignment | SpreadElement | StatementParent | SwitchStatement | TaggedTemplateExpression | TemplateSpan | ThrowStatement | TypeAssertion | TypeOfExpression | TypeParameterDeclaration | VariableDeclaration | VoidExpression | YieldExpression;
+}
+type Modifier = AbstractKeyword | AccessorKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | ExportKeyword | InKeyword | OutKeyword | OverrideKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | ReadonlyKeyword | StaticKeyword;
+type ModifierLike = Decorator | Modifier;
+interface ModuleBlock extends ts.Node {
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly kind: ts.SyntaxKind.ModuleBlock;
+  readonly parent: Block | CaseOrDefaultClause | IfStatement | IterationStatement | LabeledStatement | ModuleDeclaration | NamespaceBody | SourceFile | WithStatement;
+  readonly statements: ts.NodeArray<Statement>;
+}
+type ModuleBody = JSDocNamespaceBody | NamespaceBody;
+interface ModuleDeclaration extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _statementBrand: any;
+  readonly body?: JSDocNamespaceDeclaration | ModuleBody;
+  readonly kind: ts.SyntaxKind.ModuleDeclaration;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly name: ModuleName;
+  readonly parent: StatementParent;
+}
+type ModuleExportName = Identifier | StringLiteral;
+type ModuleName = Identifier | StringLiteral;
+type ModuleReference = EntityName | ExternalModuleReference;
+type MultiplicativeOperator = ts.SyntaxKind.AsteriskToken | ts.SyntaxKind.PercentToken | ts.SyntaxKind.SlashToken;
+type MultiplicativeOperatorOrHigher = ExponentiationOperator | MultiplicativeOperator;
+type NamedExportBindings = NamedExports | NamespaceExport;
+interface NamedExports extends ts.Node {
+  readonly elements: ts.NodeArray<ExportSpecifier>;
+  readonly kind: ts.SyntaxKind.NamedExports;
+  readonly parent: ExportDeclaration;
+}
+type NamedImportBindings = NamedImports | NamespaceImport;
+interface NamedImports extends ts.Node {
+  readonly elements: ts.NodeArray<ImportSpecifier>;
+  readonly kind: ts.SyntaxKind.NamedImports;
+  readonly parent: ImportClause;
+}
+interface NamedTupleMember extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _typeNodeBrand: any;
+  readonly dotDotDotToken?: Token<ts.SyntaxKind.DotDotDotToken, NamedTupleMember>;
+  readonly kind: ts.SyntaxKind.NamedTupleMember;
+  readonly name: Identifier;
+  readonly parent: SyntheticExpression | TypeNodeParent;
+  readonly questionToken?: Token<ts.SyntaxKind.QuestionToken, NamedTupleMember>;
+  readonly type: TypeNode;
+}
+type NamespaceBody = ModuleBlock | NamespaceDeclaration;
+interface NamespaceDeclaration extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _statementBrand: any;
+  readonly body: NamespaceBody;
+  readonly kind: ts.SyntaxKind.ModuleDeclaration;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly name: Identifier;
+  readonly parent: ModuleDeclaration | NamespaceDeclaration;
+}
+interface NamespaceExport extends ts.Node {
+  _declarationBrand: any;
+  readonly kind: ts.SyntaxKind.NamespaceExport;
+  readonly name: ModuleExportName;
+  readonly parent: ExportDeclaration;
+}
+interface NamespaceExportDeclaration extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly kind: ts.SyntaxKind.NamespaceExportDeclaration;
+  readonly name: Identifier;
+  readonly parent: StatementParent;
+}
+interface NamespaceImport extends ts.Node {
+  _declarationBrand: any;
+  readonly kind: ts.SyntaxKind.NamespaceImport;
+  readonly name: Identifier;
+  readonly parent: ImportClause;
+}
+interface NeverKeyword extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.NeverKeyword;
+  readonly parent: TypeNodeParent;
+}
+interface NewExpression extends ts.Node {
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly arguments?: ts.NodeArray<Expression>;
+  readonly expression: LeftHandSideExpression;
+  readonly kind: ts.SyntaxKind.NewExpression;
+  readonly parent: LeftHandSideExpressionParent;
+  readonly typeArguments?: ts.NodeArray<TypeNode>;
+}
+type NodeWithTypeArguments = ExpressionWithTypeArguments | ImportTypeNode | TypeQueryNode | TypeReferenceNode;
+interface NonNullExpression extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.NonNullExpression;
+  readonly parent: LeftHandSideExpressionParent;
+}
+interface NoSubstitutionTemplateLiteral extends ts.Node {
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _literalExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  hasExtendedUnicodeEscape?: boolean;
+  isUnterminated?: boolean;
+  readonly kind: ts.SyntaxKind.NoSubstitutionTemplateLiteral;
+  readonly parent: ClassStaticBlockDeclaration | ConstructorDeclaration | FunctionOrConstructorTypeNodeBase | JSDocFunctionType | LeftHandSideExpressionParent | LiteralTypeNode | MethodDeclaration | SemicolonClassElement | TypeElement;
+  rawText?: string;
+  text: string;
+}
+interface NotEmittedStatement extends ts.Node {
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly kind: ts.SyntaxKind.NotEmittedStatement;
+  readonly parent: StatementParent;
+}
+interface NotEmittedTypeElement extends ts.Node {
+  _declarationBrand: any;
+  _typeElementBrand: any;
+  readonly kind: ts.SyntaxKind.NotEmittedTypeElement;
+  readonly name?: PropertyName;
+  readonly parent: InterfaceDeclaration | MappedTypeNode | TypeLiteralNode;
+  readonly questionToken?: QuestionToken | undefined;
+}
+interface NullLiteral extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly kind: ts.SyntaxKind.NullKeyword;
+  readonly parent: LeftHandSideExpressionParent | LiteralTypeNode;
+}
+interface NumberKeyword extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.NumberKeyword;
+  readonly parent: TypeNodeParent;
+}
+interface NumericLiteral extends ts.Node {
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _literalExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  hasExtendedUnicodeEscape?: boolean;
+  isUnterminated?: boolean;
+  readonly kind: ts.SyntaxKind.NumericLiteral;
+  readonly parent: ClassStaticBlockDeclaration | ConstructorDeclaration | FunctionOrConstructorTypeNodeBase | JSDocFunctionType | LeftHandSideExpressionParent | LiteralTypeNode | MethodDeclaration | SemicolonClassElement | TypeElement;
+  text: string;
+}
+interface ObjectBindingPattern extends ts.Node {
+  readonly elements: ts.NodeArray<BindingElement>;
+  readonly kind: ts.SyntaxKind.ObjectBindingPattern;
+  readonly parent: BindingElement | ParameterDeclaration | VariableDeclaration;
+}
+interface ObjectKeyword extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.ObjectKeyword;
+  readonly parent: TypeNodeParent;
+}
+type ObjectLiteralElementLike = AccessorDeclaration | MethodDeclaration | PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment;
+interface ObjectLiteralExpression extends ts.Node {
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _jsdocContainerBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly kind: ts.SyntaxKind.ObjectLiteralExpression;
+  readonly parent: LeftHandSideExpressionParent;
+  readonly properties: ts.NodeArray<ObjectLiteralElementLike>;
+}
+type ObjectLiteralExpressionBase = ObjectLiteralExpression;
+interface OmittedExpression extends ts.Node {
+  _expressionBrand: any;
+  readonly kind: ts.SyntaxKind.OmittedExpression;
+  readonly parent: ArrayBindingPattern | ExpressionParent;
+}
+interface OptionalTypeNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.OptionalType;
+  readonly parent: TypeNodeParent;
+  readonly type: TypeNode;
+}
+interface OutKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.OutKeyword;
+  readonly parent: ModifierParent;
+}
+interface OverrideKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.OverrideKeyword;
+  readonly parent: ModifierParent;
+}
+interface ParameterDeclaration extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  readonly dotDotDotToken?: DotDotDotToken;
+  readonly initializer?: Expression;
+  readonly kind: ts.SyntaxKind.Parameter;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly name: BindingName;
+  readonly parent: AccessorDeclaration | ArrowFunction | CallSignatureDeclaration | ConstructorDeclaration | ConstructSignatureDeclaration | FunctionDeclaration | FunctionExpression | FunctionOrConstructorTypeNodeBase | IndexSignatureDeclaration | JSDocFunctionType | MethodDeclaration | MethodSignature | SyntheticExpression;
+  readonly questionToken?: QuestionToken;
+  readonly type?: TypeNode;
+}
+interface ParenthesizedExpression extends ts.Node {
+  _expressionBrand: any;
+  _jsdocContainerBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.ParenthesizedExpression;
+  readonly parent: LeftHandSideExpressionParent;
+}
+interface ParenthesizedTypeNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.ParenthesizedType;
+  readonly parent: TypeNodeParent;
+  readonly type: TypeNode;
+}
+interface PartiallyEmittedExpression extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.PartiallyEmittedExpression;
+  readonly parent: LeftHandSideExpressionParent;
+}
+interface PlusToken extends ts.Node {
+  readonly kind: ts.SyntaxKind.PlusToken;
+  readonly parent: MappedTypeNode;
+}
+interface PostfixUnaryExpression extends ts.Node {
+  _expressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly kind: ts.SyntaxKind.PostfixUnaryExpression;
+  readonly operand: LeftHandSideExpression;
+  readonly operator: PostfixUnaryOperator;
+  readonly parent: AwaitExpression | DeleteExpression | ExpressionParent | PrefixUnaryExpression | TypeAssertion | TypeOfExpression | VoidExpression;
+}
+type PostfixUnaryOperator = ts.SyntaxKind.MinusMinusToken | ts.SyntaxKind.PlusPlusToken;
+interface PrefixUnaryExpression extends ts.Node {
+  _expressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly kind: ts.SyntaxKind.PrefixUnaryExpression;
+  readonly operand: UnaryExpression;
+  readonly operator: PrefixUnaryOperator;
+  readonly parent: AwaitExpression | DeleteExpression | ExpressionParent | LiteralTypeNode | PrefixUnaryExpression | TypeAssertion | TypeOfExpression | VoidExpression;
+}
+type PrefixUnaryOperator = ts.SyntaxKind.ExclamationToken | ts.SyntaxKind.MinusMinusToken | ts.SyntaxKind.MinusToken | ts.SyntaxKind.PlusPlusToken | ts.SyntaxKind.PlusToken | ts.SyntaxKind.TildeToken;
+type PrimaryExpression = ArrayLiteralExpression | ClassExpression | FalseLiteral | FunctionExpression | Identifier | ImportExpression | JsxAttributes | JsxElement | JsxFragment | JsxSelfClosingElement | LiteralExpression | MetaProperty | MissingDeclaration | NewExpression | NullLiteral | ObjectLiteralExpressionBase | ParenthesizedExpression | PrivateIdentifier | SuperExpression | TemplateExpression | ThisExpression | TrueLiteral;
+interface PrivateIdentifier extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly escapedText: ts.__String;
+  readonly kind: ts.SyntaxKind.PrivateIdentifier;
+  readonly parent: ClassStaticBlockDeclaration | ConstructorDeclaration | FunctionOrConstructorTypeNodeBase | JSDocFunctionType | JsxTagNamePropertyAccess | LeftHandSideExpressionParent | MethodDeclaration | SemicolonClassElement | TypeElement;
+  readonly text: string;
+}
+interface PrivateKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.PrivateKeyword;
+  readonly parent: ModifierParent;
+}
+interface PropertyAccessExpression extends ts.Node {
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly expression: LeftHandSideExpression;
+  readonly kind: ts.SyntaxKind.PropertyAccessExpression;
+  readonly name: MemberName;
+  readonly parent: LeftHandSideExpressionParent;
+  readonly questionDotToken?: QuestionDotToken;
+}
+interface PropertyAssignment extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _objectLiteralBrand: any;
+  readonly initializer: Expression;
+  readonly kind: ts.SyntaxKind.PropertyAssignment;
+  readonly name: PropertyName;
+  readonly parent: ObjectLiteralExpressionBase;
+}
+interface PropertyDeclaration extends ts.Node {
+  _classElementBrand: any;
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  readonly exclamationToken?: ExclamationToken;
+  readonly initializer?: Expression;
+  readonly kind: ts.SyntaxKind.PropertyDeclaration;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly name: PropertyName;
+  readonly parent: ClassDeclaration | ClassExpression;
+  readonly questionToken?: QuestionToken;
+  readonly type?: TypeNode;
+}
+type PropertyName = BigIntLiteral | ComputedPropertyName | Identifier | NoSubstitutionTemplateLiteral | NumericLiteral | PrivateIdentifier | StringLiteral;
+interface PropertySignature extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _typeElementBrand: any;
+  readonly kind: ts.SyntaxKind.PropertySignature;
+  readonly modifiers?: ts.NodeArray<Modifier>;
+  readonly name: PropertyName;
+  readonly parent: InterfaceDeclaration | MappedTypeNode | TypeLiteralNode;
+  readonly questionToken?: QuestionToken;
+  readonly type?: TypeNode;
+}
+interface ProtectedKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.ProtectedKeyword;
+  readonly parent: ModifierParent;
+}
+interface PublicKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.PublicKeyword;
+  readonly parent: ModifierParent;
+}
+interface QualifiedName extends ts.Node {
+  _flowContainerBrand: any;
+  readonly kind: ts.SyntaxKind.QualifiedName;
+  readonly left: EntityName;
+  readonly parent: ImportEqualsDeclaration | ImportTypeNode | JSDocLink | JSDocLinkCode | JSDocLinkPlain | JSDocMemberName | JSDocPropertyLikeTag | QualifiedName | TypeQueryNode | TypeReferenceNode;
+  readonly right: Identifier;
+}
+interface QuestionDotToken extends ts.Node {
+  readonly kind: ts.SyntaxKind.QuestionDotToken;
+  readonly parent: CallExpression | ElementAccessExpression | JsxTagNamePropertyAccess | PropertyAccessExpression;
+}
+interface QuestionToken extends ts.Node {
+  readonly kind: ts.SyntaxKind.QuestionToken;
+  readonly parent: ArrowFunction | ConditionalExpression | ConstructorDeclaration | FunctionDeclaration | FunctionExpression | MappedTypeNode | MethodDeclaration | ParameterDeclaration | PropertyDeclaration | TypeElement;
+}
+interface ReadonlyKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.ReadonlyKeyword;
+  readonly parent: MappedTypeNode | ModifierParent;
+}
+interface RegularExpressionLiteral extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _literalExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  hasExtendedUnicodeEscape?: boolean;
+  isUnterminated?: boolean;
+  readonly kind: ts.SyntaxKind.RegularExpressionLiteral;
+  readonly parent: LeftHandSideExpressionParent | LiteralTypeNode;
+  text: string;
+}
+type RelationalOperator = ts.SyntaxKind.GreaterThanEqualsToken | ts.SyntaxKind.GreaterThanToken | ts.SyntaxKind.InKeyword | ts.SyntaxKind.InstanceOfKeyword | ts.SyntaxKind.LessThanEqualsToken | ts.SyntaxKind.LessThanToken;
+type RelationalOperatorOrHigher = RelationalOperator | ShiftOperatorOrHigher;
+interface RestTypeNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.RestType;
+  readonly parent: TypeNodeParent;
+  readonly type: TypeNode;
+}
+interface ReturnStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly expression?: Expression;
+  readonly kind: ts.SyntaxKind.ReturnStatement;
+  readonly parent: StatementParent;
+}
+interface SatisfiesExpression extends ts.Node {
+  _expressionBrand: any;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.SatisfiesExpression;
+  readonly parent: ExpressionParent;
+  readonly type: TypeNode;
+}
+interface SemicolonClassElement extends ts.Node {
+  _classElementBrand: any;
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  readonly kind: ts.SyntaxKind.SemicolonClassElement;
+  readonly name?: PropertyName;
+  readonly parent: ClassDeclaration | ClassExpression;
+}
+interface SetAccessorDeclaration extends ts.Node {
+  _classElementBrand: any;
+  _declarationBrand: any;
+  _flowContainerBrand: any;
+  _functionLikeDeclarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _objectLiteralBrand: any;
+  _typeElementBrand: any;
+  readonly asteriskToken?: AsteriskToken | undefined;
+  readonly body?: FunctionBody;
+  readonly exclamationToken?: ExclamationToken | undefined;
+  readonly kind: ts.SyntaxKind.SetAccessor;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly name: PropertyName;
+  readonly parameters: ts.NodeArray<ParameterDeclaration>;
+  readonly parent: ClassDeclaration | ClassExpression | InterfaceDeclaration | MappedTypeNode | ObjectLiteralExpressionBase | TypeLiteralNode;
+  readonly questionToken?: QuestionToken | undefined;
+  readonly type?: TypeNode | undefined;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration> | undefined;
+}
+type ShiftOperator = ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken | ts.SyntaxKind.GreaterThanGreaterThanToken | ts.SyntaxKind.LessThanLessThanToken;
+type ShiftOperatorOrHigher = AdditiveOperatorOrHigher | ShiftOperator;
+interface ShorthandPropertyAssignment extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _objectLiteralBrand: any;
+  readonly equalsToken?: EqualsToken;
+  readonly kind: ts.SyntaxKind.ShorthandPropertyAssignment;
+  readonly name: Identifier;
+  readonly objectAssignmentInitializer?: Expression;
+  readonly parent: ObjectLiteralExpressionBase;
+}
+interface SourceFile extends ts.Node {
+  readonly kind: ts.SyntaxKind.SourceFile;
+  amdDependencies: readonly ts.AmdDependency[];
+  readonly endOfFileToken: Token<ts.SyntaxKind.EndOfFileToken, SourceFile>;
+  fileName: string;
+  isDeclarationFile: boolean;
+  languageVariant: ts.LanguageVariant;
+  libReferenceDirectives: readonly ts.FileReference[];
+  moduleName?: string;
+  readonly parent: NullNode;
+  referencedFiles: readonly ts.FileReference[];
+  readonly statements: ts.NodeArray<Statement>;
+  text: string;
+  typeReferenceDirectives: readonly ts.FileReference[];
+  /**
+   * lib.d.ts should have a reference comment like
+   *
+   *  /// &lt;reference no-default-lib="true"/>
+   *
+   * If any other file has this comment, it signals not to include lib.d.ts
+   * because this containing file is intended to act as a default library.
+   */
+  hasNoDefaultLib: boolean;
+  languageVersion: ts.ScriptTarget;
+  /**
+   * When `module` is `Node16` or `NodeNext`, this field controls whether the
+   * source file in question is an ESNext-output-format file, or a CommonJS-output-format
+   * module. This is derived by the module resolver as it looks up the file, since
+   * it is derived from either the file extension of the module, or the containing
+   * `package.json` context, and affects both checking and emit.
+   *
+   * It is _public_ so that (pre)transformers can set this field,
+   * since it switches the builtin `node` module transform. Generally speaking, if unset,
+   * the field is treated as though it is `ModuleKind.CommonJS`.
+   *
+   * Note that this field is only set by the module resolution process when
+   * `moduleResolution` is `Node16` or `NodeNext`, which is implied by the `module` setting
+   * of `Node16` or `NodeNext`, respectively, but may be overriden (eg, by a `moduleResolution`
+   * of `node`). If so, this field will be unset and source files will be considered to be
+   * CommonJS-output-format by the node module transformer and type checker, regardless of extension or context.
+   */
+  _declarationBrand: any;
+  _localsContainerBrand: any;
+  getLineAndCharacterOfPosition(pos: number): ts.LineAndCharacter;
+  getLineEndOfPosition(pos: number): number;
+  getLineStarts(): readonly number[];
+  getPositionOfLineAndCharacter(line: number, character: number): number;
+  impliedNodeFormat?: ts.ResolutionMode;
+  update(newText: string, textChangeRange: ts.TextChangeRange): SourceFile;
+}
+interface SpreadAssignment extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _objectLiteralBrand: any;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.SpreadAssignment;
+  readonly name?: PropertyName;
+  readonly parent: ObjectLiteralExpressionBase;
+}
+interface SpreadElement extends ts.Node {
+  _expressionBrand: any;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.SpreadElement;
+  readonly parent: ExpressionParent;
+}
+type Statement = Block | BreakStatement | ContinueStatement | DebuggerStatement | DeclarationStatement | EmptyStatement | ExpressionStatement | IfStatement | ImportDeclaration | IterationStatement | LabeledStatement | ModuleBlock | NotEmittedStatement | ReturnStatement | SwitchStatement | ThrowStatement | TryStatement | VariableStatement | WithStatement;
+interface StaticKeyword extends ts.Node {
+  readonly kind: ts.SyntaxKind.StaticKeyword;
+  readonly parent: ModifierParent;
+}
+interface StringKeyword extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.StringKeyword;
+  readonly parent: TypeNodeParent;
+}
+interface StringLiteral extends ts.Node {
+  _declarationBrand: any;
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _literalExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  hasExtendedUnicodeEscape?: boolean;
+  isUnterminated?: boolean;
+  readonly kind: ts.SyntaxKind.StringLiteral;
+  readonly parent: ArrayLiteralExpression | ArrowFunction | AsExpression | AwaitExpression | BinaryExpression | BindingElement | CallExpression | CaseClause | ClassStaticBlockDeclaration | CommaListExpression | ComputedPropertyName | ConditionalExpression | ConstructorDeclaration | Decorator | DeleteExpression | ElementAccessExpression | EnumMember | ExportAssignment | ExportDeclaration | ExportSpecifier | ExpressionStatement | ExpressionWithTypeArguments | ExternalModuleReference | FunctionOrConstructorTypeNodeBase | IfStatement | ImportAttribute | ImportDeclaration | ImportSpecifier | IterationStatement | JSDocFunctionType | JsxAttributeLike | JsxExpression | LiteralTypeNode | MethodDeclaration | ModuleDeclaration | NamespaceExport | NewExpression | NonNullExpression | ParameterDeclaration | ParenthesizedExpression | PartiallyEmittedExpression | PostfixUnaryExpression | PrefixUnaryExpression | PropertyAccessExpression | PropertyAssignment | PropertyDeclaration | ReturnStatement | SatisfiesExpression | SemicolonClassElement | ShorthandPropertyAssignment | SpreadAssignment | SpreadElement | SwitchStatement | TaggedTemplateExpression | TemplateSpan | ThrowStatement | TypeAssertion | TypeElement | TypeOfExpression | TypeParameterDeclaration | VariableDeclaration | VoidExpression | WithStatement | YieldExpression;
+  text: string;
+}
+interface SuperExpression extends ts.Node {
+  _expressionBrand: any;
+  _flowContainerBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly kind: ts.SyntaxKind.SuperKeyword;
+  readonly parent: LeftHandSideExpressionParent;
+}
+interface SwitchStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly caseBlock: CaseBlock;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.SwitchStatement;
+  readonly parent: StatementParent;
+  possiblyExhaustive?: boolean;
+}
+interface SymbolKeyword extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.SymbolKeyword;
+  readonly parent: TypeNodeParent;
+}
+interface SyntheticExpression extends ts.Node {
+  _expressionBrand: any;
+  readonly isSpread: boolean;
+  readonly kind: ts.SyntaxKind.SyntheticExpression;
+  readonly parent: ExpressionParent;
+  readonly tupleNameSource?: NamedTupleMember | ParameterDeclaration;
+  readonly type: ts.Type;
+}
+interface TaggedTemplateExpression extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly kind: ts.SyntaxKind.TaggedTemplateExpression;
+  readonly parent: LeftHandSideExpressionParent;
+  readonly tag: LeftHandSideExpression;
+  readonly template: TemplateLiteral;
+  readonly typeArguments?: ts.NodeArray<TypeNode>;
+}
+interface TemplateExpression extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly head: TemplateHead;
+  readonly kind: ts.SyntaxKind.TemplateExpression;
+  readonly parent: LeftHandSideExpressionParent;
+  readonly templateSpans: ts.NodeArray<TemplateSpan>;
+}
+interface TemplateHead extends ts.Node {
+  hasExtendedUnicodeEscape?: boolean;
+  isUnterminated?: boolean;
+  readonly kind: ts.SyntaxKind.TemplateHead;
+  readonly parent: TemplateExpression | TemplateLiteralTypeNode;
+  rawText?: string;
+  text: string;
+}
+type TemplateLiteral = NoSubstitutionTemplateLiteral | TemplateExpression;
+interface TemplateLiteralTypeNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly head: TemplateHead;
+  readonly kind: ts.SyntaxKind.TemplateLiteralType;
+  readonly parent: TypeNodeParent;
+  readonly templateSpans: ts.NodeArray<TemplateLiteralTypeSpan>;
+}
+interface TemplateLiteralTypeSpan extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.TemplateLiteralTypeSpan;
+  readonly literal: TemplateMiddle | TemplateTail;
+  readonly parent: TemplateLiteralTypeNode | TypeNodeParent;
+  readonly type: TypeNode;
+}
+interface TemplateMiddle extends ts.Node {
+  hasExtendedUnicodeEscape?: boolean;
+  isUnterminated?: boolean;
+  readonly kind: ts.SyntaxKind.TemplateMiddle;
+  readonly parent: TemplateLiteralTypeSpan | TemplateSpan;
+  rawText?: string;
+  text: string;
+}
+interface TemplateSpan extends ts.Node {
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.TemplateSpan;
+  readonly literal: TemplateMiddle | TemplateTail;
+  readonly parent: TemplateExpression;
+}
+interface TemplateTail extends ts.Node {
+  hasExtendedUnicodeEscape?: boolean;
+  isUnterminated?: boolean;
+  readonly kind: ts.SyntaxKind.TemplateTail;
+  readonly parent: TemplateLiteralTypeSpan | TemplateSpan;
+  rawText?: string;
+  text: string;
+}
+interface ThisExpression extends ts.Node {
+  _expressionBrand: any;
+  _flowContainerBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly kind: ts.SyntaxKind.ThisKeyword;
+  readonly parent: JsxClosingElement | JsxOpeningElement | JsxSelfClosingElement | JsxTagNamePropertyAccess | LeftHandSideExpressionParent;
+}
+interface ThisTypeNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.ThisType;
+  readonly parent: TypeNodeParent;
+}
+interface ThrowStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.ThrowStatement;
+  readonly parent: StatementParent;
+}
+interface TrueLiteral extends ts.Node {
+  _expressionBrand: any;
+  _leftHandSideExpressionBrand: any;
+  _memberExpressionBrand: any;
+  _primaryExpressionBrand: any;
+  _unaryExpressionBrand: any;
+  _updateExpressionBrand: any;
+  readonly kind: ts.SyntaxKind.TrueKeyword;
+  readonly parent: LeftHandSideExpressionParent | LiteralTypeNode;
+}
+interface TryStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly catchClause?: CatchClause;
+  readonly finallyBlock?: Block;
+  readonly kind: ts.SyntaxKind.TryStatement;
+  readonly parent: StatementParent;
+  readonly tryBlock: Block;
+}
+interface TupleTypeNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly elements: ts.NodeArray<NamedTupleMember | TypeNode>;
+  readonly kind: ts.SyntaxKind.TupleType;
+  readonly parent: TypeNodeParent;
+}
+interface TypeAliasDeclaration extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  _localsContainerBrand: any;
+  _statementBrand: any;
+  readonly kind: ts.SyntaxKind.TypeAliasDeclaration;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly name: Identifier;
+  readonly parent: StatementParent;
+  readonly type: TypeNode;
+  readonly typeParameters?: ts.NodeArray<TypeParameterDeclaration>;
+}
+interface TypeAssertion extends ts.Node {
+  _expressionBrand: any;
+  _unaryExpressionBrand: any;
+  readonly expression: UnaryExpression;
+  readonly kind: ts.SyntaxKind.TypeAssertionExpression;
+  readonly parent: AwaitExpression | DeleteExpression | ExpressionParent | PrefixUnaryExpression | TypeAssertion | TypeOfExpression | VoidExpression;
+  readonly type: TypeNode;
+}
+type TypeElement = CallSignatureDeclaration | ConstructSignatureDeclaration | GetAccessorDeclaration | IndexSignatureDeclaration | MethodSignature | NotEmittedTypeElement | PropertySignature | SetAccessorDeclaration;
+interface TypeLiteralNode extends ts.Node {
+  _declarationBrand: any;
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.TypeLiteral;
+  readonly members: ts.NodeArray<TypeElement>;
+  readonly parent: TypeNodeParent;
+}
+type TypeNode = AnyKeyword | ArrayTypeNode | BigIntKeyword | BooleanKeyword | ConditionalTypeNode | FunctionOrConstructorTypeNodeBase | IndexedAccessTypeNode | InferTypeNode | IntersectionTypeNode | IntrinsicKeyword | JSDocType | JSDocTypeExpression | LiteralTypeNode | MappedTypeNode | NamedTupleMember | NeverKeyword | NodeWithTypeArguments | NumberKeyword | ObjectKeyword | OptionalTypeNode | ParenthesizedTypeNode | RestTypeNode | StringKeyword | SymbolKeyword | TemplateLiteralTypeNode | TemplateLiteralTypeSpan | ThisTypeNode | TupleTypeNode | TypeLiteralNode | TypeOperatorNode | TypePredicateNode | UndefinedKeyword | UnionTypeNode | UnknownKeyword | VoidKeyword;
+interface TypeOfExpression extends ts.Node {
+  _expressionBrand: any;
+  _unaryExpressionBrand: any;
+  readonly expression: UnaryExpression;
+  readonly kind: ts.SyntaxKind.TypeOfExpression;
+  readonly parent: AwaitExpression | DeleteExpression | ExpressionParent | PrefixUnaryExpression | TypeAssertion | TypeOfExpression | VoidExpression;
+}
+interface TypeOperatorNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.TypeOperator;
+  readonly operator: ts.SyntaxKind.KeyOfKeyword | ts.SyntaxKind.ReadonlyKeyword | ts.SyntaxKind.UniqueKeyword;
+  readonly parent: TypeNodeParent;
+  readonly type: TypeNode;
+}
+interface TypeParameterDeclaration extends ts.Node {
+  readonly kind: ts.SyntaxKind.TypeParameter;
+  readonly modifiers?: ts.NodeArray<Modifier>;
+  readonly name: Identifier;
+  readonly parent: AccessorDeclaration | ArrowFunction | CallSignatureDeclaration | ClassDeclaration | ClassExpression | ConstructorDeclaration | ConstructSignatureDeclaration | FunctionDeclaration | FunctionExpression | FunctionOrConstructorTypeNodeBase | IndexSignatureDeclaration | InferTypeNode | InterfaceDeclaration | JSDocFunctionType | JSDocTemplateTag | MappedTypeNode | MethodDeclaration | MethodSignature | TypeAliasDeclaration;
+  /** Note: Consider calling `getEffectiveConstraintOfTypeParameter` */
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  readonly constraint?: TypeNode;
+  readonly default?: TypeNode;
+  expression?: Expression;
+}
+interface TypePredicateNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly assertsModifier?: AssertsKeyword;
+  readonly kind: ts.SyntaxKind.TypePredicate;
+  readonly parameterName: Identifier | ThisTypeNode;
+  readonly parent: TypeNodeParent;
+  readonly type?: TypeNode;
+}
+interface TypeQueryNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly exprName: EntityName;
+  readonly kind: ts.SyntaxKind.TypeQuery;
+  readonly parent: TypeNodeParent;
+  readonly typeArguments?: ts.NodeArray<TypeNode>;
+}
+interface TypeReferenceNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.TypeReference;
+  readonly parent: TypeNodeParent;
+  readonly typeArguments?: ts.NodeArray<TypeNode>;
+  readonly typeName: EntityName;
+}
+type UnaryExpression = AwaitExpression | DeleteExpression | TypeAssertion | TypeOfExpression | UpdateExpression | VoidExpression;
+interface UndefinedKeyword extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.UndefinedKeyword;
+  readonly parent: TypeNodeParent;
+}
+interface UnionTypeNode extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.UnionType;
+  readonly parent: TypeNodeParent;
+  readonly types: ts.NodeArray<TypeNode>;
+}
+interface UnknownKeyword extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.UnknownKeyword;
+  readonly parent: TypeNodeParent;
+}
+type UpdateExpression = LeftHandSideExpression | PostfixUnaryExpression | PrefixUnaryExpression;
+interface VariableDeclaration extends ts.Node {
+  _declarationBrand: any;
+  _jsdocContainerBrand: any;
+  readonly exclamationToken?: ExclamationToken;
+  readonly initializer?: Expression;
+  readonly kind: ts.SyntaxKind.VariableDeclaration;
+  readonly name: BindingName;
+  readonly parent: CatchClause | VariableDeclarationList;
+  readonly type?: TypeNode;
+}
+interface VariableDeclarationList extends ts.Node {
+  readonly declarations: ts.NodeArray<VariableDeclaration>;
+  readonly kind: ts.SyntaxKind.VariableDeclarationList;
+  readonly parent: ForInStatement | ForOfStatement | ForStatement | VariableStatement;
+}
+interface VariableStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly declarationList: VariableDeclarationList;
+  readonly kind: ts.SyntaxKind.VariableStatement;
+  readonly modifiers?: ts.NodeArray<ModifierLike>;
+  readonly parent: StatementParent;
+}
+interface VoidExpression extends ts.Node {
+  _expressionBrand: any;
+  _unaryExpressionBrand: any;
+  readonly expression: UnaryExpression;
+  readonly kind: ts.SyntaxKind.VoidExpression;
+  readonly parent: AwaitExpression | DeleteExpression | ExpressionParent | PrefixUnaryExpression | TypeAssertion | TypeOfExpression | VoidExpression;
+}
+interface VoidKeyword extends ts.Node {
+  _typeNodeBrand: any;
+  readonly kind: ts.SyntaxKind.VoidKeyword;
+  readonly parent: TypeNodeParent;
+}
+interface WhileStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.WhileStatement;
+  readonly parent: StatementParent;
+  readonly statement: Statement;
+}
+interface WithStatement extends ts.Node {
+  _flowContainerBrand: any;
+  _jsdocContainerBrand: any;
+  _statementBrand: any;
+  readonly expression: Expression;
+  readonly kind: ts.SyntaxKind.WithStatement;
+  readonly parent: StatementParent;
+  readonly statement: Statement;
+}
+interface YieldExpression extends ts.Node {
+  _expressionBrand: any;
+  readonly asteriskToken?: AsteriskToken;
+  readonly expression?: Expression;
+  readonly kind: ts.SyntaxKind.YieldExpression;
+  readonly parent: ExpressionParent;
+}
+interface Token<Kind extends ts.SyntaxKind, Parent extends ts.Node> extends ts.Node {
+  readonly kind: Kind;
+  readonly parent: Parent;
+}
+interface NullNode extends ts.Node {
+  readonly kind: ts.SyntaxKind.NullKeyword;
+  readonly parent: NullNode;
+}
+type ExpressionParent = ArrayLiteralExpression | ArrowFunction | AsExpression | BinaryExpression | BindingElement | CallExpression | CaseClause | CommaListExpression | ComputedPropertyName | ConditionalExpression | ElementAccessExpression | EnumMember | ExportAssignment | ExportDeclaration | ExpressionStatement | ExternalModuleReference | IfStatement | ImportAttribute | ImportDeclaration | IterationStatement | JsxExpression | JsxSpreadAttribute | NewExpression | NonNullExpression | ParameterDeclaration | ParenthesizedExpression | PartiallyEmittedExpression | PropertyAssignment | PropertyDeclaration | ReturnStatement | SatisfiesExpression | ShorthandPropertyAssignment | SpreadAssignment | SpreadElement | SwitchStatement | TemplateSpan | ThrowStatement | TypeParameterDeclaration | VariableDeclaration | WithStatement | YieldExpression;
+type LeftHandSideExpressionParent = AwaitExpression | Decorator | DeleteExpression | ExpressionParent | ExpressionWithTypeArguments | PostfixUnaryExpression | PrefixUnaryExpression | PropertyAccessExpression | TaggedTemplateExpression | TypeAssertion | TypeOfExpression | VoidExpression;
+type ModifierParent = AccessorDeclaration | ArrowFunction | ClassDeclaration | ClassExpression | ConstructorDeclaration | ConstructorTypeNode | EnumDeclaration | ExportAssignment | ExportDeclaration | FunctionDeclaration | FunctionExpression | ImportDeclaration | ImportEqualsDeclaration | IndexSignatureDeclaration | InterfaceDeclaration | JSDocNamespaceDeclaration | MethodDeclaration | MethodSignature | ModuleDeclaration | NamespaceDeclaration | ParameterDeclaration | PropertyDeclaration | PropertySignature | TypeAliasDeclaration | TypeParameterDeclaration | VariableStatement;
+type StatementParent = Block | CaseOrDefaultClause | IfStatement | IterationStatement | LabeledStatement | ModuleBlock | SourceFile | WithStatement;
+type TypeNodeParent = AccessorDeclaration | ArrayTypeNode | ArrowFunction | AsExpression | CallExpression | CallSignatureDeclaration | ConditionalTypeNode | ConstructorDeclaration | ConstructSignatureDeclaration | FunctionDeclaration | FunctionExpression | FunctionOrConstructorTypeNodeBase | IndexedAccessTypeNode | IndexSignatureDeclaration | IntersectionTypeNode | JSDocFunctionType | JSDocNamepathType | JSDocNonNullableType | JSDocNullableType | JSDocOptionalType | JSDocTypeExpression | JSDocVariadicType | JsxOpeningElement | JsxSelfClosingElement | MappedTypeNode | MethodDeclaration | MethodSignature | NamedTupleMember | NewExpression | NodeWithTypeArguments | OptionalTypeNode | ParameterDeclaration | ParenthesizedTypeNode | PropertyDeclaration | PropertySignature | RestTypeNode | SatisfiesExpression | TaggedTemplateExpression | TemplateLiteralTypeSpan | TupleTypeNode | TypeAliasDeclaration | TypeAssertion | TypeOperatorNode | TypeParameterDeclaration | TypePredicateNode | UnionTypeNode | VariableDeclaration;
+//#endregion
+export { CallExpression, Decorator, Expression, JsxOpeningElement, JsxSelfClosingElement, NewExpression, PropertyAccessExpression, TaggedTemplateExpression };
+//# sourceMappingURL=ast.d.ts.map