ts-simple-ast

  • Version 21.0.4
  • Published
  • 1.95 MB
  • 9 dependencies
  • MIT license

Install

npm i ts-simple-ast
yarn add ts-simple-ast
pnpm add ts-simple-ast

Overview

TypeScript compiler wrapper for static analysis and code manipulation.

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable ArrayDestructuringAssignmentBase

const ArrayDestructuringAssignmentBase: typeof AssignmentExpression;

    variable ArrowFunctionBase

    const ArrowFunctionBase: Constructor<TextInsertableNode> &
    Constructor<BodiedNode> &
    Constructor<AsyncableNode> &
    Constructor<FunctionLikeDeclaration> &
    typeof Expression;

      variable AsExpressionBase

      const AsExpressionBase: Constructor<TypedNode> &
      Constructor<ExpressionedNode> &
      typeof Expression;

        variable AssignmentExpressionBase

        const AssignmentExpressionBase: typeof BinaryExpression;

          variable AwaitExpressionBase

          const AwaitExpressionBase: Constructor<UnaryExpressionedNode> &
          typeof UnaryExpression;

            variable BinaryExpressionBase

            const BinaryExpressionBase: typeof Expression;

              variable BindingElementBase

              const BindingElementBase: Constructor<InitializerExpressionableNode> &
              Constructor<BindingNamedNode> &
              typeof Node;

                variable BlockBase

                const BlockBase: Constructor<TextInsertableNode> &
                Constructor<StatementedNode> &
                typeof Statement;

                  variable BooleanLiteralBase

                  const BooleanLiteralBase: typeof PrimaryExpression;

                    variable BreakStatementBase

                    const BreakStatementBase: Constructor<ChildOrderableNode> & typeof Statement;

                      variable CallExpressionBase

                      const CallExpressionBase: Constructor<TypeArgumentedNode> &
                      Constructor<ArgumentedNode> &
                      Constructor<LeftHandSideExpressionedNode> &
                      typeof LeftHandSideExpression;

                        variable CallSignatureDeclarationBase

                        const CallSignatureDeclarationBase: Constructor<TypeParameteredNode> &
                        Constructor<ChildOrderableNode> &
                        Constructor<JSDocableNode> &
                        Constructor<SignaturedDeclaration> &
                        typeof TypeElement;

                          variable CaseBlockBase

                          const CaseBlockBase: Constructor<TextInsertableNode> & typeof Node;

                            variable CaseClauseBase

                            const CaseClauseBase: Constructor<ChildOrderableNode> &
                            Constructor<TextInsertableNode> &
                            Constructor<StatementedNode> &
                            typeof Node;

                              variable CatchClauseBase

                              const CatchClauseBase: typeof Node;

                                variable ClassDeclarationBase

                                const ClassDeclarationBase: Constructor<ChildOrderableNode> &
                                Constructor<NamespaceChildableNode> &
                                Constructor<AmbientableNode> &
                                Constructor<ExportableNode> &
                                Constructor<ClassLikeDeclarationBase> &
                                typeof Statement;

                                  variable ClassExpressionBase

                                  const ClassExpressionBase: Constructor<ClassLikeDeclarationBase> &
                                  typeof PrimaryExpression;

                                    variable CommaListExpressionBase

                                    const CommaListExpressionBase: typeof Expression;

                                      variable ConditionalExpressionBase

                                      const ConditionalExpressionBase: typeof Expression;

                                        variable ConstructorDeclarationBase

                                        const ConstructorDeclarationBase: Constructor<ChildOrderableNode> &
                                        Constructor<TextInsertableNode> &
                                        Constructor<OverloadableNode> &
                                        Constructor<ScopedNode> &
                                        Constructor<FunctionLikeDeclaration> &
                                        Constructor<BodyableNode> &
                                        typeof Node;

                                          variable ConstructorDeclarationOverloadBase

                                          const ConstructorDeclarationOverloadBase: Constructor<TypeParameteredNode> &
                                          Constructor<JSDocableNode> &
                                          Constructor<ChildOrderableNode> &
                                          Constructor<TextInsertableNode> &
                                          Constructor<ScopedNode> &
                                          Constructor<ModifierableNode> &
                                          Constructor<SignaturedDeclaration> &
                                          typeof Node;

                                            variable ConstructSignatureDeclarationBase

                                            const ConstructSignatureDeclarationBase: Constructor<TypeParameteredNode> &
                                            Constructor<ChildOrderableNode> &
                                            Constructor<JSDocableNode> &
                                            Constructor<SignaturedDeclaration> &
                                            typeof TypeElement;

                                              variable ContinueStatementBase

                                              const ContinueStatementBase: Constructor<ChildOrderableNode> & typeof Statement;

                                                variable DebuggerStatementBase

                                                const DebuggerStatementBase: typeof Statement;

                                                  variable DecoratorBase

                                                  const DecoratorBase: typeof Node;

                                                    variable DefaultClauseBase

                                                    const DefaultClauseBase: Constructor<ChildOrderableNode> &
                                                    Constructor<TextInsertableNode> &
                                                    Constructor<StatementedNode> &
                                                    typeof Node;

                                                      variable DeleteExpressionBase

                                                      const DeleteExpressionBase: Constructor<UnaryExpressionedNode> &
                                                      typeof UnaryExpression;

                                                        variable DoStatementBase

                                                        const DoStatementBase: typeof IterationStatement;

                                                          variable ElementAccessExpressionBase

                                                          const ElementAccessExpressionBase: Constructor<LeftHandSideExpressionedNode> &
                                                          typeof MemberExpression;

                                                            variable EmptyStatementBase

                                                            const EmptyStatementBase: typeof Statement;

                                                              variable EnumDeclarationBase

                                                              const EnumDeclarationBase: Constructor<ChildOrderableNode> &
                                                              Constructor<TextInsertableNode> &
                                                              Constructor<NamespaceChildableNode> &
                                                              Constructor<JSDocableNode> &
                                                              Constructor<AmbientableNode> &
                                                              Constructor<ExportableNode> &
                                                              Constructor<ModifierableNode> &
                                                              Constructor<NamedNode> &
                                                              typeof Statement;

                                                                variable EnumMemberBase

                                                                const EnumMemberBase: Constructor<JSDocableNode> &
                                                                Constructor<InitializerExpressionableNode> &
                                                                Constructor<PropertyNamedNode> &
                                                                typeof Node;

                                                                  variable ExportAssignmentBase

                                                                  const ExportAssignmentBase: typeof Statement;

                                                                    variable ExportDeclarationBase

                                                                    const ExportDeclarationBase: typeof Statement;

                                                                      variable ExportSpecifierBase

                                                                      const ExportSpecifierBase: typeof Node;

                                                                        variable ExpressionStatementBase

                                                                        const ExpressionStatementBase: Constructor<JSDocableNode> &
                                                                        Constructor<ChildOrderableNode> &
                                                                        typeof Statement;

                                                                          variable ExpressionWithTypeArgumentsBase

                                                                          const ExpressionWithTypeArgumentsBase: Constructor<LeftHandSideExpressionedNode> &
                                                                          typeof TypeNode;

                                                                            variable ForInStatementBase

                                                                            const ForInStatementBase: typeof IterationStatement;

                                                                              variable ForOfStatementBase

                                                                              const ForOfStatementBase: Constructor<AwaitableNode> & typeof IterationStatement;

                                                                                variable ForStatementBase

                                                                                const ForStatementBase: typeof IterationStatement;

                                                                                  variable FunctionDeclarationBase

                                                                                  const FunctionDeclarationBase: Constructor<ChildOrderableNode> &
                                                                                  Constructor<UnwrappableNode> &
                                                                                  Constructor<TextInsertableNode> &
                                                                                  Constructor<OverloadableNode> &
                                                                                  Constructor<BodyableNode> &
                                                                                  Constructor<AsyncableNode> &
                                                                                  Constructor<GeneratorableNode> &
                                                                                  Constructor<FunctionLikeDeclaration> &
                                                                                  Constructor<StatementedNode> &
                                                                                  Constructor<AmbientableNode> &
                                                                                  Constructor<NamespaceChildableNode> &
                                                                                  Constructor<ExportableNode> &
                                                                                  Constructor<ModifierableNode> &
                                                                                  Constructor<NameableNode> &
                                                                                  typeof Node;

                                                                                    variable FunctionDeclarationOverloadBase

                                                                                    const FunctionDeclarationOverloadBase: Constructor<ChildOrderableNode> &
                                                                                    Constructor<UnwrappableNode> &
                                                                                    Constructor<TextInsertableNode> &
                                                                                    Constructor<AsyncableNode> &
                                                                                    Constructor<GeneratorableNode> &
                                                                                    Constructor<ModifierableNode> &
                                                                                    Constructor<SignaturedDeclaration> &
                                                                                    Constructor<StatementedNode> &
                                                                                    Constructor<AmbientableNode> &
                                                                                    Constructor<NamespaceChildableNode> &
                                                                                    Constructor<JSDocableNode> &
                                                                                    Constructor<TypeParameteredNode> &
                                                                                    Constructor<ExportableNode> &
                                                                                    typeof Node;

                                                                                      variable FunctionExpressionBase

                                                                                      const FunctionExpressionBase: Constructor<JSDocableNode> &
                                                                                      Constructor<TextInsertableNode> &
                                                                                      Constructor<BodiedNode> &
                                                                                      Constructor<AsyncableNode> &
                                                                                      Constructor<GeneratorableNode> &
                                                                                      Constructor<StatementedNode> &
                                                                                      Constructor<TypeParameteredNode> &
                                                                                      Constructor<SignaturedDeclaration> &
                                                                                      Constructor<ModifierableNode> &
                                                                                      Constructor<NameableNode> &
                                                                                      typeof PrimaryExpression;

                                                                                        variable FunctionOrConstructorTypeNodeBaseBase

                                                                                        const FunctionOrConstructorTypeNodeBaseBase: Constructor<SignaturedDeclaration> &
                                                                                        typeof TypeNode;

                                                                                          variable FunctionTypeNodeBase

                                                                                          const FunctionTypeNodeBase: Constructor<TypeParameteredNode> &
                                                                                          typeof FunctionOrConstructorTypeNodeBase;

                                                                                            variable GetAccessorDeclarationBase

                                                                                            const GetAccessorDeclarationBase: Constructor<ChildOrderableNode> &
                                                                                            Constructor<TextInsertableNode> &
                                                                                            Constructor<DecoratableNode> &
                                                                                            Constructor<AbstractableNode> &
                                                                                            Constructor<ScopedNode> &
                                                                                            Constructor<StaticableNode> &
                                                                                            Constructor<FunctionLikeDeclaration> &
                                                                                            Constructor<BodyableNode> &
                                                                                            Constructor<PropertyNamedNode> &
                                                                                            typeof Node;

                                                                                              variable IdentifierBase

                                                                                              const IdentifierBase: Constructor<ReferenceFindableNode> &
                                                                                              Constructor<RenameableNode> &
                                                                                              typeof PrimaryExpression;

                                                                                                variable IfStatementBase

                                                                                                const IfStatementBase: Constructor<ChildOrderableNode> & typeof Statement;

                                                                                                  variable ImportClauseBase

                                                                                                  const ImportClauseBase: typeof Node;

                                                                                                    variable ImportDeclarationBase

                                                                                                    const ImportDeclarationBase: typeof Statement;

                                                                                                      variable ImportEqualsDeclarationBase

                                                                                                      const ImportEqualsDeclarationBase: Constructor<JSDocableNode> &
                                                                                                      Constructor<NamedNode> &
                                                                                                      typeof Statement;

                                                                                                        variable ImportExpressionBase

                                                                                                        const ImportExpressionBase: typeof PrimaryExpression;

                                                                                                          variable ImportSpecifierBase

                                                                                                          const ImportSpecifierBase: typeof Node;

                                                                                                            variable ImportTypeNodeBase

                                                                                                            const ImportTypeNodeBase: Constructor<TypeArgumentedNode> & typeof TypeNode;

                                                                                                              variable IndexSignatureDeclarationBase

                                                                                                              const IndexSignatureDeclarationBase: Constructor<ReturnTypedNode> &
                                                                                                              Constructor<ChildOrderableNode> &
                                                                                                              Constructor<JSDocableNode> &
                                                                                                              Constructor<ReadonlyableNode> &
                                                                                                              Constructor<ModifierableNode> &
                                                                                                              typeof TypeElement;

                                                                                                                variable InterfaceDeclarationBase

                                                                                                                const InterfaceDeclarationBase: Constructor<TypeElementMemberedNode> &
                                                                                                                Constructor<ChildOrderableNode> &
                                                                                                                Constructor<TextInsertableNode> &
                                                                                                                Constructor<ExtendsClauseableNode> &
                                                                                                                Constructor<HeritageClauseableNode> &
                                                                                                                Constructor<TypeParameteredNode> &
                                                                                                                Constructor<JSDocableNode> &
                                                                                                                Constructor<AmbientableNode> &
                                                                                                                Constructor<NamespaceChildableNode> &
                                                                                                                Constructor<ExportableNode> &
                                                                                                                Constructor<ModifierableNode> &
                                                                                                                Constructor<NamedNode> &
                                                                                                                typeof Statement;

                                                                                                                  variable IterationStatementBase

                                                                                                                  const IterationStatementBase: Constructor<ChildOrderableNode> & typeof Statement;

                                                                                                                    variable JSDocBase

                                                                                                                    const JSDocBase: typeof Node;

                                                                                                                      variable JSDocParameterTagBase

                                                                                                                      const JSDocParameterTagBase: Constructor<JSDocPropertyLikeTag> & typeof JSDocTag;

                                                                                                                        variable JSDocPropertyTagBase

                                                                                                                        const JSDocPropertyTagBase: Constructor<JSDocPropertyLikeTag> & typeof JSDocTag;

                                                                                                                          variable JsxAttributeBase

                                                                                                                          const JsxAttributeBase: Constructor<NamedNode> & typeof Node;

                                                                                                                            variable JsxClosingElementBase

                                                                                                                            const JsxClosingElementBase: Constructor<JsxTagNamedNode> & typeof Node;

                                                                                                                              variable JsxElementBase

                                                                                                                              const JsxElementBase: typeof PrimaryExpression;

                                                                                                                                variable JsxOpeningElementBase

                                                                                                                                const JsxOpeningElementBase: Constructor<JsxAttributedNode> &
                                                                                                                                Constructor<JsxTagNamedNode> &
                                                                                                                                typeof Expression;

                                                                                                                                  variable JsxSelfClosingElementBase

                                                                                                                                  const JsxSelfClosingElementBase: Constructor<JsxAttributedNode> &
                                                                                                                                  Constructor<JsxTagNamedNode> &
                                                                                                                                  typeof PrimaryExpression;

                                                                                                                                    variable JsxSpreadAttributeBase

                                                                                                                                    const JsxSpreadAttributeBase: typeof Node;

                                                                                                                                      variable LabeledStatementBase

                                                                                                                                      const LabeledStatementBase: Constructor<JSDocableNode> &
                                                                                                                                      Constructor<ChildOrderableNode> &
                                                                                                                                      typeof Statement;

                                                                                                                                        variable LiteralExpressionBase

                                                                                                                                        const LiteralExpressionBase: Constructor<LiteralLikeNode> & typeof PrimaryExpression;

                                                                                                                                          variable MetaPropertyBase

                                                                                                                                          const MetaPropertyBase: Constructor<NamedNode> & typeof PrimaryExpression;

                                                                                                                                            variable MethodDeclarationBase

                                                                                                                                            const MethodDeclarationBase: Constructor<ChildOrderableNode> &
                                                                                                                                            Constructor<TextInsertableNode> &
                                                                                                                                            Constructor<OverloadableNode> &
                                                                                                                                            Constructor<BodyableNode> &
                                                                                                                                            Constructor<DecoratableNode> &
                                                                                                                                            Constructor<AbstractableNode> &
                                                                                                                                            Constructor<ScopedNode> &
                                                                                                                                            Constructor<QuestionTokenableNode> &
                                                                                                                                            Constructor<StaticableNode> &
                                                                                                                                            Constructor<AsyncableNode> &
                                                                                                                                            Constructor<GeneratorableNode> &
                                                                                                                                            Constructor<FunctionLikeDeclaration> &
                                                                                                                                            Constructor<PropertyNamedNode> &
                                                                                                                                            typeof Node;

                                                                                                                                              variable MethodDeclarationOverloadBase

                                                                                                                                              const MethodDeclarationOverloadBase: Constructor<JSDocableNode> &
                                                                                                                                              Constructor<ChildOrderableNode> &
                                                                                                                                              Constructor<TextInsertableNode> &
                                                                                                                                              Constructor<ScopedNode> &
                                                                                                                                              Constructor<TypeParameteredNode> &
                                                                                                                                              Constructor<AbstractableNode> &
                                                                                                                                              Constructor<QuestionTokenableNode> &
                                                                                                                                              Constructor<StaticableNode> &
                                                                                                                                              Constructor<AsyncableNode> &
                                                                                                                                              Constructor<ModifierableNode> &
                                                                                                                                              Constructor<GeneratorableNode> &
                                                                                                                                              Constructor<SignaturedDeclaration> &
                                                                                                                                              typeof Node;

                                                                                                                                                variable MethodSignatureBase

                                                                                                                                                const MethodSignatureBase: Constructor<ChildOrderableNode> &
                                                                                                                                                Constructor<JSDocableNode> &
                                                                                                                                                Constructor<QuestionTokenableNode> &
                                                                                                                                                Constructor<TypeParameteredNode> &
                                                                                                                                                Constructor<SignaturedDeclaration> &
                                                                                                                                                Constructor<PropertyNamedNode> &
                                                                                                                                                typeof TypeElement;

                                                                                                                                                  variable ModuleBlockBase

                                                                                                                                                  const ModuleBlockBase: Constructor<StatementedNode> & typeof Statement;

                                                                                                                                                    variable NamedExportsBase

                                                                                                                                                    const NamedExportsBase: typeof Node;

                                                                                                                                                      variable NamedImportsBase

                                                                                                                                                      const NamedImportsBase: typeof Node;

                                                                                                                                                        variable NamespaceDeclarationBase

                                                                                                                                                        const NamespaceDeclarationBase: Constructor<ModuledNode> &
                                                                                                                                                        Constructor<ChildOrderableNode> &
                                                                                                                                                        Constructor<UnwrappableNode> &
                                                                                                                                                        Constructor<TextInsertableNode> &
                                                                                                                                                        Constructor<BodiedNode> &
                                                                                                                                                        Constructor<NamespaceChildableNode> &
                                                                                                                                                        Constructor<StatementedNode> &
                                                                                                                                                        Constructor<JSDocableNode> &
                                                                                                                                                        Constructor<AmbientableNode> &
                                                                                                                                                        Constructor<ExportableNode> &
                                                                                                                                                        Constructor<ModifierableNode> &
                                                                                                                                                        Constructor<NamedNode> &
                                                                                                                                                        typeof Statement;

                                                                                                                                                          variable NamespaceImportBase

                                                                                                                                                          const NamespaceImportBase: Constructor<RenameableNode> & typeof Node;

                                                                                                                                                            variable NewExpressionBase

                                                                                                                                                            const NewExpressionBase: Constructor<TypeArgumentedNode> &
                                                                                                                                                            Constructor<ArgumentedNode> &
                                                                                                                                                            Constructor<LeftHandSideExpressionedNode> &
                                                                                                                                                            typeof PrimaryExpression;

                                                                                                                                                              variable NonNullExpressionBase

                                                                                                                                                              const NonNullExpressionBase: Constructor<ExpressionedNode> &
                                                                                                                                                              typeof LeftHandSideExpression;

                                                                                                                                                                variable NoSubstitutionTemplateLiteralBase

                                                                                                                                                                const NoSubstitutionTemplateLiteralBase: typeof LiteralExpression;

                                                                                                                                                                  variable NotEmittedStatementBase

                                                                                                                                                                  const NotEmittedStatementBase: typeof Statement;

                                                                                                                                                                    variable NullLiteralBase

                                                                                                                                                                    const NullLiteralBase: typeof PrimaryExpression;

                                                                                                                                                                      variable NumericLiteralBase

                                                                                                                                                                      const NumericLiteralBase: typeof LiteralExpression;

                                                                                                                                                                        variable ObjectDestructuringAssignmentBase

                                                                                                                                                                        const ObjectDestructuringAssignmentBase: typeof AssignmentExpression;

                                                                                                                                                                          variable ObjectLiteralExpressionBase

                                                                                                                                                                          const ObjectLiteralExpressionBase: typeof PrimaryExpression;

                                                                                                                                                                            variable OmittedExpressionBase

                                                                                                                                                                            const OmittedExpressionBase: typeof Expression;

                                                                                                                                                                              variable ParameterDeclarationBase

                                                                                                                                                                              const ParameterDeclarationBase: Constructor<QuestionTokenableNode> &
                                                                                                                                                                              Constructor<DecoratableNode> &
                                                                                                                                                                              Constructor<ScopeableNode> &
                                                                                                                                                                              Constructor<ReadonlyableNode> &
                                                                                                                                                                              Constructor<ModifierableNode> &
                                                                                                                                                                              Constructor<TypedNode> &
                                                                                                                                                                              Constructor<InitializerExpressionableNode> &
                                                                                                                                                                              Constructor<DeclarationNamedNode> &
                                                                                                                                                                              typeof Node;

                                                                                                                                                                                variable ParenthesizedExpressionBase

                                                                                                                                                                                const ParenthesizedExpressionBase: Constructor<ExpressionedNode> & typeof Expression;

                                                                                                                                                                                  variable PartiallyEmittedExpressionBase

                                                                                                                                                                                  const PartiallyEmittedExpressionBase: Constructor<ExpressionedNode> &
                                                                                                                                                                                  typeof Expression;

                                                                                                                                                                                    variable PostfixUnaryExpressionBase

                                                                                                                                                                                    const PostfixUnaryExpressionBase: typeof UnaryExpression;

                                                                                                                                                                                      variable PrefixUnaryExpressionBase

                                                                                                                                                                                      const PrefixUnaryExpressionBase: typeof UnaryExpression;

                                                                                                                                                                                        variable PropertyAccessExpressionBase

                                                                                                                                                                                        const PropertyAccessExpressionBase: Constructor<NamedNode> &
                                                                                                                                                                                        Constructor<LeftHandSideExpressionedNode> &
                                                                                                                                                                                        typeof MemberExpression;

                                                                                                                                                                                          variable PropertyAssignmentBase

                                                                                                                                                                                          const PropertyAssignmentBase: Constructor<InitializerGetExpressionableNode> &
                                                                                                                                                                                          Constructor<QuestionTokenableNode> &
                                                                                                                                                                                          Constructor<PropertyNamedNode> &
                                                                                                                                                                                          typeof Node;

                                                                                                                                                                                            variable PropertyDeclarationBase

                                                                                                                                                                                            const PropertyDeclarationBase: Constructor<ChildOrderableNode> &
                                                                                                                                                                                            Constructor<DecoratableNode> &
                                                                                                                                                                                            Constructor<AbstractableNode> &
                                                                                                                                                                                            Constructor<ScopedNode> &
                                                                                                                                                                                            Constructor<StaticableNode> &
                                                                                                                                                                                            Constructor<JSDocableNode> &
                                                                                                                                                                                            Constructor<ReadonlyableNode> &
                                                                                                                                                                                            Constructor<ExclamationTokenableNode> &
                                                                                                                                                                                            Constructor<QuestionTokenableNode> &
                                                                                                                                                                                            Constructor<InitializerExpressionableNode> &
                                                                                                                                                                                            Constructor<TypedNode> &
                                                                                                                                                                                            Constructor<PropertyNamedNode> &
                                                                                                                                                                                            Constructor<ModifierableNode> &
                                                                                                                                                                                            typeof Node;

                                                                                                                                                                                              variable PropertySignatureBase

                                                                                                                                                                                              const PropertySignatureBase: Constructor<ChildOrderableNode> &
                                                                                                                                                                                              Constructor<JSDocableNode> &
                                                                                                                                                                                              Constructor<ReadonlyableNode> &
                                                                                                                                                                                              Constructor<QuestionTokenableNode> &
                                                                                                                                                                                              Constructor<InitializerExpressionableNode> &
                                                                                                                                                                                              Constructor<TypedNode> &
                                                                                                                                                                                              Constructor<PropertyNamedNode> &
                                                                                                                                                                                              Constructor<ModifierableNode> &
                                                                                                                                                                                              typeof TypeElement;

                                                                                                                                                                                                variable RegularExpressionLiteralBase

                                                                                                                                                                                                const RegularExpressionLiteralBase: typeof LiteralExpression;

                                                                                                                                                                                                  variable ReturnStatementBase

                                                                                                                                                                                                  const ReturnStatementBase: Constructor<ChildOrderableNode> & typeof Statement;

                                                                                                                                                                                                    variable SetAccessorDeclarationBase

                                                                                                                                                                                                    const SetAccessorDeclarationBase: Constructor<ChildOrderableNode> &
                                                                                                                                                                                                    Constructor<TextInsertableNode> &
                                                                                                                                                                                                    Constructor<DecoratableNode> &
                                                                                                                                                                                                    Constructor<AbstractableNode> &
                                                                                                                                                                                                    Constructor<ScopedNode> &
                                                                                                                                                                                                    Constructor<StaticableNode> &
                                                                                                                                                                                                    Constructor<FunctionLikeDeclaration> &
                                                                                                                                                                                                    Constructor<BodyableNode> &
                                                                                                                                                                                                    Constructor<PropertyNamedNode> &
                                                                                                                                                                                                    typeof Node;

                                                                                                                                                                                                      variable ShorthandPropertyAssignmentBase

                                                                                                                                                                                                      const ShorthandPropertyAssignmentBase: Constructor<InitializerGetExpressionableNode> &
                                                                                                                                                                                                      Constructor<QuestionTokenableNode> &
                                                                                                                                                                                                      Constructor<NamedNode> &
                                                                                                                                                                                                      typeof Node;

                                                                                                                                                                                                        variable SourceFileBase

                                                                                                                                                                                                        const SourceFileBase: Constructor<ModuledNode> &
                                                                                                                                                                                                        Constructor<StatementedNode> &
                                                                                                                                                                                                        Constructor<TextInsertableNode> &
                                                                                                                                                                                                        typeof Node;

                                                                                                                                                                                                          variable SpreadAssignmentBase

                                                                                                                                                                                                          const SpreadAssignmentBase: Constructor<ExpressionedNode> & typeof Node;

                                                                                                                                                                                                            variable SpreadElementBase

                                                                                                                                                                                                            const SpreadElementBase: Constructor<ExpressionedNode> & typeof Expression;

                                                                                                                                                                                                              variable StringLiteralBase

                                                                                                                                                                                                              const StringLiteralBase: typeof LiteralExpression;

                                                                                                                                                                                                                variable SuperElementAccessExpressionBase

                                                                                                                                                                                                                const SuperElementAccessExpressionBase: Constructor<SuperExpressionedNode> &
                                                                                                                                                                                                                typeof ElementAccessExpression;

                                                                                                                                                                                                                  variable SuperExpressionBase

                                                                                                                                                                                                                  const SuperExpressionBase: typeof PrimaryExpression;

                                                                                                                                                                                                                    variable SuperPropertyAccessExpressionBase

                                                                                                                                                                                                                    const SuperPropertyAccessExpressionBase: Constructor<SuperExpressionedNode> &
                                                                                                                                                                                                                    typeof PropertyAccessExpression;

                                                                                                                                                                                                                      variable SwitchStatementBase

                                                                                                                                                                                                                      const SwitchStatementBase: Constructor<ChildOrderableNode> & typeof Statement;

                                                                                                                                                                                                                        variable TemplateExpressionBase

                                                                                                                                                                                                                        const TemplateExpressionBase: typeof PrimaryExpression;

                                                                                                                                                                                                                          variable TemplateHeadBase

                                                                                                                                                                                                                          const TemplateHeadBase: Constructor<LiteralLikeNode> & typeof Node;

                                                                                                                                                                                                                            variable TemplateMiddleBase

                                                                                                                                                                                                                            const TemplateMiddleBase: Constructor<LiteralLikeNode> & typeof Node;

                                                                                                                                                                                                                              variable TemplateSpanBase

                                                                                                                                                                                                                              const TemplateSpanBase: Constructor<ExpressionedNode> & typeof Node;

                                                                                                                                                                                                                                variable TemplateTailBase

                                                                                                                                                                                                                                const TemplateTailBase: Constructor<LiteralLikeNode> & typeof Node;

                                                                                                                                                                                                                                  variable ThisExpressionBase

                                                                                                                                                                                                                                  const ThisExpressionBase: typeof PrimaryExpression;

                                                                                                                                                                                                                                    variable ThrowStatementBase

                                                                                                                                                                                                                                    const ThrowStatementBase: typeof Statement;

                                                                                                                                                                                                                                      variable TryStatementBase

                                                                                                                                                                                                                                      const TryStatementBase: typeof Statement;

                                                                                                                                                                                                                                        variable TypeAliasDeclarationBase

                                                                                                                                                                                                                                        const TypeAliasDeclarationBase: Constructor<ChildOrderableNode> &
                                                                                                                                                                                                                                        Constructor<TypeParameteredNode> &
                                                                                                                                                                                                                                        Constructor<TypedNode> &
                                                                                                                                                                                                                                        Constructor<JSDocableNode> &
                                                                                                                                                                                                                                        Constructor<AmbientableNode> &
                                                                                                                                                                                                                                        Constructor<ExportableNode> &
                                                                                                                                                                                                                                        Constructor<ModifierableNode> &
                                                                                                                                                                                                                                        Constructor<NamedNode> &
                                                                                                                                                                                                                                        typeof Statement;

                                                                                                                                                                                                                                          variable TypeAssertionBase

                                                                                                                                                                                                                                          const TypeAssertionBase: Constructor<TypedNode> &
                                                                                                                                                                                                                                          Constructor<UnaryExpressionedNode> &
                                                                                                                                                                                                                                          typeof UnaryExpression;

                                                                                                                                                                                                                                            variable TypeLiteralNodeBase

                                                                                                                                                                                                                                            const TypeLiteralNodeBase: Constructor<TypeElementMemberedNode> & typeof TypeNode;

                                                                                                                                                                                                                                              variable TypeOfExpressionBase

                                                                                                                                                                                                                                              const TypeOfExpressionBase: Constructor<UnaryExpressionedNode> &
                                                                                                                                                                                                                                              typeof UnaryExpression;

                                                                                                                                                                                                                                                variable TypeParameterDeclarationBase

                                                                                                                                                                                                                                                const TypeParameterDeclarationBase: Constructor<NamedNode> & typeof Node;

                                                                                                                                                                                                                                                  variable VariableDeclarationBase

                                                                                                                                                                                                                                                  const VariableDeclarationBase: Constructor<ExclamationTokenableNode> &
                                                                                                                                                                                                                                                  Constructor<TypedNode> &
                                                                                                                                                                                                                                                  Constructor<InitializerExpressionableNode> &
                                                                                                                                                                                                                                                  Constructor<BindingNamedNode> &
                                                                                                                                                                                                                                                  typeof Node;

                                                                                                                                                                                                                                                    variable VariableDeclarationListBase

                                                                                                                                                                                                                                                    const VariableDeclarationListBase: Constructor<ModifierableNode> & typeof Node;

                                                                                                                                                                                                                                                      variable VariableStatementBase

                                                                                                                                                                                                                                                      const VariableStatementBase: Constructor<ChildOrderableNode> &
                                                                                                                                                                                                                                                      Constructor<NamespaceChildableNode> &
                                                                                                                                                                                                                                                      Constructor<JSDocableNode> &
                                                                                                                                                                                                                                                      Constructor<AmbientableNode> &
                                                                                                                                                                                                                                                      Constructor<ExportableNode> &
                                                                                                                                                                                                                                                      Constructor<ModifierableNode> &
                                                                                                                                                                                                                                                      typeof Statement;

                                                                                                                                                                                                                                                        variable VoidExpressionBase

                                                                                                                                                                                                                                                        const VoidExpressionBase: Constructor<UnaryExpressionedNode> &
                                                                                                                                                                                                                                                        typeof UnaryExpression;

                                                                                                                                                                                                                                                          variable WhileStatementBase

                                                                                                                                                                                                                                                          const WhileStatementBase: typeof IterationStatement;

                                                                                                                                                                                                                                                            variable WithStatementBase

                                                                                                                                                                                                                                                            const WithStatementBase: Constructor<ChildOrderableNode> & typeof Statement;

                                                                                                                                                                                                                                                              variable YieldExpressionBase

                                                                                                                                                                                                                                                              const YieldExpressionBase: Constructor<GeneratorableNode> & typeof Expression;

                                                                                                                                                                                                                                                                Functions

                                                                                                                                                                                                                                                                function AbstractableNode

                                                                                                                                                                                                                                                                AbstractableNode: <T extends Constructor<AbstractableNodeExtensionType>>(
                                                                                                                                                                                                                                                                Base: T
                                                                                                                                                                                                                                                                ) => Constructor<AbstractableNode> & T;

                                                                                                                                                                                                                                                                  function AmbientableNode

                                                                                                                                                                                                                                                                  AmbientableNode: <T extends Constructor<AmbientableNodeExtensionType>>(
                                                                                                                                                                                                                                                                  Base: T
                                                                                                                                                                                                                                                                  ) => Constructor<AmbientableNode> & T;

                                                                                                                                                                                                                                                                    function ArgumentedNode

                                                                                                                                                                                                                                                                    ArgumentedNode: <T extends Constructor<ArgumentedNodeExtensionType>>(
                                                                                                                                                                                                                                                                    Base: T
                                                                                                                                                                                                                                                                    ) => Constructor<ArgumentedNode> & T;

                                                                                                                                                                                                                                                                      function AsyncableNode

                                                                                                                                                                                                                                                                      AsyncableNode: <T extends Constructor<AsyncableNodeExtensionType>>(
                                                                                                                                                                                                                                                                      Base: T
                                                                                                                                                                                                                                                                      ) => Constructor<AsyncableNode> & T;

                                                                                                                                                                                                                                                                        function AwaitableNode

                                                                                                                                                                                                                                                                        AwaitableNode: <T extends Constructor<AwaitableNodeExtensionType>>(
                                                                                                                                                                                                                                                                        Base: T
                                                                                                                                                                                                                                                                        ) => Constructor<AwaitableNode> & T;

                                                                                                                                                                                                                                                                          function BindingNamedNode

                                                                                                                                                                                                                                                                          BindingNamedNode: <T extends Constructor<BindingNamedNodeExtensionType>>(
                                                                                                                                                                                                                                                                          Base: T
                                                                                                                                                                                                                                                                          ) => Constructor<BindingNamedNode> & T;

                                                                                                                                                                                                                                                                            function BodiedNode

                                                                                                                                                                                                                                                                            BodiedNode: <T extends Constructor<BodiedNodeExtensionType>>(
                                                                                                                                                                                                                                                                            Base: T
                                                                                                                                                                                                                                                                            ) => Constructor<BodiedNode> & T;

                                                                                                                                                                                                                                                                              function BodyableNode

                                                                                                                                                                                                                                                                              BodyableNode: <T extends Constructor<BodyableNodeExtensionType>>(
                                                                                                                                                                                                                                                                              Base: T
                                                                                                                                                                                                                                                                              ) => Constructor<BodyableNode> & T;

                                                                                                                                                                                                                                                                                function ChildOrderableNode

                                                                                                                                                                                                                                                                                ChildOrderableNode: <T extends Constructor<ChildOrderableNodeExtensionType>>(
                                                                                                                                                                                                                                                                                Base: T
                                                                                                                                                                                                                                                                                ) => Constructor<ChildOrderableNode> & T;

                                                                                                                                                                                                                                                                                  function ClassLikeDeclarationBase

                                                                                                                                                                                                                                                                                  ClassLikeDeclarationBase: <
                                                                                                                                                                                                                                                                                  T extends Constructor<ClassLikeDeclarationBaseExtensionType>
                                                                                                                                                                                                                                                                                  >(
                                                                                                                                                                                                                                                                                  Base: T
                                                                                                                                                                                                                                                                                  ) => Constructor<ClassLikeDeclarationBase> & T;

                                                                                                                                                                                                                                                                                    function ClassLikeDeclarationBaseSpecific

                                                                                                                                                                                                                                                                                    ClassLikeDeclarationBaseSpecific: <
                                                                                                                                                                                                                                                                                    T extends Constructor<ClassLikeDeclarationBaseSpecificExtensionType>
                                                                                                                                                                                                                                                                                    >(
                                                                                                                                                                                                                                                                                    Base: T
                                                                                                                                                                                                                                                                                    ) => Constructor<ClassLikeDeclarationBaseSpecific> & T;

                                                                                                                                                                                                                                                                                      function createWrappedNode

                                                                                                                                                                                                                                                                                      createWrappedNode: <T extends ts.Node = ts.Node>(
                                                                                                                                                                                                                                                                                      node: T,
                                                                                                                                                                                                                                                                                      opts?: CreateWrappedNodeOptions
                                                                                                                                                                                                                                                                                      ) => CompilerNodeToWrappedType<T>;
                                                                                                                                                                                                                                                                                      • Creates a wrapped node from a compiler node.

                                                                                                                                                                                                                                                                                        Parameter node

                                                                                                                                                                                                                                                                                        Node to create a wrapped node from.

                                                                                                                                                                                                                                                                                        Parameter info

                                                                                                                                                                                                                                                                                        Info for creating the wrapped node.

                                                                                                                                                                                                                                                                                      function DeclarationNamedNode

                                                                                                                                                                                                                                                                                      DeclarationNamedNode: <T extends Constructor<DeclarationNamedNodeExtensionType>>(
                                                                                                                                                                                                                                                                                      Base: T
                                                                                                                                                                                                                                                                                      ) => Constructor<DeclarationNamedNode> & T;

                                                                                                                                                                                                                                                                                        function DecoratableNode

                                                                                                                                                                                                                                                                                        DecoratableNode: <T extends Constructor<DecoratableNodeExtensionType>>(
                                                                                                                                                                                                                                                                                        Base: T
                                                                                                                                                                                                                                                                                        ) => Constructor<DecoratableNode> & T;

                                                                                                                                                                                                                                                                                          function ExclamationTokenableNode

                                                                                                                                                                                                                                                                                          ExclamationTokenableNode: <
                                                                                                                                                                                                                                                                                          T extends Constructor<ExclamationTokenableNodeExtensionType>
                                                                                                                                                                                                                                                                                          >(
                                                                                                                                                                                                                                                                                          Base: T
                                                                                                                                                                                                                                                                                          ) => Constructor<ExclamationTokenableNode> & T;

                                                                                                                                                                                                                                                                                            function ExportableNode

                                                                                                                                                                                                                                                                                            ExportableNode: <T extends Constructor<ExportableNodeExtensionType>>(
                                                                                                                                                                                                                                                                                            Base: T
                                                                                                                                                                                                                                                                                            ) => Constructor<ExportableNode> & T;

                                                                                                                                                                                                                                                                                              function ExpressionedNode

                                                                                                                                                                                                                                                                                              ExpressionedNode: <T extends Constructor<ExpressionedNodeExtensionType>>(
                                                                                                                                                                                                                                                                                              Base: T
                                                                                                                                                                                                                                                                                              ) => Constructor<ExpressionedNode> & T;

                                                                                                                                                                                                                                                                                                function ExtendsClauseableNode

                                                                                                                                                                                                                                                                                                ExtendsClauseableNode: <
                                                                                                                                                                                                                                                                                                T extends Constructor<ExtendsClauseableNodeExtensionType>
                                                                                                                                                                                                                                                                                                >(
                                                                                                                                                                                                                                                                                                Base: T
                                                                                                                                                                                                                                                                                                ) => Constructor<ExtendsClauseableNode> & T;

                                                                                                                                                                                                                                                                                                  function FunctionLikeDeclaration

                                                                                                                                                                                                                                                                                                  FunctionLikeDeclaration: <
                                                                                                                                                                                                                                                                                                  T extends Constructor<FunctionLikeDeclarationExtensionType>
                                                                                                                                                                                                                                                                                                  >(
                                                                                                                                                                                                                                                                                                  Base: T
                                                                                                                                                                                                                                                                                                  ) => Constructor<FunctionLikeDeclaration> & T;

                                                                                                                                                                                                                                                                                                    function GeneratorableNode

                                                                                                                                                                                                                                                                                                    GeneratorableNode: <T extends Constructor<GeneratorableNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                    Base: T
                                                                                                                                                                                                                                                                                                    ) => Constructor<GeneratorableNode> & T;

                                                                                                                                                                                                                                                                                                      function getCompilerOptionsFromTsConfig

                                                                                                                                                                                                                                                                                                      getCompilerOptionsFromTsConfig: (
                                                                                                                                                                                                                                                                                                      filePath: string,
                                                                                                                                                                                                                                                                                                      options?: CompilerOptionsFromTsConfigOptions
                                                                                                                                                                                                                                                                                                      ) => CompilerOptionsFromTsConfigResult;
                                                                                                                                                                                                                                                                                                      • Gets the compiler options from a specified tsconfig.json

                                                                                                                                                                                                                                                                                                        Parameter filePath

                                                                                                                                                                                                                                                                                                        File path to the tsconfig.json.

                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                        Options.

                                                                                                                                                                                                                                                                                                      function HeritageClauseableNode

                                                                                                                                                                                                                                                                                                      HeritageClauseableNode: <
                                                                                                                                                                                                                                                                                                      T extends Constructor<HeritageClauseableNodeExtensionType>
                                                                                                                                                                                                                                                                                                      >(
                                                                                                                                                                                                                                                                                                      Base: T
                                                                                                                                                                                                                                                                                                      ) => Constructor<HeritageClauseableNode> & T;

                                                                                                                                                                                                                                                                                                        function ImplementsClauseableNode

                                                                                                                                                                                                                                                                                                        ImplementsClauseableNode: <
                                                                                                                                                                                                                                                                                                        T extends Constructor<ImplementsClauseableNodeExtensionType>
                                                                                                                                                                                                                                                                                                        >(
                                                                                                                                                                                                                                                                                                        Base: T
                                                                                                                                                                                                                                                                                                        ) => Constructor<ImplementsClauseableNode> & T;

                                                                                                                                                                                                                                                                                                          function ImportExpressionedNode

                                                                                                                                                                                                                                                                                                          ImportExpressionedNode: <
                                                                                                                                                                                                                                                                                                          T extends Constructor<ImportExpressionedNodeExtensionType>
                                                                                                                                                                                                                                                                                                          >(
                                                                                                                                                                                                                                                                                                          Base: T
                                                                                                                                                                                                                                                                                                          ) => Constructor<ImportExpressionedNode> & T;

                                                                                                                                                                                                                                                                                                            function InitializerExpressionableNode

                                                                                                                                                                                                                                                                                                            InitializerExpressionableNode: <
                                                                                                                                                                                                                                                                                                            T extends Constructor<InitializerExpressionableNodeExtensionType>
                                                                                                                                                                                                                                                                                                            >(
                                                                                                                                                                                                                                                                                                            Base: T
                                                                                                                                                                                                                                                                                                            ) => Constructor<InitializerExpressionableNode> & T;

                                                                                                                                                                                                                                                                                                              function InitializerGetExpressionableNode

                                                                                                                                                                                                                                                                                                              InitializerGetExpressionableNode: <
                                                                                                                                                                                                                                                                                                              T extends Constructor<InitializerGetExpressionableNodeExtensionType>
                                                                                                                                                                                                                                                                                                              >(
                                                                                                                                                                                                                                                                                                              Base: T
                                                                                                                                                                                                                                                                                                              ) => Constructor<InitializerGetExpressionableNode> & T;

                                                                                                                                                                                                                                                                                                                function InitializerSetExpressionableNode

                                                                                                                                                                                                                                                                                                                InitializerSetExpressionableNode: <
                                                                                                                                                                                                                                                                                                                T extends Constructor<InitializerSetExpressionableNodeExtensionType>
                                                                                                                                                                                                                                                                                                                >(
                                                                                                                                                                                                                                                                                                                Base: T
                                                                                                                                                                                                                                                                                                                ) => Constructor<InitializerSetExpressionableNode> & T;

                                                                                                                                                                                                                                                                                                                  function JSDocableNode

                                                                                                                                                                                                                                                                                                                  JSDocableNode: <T extends Constructor<JSDocableNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                  Base: T
                                                                                                                                                                                                                                                                                                                  ) => Constructor<JSDocableNode> & T;

                                                                                                                                                                                                                                                                                                                    function JSDocPropertyLikeTag

                                                                                                                                                                                                                                                                                                                    JSDocPropertyLikeTag: <T extends Constructor<JSDocPropertyLikeTagExtensionType>>(
                                                                                                                                                                                                                                                                                                                    Base: T
                                                                                                                                                                                                                                                                                                                    ) => Constructor<JSDocPropertyLikeTag> & T;

                                                                                                                                                                                                                                                                                                                      function JsxAttributedNode

                                                                                                                                                                                                                                                                                                                      JsxAttributedNode: <T extends Constructor<JsxAttributedNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                      Base: T
                                                                                                                                                                                                                                                                                                                      ) => Constructor<JsxAttributedNode> & T;

                                                                                                                                                                                                                                                                                                                        function JsxTagNamedNode

                                                                                                                                                                                                                                                                                                                        JsxTagNamedNode: <T extends Constructor<JsxTagNamedNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                        Base: T
                                                                                                                                                                                                                                                                                                                        ) => Constructor<JsxTagNamedNode> & T;

                                                                                                                                                                                                                                                                                                                          function LeftHandSideExpressionedNode

                                                                                                                                                                                                                                                                                                                          LeftHandSideExpressionedNode: <
                                                                                                                                                                                                                                                                                                                          T extends Constructor<LeftHandSideExpressionedNodeExtensionType>
                                                                                                                                                                                                                                                                                                                          >(
                                                                                                                                                                                                                                                                                                                          Base: T
                                                                                                                                                                                                                                                                                                                          ) => Constructor<LeftHandSideExpressionedNode> & T;

                                                                                                                                                                                                                                                                                                                            function LiteralLikeNode

                                                                                                                                                                                                                                                                                                                            LiteralLikeNode: <T extends Constructor<LiteralLikeNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                            Base: T
                                                                                                                                                                                                                                                                                                                            ) => Constructor<LiteralLikeNode> & T;

                                                                                                                                                                                                                                                                                                                              function ModifierableNode

                                                                                                                                                                                                                                                                                                                              ModifierableNode: <T extends Constructor<ModifierableNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                              Base: T
                                                                                                                                                                                                                                                                                                                              ) => Constructor<ModifierableNode> & T;

                                                                                                                                                                                                                                                                                                                                function ModuledNode

                                                                                                                                                                                                                                                                                                                                ModuledNode: <T extends Constructor<ModuledNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                Base: T
                                                                                                                                                                                                                                                                                                                                ) => Constructor<ModuledNode> & T;

                                                                                                                                                                                                                                                                                                                                  function NameableNode

                                                                                                                                                                                                                                                                                                                                  NameableNode: <T extends Constructor<NameableNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                  Base: T
                                                                                                                                                                                                                                                                                                                                  ) => Constructor<NameableNode> & T;

                                                                                                                                                                                                                                                                                                                                    function NamedNode

                                                                                                                                                                                                                                                                                                                                    NamedNode: <T extends Constructor<NamedNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                    Base: T
                                                                                                                                                                                                                                                                                                                                    ) => Constructor<NamedNode> & T;

                                                                                                                                                                                                                                                                                                                                      function NamedNodeBase

                                                                                                                                                                                                                                                                                                                                      NamedNodeBase: <
                                                                                                                                                                                                                                                                                                                                      TCompilerNode extends ts.Node,
                                                                                                                                                                                                                                                                                                                                      U extends Constructor<NamedNodeBaseExtensionType<TCompilerNode>>
                                                                                                                                                                                                                                                                                                                                      >(
                                                                                                                                                                                                                                                                                                                                      Base: U
                                                                                                                                                                                                                                                                                                                                      ) => Constructor<NamedNodeSpecificBase<CompilerNodeToWrappedType<TCompilerNode>>> &
                                                                                                                                                                                                                                                                                                                                      U;

                                                                                                                                                                                                                                                                                                                                        function NamespaceChildableNode

                                                                                                                                                                                                                                                                                                                                        NamespaceChildableNode: <
                                                                                                                                                                                                                                                                                                                                        T extends Constructor<NamespaceChildableNodeExtensionType>
                                                                                                                                                                                                                                                                                                                                        >(
                                                                                                                                                                                                                                                                                                                                        Base: T
                                                                                                                                                                                                                                                                                                                                        ) => Constructor<NamespaceChildableNode> & T;

                                                                                                                                                                                                                                                                                                                                          function OverloadableNode

                                                                                                                                                                                                                                                                                                                                          OverloadableNode: <T extends Constructor<OverloadableNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                          Base: T
                                                                                                                                                                                                                                                                                                                                          ) => Constructor<OverloadableNode> & T;

                                                                                                                                                                                                                                                                                                                                            function ParameteredNode

                                                                                                                                                                                                                                                                                                                                            ParameteredNode: <T extends Constructor<ParameteredNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                            Base: T
                                                                                                                                                                                                                                                                                                                                            ) => Constructor<ParameteredNode> & T;

                                                                                                                                                                                                                                                                                                                                              function printNode

                                                                                                                                                                                                                                                                                                                                              printNode: {
                                                                                                                                                                                                                                                                                                                                              (node: ts.Node, options?: PrintNodeOptions): string;
                                                                                                                                                                                                                                                                                                                                              (node: ts.Node, sourceFile: ts.SourceFile, options?: PrintNodeOptions): string;
                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                              • Prints the provided node using the compiler's printer.

                                                                                                                                                                                                                                                                                                                                                Parameter node

                                                                                                                                                                                                                                                                                                                                                Compiler node.

                                                                                                                                                                                                                                                                                                                                                Parameter options

                                                                                                                                                                                                                                                                                                                                                Options.

                                                                                                                                                                                                                                                                                                                                                Remarks

                                                                                                                                                                                                                                                                                                                                                If the node was not constructed with the compiler API factory methods and the node does not have parents set, then use the other overload that accepts a source file.

                                                                                                                                                                                                                                                                                                                                              • Prints the provided node using the compiler's printer.

                                                                                                                                                                                                                                                                                                                                                Parameter node

                                                                                                                                                                                                                                                                                                                                                Compiler node.

                                                                                                                                                                                                                                                                                                                                                Parameter sourceFile

                                                                                                                                                                                                                                                                                                                                                Compiler source file.

                                                                                                                                                                                                                                                                                                                                                Parameter options

                                                                                                                                                                                                                                                                                                                                                Options.

                                                                                                                                                                                                                                                                                                                                              function PropertyNamedNode

                                                                                                                                                                                                                                                                                                                                              PropertyNamedNode: <T extends Constructor<PropertyNamedNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                              Base: T
                                                                                                                                                                                                                                                                                                                                              ) => Constructor<PropertyNamedNode> & T;

                                                                                                                                                                                                                                                                                                                                                function QuestionTokenableNode

                                                                                                                                                                                                                                                                                                                                                QuestionTokenableNode: <
                                                                                                                                                                                                                                                                                                                                                T extends Constructor<QuestionTokenableNodeExtensionType>
                                                                                                                                                                                                                                                                                                                                                >(
                                                                                                                                                                                                                                                                                                                                                Base: T
                                                                                                                                                                                                                                                                                                                                                ) => Constructor<QuestionTokenableNode> & T;

                                                                                                                                                                                                                                                                                                                                                  function ReadonlyableNode

                                                                                                                                                                                                                                                                                                                                                  ReadonlyableNode: <T extends Constructor<ReadonlyableNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                                  Base: T
                                                                                                                                                                                                                                                                                                                                                  ) => Constructor<ReadonlyableNode> & T;

                                                                                                                                                                                                                                                                                                                                                    function ReferenceFindableNode

                                                                                                                                                                                                                                                                                                                                                    ReferenceFindableNode: <
                                                                                                                                                                                                                                                                                                                                                    T extends Constructor<ReferenceFindableNodeExtensionType>
                                                                                                                                                                                                                                                                                                                                                    >(
                                                                                                                                                                                                                                                                                                                                                    Base: T
                                                                                                                                                                                                                                                                                                                                                    ) => Constructor<ReferenceFindableNode> & T;

                                                                                                                                                                                                                                                                                                                                                      function RenameableNode

                                                                                                                                                                                                                                                                                                                                                      RenameableNode: <T extends Constructor<RenameableNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                                      Base: T
                                                                                                                                                                                                                                                                                                                                                      ) => Constructor<RenameableNode> & T;

                                                                                                                                                                                                                                                                                                                                                        function ReturnTypedNode

                                                                                                                                                                                                                                                                                                                                                        ReturnTypedNode: <T extends Constructor<ReturnTypedNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                                        Base: T
                                                                                                                                                                                                                                                                                                                                                        ) => Constructor<ReturnTypedNode> & T;

                                                                                                                                                                                                                                                                                                                                                          function ScopeableNode

                                                                                                                                                                                                                                                                                                                                                          ScopeableNode: <T extends Constructor<ScopeableNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                                          Base: T
                                                                                                                                                                                                                                                                                                                                                          ) => Constructor<ScopeableNode> & T;

                                                                                                                                                                                                                                                                                                                                                            function ScopedNode

                                                                                                                                                                                                                                                                                                                                                            ScopedNode: <T extends Constructor<ScopedNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                                            Base: T
                                                                                                                                                                                                                                                                                                                                                            ) => Constructor<ScopedNode> & T;

                                                                                                                                                                                                                                                                                                                                                              function SignaturedDeclaration

                                                                                                                                                                                                                                                                                                                                                              SignaturedDeclaration: <
                                                                                                                                                                                                                                                                                                                                                              T extends Constructor<SignaturedDeclarationExtensionType>
                                                                                                                                                                                                                                                                                                                                                              >(
                                                                                                                                                                                                                                                                                                                                                              Base: T
                                                                                                                                                                                                                                                                                                                                                              ) => Constructor<SignaturedDeclaration> & T;

                                                                                                                                                                                                                                                                                                                                                                function StatementedNode

                                                                                                                                                                                                                                                                                                                                                                StatementedNode: <T extends Constructor<StatementedNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                                                Base: T
                                                                                                                                                                                                                                                                                                                                                                ) => Constructor<StatementedNode> & T;

                                                                                                                                                                                                                                                                                                                                                                  function StaticableNode

                                                                                                                                                                                                                                                                                                                                                                  StaticableNode: <T extends Constructor<StaticableNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                                                  Base: T
                                                                                                                                                                                                                                                                                                                                                                  ) => Constructor<StaticableNode> & T;

                                                                                                                                                                                                                                                                                                                                                                    function SuperExpressionedNode

                                                                                                                                                                                                                                                                                                                                                                    SuperExpressionedNode: <
                                                                                                                                                                                                                                                                                                                                                                    T extends Constructor<SuperExpressionedNodeExtensionType>
                                                                                                                                                                                                                                                                                                                                                                    >(
                                                                                                                                                                                                                                                                                                                                                                    Base: T
                                                                                                                                                                                                                                                                                                                                                                    ) => Constructor<SuperExpressionedNode> & T;

                                                                                                                                                                                                                                                                                                                                                                      function TextInsertableNode

                                                                                                                                                                                                                                                                                                                                                                      TextInsertableNode: <T extends Constructor<TextInsertableNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                                                      Base: T
                                                                                                                                                                                                                                                                                                                                                                      ) => Constructor<TextInsertableNode> & T;

                                                                                                                                                                                                                                                                                                                                                                        function TypeArgumentedNode

                                                                                                                                                                                                                                                                                                                                                                        TypeArgumentedNode: <T extends Constructor<TypeArgumentedNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                                                        Base: T
                                                                                                                                                                                                                                                                                                                                                                        ) => Constructor<TypeArgumentedNode> & T;

                                                                                                                                                                                                                                                                                                                                                                          function TypedNode

                                                                                                                                                                                                                                                                                                                                                                          TypedNode: <T extends Constructor<TypedNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                                                          Base: T
                                                                                                                                                                                                                                                                                                                                                                          ) => Constructor<TypedNode> & T;

                                                                                                                                                                                                                                                                                                                                                                            function TypeElementMemberedNode

                                                                                                                                                                                                                                                                                                                                                                            TypeElementMemberedNode: <
                                                                                                                                                                                                                                                                                                                                                                            T extends Constructor<TypeElementMemberedNodeExtensionType>
                                                                                                                                                                                                                                                                                                                                                                            >(
                                                                                                                                                                                                                                                                                                                                                                            Base: T
                                                                                                                                                                                                                                                                                                                                                                            ) => Constructor<TypeElementMemberedNode> & T;

                                                                                                                                                                                                                                                                                                                                                                              function TypeParameteredNode

                                                                                                                                                                                                                                                                                                                                                                              TypeParameteredNode: <T extends Constructor<TypeParameteredNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                                                              Base: T
                                                                                                                                                                                                                                                                                                                                                                              ) => Constructor<TypeParameteredNode> & T;

                                                                                                                                                                                                                                                                                                                                                                                function UnaryExpressionedNode

                                                                                                                                                                                                                                                                                                                                                                                UnaryExpressionedNode: <
                                                                                                                                                                                                                                                                                                                                                                                T extends Constructor<UnaryExpressionedNodeExtensionType>
                                                                                                                                                                                                                                                                                                                                                                                >(
                                                                                                                                                                                                                                                                                                                                                                                Base: T
                                                                                                                                                                                                                                                                                                                                                                                ) => Constructor<UnaryExpressionedNode> & T;

                                                                                                                                                                                                                                                                                                                                                                                  function UnwrappableNode

                                                                                                                                                                                                                                                                                                                                                                                  UnwrappableNode: <T extends Constructor<UnwrappableNodeExtensionType>>(
                                                                                                                                                                                                                                                                                                                                                                                  Base: T
                                                                                                                                                                                                                                                                                                                                                                                  ) => Constructor<UnwrappableNode> & T;

                                                                                                                                                                                                                                                                                                                                                                                    Classes

                                                                                                                                                                                                                                                                                                                                                                                    class ArgumentError

                                                                                                                                                                                                                                                                                                                                                                                    class ArgumentError extends BaseError {}

                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                      protected constructor();

                                                                                                                                                                                                                                                                                                                                                                                        class ArgumentNullOrWhitespaceError

                                                                                                                                                                                                                                                                                                                                                                                        class ArgumentNullOrWhitespaceError extends ArgumentError {}

                                                                                                                                                                                                                                                                                                                                                                                          class ArgumentOutOfRangeError

                                                                                                                                                                                                                                                                                                                                                                                          class ArgumentOutOfRangeError extends ArgumentError {}

                                                                                                                                                                                                                                                                                                                                                                                            class ArgumentTypeError

                                                                                                                                                                                                                                                                                                                                                                                            class ArgumentTypeError extends ArgumentError {}

                                                                                                                                                                                                                                                                                                                                                                                              class ArrayBindingPattern

                                                                                                                                                                                                                                                                                                                                                                                              class ArrayBindingPattern extends Node<ts.ArrayBindingPattern> {}

                                                                                                                                                                                                                                                                                                                                                                                                method getElements

                                                                                                                                                                                                                                                                                                                                                                                                getElements: () => (BindingElement | OmittedExpression)[];
                                                                                                                                                                                                                                                                                                                                                                                                • Gets the array binding pattern's elements.

                                                                                                                                                                                                                                                                                                                                                                                                class ArrayDestructuringAssignment

                                                                                                                                                                                                                                                                                                                                                                                                class ArrayDestructuringAssignment extends ArrayDestructuringAssignmentBase<ts.ArrayDestructuringAssignment> {}

                                                                                                                                                                                                                                                                                                                                                                                                  method getLeft

                                                                                                                                                                                                                                                                                                                                                                                                  getLeft: () => ArrayLiteralExpression;
                                                                                                                                                                                                                                                                                                                                                                                                  • Gets the left array literal expression of the array destructuring assignment.

                                                                                                                                                                                                                                                                                                                                                                                                  class ArrayLiteralExpression

                                                                                                                                                                                                                                                                                                                                                                                                  class ArrayLiteralExpression extends PrimaryExpression<ts.ArrayLiteralExpression> {}

                                                                                                                                                                                                                                                                                                                                                                                                    method addElement

                                                                                                                                                                                                                                                                                                                                                                                                    addElement: (
                                                                                                                                                                                                                                                                                                                                                                                                    textOrWriterFunction: string | WriterFunction,
                                                                                                                                                                                                                                                                                                                                                                                                    options?: { useNewLines?: boolean }
                                                                                                                                                                                                                                                                                                                                                                                                    ) => Expression<ts.Expression>;
                                                                                                                                                                                                                                                                                                                                                                                                    • Adds an element to the array.

                                                                                                                                                                                                                                                                                                                                                                                                      Parameter textOrWriterFunction

                                                                                                                                                                                                                                                                                                                                                                                                      Text to add as an element.

                                                                                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                      Options.

                                                                                                                                                                                                                                                                                                                                                                                                    method addElements

                                                                                                                                                                                                                                                                                                                                                                                                    addElements: (
                                                                                                                                                                                                                                                                                                                                                                                                    textsOrWriterFunction:
                                                                                                                                                                                                                                                                                                                                                                                                    | ReadonlyArray<string | WriterFunction>
                                                                                                                                                                                                                                                                                                                                                                                                    | WriterFunction,
                                                                                                                                                                                                                                                                                                                                                                                                    options?: { useNewLines?: boolean }
                                                                                                                                                                                                                                                                                                                                                                                                    ) => Expression<ts.Expression>[];
                                                                                                                                                                                                                                                                                                                                                                                                    • Adds elements to the array.

                                                                                                                                                                                                                                                                                                                                                                                                      Parameter textsOrWriterFunction

                                                                                                                                                                                                                                                                                                                                                                                                      Texts to add as elements.

                                                                                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                      Options.

                                                                                                                                                                                                                                                                                                                                                                                                    method getElements

                                                                                                                                                                                                                                                                                                                                                                                                    getElements: () => Expression[];
                                                                                                                                                                                                                                                                                                                                                                                                    • Gets the array's elements.

                                                                                                                                                                                                                                                                                                                                                                                                    method insertElement

                                                                                                                                                                                                                                                                                                                                                                                                    insertElement: (
                                                                                                                                                                                                                                                                                                                                                                                                    index: number,
                                                                                                                                                                                                                                                                                                                                                                                                    textOrWriterFunction: string | WriterFunction,
                                                                                                                                                                                                                                                                                                                                                                                                    options?: { useNewLines?: boolean }
                                                                                                                                                                                                                                                                                                                                                                                                    ) => Expression<ts.Expression>;
                                                                                                                                                                                                                                                                                                                                                                                                    • Insert an element into the array.

                                                                                                                                                                                                                                                                                                                                                                                                      Parameter index

                                                                                                                                                                                                                                                                                                                                                                                                      Child index to insert at.

                                                                                                                                                                                                                                                                                                                                                                                                      Parameter text

                                                                                                                                                                                                                                                                                                                                                                                                      Text to insert as an element.

                                                                                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                      Options.

                                                                                                                                                                                                                                                                                                                                                                                                    method insertElements

                                                                                                                                                                                                                                                                                                                                                                                                    insertElements: (
                                                                                                                                                                                                                                                                                                                                                                                                    index: number,
                                                                                                                                                                                                                                                                                                                                                                                                    textsOrWriterFunction:
                                                                                                                                                                                                                                                                                                                                                                                                    | ReadonlyArray<string | WriterFunction>
                                                                                                                                                                                                                                                                                                                                                                                                    | WriterFunction,
                                                                                                                                                                                                                                                                                                                                                                                                    options?: { useNewLines?: boolean }
                                                                                                                                                                                                                                                                                                                                                                                                    ) => Expression<ts.Expression>[];
                                                                                                                                                                                                                                                                                                                                                                                                    • Insert elements into the array.

                                                                                                                                                                                                                                                                                                                                                                                                      Parameter index

                                                                                                                                                                                                                                                                                                                                                                                                      Child index to insert at.

                                                                                                                                                                                                                                                                                                                                                                                                      Parameter textsOrWriterFunction

                                                                                                                                                                                                                                                                                                                                                                                                      Texts to insert as elements.

                                                                                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                      Options.

                                                                                                                                                                                                                                                                                                                                                                                                    method removeElement

                                                                                                                                                                                                                                                                                                                                                                                                    removeElement: {
                                                                                                                                                                                                                                                                                                                                                                                                    (index: number): void;
                                                                                                                                                                                                                                                                                                                                                                                                    (element: Expression<ts.Expression>): void;
                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                    • Removes an element from the array.

                                                                                                                                                                                                                                                                                                                                                                                                      Parameter index

                                                                                                                                                                                                                                                                                                                                                                                                      Index to remove from.

                                                                                                                                                                                                                                                                                                                                                                                                    • Removes an element from the array.

                                                                                                                                                                                                                                                                                                                                                                                                      Parameter element

                                                                                                                                                                                                                                                                                                                                                                                                      Element to remove.

                                                                                                                                                                                                                                                                                                                                                                                                    class ArrayTypeNode

                                                                                                                                                                                                                                                                                                                                                                                                    class ArrayTypeNode extends TypeNode<ts.ArrayTypeNode> {}

                                                                                                                                                                                                                                                                                                                                                                                                      method getElementTypeNode

                                                                                                                                                                                                                                                                                                                                                                                                      getElementTypeNode: () => TypeNode;
                                                                                                                                                                                                                                                                                                                                                                                                      • Gets the array type node's element type node.

                                                                                                                                                                                                                                                                                                                                                                                                      class ArrowFunction

                                                                                                                                                                                                                                                                                                                                                                                                      class ArrowFunction extends ArrowFunctionBase<ts.ArrowFunction> {}

                                                                                                                                                                                                                                                                                                                                                                                                        method getEqualsGreaterThan

                                                                                                                                                                                                                                                                                                                                                                                                        getEqualsGreaterThan: () => Node<ts.Token<SyntaxKind.EqualsGreaterThanToken>>;
                                                                                                                                                                                                                                                                                                                                                                                                        • Gets the equals greater than token of the arrow function.

                                                                                                                                                                                                                                                                                                                                                                                                        class AsExpression

                                                                                                                                                                                                                                                                                                                                                                                                        class AsExpression extends AsExpressionBase<ts.AsExpression> {}

                                                                                                                                                                                                                                                                                                                                                                                                          class AssignmentExpression

                                                                                                                                                                                                                                                                                                                                                                                                          class AssignmentExpression<
                                                                                                                                                                                                                                                                                                                                                                                                          T extends ts.AssignmentExpression<ts.AssignmentOperatorToken> = ts.AssignmentExpression<ts.AssignmentOperatorToken>
                                                                                                                                                                                                                                                                                                                                                                                                          > extends AssignmentExpressionBase<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                            method getOperatorToken

                                                                                                                                                                                                                                                                                                                                                                                                            getOperatorToken: () => Node<ts.Token<ts.AssignmentOperator>>;
                                                                                                                                                                                                                                                                                                                                                                                                            • Gets the operator token of the assignment expression.

                                                                                                                                                                                                                                                                                                                                                                                                            class AwaitExpression

                                                                                                                                                                                                                                                                                                                                                                                                            class AwaitExpression extends AwaitExpressionBase<ts.AwaitExpression> {}

                                                                                                                                                                                                                                                                                                                                                                                                              class BaseError

                                                                                                                                                                                                                                                                                                                                                                                                              abstract class BaseError extends Error {}

                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                protected constructor();

                                                                                                                                                                                                                                                                                                                                                                                                                  property message

                                                                                                                                                                                                                                                                                                                                                                                                                  readonly message: string;

                                                                                                                                                                                                                                                                                                                                                                                                                    class BinaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                    class BinaryExpression<
                                                                                                                                                                                                                                                                                                                                                                                                                    T extends ts.BinaryExpression = ts.BinaryExpression
                                                                                                                                                                                                                                                                                                                                                                                                                    > extends BinaryExpressionBase<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                      method getLeft

                                                                                                                                                                                                                                                                                                                                                                                                                      getLeft: () => Expression;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Gets the left side of the binary expression.

                                                                                                                                                                                                                                                                                                                                                                                                                      method getOperatorToken

                                                                                                                                                                                                                                                                                                                                                                                                                      getOperatorToken: () => Node<ts.Token<ts.BinaryOperator>>;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Gets the operator token of the binary expression.

                                                                                                                                                                                                                                                                                                                                                                                                                      method getRight

                                                                                                                                                                                                                                                                                                                                                                                                                      getRight: () => Expression;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Gets the right side of the binary expression.

                                                                                                                                                                                                                                                                                                                                                                                                                      class BindingElement

                                                                                                                                                                                                                                                                                                                                                                                                                      class BindingElement extends BindingElementBase<ts.BindingElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                        method getDotDotDotToken

                                                                                                                                                                                                                                                                                                                                                                                                                        getDotDotDotToken: () => Node<ts.Token<SyntaxKind.DotDotDotToken>> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                        • Gets the binding element's dot dot dot token (...) if it exists or returns undefined.

                                                                                                                                                                                                                                                                                                                                                                                                                        method getDotDotDotTokenOrThrow

                                                                                                                                                                                                                                                                                                                                                                                                                        getDotDotDotTokenOrThrow: () => Node<ts.Token<SyntaxKind.DotDotDotToken>>;
                                                                                                                                                                                                                                                                                                                                                                                                                        • Gets the binding element's dot dot dot token (...) if it exists or throws if not.

                                                                                                                                                                                                                                                                                                                                                                                                                        method getPropertyNameNode

                                                                                                                                                                                                                                                                                                                                                                                                                        getPropertyNameNode: () =>
                                                                                                                                                                                                                                                                                                                                                                                                                        | Identifier
                                                                                                                                                                                                                                                                                                                                                                                                                        | NumericLiteral
                                                                                                                                                                                                                                                                                                                                                                                                                        | StringLiteral
                                                                                                                                                                                                                                                                                                                                                                                                                        | ComputedPropertyName
                                                                                                                                                                                                                                                                                                                                                                                                                        | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                        • Gets binding element's property name node or returns undefined if not found.

                                                                                                                                                                                                                                                                                                                                                                                                                          For example in const { a: b } = { a: 5 }, a would be the property name.

                                                                                                                                                                                                                                                                                                                                                                                                                        method getPropertyNameNodeOrThrow

                                                                                                                                                                                                                                                                                                                                                                                                                        getPropertyNameNodeOrThrow: () => PropertyName;
                                                                                                                                                                                                                                                                                                                                                                                                                        • Gets binding element's property name node or throws if not found.

                                                                                                                                                                                                                                                                                                                                                                                                                          For example in const { a: b } = { a: 5 }, a would be the property name.

                                                                                                                                                                                                                                                                                                                                                                                                                        class Block

                                                                                                                                                                                                                                                                                                                                                                                                                        class Block extends BlockBase<ts.Block> {}

                                                                                                                                                                                                                                                                                                                                                                                                                          class BooleanLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                          class BooleanLiteral extends BooleanLiteralBase<ts.BooleanLiteral> {}

                                                                                                                                                                                                                                                                                                                                                                                                                            method getLiteralValue

                                                                                                                                                                                                                                                                                                                                                                                                                            getLiteralValue: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Gets the literal value.

                                                                                                                                                                                                                                                                                                                                                                                                                            method setLiteralValue

                                                                                                                                                                                                                                                                                                                                                                                                                            setLiteralValue: (value: boolean) => BooleanLiteral;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Sets the literal value.

                                                                                                                                                                                                                                                                                                                                                                                                                              Note: For the time being, this forgets the current node and returns the new node.

                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter value

                                                                                                                                                                                                                                                                                                                                                                                                                              Value to set.

                                                                                                                                                                                                                                                                                                                                                                                                                            class BreakStatement

                                                                                                                                                                                                                                                                                                                                                                                                                            class BreakStatement extends BreakStatementBase<ts.BreakStatement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                              method getLabel

                                                                                                                                                                                                                                                                                                                                                                                                                              getLabel: () => Identifier | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                              • Gets this break statement's label or undefined if it does not exist.

                                                                                                                                                                                                                                                                                                                                                                                                                              method getLabelOrThrow

                                                                                                                                                                                                                                                                                                                                                                                                                              getLabelOrThrow: () => Identifier;
                                                                                                                                                                                                                                                                                                                                                                                                                              • Gets this break statement's label or throw if it does not exist.

                                                                                                                                                                                                                                                                                                                                                                                                                              class CallExpression

                                                                                                                                                                                                                                                                                                                                                                                                                              class CallExpression<
                                                                                                                                                                                                                                                                                                                                                                                                                              T extends ts.CallExpression = ts.CallExpression
                                                                                                                                                                                                                                                                                                                                                                                                                              > extends CallExpressionBase<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                method getReturnType

                                                                                                                                                                                                                                                                                                                                                                                                                                getReturnType: () => Type;
                                                                                                                                                                                                                                                                                                                                                                                                                                • Gets the return type of the call expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                class CallSignatureDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                class CallSignatureDeclaration extends CallSignatureDeclarationBase<ts.CallSignatureDeclaration> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                  method getStructure

                                                                                                                                                                                                                                                                                                                                                                                                                                  getStructure: () => CallSignatureDeclarationStructure;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Gets the structure equivalent to this node.

                                                                                                                                                                                                                                                                                                                                                                                                                                  method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                  remove: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Removes this call signature.

                                                                                                                                                                                                                                                                                                                                                                                                                                  method set

                                                                                                                                                                                                                                                                                                                                                                                                                                  set: (structure: Partial<CallSignatureDeclarationStructure>) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Sets the node from a structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter structure

                                                                                                                                                                                                                                                                                                                                                                                                                                    Structure to set the node with.

                                                                                                                                                                                                                                                                                                                                                                                                                                  class CaseBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                  class CaseBlock extends CaseBlockBase<ts.CaseBlock> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    method getClauses

                                                                                                                                                                                                                                                                                                                                                                                                                                    getClauses: () => CaseOrDefaultClause[];
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Gets the clauses.

                                                                                                                                                                                                                                                                                                                                                                                                                                    method removeClause

                                                                                                                                                                                                                                                                                                                                                                                                                                    removeClause: (index: number) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Removes the clause at the specified index.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter index

                                                                                                                                                                                                                                                                                                                                                                                                                                      Index.

                                                                                                                                                                                                                                                                                                                                                                                                                                    method removeClauses

                                                                                                                                                                                                                                                                                                                                                                                                                                    removeClauses: (indexRange: [number, number]) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Removes the clauses in the specified range.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter indexRange

                                                                                                                                                                                                                                                                                                                                                                                                                                      Index range.

                                                                                                                                                                                                                                                                                                                                                                                                                                    class CaseClause

                                                                                                                                                                                                                                                                                                                                                                                                                                    class CaseClause extends CaseClauseBase<ts.CaseClause> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      method getExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                      getExpression: () => Expression;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Gets this switch statement's expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                      method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                      remove: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Removes this case clause.

                                                                                                                                                                                                                                                                                                                                                                                                                                      class CatchClause

                                                                                                                                                                                                                                                                                                                                                                                                                                      class CatchClause extends CatchClauseBase<ts.CatchClause> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                        method getBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                        getBlock: () => Block;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Gets this catch clause's block.

                                                                                                                                                                                                                                                                                                                                                                                                                                        method getVariableDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                        getVariableDeclaration: () => VariableDeclaration | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Gets this catch clause's variable declaration or undefined if none exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                        method getVariableDeclarationOrThrow

                                                                                                                                                                                                                                                                                                                                                                                                                                        getVariableDeclarationOrThrow: () => VariableDeclaration;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Gets this catch clause's variable declaration or throws if none exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                        class ClassDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                        class ClassDeclaration extends ClassDeclarationBase<ts.ClassDeclaration> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          method extractInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                          extractInterface: (name?: string) => InterfaceDeclarationStructure;
                                                                                                                                                                                                                                                                                                                                                                                                                                          • Extracts an interface declaration structure from the class.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                            Name of the interface. Falls back to the same name as the class and then the filepath's base name.

                                                                                                                                                                                                                                                                                                                                                                                                                                          method extractStaticInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                          extractStaticInterface: (name: string) => InterfaceDeclarationStructure;
                                                                                                                                                                                                                                                                                                                                                                                                                                          • Extracts an interface declaration structure from the static part of the class.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                            Name of the interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                          method getStructure

                                                                                                                                                                                                                                                                                                                                                                                                                                          getStructure: () => ClassDeclarationStructure;
                                                                                                                                                                                                                                                                                                                                                                                                                                          • Gets the structure equivalent to this node.

                                                                                                                                                                                                                                                                                                                                                                                                                                          method set

                                                                                                                                                                                                                                                                                                                                                                                                                                          set: (structure: Partial<ClassDeclarationStructure>) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                          • Sets the node from a structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter structure

                                                                                                                                                                                                                                                                                                                                                                                                                                            Structure to set the node with.

                                                                                                                                                                                                                                                                                                                                                                                                                                          class ClassExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                          class ClassExpression extends ClassExpressionBase<ts.ClassExpression> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            class CodeAction

                                                                                                                                                                                                                                                                                                                                                                                                                                            class CodeAction<TCompilerObject extends ts.CodeAction = ts.CodeAction> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Represents a code action.

                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                            protected constructor();

                                                                                                                                                                                                                                                                                                                                                                                                                                              property compilerObject

                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly compilerObject: ts.CodeAction;
                                                                                                                                                                                                                                                                                                                                                                                                                                              • Gets the compiler object.

                                                                                                                                                                                                                                                                                                                                                                                                                                              method getChanges