@typescript-eslint/typescript-estree

  • Version 7.1.0
  • Published
  • 566 kB
  • 8 dependencies
  • BSD-2-Clause license

Install

npm i @typescript-eslint/typescript-estree
yarn add @typescript-eslint/typescript-estree
pnpm add @typescript-eslint/typescript-estree

Overview

A parser that converts TypeScript source code into an ESTree compatible form

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable clearProgramCache

const clearProgramCache: () => void;

    variable typescriptVersionIsAtLeast

    const typescriptVersionIsAtLeast: Record<
    '4.7' | '4.8' | '4.9' | '5.0' | '5.1' | '5.2' | '5.3' | '5.4',
    boolean
    >;

      variable version

      const version: string;

        Functions

        function clearCaches

        clearCaches: () => void;
        • Clears all of the internal caches. Generally you shouldn't need or want to use this. Examples of intended uses: - In tests to reset parser state to keep tests isolated. - In custom lint tooling that iteratively lints one project at a time to prevent OOMs.

        function createProgram

        createProgram: (configFile: string, projectDirectory?: string) => ts.Program;
        • Utility offered by parser to help consumers construct their own program instance.

          Parameter configFile

          the path to the tsconfig.json file, relative to projectDirectory

          Parameter projectDirectory

          the project directory to use as the CWD, defaults to process.cwd()

        function getCanonicalFileName

        getCanonicalFileName: (filePath: string) => CanonicalPath;

          function getDecorators

          getDecorators: (
          node: ts.Node | null | undefined,
          includeIllegalDecorators?: boolean
          ) => ts.Decorator[] | undefined;

            function getLanguageVariant

            getLanguageVariant: (scriptKind: ts.ScriptKind) => ts.LanguageVariant;

              function getModifiers

              getModifiers: (
              node: ts.Node | null | undefined,
              includeIllegalModifiers?: boolean
              ) => ts.Modifier[] | undefined;

                function getScriptKind

                getScriptKind: (filePath: string, jsx: boolean) => ts.ScriptKind;

                  function parse

                  parse: <
                  T extends ParseAndGenerateServicesOptions = ParseAndGenerateServicesOptions
                  >(
                  code: string,
                  options?: T
                  ) => AST<T>;

                    function parseAndGenerateServices

                    parseAndGenerateServices: <
                    T extends ParseAndGenerateServicesOptions = ParseAndGenerateServicesOptions
                    >(
                    code: ts.SourceFile | string,
                    options: T
                    ) => ParseAndGenerateServicesResult<T>;

                      function simpleTraverse

                      simpleTraverse: (
                      startingNode: TSESTree.Node,
                      options: SimpleTraverseOptions,
                      setParentPointers?: boolean
                      ) => void;

                        Classes

                        class TSError

                        class TSError extends Error {}

                          constructor

                          constructor(
                          message: string,
                          fileName: string,
                          location: {
                          start: { line: number; column: number; offset: number };
                          end: { line: number; column: number; offset: number };
                          }
                          );

                            property column

                            readonly column: number;

                              property fileName

                              readonly fileName: string;

                                property index

                                readonly index: number;

                                  property lineNumber

                                  readonly lineNumber: number;

                                    property location

                                    readonly location: {
                                    start: { line: number; column: number; offset: number };
                                    end: { line: number; column: number; offset: number };
                                    };

                                      Interfaces

                                      interface EstreeToTsNodeTypes

                                      interface EstreeToTsNodeTypes {}

                                        property [AST_NODE_TYPES.AccessorProperty]

                                        [AST_NODE_TYPES.AccessorProperty]: ts.PropertyDeclaration;

                                          property [AST_NODE_TYPES.ArrayExpression]

                                          [AST_NODE_TYPES.ArrayExpression]: ts.ArrayLiteralExpression;

                                            property [AST_NODE_TYPES.ArrayPattern]

                                            [AST_NODE_TYPES.ArrayPattern]:
                                            | ts.ArrayBindingPattern
                                            | ts.ArrayLiteralExpression;

                                              property [AST_NODE_TYPES.ArrowFunctionExpression]

                                              [AST_NODE_TYPES.ArrowFunctionExpression]: ts.ArrowFunction;

                                                property [AST_NODE_TYPES.AssignmentExpression]

                                                [AST_NODE_TYPES.AssignmentExpression]: ts.BinaryExpression;

                                                  property [AST_NODE_TYPES.AssignmentPattern]

                                                  [AST_NODE_TYPES.AssignmentPattern]:
                                                  | ts.BinaryExpression
                                                  | ts.BindingElement
                                                  | ts.ParameterDeclaration
                                                  | ts.ShorthandPropertyAssignment;

                                                    property [AST_NODE_TYPES.AwaitExpression]

                                                    [AST_NODE_TYPES.AwaitExpression]: ts.AwaitExpression;

                                                      property [AST_NODE_TYPES.BinaryExpression]

                                                      [AST_NODE_TYPES.BinaryExpression]: ts.BinaryExpression;

                                                        property [AST_NODE_TYPES.BlockStatement]

                                                        [AST_NODE_TYPES.BlockStatement]: ts.Block;

                                                          property [AST_NODE_TYPES.BreakStatement]

                                                          [AST_NODE_TYPES.BreakStatement]: ts.BreakStatement;

                                                            property [AST_NODE_TYPES.CallExpression]

                                                            [AST_NODE_TYPES.CallExpression]: ts.CallExpression;

                                                              property [AST_NODE_TYPES.CatchClause]

                                                              [AST_NODE_TYPES.CatchClause]: ts.CatchClause;

                                                                property [AST_NODE_TYPES.ChainExpression]

                                                                [AST_NODE_TYPES.ChainExpression]:
                                                                | ts.CallExpression
                                                                | ts.ElementAccessExpression
                                                                | ts.NonNullExpression
                                                                | ts.PropertyAccessExpression;

                                                                  property [AST_NODE_TYPES.ClassBody]

                                                                  [AST_NODE_TYPES.ClassBody]: ts.ClassDeclaration | ts.ClassExpression;

                                                                    property [AST_NODE_TYPES.ClassDeclaration]

                                                                    [AST_NODE_TYPES.ClassDeclaration]: ts.ClassDeclaration;

                                                                      property [AST_NODE_TYPES.ClassExpression]

                                                                      [AST_NODE_TYPES.ClassExpression]: ts.ClassExpression;

                                                                        property [AST_NODE_TYPES.ConditionalExpression]

                                                                        [AST_NODE_TYPES.ConditionalExpression]: ts.ConditionalExpression;

                                                                          property [AST_NODE_TYPES.ContinueStatement]

                                                                          [AST_NODE_TYPES.ContinueStatement]: ts.ContinueStatement;

                                                                            property [AST_NODE_TYPES.DebuggerStatement]

                                                                            [AST_NODE_TYPES.DebuggerStatement]: ts.DebuggerStatement;

                                                                              property [AST_NODE_TYPES.Decorator]

                                                                              [AST_NODE_TYPES.Decorator]: ts.Decorator;

                                                                                property [AST_NODE_TYPES.DoWhileStatement]

                                                                                [AST_NODE_TYPES.DoWhileStatement]: ts.DoStatement;

                                                                                  property [AST_NODE_TYPES.EmptyStatement]

                                                                                  [AST_NODE_TYPES.EmptyStatement]: ts.EmptyStatement;

                                                                                    property [AST_NODE_TYPES.ExportAllDeclaration]

                                                                                    [AST_NODE_TYPES.ExportAllDeclaration]: ts.ExportDeclaration;

                                                                                      property [AST_NODE_TYPES.ExportDefaultDeclaration]

                                                                                      [AST_NODE_TYPES.ExportDefaultDeclaration]:
                                                                                      | ts.ClassDeclaration
                                                                                      | ts.ClassExpression
                                                                                      | ts.EnumDeclaration
                                                                                      | ts.ExportAssignment
                                                                                      | ts.FunctionDeclaration
                                                                                      | ts.InterfaceDeclaration
                                                                                      | ts.ModuleDeclaration
                                                                                      | ts.TypeAliasDeclaration
                                                                                      | ts.VariableStatement;

                                                                                        property [AST_NODE_TYPES.ExportNamedDeclaration]

                                                                                        [AST_NODE_TYPES.ExportNamedDeclaration]:
                                                                                        | ts.ClassDeclaration
                                                                                        | ts.ClassExpression
                                                                                        | ts.EnumDeclaration
                                                                                        | ts.ExportDeclaration
                                                                                        | ts.FunctionDeclaration
                                                                                        | ts.ImportEqualsDeclaration
                                                                                        | ts.InterfaceDeclaration
                                                                                        | ts.ModuleDeclaration
                                                                                        | ts.TypeAliasDeclaration
                                                                                        | ts.VariableStatement;

                                                                                          property [AST_NODE_TYPES.ExportSpecifier]

                                                                                          [AST_NODE_TYPES.ExportSpecifier]: ts.ExportSpecifier;

                                                                                            property [AST_NODE_TYPES.ExpressionStatement]

                                                                                            [AST_NODE_TYPES.ExpressionStatement]: ts.ExpressionStatement;

                                                                                              property [AST_NODE_TYPES.ForInStatement]

                                                                                              [AST_NODE_TYPES.ForInStatement]: ts.ForInStatement;

                                                                                                property [AST_NODE_TYPES.ForOfStatement]

                                                                                                [AST_NODE_TYPES.ForOfStatement]: ts.ForOfStatement;

                                                                                                  property [AST_NODE_TYPES.ForStatement]

                                                                                                  [AST_NODE_TYPES.ForStatement]: ts.ForStatement;

                                                                                                    property [AST_NODE_TYPES.FunctionDeclaration]

                                                                                                    [AST_NODE_TYPES.FunctionDeclaration]: ts.FunctionDeclaration;

                                                                                                      property [AST_NODE_TYPES.FunctionExpression]

                                                                                                      [AST_NODE_TYPES.FunctionExpression]:
                                                                                                      | ts.ConstructorDeclaration
                                                                                                      | ts.FunctionExpression
                                                                                                      | ts.GetAccessorDeclaration
                                                                                                      | ts.MethodDeclaration
                                                                                                      | ts.SetAccessorDeclaration;

                                                                                                        property [AST_NODE_TYPES.Identifier]

                                                                                                        [AST_NODE_TYPES.Identifier]:
                                                                                                        | ts.ConstructorDeclaration
                                                                                                        | ts.Identifier
                                                                                                        | ts.Token<ts.SyntaxKind.ImportKeyword | ts.SyntaxKind.NewKeyword>;

                                                                                                          property [AST_NODE_TYPES.IfStatement]

                                                                                                          [AST_NODE_TYPES.IfStatement]: ts.IfStatement;

                                                                                                            property [AST_NODE_TYPES.ImportAttribute]

                                                                                                            [AST_NODE_TYPES.ImportAttribute]: 'ImportAttribute' extends keyof typeof ts
                                                                                                            ? ts.ImportAttribute
                                                                                                            : ts.AssertEntry;

                                                                                                              property [AST_NODE_TYPES.ImportDeclaration]

                                                                                                              [AST_NODE_TYPES.ImportDeclaration]: ts.ImportDeclaration;

                                                                                                                property [AST_NODE_TYPES.ImportDefaultSpecifier]

                                                                                                                [AST_NODE_TYPES.ImportDefaultSpecifier]: ts.ImportClause;

                                                                                                                  property [AST_NODE_TYPES.ImportExpression]

                                                                                                                  [AST_NODE_TYPES.ImportExpression]: ts.CallExpression;

                                                                                                                    property [AST_NODE_TYPES.ImportNamespaceSpecifier]

                                                                                                                    [AST_NODE_TYPES.ImportNamespaceSpecifier]: ts.NamespaceImport;

                                                                                                                      property [AST_NODE_TYPES.ImportSpecifier]

                                                                                                                      [AST_NODE_TYPES.ImportSpecifier]: ts.ImportSpecifier;

                                                                                                                        property [AST_NODE_TYPES.JSXAttribute]

                                                                                                                        [AST_NODE_TYPES.JSXAttribute]: ts.JsxAttribute;

                                                                                                                          property [AST_NODE_TYPES.JSXClosingElement]

                                                                                                                          [AST_NODE_TYPES.JSXClosingElement]: ts.JsxClosingElement;

                                                                                                                            property [AST_NODE_TYPES.JSXClosingFragment]

                                                                                                                            [AST_NODE_TYPES.JSXClosingFragment]: ts.JsxClosingFragment;

                                                                                                                              property [AST_NODE_TYPES.JSXElement]

                                                                                                                              [AST_NODE_TYPES.JSXElement]: ts.JsxElement | ts.JsxSelfClosingElement;

                                                                                                                                property [AST_NODE_TYPES.JSXEmptyExpression]

                                                                                                                                [AST_NODE_TYPES.JSXEmptyExpression]: ts.JsxExpression;

                                                                                                                                  property [AST_NODE_TYPES.JSXExpressionContainer]

                                                                                                                                  [AST_NODE_TYPES.JSXExpressionContainer]: ts.JsxExpression;

                                                                                                                                    property [AST_NODE_TYPES.JSXFragment]

                                                                                                                                    [AST_NODE_TYPES.JSXFragment]: ts.JsxFragment;

                                                                                                                                      property [AST_NODE_TYPES.JSXIdentifier]

                                                                                                                                      [AST_NODE_TYPES.JSXIdentifier]: ts.Identifier | ts.ThisExpression;

                                                                                                                                        property [AST_NODE_TYPES.JSXMemberExpression]

                                                                                                                                        [AST_NODE_TYPES.JSXMemberExpression]: ts.PropertyAccessExpression;

                                                                                                                                          property [AST_NODE_TYPES.JSXNamespacedName]

                                                                                                                                          [AST_NODE_TYPES.JSXNamespacedName]: ts.JsxNamespacedName;

                                                                                                                                            property [AST_NODE_TYPES.JSXOpeningElement]

                                                                                                                                            [AST_NODE_TYPES.JSXOpeningElement]:
                                                                                                                                            | ts.JsxOpeningElement
                                                                                                                                            | ts.JsxSelfClosingElement;

                                                                                                                                              property [AST_NODE_TYPES.JSXOpeningFragment]

                                                                                                                                              [AST_NODE_TYPES.JSXOpeningFragment]: ts.JsxOpeningFragment;

                                                                                                                                                property [AST_NODE_TYPES.JSXSpreadAttribute]

                                                                                                                                                [AST_NODE_TYPES.JSXSpreadAttribute]: ts.JsxSpreadAttribute;

                                                                                                                                                  property [AST_NODE_TYPES.JSXSpreadChild]

                                                                                                                                                  [AST_NODE_TYPES.JSXSpreadChild]: ts.JsxExpression;

                                                                                                                                                    property [AST_NODE_TYPES.JSXText]

                                                                                                                                                    [AST_NODE_TYPES.JSXText]: ts.JsxText;

                                                                                                                                                      property [AST_NODE_TYPES.LabeledStatement]

                                                                                                                                                      [AST_NODE_TYPES.LabeledStatement]: ts.LabeledStatement;

                                                                                                                                                        property [AST_NODE_TYPES.Literal]

                                                                                                                                                        [AST_NODE_TYPES.Literal]:
                                                                                                                                                        | ts.BigIntLiteral
                                                                                                                                                        | ts.BooleanLiteral
                                                                                                                                                        | ts.NullLiteral
                                                                                                                                                        | ts.NumericLiteral
                                                                                                                                                        | ts.RegularExpressionLiteral
                                                                                                                                                        | ts.StringLiteral;

                                                                                                                                                          property [AST_NODE_TYPES.LogicalExpression]

                                                                                                                                                          [AST_NODE_TYPES.LogicalExpression]: ts.BinaryExpression;

                                                                                                                                                            property [AST_NODE_TYPES.MemberExpression]

                                                                                                                                                            [AST_NODE_TYPES.MemberExpression]:
                                                                                                                                                            | ts.ElementAccessExpression
                                                                                                                                                            | ts.PropertyAccessExpression;

                                                                                                                                                              property [AST_NODE_TYPES.MetaProperty]

                                                                                                                                                              [AST_NODE_TYPES.MetaProperty]: ts.MetaProperty;

                                                                                                                                                                property [AST_NODE_TYPES.MethodDefinition]

                                                                                                                                                                [AST_NODE_TYPES.MethodDefinition]:
                                                                                                                                                                | ts.ConstructorDeclaration
                                                                                                                                                                | ts.GetAccessorDeclaration
                                                                                                                                                                | ts.MethodDeclaration
                                                                                                                                                                | ts.SetAccessorDeclaration;

                                                                                                                                                                  property [AST_NODE_TYPES.NewExpression]

                                                                                                                                                                  [AST_NODE_TYPES.NewExpression]: ts.NewExpression;

                                                                                                                                                                    property [AST_NODE_TYPES.ObjectExpression]

                                                                                                                                                                    [AST_NODE_TYPES.ObjectExpression]: ts.ObjectLiteralExpression;

                                                                                                                                                                      property [AST_NODE_TYPES.ObjectPattern]

                                                                                                                                                                      [AST_NODE_TYPES.ObjectPattern]:
                                                                                                                                                                      | ts.ObjectBindingPattern
                                                                                                                                                                      | ts.ObjectLiteralExpression;

                                                                                                                                                                        property [AST_NODE_TYPES.PrivateIdentifier]

                                                                                                                                                                        [AST_NODE_TYPES.PrivateIdentifier]: ts.PrivateIdentifier;

                                                                                                                                                                          property [AST_NODE_TYPES.Program]

                                                                                                                                                                          [AST_NODE_TYPES.Program]: ts.SourceFile;

                                                                                                                                                                            property [AST_NODE_TYPES.Property]

                                                                                                                                                                            [AST_NODE_TYPES.Property]:
                                                                                                                                                                            | ts.BindingElement
                                                                                                                                                                            | ts.GetAccessorDeclaration
                                                                                                                                                                            | ts.MethodDeclaration
                                                                                                                                                                            | ts.PropertyAssignment
                                                                                                                                                                            | ts.SetAccessorDeclaration
                                                                                                                                                                            | ts.ShorthandPropertyAssignment;

                                                                                                                                                                              property [AST_NODE_TYPES.PropertyDefinition]

                                                                                                                                                                              [AST_NODE_TYPES.PropertyDefinition]: ts.PropertyDeclaration;

                                                                                                                                                                                property [AST_NODE_TYPES.RestElement]

                                                                                                                                                                                [AST_NODE_TYPES.RestElement]:
                                                                                                                                                                                | ts.BindingElement
                                                                                                                                                                                | ts.ParameterDeclaration
                                                                                                                                                                                | ts.SpreadAssignment
                                                                                                                                                                                | ts.SpreadElement;

                                                                                                                                                                                  property [AST_NODE_TYPES.ReturnStatement]

                                                                                                                                                                                  [AST_NODE_TYPES.ReturnStatement]: ts.ReturnStatement;

                                                                                                                                                                                    property [AST_NODE_TYPES.SequenceExpression]

                                                                                                                                                                                    [AST_NODE_TYPES.SequenceExpression]: ts.BinaryExpression;

                                                                                                                                                                                      property [AST_NODE_TYPES.SpreadElement]

                                                                                                                                                                                      [AST_NODE_TYPES.SpreadElement]: ts.SpreadAssignment | ts.SpreadElement;

                                                                                                                                                                                        property [AST_NODE_TYPES.StaticBlock]

                                                                                                                                                                                        [AST_NODE_TYPES.StaticBlock]: ts.ClassStaticBlockDeclaration;

                                                                                                                                                                                          property [AST_NODE_TYPES.Super]

                                                                                                                                                                                          [AST_NODE_TYPES.Super]: ts.SuperExpression;

                                                                                                                                                                                            property [AST_NODE_TYPES.SwitchCase]

                                                                                                                                                                                            [AST_NODE_TYPES.SwitchCase]: ts.CaseClause | ts.DefaultClause;

                                                                                                                                                                                              property [AST_NODE_TYPES.SwitchStatement]

                                                                                                                                                                                              [AST_NODE_TYPES.SwitchStatement]: ts.SwitchStatement;

                                                                                                                                                                                                property [AST_NODE_TYPES.TaggedTemplateExpression]

                                                                                                                                                                                                [AST_NODE_TYPES.TaggedTemplateExpression]: ts.TaggedTemplateExpression;

                                                                                                                                                                                                  property [AST_NODE_TYPES.TemplateElement]

                                                                                                                                                                                                  [AST_NODE_TYPES.TemplateElement]:
                                                                                                                                                                                                  | ts.NoSubstitutionTemplateLiteral
                                                                                                                                                                                                  | ts.TemplateHead
                                                                                                                                                                                                  | ts.TemplateMiddle
                                                                                                                                                                                                  | ts.TemplateTail;

                                                                                                                                                                                                    property [AST_NODE_TYPES.TemplateLiteral]

                                                                                                                                                                                                    [AST_NODE_TYPES.TemplateLiteral]:
                                                                                                                                                                                                    | ts.NoSubstitutionTemplateLiteral
                                                                                                                                                                                                    | ts.TemplateExpression;

                                                                                                                                                                                                      property [AST_NODE_TYPES.ThisExpression]

                                                                                                                                                                                                      [AST_NODE_TYPES.ThisExpression]:
                                                                                                                                                                                                      | ts.Identifier
                                                                                                                                                                                                      | ts.KeywordTypeNode
                                                                                                                                                                                                      | ts.ThisExpression;

                                                                                                                                                                                                        property [AST_NODE_TYPES.ThrowStatement]

                                                                                                                                                                                                        [AST_NODE_TYPES.ThrowStatement]: ts.ThrowStatement;

                                                                                                                                                                                                          property [AST_NODE_TYPES.TryStatement]

                                                                                                                                                                                                          [AST_NODE_TYPES.TryStatement]: ts.TryStatement;

                                                                                                                                                                                                            property [AST_NODE_TYPES.TSAbstractAccessorProperty]

                                                                                                                                                                                                            [AST_NODE_TYPES.TSAbstractAccessorProperty]: ts.PropertyDeclaration;

                                                                                                                                                                                                              property [AST_NODE_TYPES.TSAbstractKeyword]

                                                                                                                                                                                                              [AST_NODE_TYPES.TSAbstractKeyword]: ts.Token<ts.SyntaxKind.AbstractKeyword>;

                                                                                                                                                                                                                property [AST_NODE_TYPES.TSAbstractMethodDefinition]

                                                                                                                                                                                                                [AST_NODE_TYPES.TSAbstractMethodDefinition]:
                                                                                                                                                                                                                | ts.ConstructorDeclaration
                                                                                                                                                                                                                | ts.GetAccessorDeclaration
                                                                                                                                                                                                                | ts.MethodDeclaration
                                                                                                                                                                                                                | ts.SetAccessorDeclaration;

                                                                                                                                                                                                                  property [AST_NODE_TYPES.TSAbstractPropertyDefinition]

                                                                                                                                                                                                                  [AST_NODE_TYPES.TSAbstractPropertyDefinition]: ts.PropertyDeclaration;

                                                                                                                                                                                                                    property [AST_NODE_TYPES.TSAnyKeyword]

                                                                                                                                                                                                                    [AST_NODE_TYPES.TSAnyKeyword]: ts.KeywordTypeNode;

                                                                                                                                                                                                                      property [AST_NODE_TYPES.TSArrayType]

                                                                                                                                                                                                                      [AST_NODE_TYPES.TSArrayType]: ts.ArrayTypeNode;

                                                                                                                                                                                                                        property [AST_NODE_TYPES.TSAsExpression]

                                                                                                                                                                                                                        [AST_NODE_TYPES.TSAsExpression]: ts.AsExpression;

                                                                                                                                                                                                                          property [AST_NODE_TYPES.TSAsyncKeyword]

                                                                                                                                                                                                                          [AST_NODE_TYPES.TSAsyncKeyword]: ts.Token<ts.SyntaxKind.AsyncKeyword>;

                                                                                                                                                                                                                            property [AST_NODE_TYPES.TSBigIntKeyword]

                                                                                                                                                                                                                            [AST_NODE_TYPES.TSBigIntKeyword]: ts.KeywordTypeNode;

                                                                                                                                                                                                                              property [AST_NODE_TYPES.TSBooleanKeyword]

                                                                                                                                                                                                                              [AST_NODE_TYPES.TSBooleanKeyword]: ts.KeywordTypeNode;

                                                                                                                                                                                                                                property [AST_NODE_TYPES.TSCallSignatureDeclaration]

                                                                                                                                                                                                                                [AST_NODE_TYPES.TSCallSignatureDeclaration]: ts.CallSignatureDeclaration;

                                                                                                                                                                                                                                  property [AST_NODE_TYPES.TSClassImplements]

                                                                                                                                                                                                                                  [AST_NODE_TYPES.TSClassImplements]: ts.ExpressionWithTypeArguments;

                                                                                                                                                                                                                                    property [AST_NODE_TYPES.TSConditionalType]

                                                                                                                                                                                                                                    [AST_NODE_TYPES.TSConditionalType]: ts.ConditionalTypeNode;

                                                                                                                                                                                                                                      property [AST_NODE_TYPES.TSConstructorType]

                                                                                                                                                                                                                                      [AST_NODE_TYPES.TSConstructorType]: ts.ConstructorTypeNode;

                                                                                                                                                                                                                                        property [AST_NODE_TYPES.TSConstructSignatureDeclaration]

                                                                                                                                                                                                                                        [AST_NODE_TYPES.TSConstructSignatureDeclaration]: ts.ConstructSignatureDeclaration;

                                                                                                                                                                                                                                          property [AST_NODE_TYPES.TSDeclareFunction]

                                                                                                                                                                                                                                          [AST_NODE_TYPES.TSDeclareFunction]: ts.FunctionDeclaration;

                                                                                                                                                                                                                                            property [AST_NODE_TYPES.TSDeclareKeyword]

                                                                                                                                                                                                                                            [AST_NODE_TYPES.TSDeclareKeyword]: ts.Token<ts.SyntaxKind.DeclareKeyword>;

                                                                                                                                                                                                                                              property [AST_NODE_TYPES.TSEmptyBodyFunctionExpression]

                                                                                                                                                                                                                                              [AST_NODE_TYPES.TSEmptyBodyFunctionExpression]:
                                                                                                                                                                                                                                              | ts.ConstructorDeclaration
                                                                                                                                                                                                                                              | ts.FunctionExpression
                                                                                                                                                                                                                                              | ts.GetAccessorDeclaration
                                                                                                                                                                                                                                              | ts.MethodDeclaration
                                                                                                                                                                                                                                              | ts.SetAccessorDeclaration;

                                                                                                                                                                                                                                                property [AST_NODE_TYPES.TSEnumDeclaration]

                                                                                                                                                                                                                                                [AST_NODE_TYPES.TSEnumDeclaration]: ts.EnumDeclaration;

                                                                                                                                                                                                                                                  property [AST_NODE_TYPES.TSEnumMember]

                                                                                                                                                                                                                                                  [AST_NODE_TYPES.TSEnumMember]: ts.EnumMember;

                                                                                                                                                                                                                                                    property [AST_NODE_TYPES.TSExportAssignment]

                                                                                                                                                                                                                                                    [AST_NODE_TYPES.TSExportAssignment]: ts.ExportAssignment;

                                                                                                                                                                                                                                                      property [AST_NODE_TYPES.TSExportKeyword]

                                                                                                                                                                                                                                                      [AST_NODE_TYPES.TSExportKeyword]: ts.Token<ts.SyntaxKind.ExportKeyword>;

                                                                                                                                                                                                                                                        property [AST_NODE_TYPES.TSExternalModuleReference]

                                                                                                                                                                                                                                                        [AST_NODE_TYPES.TSExternalModuleReference]: ts.ExternalModuleReference;

                                                                                                                                                                                                                                                          property [AST_NODE_TYPES.TSFunctionType]

                                                                                                                                                                                                                                                          [AST_NODE_TYPES.TSFunctionType]: ts.FunctionTypeNode;

                                                                                                                                                                                                                                                            property [AST_NODE_TYPES.TSImportEqualsDeclaration]

                                                                                                                                                                                                                                                            [AST_NODE_TYPES.TSImportEqualsDeclaration]: ts.ImportEqualsDeclaration;

                                                                                                                                                                                                                                                              property [AST_NODE_TYPES.TSImportType]

                                                                                                                                                                                                                                                              [AST_NODE_TYPES.TSImportType]: ts.ImportTypeNode;

                                                                                                                                                                                                                                                                property [AST_NODE_TYPES.TSIndexedAccessType]

                                                                                                                                                                                                                                                                [AST_NODE_TYPES.TSIndexedAccessType]: ts.IndexedAccessTypeNode;

                                                                                                                                                                                                                                                                  property [AST_NODE_TYPES.TSIndexSignature]

                                                                                                                                                                                                                                                                  [AST_NODE_TYPES.TSIndexSignature]: ts.IndexSignatureDeclaration;

                                                                                                                                                                                                                                                                    property [AST_NODE_TYPES.TSInferType]

                                                                                                                                                                                                                                                                    [AST_NODE_TYPES.TSInferType]: ts.InferTypeNode;

                                                                                                                                                                                                                                                                      property [AST_NODE_TYPES.TSInstantiationExpression]

                                                                                                                                                                                                                                                                      [AST_NODE_TYPES.TSInstantiationExpression]: ts.ExpressionWithTypeArguments;

                                                                                                                                                                                                                                                                        property [AST_NODE_TYPES.TSInterfaceBody]

                                                                                                                                                                                                                                                                        [AST_NODE_TYPES.TSInterfaceBody]: ts.InterfaceDeclaration;

                                                                                                                                                                                                                                                                          property [AST_NODE_TYPES.TSInterfaceDeclaration]

                                                                                                                                                                                                                                                                          [AST_NODE_TYPES.TSInterfaceDeclaration]: ts.InterfaceDeclaration;

                                                                                                                                                                                                                                                                            property [AST_NODE_TYPES.TSInterfaceHeritage]

                                                                                                                                                                                                                                                                            [AST_NODE_TYPES.TSInterfaceHeritage]: ts.ExpressionWithTypeArguments;

                                                                                                                                                                                                                                                                              property [AST_NODE_TYPES.TSIntersectionType]

                                                                                                                                                                                                                                                                              [AST_NODE_TYPES.TSIntersectionType]: ts.IntersectionTypeNode;

                                                                                                                                                                                                                                                                                property [AST_NODE_TYPES.TSIntrinsicKeyword]

                                                                                                                                                                                                                                                                                [AST_NODE_TYPES.TSIntrinsicKeyword]: ts.KeywordTypeNode;

                                                                                                                                                                                                                                                                                  property [AST_NODE_TYPES.TSLiteralType]

                                                                                                                                                                                                                                                                                  [AST_NODE_TYPES.TSLiteralType]: ts.LiteralTypeNode;

                                                                                                                                                                                                                                                                                    property [AST_NODE_TYPES.TSMappedType]

                                                                                                                                                                                                                                                                                    [AST_NODE_TYPES.TSMappedType]: ts.MappedTypeNode;

                                                                                                                                                                                                                                                                                      property [AST_NODE_TYPES.TSMethodSignature]

                                                                                                                                                                                                                                                                                      [AST_NODE_TYPES.TSMethodSignature]:
                                                                                                                                                                                                                                                                                      | ts.GetAccessorDeclaration
                                                                                                                                                                                                                                                                                      | ts.MethodSignature
                                                                                                                                                                                                                                                                                      | ts.SetAccessorDeclaration;

                                                                                                                                                                                                                                                                                        property [AST_NODE_TYPES.TSModuleBlock]

                                                                                                                                                                                                                                                                                        [AST_NODE_TYPES.TSModuleBlock]: ts.ModuleBlock;

                                                                                                                                                                                                                                                                                          property [AST_NODE_TYPES.TSModuleDeclaration]

                                                                                                                                                                                                                                                                                          [AST_NODE_TYPES.TSModuleDeclaration]: ts.ModuleDeclaration;

                                                                                                                                                                                                                                                                                            property [AST_NODE_TYPES.TSNamedTupleMember]

                                                                                                                                                                                                                                                                                            [AST_NODE_TYPES.TSNamedTupleMember]: ts.NamedTupleMember;

                                                                                                                                                                                                                                                                                              property [AST_NODE_TYPES.TSNamespaceExportDeclaration]

                                                                                                                                                                                                                                                                                              [AST_NODE_TYPES.TSNamespaceExportDeclaration]: ts.NamespaceExportDeclaration;

                                                                                                                                                                                                                                                                                                property [AST_NODE_TYPES.TSNeverKeyword]

                                                                                                                                                                                                                                                                                                [AST_NODE_TYPES.TSNeverKeyword]: ts.KeywordTypeNode;

                                                                                                                                                                                                                                                                                                  property [AST_NODE_TYPES.TSNonNullExpression]

                                                                                                                                                                                                                                                                                                  [AST_NODE_TYPES.TSNonNullExpression]: ts.NonNullExpression;

                                                                                                                                                                                                                                                                                                    property [AST_NODE_TYPES.TSNullKeyword]

                                                                                                                                                                                                                                                                                                    [AST_NODE_TYPES.TSNullKeyword]: ts.KeywordTypeNode | ts.NullLiteral;

                                                                                                                                                                                                                                                                                                      property [AST_NODE_TYPES.TSNumberKeyword]

                                                                                                                                                                                                                                                                                                      [AST_NODE_TYPES.TSNumberKeyword]: ts.KeywordTypeNode;

                                                                                                                                                                                                                                                                                                        property [AST_NODE_TYPES.TSObjectKeyword]

                                                                                                                                                                                                                                                                                                        [AST_NODE_TYPES.TSObjectKeyword]: ts.KeywordTypeNode;

                                                                                                                                                                                                                                                                                                          property [AST_NODE_TYPES.TSOptionalType]

                                                                                                                                                                                                                                                                                                          [AST_NODE_TYPES.TSOptionalType]: ts.OptionalTypeNode;

                                                                                                                                                                                                                                                                                                            property [AST_NODE_TYPES.TSParameterProperty]

                                                                                                                                                                                                                                                                                                            [AST_NODE_TYPES.TSParameterProperty]: ts.ParameterDeclaration;

                                                                                                                                                                                                                                                                                                              property [AST_NODE_TYPES.TSPrivateKeyword]

                                                                                                                                                                                                                                                                                                              [AST_NODE_TYPES.TSPrivateKeyword]: ts.Token<ts.SyntaxKind.PrivateKeyword>;

                                                                                                                                                                                                                                                                                                                property [AST_NODE_TYPES.TSPropertySignature]

                                                                                                                                                                                                                                                                                                                [AST_NODE_TYPES.TSPropertySignature]: ts.PropertySignature;

                                                                                                                                                                                                                                                                                                                  property [AST_NODE_TYPES.TSProtectedKeyword]

                                                                                                                                                                                                                                                                                                                  [AST_NODE_TYPES.TSProtectedKeyword]: ts.Token<ts.SyntaxKind.ProtectedKeyword>;

                                                                                                                                                                                                                                                                                                                    property [AST_NODE_TYPES.TSPublicKeyword]

                                                                                                                                                                                                                                                                                                                    [AST_NODE_TYPES.TSPublicKeyword]: ts.Token<ts.SyntaxKind.PublicKeyword>;

                                                                                                                                                                                                                                                                                                                      property [AST_NODE_TYPES.TSQualifiedName]

                                                                                                                                                                                                                                                                                                                      [AST_NODE_TYPES.TSQualifiedName]: ts.Identifier | ts.QualifiedName;

                                                                                                                                                                                                                                                                                                                        property [AST_NODE_TYPES.TSReadonlyKeyword]

                                                                                                                                                                                                                                                                                                                        [AST_NODE_TYPES.TSReadonlyKeyword]: ts.Token<ts.SyntaxKind.ReadonlyKeyword>;

                                                                                                                                                                                                                                                                                                                          property [AST_NODE_TYPES.TSRestType]

                                                                                                                                                                                                                                                                                                                          [AST_NODE_TYPES.TSRestType]: ts.NamedTupleMember | ts.RestTypeNode;

                                                                                                                                                                                                                                                                                                                            property [AST_NODE_TYPES.TSSatisfiesExpression]

                                                                                                                                                                                                                                                                                                                            [AST_NODE_TYPES.TSSatisfiesExpression]: ts.SatisfiesExpression;

                                                                                                                                                                                                                                                                                                                              property [AST_NODE_TYPES.TSStaticKeyword]

                                                                                                                                                                                                                                                                                                                              [AST_NODE_TYPES.TSStaticKeyword]: ts.Token<ts.SyntaxKind.StaticKeyword>;

                                                                                                                                                                                                                                                                                                                                property [AST_NODE_TYPES.TSStringKeyword]

                                                                                                                                                                                                                                                                                                                                [AST_NODE_TYPES.TSStringKeyword]: ts.KeywordTypeNode;

                                                                                                                                                                                                                                                                                                                                  property [AST_NODE_TYPES.TSSymbolKeyword]

                                                                                                                                                                                                                                                                                                                                  [AST_NODE_TYPES.TSSymbolKeyword]: ts.KeywordTypeNode;

                                                                                                                                                                                                                                                                                                                                    property [AST_NODE_TYPES.TSTemplateLiteralType]

                                                                                                                                                                                                                                                                                                                                    [AST_NODE_TYPES.TSTemplateLiteralType]: ts.TemplateLiteralTypeNode;

                                                                                                                                                                                                                                                                                                                                      property [AST_NODE_TYPES.TSThisType]

                                                                                                                                                                                                                                                                                                                                      [AST_NODE_TYPES.TSThisType]: ts.ThisTypeNode;

                                                                                                                                                                                                                                                                                                                                        property [AST_NODE_TYPES.TSTupleType]

                                                                                                                                                                                                                                                                                                                                        [AST_NODE_TYPES.TSTupleType]: ts.TupleTypeNode;

                                                                                                                                                                                                                                                                                                                                          property [AST_NODE_TYPES.TSTypeAliasDeclaration]

                                                                                                                                                                                                                                                                                                                                          [AST_NODE_TYPES.TSTypeAliasDeclaration]: ts.TypeAliasDeclaration;

                                                                                                                                                                                                                                                                                                                                            property [AST_NODE_TYPES.TSTypeAnnotation]

                                                                                                                                                                                                                                                                                                                                            [AST_NODE_TYPES.TSTypeAnnotation]: undefined;

                                                                                                                                                                                                                                                                                                                                              property [AST_NODE_TYPES.TSTypeAssertion]

                                                                                                                                                                                                                                                                                                                                              [AST_NODE_TYPES.TSTypeAssertion]: ts.TypeAssertion;

                                                                                                                                                                                                                                                                                                                                                property [AST_NODE_TYPES.TSTypeLiteral]

                                                                                                                                                                                                                                                                                                                                                [AST_NODE_TYPES.TSTypeLiteral]: ts.TypeLiteralNode;

                                                                                                                                                                                                                                                                                                                                                  property [AST_NODE_TYPES.TSTypeOperator]

                                                                                                                                                                                                                                                                                                                                                  [AST_NODE_TYPES.TSTypeOperator]: ts.TypeOperatorNode;

                                                                                                                                                                                                                                                                                                                                                    property [AST_NODE_TYPES.TSTypeParameter]

                                                                                                                                                                                                                                                                                                                                                    [AST_NODE_TYPES.TSTypeParameter]: ts.TypeParameterDeclaration;

                                                                                                                                                                                                                                                                                                                                                      property [AST_NODE_TYPES.TSTypeParameterDeclaration]

                                                                                                                                                                                                                                                                                                                                                      [AST_NODE_TYPES.TSTypeParameterDeclaration]: undefined;

                                                                                                                                                                                                                                                                                                                                                        property [AST_NODE_TYPES.TSTypeParameterInstantiation]

                                                                                                                                                                                                                                                                                                                                                        [AST_NODE_TYPES.TSTypeParameterInstantiation]:
                                                                                                                                                                                                                                                                                                                                                        | ts.CallExpression
                                                                                                                                                                                                                                                                                                                                                        | ts.ExpressionWithTypeArguments
                                                                                                                                                                                                                                                                                                                                                        | ts.ImportTypeNode
                                                                                                                                                                                                                                                                                                                                                        | ts.JsxOpeningElement
                                                                                                                                                                                                                                                                                                                                                        | ts.JsxSelfClosingElement
                                                                                                                                                                                                                                                                                                                                                        | ts.NewExpression
                                                                                                                                                                                                                                                                                                                                                        | ts.TaggedTemplateExpression
                                                                                                                                                                                                                                                                                                                                                        | ts.TypeQueryNode
                                                                                                                                                                                                                                                                                                                                                        | ts.TypeReferenceNode;

                                                                                                                                                                                                                                                                                                                                                          property [AST_NODE_TYPES.TSTypePredicate]

                                                                                                                                                                                                                                                                                                                                                          [AST_NODE_TYPES.TSTypePredicate]: ts.TypePredicateNode;

                                                                                                                                                                                                                                                                                                                                                            property [AST_NODE_TYPES.TSTypeQuery]

                                                                                                                                                                                                                                                                                                                                                            [AST_NODE_TYPES.TSTypeQuery]: ts.ImportTypeNode | ts.TypeQueryNode;

                                                                                                                                                                                                                                                                                                                                                              property [AST_NODE_TYPES.TSTypeReference]

                                                                                                                                                                                                                                                                                                                                                              [AST_NODE_TYPES.TSTypeReference]: ts.TypeReferenceNode;

                                                                                                                                                                                                                                                                                                                                                                property [AST_NODE_TYPES.TSUndefinedKeyword]

                                                                                                                                                                                                                                                                                                                                                                [AST_NODE_TYPES.TSUndefinedKeyword]: ts.KeywordTypeNode;

                                                                                                                                                                                                                                                                                                                                                                  property [AST_NODE_TYPES.TSUnionType]

                                                                                                                                                                                                                                                                                                                                                                  [AST_NODE_TYPES.TSUnionType]: ts.UnionTypeNode;

                                                                                                                                                                                                                                                                                                                                                                    property [AST_NODE_TYPES.TSUnknownKeyword]

                                                                                                                                                                                                                                                                                                                                                                    [AST_NODE_TYPES.TSUnknownKeyword]: ts.KeywordTypeNode;

                                                                                                                                                                                                                                                                                                                                                                      property [AST_NODE_TYPES.TSVoidKeyword]

                                                                                                                                                                                                                                                                                                                                                                      [AST_NODE_TYPES.TSVoidKeyword]: ts.KeywordTypeNode;

                                                                                                                                                                                                                                                                                                                                                                        property [AST_NODE_TYPES.UnaryExpression]

                                                                                                                                                                                                                                                                                                                                                                        [AST_NODE_TYPES.UnaryExpression]:
                                                                                                                                                                                                                                                                                                                                                                        | ts.DeleteExpression
                                                                                                                                                                                                                                                                                                                                                                        | ts.PostfixUnaryExpression
                                                                                                                                                                                                                                                                                                                                                                        | ts.PrefixUnaryExpression
                                                                                                                                                                                                                                                                                                                                                                        | ts.TypeOfExpression
                                                                                                                                                                                                                                                                                                                                                                        | ts.VoidExpression;

                                                                                                                                                                                                                                                                                                                                                                          property [AST_NODE_TYPES.UpdateExpression]

                                                                                                                                                                                                                                                                                                                                                                          [AST_NODE_TYPES.UpdateExpression]:
                                                                                                                                                                                                                                                                                                                                                                          | ts.PostfixUnaryExpression
                                                                                                                                                                                                                                                                                                                                                                          | ts.PrefixUnaryExpression;

                                                                                                                                                                                                                                                                                                                                                                            property [AST_NODE_TYPES.VariableDeclaration]

                                                                                                                                                                                                                                                                                                                                                                            [AST_NODE_TYPES.VariableDeclaration]:
                                                                                                                                                                                                                                                                                                                                                                            | ts.VariableDeclarationList
                                                                                                                                                                                                                                                                                                                                                                            | ts.VariableStatement;

                                                                                                                                                                                                                                                                                                                                                                              property [AST_NODE_TYPES.VariableDeclarator]

                                                                                                                                                                                                                                                                                                                                                                              [AST_NODE_TYPES.VariableDeclarator]: ts.VariableDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                property [AST_NODE_TYPES.WhileStatement]

                                                                                                                                                                                                                                                                                                                                                                                [AST_NODE_TYPES.WhileStatement]: ts.WhileStatement;

                                                                                                                                                                                                                                                                                                                                                                                  property [AST_NODE_TYPES.WithStatement]

                                                                                                                                                                                                                                                                                                                                                                                  [AST_NODE_TYPES.WithStatement]: ts.WithStatement;

                                                                                                                                                                                                                                                                                                                                                                                    property [AST_NODE_TYPES.YieldExpression]

                                                                                                                                                                                                                                                                                                                                                                                    [AST_NODE_TYPES.YieldExpression]: ts.YieldExpression;

                                                                                                                                                                                                                                                                                                                                                                                      interface ParseAndGenerateServicesResult

                                                                                                                                                                                                                                                                                                                                                                                      interface ParseAndGenerateServicesResult<T extends TSESTreeOptions> {}

                                                                                                                                                                                                                                                                                                                                                                                        property ast

                                                                                                                                                                                                                                                                                                                                                                                        ast: AST<T>;

                                                                                                                                                                                                                                                                                                                                                                                          property services

                                                                                                                                                                                                                                                                                                                                                                                          services: ParserServices;

                                                                                                                                                                                                                                                                                                                                                                                            interface ParserServicesWithoutTypeInformation

                                                                                                                                                                                                                                                                                                                                                                                            interface ParserServicesWithoutTypeInformation extends ParserServicesNodeMaps {}

                                                                                                                                                                                                                                                                                                                                                                                              property program

                                                                                                                                                                                                                                                                                                                                                                                              program: null;

                                                                                                                                                                                                                                                                                                                                                                                                interface ParserServicesWithTypeInformation

                                                                                                                                                                                                                                                                                                                                                                                                interface ParserServicesWithTypeInformation extends ParserServicesNodeMaps {}

                                                                                                                                                                                                                                                                                                                                                                                                  property getSymbolAtLocation

                                                                                                                                                                                                                                                                                                                                                                                                  getSymbolAtLocation: (node: TSESTree.Node) => ts.Symbol | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                    property getTypeAtLocation

                                                                                                                                                                                                                                                                                                                                                                                                    getTypeAtLocation: (node: TSESTree.Node) => ts.Type;

                                                                                                                                                                                                                                                                                                                                                                                                      property program

                                                                                                                                                                                                                                                                                                                                                                                                      program: ts.Program;

                                                                                                                                                                                                                                                                                                                                                                                                        Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                        type AST

                                                                                                                                                                                                                                                                                                                                                                                                        type AST<T extends TSESTreeOptions> = TSESTree.Program &
                                                                                                                                                                                                                                                                                                                                                                                                        (T['comment'] extends true
                                                                                                                                                                                                                                                                                                                                                                                                        ? {
                                                                                                                                                                                                                                                                                                                                                                                                        comments: TSESTree.Comment[];
                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                        : EmptyObject) &
                                                                                                                                                                                                                                                                                                                                                                                                        (T['tokens'] extends true
                                                                                                                                                                                                                                                                                                                                                                                                        ? {
                                                                                                                                                                                                                                                                                                                                                                                                        tokens: TSESTree.Token[];
                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                        : EmptyObject);

                                                                                                                                                                                                                                                                                                                                                                                                          type ParserServices

                                                                                                                                                                                                                                                                                                                                                                                                          type ParserServices =
                                                                                                                                                                                                                                                                                                                                                                                                          | ParserServicesWithoutTypeInformation
                                                                                                                                                                                                                                                                                                                                                                                                          | ParserServicesWithTypeInformation;

                                                                                                                                                                                                                                                                                                                                                                                                            type TSESTreeOptions

                                                                                                                                                                                                                                                                                                                                                                                                            type TSESTreeOptions = ParseAndGenerateServicesOptions;

                                                                                                                                                                                                                                                                                                                                                                                                              type TSESTreeToTSNode

                                                                                                                                                                                                                                                                                                                                                                                                              type TSESTreeToTSNode<T extends TSESTree.Node = TSESTree.Node> = Extract<
                                                                                                                                                                                                                                                                                                                                                                                                              ts.Token<ts.SyntaxKind.ImportKeyword | ts.SyntaxKind.NewKeyword> | TSNode,
                                                                                                                                                                                                                                                                                                                                                                                                              EstreeToTsNodeTypes[T['type']]
                                                                                                                                                                                                                                                                                                                                                                                                              >;
                                                                                                                                                                                                                                                                                                                                                                                                              • Maps TSESTree AST Node type to the expected TypeScript AST Node type(s). This mapping is based on the internal logic of the parser.

                                                                                                                                                                                                                                                                                                                                                                                                              type TSNode

                                                                                                                                                                                                                                                                                                                                                                                                              type TSNode =
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.Modifier
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.Identifier
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ImportAttribute
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ImportAttributes
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.AssertClause
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.AssertEntry
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.PrivateIdentifier
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.QualifiedName
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ComputedPropertyName
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.Decorator
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TypeParameterDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.CallSignatureDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ConstructSignatureDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.VariableDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.VariableDeclarationList
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ParameterDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.BindingElement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.PropertySignature
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.PropertyDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.PropertyAssignment
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ShorthandPropertyAssignment
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.SpreadAssignment
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ObjectBindingPattern
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ArrayBindingPattern
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.FunctionDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.MethodSignature
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.MethodDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ConstructorDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.SemicolonClassElement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.GetAccessorDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.SetAccessorDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.IndexSignatureDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.KeywordTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ImportTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ThisTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ClassStaticBlockDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ConstructorTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.FunctionTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TypeReferenceNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TypePredicateNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TypeQueryNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TypeLiteralNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ArrayTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.NamedTupleMember
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TupleTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.OptionalTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.RestTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.UnionTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.IntersectionTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ConditionalTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.InferTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ParenthesizedTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TypeOperatorNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.IndexedAccessTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.MappedTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.LiteralTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.StringLiteral
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.OmittedExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.PartiallyEmittedExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.PrefixUnaryExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.PostfixUnaryExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.NullLiteral
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.BooleanLiteral
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ThisExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.SuperExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ImportExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.DeleteExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TypeOfExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.VoidExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.AwaitExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.YieldExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.SyntheticExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.BinaryExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ConditionalExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.FunctionExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ArrowFunction
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.RegularExpressionLiteral
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.NoSubstitutionTemplateLiteral
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.NumericLiteral
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.BigIntLiteral
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TemplateHead
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TemplateMiddle
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TemplateTail
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TemplateExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TemplateSpan
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ParenthesizedExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ArrayLiteralExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.SpreadElement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ObjectLiteralExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.PropertyAccessExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ElementAccessExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.CallExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ExpressionWithTypeArguments
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.NewExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TaggedTemplateExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.AsExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TypeAssertion
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.NonNullExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.MetaProperty
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JsxElement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JsxOpeningElement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JsxSelfClosingElement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JsxFragment
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JsxOpeningFragment
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JsxClosingFragment
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JsxAttribute
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JsxSpreadAttribute
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JsxClosingElement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JsxExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JsxNamespacedName
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JsxText
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.NotEmittedStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.CommaListExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.EmptyStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.DebuggerStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.MissingDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.Block
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.VariableStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ExpressionStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.IfStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.DoStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.WhileStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ForStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ForInStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ForOfStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.BreakStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ContinueStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ReturnStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.WithStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.SwitchStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.CaseBlock
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.CaseClause
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.DefaultClause
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.LabeledStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ThrowStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TryStatement
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.CatchClause
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ClassDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ClassExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.InterfaceDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.HeritageClause
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TypeAliasDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.EnumMember
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.EnumDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ModuleDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ModuleBlock
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ImportEqualsDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ExternalModuleReference
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ImportDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ImportClause
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.NamespaceImport
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.NamespaceExportDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ExportDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.NamedImports
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.NamedExports
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ImportSpecifier
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ExportSpecifier
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ExportAssignment
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.SourceFile
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.Bundle
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.InputFiles
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.UnparsedSource
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JsonMinusNumericLiteral
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TemplateLiteralTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.SatisfiesExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDoc
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocTypeExpression
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocUnknownTag
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocAugmentsTag
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocClassTag
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocEnumTag
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocThisTag
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocTemplateTag
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocReturnTag
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocTypeTag
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocTypedefTag
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocCallbackTag
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocSignature
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocPropertyTag
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocParameterTag
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocTypeLiteral
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocFunctionType
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocAllType
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocUnknownType
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocNullableType
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocNonNullableType
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocOptionalType
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocVariadicType
                                                                                                                                                                                                                                                                                                                                                                                                              | ts.JSDocAuthorTag;

                                                                                                                                                                                                                                                                                                                                                                                                                type TSToken

                                                                                                                                                                                                                                                                                                                                                                                                                type TSToken = ts.Token<ts.SyntaxKind>;

                                                                                                                                                                                                                                                                                                                                                                                                                  Package Files (13)

                                                                                                                                                                                                                                                                                                                                                                                                                  Dependencies (8)

                                                                                                                                                                                                                                                                                                                                                                                                                  Dev Dependencies (10)

                                                                                                                                                                                                                                                                                                                                                                                                                  Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                  No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                  Badge

                                                                                                                                                                                                                                                                                                                                                                                                                  To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                  You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@typescript-eslint/typescript-estree.

                                                                                                                                                                                                                                                                                                                                                                                                                  • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                    [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@typescript-eslint/typescript-estree)
                                                                                                                                                                                                                                                                                                                                                                                                                  • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                    <a href="https://www.jsdocs.io/package/@typescript-eslint/typescript-estree"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>